keychain/SecureObjectSync/Regressions/SOSRegressionUtilities.m

   1 /*
   2  * Copyright (c) 2012-2014 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 //
  25 //  SOSRegressionUtilities.c
  26 //
  27
  28 #include <AssertMacros.h>
  29 #include <stdio.h>
  30 #include <Security/SecItem.h>
  31
  32 #include <utilities/SecCFWrappers.h>
  33 #include <utilities/debugging.h>
  34
  35 #include "keychain/SecureObjectSync/SOSAccount.h"
  36 #include "keychain/SecureObjectSync/SOSAccountPriv.h"
  37 #include "keychain/SecureObjectSync/SOSCircle.h"
  38 #include "keychain/SecureObjectSync/SOSInternal.h"
  39 #include "keychain/SecureObjectSync/SOSPeerInfoInternal.h"
  40
  41 #include "keychain/SecureObjectSync/CKBridge/SOSCloudKeychainClient.h"
  42 #include "SOSRegressionUtilities.h"
  43 #include "keychain/SecureObjectSync/SOSInternal.h"
  44
  45 #if TARGET_OS_IPHONE
  46 #include <MobileGestalt.h>
  47 #endif
  48
  49 static const uint64_t maxTimeToWaitInSeconds = 30ull * NSEC_PER_SEC;
  50
  51 // MARK: ----- SOS General -----
  52
  53 const char *cloudKeychainProxyPath = "/System/Library/Frameworks/Security.framework/Resources/CloudKeychainProxy.bundle/CloudKeychainProxy";
  54
  55 static const char *basecfabsoluteTimeToString(CFAbsoluteTime abstime, CFTimeZoneRef tz)
  56 {
  57     CFGregorianDate greg = CFAbsoluteTimeGetGregorianDate(abstime, NULL);
  58     char str[20];
  59     if (19 != snprintf(str, 20, "%4.4d-%2.2d-%2.2d_%2.2d:%2.2d:%2.2d",
  60         (int)greg.year, greg.month, greg.day, greg.hour, greg.minute, (int)greg.second))
  61         str[0]=0;
  62     char *data = (char *)malloc(20);
  63     strncpy(data, str, 20);
  64     return data;
  65 }
  66
  67 const char *cfabsoluteTimeToString(CFAbsoluteTime abstime)
  68 {
  69     return basecfabsoluteTimeToString(abstime, NULL);
  70 }
  71
  72 const char *cfabsoluteTimeToStringLocal(CFAbsoluteTime abstime)
  73 {
  74     // Caller must release using free
  75     CFDateFormatterRef formatter = NULL;
  76     CFTimeZoneRef tz = NULL;
  77         CFLocaleRef locale = NULL;
  78     CFDateRef date = NULL;
  79     CFStringRef cftime_string = NULL;
  80     char *time_string = NULL;
  81     char buffer[1024] = {0,};
  82     size_t sz;
  83
  84     require(tz = CFTimeZoneCopySystem(), xit);
  85     require(locale = CFLocaleCreate(NULL, CFSTR("en_US")), xit);
  86
  87     require(formatter = CFDateFormatterCreate(kCFAllocatorDefault, locale, kCFDateFormatterShortStyle, kCFDateFormatterShortStyle), xit);
  88     CFDateFormatterSetFormat(formatter, CFSTR("MM/dd/yy HH:mm:ss.SSS zzz"));
  89     require(date = CFDateCreate(kCFAllocatorDefault, abstime), xit);
  90     require(cftime_string = CFDateFormatterCreateStringWithDate(kCFAllocatorDefault, formatter, date), xit);
  91
  92     CFStringGetCString(cftime_string, buffer, 1024, kCFStringEncodingUTF8);
  93     sz = strnlen(buffer, 1024);
  94     time_string = (char *)malloc(sz);
  95     strncpy(time_string, buffer, sz+1);
  96 xit:
  97     CFReleaseSafe(tz);
  98     CFReleaseSafe(formatter);
  99     CFReleaseSafe(locale);
 100     CFReleaseSafe(date);
 101     CFReleaseSafe(cftime_string);
 102     return time_string;
 103 }
 104
 105 #include <sys/stat.h>
 106
 107 static int file_exist (const char *filename)
 108 {
 109     struct stat buffer;
 110     return (stat (filename, &buffer) == 0);
 111 }
 112
 113 bool XPCServiceInstalled(void)
 114 {
 115     return file_exist(cloudKeychainProxyPath);
 116 }
 117
 118 void registerForKVSNotifications(const void *observer, CFStringRef name, CFNotificationCallback callBack)
 119 {
 120     // observer is basically a context; name may not be null
 121     CFNotificationCenterRef center = CFNotificationCenterGetDarwinNotifyCenter();
 122     CFNotificationSuspensionBehavior suspensionBehavior = CFNotificationSuspensionBehaviorDeliverImmediately;    //ignored?
 123     CFNotificationCenterAddObserver(center, observer, callBack, name, NULL, suspensionBehavior);
 124 }
 125
 126 bool testPutObjectInCloudAndSync(CFStringRef key, CFTypeRef object, CFErrorRef *error, dispatch_group_t dgroup, dispatch_queue_t processQueue)
 127 {
 128     bool result = testPutObjectInCloud(key, object, error, dgroup, processQueue);
 129     testSynchronize(processQueue, dgroup);
 130
 131     return result;
 132 }
 133
 134 bool testPutObjectInCloud(CFStringRef key, CFTypeRef object, CFErrorRef *error, dispatch_group_t dgroup, dispatch_queue_t processQueue)
 135 {
 136     secnotice("test", "testPutObjectInCloud: key: %@, %@", key, object);
 137     CFDictionaryRef objects = CFDictionaryCreateForCFTypes(kCFAllocatorDefault, key, object, NULL);
 138     if (objects)
 139     {
 140         dispatch_group_enter(dgroup);
 141         SOSCloudKeychainPutObjectsInCloud(objects, processQueue, ^ (CFDictionaryRef returnedValues, CFErrorRef error)
 142         {
 143             secnotice("test", "testPutObjectInCloud returned: %@", returnedValues);
 144             if (error)
 145             {
 146                 secnotice("test", "testPutObjectInCloud returned: %@", error);
 147                 CFRelease(error);
 148             }
 149             dispatch_group_leave(dgroup);
 150         });
 151         CFRelease(objects);
 152     }
 153
 154     return true;
 155 }
 156
 157 CFTypeRef testGetObjectFromCloud(CFStringRef key, dispatch_queue_t processQueue, dispatch_group_t dgroup)
 158 {
 159     // TODO: make sure we return NULL, not CFNull
 160     secnotice("test", "start");
 161     CFMutableArrayRef keysToGet = CFArrayCreateMutableForCFTypes(kCFAllocatorDefault);
 162     CFArrayAppendValue(keysToGet, key);
 163
 164     __block CFTypeRef object = NULL;
 165
 166     dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
 167     dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds);
 168
 169     dispatch_group_enter(dgroup);
 170     SOSCloudKeychainGetObjectsFromCloud(keysToGet, processQueue, ^ (CFDictionaryRef returnedValues, CFErrorRef error)
 171     {
 172         secnotice("test", "SOSCloudKeychainGetObjectsFromCloud returned: %@", returnedValues);
 173         if (returnedValues)
 174         {
 175             object = (CFTypeRef)CFDictionaryGetValue(returnedValues, key);
 176             if (object)
 177                 CFRetain(object);
 178         }
 179         if (error)
 180         {
 181             secerror("SOSCloudKeychainGetObjectsFromCloud returned error: %@", error);
 182      //       CFRelease(*error);
 183         }
 184         dispatch_group_leave(dgroup);
 185         secnotice("test", "SOSCloudKeychainGetObjectsFromCloud block exit: %@", object);
 186         dispatch_semaphore_signal(waitSemaphore);
 187     });
 188
 189         dispatch_semaphore_wait(waitSemaphore, finishTime);
 190     if (object && (CFGetTypeID(object) == CFNullGetTypeID()))   // return a NULL instead of a CFNull
 191     {
 192         CFRelease(object);
 193         object = NULL;
 194     }
 195     secnotice("test", "returned: %@", object);
 196     return object;
 197 }
 198
 199 CFTypeRef testGetObjectsFromCloud(CFArrayRef keysToGet, dispatch_queue_t processQueue, dispatch_group_t dgroup)
 200 {
 201     __block CFTypeRef object = NULL;
 202
 203     dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
 204     dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds);
 205     dispatch_group_enter(dgroup);
 206
 207     CloudKeychainReplyBlock replyBlock =
 208         ^ (CFDictionaryRef returnedValues, CFErrorRef error)
 209     {
 210         secnotice("test", "SOSCloudKeychainGetObjectsFromCloud returned: %@", returnedValues);
 211         object = returnedValues;
 212         if (object)
 213             CFRetain(object);
 214         if (error)
 215         {
 216             secerror("SOSCloudKeychainGetObjectsFromCloud returned error: %@", error);
 217         }
 218         dispatch_group_leave(dgroup);
 219         secnotice("test", "SOSCloudKeychainGetObjectsFromCloud block exit: %@", object);
 220         dispatch_semaphore_signal(waitSemaphore);
 221     };
 222
 223     if (!keysToGet) {
 224         SOSCloudKeychainGetAllObjectsFromCloud(processQueue, replyBlock);
 225     } else {
 226         SOSCloudKeychainGetObjectsFromCloud(keysToGet, processQueue, replyBlock);
 227     }
 228
 229         dispatch_semaphore_wait(waitSemaphore, finishTime);
 230     if (object && (CFGetTypeID(object) == CFNullGetTypeID()))   // return a NULL instead of a CFNull
 231     {
 232         CFRelease(object);
 233         object = NULL;
 234     }
 235     secnotice("test", "returned: %@", object);
 236     return object;
 237 }
 238
 239 bool testSynchronize(dispatch_queue_t processQueue, dispatch_group_t dgroup)
 240 {
 241     __block bool result = false;
 242     dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
 243     dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds);
 244
 245     dispatch_group_enter(dgroup);
 246
 247     SOSCloudKeychainSynchronize(processQueue, ^(CFDictionaryRef returnedValues, CFErrorRef error)
 248         {
 249             result = true;
 250             dispatch_group_leave(dgroup);
 251             dispatch_semaphore_signal(waitSemaphore);
 252         });
 253
 254         dispatch_semaphore_wait(waitSemaphore, finishTime);
 255     return result;
 256 }
 257
 258 bool testClearAll(dispatch_queue_t processQueue, dispatch_group_t dgroup)
 259 {
 260     __block bool result = false;
 261     dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
 262     dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds);
 263
 264     dispatch_group_enter(dgroup);
 265
 266     secnotice("circleOps", "SOSCloudKeychainClearAll called by testClearAll");
 267     SOSCloudKeychainClearAll(processQueue, ^(CFDictionaryRef returnedValues, CFErrorRef error)
 268         {
 269             result = true;
 270             secnotice("test", "SOSCloudKeychainClearAll returned: %@", error);
 271             dispatch_group_leave(dgroup);
 272             dispatch_semaphore_signal(waitSemaphore);
 273         });
 274
 275         dispatch_semaphore_wait(waitSemaphore, finishTime);
 276     secnotice("test", "SOSCloudKeychainClearAll exit");
 277     return result;
 278 }
 279
 280 void unregisterFromKVSNotifications(const void *observer)
 281 {
 282     CFNotificationCenterRemoveEveryObserver(CFNotificationCenterGetDarwinNotifyCenter(), observer);
 283 }
 284
 285 //
 286 // MARK: SOSPeerInfo creation helpers
 287 //
 288
 289 CFDictionaryRef SOSCreatePeerGestaltFromName(CFStringRef name)
 290 {
 291     return CFDictionaryCreateForCFTypes(kCFAllocatorDefault,
 292                                         kPIUserDefinedDeviceNameKey, name,
 293                                         NULL);
 294 }
 295
 296
 297 SOSPeerInfoRef SOSCreatePeerInfoFromName(CFStringRef name,
 298                                          SecKeyRef* outSigningKey,
 299                                          SecKeyRef* outOctagonSigningKey,
 300                                          SecKeyRef* outOctagonEncryptionKey,
 301                                          CFErrorRef *error)
 302 {
 303     SOSPeerInfoRef result = NULL;
 304     SecKeyRef publicKey = NULL;
 305     SecKeyRef octagonSigningPublicKey = NULL;
 306     SecKeyRef octagonEncryptionPublicKey = NULL;
 307     CFDictionaryRef gestalt = NULL;
 308
 309     require(outSigningKey, exit);
 310
 311     require_quiet(SecError(GeneratePermanentECPair(256, &publicKey, outSigningKey), error, CFSTR("Failed To Create Key")), exit);
 312     require_quiet(SecError(GeneratePermanentECPair(384, &octagonSigningPublicKey, outOctagonSigningKey), error, CFSTR("Failed to Create Octagon Signing Key")), exit);
 313     require_quiet(SecError(GeneratePermanentECPair(384, &octagonEncryptionPublicKey, outOctagonEncryptionKey), error, CFSTR("Failed to Create Octagon Encryption Key")), exit);
 314
 315     gestalt = SOSCreatePeerGestaltFromName(name);
 316     require(gestalt, exit);
 317
 318     result = SOSPeerInfoCreate(NULL, gestalt, NULL, *outSigningKey,
 319                                *outOctagonSigningKey, *outOctagonEncryptionKey,
 320                                // Always support CKKS4All for now
 321                                true,
 322                                error);
 323
 324 exit:
 325     CFReleaseNull(gestalt);
 326     CFReleaseNull(publicKey);
 327     CFReleaseNull(octagonSigningPublicKey);
 328     CFReleaseNull(octagonEncryptionPublicKey);
 329
 330     return result;
 331 }
 332
 333 SOSFullPeerInfoRef SOSCreateFullPeerInfoFromName(CFStringRef name,
 334                                                  SecKeyRef* outSigningKey,
 335                                                  SecKeyRef* outOctagonSigningKey,
 336                                                  SecKeyRef* outOctagonEncryptionKey,
 337                                                  CFErrorRef *error)
 338 {
 339     SOSFullPeerInfoRef result = NULL;
 340     SecKeyRef publicKey = NULL;
 341     CFDictionaryRef gestalt = NULL;
 342
 343     require(outSigningKey, exit);
 344     *outSigningKey = GeneratePermanentFullECKey(256, name, error);
 345     require(*outSigningKey, exit);
 346
 347     require(outOctagonSigningKey, exit);
 348     *outOctagonSigningKey = GeneratePermanentFullECKey(384, name, error);
 349     require(*outOctagonSigningKey, exit);
 350
 351     require(outOctagonEncryptionKey, exit);
 352     *outOctagonEncryptionKey = GeneratePermanentFullECKey(384, name, error);
 353     require(*outOctagonEncryptionKey, exit);
 354
 355     gestalt = SOSCreatePeerGestaltFromName(name);
 356     require(gestalt, exit);
 357
 358     result = SOSFullPeerInfoCreate(NULL, gestalt,
 359                                    NULL,
 360                                    *outSigningKey,
 361                                    *outOctagonSigningKey,
 362                                    *outOctagonEncryptionKey,
 363                                    error);
 364
 365 exit:
 366     CFReleaseNull(gestalt);
 367     CFReleaseNull(publicKey);
 368
 369     return result;
 370 }
 371
 372 // MARK: ----- MAC Address -----
 373
 374 /*
 375  *      Name:                   GetHardwareAdress
 376  *
 377  *      Parameters:             None.
 378  *
 379  *      Returns:                Nothing
 380  *
 381  *      Description:    Retrieve the hardare address for a specified network interface
 382  *
 383  */
 384
 385 #include <stdlib.h>
 386 #include <string.h>
 387
 388 #include <sys/socket.h>
 389 #include <netinet/in.h>
 390 #include <sys/sysctl.h>
 391 #include <net/if.h>
 392 #include <net/if_dl.h>
 393 #include <net/route.h>
 394
 395 #include <unistd.h>
 396 #include <netdb.h>
 397 #include <sys/stat.h>
 398
 399 static int getHardwareAddress(const char *interfaceName, size_t maxLenAllowed, size_t *outActualLength, char *outHardwareAddress)
 400 {
 401         char                            *end;
 402         struct if_msghdr        *ifm;
 403         struct sockaddr_dl      *sdl;
 404         char                            *buf;
 405         int                             result = -1;
 406         size_t                          buffSize;
 407         int                                     mib[6] = {CTL_NET, AF_ROUTE, 0, AF_INET, NET_RT_IFLIST, 0 };
 408
 409         buf = 0;
 410         *outActualLength = 0;
 411         //      see how much space is needed
 412         require_noerr(result = sysctl(mib, 6, NULL, &buffSize, NULL, 0), xit);
 413
 414         //      allocate the buffer
 415         require(buf = malloc(buffSize), xit);
 416
 417         //      get the interface info
 418         require_noerr(result = sysctl(mib, 6, buf, &buffSize, NULL, 0), xit);
 419
 420         ifm = (struct if_msghdr *) buf;
 421         end = buf + buffSize;
 422         do
 423         {
 424                 if (ifm->ifm_type == RTM_IFINFO)                //      should always be true
 425                 {
 426                         sdl = (struct sockaddr_dl *) (ifm + 1);
 427                         if ( sdl->sdl_nlen == strlen( interfaceName ) && ( bcmp( sdl->sdl_data, interfaceName, sdl->sdl_nlen ) == 0 ) )
 428                         {
 429                                 if (  sdl->sdl_alen > 0 )
 430                                 {
 431                                         size_t hardwareLen;
 432
 433                                         result = 0;                                             //      indicate found the interface
 434                                         hardwareLen = sdl->sdl_alen;
 435                                         if ( hardwareLen > maxLenAllowed )
 436                                         {
 437                                                 hardwareLen = maxLenAllowed;
 438                                                 result = -2;                            //      indicate truncation of the address
 439                                         }
 440                                         memcpy( outHardwareAddress, sdl->sdl_data + sdl->sdl_nlen, hardwareLen );
 441                                         *outActualLength = hardwareLen;
 442                                         break;
 443
 444                                 }
 445                         }
 446                 }
 447                 ifm = (struct if_msghdr *)  ((char*)ifm + ifm->ifm_msglen);
 448         } while ( (char*)ifm < end );
 449
 450 xit:
 451         if (buf)
 452                 free(buf);
 453
 454         return result;
 455 }
 456
 457 // MARK: ----- cloudTransportTests -----
 458
 459 CFStringRef myMacAddress(void)
 460 {
 461     // 6 bytes, no ":"s
 462     CFStringRef result = NULL;
 463     const char *interfaceName = "en0";
 464     size_t maxLenAllowed = 1024;
 465     size_t outActualLength = 0;
 466     char outHardwareAddress[1024];
 467
 468     require_noerr(getHardwareAddress(interfaceName, maxLenAllowed, &outActualLength, outHardwareAddress), xit);
 469     require(outActualLength==6, xit);
 470     unsigned char buf[32]={0,};
 471
 472     unsigned char *ps = (unsigned char *)buf;
 473     unsigned char *pa = (unsigned char *)outHardwareAddress;
 474     for (int ix = 0; ix < 6; ix++, pa++)
 475         ps += sprintf((char *)ps, "%02x", *pa);
 476
 477     result = CFStringCreateWithCString(kCFAllocatorDefault, (const char *)buf, kCFStringEncodingUTF8);
 478
 479 xit:
 480     return result;
 481 }