crypto/mock_keychain_mac.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/logging.h"
   6 #include "base/time.h"
   7 #include "crypto/mock_keychain_mac.h"
   8
   9 namespace crypto {
  10
  11 // static
  12 const SecKeychainSearchRef MockKeychain::kDummySearchRef =
  13     reinterpret_cast<SecKeychainSearchRef>(1000);
  14
  15 MockKeychain::MockKeychain()
  16     : next_item_key_(0),
  17       search_copy_count_(0),
  18       keychain_item_copy_count_(0),
  19       attribute_data_copy_count_(0),
  20       find_generic_result_(noErr),
  21       called_add_generic_(false),
  22       password_data_count_(0) {}
  23
  24 void MockKeychain::InitializeKeychainData(MockKeychainItemType key) const {
  25   UInt32 tags[] = { kSecAccountItemAttr,
  26                     kSecServerItemAttr,
  27                     kSecPortItemAttr,
  28                     kSecPathItemAttr,
  29                     kSecProtocolItemAttr,
  30                     kSecAuthenticationTypeItemAttr,
  31                     kSecSecurityDomainItemAttr,
  32                     kSecCreationDateItemAttr,
  33                     kSecNegativeItemAttr,
  34                     kSecCreatorItemAttr };
  35   keychain_attr_list_[key] = SecKeychainAttributeList();
  36   keychain_data_[key] = KeychainPasswordData();
  37   keychain_attr_list_[key].count = arraysize(tags);
  38   keychain_attr_list_[key].attr = static_cast<SecKeychainAttribute*>(
  39       calloc(keychain_attr_list_[key].count, sizeof(SecKeychainAttribute)));
  40   for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) {
  41     keychain_attr_list_[key].attr[i].tag = tags[i];
  42     size_t data_size = 0;
  43     switch (tags[i]) {
  44       case kSecPortItemAttr:
  45         data_size = sizeof(UInt32);
  46         break;
  47       case kSecProtocolItemAttr:
  48         data_size = sizeof(SecProtocolType);
  49         break;
  50       case kSecAuthenticationTypeItemAttr:
  51         data_size = sizeof(SecAuthenticationType);
  52         break;
  53       case kSecNegativeItemAttr:
  54         data_size = sizeof(Boolean);
  55         break;
  56       case kSecCreatorItemAttr:
  57         data_size = sizeof(OSType);
  58         break;
  59     }
  60     if (data_size > 0) {
  61       keychain_attr_list_[key].attr[i].length = data_size;
  62       keychain_attr_list_[key].attr[i].data = calloc(1, data_size);
  63     }
  64   }
  65 }
  66
  67 MockKeychain::~MockKeychain() {
  68   for (std::map<MockKeychainItemType, SecKeychainAttributeList>::iterator it =
  69        keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) {
  70     for (unsigned int i = 0; i < it->second.count; ++i) {
  71       if (it->second.attr[i].data)
  72         free(it->second.attr[i].data);
  73     }
  74     free(it->second.attr);
  75     if (keychain_data_[it->first].data)
  76       free(keychain_data_[it->first].data);
  77   }
  78   keychain_attr_list_.clear();
  79   keychain_data_.clear();
  80 }
  81
  82 SecKeychainAttribute* MockKeychain::AttributeWithTag(
  83     const SecKeychainAttributeList& attribute_list,
  84     UInt32 tag) {
  85   int attribute_index = -1;
  86   for (unsigned int i = 0; i < attribute_list.count; ++i) {
  87     if (attribute_list.attr[i].tag == tag) {
  88       attribute_index = i;
  89       break;
  90     }
  91   }
  92   if (attribute_index == -1) {
  93     NOTREACHED() << "Unsupported attribute: " << tag;
  94     return NULL;
  95   }
  96   return &(attribute_list.attr[attribute_index]);
  97 }
  98
  99 void MockKeychain::SetTestDataBytes(MockKeychainItemType item,
 100                                     UInt32 tag,
 101                                     const void* data,
 102                                     size_t length) {
 103   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
 104                                                      tag);
 105   attribute->length = length;
 106   if (length > 0) {
 107     if (attribute->data)
 108       free(attribute->data);
 109     attribute->data = malloc(length);
 110     CHECK(attribute->data);
 111     memcpy(attribute->data, data, length);
 112   } else {
 113     attribute->data = NULL;
 114   }
 115 }
 116
 117 void MockKeychain::SetTestDataString(
 118     MockKeychainItemType item,
 119     UInt32 tag,
 120     const char* value) {
 121   SetTestDataBytes(item, tag, value, value ? strlen(value) : 0);
 122 }
 123
 124 void MockKeychain::SetTestDataPort(MockKeychainItemType item, UInt32 value) {
 125   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
 126                                                      kSecPortItemAttr);
 127   UInt32* data = static_cast<UInt32*>(attribute->data);
 128   *data = value;
 129 }
 130
 131 void MockKeychain::SetTestDataProtocol(MockKeychainItemType item,
 132                                        SecProtocolType value) {
 133   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
 134                                                      kSecProtocolItemAttr);
 135   SecProtocolType* data = static_cast<SecProtocolType*>(attribute->data);
 136   *data = value;
 137 }
 138
 139 void MockKeychain::SetTestDataAuthType(
 140     MockKeychainItemType item,
 141     SecAuthenticationType value) {
 142   SecKeychainAttribute* attribute = AttributeWithTag(
 143       keychain_attr_list_[item], kSecAuthenticationTypeItemAttr);
 144   SecAuthenticationType* data = static_cast<SecAuthenticationType*>(
 145       attribute->data);
 146   *data = value;
 147 }
 148
 149 void MockKeychain::SetTestDataNegativeItem(MockKeychainItemType item,
 150                                            Boolean value) {
 151   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
 152                                                      kSecNegativeItemAttr);
 153   Boolean* data = static_cast<Boolean*>(attribute->data);
 154   *data = value;
 155 }
 156
 157 void MockKeychain::SetTestDataCreator(MockKeychainItemType item, OSType value) {
 158   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
 159                                                      kSecCreatorItemAttr);
 160   OSType* data = static_cast<OSType*>(attribute->data);
 161   *data = value;
 162 }
 163
 164 void MockKeychain::SetTestDataPasswordBytes(MockKeychainItemType item,
 165                                             const void* data,
 166                                             size_t length) {
 167   keychain_data_[item].length = length;
 168   if (length > 0) {
 169     if (keychain_data_[item].data)
 170       free(keychain_data_[item].data);
 171     keychain_data_[item].data = malloc(length);
 172     memcpy(keychain_data_[item].data, data, length);
 173   } else {
 174     keychain_data_[item].data = NULL;
 175   }
 176 }
 177
 178 void MockKeychain::SetTestDataPasswordString(
 179     MockKeychainItemType item,
 180     const char* value) {
 181   SetTestDataPasswordBytes(item, value, value ? strlen(value) : 0);
 182 }
 183
 184 OSStatus MockKeychain::ItemCopyAttributesAndData(
 185     SecKeychainItemRef itemRef,
 186     SecKeychainAttributeInfo* info,
 187     SecItemClass* itemClass,
 188     SecKeychainAttributeList** attrList,
 189     UInt32* length,
 190     void** outData) const {
 191   DCHECK(itemRef);
 192   MockKeychainItemType key =
 193       reinterpret_cast<MockKeychainItemType>(itemRef) - 1;
 194   if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
 195     return errSecInvalidItemRef;
 196
 197   DCHECK(!itemClass);  // itemClass not implemented in the Mock.
 198   if (attrList)
 199     *attrList  = &(keychain_attr_list_[key]);
 200   if (outData) {
 201     *outData = keychain_data_[key].data;
 202     DCHECK(length);
 203     *length = keychain_data_[key].length;
 204   }
 205
 206   ++attribute_data_copy_count_;
 207   return noErr;
 208 }
 209
 210 OSStatus MockKeychain::ItemModifyAttributesAndData(
 211     SecKeychainItemRef itemRef,
 212     const SecKeychainAttributeList* attrList,
 213     UInt32 length,
 214     const void* data) const {
 215   DCHECK(itemRef);
 216   const char* fail_trigger = "fail_me";
 217   if (length == strlen(fail_trigger) &&
 218       memcmp(data, fail_trigger, length) == 0) {
 219     return errSecAuthFailed;
 220   }
 221
 222   MockKeychainItemType key =
 223       reinterpret_cast<MockKeychainItemType>(itemRef) - 1;
 224   if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
 225     return errSecInvalidItemRef;
 226
 227   MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
 228   if (attrList) {
 229     for (UInt32 change_attr = 0; change_attr < attrList->count; ++change_attr) {
 230       if (attrList->attr[change_attr].tag == kSecCreatorItemAttr) {
 231         void* data = attrList->attr[change_attr].data;
 232         mutable_this->SetTestDataCreator(key, *(static_cast<OSType*>(data)));
 233       } else {
 234         NOTIMPLEMENTED();
 235       }
 236     }
 237   }
 238   if (data)
 239     mutable_this->SetTestDataPasswordBytes(key, data, length);
 240   return noErr;
 241 }
 242
 243 OSStatus MockKeychain::ItemFreeAttributesAndData(
 244     SecKeychainAttributeList* attrList,
 245     void* data) const {
 246   --attribute_data_copy_count_;
 247   return noErr;
 248 }
 249
 250 OSStatus MockKeychain::ItemDelete(SecKeychainItemRef itemRef) const {
 251   MockKeychainItemType key =
 252       reinterpret_cast<MockKeychainItemType>(itemRef) - 1;
 253
 254   for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) {
 255     if (keychain_attr_list_[key].attr[i].data)
 256       free(keychain_attr_list_[key].attr[i].data);
 257   }
 258   free(keychain_attr_list_[key].attr);
 259   if (keychain_data_[key].data)
 260     free(keychain_data_[key].data);
 261
 262   keychain_attr_list_.erase(key);
 263   keychain_data_.erase(key);
 264   added_via_api_.erase(key);
 265   return noErr;
 266 }
 267
 268 OSStatus MockKeychain::SearchCreateFromAttributes(
 269     CFTypeRef keychainOrArray,
 270     SecItemClass itemClass,
 271     const SecKeychainAttributeList* attrList,
 272     SecKeychainSearchRef* searchRef) const {
 273   // Figure out which of our mock items matches, and set up the array we'll use
 274   // to generate results out of SearchCopyNext.
 275   remaining_search_results_.clear();
 276   for (std::map<MockKeychainItemType, SecKeychainAttributeList>::const_iterator
 277            it = keychain_attr_list_.begin();
 278        it != keychain_attr_list_.end();
 279        ++it) {
 280     bool mock_item_matches = true;
 281     for (UInt32 search_attr = 0; search_attr < attrList->count; ++search_attr) {
 282       SecKeychainAttribute* mock_attribute =
 283           AttributeWithTag(it->second, attrList->attr[search_attr].tag);
 284       if (mock_attribute->length != attrList->attr[search_attr].length ||
 285           memcmp(mock_attribute->data, attrList->attr[search_attr].data,
 286                  attrList->attr[search_attr].length) != 0) {
 287         mock_item_matches = false;
 288         break;
 289       }
 290     }
 291     if (mock_item_matches)
 292       remaining_search_results_.push_back(it->first);
 293   }
 294
 295   DCHECK(searchRef);
 296   *searchRef = kDummySearchRef;
 297   ++search_copy_count_;
 298   return noErr;
 299 }
 300
 301 bool MockKeychain::AlreadyContainsInternetPassword(
 302     UInt32 serverNameLength,
 303     const char* serverName,
 304     UInt32 securityDomainLength,
 305     const char* securityDomain,
 306     UInt32 accountNameLength,
 307     const char* accountName,
 308     UInt32 pathLength,
 309     const char* path,
 310     UInt16 port,
 311     SecProtocolType protocol,
 312     SecAuthenticationType authenticationType) const {
 313   for (std::map<MockKeychainItemType, SecKeychainAttributeList>::const_iterator
 314            it = keychain_attr_list_.begin();
 315        it != keychain_attr_list_.end();
 316        ++it) {
 317     SecKeychainAttribute* attribute;
 318     attribute = AttributeWithTag(it->second, kSecServerItemAttr);
 319     if ((attribute->length != serverNameLength) ||
 320         (attribute->data == NULL && *serverName != '\0') ||
 321         (attribute->data != NULL && *serverName == '\0') ||
 322         strncmp(serverName,
 323                 (const char*) attribute->data,
 324                 serverNameLength) != 0) {
 325       continue;
 326     }
 327     attribute = AttributeWithTag(it->second, kSecSecurityDomainItemAttr);
 328     if ((attribute->length != securityDomainLength) ||
 329         (attribute->data == NULL && *securityDomain != '\0') ||
 330         (attribute->data != NULL && *securityDomain == '\0') ||
 331         strncmp(securityDomain,
 332                 (const char*) attribute->data,
 333                 securityDomainLength) != 0) {
 334       continue;
 335     }
 336     attribute = AttributeWithTag(it->second, kSecAccountItemAttr);
 337     if ((attribute->length != accountNameLength) ||
 338         (attribute->data == NULL && *accountName != '\0') ||
 339         (attribute->data != NULL && *accountName == '\0') ||
 340         strncmp(accountName,
 341                 (const char*) attribute->data,
 342                 accountNameLength) != 0) {
 343       continue;
 344     }
 345     attribute = AttributeWithTag(it->second, kSecPathItemAttr);
 346     if ((attribute->length != pathLength) ||
 347         (attribute->data == NULL && *path != '\0') ||
 348         (attribute->data != NULL && *path == '\0') ||
 349         strncmp(path,
 350                 (const char*) attribute->data,
 351                 pathLength) != 0) {
 352       continue;
 353     }
 354     attribute = AttributeWithTag(it->second, kSecPortItemAttr);
 355     if ((attribute->data == NULL) ||
 356         (port != *(static_cast<UInt32*>(attribute->data)))) {
 357       continue;
 358     }
 359     attribute = AttributeWithTag(it->second, kSecProtocolItemAttr);
 360     if ((attribute->data == NULL) ||
 361         (protocol != *(static_cast<SecProtocolType*>(attribute->data)))) {
 362       continue;
 363     }
 364     attribute = AttributeWithTag(it->second, kSecAuthenticationTypeItemAttr);
 365     if ((attribute->data == NULL) ||
 366         (authenticationType !=
 367             *(static_cast<SecAuthenticationType*>(attribute->data)))) {
 368       continue;
 369     }
 370     // The keychain already has this item, since all fields other than the
 371     // password match.
 372     return true;
 373   }
 374   return false;
 375 }
 376
 377 OSStatus MockKeychain::AddInternetPassword(
 378     SecKeychainRef keychain,
 379     UInt32 serverNameLength,
 380     const char* serverName,
 381     UInt32 securityDomainLength,
 382     const char* securityDomain,
 383     UInt32 accountNameLength,
 384     const char* accountName,
 385     UInt32 pathLength,
 386     const char* path,
 387     UInt16 port,
 388     SecProtocolType protocol,
 389     SecAuthenticationType authenticationType,
 390     UInt32 passwordLength,
 391     const void* passwordData,
 392     SecKeychainItemRef* itemRef) const {
 393
 394   // Check for the magic duplicate item trigger.
 395   if (strcmp(serverName, "some.domain.com") == 0)
 396     return errSecDuplicateItem;
 397
 398   // If the account already exists in the keychain, we don't add it.
 399   if (AlreadyContainsInternetPassword(serverNameLength, serverName,
 400                                       securityDomainLength, securityDomain,
 401                                       accountNameLength, accountName,
 402                                       pathLength, path,
 403                                       port, protocol,
 404                                       authenticationType)) {
 405     return errSecDuplicateItem;
 406   }
 407
 408   // Pick the next unused slot.
 409   MockKeychainItemType key = next_item_key_++;
 410
 411   // Initialize keychain data storage at the target location.
 412   InitializeKeychainData(key);
 413
 414   MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
 415   mutable_this->SetTestDataBytes(key, kSecServerItemAttr, serverName,
 416                                  serverNameLength);
 417   mutable_this->SetTestDataBytes(key, kSecSecurityDomainItemAttr,
 418                                  securityDomain, securityDomainLength);
 419   mutable_this->SetTestDataBytes(key, kSecAccountItemAttr, accountName,
 420                                  accountNameLength);
 421   mutable_this->SetTestDataBytes(key, kSecPathItemAttr, path, pathLength);
 422   mutable_this->SetTestDataPort(key, port);
 423   mutable_this->SetTestDataProtocol(key, protocol);
 424   mutable_this->SetTestDataAuthType(key, authenticationType);
 425   mutable_this->SetTestDataPasswordBytes(key, passwordData,
 426                                          passwordLength);
 427   base::Time::Exploded exploded_time;
 428   base::Time::Now().UTCExplode(&exploded_time);
 429   char time_string[128];
 430   snprintf(time_string, sizeof(time_string), "%04d%02d%02d%02d%02d%02dZ",
 431            exploded_time.year, exploded_time.month, exploded_time.day_of_month,
 432            exploded_time.hour, exploded_time.minute, exploded_time.second);
 433   mutable_this->SetTestDataString(key, kSecCreationDateItemAttr, time_string);
 434
 435   added_via_api_.insert(key);
 436
 437   if (itemRef) {
 438     *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
 439     ++keychain_item_copy_count_;
 440   }
 441   return noErr;
 442 }
 443
 444 OSStatus MockKeychain::SearchCopyNext(SecKeychainSearchRef searchRef,
 445                                       SecKeychainItemRef* itemRef) const {
 446   if (remaining_search_results_.empty())
 447     return errSecItemNotFound;
 448   MockKeychainItemType key = remaining_search_results_.front();
 449   remaining_search_results_.erase(remaining_search_results_.begin());
 450   *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
 451   ++keychain_item_copy_count_;
 452   return noErr;
 453 }
 454
 455 OSStatus MockKeychain::FindGenericPassword(CFTypeRef keychainOrArray,
 456                                            UInt32 serviceNameLength,
 457                                            const char* serviceName,
 458                                            UInt32 accountNameLength,
 459                                            const char* accountName,
 460                                            UInt32* passwordLength,
 461                                            void** passwordData,
 462                                            SecKeychainItemRef* itemRef) const {
 463   // When simulating |noErr| we return canned |passwordData| and
 464   // |passwordLenght|.  Otherwise, just return given code.
 465   if (find_generic_result_ == noErr) {
 466     static char password[] = "my_password";
 467
 468     DCHECK(passwordData);
 469     *passwordData = static_cast<void*>(password);
 470     DCHECK(passwordLength);
 471     *passwordLength = strlen(password);
 472     password_data_count_++;
 473   }
 474
 475   return find_generic_result_;
 476 }
 477
 478 OSStatus MockKeychain::ItemFreeContent(SecKeychainAttributeList* attrList,
 479                                        void* data) const {
 480   // No-op.
 481   password_data_count_--;
 482   return noErr;
 483 }
 484
 485 OSStatus MockKeychain::AddGenericPassword(SecKeychainRef keychain,
 486                                           UInt32 serviceNameLength,
 487                                           const char* serviceName,
 488                                           UInt32 accountNameLength,
 489                                           const char* accountName,
 490                                           UInt32 passwordLength,
 491                                           const void* passwordData,
 492                                           SecKeychainItemRef* itemRef) const {
 493   called_add_generic_ = true;
 494
 495   DCHECK(passwordLength > 0);
 496   DCHECK(passwordData);
 497   add_generic_password_ =
 498       std::string(const_cast<char*>(static_cast<const char*>(passwordData)),
 499                   passwordLength);
 500   return noErr;
 501 }
 502
 503 void MockKeychain::Free(CFTypeRef ref) const {
 504   if (!ref)
 505     return;
 506
 507   if (ref == kDummySearchRef) {
 508     --search_copy_count_;
 509   } else {
 510     --keychain_item_copy_count_;
 511   }
 512 }
 513
 514 int MockKeychain::UnfreedSearchCount() const {
 515   return search_copy_count_;
 516 }
 517
 518 int MockKeychain::UnfreedKeychainItemCount() const {
 519   return keychain_item_copy_count_;
 520 }
 521
 522 int MockKeychain::UnfreedAttributeDataCount() const {
 523   return attribute_data_copy_count_;
 524 }
 525
 526 bool MockKeychain::CreatorCodesSetForAddedItems() const {
 527   for (std::set<MockKeychainItemType>::const_iterator
 528            i = added_via_api_.begin();
 529        i != added_via_api_.end();
 530        ++i) {
 531     SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[*i],
 532                                                        kSecCreatorItemAttr);
 533     OSType* data = static_cast<OSType*>(attribute->data);
 534     if (*data == 0)
 535       return false;
 536   }
 537   return true;
 538 }
 539
 540 void MockKeychain::AddTestItem(const KeychainTestData& item_data) {
 541   MockKeychainItemType key = next_item_key_++;
 542
 543   InitializeKeychainData(key);
 544   SetTestDataAuthType(key, item_data.auth_type);
 545   SetTestDataString(key, kSecServerItemAttr, item_data.server);
 546   SetTestDataProtocol(key, item_data.protocol);
 547   SetTestDataString(key, kSecPathItemAttr, item_data.path);
 548   SetTestDataPort(key, item_data.port);
 549   SetTestDataString(key, kSecSecurityDomainItemAttr,
 550                     item_data.security_domain);
 551   SetTestDataString(key, kSecCreationDateItemAttr, item_data.creation_date);
 552   SetTestDataString(key, kSecAccountItemAttr, item_data.username);
 553   SetTestDataPasswordString(key, item_data.password);
 554   SetTestDataNegativeItem(key, item_data.negative_item);
 555 }
 556
 557 }  // namespace crypto