OSX/sec/Security/SecEMCS.m

   1 /*
   2  * Copyright (c) 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 #define __KEYCHAINCORE__ 1
  25
  26 #include <Foundation/Foundation.h>
  27 #include <Security/SecBase.h>
  28 #include <Security/SecBasePriv.h>
  29 #include <Security/SecCFAllocator.h>
  30 #include <corecrypto/ccpbkdf2.h>
  31 #include <corecrypto/ccsha2.h>
  32 #include <corecrypto/ccaes.h>
  33 #include <corecrypto/ccmode.h>
  34 #include <corecrypto/ccwrap.h>
  35
  36 #include <utilities/SecCFWrappers.h>
  37 #include <AssertMacros.h>
  38
  39 #include "SecEMCSPriv.h"
  40
  41 static CFStringRef kiDMSSalt = CFSTR("salt");
  42 static CFStringRef kiDMSIterrations = CFSTR("iter");
  43 static CFStringRef kiDMSWrapEMCSKey = CFSTR("wkey");
  44
  45 #define MIN_ITERATIONS  1000
  46 #define MIN_SALTLEN 16
  47 #define KEY_LENGTH 16
  48
  49 /*
  50  *
  51  */
  52
  53 static CFDataRef
  54 CopyWrappedKey(CFDataRef wrappingKey, CFDataRef unwrappedKey)
  55 {
  56     const struct ccmode_ecb *ecb_mode = ccaes_ecb_encrypt_mode();
  57     ccecb_ctx_decl(ccecb_context_size(ecb_mode), key);
  58     CFMutableDataRef wrappedKey = NULL;
  59
  60     require(CFDataGetLength(wrappingKey) == KEY_LENGTH, out);
  61
  62     ccecb_init(ecb_mode, key, CFDataGetLength(wrappingKey), CFDataGetBytePtr(wrappingKey));
  63
  64     wrappedKey = CFDataCreateMutableWithScratch(NULL, ccwrap_wrapped_size(CFDataGetLength(unwrappedKey)));
  65     require(wrappingKey, out);
  66
  67     size_t obytes = 0;
  68     int wrap_status = ccwrap_auth_encrypt(ecb_mode, key, CFDataGetLength(unwrappedKey), CFDataGetBytePtr(unwrappedKey),
  69                                           &obytes, CFDataGetMutableBytePtr(wrappedKey));
  70     if (wrap_status == 0) {
  71         assert(obytes == (size_t)CFDataGetLength(wrappedKey));
  72     } else {
  73         CFReleaseNull(wrappedKey);
  74         goto out;
  75     }
  76
  77  out:
  78     ccecb_ctx_clear(ccecb_context_size(ecb_mode), key);
  79     return wrappedKey;
  80 }
  81
  82 static NSData *
  83 CopyUnwrappedKey(CFDataRef wrappingKey, CFDataRef wrappedKey)
  84 {
  85     const struct ccmode_ecb *ecb_mode = ccaes_ecb_decrypt_mode();
  86     ccecb_ctx_decl(ccecb_context_size(ecb_mode), key);
  87     NSMutableData *unwrappedKey = NULL;
  88
  89     require(CFDataGetLength(wrappedKey) >= CCWRAP_SEMIBLOCK, out);
  90     require(CFDataGetLength(wrappingKey) == KEY_LENGTH, out);
  91
  92     ccecb_init(ecb_mode, key, CFDataGetLength(wrappingKey), CFDataGetBytePtr(wrappingKey));
  93
  94     unwrappedKey = CFBridgingRelease(CFDataCreateMutableWithScratch(SecCFAllocatorZeroize(), ccwrap_unwrapped_size(CFDataGetLength(wrappedKey))));
  95     require(unwrappedKey, out);
  96
  97     size_t obytes = 0;
  98     int unwrap_status = ccwrap_auth_decrypt(ecb_mode, key, CFDataGetLength(wrappedKey), CFDataGetBytePtr(wrappedKey),
  99                                             &obytes, [unwrappedKey mutableBytes]);
 100     if (unwrap_status == 0) {
 101         assert(obytes == (size_t)[unwrappedKey length]);
 102     } else {
 103         unwrappedKey = NULL;
 104         goto out;
 105     }
 106
 107  out:
 108     ccecb_ctx_clear(ccecb_context_size(ecb_mode), key);
 109     return unwrappedKey;
 110 }
 111
 112 /*
 113  *
 114  */
 115
 116 static CFDataRef
 117 CreateDerivedKey(CFDataRef salt, long iterations, NSString *managedCredential)
 118 {
 119     if (iterations < MIN_ITERATIONS || CFDataGetLength(salt) < MIN_SALTLEN)
 120         return NULL;
 121
 122     /*
 123      * Assume users use the same normalization rules always
 124      */
 125
 126     CFMutableDataRef key = CFDataCreateMutable(SecCFAllocatorZeroize(), KEY_LENGTH);
 127     if (key == NULL) {
 128         return NULL;
 129     }
 130
 131     CFDataSetLength(key, KEY_LENGTH);
 132
 133     int ret;
 134     ret = ccpbkdf2_hmac(ccsha256_di(),
 135                         strlen(managedCredential.UTF8String), managedCredential.UTF8String,
 136                         CFDataGetLength(salt), CFDataGetBytePtr(salt),
 137                         iterations,
 138                         KEY_LENGTH, CFDataGetMutableBytePtr(key));
 139     if (ret) {
 140         CFRelease(key);
 141         return NULL;
 142     }
 143     return key;
 144 }
 145
 146
 147 /*
 148  * Given a dictionary stored in iDMS and a passcode, return a crypto key
 149  */
 150
 151 NSData *
 152 SecEMCSCreateDerivedEMCSKey(NSDictionary *iDMSData, NSString *managedCredential, NSError **error)
 153 {
 154     CFDataRef userDerivedKey = NULL, emcsKey = NULL;
 155     CFNumberRef number = NULL;
 156     CFDataRef salt = NULL;
 157     NSData *key = NULL;
 158     long iterations;
 159
 160     salt = CFDictionaryGetValue((__bridge CFDictionaryRef)iDMSData, kiDMSSalt);
 161     number = CFDictionaryGetValue((__bridge CFDictionaryRef)iDMSData, kiDMSIterrations);
 162     emcsKey = CFDictionaryGetValue((__bridge CFDictionaryRef)iDMSData, kiDMSWrapEMCSKey);
 163
 164     /* validate parameters */
 165     if (!isData(salt) || !isNumber(number) || !isData(emcsKey))
 166         return NULL;
 167
 168     if (!CFNumberGetValue(number, kCFNumberLongType, &iterations))
 169         return NULL;
 170
 171     userDerivedKey = CreateDerivedKey(salt, iterations, managedCredential);
 172     if (userDerivedKey == NULL)
 173         return NULL;
 174
 175     key = CopyUnwrappedKey(userDerivedKey, emcsKey);
 176     CFRelease(userDerivedKey);
 177
 178     return key;
 179 }
 180
 181 /*
 182  * Return a dictionary to be stored in iDMS
 183  */
 184
 185 NSDictionary *
 186 SecEMCSCreateNewiDMSKey(NSDictionary *options,
 187                         NSData *oldEMCSKey,
 188                         NSString *managedCredential,
 189                         NSData **emcsKey,
 190                         NSError **error)
 191 {
 192     CFMutableDataRef salt = NULL;
 193     const long iter = MIN_ITERATIONS;
 194     CFDataRef wrappedEMCSKey = NULL;
 195     CFMutableDataRef localEmcsKey = NULL;
 196     CFNumberRef iterations = NULL;
 197     CFDataRef userDerivedKey = NULL;
 198     CFDictionaryRef key = NULL;
 199
 200     if (emcsKey)
 201         *emcsKey = NULL;
 202
 203     if (oldEMCSKey) {
 204         if (CFGetTypeID((__bridge CFTypeRef)(oldEMCSKey)) != CFDataGetTypeID())
 205             return NULL;
 206         if (CFDataGetLength((__bridge CFDataRef)oldEMCSKey) != KEY_LENGTH)
 207             return NULL;
 208     }
 209
 210     salt = CFDataCreateMutableWithScratch(NULL, MIN_SALTLEN);
 211     if (salt == NULL)
 212         goto out;
 213
 214     if (SecRandomCopyBytes(NULL, CFDataGetLength(salt), CFDataGetMutableBytePtr(salt)) != 0)
 215         goto out;
 216
 217
 218     iterations = CFNumberCreate(NULL, kCFNumberLongType, &iter);
 219     if (iterations == NULL)
 220         goto out;
 221
 222     if (oldEMCSKey) {
 223         localEmcsKey = CFDataCreateMutableCopy(SecCFAllocatorZeroize(), 0, (__bridge CFDataRef)oldEMCSKey);
 224     } else {
 225         localEmcsKey = CFDataCreateMutableWithScratch(SecCFAllocatorZeroize(), KEY_LENGTH);
 226         if (localEmcsKey == NULL)
 227             goto out;
 228         if (SecRandomCopyBytes(NULL, CFDataGetLength(localEmcsKey), CFDataGetMutableBytePtr(localEmcsKey)) != 0)
 229             goto out;
 230     }
 231
 232     userDerivedKey = CreateDerivedKey(salt, iter, managedCredential);
 233     if (userDerivedKey == NULL)
 234         goto out;
 235
 236     wrappedEMCSKey = CopyWrappedKey(userDerivedKey, localEmcsKey);
 237     CFRelease(userDerivedKey);
 238     if (wrappedEMCSKey == NULL)
 239         goto out;
 240
 241     const void *keys[] = {
 242         kiDMSSalt,
 243         kiDMSIterrations,
 244         kiDMSWrapEMCSKey,
 245     };
 246     const void *values[] = {
 247         salt,
 248         iterations,
 249         wrappedEMCSKey,
 250     };
 251     _Static_assert(sizeof(keys)/sizeof(keys[0]) == sizeof(values)/sizeof(values[0]), "keys != values");
 252
 253     key = CFDictionaryCreate(NULL, keys, values, sizeof(keys)/sizeof(keys[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 254     if (key && emcsKey)
 255         *emcsKey = CFRetain(localEmcsKey);
 256
 257  out:
 258     CFReleaseNull(salt);
 259     CFReleaseNull(iterations);
 260     CFReleaseNull(localEmcsKey);
 261     CFReleaseNull(wrappedEMCSKey);
 262
 263     return (__bridge NSDictionary *)key;
 264 }