OSX/sec/Security/SecRSAKey.c

   1 /*
   2  * Copyright (c) 2006-2010,2012-2015 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  * SecRSAKey.c - CoreFoundation based rsa key object
  26  */
  27
  28
  29 #include "SecRSAKey.h"
  30 #include "SecRSAKeyPriv.h"
  31 #include <Security/SecKeyInternal.h>
  32 #include <Security/SecItem.h>
  33 #include <Security/SecBasePriv.h>
  34 #include <AssertMacros.h>
  35 #include <Security/SecureTransport.h> /* For error codes. */
  36 #include <CoreFoundation/CFData.h> /* For error codes. */
  37 #include <fcntl.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <CoreFoundation/CFNumber.h>
  41 #include <Security/SecFramework.h>
  42 #include <Security/SecRandom.h>
  43 #include <utilities/debugging.h>
  44 #include <utilities/SecCFWrappers.h>
  45 #include <utilities/SecCFError.h>
  46 #include <utilities/array_size.h>
  47 #include <Security/SecItemPriv.h>
  48 #include <Security/SecInternal.h>
  49
  50 #include <corecrypto/ccn.h>
  51 #include <corecrypto/ccrsa.h>
  52 #include <corecrypto/ccsha1.h>
  53 #include <corecrypto/ccsha2.h>
  54
  55 #include <libDER/asn1Types.h>
  56 #include <libDER/DER_Keys.h>
  57 #include <libDER/DER_Encode.h>
  58
  59 #include <CommonCrypto/CommonDigest.h>
  60
  61 #include <corecrypto/ccrsa_priv.h>
  62
  63 #include <stdint.h>
  64 #include <string.h>
  65
  66 #define kMaximumRSAKeyBits (1024 * 8)
  67
  68 #define RSA_PKCS1_PAD_SIGN              0x01
  69 #define RSA_PKCS1_PAD_ENCRYPT   0x02
  70
  71 /*
  72  *
  73  * Public Key
  74  *
  75  */
  76
  77 /* Public key static functions. */
  78 static void SecRSAPublicKeyDestroy(SecKeyRef key) {
  79     /* Zero out the public key */
  80     if (key->key) {
  81         ccrsa_pub_ctx_t pubkey = key->key;
  82         cc_clear(ccrsa_pub_ctx_size(ccn_sizeof_n(ccrsa_ctx_n(pubkey))), pubkey);
  83         free(key->key);
  84         key->key = NULL;
  85     }
  86 }
  87
  88 #define cc_skip_zeros(size, ptr) { while (size > 0 && *ptr == 0) { ++ptr; --size; } }
  89
  90 //
  91 // pubkey is initilaized with an n which is the maximum it can hold
  92 // We set the n to its correct value given m.
  93 //
  94 static int ccrsa_pub_init(ccrsa_pub_ctx_t pubkey,
  95                           size_t m_size, const uint8_t* m,
  96                           size_t e_size, const uint8_t* e)
  97 {
  98     cc_skip_zeros(m_size, m);
  99
 100     cc_size nm = ccn_nof_size(m_size);
 101     if (nm > ccrsa_ctx_n(pubkey))
 102         return -1;
 103
 104     ccrsa_ctx_n(pubkey) = nm;
 105
 106     ccn_read_uint(nm, ccrsa_ctx_m(pubkey), m_size, m);
 107     cczp_init(ccrsa_ctx_zm(pubkey));
 108
 109     return ccn_read_uint(nm, ccrsa_ctx_e(pubkey), e_size, e);
 110 }
 111
 112
 113 static OSStatus ccrsa_pub_decode_apple(ccrsa_pub_ctx_t pubkey, size_t pkcs1_size, const uint8_t* pkcs1)
 114 {
 115     OSStatus result = errSecParam;
 116
 117         DERItem keyItem = {(DERByte *)pkcs1, pkcs1_size};
 118     DERRSAPubKeyApple decodedKey;
 119
 120         require_noerr_action_quiet(DERParseSequence(&keyItem,
 121                                                 DERNumRSAPubKeyAppleItemSpecs, DERRSAPubKeyAppleItemSpecs,
 122                                                 &decodedKey, sizeof(decodedKey)),
 123                                errOut, result = errSecDecode);
 124
 125     // We could honor the reciprocal, but we don't think this is used enough to care.
 126     // Don't bother exploding the below function to try to handle this case, it computes.
 127
 128     require_noerr_quiet(ccrsa_pub_init(pubkey,
 129                                        decodedKey.modulus.length, decodedKey.modulus.data,
 130                                        decodedKey.pubExponent.length, decodedKey.pubExponent.data),
 131                         errOut);
 132
 133     result = errSecSuccess;
 134
 135 errOut:
 136     return result;
 137 }
 138
 139
 140 static void ccasn_encode_int(cc_size n, const cc_unit*s, size_t s_size, uint8_t **buffer)
 141 {
 142     **buffer = ASN1_INTEGER;
 143     *buffer += 1;
 144
 145     DERSize itemLength = 4;
 146     DEREncodeLength(s_size, *buffer, &itemLength);
 147     *buffer += itemLength;
 148
 149     ccn_write_int(n, s, s_size, *buffer);
 150
 151     *buffer += s_size;
 152 }
 153
 154
 155 static OSStatus SecRSAPublicKeyInit(SecKeyRef key,
 156                                     const uint8_t *keyData, CFIndex keyDataLength, SecKeyEncoding encoding) {
 157
 158     OSStatus result = errSecParam;
 159     ccrsa_pub_ctx_t pubkey;
 160     size_t size_n = 0;
 161
 162     switch (encoding) {
 163         case kSecKeyEncodingBytes: // Octets is PKCS1
 164         case kSecKeyEncodingPkcs1: {
 165             size_n = ccrsa_import_pub_n(keyDataLength, keyData);
 166             require_quiet(size_n != 0, errOut);
 167             require_quiet(size_n <= ccn_nof(kMaximumRSAKeyBits), errOut);
 168
 169             key->key = calloc(1, ccrsa_pub_ctx_size(ccn_sizeof_n(size_n)));
 170             require_action_quiet(key->key, errOut, result = errSecAllocate);
 171
 172             pubkey = key->key;
 173             ccrsa_ctx_n(pubkey) = size_n;
 174
 175             require_noerr_quiet(ccrsa_import_pub(pubkey, keyDataLength, keyData), errOut);
 176
 177             result = errSecSuccess;
 178
 179             break;
 180         }
 181         case kSecKeyEncodingApplePkcs1:
 182             /* for the few uses (I can't find any) that uses kSecKeyEncodingApplePkcs1, force largest keys  */
 183             size_n = ccn_nof(kMaximumRSAKeyBits);
 184
 185             key->key = calloc(1, ccrsa_pub_ctx_size(ccn_sizeof_n(size_n)));
 186             require_action_quiet(key->key, errOut, result = errSecAllocate);
 187
 188             pubkey = key->key;
 189             ccrsa_ctx_n(pubkey) = size_n;
 190
 191             result = ccrsa_pub_decode_apple(pubkey, keyDataLength, keyData);
 192             break;
 193         case kSecKeyEncodingRSAPublicParams:
 194         {
 195             SecRSAPublicKeyParams *params = (SecRSAPublicKeyParams *)keyData;
 196
 197             size_n = ccn_nof_size(params->modulusLength);
 198
 199             key->key = calloc(1, ccrsa_pub_ctx_size(ccn_sizeof_n(size_n)));
 200             require_action_quiet(key->key, errOut, result = errSecAllocate);
 201
 202             pubkey = key->key;
 203             ccrsa_ctx_n(pubkey) = size_n;
 204
 205             require_noerr_quiet(ccrsa_pub_init(pubkey,
 206                                                params->modulusLength, params->modulus,
 207                                                params->exponentLength, params->exponent), errOut);
 208
 209             result = errSecSuccess;
 210             break;
 211         }
 212         case kSecExtractPublicFromPrivate:
 213         {
 214             ccrsa_full_ctx_t fullKey = (ccrsa_full_ctx_t) keyData;
 215
 216             size_n = ccrsa_ctx_n(fullKey);
 217
 218             key->key = calloc(1, ccrsa_pub_ctx_size(ccn_sizeof_n(size_n)));
 219             require_action_quiet(key->key, errOut, result = errSecAllocate);
 220
 221             pubkey = key->key;
 222             ccrsa_ctx_n(pubkey) = size_n;
 223
 224             memcpy(pubkey, ccrsa_ctx_public(fullKey), ccrsa_pub_ctx_size(ccn_sizeof_n(size_n)));
 225             result = errSecSuccess;
 226             break;
 227         }
 228         default:
 229             break;
 230     }
 231
 232 errOut:
 233     return result;
 234 }
 235
 236 static CFTypeRef SecRSAPublicKeyCopyOperationResult(SecKeyRef key, SecKeyOperationType operation, SecKeyAlgorithm algorithm,
 237                                                     CFArrayRef allAlgorithms, SecKeyOperationMode mode,
 238                                                     CFTypeRef in1, CFTypeRef in2, CFErrorRef *error) {
 239     CFTypeRef result;
 240     require_action_quiet(CFEqual(algorithm, kSecKeyAlgorithmRSAEncryptionRawCCUnit), out, result = kCFNull);
 241
 242     ccrsa_pub_ctx_t pubkey = key->key;
 243     result = kCFBooleanTrue;
 244     int ccerr = 0;
 245     switch (operation) {
 246         case kSecKeyOperationTypeEncrypt:
 247             if (mode == kSecKeyOperationModePerform) {
 248                 // Input buffer length must be cc_unit aligned, otherwise it is not a valid cc_unit buffer.
 249                 CFIndex bufferSize = CFDataGetLength(in1);
 250                 require_action_quiet(bufferSize == ccn_sizeof_size(ccrsa_block_size(pubkey)), out,
 251                                      (result = NULL,
 252                                       SecError(errSecParam, error, CFSTR("%@: sign - input buffer bad size (%d bytes)"), key,
 253                                                (int)bufferSize)));
 254
 255                 // Verify that plaintext is smaller than modulus.  Note that since we already verified that input algorithm
 256                 // is kSecKeyAlgorithmRSAEncryptionRawCCUnit, we can safely access in1 CFDataRef contents as cc_unit *.
 257                 require_action_quiet(ccn_cmpn(ccn_nof_size(CFDataGetLength(in1)), (const cc_unit *)CFDataGetBytePtr(in1),
 258                                               ccrsa_ctx_n(pubkey), ccrsa_ctx_m(pubkey)) < 0, out,
 259                                      (result = NULL,
 260                                       SecError(errSecParam, error, CFSTR("RSApubkey wrong size of buffer to encrypt"))));
 261
 262                 // Encrypt into output buffer.
 263                 result = CFDataCreateMutableWithScratch(NULL, bufferSize);
 264                 ccerr = ccrsa_pub_crypt(pubkey, (cc_unit *)CFDataGetMutableBytePtr((CFMutableDataRef)result),
 265                                         (const cc_unit *)CFDataGetBytePtr(in1));
 266             }
 267             break;
 268         case kSecKeyOperationTypeDecrypt:
 269             if (mode == kSecKeyOperationModePerform) {
 270                 // Input buffer length must be cc_unit aligned, otherwise it is not a valid cc_unit buffer.
 271                 CFIndex bufferSize = CFDataGetLength(in1);
 272                 require_action_quiet(bufferSize == ccn_sizeof_size(ccrsa_block_size(pubkey)), out,
 273                                      (result = NULL,
 274                                       SecError(errSecParam, error, CFSTR("%@: sign - input buffer bad size (%d bytes)"), key,
 275                                                (int)bufferSize)));
 276
 277                 // Decrypt into output buffer.
 278                 result = CFDataCreateMutableWithScratch(NULL, bufferSize);
 279                 ccerr = ccrsa_pub_crypt(pubkey, (cc_unit *)CFDataGetMutableBytePtr((CFMutableDataRef)result),
 280                                         (const cc_unit *)CFDataGetBytePtr(in1));
 281             }
 282             break;
 283         default:
 284             result = kCFNull;
 285             break;
 286     }
 287
 288     require_noerr_action_quiet(ccerr, out, (CFReleaseNull(result),
 289                                             SecError(errSecParam, error, CFSTR("rsa_pub_crypt failed, ccerr=%d"), ccerr)));
 290 out:
 291     return result;
 292 }
 293
 294 static size_t SecRSAPublicKeyBlockSize(SecKeyRef key) {
 295     ccrsa_pub_ctx_t pubkey = key->key;
 296     return ccrsa_block_size(pubkey);
 297 }
 298
 299
 300 static CFDataRef SecRSAPublicKeyCreatePKCS1(CFAllocatorRef allocator, ccrsa_pub_ctx_t pubkey)
 301 {
 302     size_t m_size = ccn_write_int_size(ccrsa_ctx_n(pubkey), ccrsa_ctx_m(pubkey));
 303     size_t e_size = ccn_write_int_size(ccrsa_ctx_n(pubkey), ccrsa_ctx_e(pubkey));
 304
 305     const size_t seq_size = DERLengthOfItem(ASN1_INTEGER, m_size) +
 306     DERLengthOfItem(ASN1_INTEGER, e_size);
 307
 308     const size_t result_size = DERLengthOfItem(ASN1_SEQUENCE, seq_size);
 309
 310         CFMutableDataRef pkcs1 = CFDataCreateMutableWithScratch(allocator, result_size);
 311     uint8_t *bytes = CFDataGetMutableBytePtr(pkcs1);
 312
 313     *bytes++ = ONE_BYTE_ASN1_CONSTR_SEQUENCE;
 314
 315     DERSize itemLength = 4;
 316     DEREncodeLength(seq_size, bytes, &itemLength);
 317     bytes += itemLength;
 318
 319     ccasn_encode_int(ccrsa_ctx_n(pubkey), ccrsa_ctx_m(pubkey), m_size, &bytes);
 320     ccasn_encode_int(ccrsa_ctx_n(pubkey), ccrsa_ctx_e(pubkey), e_size, &bytes);
 321
 322     return pkcs1;
 323 }
 324
 325 static OSStatus SecRSAPublicKeyCopyPublicSerialization(SecKeyRef key, CFDataRef* serialized)
 326 {
 327     ccrsa_pub_ctx_t pubkey = key->key;
 328
 329         CFAllocatorRef allocator = CFGetAllocator(key);
 330     *serialized = SecRSAPublicKeyCreatePKCS1(allocator, pubkey);
 331
 332     if (NULL == *serialized)
 333         return errSecDecode;
 334     else
 335         return errSecSuccess;
 336 }
 337
 338 static CFDictionaryRef SecRSAPublicKeyCopyAttributeDictionary(SecKeyRef key) {
 339     CFDictionaryRef dict = SecKeyGeneratePublicAttributeDictionary(key, kSecAttrKeyTypeRSA);
 340     CFMutableDictionaryRef mutableDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
 341     CFDictionarySetValue(mutableDict, kSecAttrCanDecrypt, kCFBooleanTrue);
 342     CFDictionarySetValue(mutableDict, kSecAttrCanDerive, kCFBooleanFalse);
 343     CFAssignRetained(dict, mutableDict);
 344     return dict;
 345 }
 346
 347 static CFDataRef SecRSAPublicKeyCopyExternalRepresentation(SecKeyRef key, CFErrorRef *error) {
 348     ccrsa_pub_ctx_t pubkey = key->key;
 349     return SecRSAPublicKeyCreatePKCS1(CFGetAllocator(key), pubkey);
 350 }
 351
 352 static CFStringRef SecRSAPublicKeyCopyDescription(SecKeyRef key) {
 353
 354     CFStringRef keyDescription = NULL;
 355     CFDataRef modRef = SecKeyCopyModulus(key);
 356
 357     ccrsa_pub_ctx_t pubkey = key->key;
 358
 359     CFStringRef modulusString = CFDataCopyHexString(modRef);
 360     require_quiet(modulusString, fail);
 361
 362     keyDescription = CFStringCreateWithFormat(kCFAllocatorDefault,NULL,CFSTR( "<SecKeyRef algorithm id: %lu, key type: %s, version: %d, block size: %zu bits, exponent: {hex: %llx, decimal: %lld}, modulus: %@, addr: %p>"), SecKeyGetAlgorithmId(key), key->key_class->name, key->key_class->version, (8*SecKeyGetBlockSize(key)), (long long)*ccrsa_ctx_e(pubkey), (long long)*ccrsa_ctx_e(pubkey), modulusString, key);
 363
 364 fail:
 365     CFReleaseSafe(modRef);
 366     CFReleaseSafe(modulusString);
 367         if(!keyDescription)
 368                 keyDescription = CFStringCreateWithFormat(kCFAllocatorDefault,NULL,CFSTR("<SecKeyRef algorithm id: %lu, key type: %s, version: %d, block size: %zu bits, addr: %p>"), (long)SecKeyGetAlgorithmId(key), key->key_class->name, key->key_class->version, (8*SecKeyGetBlockSize(key)), key);
 369
 370         return keyDescription;
 371 }
 372
 373 SecKeyDescriptor kSecRSAPublicKeyDescriptor = {
 374     .version = kSecKeyDescriptorVersion,
 375     .name = "RSAPublicKey",
 376
 377     .init = SecRSAPublicKeyInit,
 378     .destroy = SecRSAPublicKeyDestroy,
 379     .blockSize = SecRSAPublicKeyBlockSize,
 380     .copyDictionary = SecRSAPublicKeyCopyAttributeDictionary,
 381     .copyExternalRepresentation = SecRSAPublicKeyCopyExternalRepresentation,
 382     .describe = SecRSAPublicKeyCopyDescription,
 383     .copyPublic = SecRSAPublicKeyCopyPublicSerialization,
 384     .copyOperationResult = SecRSAPublicKeyCopyOperationResult,
 385 };
 386
 387 /* Public Key API functions. */
 388 SecKeyRef SecKeyCreateRSAPublicKey_ios(CFAllocatorRef allocator,
 389                                    const uint8_t *keyData, CFIndex keyDataLength,
 390                                    SecKeyEncoding encoding) {
 391     return SecKeyCreate(allocator, &kSecRSAPublicKeyDescriptor, keyData,
 392                         keyDataLength, encoding);
 393 }
 394
 395 SecKeyRef SecKeyCreateRSAPublicKey(CFAllocatorRef allocator,
 396                                    const uint8_t *keyData, CFIndex keyDataLength,
 397                                    SecKeyEncoding encoding) {
 398     return SecKeyCreateRSAPublicKey_ios(allocator, keyData,
 399                         keyDataLength, encoding);
 400 }
 401
 402 CFDataRef SecKeyCopyModulus(SecKeyRef key) {
 403     CFDataRef modulus = NULL;
 404     if (key->key_class == &kSecRSAPublicKeyDescriptor) {
 405         ccrsa_pub_ctx_t pubkey = key->key;
 406
 407         size_t m_size = ccn_write_uint_size(ccrsa_ctx_n(pubkey), ccrsa_ctx_m(pubkey));
 408
 409         CFAllocatorRef allocator = CFGetAllocator(key);
 410         CFMutableDataRef modulusData = CFDataCreateMutable(allocator, m_size);
 411
 412         if (modulusData == NULL)
 413             return NULL;
 414
 415         CFDataSetLength(modulusData, m_size);
 416
 417         ccn_write_uint(ccrsa_ctx_n(pubkey), ccrsa_ctx_m(pubkey), m_size, CFDataGetMutableBytePtr(modulusData));
 418         modulus = modulusData;
 419     } else if (key->key_class->copyDictionary != NULL) {
 420         CFDictionaryRef dict = key->key_class->copyDictionary(key);
 421         if (dict != NULL) {
 422             modulus = CFRetainSafe(CFDictionaryGetValue(dict, CFSTR("_rsam")));
 423             CFRelease(dict);
 424         }
 425     }
 426
 427     return modulus;
 428 }
 429
 430 CFDataRef SecKeyCopyExponent(SecKeyRef key) {
 431     CFDataRef exponent = NULL;
 432     if (key->key_class == &kSecRSAPublicKeyDescriptor) {
 433         ccrsa_pub_ctx_t pubkey = key->key;
 434
 435         size_t e_size = ccn_write_uint_size(ccrsa_ctx_n(pubkey), ccrsa_ctx_e(pubkey));
 436
 437         CFAllocatorRef allocator = CFGetAllocator(key);
 438         CFMutableDataRef exponentData = CFDataCreateMutable(allocator, e_size);
 439
 440         if (exponentData == NULL)
 441             return NULL;
 442
 443         CFDataSetLength(exponentData, e_size);
 444
 445         ccn_write_uint(ccrsa_ctx_n(pubkey), ccrsa_ctx_e(pubkey), e_size, CFDataGetMutableBytePtr(exponentData));
 446         exponent = exponentData;
 447     } else if (key->key_class->copyDictionary != NULL) {
 448         CFDictionaryRef dict = key->key_class->copyDictionary(key);
 449         if (dict != NULL) {
 450             exponent = CFRetainSafe(CFDictionaryGetValue(dict, CFSTR("_rsae")));
 451             CFRelease(dict);
 452         }
 453     }
 454
 455     return exponent;
 456 }
 457
 458
 459 /*
 460  *
 461  * Private Key
 462  *
 463  */
 464
 465 /* Private key static functions. */
 466 static void SecRSAPrivateKeyDestroy(SecKeyRef key) {
 467     /* Zero out the public key */
 468     if (key->key) {
 469         ccrsa_full_ctx_t fullkey = key->key;
 470         cc_clear(ccrsa_full_ctx_size(ccn_sizeof_n(ccrsa_ctx_n(fullkey))), fullkey);
 471         free(key->key);
 472         key->key = NULL;
 473     }
 474 }
 475
 476 static OSStatus SecRSAPrivateKeyInit(SecKeyRef key, const uint8_t *keyData, CFIndex keyDataLength, SecKeyEncoding encoding) {
 477     OSStatus result = errSecParam;
 478     ccrsa_full_ctx_t fullkey;
 479     cc_size size_n = 0;
 480
 481     switch (encoding) {
 482         case kSecKeyEncodingBytes: // Octets is PKCS1
 483         case kSecKeyEncodingPkcs1:
 484         {
 485             size_n = ccrsa_import_priv_n(keyDataLength,keyData);
 486             require_quiet(size_n != 0, errOut);
 487             require_quiet(size_n <= ccn_nof(kMaximumRSAKeyBits), errOut);
 488
 489             key->key = calloc(1, ccrsa_full_ctx_size(ccn_sizeof_n(size_n)));
 490             require_action_quiet(key->key, errOut, result = errSecAllocate);
 491
 492             fullkey = key->key;
 493             ccrsa_ctx_n(fullkey) = size_n;
 494
 495             require_quiet(ccrsa_import_priv(fullkey, keyDataLength, keyData)==0, errOut);
 496
 497             result = errSecSuccess;
 498             break;
 499         }
 500         case kSecGenerateKey:
 501         {
 502             CFDictionaryRef parameters = (CFDictionaryRef) keyData;
 503
 504             CFTypeRef ksize = CFDictionaryGetValue(parameters, kSecAttrKeySizeInBits);
 505             CFIndex keyLengthInBits = getIntValue(ksize);
 506
 507             if (keyLengthInBits < 512 || keyLengthInBits > kMaximumRSAKeyBits) {
 508                 secwarning("Invalid or missing key size in: %@", parameters);
 509                 result = errSecKeySizeNotAllowed;
 510                 goto errOut;
 511             }
 512
 513             size_n = ccn_nof(keyLengthInBits);
 514
 515             key->key = calloc(1, ccrsa_full_ctx_size(ccn_sizeof_n(size_n)));
 516             require_action_quiet(key->key, errOut, result = errSecAllocate);
 517
 518             fullkey = key->key;
 519             ccrsa_ctx_n(fullkey) = size_n;
 520
 521             /* TODO: Add support for kSecPublicExponent parameter. */
 522             static uint8_t e[] = { 0x01, 0x00, 0x01 }; // Default is 65537
 523             if (!ccrsa_generate_fips186_key(keyLengthInBits, fullkey, sizeof(e), e, ccrng_seckey,ccrng_seckey))
 524                 result = errSecSuccess;
 525             break;
 526         }
 527         default:
 528             break;
 529     }
 530 errOut:
 531     return result;
 532 }
 533
 534 static CFTypeRef SecRSAPrivateKeyCopyOperationResult(SecKeyRef key, SecKeyOperationType operation, SecKeyAlgorithm algorithm,
 535                                                      CFArrayRef allAlgorithms, SecKeyOperationMode mode,
 536                                                      CFTypeRef in1, CFTypeRef in2, CFErrorRef *error) {
 537     CFTypeRef result = kCFNull;
 538
 539     ccrsa_full_ctx_t fullkey = key->key;
 540     int ccerr = 0;
 541     switch (operation) {
 542         case kSecKeyOperationTypeSign:
 543             if (CFEqual(algorithm, kSecKeyAlgorithmRSASignatureRawCCUnit)) {
 544                 if (mode == kSecKeyOperationModePerform) {
 545                     // Input buffer length must be cc_unit aligned, otherwise it is not a valid cc_unit buffer.
 546                     CFIndex bufferSize = CFDataGetLength(in1);
 547                     require_action_quiet(bufferSize == ccn_sizeof_size(ccrsa_block_size(ccrsa_ctx_public(fullkey))), out,
 548                                          (result = NULL,
 549                                           SecError(errSecParam, error, CFSTR("%@: sign - input buffer bad size (%d bytes)"), key,
 550                                                    (int)bufferSize)));
 551
 552                     // Verify that data is smaller than modulus.  Note that since we already verified that input algorithm
 553                     // is kSecKeyAlgorithmRSASignatureRawCCUnit, we can safely access in1 CFDataRef contents as cc_unit *.
 554                     require_action_quiet(ccn_cmpn(ccn_nof_size(CFDataGetLength(in1)), (const cc_unit *)CFDataGetBytePtr(in1),
 555                                                   ccrsa_ctx_n(fullkey), ccrsa_ctx_m(fullkey)) < 0, out,
 556                                          (result = NULL,
 557                                           SecError(errSecParam, error, CFSTR("%@: sign - digest too big (%d bytes)"), key,
 558                                                    (int)CFDataGetLength(in1))));
 559
 560                     // Encrypt buffer and write it to output data.
 561                     result = CFDataCreateMutableWithScratch(kCFAllocatorDefault, bufferSize);
 562                     ccerr = ccrsa_priv_crypt(fullkey, (cc_unit *)CFDataGetMutableBytePtr((CFMutableDataRef)result),
 563                                              (const cc_unit *)CFDataGetBytePtr(in1));
 564                 } else {
 565                     // Operation is supported.
 566                     result = kCFBooleanTrue;
 567                 }
 568             }
 569             break;
 570         case kSecKeyOperationTypeDecrypt:
 571             if (CFEqual(algorithm, kSecKeyAlgorithmRSAEncryptionRawCCUnit)) {
 572                 if (mode == kSecKeyOperationModePerform) {
 573                     // Input buffer length must be cc_unit aligned, otherwise it is not a valid cc_unit buffer.
 574                     CFIndex bufferSize = CFDataGetLength(in1);
 575                     require_action_quiet(bufferSize == ccn_sizeof_size(ccrsa_block_size(ccrsa_ctx_public(fullkey))), out,
 576                                          (result = NULL,
 577                                           SecError(errSecParam, error, CFSTR("%@: sign - input buffer bad size (%d bytes)"), key,
 578                                                    (int)bufferSize)));
 579
 580                     // Decrypt buffer and write it to output data.
 581                     result = CFDataCreateMutableWithScratch(NULL, bufferSize);
 582                     ccerr = ccrsa_priv_crypt(fullkey, (cc_unit *)CFDataGetMutableBytePtr((CFMutableDataRef)result),
 583                                              (const cc_unit *)CFDataGetBytePtr(in1));
 584                 } else {
 585                     // Operation is supported.
 586                     result = kCFBooleanTrue;
 587                 }
 588             }
 589             break;
 590         default:
 591             break;
 592     }
 593
 594     require_noerr_action_quiet(ccerr, out, (CFReleaseNull(result),
 595                                             SecError(errSecParam, error, CFSTR("rsa_priv_crypt failed, ccerr=%d"), ccerr)));
 596 out:
 597     return result;
 598 }
 599
 600 static size_t SecRSAPrivateKeyBlockSize(SecKeyRef key) {
 601     ccrsa_full_ctx_t fullkey = key->key;
 602
 603     return ccn_write_uint_size(ccrsa_ctx_n(fullkey), ccrsa_ctx_m(fullkey));
 604 }
 605
 606 static CFDataRef SecRSAPrivateKeyCreatePKCS1(CFAllocatorRef allocator, ccrsa_full_ctx_t fullkey)
 607 {
 608     const size_t result_size = ccrsa_export_priv_size(fullkey);
 609
 610     CFMutableDataRef pkcs1 = CFDataCreateMutable(allocator, result_size);
 611
 612     if (pkcs1 == NULL) {
 613         return NULL;
 614     }
 615
 616     CFDataSetLength(pkcs1, result_size);
 617
 618     uint8_t *bytes = CFDataGetMutableBytePtr(pkcs1);
 619
 620     if (ccrsa_export_priv(fullkey,result_size,bytes)!=0) {
 621         /* Decoding failed */
 622         CFReleaseNull(pkcs1);
 623         return NULL;
 624     }
 625
 626     return pkcs1;
 627 }
 628
 629 static CFDataRef SecRSAPrivateKeyCopyPKCS1(SecKeyRef key)
 630 {
 631     ccrsa_full_ctx_t fullkey = key->key;
 632
 633         CFAllocatorRef allocator = CFGetAllocator(key);
 634     return SecRSAPrivateKeyCreatePKCS1(allocator, fullkey);
 635 }
 636
 637 static OSStatus SecRSAPrivateKeyCopyPublicSerialization(SecKeyRef key, CFDataRef* serialized)
 638 {
 639     ccrsa_full_ctx_t fullkey = key->key;
 640
 641         CFAllocatorRef allocator = CFGetAllocator(key);
 642     *serialized = SecRSAPublicKeyCreatePKCS1(allocator, ccrsa_ctx_public(fullkey));
 643
 644     if (NULL == *serialized)
 645         return errSecDecode;
 646     else
 647         return errSecSuccess;
 648 }
 649
 650
 651 static CFDictionaryRef SecRSAPrivateKeyCopyAttributeDictionary(SecKeyRef key) {
 652         CFDictionaryRef dict = NULL;
 653         CFDataRef fullKeyBlob = NULL;
 654
 655         /* PKCS1 encode the key pair. */
 656         fullKeyBlob = SecRSAPrivateKeyCopyPKCS1(key);
 657     require_quiet(fullKeyBlob, errOut);
 658
 659         dict = SecKeyGeneratePrivateAttributeDictionary(key, kSecAttrKeyTypeRSA, fullKeyBlob);
 660     CFMutableDictionaryRef mutableDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
 661     CFDictionarySetValue(mutableDict, kSecAttrCanDerive, kCFBooleanFalse);
 662     CFAssignRetained(dict, mutableDict);
 663
 664 errOut:
 665         CFReleaseSafe(fullKeyBlob);
 666
 667         return dict;
 668 }
 669
 670 static CFDataRef SecRSAPrivateKeyCopyExternalRepresentation(SecKeyRef key, CFErrorRef *error) {
 671     return SecRSAPrivateKeyCopyPKCS1(key);
 672 }
 673
 674 static CFStringRef SecRSAPrivateKeyCopyDescription(SecKeyRef key){
 675
 676         return CFStringCreateWithFormat(kCFAllocatorDefault,NULL,CFSTR( "<SecKeyRef algorithm id: %lu, key type: %s, version: %d, block size: %zu bits, addr: %p>"), SecKeyGetAlgorithmId(key), key->key_class->name, key->key_class->version, (8*SecKeyGetBlockSize(key)), key);
 677
 678 }
 679
 680 SecKeyDescriptor kSecRSAPrivateKeyDescriptor = {
 681     .version = kSecKeyDescriptorVersion,
 682     .name = "RSAPrivateKey",
 683
 684     .init = SecRSAPrivateKeyInit,
 685     .destroy = SecRSAPrivateKeyDestroy,
 686     .blockSize = SecRSAPrivateKeyBlockSize,
 687     .copyExternalRepresentation = SecRSAPrivateKeyCopyExternalRepresentation,
 688     .copyDictionary = SecRSAPrivateKeyCopyAttributeDictionary,
 689     .describe = SecRSAPrivateKeyCopyDescription,
 690     .copyPublic = SecRSAPrivateKeyCopyPublicSerialization,
 691     .copyOperationResult = SecRSAPrivateKeyCopyOperationResult,
 692 };
 693
 694 /* Private Key API functions. */
 695 SecKeyRef SecKeyCreateRSAPrivateKey(CFAllocatorRef allocator,
 696                                     const uint8_t *keyData, CFIndex keyDataLength,
 697                                     SecKeyEncoding encoding) {
 698     return SecKeyCreate(allocator, &kSecRSAPrivateKeyDescriptor, keyData,
 699                         keyDataLength, encoding);
 700 }
 701
 702
 703 OSStatus SecRSAKeyGeneratePair(CFDictionaryRef parameters,
 704                                SecKeyRef *rsaPublicKey, SecKeyRef *rsaPrivateKey) {
 705     OSStatus status = errSecParam;
 706
 707     CFAllocatorRef allocator = NULL; /* @@@ get from parameters. */
 708
 709     SecKeyRef pubKey = NULL;
 710     SecKeyRef privKey = SecKeyCreate(allocator, &kSecRSAPrivateKeyDescriptor,
 711                                      (const void*) parameters, 0, kSecGenerateKey);
 712
 713     require_quiet(privKey, errOut);
 714
 715         /* Create SecKeyRef's from the pkcs1 encoded keys. */
 716     pubKey = SecKeyCreate(allocator, &kSecRSAPublicKeyDescriptor,
 717                           privKey->key, 0, kSecExtractPublicFromPrivate);
 718
 719     require_quiet(pubKey, errOut);
 720
 721     if (rsaPublicKey) {
 722         *rsaPublicKey = pubKey;
 723         pubKey = NULL;
 724     }
 725     if (rsaPrivateKey) {
 726         *rsaPrivateKey = privKey;
 727         privKey = NULL;
 728     }
 729
 730     status = errSecSuccess;
 731
 732 errOut:
 733     CFReleaseSafe(pubKey);
 734     CFReleaseSafe(privKey);
 735
 736         return status;
 737 }