OSX/sec/SOSCircle/SecureObjectSync/SOSAccountDer.m

   1 /*
   2  * Copyright (c) 2013-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 "SOSAccountPriv.h"
  26 #include <Security/SecureObjectSync/SOSCircleDer.h>
  27
  28 //
  29 // DER Encoding utilities
  30 //
  31
  32 static const uint8_t* ccder_decode_null(const uint8_t* der, const uint8_t *der_end)
  33 {
  34     if (NULL == der)
  35         return NULL;
  36
  37     size_t payload_size = 0;
  38     const uint8_t *payload = ccder_decode_tl(CCDER_NULL, &payload_size, der, der_end);
  39
  40     if (NULL == payload || payload_size != 0) {
  41         return NULL;
  42     }
  43
  44     return payload + payload_size;
  45 }
  46
  47
  48 static size_t ccder_sizeof_null(void)
  49 {
  50     return ccder_sizeof(CCDER_NULL, 0);
  51 }
  52
  53
  54 static uint8_t* ccder_encode_null(const uint8_t *der, uint8_t *der_end)
  55 {
  56     return ccder_encode_tl(CCDER_NULL, 0, der, der_end);
  57 }
  58
  59
  60 //
  61 // Encodes data or a zero length data
  62 //
  63 size_t der_sizeof_fullpeer_or_null(SOSFullPeerInfoRef full_peer, CFErrorRef* error)
  64 {
  65     if (full_peer) {
  66         return SOSFullPeerInfoGetDEREncodedSize(full_peer, error);
  67     } else {
  68         return ccder_sizeof_null();
  69     }
  70 }
  71
  72 uint8_t* der_encode_fullpeer_or_null(SOSFullPeerInfoRef full_peer, CFErrorRef* error, const uint8_t* der, uint8_t* der_end)
  73 {
  74     if (full_peer) {
  75         return SOSFullPeerInfoEncodeToDER(full_peer, error, der, der_end);
  76     } else {
  77         return ccder_encode_null(der, der_end);
  78     }
  79 }
  80
  81
  82 const uint8_t* der_decode_fullpeer_or_null(CFAllocatorRef allocator, SOSFullPeerInfoRef* full_peer,
  83                                            CFErrorRef* error,
  84                                            const uint8_t* der, const uint8_t* der_end)
  85 {
  86     ccder_tag tag;
  87
  88     require_action_quiet(ccder_decode_tag(&tag, der, der_end), fail, der = NULL);
  89
  90     require_action_quiet(full_peer, fail, der = NULL);
  91
  92     if (tag == CCDER_NULL) {
  93         der = ccder_decode_null(der, der_end);
  94     } else  {
  95         *full_peer = SOSFullPeerInfoCreateFromDER(kCFAllocatorDefault, error, &der, der_end);
  96     }
  97
  98 fail:
  99     return der;
 100 }
 101
 102
 103 //
 104 // Mark: public_bytes encode/decode
 105 //
 106
 107 size_t der_sizeof_public_bytes(SecKeyRef publicKey, CFErrorRef* error)
 108 {
 109     CFDataRef publicData = NULL;
 110
 111     if (publicKey)
 112         SecKeyCopyPublicBytes(publicKey, &publicData);
 113
 114     size_t size = der_sizeof_data_or_null(publicData, error);
 115
 116     CFReleaseNull(publicData);
 117
 118     return size;
 119 }
 120
 121 uint8_t* der_encode_public_bytes(SecKeyRef publicKey, CFErrorRef* error, const uint8_t* der, uint8_t* der_end)
 122 {
 123     CFDataRef publicData = NULL;
 124
 125     if (publicKey)
 126         SecKeyCopyPublicBytes(publicKey, &publicData);
 127
 128     uint8_t *result = der_encode_data_or_null(publicData, error, der, der_end);
 129
 130     CFReleaseNull(publicData);
 131
 132     return result;
 133 }
 134
 135 const uint8_t* der_decode_public_bytes(CFAllocatorRef allocator, CFIndex algorithmID, SecKeyRef* publicKey, CFErrorRef* error, const uint8_t* der, const uint8_t* der_end)
 136 {
 137     CFDataRef dataFound = NULL;
 138     der = der_decode_data_or_null(allocator, &dataFound, error, der, der_end);
 139
 140     if (der && dataFound && publicKey) {
 141         *publicKey = SecKeyCreateFromPublicData(allocator, algorithmID, dataFound);
 142     }
 143     CFReleaseNull(dataFound);
 144
 145     return der;
 146 }
 147