]> git.saurik.com Git - apple/security.git/blob - OSX/libsecurity_keychain/lib/Keychains.cpp
Security-57337.20.44.tar.gz
[apple/security.git] / OSX / libsecurity_keychain / lib / Keychains.cpp
1 /*
2 * Copyright (c) 2000-2004,2011-2014 Apple Inc. All Rights Reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24
25 //
26 // Keychains.cpp
27 //
28
29 #include "KCEventNotifier.h"
30 #include "Keychains.h"
31
32 #include "Item.h"
33 #include "KCCursor.h"
34 #include "Globals.h"
35 #include <security_cdsa_utilities/Schema.h>
36 #include <security_cdsa_client/keychainacl.h>
37 #include <security_cdsa_utilities/cssmacl.h>
38 #include <security_cdsa_utilities/cssmdb.h>
39 #include <security_utilities/trackingallocator.h>
40 #include <security_keychain/SecCFTypes.h>
41
42 #include "SecKeychainPriv.h"
43
44 #include <Security/SecKeychainItemPriv.h>
45 #include <CoreFoundation/CoreFoundation.h>
46 #include "DLDbListCFPref.h"
47 #include <fcntl.h>
48 #include <sys/param.h>
49 #include <syslog.h>
50 #include <sys/stat.h>
51 #include <sys/socket.h>
52 #include <sys/un.h>
53 #include <sys/types.h>
54 #include <sys/time.h>
55
56 static dispatch_once_t SecKeychainSystemKeychainChecked;
57
58 OSStatus SecKeychainSystemKeychainCheckWouldDeadlock()
59 {
60 dispatch_once(&SecKeychainSystemKeychainChecked, ^{});
61 return errSecSuccess;
62 }
63
64 using namespace KeychainCore;
65 using namespace CssmClient;
66
67
68 typedef struct EventItem
69 {
70 SecKeychainEvent kcEvent;
71 Item item;
72 } EventItem;
73
74 typedef std::list<EventItem> EventBufferSuper;
75 class EventBuffer : public EventBufferSuper
76 {
77 public:
78 EventBuffer () {}
79 virtual ~EventBuffer ();
80 };
81
82
83 EventBuffer::~EventBuffer ()
84 {
85 }
86
87
88
89 //
90 // KeychainSchemaImpl
91 //
92 KeychainSchemaImpl::KeychainSchemaImpl(const Db &db) : mMutex(Mutex::recursive)
93 {
94 DbCursor relations(db);
95 relations->recordType(CSSM_DL_DB_SCHEMA_INFO);
96 DbAttributes relationRecord(db, 1);
97 relationRecord.add(Schema::RelationID);
98 DbUniqueRecord outerUniqueId(db);
99
100 while (relations->next(&relationRecord, NULL, outerUniqueId))
101 {
102 DbUniqueRecord uniqueId(db);
103
104 uint32 relationID = relationRecord.at(0);
105 if (CSSM_DB_RECORDTYPE_SCHEMA_START <= relationID
106 && relationID < CSSM_DB_RECORDTYPE_SCHEMA_END)
107 continue;
108
109 // Create a cursor on the SCHEMA_ATTRIBUTES table for records with
110 // RelationID == relationID
111 DbCursor attributes(db);
112 attributes->recordType(CSSM_DL_DB_SCHEMA_ATTRIBUTES);
113 attributes->add(CSSM_DB_EQUAL, Schema::RelationID, relationID);
114
115 // Set up a record for retriving the SCHEMA_ATTRIBUTES
116 DbAttributes attributeRecord(db, 2);
117 attributeRecord.add(Schema::AttributeFormat);
118 attributeRecord.add(Schema::AttributeID);
119
120 RelationInfoMap &rim = mDatabaseInfoMap[relationID];
121 while (attributes->next(&attributeRecord, NULL, uniqueId))
122 rim[attributeRecord.at(1)] = attributeRecord.at(0);
123
124 // Create a cursor on the CSSM_DL_DB_SCHEMA_INDEXES table for records
125 // with RelationID == relationID
126 DbCursor indexes(db);
127 indexes->recordType(CSSM_DL_DB_SCHEMA_INDEXES);
128 indexes->conjunctive(CSSM_DB_AND);
129 indexes->add(CSSM_DB_EQUAL, Schema::RelationID, relationID);
130 indexes->add(CSSM_DB_EQUAL, Schema::IndexType,
131 uint32(CSSM_DB_INDEX_UNIQUE));
132
133 // Set up a record for retriving the SCHEMA_INDEXES
134 DbAttributes indexRecord(db, 1);
135 indexRecord.add(Schema::AttributeID);
136
137 CssmAutoDbRecordAttributeInfo &infos =
138 *new CssmAutoDbRecordAttributeInfo();
139 mPrimaryKeyInfoMap.
140 insert(PrimaryKeyInfoMap::value_type(relationID, &infos));
141 infos.DataRecordType = relationID;
142 while (indexes->next(&indexRecord, NULL, uniqueId))
143 {
144 CssmDbAttributeInfo &info = infos.add();
145 info.AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER;
146 info.Label.AttributeID = indexRecord.at(0);
147 // @@@ Might insert bogus value if DB is corrupt
148 info.AttributeFormat = rim[info.Label.AttributeID];
149 }
150 }
151 }
152
153 KeychainSchemaImpl::~KeychainSchemaImpl()
154 {
155 try
156 {
157 map<CSSM_DB_RECORDTYPE, CssmAutoDbRecordAttributeInfo *>::iterator it = mPrimaryKeyInfoMap.begin();
158 while (it != mPrimaryKeyInfoMap.end())
159 {
160 delete it->second;
161 it++;
162 }
163 // for_each_map_delete(mPrimaryKeyInfoMap.begin(), mPrimaryKeyInfoMap.end());
164 }
165 catch(...)
166 {
167 }
168 }
169
170 const KeychainSchemaImpl::RelationInfoMap &
171 KeychainSchemaImpl::relationInfoMapFor(CSSM_DB_RECORDTYPE recordType) const
172 {
173 DatabaseInfoMap::const_iterator dit = mDatabaseInfoMap.find(recordType);
174 if (dit == mDatabaseInfoMap.end())
175 MacOSError::throwMe(errSecNoSuchClass);
176 return dit->second;
177 }
178
179 bool KeychainSchemaImpl::hasRecordType (CSSM_DB_RECORDTYPE recordType) const
180 {
181 DatabaseInfoMap::const_iterator it = mDatabaseInfoMap.find(recordType);
182 return it != mDatabaseInfoMap.end();
183 }
184
185 bool
186 KeychainSchemaImpl::hasAttribute(CSSM_DB_RECORDTYPE recordType, uint32 attributeId) const
187 {
188 try
189 {
190 const RelationInfoMap &rmap = relationInfoMapFor(recordType);
191 RelationInfoMap::const_iterator rit = rmap.find(attributeId);
192 return rit != rmap.end();
193 }
194 catch (MacOSError result)
195 {
196 if (result.osStatus () == errSecNoSuchClass)
197 {
198 return false;
199 }
200 else
201 {
202 throw;
203 }
204 }
205 }
206
207 CSSM_DB_ATTRIBUTE_FORMAT
208 KeychainSchemaImpl::attributeFormatFor(CSSM_DB_RECORDTYPE recordType, uint32 attributeId) const
209 {
210 const RelationInfoMap &rmap = relationInfoMapFor(recordType);
211 RelationInfoMap::const_iterator rit = rmap.find(attributeId);
212 if (rit == rmap.end())
213 MacOSError::throwMe(errSecNoSuchAttr);
214
215 return rit->second;
216 }
217
218 CssmDbAttributeInfo
219 KeychainSchemaImpl::attributeInfoFor(CSSM_DB_RECORDTYPE recordType, uint32 attributeId) const
220 {
221 CSSM_DB_ATTRIBUTE_INFO info;
222 info.AttributeFormat = attributeFormatFor(recordType, attributeId);
223 info.AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER;
224 info.Label.AttributeID = attributeId;
225
226 return info;
227 }
228
229 void
230 KeychainSchemaImpl::getAttributeInfoForRecordType(CSSM_DB_RECORDTYPE recordType, SecKeychainAttributeInfo **Info) const
231 {
232 const RelationInfoMap &rmap = relationInfoMapFor(recordType);
233
234 SecKeychainAttributeInfo *theList=reinterpret_cast<SecKeychainAttributeInfo *>(malloc(sizeof(SecKeychainAttributeInfo)));
235
236 size_t capacity=rmap.size();
237 UInt32 *tagBuf=reinterpret_cast<UInt32 *>(malloc(capacity*sizeof(UInt32)));
238 UInt32 *formatBuf=reinterpret_cast<UInt32 *>(malloc(capacity*sizeof(UInt32)));
239 UInt32 i=0;
240
241
242 for (RelationInfoMap::const_iterator rit = rmap.begin(); rit != rmap.end(); ++rit)
243 {
244 if (i>=capacity)
245 {
246 capacity *= 2;
247 if (capacity <= i) capacity = i + 1;
248 tagBuf=reinterpret_cast<UInt32 *>(realloc(tagBuf, (capacity*sizeof(UInt32))));
249 formatBuf=reinterpret_cast<UInt32 *>(realloc(tagBuf, (capacity*sizeof(UInt32))));
250 }
251 tagBuf[i]=rit->first;
252 formatBuf[i++]=rit->second;
253 }
254
255 theList->count=i;
256 theList->tag=tagBuf;
257 theList->format=formatBuf;
258 *Info=theList;
259 }
260
261
262 const CssmAutoDbRecordAttributeInfo &
263 KeychainSchemaImpl::primaryKeyInfosFor(CSSM_DB_RECORDTYPE recordType) const
264 {
265 PrimaryKeyInfoMap::const_iterator it;
266 it = mPrimaryKeyInfoMap.find(recordType);
267
268 if (it == mPrimaryKeyInfoMap.end())
269 MacOSError::throwMe(errSecNoSuchClass); // @@@ Not really but whatever.
270
271 return *it->second;
272 }
273
274 bool
275 KeychainSchemaImpl::operator <(const KeychainSchemaImpl &other) const
276 {
277 return mDatabaseInfoMap < other.mDatabaseInfoMap;
278 }
279
280 bool
281 KeychainSchemaImpl::operator ==(const KeychainSchemaImpl &other) const
282 {
283 return mDatabaseInfoMap == other.mDatabaseInfoMap;
284 }
285
286 void
287 KeychainSchemaImpl::didCreateRelation(CSSM_DB_RECORDTYPE relationID,
288 const char *inRelationName,
289 uint32 inNumberOfAttributes,
290 const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo,
291 uint32 inNumberOfIndexes,
292 const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo)
293 {
294 StLock<Mutex>_(mMutex);
295
296 if (CSSM_DB_RECORDTYPE_SCHEMA_START <= relationID
297 && relationID < CSSM_DB_RECORDTYPE_SCHEMA_END)
298 return;
299
300 // if our schema is already in the map, return
301 if (mPrimaryKeyInfoMap.find(relationID) != mPrimaryKeyInfoMap.end())
302 {
303 return;
304 }
305
306 RelationInfoMap &rim = mDatabaseInfoMap[relationID];
307 for (uint32 ix = 0; ix < inNumberOfAttributes; ++ix)
308 rim[pAttributeInfo[ix].AttributeId] = pAttributeInfo[ix].DataType;
309
310 CssmAutoDbRecordAttributeInfo *infos = new CssmAutoDbRecordAttributeInfo();
311
312 mPrimaryKeyInfoMap.
313 insert(PrimaryKeyInfoMap::value_type(relationID, infos));
314 infos->DataRecordType = relationID;
315 for (uint32 ix = 0; ix < inNumberOfIndexes; ++ix)
316 if (pIndexInfo[ix].IndexType == CSSM_DB_INDEX_UNIQUE)
317 {
318 CssmDbAttributeInfo &info = infos->add();
319 info.AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER;
320 info.Label.AttributeID = pIndexInfo[ix].AttributeId;
321 info.AttributeFormat = rim[info.Label.AttributeID];
322 }
323 }
324
325
326
327 KeychainSchema::~KeychainSchema()
328
329 {
330 }
331
332
333
334 struct Event
335 {
336 SecKeychainEvent eventCode;
337 PrimaryKey primaryKey;
338 };
339 typedef std::list<Event> EventList;
340
341 #define SYSTEM_KEYCHAIN_CHECK_UNIX_BASE_NAME "/var/run/systemkeychaincheck"
342 #define SYSTEM_KEYCHAIN_CHECK_UNIX_DOMAIN_SOCKET_NAME (SYSTEM_KEYCHAIN_CHECK_UNIX_BASE_NAME ".socket")
343 #define SYSTEM_KEYCHAIN_CHECK_COMPLETE_FILE_NAME (SYSTEM_KEYCHAIN_CHECK_UNIX_BASE_NAME ".done")
344
345 static void check_system_keychain()
346 {
347 // sadly we can't use XPC here, XPC_DOMAIN_TYPE_SYSTEM doesn't exist yet. Also xpc-helper uses the
348 // keychain API (I assume for checking codesign things). So we use Unix Domain Sockets.
349
350 // NOTE: if we hit a system error we attempt to log it, and then just don't check the system keychain.
351 // In theory a system might be able to recover from this state if we let it try to muddle along, and
352 // past behaviour didn't even try this hard to do the keychain check. In particular we could be in a
353 // sandbox'ed process. So we just do our best and let another process try again.
354
355 struct stat keycheck_file_info;
356 if (stat(SYSTEM_KEYCHAIN_CHECK_COMPLETE_FILE_NAME, &keycheck_file_info) < 0) {
357 int server_fd = socket(PF_UNIX, SOCK_STREAM, 0);
358 if (server_fd < 0) {
359 syslog(LOG_ERR, "Can't get socket (%m) system keychain may be unchecked");
360 return;
361 }
362
363 struct sockaddr_un keychain_check_server_address;
364 keychain_check_server_address.sun_family = AF_UNIX;
365 if (strlcpy(keychain_check_server_address.sun_path, SYSTEM_KEYCHAIN_CHECK_UNIX_DOMAIN_SOCKET_NAME, sizeof(keychain_check_server_address.sun_path)) > sizeof(keychain_check_server_address.sun_path)) {
366 // It would be nice if we could compile time assert this
367 syslog(LOG_ERR, "Socket path too long, max length %lu, your length %lu", (unsigned long)sizeof(keychain_check_server_address.sun_path), (unsigned long)strlen(SYSTEM_KEYCHAIN_CHECK_UNIX_DOMAIN_SOCKET_NAME));
368 close(server_fd);
369 return;
370 }
371 keychain_check_server_address.sun_len = SUN_LEN(&keychain_check_server_address);
372
373 int rc = connect(server_fd, (struct sockaddr *)&keychain_check_server_address, keychain_check_server_address.sun_len);
374 if (rc < 0) {
375 syslog(LOG_ERR, "Can not connect to %s: %m", SYSTEM_KEYCHAIN_CHECK_UNIX_DOMAIN_SOCKET_NAME);
376 close(server_fd);
377 return;
378 }
379
380 // this read lets us block until the EOF comes, we don't ever get a byte (and if we do, we don't care about it)
381 char byte;
382 ssize_t read_size = read(server_fd, &byte, 1);
383 if (read_size < 0) {
384 syslog(LOG_ERR, "Error reading from system keychain checker: %m");
385 }
386
387 close(server_fd);
388 return;
389 }
390 }
391
392 //
393 // KeychainImpl
394 //
395 KeychainImpl::KeychainImpl(const Db &db)
396 : mInCache(false), mDb(db), mCustomUnlockCreds (this), mIsInBatchMode (false), mMutex(Mutex::recursive)
397 {
398 dispatch_once(&SecKeychainSystemKeychainChecked, ^{
399 check_system_keychain();
400 });
401 mDb->defaultCredentials(this); // install activation hook
402 mEventBuffer = new EventBuffer;
403 }
404
405 KeychainImpl::~KeychainImpl()
406 {
407 try
408 {
409 // Remove ourselves from the cache if we are in it.
410 // fprintf(stderr, "Removing %p from storage manager cache.\n", handle(false));
411 globals().storageManager.removeKeychain(dlDbIdentifier(), this);
412 delete mEventBuffer;
413 }
414 catch(...)
415 {
416 }
417 }
418
419 Mutex*
420 KeychainImpl::getMutexForObject()
421 {
422 return globals().storageManager.getStorageManagerMutex();
423 }
424
425 Mutex*
426 KeychainImpl::getKeychainMutex()
427 {
428 return &mMutex;
429 }
430
431 void KeychainImpl::aboutToDestruct()
432 {
433 // remove me from the global cache, we are done
434 // fprintf(stderr, "Destructing keychain object\n");
435 DLDbIdentifier identifier = dlDbIdentifier();
436 globals().storageManager.removeKeychain(identifier, this);
437 }
438
439 bool
440 KeychainImpl::operator ==(const KeychainImpl &keychain) const
441 {
442 return dlDbIdentifier() == keychain.dlDbIdentifier();
443 }
444
445 KCCursor
446 KeychainImpl::createCursor(SecItemClass itemClass, const SecKeychainAttributeList *attrList)
447 {
448 StLock<Mutex>_(mMutex);
449
450 StorageManager::KeychainList keychains;
451 keychains.push_back(Keychain(this));
452 return KCCursor(keychains, itemClass, attrList);
453 }
454
455 KCCursor
456 KeychainImpl::createCursor(const SecKeychainAttributeList *attrList)
457 {
458 StLock<Mutex>_(mMutex);
459
460 StorageManager::KeychainList keychains;
461 keychains.push_back(Keychain(this));
462 return KCCursor(keychains, attrList);
463 }
464
465 void
466 KeychainImpl::create(UInt32 passwordLength, const void *inPassword)
467 {
468 StLock<Mutex>_(mMutex);
469
470 if (!inPassword)
471 {
472 create();
473 return;
474 }
475
476 Allocator &alloc = Allocator::standard();
477
478 // @@@ Share this instance
479
480 const CssmData password(const_cast<void *>(inPassword), passwordLength);
481 AclFactory::PasswordChangeCredentials pCreds (password, alloc);
482 AclFactory::AnyResourceContext rcc(pCreds);
483 create(&rcc);
484 }
485
486 void KeychainImpl::create(ConstStringPtr inPassword)
487 {
488 StLock<Mutex>_(mMutex);
489
490 if ( inPassword )
491 create(static_cast<UInt32>(inPassword[0]), &inPassword[1]);
492 else
493 create();
494 }
495
496 void
497 KeychainImpl::create()
498 {
499 StLock<Mutex>_(mMutex);
500
501 AclFactory aclFactory;
502 AclFactory::AnyResourceContext rcc(aclFactory.unlockCred());
503 create(&rcc);
504 }
505
506 void KeychainImpl::createWithBlob(CssmData &blob)
507 {
508 StLock<Mutex>_(mMutex);
509
510 mDb->dbInfo(&Schema::DBInfo);
511 AclFactory aclFactory;
512 AclFactory::AnyResourceContext rcc(aclFactory.unlockCred());
513 mDb->resourceControlContext (&rcc);
514 try
515 {
516 mDb->createWithBlob(blob);
517 }
518 catch (...)
519 {
520 mDb->resourceControlContext(NULL);
521 mDb->dbInfo(NULL);
522 throw;
523 }
524 mDb->resourceControlContext(NULL);
525 mDb->dbInfo(NULL); // Clear the schema (to not break an open call later)
526 globals().storageManager.created(Keychain(this));
527
528 KCEventNotifier::PostKeychainEvent (kSecKeychainListChangedEvent, this, NULL);
529 }
530
531 void
532 KeychainImpl::create(const ResourceControlContext *rcc)
533 {
534 StLock<Mutex>_(mMutex);
535
536 mDb->dbInfo(&Schema::DBInfo); // Set the schema (to force a create)
537 mDb->resourceControlContext(rcc);
538 try
539 {
540 mDb->create();
541 }
542 catch (...)
543 {
544 mDb->resourceControlContext(NULL);
545 mDb->dbInfo(NULL); // Clear the schema (to not break an open call later)
546 throw;
547 }
548 mDb->resourceControlContext(NULL);
549 mDb->dbInfo(NULL); // Clear the schema (to not break an open call later)
550 globals().storageManager.created(Keychain(this));
551 }
552
553 void
554 KeychainImpl::open()
555 {
556 StLock<Mutex>_(mMutex);
557
558 mDb->open();
559 }
560
561 void
562 KeychainImpl::lock()
563 {
564 StLock<Mutex>_(mMutex);
565
566 mDb->lock();
567 }
568
569 void
570 KeychainImpl::unlock()
571 {
572 StLock<Mutex>_(mMutex);
573
574 mDb->unlock();
575 }
576
577 void
578 KeychainImpl::unlock(const CssmData &password)
579 {
580 StLock<Mutex>_(mMutex);
581
582 mDb->unlock(password);
583 }
584
585 void
586 KeychainImpl::unlock(ConstStringPtr password)
587 {
588 StLock<Mutex>_(mMutex);
589
590 if (password)
591 {
592 const CssmData data(const_cast<unsigned char *>(&password[1]), password[0]);
593 unlock(data);
594 }
595 else
596 unlock();
597 }
598
599 void
600 KeychainImpl::stash()
601 {
602 StLock<Mutex>_(mMutex);
603
604 mDb->stash();
605 }
606
607 void
608 KeychainImpl::stashCheck()
609 {
610 StLock<Mutex>_(mMutex);
611
612 mDb->stashCheck();
613 }
614
615 void
616 KeychainImpl::getSettings(uint32 &outIdleTimeOut, bool &outLockOnSleep)
617 {
618 StLock<Mutex>_(mMutex);
619
620 mDb->getSettings(outIdleTimeOut, outLockOnSleep);
621 }
622
623 void
624 KeychainImpl::setSettings(uint32 inIdleTimeOut, bool inLockOnSleep)
625 {
626 StLock<Mutex>_(mMutex);
627
628 // The .Mac syncing code only makes sense for the AppleFile CSP/DL,
629 // but other DLs such as the OCSP and LDAP DLs do not expose a way to
630 // change settings or the password. To make a minimal change that only affects
631 // the smartcard case, we only look for that CSP/DL
632
633 bool isSmartcard = (mDb->dl()->guid() == gGuidAppleSdCSPDL);
634
635 // get the old keychain blob so that we can tell .Mac to resync it
636 CssmAutoData oldBlob(mDb ->allocator());
637 if (!isSmartcard)
638 mDb->copyBlob(oldBlob.get());
639
640 mDb->setSettings(inIdleTimeOut, inLockOnSleep);
641 }
642
643 void
644 KeychainImpl::changePassphrase(UInt32 oldPasswordLength, const void *oldPassword,
645 UInt32 newPasswordLength, const void *newPassword)
646 {
647 StLock<Mutex>_(mMutex);
648
649 bool isSmartcard = (mDb->dl()->guid() == gGuidAppleSdCSPDL);
650
651 TrackingAllocator allocator(Allocator::standard());
652 AutoCredentials cred = AutoCredentials(allocator);
653 if (oldPassword)
654 {
655 const CssmData &oldPass = *new(allocator) CssmData(const_cast<void *>(oldPassword), oldPasswordLength);
656 TypedList &oldList = *new(allocator) TypedList(allocator, CSSM_SAMPLE_TYPE_KEYCHAIN_LOCK);
657 oldList.append(new(allocator) ListElement(CSSM_SAMPLE_TYPE_PASSWORD));
658 oldList.append(new(allocator) ListElement(oldPass));
659 cred += oldList;
660 }
661
662 if (newPassword)
663 {
664 const CssmData &newPass = *new(allocator) CssmData(const_cast<void *>(newPassword), newPasswordLength);
665 TypedList &newList = *new(allocator) TypedList(allocator, CSSM_SAMPLE_TYPE_KEYCHAIN_CHANGE_LOCK);
666 newList.append(new(allocator) ListElement(CSSM_SAMPLE_TYPE_PASSWORD));
667 newList.append(new(allocator) ListElement(newPass));
668 cred += newList;
669 }
670
671 // get the old keychain blob so that we can tell .Mac to resync it
672 CssmAutoData oldBlob(mDb->allocator());
673 if (!isSmartcard)
674 mDb->copyBlob(oldBlob.get());
675
676 mDb->changePassphrase(&cred);
677 }
678
679 void
680 KeychainImpl::changePassphrase(ConstStringPtr oldPassword, ConstStringPtr newPassword)
681 {
682 StLock<Mutex>_(mMutex);
683
684 const void *oldPtr, *newPtr;
685 UInt32 oldLen, newLen;
686 if (oldPassword)
687 {
688 oldLen = oldPassword[0];
689 oldPtr = oldPassword + 1;
690 }
691 else
692 {
693 oldLen = 0;
694 oldPtr = NULL;
695 }
696
697 if (newPassword)
698 {
699 newLen = newPassword[0];
700 newPtr = newPassword + 1;
701 }
702 else
703 {
704 newLen = 0;
705 newPtr = NULL;
706 }
707
708 changePassphrase(oldLen, oldPtr, newLen, newPtr);
709 }
710
711 void
712 KeychainImpl::authenticate(const CSSM_ACCESS_CREDENTIALS *cred)
713 {
714 StLock<Mutex>_(mMutex);
715
716 if (!exists())
717 MacOSError::throwMe(errSecNoSuchKeychain);
718
719 MacOSError::throwMe(errSecUnimplemented);
720 }
721
722 UInt32
723 KeychainImpl::status() const
724 {
725 // @@@ We should figure out the read/write status though a DL passthrough
726 // or some other way. Also should locked be unlocked read only or just
727 // read-only?
728 return (mDb->isLocked() ? 0 : kSecUnlockStateStatus | kSecWritePermStatus)
729 | kSecReadPermStatus;
730 }
731
732 bool
733 KeychainImpl::exists()
734 {
735 StLock<Mutex>_(mMutex);
736
737 bool exists = true;
738 try
739 {
740 open();
741 // Ok to leave the mDb open since it will get closed when it goes away.
742 }
743 catch (const CssmError &e)
744 {
745 if (e.osStatus() != CSSMERR_DL_DATASTORE_DOESNOT_EXIST)
746 throw;
747 exists = false;
748 }
749
750 return exists;
751 }
752
753 bool
754 KeychainImpl::isActive() const
755 {
756 return mDb->isActive();
757 }
758
759 void KeychainImpl::completeAdd(Item &inItem, PrimaryKey &primaryKey)
760 {
761
762
763 // The inItem shouldn't be in the cache yet
764 assert(!inItem->inCache());
765
766 // Insert inItem into mDbItemMap with key primaryKey. p.second will be
767 // true if it got inserted. If not p.second will be false and p.first
768 // will point to the current entry with key primaryKey.
769 pair<DbItemMap::iterator, bool> p =
770 mDbItemMap.insert(DbItemMap::value_type(primaryKey, inItem.get()));
771 if (!p.second)
772 {
773 // There was already an ItemImpl * in mDbItemMap with key
774 // primaryKey. Get a ref to the pointer to it so we can assign a
775 // new value to it below.
776 ItemImpl *oldItem = p.first->second;
777
778 // @@@ If this happens we are breaking our API contract of
779 // uniquifying items. We really need to insert the item into the
780 // map before we start the add. And have the item be in an
781 // "is being added" state.
782 assert(oldItem->inCache());
783 secdebug("keychain", "add of new item %p somehow replaced %p",
784 inItem.get(), oldItem);
785
786 // make sure that we both mark the item and remove the item from the cache
787 removeItem(oldItem->primaryKey(), oldItem);
788 oldItem = inItem.get();
789 }
790
791 inItem->inCache(true);
792 }
793
794 void
795 KeychainImpl::addCopy(Item &inItem)
796 {
797 Keychain keychain(this);
798 PrimaryKey primaryKey = inItem->addWithCopyInfo(keychain, true);
799 completeAdd(inItem, primaryKey);
800 postEvent(kSecAddEvent, inItem);
801 }
802
803 void
804 KeychainImpl::add(Item &inItem)
805 {
806 Keychain keychain(this);
807 PrimaryKey primaryKey = inItem->add(keychain);
808 completeAdd(inItem, primaryKey);
809 postEvent(kSecAddEvent, inItem);
810 }
811
812 void
813 KeychainImpl::didUpdate(const Item &inItem, PrimaryKey &oldPK,
814 PrimaryKey &newPK)
815 {
816 // If the primary key hasn't changed we don't need to update mDbItemMap.
817 if (oldPK != newPK)
818 {
819 // If inItem isn't in the cache we don't need to update mDbItemMap.
820 assert(inItem->inCache());
821 if (inItem->inCache())
822 {
823 // First remove the entry for inItem in mDbItemMap with key oldPK.
824 DbItemMap::iterator it = mDbItemMap.find(oldPK);
825 if (it != mDbItemMap.end() && (ItemImpl*) it->second == inItem.get())
826 mDbItemMap.erase(it);
827
828 // Insert inItem into mDbItemMap with key newPK. p.second will be
829 // true if it got inserted. If not p.second will be false and
830 // p.first will point to the current entry with key newPK.
831 pair<DbItemMap::iterator, bool> p =
832 mDbItemMap.insert(DbItemMap::value_type(newPK, inItem.get()));
833 if (!p.second)
834 {
835 // There was already an ItemImpl * in mDbItemMap with key
836 // primaryKey. Get a ref to the pointer to it so we can assign
837 // a new value to it below.
838 ItemImpl *oldItem = p.first->second;
839
840 // @@@ If this happens we are breaking our API contract of
841 // uniquifying items. We really need to insert the item into
842 // the map with the new primary key before we start the update.
843 // And have the item be in an "is being updated" state.
844 assert(oldItem->inCache());
845 secdebug("keychain", "update of item %p somehow replaced %p",
846 inItem.get(), oldItem);
847 oldItem->inCache(false);
848 oldItem = inItem.get();
849 }
850 }
851 }
852
853 postEvent(kSecUpdateEvent, inItem);
854 }
855
856 void
857 KeychainImpl::deleteItem(Item &inoutItem)
858 {
859 {
860 // We don't need to hold the DO mutex through event posting, and, in fact, doing so causes deadlock.
861 // Hold it only as long as needed, instead.
862
863
864 // item must be persistent
865 if (!inoutItem->isPersistent())
866 MacOSError::throwMe(errSecInvalidItemRef);
867
868 DbUniqueRecord uniqueId = inoutItem->dbUniqueRecord();
869 PrimaryKey primaryKey = inoutItem->primaryKey();
870 uniqueId->deleteRecord();
871
872 // Don't remove the item from the mDbItemMap here since this would cause
873 // us to report a new item to our caller when we receive the
874 // kSecDeleteEvent notification.
875 // It will be removed before we post the notification, because
876 // CCallbackMgr will call didDeleteItem()
877
878 // Post the notification for the item deletion with
879 // the primaryKey obtained when the item still existed
880 }
881
882 postEvent(kSecDeleteEvent, inoutItem);
883 }
884
885
886 CssmClient::CSP
887 KeychainImpl::csp()
888 {
889 StLock<Mutex>_(mMutex);
890
891 if (!mDb->dl()->subserviceMask() & CSSM_SERVICE_CSP)
892 MacOSError::throwMe(errSecInvalidKeychain);
893
894 // Try to cast first to a CSPDL to handle case where we don't have an SSDb
895 try
896 {
897 CssmClient::CSPDL cspdl(dynamic_cast<CssmClient::CSPDLImpl *>(&*mDb->dl()));
898 return CSP(cspdl);
899 }
900 catch (...)
901 {
902 SSDbImpl* impl = dynamic_cast<SSDbImpl *>(&(*mDb));
903 if (impl == NULL)
904 {
905 CssmError::throwMe(CSSMERR_CSSM_INVALID_POINTER);
906 }
907
908 SSDb ssDb(impl);
909 return ssDb->csp();
910 }
911 }
912
913 PrimaryKey
914 KeychainImpl::makePrimaryKey(CSSM_DB_RECORDTYPE recordType, DbUniqueRecord &uniqueId)
915 {
916 StLock<Mutex>_(mMutex);
917
918 DbAttributes primaryKeyAttrs(uniqueId->database());
919 primaryKeyAttrs.recordType(recordType);
920 gatherPrimaryKeyAttributes(primaryKeyAttrs);
921 uniqueId->get(&primaryKeyAttrs, NULL);
922 return PrimaryKey(primaryKeyAttrs);
923 }
924
925 const CssmAutoDbRecordAttributeInfo &
926 KeychainImpl::primaryKeyInfosFor(CSSM_DB_RECORDTYPE recordType)
927 {
928 StLock<Mutex>_(mMutex);
929
930 try
931 {
932 return keychainSchema()->primaryKeyInfosFor(recordType);
933 }
934 catch (const CommonError &error)
935 {
936 switch (error.osStatus())
937 {
938 case errSecNoSuchClass:
939 case CSSMERR_DL_INVALID_RECORDTYPE:
940 resetSchema();
941 return keychainSchema()->primaryKeyInfosFor(recordType);
942 default:
943 throw;
944 }
945 }
946 }
947
948 void KeychainImpl::gatherPrimaryKeyAttributes(DbAttributes& primaryKeyAttrs)
949 {
950 StLock<Mutex>_(mMutex);
951
952 const CssmAutoDbRecordAttributeInfo &infos =
953 primaryKeyInfosFor(primaryKeyAttrs.recordType());
954
955 // @@@ fix this to not copy info.
956 for (uint32 i = 0; i < infos.size(); i++)
957 primaryKeyAttrs.add(infos.at(i));
958 }
959
960 ItemImpl *
961 KeychainImpl::_lookupItem(const PrimaryKey &primaryKey)
962 {
963 DbItemMap::iterator it = mDbItemMap.find(primaryKey);
964 if (it != mDbItemMap.end())
965 {
966 if (it->second == NULL)
967 {
968 // we've been weak released...
969 mDbItemMap.erase(it);
970 }
971 else
972 {
973 return it->second;
974 }
975 }
976
977 return NULL;
978 }
979
980 Item
981 KeychainImpl::item(const PrimaryKey &primaryKey)
982 {
983 StLock<Mutex>_(mMutex);
984
985 // Lookup the item in the map while holding the apiLock.
986 ItemImpl *itemImpl = _lookupItem(primaryKey);
987 if (itemImpl)
988 return Item(itemImpl);
989
990 try
991 {
992 // We didn't find it so create a new item with just a keychain and
993 // a primary key. However since we aren't holding
994 // globals().apiLock anymore some other thread might have beaten
995 // us to creating this item and adding it to the cache. If that
996 // happens we retry the lookup.
997 return Item(this, primaryKey);
998 }
999 catch (const MacOSError &e)
1000 {
1001 // If the item creation failed because some other thread already
1002 // inserted this item into the cache we retry the lookup.
1003 if (e.osStatus() == errSecDuplicateItem)
1004 {
1005 // Lookup the item in the map while holding the apiLock.
1006 ItemImpl *itemImpl = _lookupItem(primaryKey);
1007 if (itemImpl)
1008 return Item(itemImpl);
1009 }
1010 throw;
1011 }
1012 }
1013
1014
1015 Item
1016 KeychainImpl::item(CSSM_DB_RECORDTYPE recordType, DbUniqueRecord &uniqueId)
1017 {
1018 StLock<Mutex>_(mMutex);
1019
1020 PrimaryKey primaryKey = makePrimaryKey(recordType, uniqueId);
1021 {
1022 // Lookup the item in the map while holding the apiLock.
1023 ItemImpl *itemImpl = _lookupItem(primaryKey);
1024
1025 if (itemImpl)
1026 {
1027 return Item(itemImpl);
1028 }
1029 }
1030
1031 try
1032 {
1033 // We didn't find it so create a new item with a keychain, a primary key
1034 // and a DbUniqueRecord. However since we aren't holding
1035 // globals().apiLock anymore some other thread might have beaten
1036 // us to creating this item and adding it to the cache. If that
1037 // happens we retry the lookup.
1038 return Item(this, primaryKey, uniqueId);
1039 }
1040 catch (const MacOSError &e)
1041 {
1042 // If the item creation failed because some other thread already
1043 // inserted this item into the cache we retry the lookup.
1044 if (e.osStatus() == errSecDuplicateItem)
1045 {
1046 // Lookup the item in the map while holding the apiLock.
1047 ItemImpl *itemImpl = _lookupItem(primaryKey);
1048 if (itemImpl)
1049 return Item(itemImpl);
1050 }
1051 throw;
1052 }
1053 }
1054
1055 KeychainSchema
1056 KeychainImpl::keychainSchema()
1057 {
1058 StLock<Mutex>_(mMutex);
1059 if (!mKeychainSchema)
1060 mKeychainSchema = KeychainSchema(mDb);
1061
1062 return mKeychainSchema;
1063 }
1064
1065 void KeychainImpl::resetSchema()
1066 {
1067 mKeychainSchema = NULL; // re-fetch it from db next time
1068 }
1069
1070
1071 // Called from DbItemImpl's constructor (so it is only partially constructed),
1072 // add it to the map.
1073 void
1074 KeychainImpl::addItem(const PrimaryKey &primaryKey, ItemImpl *dbItemImpl)
1075 {
1076 StLock<Mutex>_(mMutex);
1077
1078 // The dbItemImpl shouldn't be in the cache yet
1079 assert(!dbItemImpl->inCache());
1080
1081 // Insert dbItemImpl into mDbItemMap with key primaryKey. p.second will
1082 // be true if it got inserted. If not p.second will be false and p.first
1083 // will point to the current entry with key primaryKey.
1084 pair<DbItemMap::iterator, bool> p =
1085 mDbItemMap.insert(DbItemMap::value_type(primaryKey, dbItemImpl));
1086
1087 if (!p.second)
1088 {
1089 // There was already an ItemImpl * in mDbItemMap with key primaryKey.
1090 // There is a race condition here when being called in multiple threads
1091 // We might have added an item using add and received a notification at
1092 // the same time.
1093 MacOSError::throwMe(errSecDuplicateItem);
1094 }
1095
1096 dbItemImpl->inCache(true);
1097 }
1098
1099 void
1100 KeychainImpl::didDeleteItem(ItemImpl *inItemImpl)
1101 {
1102 StLock<Mutex>_(mMutex);
1103
1104 // Called by CCallbackMgr
1105 secdebug("kcnotify", "%p notified that item %p was deleted", this, inItemImpl);
1106 removeItem(inItemImpl->primaryKey(), inItemImpl);
1107 }
1108
1109 void
1110 KeychainImpl::removeItem(const PrimaryKey &primaryKey, ItemImpl *inItemImpl)
1111 {
1112 StLock<Mutex>_(mMutex);
1113
1114 // If inItemImpl isn't in the cache to begin with we are done.
1115 if (!inItemImpl->inCache())
1116 return;
1117
1118 DbItemMap::iterator it = mDbItemMap.find(primaryKey);
1119 if (it != mDbItemMap.end() && (ItemImpl*) it->second == inItemImpl)
1120 mDbItemMap.erase(it);
1121
1122 inItemImpl->inCache(false);
1123 }
1124
1125 void
1126 KeychainImpl::getAttributeInfoForItemID(CSSM_DB_RECORDTYPE itemID,
1127 SecKeychainAttributeInfo **Info)
1128 {
1129 StLock<Mutex>_(mMutex);
1130
1131 try
1132 {
1133 keychainSchema()->getAttributeInfoForRecordType(itemID, Info);
1134 }
1135 catch (const CommonError &error)
1136 {
1137 switch (error.osStatus())
1138 {
1139 case errSecNoSuchClass:
1140 case CSSMERR_DL_INVALID_RECORDTYPE:
1141 resetSchema();
1142 keychainSchema()->getAttributeInfoForRecordType(itemID, Info);
1143 default:
1144 throw;
1145 }
1146 }
1147 }
1148
1149 void
1150 KeychainImpl::freeAttributeInfo(SecKeychainAttributeInfo *Info)
1151 {
1152 free(Info->tag);
1153 free(Info->format);
1154 free(Info);
1155 }
1156
1157 CssmDbAttributeInfo
1158 KeychainImpl::attributeInfoFor(CSSM_DB_RECORDTYPE recordType, UInt32 tag)
1159 {
1160 StLock<Mutex>_(mMutex);
1161
1162 try
1163 {
1164 return keychainSchema()->attributeInfoFor(recordType, tag);
1165 }
1166 catch (const CommonError &error)
1167 {
1168 switch (error.osStatus())
1169 {
1170 case errSecNoSuchClass:
1171 case CSSMERR_DL_INVALID_RECORDTYPE:
1172 resetSchema();
1173 return keychainSchema()->attributeInfoFor(recordType, tag);
1174 default:
1175 throw;
1176 }
1177 }
1178 }
1179
1180 void
1181 KeychainImpl::recode(const CssmData &data, const CssmData &extraData)
1182 {
1183 StLock<Mutex>_(mMutex);
1184
1185 mDb->recode(data, extraData);
1186 }
1187
1188 void
1189 KeychainImpl::copyBlob(CssmData &data)
1190 {
1191 StLock<Mutex>_(mMutex);
1192
1193 mDb->copyBlob(data);
1194 }
1195
1196 void
1197 KeychainImpl::setBatchMode(Boolean mode, Boolean rollback)
1198 {
1199 StLock<Mutex>_(mMutex);
1200
1201 mDb->setBatchMode(mode, rollback);
1202 mIsInBatchMode = mode;
1203 if (!mode)
1204 {
1205 if (!rollback) // was batch mode being turned off without an abort?
1206 {
1207 // dump the buffer
1208 EventBuffer::iterator it = mEventBuffer->begin();
1209 while (it != mEventBuffer->end())
1210 {
1211 PrimaryKey primaryKey;
1212 if (it->item)
1213 {
1214 primaryKey = it->item->primaryKey();
1215 }
1216
1217 KCEventNotifier::PostKeychainEvent(it->kcEvent, mDb->dlDbIdentifier(), primaryKey);
1218
1219 ++it;
1220 }
1221
1222 }
1223
1224 // notify that a keychain has changed in too many ways to count
1225 KCEventNotifier::PostKeychainEvent(kSecKeychainLeftBatchModeEvent);
1226 mEventBuffer->clear();
1227 }
1228 else
1229 {
1230 KCEventNotifier::PostKeychainEvent(kSecKeychainEnteredBatchModeEvent);
1231 }
1232 }
1233
1234 void
1235 KeychainImpl::postEvent(SecKeychainEvent kcEvent, ItemImpl* item)
1236 {
1237 PrimaryKey primaryKey;
1238
1239 {
1240 StLock<Mutex>_(mMutex);
1241
1242 if (item != NULL)
1243 {
1244 primaryKey = item->primaryKey();
1245 }
1246 }
1247
1248 if (!mIsInBatchMode)
1249 {
1250 KCEventNotifier::PostKeychainEvent(kcEvent, mDb->dlDbIdentifier(), primaryKey);
1251 }
1252 else
1253 {
1254 StLock<Mutex>_(mMutex);
1255
1256 EventItem it;
1257 it.kcEvent = kcEvent;
1258 if (item != NULL)
1259 {
1260 it.item = item;
1261 }
1262
1263 mEventBuffer->push_back (it);
1264 }
1265 }
1266
1267 Keychain::Keychain()
1268 {
1269 dispatch_once(&SecKeychainSystemKeychainChecked, ^{
1270 check_system_keychain();
1271 });
1272 }
1273
1274 Keychain::~Keychain()
1275 {
1276 }
1277
1278
1279
1280 Keychain
1281 Keychain::optional(SecKeychainRef handle)
1282 {
1283 if (handle)
1284 return KeychainImpl::required(handle);
1285 else
1286 return globals().storageManager.defaultKeychain();
1287 }
1288
1289
1290 CFIndex KeychainCore::GetKeychainRetainCount(Keychain& kc)
1291 {
1292 CFTypeRef ref = kc->handle(false);
1293 return CFGetRetainCount(ref);
1294 }
1295
1296
1297 //
1298 // Create default credentials for this keychain.
1299 // This is triggered upon default open (i.e. a Db::activate() with no set credentials).
1300 //
1301 // This function embodies the "default credentials" logic for Keychain-layer databases.
1302 //
1303 const AccessCredentials *
1304 KeychainImpl::makeCredentials()
1305 {
1306 return defaultCredentials();
1307 }
1308
1309
1310 const AccessCredentials *
1311 KeychainImpl::defaultCredentials()
1312 {
1313 StLock<Mutex>_(mMutex);
1314
1315 // Use custom unlock credentials for file keychains which have a referral
1316 // record and the standard credentials for all others.
1317
1318 if (mDb->dl()->guid() == gGuidAppleCSPDL && mCustomUnlockCreds(mDb))
1319 return &mCustomUnlockCreds;
1320 else
1321 if (mDb->dl()->guid() == gGuidAppleSdCSPDL)
1322 return globals().smartcardCredentials();
1323 else
1324 return globals().keychainCredentials();
1325 }
1326
1327
1328
1329 bool KeychainImpl::mayDelete()
1330 {
1331 return true;
1332 }