OSX/sec/Security/SecuritydXPC.c

   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 #include <Security/SecuritydXPC.h>
  26 #include <Security/SecCFAllocator.h>
  27 #include <ipc/securityd_client.h>
  28 #include <utilities/SecCFError.h>
  29 #include <utilities/SecDb.h>
  30 #include <utilities/SecCFWrappers.h>
  31 #include <utilities/der_plist.h>
  32
  33 // TODO Shorten these string values to save ipc bandwidth.
  34 const char *kSecXPCKeyOperation = "operation";
  35 const char *kSecXPCKeyResult = "status";
  36 const char *kSecXPCKeyEndpoint = "endpoint";
  37 const char *kSecXPCKeyError = "error";
  38 const char *kSecXPCKeyClientToken = "client";
  39 const char *kSecXPCKeyPeerInfoArray = "peer-infos";
  40 const char *kSecXPCKeyPeerInfo = "peer-info";
  41 const char *kSecXPCKeyUserLabel = "userlabel";
  42 const char *kSecXPCKeyBackup = "backup";
  43 const char *kSecXPCKeyKeybag = "keybag";
  44 const char *kSecXPCKeyFlags = "flags";
  45 const char *kSecXPCKeyUserPassword = "password";
  46 const char *kSecXPCKeyEMCSBackup = "emcsbackup";
  47 const char *kSecXPCKeyDSID = "dsid";
  48 const char *kSecXPCKeyQuery = "query";
  49 const char *kSecXPCKeyAttributesToUpdate = "attributesToUpdate";
  50 const char *kSecXPCKeyDomain = "domain";
  51 const char *kSecXPCKeyDigest = "digest";
  52 const char *kSecXPCKeyCertificate = "cert";
  53 const char *kSecXPCKeySettings = "settings";
  54 const char *kSecXPCKeyOTAFileDirectory = "path";
  55 const char *kSecXPCLimitInMinutes = "limitMinutes";
  56 const char *kSecXPCPublicPeerId = "publicPeerId"; // Public peer id
  57 const char *kSecXPCOTRSession = "otrsess"; // OTR session bytes
  58 const char *kSecXPCData = "data"; // Data to process
  59 const char *kSecXPCOTRReady = "otrrdy"; // OTR ready for messages
  60 const char *kSecXPCKeyViewName = "viewname";
  61 const char *kSecXPCKeyViewActionCode = "viewactioncode";
  62 const char *kSecXPCKeyHSA2AutoAcceptInfo = "autoacceptinfo";
  63 const char *kSecXPCKeyString = "cfstring";
  64 const char *kSecXPCKeyArray = "cfarray";
  65 const char *kSecXPCKeySet = "cfset";
  66 const char *kSecXPCKeySet2 = "cfset2";
  67 const char *kSecXPCKeyNewPublicBackupKey = "newPublicBackupKey";
  68 const char *kSecXPCKeyRecoveryPublicKey = "RecoveryPublicKey";
  69 const char *kSecXPCKeyIncludeV0 = "includeV0";
  70 const char *kSecXPCKeyReason = "reason";
  71 const char *kSecXPCKeyEnabledViewsKey = "enabledViews";
  72 const char *kSecXPCKeyDisabledViewsKey = "disabledViews";
  73 const char *kSecXPCKeyEscrowLabel = "escrow";
  74 const char *kSecXPCKeyTriesLabel = "tries";
  75 const char *kSecXPCKeyFileDescriptor = "fileDescriptor";
  76 const char *kSecXPCKeyAccessGroups = "accessGroups";
  77 const char *kSecXPCKeyClasses = "classes";
  78 const char *kSecXPCKeyNormalizedIssuer = "normIssuer";
  79 const char *kSecXPCKeySerialNumber = "serialNum";
  80 const char *kSecXPCKeyBackupKeybagIdentifier = "backupKeybagID";
  81 const char *kSecXPCKeyBackupKeybagPath = "backupKeybagPath";
  82 const char *kSecXPCVersion = "version";
  83 const char *kSecXPCKeySignInAnalytics = "signinanalytics";
  84 //
  85 // XPC Functions for both client and server.
  86 //
  87
  88
  89 CFStringRef SOSCCGetOperationDescription(enum SecXPCOperation op)
  90 {
  91     switch (op) {
  92         case kSecXPCOpAccountSetToNew:
  93             return CFSTR("AccountSetToNew");
  94         case kSecXPCOpOTAGetEscrowCertificates:
  95             return CFSTR("OTAGetEscrowCertificates");
  96         case kSecXPCOpOTAPKIGetNewAsset:
  97             return CFSTR("OTAPKIGetNewAsset");
  98         case kSecXPCOpOTASecExperimentGetNewAsset:
  99             return CFSTR("OTASecExperimentGetNewAsset");
 100         case kSecXPCOpOTASecExperimentGetAsset:
 101             return CFSTR("OTASecExperimentGetAsset");
 102         case kSecXPCOpAcceptApplicants:
 103             return CFSTR("AcceptApplicants");
 104         case kSecXPCOpApplyToARing:
 105             return CFSTR("ApplyToARing");
 106         case kSecXPCOpBailFromCircle:
 107             return CFSTR("BailFromCircle");
 108         case kSecXPCOpCanAuthenticate:
 109             return CFSTR("CanAuthenticate");
 110         case kSecXPCOpCopyApplicantPeerInfo:
 111             return CFSTR("CopyApplicantPeerInfo");
 112         case kSecXPCOpCopyConcurringPeerPeerInfo:
 113             return CFSTR("CopyConcurringPeerPeerInfo");
 114         case kSecXPCOpCopyEngineState:
 115             return CFSTR("CopyEngineState");
 116         case kSecXPCOpCopyGenerationPeerInfo:
 117             return CFSTR("CopyGenerationPeerInfo");
 118         case kSecXPCOpCopyIncompatibilityInfo:
 119             return CFSTR("CopyIncompatibilityInfo");
 120         case kSecXPCOpCopyMyPeerInfo:
 121             return CFSTR("CopyMyPeerInfo");
 122         case kSecXPCOpCopyNotValidPeerPeerInfo:
 123             return CFSTR("CopyNotValidPeerPeerInfo");
 124         case kSecXPCOpCopyPeerPeerInfo:
 125             return CFSTR("CopyPeerPeerInfo");
 126         case kSecXPCOpCopyRetirementPeerInfo:
 127             return CFSTR("CopyRetirementPeerInfo");
 128         case kSecXPCOpCopyValidPeerPeerInfo:
 129             return CFSTR("CopyValidPeerPeerInfo");
 130         case kSecXPCOpCopyViewUnawarePeerInfo:
 131             return CFSTR("CopyViewUnawarePeerInfo");
 132         case kSecXPCOpDeviceInCircle:
 133             return CFSTR("DeviceInCircle");
 134         case kSecXPCOpEnableRing:
 135             return CFSTR("EnableRing");
 136         case kSecXPCOpGetAllTheRings:
 137             return CFSTR("GetAllTheRings");
 138         case kSecXPCOpGetLastDepartureReason:
 139             return CFSTR("GetLastDepartureReason");
 140         case kSecXPCOpLoggedOutOfAccount:
 141             return CFSTR("LoggedOutOfAccount");
 142         case kSecXPCOpProcessSyncWithAllPeers:
 143             return CFSTR("ProcessSyncWithAllPeers");
 144         case kSecXPCOpProcessSyncWithPeers:
 145             return CFSTR("ProcessSyncWithPeers");
 146         case kSecXPCOpProcessUnlockNotification:
 147             return CFSTR("ProcessUnlockNotification");
 148         case kSecXPCOpPurgeUserCredentials:
 149             return CFSTR("PurgeUserCredentials");
 150         case kSecXPCOpRejectApplicants:
 151             return CFSTR("RejectApplicants");
 152         case kSecXPCOpRemoveThisDeviceFromCircle:
 153             return CFSTR("RemoveThisDeviceFromCircle");
 154         case kSecXPCOpRemoveThisDeviceFromCircleWithAnalytics:
 155             return CFSTR("RemoveThisDeviceFromCircleWithAnalytics");
 156         case kSecXPCOpRemovePeersFromCircle:
 157             return CFSTR("RemovePeersFromCircle");
 158         case kSecXPCOpRemovePeersFromCircleWithAnalytics:
 159             return CFSTR("RemovePeersFromCircleWithAnalytics");
 160         case kSecXPCOpRequestEnsureFreshParameters:
 161             return CFSTR("RequestEnsureFreshParameters");
 162         case kSecXPCOpRequestToJoin:
 163             return CFSTR("RequestToJoin");
 164         case kSecXPCOpRequestToJoinWithAnalytics:
 165             return CFSTR("RequestToJoinWithAnalytics");
 166         case kSecXPCOpRequestToJoinAfterRestore:
 167             return CFSTR("RequestToJoinAfterRestore");
 168         case kSecXPCOpRequestToJoinAfterRestoreWithAnalytics:
 169             return CFSTR("RequestToJoinAfterRestoreWithAnalytics");
 170         case kSecXPCOpResetToEmpty:
 171             return CFSTR("ResetToEmpty");
 172         case kSecXPCOpResetToEmptyWithAnalytics:
 173             return CFSTR("ResetToEmptyWithAnalytics");
 174         case kSecXPCOpResetToOffering:
 175             return CFSTR("ResetToOffering");
 176         case kSecXPCOpRingStatus:
 177             return CFSTR("RingStatus");
 178         case kSecXPCOpRollKeys:
 179             return CFSTR("RollKeys");
 180         case kSecXPCOpSetBagForAllSlices:
 181             return CFSTR("SetBagForAllSlices");
 182         case kSecXPCOpSetLastDepartureReason:
 183             return CFSTR("SetLastDepartureReason");
 184         case kSecXPCOpSetNewPublicBackupKey:
 185             return CFSTR("SetNewPublicBackupKey");
 186         case kSecXPCOpSetUserCredentials:
 187             return CFSTR("SetUserCredentials");
 188         case kSecXPCOpSetUserCredentialsAndDSID:
 189             return CFSTR("SetUserCredentialsAndDSID");
 190         case kSecXPCOpSetUserCredentialsAndDSIDWithAnalytics:
 191             return CFSTR("SetUserCredentialsAndDSIDWithAnalytics");
 192         case kSecXPCOpTryUserCredentials:
 193             return CFSTR("TryUserCredentials");
 194         case kSecXPCOpValidateUserPublic:
 195             return CFSTR("ValidateUserPublic");
 196         case kSecXPCOpView:
 197             return CFSTR("View");
 198         case kSecXPCOpWithdrawlFromARing:
 199             return CFSTR("WithdrawlFromARing");
 200         case sec_add_shared_web_credential_id:
 201             return CFSTR("add_shared_web_credential");
 202         case sec_copy_shared_web_credential_id:
 203             return CFSTR("copy_shared_web_credential");
 204         case sec_delete_all_id:
 205             return CFSTR("delete_all");
 206         case sec_get_log_settings_id:
 207             return CFSTR("get_log_settings");
 208         case sec_item_add_id:
 209             return CFSTR("add");
 210         case sec_item_backup_copy_names_id:
 211             return CFSTR("backup_copy_names");
 212         case sec_item_backup_handoff_fd_id:
 213             return CFSTR("backup_handoff_fd");
 214         case sec_item_backup_restore_id:
 215             return CFSTR("backup_restore");
 216         case sec_item_backup_set_confirmed_manifest_id:
 217             return CFSTR("backup_set_confirmed_manifest");
 218         case sec_item_copy_matching_id:
 219             return CFSTR("copy_matching");
 220         case sec_item_delete_id:
 221             return CFSTR("delete");
 222         case sec_item_update_id:
 223             return CFSTR("update");
 224         case sec_keychain_backup_id:
 225             return CFSTR("keychain_backup");
 226         case sec_keychain_backup_syncable_id:
 227             return CFSTR("keychain_backup_syncable");
 228         case sec_keychain_restore_id:
 229             return CFSTR("keychain_restore");
 230         case sec_keychain_restore_syncable_id:
 231             return CFSTR("keychain_restore_syncable");
 232         case sec_keychain_sync_update_message_id:
 233             return CFSTR("keychain_sync_update_message");
 234         case sec_ota_pki_trust_store_version_id:
 235             return CFSTR("ota_pki_trust_store_version");
 236         case sec_ota_pki_asset_version_id:
 237             return CFSTR("ota_pki_asset_version");
 238         case sec_otr_session_create_remote_id:
 239             return CFSTR("otr_session_create_remote");
 240         case sec_otr_session_process_packet_remote_id:
 241             return CFSTR("otr_session_process_packet_remote");
 242         case sec_set_circle_log_settings_id:
 243             return CFSTR("set_circle_log_settings");
 244         case sec_set_xpc_log_settings_id:
 245             return CFSTR("set_xpc_log_settings");
 246         case sec_trust_evaluate_id:
 247             return CFSTR("trust_evaluate");
 248         case sec_trust_store_contains_id:
 249             return CFSTR("trust_store_contains");
 250         case sec_trust_store_remove_certificate_id:
 251             return CFSTR("trust_store_remove_certificate");
 252         case sec_trust_store_set_trust_settings_id:
 253             return CFSTR("trust_store_set_trust_settings");
 254         case sec_trust_store_copy_all_id:
 255             return CFSTR("trust_store_copy_all");
 256         case sec_trust_store_copy_usage_constraints_id:
 257             return CFSTR("trust_store_copy_usage_constraints");
 258         case sec_ocsp_cache_flush_id:
 259             return CFSTR("ocsp_cache_flush");
 260         case soscc_EnsurePeerRegistration_id:
 261             return CFSTR("EnsurePeerRegistration");
 262         case kSecXPCOpSetEscrowRecord:
 263             return CFSTR("SetEscrowRecord");
 264         case kSecXPCOpGetEscrowRecord:
 265             return CFSTR("GetEscrowRecord");
 266         case kSecXPCOpWhoAmI:
 267             return CFSTR("WhoAmI");
 268         case kSecXPCOpTransmogrifyToSyncBubble:
 269             return CFSTR("TransmogrifyToSyncBubble");
 270         case kSecXPCOpWrapToBackupSliceKeyBagForView:
 271             return CFSTR("WrapToBackupSliceKeyBagForView");
 272         case kSecXPCOpCopyAccountData:
 273             return CFSTR("CopyAccountDataFromKeychain");
 274         case kSecXPCOpDeleteAccountData:
 275             return CFSTR("DeleteAccountDataFromKeychain");
 276         case kSecXPCOpCopyEngineData:
 277             return CFSTR("CopyEngineDataFromKeychain");
 278         case kSecXPCOpDeleteEngineData:
 279             return CFSTR("DeleteEngineDataFromKeychain");
 280         case sec_item_update_token_items_id:
 281             return CFSTR("UpdateTokenItems");
 282         case sec_delete_items_with_access_groups_id:
 283             return CFSTR("sec_delete_items_with_access_groups_id");
 284         case kSecXPCOpPeersHaveViewsEnabled:
 285             return CFSTR("kSecXPCOpPeersHaveViewsEnabled");
 286         case kSecXPCOpRegisterRecoveryPublicKey:
 287             return CFSTR("RegisterRecoveryPublicKey");
 288         case kSecXPCOpGetRecoveryPublicKey:
 289             return CFSTR("GetRecoveryPublicKey");
 290         case kSecXPCOpCopyBackupInformation:
 291             return CFSTR("CopyBackupInformation");
 292         case kSecXPCOpMessageFromPeerIsPending:
 293             return CFSTR("MessageFromPeerIsPending");
 294         case kSecXPCOpSendToPeerIsPending:
 295             return CFSTR("SendToPeerIsPending");
 296         case sec_item_copy_parent_certificates_id:
 297             return CFSTR("copy_parent_certificates");
 298         case sec_item_certificate_exists_id:
 299             return CFSTR("certificate_exists");
 300         case kSecXPCOpBackupKeybagAdd:
 301             return CFSTR("KeybagAdd");
 302         case kSecXPCOpBackupKeybagDelete:
 303             return CFSTR("KeybagDelete");
 304         case kSecXPCOpKeychainControlEndpoint:
 305             return CFSTR("KeychainControlEndpoint");
 306         case kSecXPCOpNetworkingAnalyticsReport:
 307             return CFSTR("NetworkingAnalyticsReport");
 308         case kSecXPCOpSetCTExceptions:
 309             return CFSTR("SetCTExceptions");
 310         case kSecXPCOpCopyCTExceptions:
 311             return CFSTR("CopyCTExceptions");
 312         case sec_trust_get_exception_reset_count_id:
 313             return CFSTR("GetExceptionResetCount");
 314         case sec_trust_increment_exception_reset_count_id:
 315             return CFSTR("IncrementExceptionResetCount");
 316         default:
 317             return CFSTR("Unknown xpc operation");
 318     }
 319 }
 320
 321 bool SecXPCDictionarySetPList(xpc_object_t message, const char *key, CFTypeRef object, CFErrorRef *error)
 322 {
 323     if (!object)
 324         return SecError(errSecParam, error, CFSTR("object for key %s is NULL"), key);
 325
 326     size_t size = der_sizeof_plist(object, error);
 327     if (!size)
 328         return false;
 329     uint8_t *der = malloc(size);
 330     uint8_t *der_end = der + size;
 331     uint8_t *der_start = der_encode_plist(object, error, der, der_end);
 332     if (!der_start) {
 333         free(der);
 334         return false;
 335     }
 336
 337     assert(der == der_start);
 338     xpc_dictionary_set_data(message, key, der_start, der_end - der_start);
 339     free(der);
 340     return true;
 341 }
 342
 343 bool SecXPCDictionarySetPListOptional(xpc_object_t message, const char *key, CFTypeRef object, CFErrorRef *error) {
 344     return !object || SecXPCDictionarySetPList(message, key, object, error);
 345 }
 346
 347 bool SecXPCDictionarySetData(xpc_object_t message, const char *key, CFDataRef data, CFErrorRef *error)
 348 {
 349     if (!data)
 350         return SecError(errSecParam, error, CFSTR("data for key %s is NULL"), key);
 351
 352     xpc_dictionary_set_data(message, key, CFDataGetBytePtr(data), CFDataGetLength(data));
 353     return true;
 354 }
 355
 356 bool SecXPCDictionarySetBool(xpc_object_t message, const char *key, bool value, CFErrorRef *error)
 357 {
 358     xpc_dictionary_set_bool(message, key, value);
 359     return true;
 360 }
 361
 362 bool SecXPCDictionarySetString(xpc_object_t message, const char *key, CFStringRef string, CFErrorRef *error)
 363 {
 364     if (!string)
 365         return SecError(errSecParam, error, CFSTR("string for key %s is NULL"), key);
 366
 367     __block bool ok = true;
 368     CFStringPerformWithCString(string, ^(const char *utf8Str) {
 369         if (utf8Str)
 370             xpc_dictionary_set_string(message, key, utf8Str);
 371         else
 372             ok = SecError(errSecParam, error, CFSTR("failed to convert string for key %s to utf8"), key);
 373     });
 374     return ok;
 375 }
 376
 377 bool SecXPCDictionarySetStringOptional(xpc_object_t message, const char *key, CFStringRef string, CFErrorRef *error) {
 378     return !string || SecXPCDictionarySetString(message, key, string, error);
 379 }
 380
 381 bool SecXPCDictionarySetDataOptional(xpc_object_t message, const char *key, CFDataRef data, CFErrorRef *error) {
 382     return !data || SecXPCDictionarySetData(message, key, data, error);
 383 }
 384
 385 bool SecXPCDictionarySetInt64(xpc_object_t message, const char *key, int64_t value, CFErrorRef *error) {
 386     xpc_dictionary_set_int64(message, key, value);
 387     return true;
 388 }
 389
 390 bool SecXPCDictionarySetFileDescriptor(xpc_object_t message, const char *key, int fd, CFErrorRef *error) {
 391     xpc_dictionary_set_fd(message, key, fd);
 392     return true;
 393 }
 394
 395 int SecXPCDictionaryDupFileDescriptor(xpc_object_t message, const char *key, CFErrorRef *error) {
 396     int fd = xpc_dictionary_dup_fd(message, key);
 397     if (fd < 0)
 398         SecError(errSecParam, error, CFSTR("missing fd for key %s"), key);
 399
 400     return fd;
 401 }
 402
 403 CFSetRef SecXPCDictionaryCopySet(xpc_object_t message, const char *key, CFErrorRef *error) {
 404     CFTypeRef obj = SecXPCDictionaryCopyPList(message, key, error);
 405     CFSetRef set = copyIfSet(obj, error);
 406     if (obj && !set) {
 407         CFStringRef description = CFCopyTypeIDDescription(CFGetTypeID(obj));
 408         SecError(errSecParam, error, CFSTR("object for key %s not set but %@"), key, description);
 409         CFReleaseNull(description);
 410     }
 411     CFReleaseNull(obj);
 412     return set;
 413 }
 414
 415 CFArrayRef SecXPCDictionaryCopyArray(xpc_object_t message, const char *key, CFErrorRef *error) {
 416     CFTypeRef array = SecXPCDictionaryCopyPList(message, key, error);
 417     if (array) {
 418         CFTypeID type_id = CFGetTypeID(array);
 419         if (type_id != CFArrayGetTypeID()) {
 420             CFStringRef description = CFCopyTypeIDDescription(type_id);
 421             SecError(errSecParam, error, CFSTR("object for key %s not array but %@"), key, description);
 422             CFReleaseNull(description);
 423             CFReleaseNull(array);
 424         }
 425     }
 426     return (CFArrayRef)array;
 427 }
 428
 429 bool SecXPCDictionaryCopyArrayOptional(xpc_object_t message, const char *key, CFArrayRef *parray, CFErrorRef *error) {
 430     if (!xpc_dictionary_get_value(message, key)) {
 431         *parray = NULL;
 432         return true;
 433     }
 434     *parray = SecXPCDictionaryCopyArray(message, key, error);
 435     return *parray;
 436 }
 437
 438 CFDataRef SecXPCDictionaryCopyData(xpc_object_t message, const char *key, CFErrorRef *error) {
 439     CFDataRef data = NULL;
 440     size_t size = 0;
 441     const uint8_t *bytes = xpc_dictionary_get_data(message, key, &size);
 442     if (!bytes) {
 443         SecError(errSecParam, error, CFSTR("no data for key %s"), key);
 444         return NULL;
 445     }
 446
 447     data = CFDataCreate(kCFAllocatorDefault, bytes, size);
 448     if (!data)
 449         SecError(errSecParam, error, CFSTR("failed to create data for key %s"), key);
 450
 451     return data;
 452 }
 453
 454 bool SecXPCDictionaryGetBool(xpc_object_t message, const char *key, CFErrorRef *__unused error) {
 455     return xpc_dictionary_get_bool(message, key);
 456 }
 457
 458 bool SecXPCDictionaryGetDouble(xpc_object_t message, const char *key, double *pvalue, CFErrorRef *error) {
 459     *pvalue = xpc_dictionary_get_double(message, key);
 460     if (*pvalue == NAN) {
 461         return SecError(errSecParam, error, CFSTR("object for key %s bad double"), key);
 462     }
 463     return true;
 464 }
 465
 466 bool SecXPCDictionaryCopyDataOptional(xpc_object_t message, const char *key, CFDataRef *pdata, CFErrorRef *error) {
 467     size_t size = 0;
 468     if (!xpc_dictionary_get_data(message, key, &size)) {
 469         *pdata = NULL;
 470         return true;
 471     }
 472     *pdata = SecXPCDictionaryCopyData(message, key, error);
 473     return *pdata;
 474 }
 475
 476 bool SecXPCDictionaryCopyURLOptional(xpc_object_t message, const char *key, CFURLRef *purl, CFErrorRef *error) {
 477     size_t size = 0;
 478     if (!xpc_dictionary_get_data(message, key, &size)) {
 479         *purl = NULL;
 480         return true;
 481     }
 482     CFDataRef data = SecXPCDictionaryCopyData(message, key, error);
 483     if (data) {
 484         *purl = CFURLCreateWithBytes(kCFAllocatorDefault, CFDataGetBytePtr(data), CFDataGetLength(data), kCFStringEncodingUTF8, NULL);
 485     }
 486     CFReleaseNull(data);
 487     return *purl;
 488 }
 489
 490 CFDictionaryRef SecXPCDictionaryCopyDictionary(xpc_object_t message, const char *key, CFErrorRef *error) {
 491     CFTypeRef dict = SecXPCDictionaryCopyPList(message, key, error);
 492     if (dict) {
 493         CFTypeID type_id = CFGetTypeID(dict);
 494         if (type_id != CFDictionaryGetTypeID()) {
 495             CFStringRef description = CFCopyTypeIDDescription(type_id);
 496             SecError(errSecParam, error, CFSTR("object for key %s not dictionary but %@"), key, description);
 497             CFReleaseNull(description);
 498             CFReleaseNull(dict);
 499         }
 500     }
 501     return (CFDictionaryRef)dict;
 502 }
 503
 504 bool SecXPCDictionaryCopyDictionaryOptional(xpc_object_t message, const char *key, CFDictionaryRef *pdictionary, CFErrorRef *error) {
 505     if (!xpc_dictionary_get_value(message, key)) {
 506         *pdictionary = NULL;
 507         return true;
 508     }
 509     *pdictionary = SecXPCDictionaryCopyDictionary(message, key, error);
 510     return *pdictionary;
 511 }
 512
 513 CFTypeRef SecXPCDictionaryCopyPList(xpc_object_t message, const char *key, CFErrorRef *error)
 514 {
 515     CFTypeRef cfobject = NULL;
 516     size_t size = 0;
 517     const uint8_t *der = xpc_dictionary_get_data(message, key, &size);
 518     if (!der) {
 519         SecError(errSecParam, error, CFSTR("no object for key %s"), key);
 520         return NULL;
 521     }
 522
 523     const uint8_t *der_end = der + size;
 524     /* use the sensitive allocator so that the dictionary is zeroized upon deallocation */
 525     const uint8_t *decode_end = der_decode_plist(SecCFAllocatorZeroize(), kCFPropertyListImmutable,
 526                                           &cfobject, error, der, der_end);
 527     if (decode_end != der_end) {
 528         SecError(errSecParam, error, CFSTR("trailing garbage after der decoded object for key %s"), key);
 529         CFReleaseNull(cfobject);
 530     }
 531
 532     /* zeroize xpc value as it may have contained raw key material */
 533     cc_clear(size, (void *)der);
 534
 535     return cfobject;
 536 }
 537
 538 bool SecXPCDictionaryCopyPListOptional(xpc_object_t message, const char *key, CFTypeRef *pobject, CFErrorRef *error) {
 539     size_t size = 0;
 540     if (!xpc_dictionary_get_data(message, key, &size)) {
 541         *pobject = NULL;
 542         return true;
 543     }
 544     *pobject = SecXPCDictionaryCopyPList(message, key, error);
 545     return *pobject;
 546 }
 547
 548 CFStringRef SecXPCDictionaryCopyString(xpc_object_t message, const char *key, CFErrorRef *error) {
 549     const char *string = xpc_dictionary_get_string(message, key);
 550     if (string) {
 551         CFStringRef result = CFStringCreateWithCString(kCFAllocatorDefault, string, kCFStringEncodingUTF8);
 552         if (!result) {
 553             SecError(errSecAllocate, error, CFSTR("object for key %s failed to convert %s to CFString"), key, string);
 554         }
 555         return result;
 556     } else {
 557         SecError(errSecParam, error, CFSTR("object for key %s not string"), key);
 558         return NULL;
 559     }
 560 }
 561
 562 bool SecXPCDictionaryCopyStringOptional(xpc_object_t message, const char *key, CFStringRef *pstring, CFErrorRef *error) {
 563     if (!xpc_dictionary_get_value(message, key)) {
 564         *pstring = NULL;
 565         return true;
 566     }
 567     *pstring = SecXPCDictionaryCopyString(message, key, error);
 568     return *pstring;
 569 }
 570
 571 static CFDataRef CFDataCreateWithXPCArrayAtIndex(xpc_object_t xpc_data_array, size_t index, CFErrorRef *error) {
 572     CFDataRef data = NULL;
 573     size_t length = 0;
 574     const uint8_t *bytes = xpc_array_get_data(xpc_data_array, index, &length);
 575     if (bytes) {
 576         data = CFDataCreate(kCFAllocatorDefault, bytes, length);
 577     }
 578     if (!data)
 579         SecError(errSecParam, error, CFSTR("data_array[%zu] failed to decode"), index);
 580
 581     return data;
 582 }
 583
 584 static CFArrayRef CFDataXPCArrayCopyArray(xpc_object_t xpc_data_array, CFErrorRef *error) {
 585     CFMutableArrayRef data_array = NULL;
 586     require_action_quiet(xpc_get_type(xpc_data_array) == XPC_TYPE_ARRAY, exit,
 587                          SecError(errSecParam, error, CFSTR("data_array xpc value is not an array")));
 588     size_t count = xpc_array_get_count(xpc_data_array);
 589     require_action_quiet(data_array = CFArrayCreateMutable(kCFAllocatorDefault, count, &kCFTypeArrayCallBacks), exit,
 590                          SecError(errSecAllocate, error, CFSTR("failed to create CFArray of capacity %zu"), count));
 591
 592     size_t ix;
 593     for (ix = 0; ix < count; ++ix) {
 594         CFDataRef data = CFDataCreateWithXPCArrayAtIndex(xpc_data_array, ix, error);
 595         if (!data) {
 596             CFRelease(data_array);
 597             return NULL;
 598         }
 599         CFArraySetValueAtIndex(data_array, ix, data);
 600         CFRelease(data);
 601     }
 602
 603 exit:
 604     return data_array;
 605 }
 606
 607 bool SecXPCDictionaryCopyCFDataArrayOptional(xpc_object_t message, const char *key, CFArrayRef *data_array, CFErrorRef *error) {
 608     xpc_object_t xpc_data_array = xpc_dictionary_get_value(message, key);
 609     if (!xpc_data_array) {
 610         if (data_array)
 611             *data_array = NULL;
 612         return true;
 613     }
 614     *data_array = CFDataXPCArrayCopyArray(xpc_data_array, error);
 615     return *data_array != NULL;
 616 }