]> git.saurik.com Git - apple/security.git/blob - keychain/SecureObjectSync/SOSMessage.c
projects / apple / security.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Security-59306.11.20.tar.gz
[apple/security.git] / keychain / SecureObjectSync / SOSMessage.c
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 /*
26 * SOSMessage.c - Creation and decoding of SOSMessage objects.
27 */
28
29 #include "keychain/SecureObjectSync/SOSMessage.h"
30
31 #include <AssertMacros.h>
32 #include <CoreFoundation/CoreFoundation.h>
33 #include "keychain/SecureObjectSync/SOSDigestVector.h"
34 #include "keychain/SecureObjectSync/SOSManifest.h"
35 #include "keychain/SecureObjectSync/SOSInternal.h"
36 #include <corecrypto/ccder.h>
37 #include <stdlib.h>
38 #include <stdbool.h>
39 #include <utilities/SecCFError.h>
40 #include <utilities/SecCFRelease.h>
41 #include <utilities/SecCFWrappers.h>
42 #include <utilities/array_size.h>
43 #include <utilities/der_date.h>
44 #include <utilities/der_plist.h>
45 #include <utilities/der_plist_internal.h>
46 #include <utilities/debugging.h>
47 #include <utilities/iCloudKeychainTrace.h>
48
49 // TODO: This is a layer violation, we need a better way to do this
50 // Currently it's only used for logging.
51 #include <securityd/SecItemDataSource.h>
52
53 #if defined(SOSMessageFormatSpecification) && 0
54
55 -- Secure Object Syncing Peer to Peer Message format ASN.1 definition
56 -- Everything MUST be DER encoded unless otherwise noted. These exceptions
57 -- Allow us to stream messages on a streamy network, without loading more
58 -- than one object into memory at once.
59
60 SOSMessage := SEQUENCE {
61 CHOICE {
62 v0 V0-MESSAGE-BODY-CLASS
63 v2 SOSV2MessageBody
64 }
65 }
66
67 -- v0 Message
68
69 V0-MESSAGE-BODY-CLASS ::= CLASS
70 {
71 &messageType INTEGER (manifestDigest, manifest, manifestDeltaAndObjects)
72 &version INTEGER OPTIONAL default v0
73 &Type
74 }
75 WITH SYNTAX {&Type IDENTIFIED BY &messageType}
76
77 ManifestDigest ::= OCTECT STRING (length 20)
78
79 Manifest ::= OCTECT STRING -- (length 20 * number of entries)
80
81 manifestDigestBody ::=
82 { ManifestDigest IDENTIFIED BY {manifestDigest}}
83
84 manifestBody ::=
85 { Manifest IDENTIFIED BY {manifest}}
86
87 manifestDeltaAndObjectsBody ::=
88 { ManifestDeltaAndObjects IDENTIFIED BY {manifestDeltaAndObjects}}
89
90 SOSV1MessageBody ::= MESSAGE-BODY-CLASS
91
92 ManifestDeltaAndObjects ::= SEQUENCE {
93 manfestDigest ManifestDigest
94 removals Manifest
95 additions Manifest
96 addedObjects SEQUENCE OF SOSObject
97 }
98
99 -- v2 Message
100
101 SOSMessageBody := {
102 -- top level SEQUENCE may be Constructed, indefinite-length BER encoded
103 header SOSMessageHeader,
104 deltas [0] IMPLICIT SOSManifestDeltas OPTIONAL,
105 extensions [1] IMPLICIT SOSExtensions OPTIONAL,
106 objects [2] IMPLICIT SEQUENCE OF SOSObject OPTIONAL
107 -- [2] IMPLICIT SEQUENCE OF SOSObject may be Constructed,
108 -- indefinite-length BER encoded -- }
109
110 SOSMessageHeader ::= SEQUENCE {
111 version [0] IMPLICIT SOSMessageVersion DEFAULT v2,
112 creationTime GeneralizedTime OPTIONAL,
113 -- When this message was created by the sender for tracking latency
114 sequenceNumber SOSSequenceNumber OPTIONAL,
115 -- Message Sequence Number for tracking packet loss in transport
116 digestTypes SOSDigestTypes OPTIONAL,
117 -- Determines the size and format of each SOSManifestDigest and the
118 -- elements of each SOSManifest.
119 -- We send the intersection our desired SOSDigestTypes and our peers
120 -- last received SOSDigestType. If we never received a message from our
121 -- peer we send our entire desired set and set the digestTypesProposed
122 -- messageFlag.
123 -- If the intersection is the empty set we fallback to sha1
124 -- Each digest and manifest entry is constructed by appending the
125 -- agreed upon digests in the order they are listed in the DER encoded
126 -- digestTypes.
127 messageFlags BIT STRING {
128 getObjects (0),
129 joinRequest (1),
130 partial (2),
131 digestTypesProposed (3),
132 -- This is a partial update and might not contain accurate manifest deltas (check this against spec --mb), only objects
133 clearGetObjects (4), -- WIP mb ignore
134 -- Stop sending me objects for this delta update, I will send you mine instead if you give me a full manifest delta
135 didClearGetObjectsSinceLastDelta (5) -- WIP mb ignore
136 -- clearGetObjects was set during this delta update, do not
137 -- set it again (STICKY until either peer clears delta) -- }
138 skipHello (6) -- Respond with at least a manifest
139 senderDigest SOSManifestDigest,
140 -- The senders manifest digest at the time of sending this message.
141 baseDigest [0] IMPLICIT SOSManifestDigest,
142 -- What this message is based on, if it contains deltas. If missing we assume the empty set
143 proposedDigest [1] IMPLICIT SOSManifestDigest,
144 -- What the receiver should have after patching baseDigest with
145 -- additions and removals -- }
146
147 SOSMessageVersion ::= INTEGER { v0(0), v2(2), v3(3) }
148
149 SOSSequenceNumber ::= INTEGER
150
151 -- Note this is not implemented in v2 it only supports sha1
152 SOSDigestTypes ::= SEQUENCE {
153 messageFlags BIT STRING {
154 sha1(0) -- implied if SOSDigestTypes is not present
155 sha224(1)
156 sha256(2)
157 sha384(3)
158 sha512(4)
159 digestAlgorithms SET OF AlgorithmIdentifier
160 -- Same as AlgorithmIdentifier from X.509 -- } }
161
162 SOSManifestDeltas ::= SEQUENCE {
163 removals SOSManifest
164 additions SOSManifest }
165
166 SOSExtensions ::= SEQUENCE SIZE (1..MAX) OF SOSExtension
167
168 SOSExtension ::= SEQUENCE {
169 extnID OBJECT IDENTIFIER,
170 critical BOOLEAN DEFAULT FALSE,
171 extnValue OCTET STRING }
172
173 SOSManifest ::= OCTET STRING
174 -- DER encoding is sorted and ready to merge.
175 -- All SOSDigest entries in a SOSManifest /must/ be the same size
176 -- As the negotiated SOSManifestEntry. Se comment in SOSMessageBody
177 -- on digestTypes
178
179 SOSManifestDigest ::= OCTET STRING
180
181 SOSObject ::= SEQUENCE {
182 [0] conflict OCTECT STRING OPTIONAL
183 [1] change OCTECT STRING OPTIONAL
184 object SecDictionary }
185
186 SecDictionary ::= SET of SecKVPair
187
188 SecKVPair ::= SEQUENCE {
189 key UTF8String
190 value Value }
191
192 SecValue ::= CHOICE {
193 bool Boolean
194 number INTEGER
195 string UTF8String
196 data OCTECT STRING
197 date GENERAL TIME
198 dictionary Object
199 array Array }
200
201 SecArray ::= SEQUENCE of SecValue
202
203 -- For reference:
204 AlgorithmIdentifier ::= SEQUENCE {
205 algorithm OBJECT IDENTIFIER,
206 parameters ANY DEFINED BY algorithm OPTIONAL }
207 -- contains a value of the type
208 -- registered for use with the
209 -- algorithm object identifier value
210
211 #endif // defined(SOSMessageFormatSpecification) && 0
212
213
214 #if 0
215 static inline bool SecMallocOk(const void *ptr) {
216 if (ptr) return true;
217
218 return false;
219 }
220 #endif
221 #if 0
222 static void appendObjects(CFMutableStringRef desc, CFArrayRef objects) {
223 __block bool needComma = false;
224 CFArrayForEach(objects, ^(const void *value) {
225 if (needComma)
226 CFStringAppend(desc, CFSTR(","));
227 else
228 needComma = true;
229
230 SecItemServerAppendItemDescription(desc, value);
231 });
232 }
233 #endif
234
235
236
237 //
238 // MARK: SOSMessage implementation.
239 //
240
241 // Legacy v1 message type numbers
242 enum SOSMessageType {
243 SOSManifestInvalidMessageType = 0,
244 SOSManifestDigestMessageType = 1,
245 SOSManifestMessageType = 2,
246 SOSManifestDeltaAndObjectsMessageType = 3,
247 };
248
249 struct __OpaqueSOSMessage {
250 CFRuntimeBase _base;
251
252 CFDataRef der;
253 const uint8_t *objectsDer;
254 size_t objectsLen;
255
256 CFDataRef senderDigest;
257 CFDataRef baseDigest;
258 CFDataRef proposedDigest;
259 SOSManifestRef removals;
260 SOSManifestRef additions;
261
262 CFMutableArrayRef objects;
263
264 SOSMessageFlags flags;
265 uint64_t sequenceNumber;
266 CFAbsoluteTime creationTime;
267 uint64_t version; // Message version (currently always 2)
268 bool indefiniteLength; // If set to true the top SEQUENCE and the OBJECTS SEQUENCE are written indefinite length.
269 };
270
271 CFGiblisWithCompareFor(SOSMessage)
272
273 static Boolean SOSMessageCompare(CFTypeRef cf1, CFTypeRef cf2) {
274 SOSMessageRef M = (SOSMessageRef)cf1;
275 SOSMessageRef P = (SOSMessageRef)cf2;
276 if (M->flags != P->flags) return false;
277 if (M->sequenceNumber != P->sequenceNumber) return false;
278 if (M->creationTime != P->creationTime) return false;
279 //if (!CFEqualSafe(M->der, P->der)) return false;
280 if (!CFEqualSafe(M->senderDigest, P->senderDigest)) return false;
281 if (!CFEqualSafe(M->baseDigest, P->baseDigest)) return false;
282 if (!CFEqualSafe(M->proposedDigest, P->proposedDigest)) return false;
283 if (!CFEqualSafe(M->removals, P->removals)) return false;
284 if (!CFEqualSafe(M->additions, P->additions)) return false;
285
286 // TODO Compare Objects if present.
287
288 return true;
289 }
290
291 static void SOSMessageDestroy(CFTypeRef cf) {
292 SOSMessageRef message = (SOSMessageRef)cf;
293 CFReleaseNull(message->der);
294 CFReleaseNull(message->senderDigest);
295 CFReleaseNull(message->baseDigest);
296 CFReleaseNull(message->proposedDigest);
297 CFReleaseNull(message->additions);
298 CFReleaseNull(message->removals);
299 CFReleaseNull(message->objects);
300 }
301
302 // TODO: Remove this layer violation!
303 #include <securityd/SecItemServer.h>
304
305 static uint64_t SOSMessageInferType(SOSMessageRef message, CFErrorRef *error);
306
307 static CFStringRef SOSMessageCopyFormatDescription(CFTypeRef cf, CFDictionaryRef formatOptions) {
308 SOSMessageRef message = (SOSMessageRef)cf;
309 static const uint8_t zero[4] = {};
310 const uint8_t *S = message->senderDigest ? CFDataGetBytePtr(message->senderDigest) : zero;
311 const uint8_t *B = message->baseDigest ? CFDataGetBytePtr(message->baseDigest) : zero;
312 const uint8_t *P = message->proposedDigest ? CFDataGetBytePtr(message->proposedDigest) : zero;
313 CFDateRef creationDate = CFDateCreate(CFGetAllocator(message), message->creationTime);
314
315 CFMutableStringRef objects = CFStringCreateMutable(kCFAllocatorDefault, 0);
316
317 // TODO: Remove this layer violation!
318 SOSDataSourceFactoryRef dsf = SecItemDataSourceFactoryGetDefault();
319 SOSDataSourceRef ds = SOSDataSourceFactoryCreateDataSource(dsf, kSecAttrAccessibleWhenUnlocked, NULL);
320
321 if (ds) {
322 __block size_t maxEntries = 16;
323 CFStringAppendFormat(objects, NULL, CFSTR("{[%zu]"), SOSMessageCountObjects(message));
324 SOSMessageWithSOSObjects(message, ds, NULL, ^(SOSObjectRef object, bool *stop) {
325 CFDataRef digest = SOSObjectCopyDigest(ds, object, NULL);
326 const uint8_t *O = CFDataGetBytePtr(digest);
327 CFStringAppendFormat(objects, NULL, CFSTR(" %02X%02X%02X%02X"), O[0],O[1],O[2],O[3]);
328 CFReleaseSafe(digest);
329 if (!--maxEntries) {
330 CFStringAppend(objects, CFSTR("..."));
331 *stop = true;
332 }
333 });
334 CFStringAppend(objects, CFSTR("}"));
335 } else {
336 CFStringAppend(objects, CFSTR("{NO DATASOURCE}"));
337 }
338
339 CFStringRef desc = NULL;
340 if (message->version == 0) {
341 switch (SOSMessageInferType(message, NULL)) {
342 case SOSManifestInvalidMessageType:
343 desc = CFStringCreateWithFormat(CFGetAllocator(message), NULL, CFSTR("<MSGInvalid %"PRIu64" >"), message->sequenceNumber);
344 break;
345 case SOSManifestDigestMessageType:
346 desc = CFStringCreateWithFormat(CFGetAllocator(message), NULL, CFSTR("<MSGDigest %"PRIu64" %02X%02X%02X%02X>"), message->sequenceNumber, S[0],S[1],S[2],S[3]);
347 break;
348 case SOSManifestMessageType:
349 desc = CFStringCreateWithFormat(CFGetAllocator(message), NULL, CFSTR("<MSGManifest %"PRIu64" %@>"), message->sequenceNumber, message->additions);
350 break;
351 case SOSManifestDeltaAndObjectsMessageType:
352 desc = CFStringCreateWithFormat(CFGetAllocator(message), NULL, CFSTR("<MSGObjects %"PRIu64" %02X%02X%02X%02X %@ %@ %@"),
353 message->sequenceNumber,
354 B[0],B[1],B[2],B[3],
355 message->removals, message->additions,
356 objects);
357 break;
358 }
359 } else {
360 desc = CFStringCreateWithFormat
361 (CFGetAllocator(message), NULL, CFSTR("<MSG %"PRIu64" %@ %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %@ %@ %@ %s%s%s%s%s%s%s>"),
362 message->sequenceNumber,
363 creationDate,
364 S[0],S[1],S[2],S[3],
365 B[0],B[1],B[2],B[3],
366 P[0],P[1],P[2],P[3],
367 message->removals, message->additions,
368 objects,
369 (message->flags & kSOSMessageGetObjects) ? "G" : "g",
370 (message->flags & kSOSMessageJoinRequest) ? "J" : "j",
371 (message->flags & kSOSMessagePartial) ? "P" : "p",
372 (message->flags & kSOSMessageDigestTypesProposed) ? "D" : "d",
373 (message->flags & kSOSMessageClearGetObjects) ? "K" : "k",
374 (message->flags & kSOSMessageDidClearGetObjectsSinceLastDelta) ? "Z" : "z",
375 (message->flags & kSOSMessageSkipHello) ? "H" : "h");
376 }
377 CFReleaseSafe(creationDate);
378 CFReleaseSafe(objects);
379 return desc;
380 }
381
382 //
383 // MARK: SOSMessage encoding
384 //
385
386 // Create an SOSMessage ready to be encoded.
387 SOSMessageRef SOSMessageCreate(CFAllocatorRef allocator, uint64_t version, CFErrorRef *error) {
388 SOSMessageRef message = CFTypeAllocate(SOSMessage, struct __OpaqueSOSMessage, allocator);
389 message->version = version;
390 return message;
391 }
392
393 // TODO: Remove me this is for testing only, tests should use the real thing.
394 SOSMessageRef SOSMessageCreateWithManifests(CFAllocatorRef allocator, SOSManifestRef sender,
395 SOSManifestRef base, SOSManifestRef proposed,
396 bool includeManifestDeltas, CFErrorRef *error) {
397 SOSMessageRef message = SOSMessageCreate(allocator, kEngineMessageProtocolVersion, error);
398 if (!SOSMessageSetManifests(message, sender, base, proposed, includeManifestDeltas, NULL, error))
399 CFReleaseNull(message);
400 return message;
401 }
402
403 bool SOSMessageSetManifests(SOSMessageRef message, SOSManifestRef sender,
404 SOSManifestRef base, SOSManifestRef proposed,
405 bool includeManifestDeltas, SOSManifestRef objectsSent,
406 CFErrorRef *error) {
407 if (!message) return true;
408 bool ok = true;
409 // TODO: Check at v2 encoding time
410 // if (!sender) return (SOSMessageRef)SOSErrorCreate(kSOSErrorProcessingFailure, error, NULL, CFSTR("no sender manifest specified for SOSMessage"));
411 message->baseDigest = CFRetainSafe(SOSManifestGetDigest(base, NULL));
412 secinfo("engine", "SOSMessageSetManifests: setting base digest to %@ %zu", message->baseDigest, SOSManifestGetCount(base));
413 message->proposedDigest = CFRetainSafe(SOSManifestGetDigest(proposed, NULL));
414 secinfo("engine", "SOSMessageSetManifests: setting proposed digest to %@ %zu", message->proposedDigest, SOSManifestGetCount(proposed));
415 message->senderDigest = CFRetainSafe(SOSManifestGetDigest(sender, NULL));
416 secinfo("engine", "SOSMessageSetManifests: setting sender digest to %@ %zu", message->senderDigest, SOSManifestGetCount(sender));
417
418 if (includeManifestDeltas) {
419 SOSManifestRef additions = NULL;
420 ok = SOSManifestDiff(base, proposed, &message->removals, &additions, error);
421 if (message->version == 0) {
422 message->additions = additions;
423 } else {
424 message->additions = SOSManifestCreateComplement(objectsSent, additions, error);
425 CFReleaseSafe(additions);
426 }
427 }
428 return ok;
429 }
430
431 void SOSMessageSetFlags(SOSMessageRef message, SOSMessageFlags flags) {
432 message->flags = flags;
433 }
434
435 // Add an extension to this message
436 void SOSMessageAddExtension(SOSMessageRef message, CFDataRef oid, bool isCritical, CFDataRef extension) {
437 // TODO: Implement
438 secerror("not implemented yet!");
439 }
440
441 static bool SecMessageIsObjectValid(CFDataRef object, CFErrorRef *error) {
442 const uint8_t *der = CFDataGetBytePtr(object);
443 const uint8_t *der_end = der + CFDataGetLength(object);
444 ccder_tag tag = 0;
445 size_t len = 0;
446 der = ccder_decode_tag(&tag, der, der_end);
447 if (!der )
448 return SOSErrorCreate(kSOSErrorBadFormat, error, NULL, CFSTR("Invalid DER, no tag found"));
449 if (tag == CCDER_EOL)
450 return SOSErrorCreate(kSOSErrorBadFormat, error, NULL, CFSTR("Object has EOL tag"));
451 der = ccder_decode_len(&len, der, der_end);
452 if (!der)
453 return SOSErrorCreate(kSOSErrorBadFormat, error, NULL, CFSTR("Object with tag %lu has no valid DER length"), tag);
454 der += len;
455 if (der_end - der)
456 return SOSErrorCreate(kSOSErrorBadFormat, error, NULL, CFSTR("Object has %td trailing unused bytes"), der_end - der);
457 return true;
458 }
459
460 bool SOSMessageAppendObject(SOSMessageRef message, CFDataRef object, CFErrorRef *error) {
461 if (!SecMessageIsObjectValid(object, error)) return false;
462 if (!message->objects)
463 message->objects = CFArrayCreateMutableForCFTypes(CFGetAllocator(message));
464 if (message->objects)
465 CFArrayAppendValue(message->objects, object);
466 return true;
467 }
468
469 static CC_NONNULL_ALL
470 size_t ccder_sizeof_bit_string(cc_size n, const cc_unit *s) {
471 return ccder_sizeof(CCDER_BIT_STRING, ccn_sizeof(ccn_bitlen(n, s)) + 1);
472 }
473
474 static CC_NONNULL_ALL
475 uint8_t *ccder_encode_bit_string(cc_size n, const cc_unit *s, const uint8_t *der, uint8_t *der_end) {
476 size_t bits = ccn_bitlen(n, s);
477 size_t out_size = ccn_sizeof(bits) + 1;
478 der_end = ccder_encode_body_nocopy(out_size, der, der_end);
479 if (der_end)
480 ccn_write_uint_padded(n, s, out_size, der_end);
481 return ccder_encode_tl(CCDER_BIT_STRING, out_size, der, der_end);
482 }
483
484
485 static
486 size_t der_sizeof_implicit_data(ccder_tag tag, CFDataRef data) {
487 if (!data)
488 return 0;
489 return ccder_sizeof_implicit_raw_octet_string(tag, CFDataGetLength(data));
490 }
491
492
493 static CC_NONNULL((3, 4))
494 uint8_t *der_encode_implicit_data(ccder_tag tag, CFDataRef data, const uint8_t *der, uint8_t *der_end) {
495 if (!data)
496 return der_end;
497 return ccder_encode_implicit_raw_octet_string(tag, CFDataGetLength(data), CFDataGetBytePtr(data), der, der_end);
498 }
499
500 static size_t der_sizeof_message_header(SOSMessageRef message, CFErrorRef *error) {
501 if (!message->senderDigest) {
502 // TODO: Create Error.
503 return 0;
504 }
505 cc_unit flags[1];
506 flags[0] = (cc_unit)message->flags; // TODO Fix cast or something
507
508 return ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE,
509 der_sizeof_generalizedtime(message->creationTime, error) +
510 ccder_sizeof_uint64(message->sequenceNumber) +
511 ccder_sizeof_bit_string(array_size(flags), flags) +
512 der_sizeof_implicit_data(CCDER_OCTET_STRING, message->senderDigest) +
513 der_sizeof_implicit_data(0 | CCDER_CONTEXT_SPECIFIC, message->baseDigest) +
514 der_sizeof_implicit_data(1 | CCDER_CONTEXT_SPECIFIC, message->proposedDigest));
515 }
516
517 static uint8_t *der_encode_message_header(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
518 if (!message->senderDigest) {
519 // TODO: Create Error.
520 return NULL;
521 }
522 cc_unit flags[1];
523 flags[0] = (cc_unit)message->flags; // TODO Fix cast or something
524 return ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
525 der_encode_generalizedtime(message->creationTime, error, der,
526 ccder_encode_uint64(message->sequenceNumber, der,
527 ccder_encode_bit_string(array_size(flags), flags, der,
528 der_encode_implicit_data(CCDER_OCTET_STRING, message->senderDigest, der,
529 der_encode_implicit_data(0 | CCDER_CONTEXT_SPECIFIC, message->baseDigest, der,
530 der_encode_implicit_data(1 | CCDER_CONTEXT_SPECIFIC, message->proposedDigest, der, der_end)))))));
531 }
532
533 static size_t der_sizeof_deltas(SOSMessageRef message) {
534 if (!message->additions && !message->removals) return 0;
535 if (message->version == 0) {
536 return ccder_sizeof(CCDER_OCTET_STRING, SOSManifestGetSize(message->removals))+
537 ccder_sizeof(CCDER_OCTET_STRING, SOSManifestGetSize(message->additions));
538 } else {
539 return ccder_sizeof(0 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED,
540 ccder_sizeof(CCDER_OCTET_STRING, SOSManifestGetSize(message->removals))+
541 ccder_sizeof(CCDER_OCTET_STRING, SOSManifestGetSize(message->additions)));
542 }
543 }
544
545 static uint8_t *der_encode_deltas(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
546 if (!message->additions && !message->removals) return der_end;
547 if (message->version == 0) {
548 return der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->removals), der,
549 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions), der, der_end));
550 } else {
551 return ccder_encode_constructed_tl(0 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED, der_end, der,
552 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->removals), der,
553 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions), der, der_end)));
554 }
555 }
556
557 static size_t der_sizeof_extensions(SOSMessageRef message) {
558 // We don't support any yet.
559 return 0;
560 }
561
562 static uint8_t *der_encode_extensions(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
563 // We don't support any yet.
564 return der_end;
565 }
566
567 static size_t der_sizeof_objects(SOSMessageRef message) {
568 size_t len = 0;
569 if (message->objects) {
570 CFDataRef data;
571 CFArrayForEachC(message->objects, data) {
572 len += (size_t)CFDataGetLength(data);
573 }
574 } else if (message->version != 0)
575 return 0;
576
577 if (message->indefiniteLength)
578 return len + 4;
579 else
580 return ccder_sizeof(2 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED, len);
581 }
582
583 static uint8_t *der_encode_objects(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
584 if (!message->objects && message->version != 0) return der_end;
585 const uint8_t *original_der_end = der_end;
586 if (message->indefiniteLength)
587 der_end = ccder_encode_tl(CCDER_EOL, 0, der, der_end);
588
589 for (CFIndex position = (message->objects ? CFArrayGetCount(message->objects) : 0) - 1; position >= 0; --position) {
590 CFDataRef object = CFArrayGetValueAtIndex(message->objects, position);
591 der_end = ccder_encode_body(CFDataGetLength(object), CFDataGetBytePtr(object), der, der_end);
592 }
593 if (message->indefiniteLength) {
594 return ccder_encode_tag(2 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED, der,
595 ccder_encode_len(0, der, der_end));
596 } else {
597 ccder_tag otag = message->version == 0 ? CCDER_CONSTRUCTED_SEQUENCE : 2 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED;
598 return ccder_encode_constructed_tl(otag, original_der_end, der, der_end);
599 }
600 }
601
602 static size_t der_sizeof_v2_message(SOSMessageRef message, CFErrorRef *error) {
603 size_t body_size = (der_sizeof_message_header(message, error) +
604 der_sizeof_deltas(message) +
605 der_sizeof_extensions(message) +
606 der_sizeof_objects(message));
607 if (message->indefiniteLength)
608 return body_size + 4;
609 else
610 return ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE, body_size);
611 }
612
613
614 static uint8_t *der_encode_v2_message(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
615 const uint8_t *original_der_end = der_end;
616 if (message->indefiniteLength)
617 der_end = ccder_encode_tl(CCDER_EOL, 0, der, der_end);
618
619 der_end = der_encode_message_header(message, error, der,
620 der_encode_deltas(message, error, der,
621 der_encode_extensions(message, error, der,
622 der_encode_objects(message, error, der, der_end))));
623
624 if (message->indefiniteLength) {
625 return ccder_encode_tag(CCDER_CONSTRUCTED_SEQUENCE, der,
626 ccder_encode_len(0, der, der_end));
627 } else {
628 return ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, original_der_end, der, der_end);
629 }
630 }
631
632 //------------------------------------------------------------------------------------------------------------------------------------
633 // V1 support
634 //------------------------------------------------------------------------------------------------------------------------------------
635
636 /* ManifestDigest message */
637 static size_t der_sizeof_manifest_digest_message(SOSMessageRef message, CFErrorRef *error) {
638 if (!message->senderDigest || CFDataGetLength(message->senderDigest) != SOSDigestSize) {
639 SOSErrorCreate(kSOSErrorProcessingFailure, error, NULL, CFSTR("digest length mismatch"));
640 return 0;
641 }
642 return ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE,
643 (ccder_sizeof_uint64(SOSManifestDigestMessageType) +
644 ccder_sizeof_raw_octet_string(SOSDigestSize)));
645 }
646
647 static uint8_t *der_encode_manifest_digest_message(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
648 secinfo("engine", "der_encode_manifest_digest_message: encoded sender digest as %@", message->senderDigest);
649 return ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
650 ccder_encode_uint64(SOSManifestDigestMessageType, der,
651 ccder_encode_raw_octet_string(SOSDigestSize, CFDataGetBytePtr(message->senderDigest), der, der_end)));
652 }
653
654 /* Manifest message */
655 static size_t der_sizeof_manifest_message(SOSMessageRef message, CFErrorRef *error) {
656 if (!message->additions) {
657 SOSErrorCreate(kSOSErrorProcessingFailure, error, NULL, CFSTR("no manifest for manifest message"));
658 return 0;
659 }
660 return ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE,
661 (ccder_sizeof_uint64(SOSManifestMessageType) +
662 der_sizeof_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions))));
663 }
664
665 static uint8_t *der_encode_manifest_message(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
666 secinfo("engine", "der_encode_manifest_message: encoded message additions as (%zu, %@)", SOSManifestGetCount(message->additions), SOSManifestGetDigest(message->additions, NULL));
667 return ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
668 ccder_encode_uint64(SOSManifestMessageType, der,
669 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions), der, der_end)));
670 }
671
672 /* ManifestDeltaAndObjects message */
673 static size_t der_sizeof_manifest_and_objects_message(SOSMessageRef message, CFErrorRef *error) {
674 if (!message->baseDigest || CFDataGetLength(message->baseDigest) != SOSDigestSize) {
675 SOSErrorCreate(kSOSErrorProcessingFailure, error, NULL, CFSTR("digest length mismatch"));
676 return 0;
677 }
678
679 return ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE,
680 (ccder_sizeof_uint64(SOSManifestDeltaAndObjectsMessageType) +
681 ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE,
682 (ccder_sizeof_raw_octet_string(SOSDigestSize) +
683 der_sizeof_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->removals)) +
684 der_sizeof_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions)) +
685 der_sizeof_objects(message)))));
686 }
687
688 static uint8_t *der_encode_manifest_and_objects_message(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
689 secinfo("engine", "der_encode_manifest_and_objects_message: encoded base digest as %@", message->baseDigest);
690 return ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
691 ccder_encode_uint64(SOSManifestDeltaAndObjectsMessageType, der,
692 ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
693 ccder_encode_raw_octet_string(SOSDigestSize, CFDataGetBytePtr(message->baseDigest), der,
694 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->removals), der,
695 der_encode_implicit_data(CCDER_OCTET_STRING, SOSManifestGetData(message->additions), der,
696 der_encode_objects(message, error, der, der_end)))))));
697 }
698
699 static uint64_t SOSMessageInferType(SOSMessageRef message, CFErrorRef *error) {
700 if (message->baseDigest) {
701 // TODO: Assert that we don't have senderDigest or proposedDigest
702 if (SOSManifestGetCount(message->removals) || SOSManifestGetCount(message->additions) || SOSMessageCountObjects(message)) {
703 return SOSManifestDeltaAndObjectsMessageType;
704 } else {
705 // NOTE: If we force a SOSManifestDeltaAndObjectsMessageType instead then
706 // true v0 peers will overwrite their last objects message to us. However this
707 // implements the current v0 behaviour
708 return SOSManifestDigestMessageType;
709 }
710 } else if (message->additions) {
711 // TODO: Assert that we don't have senderDigest, proposedDigest, additions, removals or objects
712 return SOSManifestMessageType;
713 } else if (message->senderDigest) {
714 // TODO: Assert that we don't have proposedDigest, removals or objects
715 return SOSManifestDigestMessageType;
716 }
717 // TODO: Create error.
718 return SOSManifestInvalidMessageType;
719 }
720
721 static size_t der_sizeof_message(SOSMessageRef message, uint64_t messageType, CFErrorRef *error) {
722 switch (messageType) {
723 case SOSManifestInvalidMessageType:
724 return der_sizeof_v2_message(message, error);
725 case SOSManifestDigestMessageType:
726 return der_sizeof_manifest_digest_message(message, error);
727 case SOSManifestMessageType:
728 return der_sizeof_manifest_message(message, error);
729 case SOSManifestDeltaAndObjectsMessageType:
730 return der_sizeof_manifest_and_objects_message(message, error);
731 }
732 return 0;
733 }
734
735 static uint8_t *der_encode_message(SOSMessageRef message, uint64_t messageType, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) {
736 switch (messageType) {
737 case SOSManifestInvalidMessageType:
738 return der_encode_v2_message(message, error, der, der_end);
739 case SOSManifestDigestMessageType:
740 return der_encode_manifest_digest_message(message, error, der, der_end);
741 case SOSManifestMessageType:
742 return der_encode_manifest_message(message, error, der, der_end);
743 case SOSManifestDeltaAndObjectsMessageType:
744 return der_encode_manifest_and_objects_message(message, error, der, der_end);
745 }
746 return der_end;
747 }
748
749 // Encode an SOSMessage, calls addObject callback and appends returned objects
750 // one by one, until addObject returns NULL.
751 CFDataRef SOSMessageCreateData(SOSMessageRef message, uint64_t sequenceNumber, CFErrorRef *error) {
752 // Version 2 message have sequence numbers, version 0 messages do not.
753 uint64_t messageType = SOSManifestInvalidMessageType;
754 message->sequenceNumber = sequenceNumber;
755 if (message->version == 0) {
756 message->indefiniteLength = false;
757 messageType = SOSMessageInferType(message, error);
758 if (!messageType) {
759 // Propagate error
760 return NULL;
761 }
762 } else {
763 message->creationTime = floor(CFAbsoluteTimeGetCurrent());
764 }
765 size_t der_size = der_sizeof_message(message, messageType, error);
766 CFMutableDataRef data = CFDataCreateMutable(NULL, der_size);
767 if (data == NULL) {
768 // TODO Error.
769 return NULL;
770 }
771 CFDataSetLength(data, der_size);
772 uint8_t *der_end = CFDataGetMutableBytePtr(data);
773 const uint8_t *der = der_end;
774 der_end += der_size;
775
776 der_end = der_encode_message(message, messageType, error, der, der_end);
777 if (der != der_end) {
778 secwarning("internal error %td bytes unused in der buffer", der_end - der);
779 }
780 return data;
781 }
782
783 //
784 // MARK: SOSMessage decoding
785 //
786
787 #define CCBER_LEN_INDEFINITE ((size_t)-1)
788
789 // Decode BER length field. Sets *lenp to ccber_indefinite_len if this is an indefinite length encoded object.
790 // Behaves like ccder_decode_len in every other way.
791 static CC_NONNULL((1, 3))
792 const uint8_t *ccber_decode_len(size_t *lenp, const uint8_t *der, const uint8_t *der_end) {
793 if (der && der < der_end) {
794 if (*der == 0x80) {
795 der++;
796 *lenp = CCBER_LEN_INDEFINITE;
797 }
798 else
799 der = ccder_decode_len(lenp, der, der_end);
800 }
801 return der;
802 }
803
804 static const uint8_t *der_decode_generalizedtime(CFAbsoluteTime *at, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
805 const uint8_t *times_end = NULL;
806 der = ccder_decode_constructed_tl(CCDER_GENERALIZED_TIME, &times_end, der, der_end);
807 der = der_decode_generalizedtime_body(at, error, der, times_end);
808 if (times_end != der) {
809 secwarning("internal error %td bytes unused in generalizedtime DER buffer", times_end - der);
810 }
811 return der;
812 }
813
814 static const uint8_t *der_decode_optional_generalizedtime(CFAbsoluteTime *at, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
815 const uint8_t *times_end = der_decode_generalizedtime(at, error, der, der_end);
816 return times_end ? times_end : der;
817 }
818
819 static CC_NONNULL((2, 4))
820 const uint8_t *ccder_decode_implicit_uint64(ccder_tag expected_tag, uint64_t* r, const uint8_t *der, const uint8_t *der_end) {
821 size_t len;
822 der = ccder_decode_tl(expected_tag, &len, der, der_end);
823 if (der && len && (*der & 0x80) != 0x80) {
824 if (ccn_read_uint(ccn_nof_size(sizeof(*r)), (cc_unit*)r, len, der) >= 0)
825 return der + len;
826 }
827 return NULL;
828 }
829
830 static const uint8_t *ccder_decode_optional_implicit_uint64(ccder_tag expected_tag, uint64_t *value, const uint8_t *der, const uint8_t *der_end) {
831 const uint8_t *ui64_end = ccder_decode_implicit_uint64(expected_tag, value, der, der_end);
832 return ui64_end ? ui64_end : der;
833 }
834
835
836 static const uint8_t *ccder_decode_optional_uint64(uint64_t *value, const uint8_t *der, const uint8_t *der_end) {
837 const uint8_t *ui64_end = ccder_decode_uint64(value, der, der_end);
838 return ui64_end ? ui64_end : der;
839 }
840
841 static const uint8_t *ccder_decode_digest_types(SOSMessageRef message, const uint8_t *der, const uint8_t *der_end) {
842 const uint8_t *dt_end;
843 der = ccder_decode_sequence_tl(&dt_end, der, der_end);
844 if (!der) return NULL;
845 // Skip over digestType body for now.
846 // TODO: Support DigestType
847 return dt_end;
848 }
849
850 static const uint8_t *ccder_decode_optional_digest_types(SOSMessageRef message, const uint8_t *der, const uint8_t *der_end) {
851 const uint8_t *dt_end = ccder_decode_digest_types(message, der, der_end);
852 return dt_end ? dt_end : der;
853 }
854
855 static const uint8_t *ccder_decode_bit_string(cc_size n, size_t *r_bitlen, cc_unit *r, const uint8_t *der, const uint8_t *der_end) {
856 size_t len;
857 const uint8_t *body = ccder_decode_tl(CCDER_BIT_STRING, &len, der, der_end);
858 if (!body || len < 1)
859 return NULL;
860
861 if (r_bitlen) *r_bitlen = (len - 1) * 8 - (body[0] & 7);
862 ccn_read_uint(1, r, len - 1, body + 1);
863 return body + len;
864 }
865
866 static const uint8_t *der_decode_implicit_data(ccder_tag expected_tag, CFDataRef *data, const uint8_t *der, const uint8_t *der_end) {
867 size_t len = 0;
868 der = ccder_decode_tl(expected_tag, &len, der, der_end);
869 if (der && data) {
870 *data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, der, len, kCFAllocatorNull);
871 if (*data)
872 der += len;
873 else
874 der = NULL;
875 }
876 return der;
877 }
878
879 static const uint8_t *der_decode_optional_implicit_data(ccder_tag expected_tag, CFDataRef *data, const uint8_t *der, const uint8_t *der_end) {
880 const uint8_t *data_end = der_decode_implicit_data(expected_tag, data, der, der_end);
881 return data_end ? data_end : der;
882 }
883
884 static const uint8_t *der_decode_deltas_body(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
885 CFDataRef removals = NULL, additions = NULL;
886 der = der_decode_implicit_data(CCDER_OCTET_STRING, &removals, der, der_end);
887 der = der_decode_implicit_data(CCDER_OCTET_STRING, &additions, der, der_end);
888 if (der) {
889 message->removals = SOSManifestCreateWithData(removals, error);
890 message->additions = SOSManifestCreateWithData(additions, error);
891 if (!message->removals || !message->additions) {
892 CFReleaseNull(message->removals);
893 CFReleaseNull(message->additions);
894 der = NULL;
895 }
896 }
897 CFReleaseSafe(removals);
898 CFReleaseSafe(additions);
899
900 return der;
901 }
902
903 static const uint8_t *der_decode_deltas(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
904 const uint8_t *deltas_end = NULL;
905 der = ccder_decode_constructed_tl(0 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED, &deltas_end, der, der_end);
906 return der_decode_deltas_body(message, error, der, deltas_end);
907 }
908
909 static const uint8_t *der_decode_optional_deltas(SOSMessageRef message, const uint8_t *der, const uint8_t *der_end) {
910 const uint8_t *seq_end = der_decode_deltas(message, NULL, der, der_end);
911 return seq_end ? seq_end : der;
912 }
913
914 static const uint8_t *der_decode_extensions(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
915 const uint8_t *extensions_end;
916 der = ccder_decode_constructed_tl(1 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED, &extensions_end, der, der_end);
917 if (!der) return NULL;
918 // Skip over extensions for now.
919 return extensions_end;
920 }
921
922 static const uint8_t *der_decode_optional_extensions(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
923 const uint8_t *extensions_end = der_decode_extensions(message, NULL, der, der_end);
924 return extensions_end ? extensions_end : der;
925 }
926
927 static const uint8_t *der_foreach_objects(size_t length, const uint8_t *der, const uint8_t *der_end, CFErrorRef *error, void(^withObject)(CFDataRef object, bool *stop)) {
928 bool stop = false;
929 ccder_tag tag;
930 // Look ahead at the tag
931 while (!stop && ccder_decode_tag(&tag, der, der_end) && tag != CCDER_EOL) {
932 const uint8_t *object_end = NULL;
933 if (!ccder_decode_constructed_tl(tag, &object_end, der, der_end)) {
934 SOSErrorCreate(kSOSErrorDecodeFailure, error, NULL, CFSTR("failed to decode object header"));
935 return NULL;
936 }
937 if (withObject) {
938 CFDataRef object = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, der, object_end - der, kCFAllocatorNull);
939 withObject(object, &stop);
940 CFReleaseSafe(object);
941 }
942 der = object_end;
943 }
944 if (length == CCBER_LEN_INDEFINITE) {
945 size_t len = 0;
946 der = ccder_decode_tl(CCDER_EOL, &len, der, der_end);
947 if (len != 0) {
948 secwarning("%td length ", der_end - der);
949 }
950 }
951 if (!stop && der != der_end)
952 secwarning("%td trailing bytes after objects DER", der_end - der);
953
954 return der;
955 }
956
957 static const uint8_t *der_decode_objects(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
958 ccder_tag tag = 0;
959 size_t objects_len = 0;
960 der = ccder_decode_tag(&tag, der, der_end);
961 if (tag != (2 | CCDER_CONTEXT_SPECIFIC | CCDER_CONSTRUCTED)) return NULL;
962 der = ccber_decode_len(&objects_len, der, der_end);
963 if (objects_len != CCBER_LEN_INDEFINITE && der_end - der != (ptrdiff_t)objects_len) {
964 secwarning("%td trailing bytes after SOSMessage DER", (der_end - der) - (ptrdiff_t)objects_len);
965 }
966 // Remember a pointer into message->der where objects starts.
967 message->objectsDer = der;
968 message->objectsLen = objects_len;
969
970 return der + objects_len;
971 }
972
973 static const uint8_t *der_decode_optional_objects(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
974 const uint8_t *seq_end = der_decode_objects(message, NULL, der, der_end);
975 return seq_end ? seq_end : der;
976 }
977
978 #if 0
979 // Move to ccder and possibly refactor ccder_decode_constructed_tl to call this.
980 #ifdef CCDER_DECODE_CONSTRUCTED_LEN_SPECIFIER
981 CCDER_DECODE_CONSTRUCTED_LEN_SPECIFIER
982 #endif
983 inline CC_NONNULL((1, 3))
984 const uint8_t *
985 ccder_decode_constructed_len(const uint8_t **body_end,
986 const uint8_t *der, const uint8_t *der_end) {
987 size_t len;
988 der = ccder_decode_len(&len, der, der_end);
989 *body_end = der + len;
990 return der;
991 }
992 #endif
993
994 static const uint8_t *der_decode_message_header(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
995 cc_unit flags[1] = {};
996 der = ccder_decode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, &der_end, der, der_end);
997 message->version = 2;
998 der = ccder_decode_optional_implicit_uint64(0 | CCDER_CONTEXT_SPECIFIC, &message->version, der, der_end);
999 der = der_decode_optional_generalizedtime(&message->creationTime, error, der, der_end);
1000 der = ccder_decode_optional_uint64(&message->sequenceNumber, der, der_end);
1001 der = ccder_decode_optional_digest_types(message, der, der_end);
1002 der = ccder_decode_bit_string(array_size(flags), NULL, flags, der, der_end);
1003 message->flags = flags[0];
1004
1005 der = der_decode_implicit_data(CCDER_OCTET_STRING, &message->senderDigest, der, der_end);
1006 secinfo("engine", "der_decode_message_header: decoded sender digest as %@", message->senderDigest);
1007
1008 der = der_decode_optional_implicit_data(0 | CCDER_CONTEXT_SPECIFIC, &message->baseDigest, der, der_end);
1009 secinfo("engine", "der_decode_message_header: decoded base digest as %@", message->baseDigest);
1010
1011 der = der_decode_optional_implicit_data(1 | CCDER_CONTEXT_SPECIFIC, &message->proposedDigest, der, der_end);
1012 secinfo("engine", "der_decode_message_header: decoded proposed digest as %@", message->proposedDigest);
1013
1014 return der;
1015 }
1016
1017 static const uint8_t *
1018 der_decode_manifest_and_objects_message(SOSMessageRef message,
1019 CFErrorRef *error, const uint8_t *der,
1020 const uint8_t *der_end) {
1021 size_t objects_len = 0;
1022 const uint8_t *body_end;
1023 der = ccder_decode_sequence_tl(&body_end, der, der_end);
1024 if (body_end != der_end) {
1025 SOSErrorCreate(kSOSErrorInvalidMessage, error, NULL, CFSTR("Trailing garbage at end of message"));
1026 return NULL;
1027 }
1028 der = der_decode_implicit_data(CCDER_OCTET_STRING, &message->baseDigest, der, body_end);
1029 secinfo("engine", "der_decode_manifest_and_objects_message: decoded base digest as %@", message->baseDigest);
1030
1031 der = der_decode_deltas_body(message, error, der, body_end);
1032 // Remember a pointer into message->der where objects starts.
1033 der = message->objectsDer = ccder_decode_tl(CCDER_CONSTRUCTED_SEQUENCE, &objects_len, der, body_end);
1034 message->objectsLen = objects_len;
1035
1036 return der ? der + objects_len : NULL;
1037 }
1038
1039 static const uint8_t *der_decode_v0_message_body(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
1040 uint64_t messageType = 0;
1041 der = ccder_decode_uint64(&messageType, der, der_end);
1042 if (der) switch (messageType) {
1043 case SOSManifestDigestMessageType:
1044 {
1045 der = der_decode_implicit_data(CCDER_OCTET_STRING, &message->senderDigest, der, der_end);
1046 secinfo("engine", "der_decode_v0_message_body: received a DigestMessage with sender digest: %@", message->senderDigest);
1047 break;
1048 }
1049 case SOSManifestMessageType:
1050 {
1051 CFDataRef manifestBody = NULL;
1052 der = der_decode_implicit_data(CCDER_OCTET_STRING, &manifestBody, der, der_end);
1053 if (!der) return NULL;
1054 if (der != der_end) {
1055 secwarning("%td trailing bytes after deltas DER", der_end - der);
1056 }
1057 message->additions = SOSManifestCreateWithData(manifestBody, error);
1058 secinfo("engine", "der_decode_v0_message_body: received a ManifestMessage with (%zu, %@)", SOSManifestGetCount(message->additions), SOSManifestGetDigest(message->additions, NULL));
1059 CFReleaseSafe(manifestBody);
1060 break;
1061 }
1062 case SOSManifestDeltaAndObjectsMessageType:
1063 {
1064 der = der_decode_manifest_and_objects_message(message, error, der, der_end);
1065 break;
1066 }
1067 default:
1068 SOSErrorCreate(kSOSErrorInvalidMessage, error, NULL, CFSTR("Invalid message type %llu"), messageType);
1069 break;
1070 }
1071 return der;
1072 }
1073
1074 static const uint8_t *der_decode_message(SOSMessageRef message, CFErrorRef *error, const uint8_t *der, const uint8_t *der_end) {
1075 ccder_tag tag = 0;
1076 size_t body_len = 0;
1077
1078 der = ccder_decode_tag(&tag, der, der_end);
1079 if (tag != CCDER_CONSTRUCTED_SEQUENCE) return NULL;
1080 der = ccber_decode_len(&body_len, der, der_end);
1081 if (der && body_len && body_len != CCBER_LEN_INDEFINITE && (der_end - der) != (ptrdiff_t)body_len) {
1082 secwarning("%td trailing bytes after SOSMessage DER", (der_end - der) - (ptrdiff_t)body_len);
1083 der_end = der + body_len;
1084 }
1085
1086 if (ccder_decode_tag(&tag, der, der_end)) switch (tag) {
1087 case CCDER_INTEGER: // v0
1088 if (body_len == CCBER_LEN_INDEFINITE)
1089 der = NULL; // Not supported for v0 messages
1090 else
1091 der = der_decode_v0_message_body(message, error, der, der_end);
1092 break;
1093 case CCDER_CONSTRUCTED_SEQUENCE: //v2
1094 der = der_decode_message_header(message, error, der, der_end);
1095 der = der_decode_optional_deltas(message, der, der_end);
1096 der = der_decode_optional_extensions(message, error, der, der_end);
1097 der = der_decode_optional_objects(message, error, der, der_end);
1098 break;
1099 }
1100 return der;
1101 }
1102
1103 // Decode a SOSMessage
1104 SOSMessageRef SOSMessageCreateWithData(CFAllocatorRef allocator, CFDataRef derData, CFErrorRef *error) {
1105 if (!derData)
1106 return (SOSMessageRef)SOSErrorCreate(kSOSErrorDecodeFailure, error, NULL, CFSTR("NULL data => no SOSMessage"));
1107 SOSMessageRef message = CFTypeAllocate(SOSMessage, struct __OpaqueSOSMessage, allocator);
1108 if (!message)
1109 return (SOSMessageRef)SOSErrorCreate(kSOSErrorAllocationFailure, error, NULL, CFSTR("failed to alloc SOSMessage"));
1110 message->der = CFRetainSafe(derData);
1111 const uint8_t *der = CFDataGetBytePtr(derData);
1112 const uint8_t *der_end = der + CFDataGetLength(derData);
1113 der = der_decode_message(message, error, der, der_end);
1114 if (!der_end || der != der_end) {
1115 if (error && !*error)
1116 SOSErrorCreate(kSOSErrorDecodeFailure, error, NULL, CFSTR("SOSMessage DER decoding failure %td bytes left"), der_end - der);
1117 return CFReleaseSafe(message);
1118 }
1119 return message;
1120 }
1121
1122 // Read values from a decoded messgage
1123
1124 CFDataRef SOSMessageGetBaseDigest(SOSMessageRef message) {
1125 return message->baseDigest;
1126 }
1127
1128 CFDataRef SOSMessageGetProposedDigest(SOSMessageRef message) {
1129 return message->proposedDigest;
1130 }
1131
1132 CFDataRef SOSMessageGetSenderDigest(SOSMessageRef message) {
1133 return message->senderDigest;
1134 }
1135
1136 SOSMessageFlags SOSMessageGetFlags(SOSMessageRef message) {
1137 return message->flags;
1138 }
1139
1140 uint64_t SOSMessageGetSequenceNumber(SOSMessageRef message) {
1141 return message->sequenceNumber;
1142 }
1143
1144 SOSManifestRef SOSMessageGetRemovals(SOSMessageRef message) {
1145 return message->removals;
1146 }
1147
1148 SOSManifestRef SOSMessageGetAdditions(SOSMessageRef message) {
1149 return message->additions;
1150 }
1151
1152 // Iterate though the extensions in a decoded SOSMessage. If criticalOnly is
1153 // true all non critical extensions are skipped.
1154 void SOSMessageWithExtensions(SOSMessageRef message, bool criticalOnly, void(^withExtension)(CFDataRef oid, bool isCritical, CFDataRef extension, bool *stop)) {
1155 // TODO
1156 }
1157
1158 size_t SOSMessageCountObjects(SOSMessageRef message) {
1159 if (message->objects)
1160 return CFArrayGetCount(message->objects);
1161 if (!message->objectsDer)
1162 return 0;
1163 const uint8_t *der = CFDataGetBytePtr(message->der);
1164 const uint8_t *der_end = der + CFDataGetLength(message->der);
1165 __block size_t count = 0;
1166 der_foreach_objects(message->objectsLen, message->objectsDer, der_end, NULL, ^(CFDataRef object, bool *stop){ ++count; });
1167 return count;
1168 }
1169
1170 // Iterate though the objects in a decoded SOSMessage.
1171 bool SOSMessageWithObjects(SOSMessageRef message, CFErrorRef *error,
1172 void(^withObject)(CFDataRef object, bool *stop)) {
1173 if (message->objects) {
1174 CFDataRef object;
1175 CFArrayForEachC(message->objects, object) {
1176 bool stop = false;
1177 withObject(object, &stop);
1178 if (stop)
1179 break;
1180 }
1181 return true;
1182 }
1183 if (!message->objectsDer)
1184 return true;
1185 const uint8_t *der = CFDataGetBytePtr(message->der);
1186 const uint8_t *der_end = der + CFDataGetLength(message->der);
1187 return der_foreach_objects(message->objectsLen, message->objectsDer, der_end, error, withObject);
1188 }
1189
1190 bool SOSMessageWithSOSObjects(SOSMessageRef message, SOSDataSourceRef dataSource, CFErrorRef *error,
1191 void(^withObject)(SOSObjectRef object, bool *stop)) {
1192 return SOSMessageWithObjects(message, error, ^(CFDataRef object, bool *stop) {
1193 CFDictionaryRef plist = NULL;
1194 const uint8_t *der = CFDataGetBytePtr(object);
1195 const uint8_t *der_end = der + CFDataGetLength(object);
1196 // TODO Remove intermediate plist format
1197 der = der_decode_dictionary(kCFAllocatorDefault, kCFPropertyListImmutable, &plist, error, der, der_end);
1198 if (der) {
1199 SOSObjectRef peersObject = SOSObjectCreateWithPropertyList(dataSource, plist, error);
1200 withObject(peersObject, stop);
1201 CFReleaseSafe(peersObject);
1202 }
1203 CFReleaseSafe(plist);
1204 });
1205 }
mirror of Security