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