1  /*
  2   * Copyright (c) 2011-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  #ifndef _SECOTRPACKETDATA_H_
 26  #define _SECOTRPACKETDATA_H_
 27  
 28  #include <CoreFoundation/CFBase.h>
 29  #include <CoreFoundation/CFRuntime.h>
 30  #include <CoreFoundation/CFData.h>
 31  
 32  #include <corecrypto/ccn.h>
 33  
 34  #include <CommonCrypto/CommonDigest.h>
 35  
 36  #include <Security/SecBase.h>
 37  
 38  #include <Security/SecOTRPackets.h>
 39  
 40  #include <AssertMacros.h>
 41  
 42  #include <security_utilities/simulatecrash_assert.h>
 43  
 44  __BEGIN_DECLS
 45  
 46  CF_ASSUME_NONNULL_BEGIN
 47  
 48  static
 49  OSStatus ReadAndVerifyByte(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, uint8_t expected);
 50  
 51  static
 52  OSStatus ReadAndVerifyShort(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, uint16_t expected);
 53  
 54  static
 55  OSStatus ReadAndVerifyMessageType(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, OTRMessageType expected);
 56  
 57  static
 58  OSStatus SizeAndSkipDATA(const uint8_t *_Nonnull *_Nonnull bytes, size_t *size,
 59                           const uint8_t *_Nonnull *_Nonnull dataBytes, size_t *dataSize);
 60  static
 61  OSStatus SizeAndSkipMPI(const uint8_t *_Nonnull *_Nonnull bytes, size_t *size,
 62                          const uint8_t *_Nonnull *_Nonnull mpiBytes, size_t *mpiSize);
 63  
 64  
 65  static
 66  OSStatus ReadLongLongCompact(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint64_t* value);
 67  
 68  static
 69  OSStatus ReadLongLong(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint64_t* value);
 70  
 71  static
 72  OSStatus ReadLong(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint32_t* value);
 73  
 74  static
 75  OSStatus ReadShort(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint16_t* value);
 76  
 77  static
 78  OSStatus ReadByte(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint8_t* value);
 79  
 80  static
 81  OSStatus ReadMessageType(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, OTRMessageType* type);
 82  
 83  static
 84  OSStatus ReadMPI(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, cc_size n, cc_unit *x);
 85  
 86  static
 87  OSStatus ReadDATA(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, size_t* dataSize, uint8_t* data);
 88  
 89  static
 90  OSStatus CreatePublicKey(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, _Nonnull SecOTRPublicIdentityRef *_Nonnull publicId);
 91  
 92  static
 93  CFMutableDataRef CFDataCreateMutableFromOTRDATA(CFAllocatorRef _Nullable allocator, const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr);
 94  
 95  static
 96  void AppendLongLongCompact(CFMutableDataRef appendTo, uint64_t value);
 97  
 98  static
 99  void AppendLongLong(CFMutableDataRef appendTo, uint64_t value);
100  
101  static
102  void AppendLong(CFMutableDataRef appendTo, uint32_t value);
103  
104  static
105  void AppendShort(CFMutableDataRef appendTo, uint16_t value);
106  
107  static
108  void AppendByte(CFMutableDataRef appendTo, uint8_t type);
109  
110  static
111  void AppendMessageType(CFMutableDataRef appendTo, OTRMessageType type);
112  
113  static
114  void AppendMPI(CFMutableDataRef appendTo, cc_size n, const cc_unit *x);
115  
116  static
117  void AppendDATA(CFMutableDataRef appendTo, size_t size, const uint8_t*data);
118  
119  static
120  void AppendPublicKey(CFMutableDataRef appendTo, SecOTRPublicIdentityRef publicId);
121  
122      
123  //
124  // Inline implementation
125  //
126  
127  static uint16_t kCurrentOTRVersion = 0x2;
128      
129  static inline OSStatus ReadLongLong(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint64_t* value)
130  {
131      require(bytesPtr != NULL, fail);
132      require(sizePtr != NULL, fail);
133      require(value != NULL, fail);
134      require(*sizePtr >= 8, fail);
135  
136      *value = ((uint64_t)(*bytesPtr)[0]) << 56 |
137      ((uint64_t)(*bytesPtr)[1]) << 48 |
138      ((uint64_t)(*bytesPtr)[2]) << 40 |
139      ((uint64_t)(*bytesPtr)[3]) << 32 |
140      ((uint64_t)(*bytesPtr)[4]) << 24 |
141      ((uint64_t)(*bytesPtr)[5]) << 16 |
142      ((uint64_t)(*bytesPtr)[6]) << 8  |
143      ((uint64_t)(*bytesPtr)[7]) << 0;
144  
145      *bytesPtr += 8;
146      *sizePtr -= 8;
147  
148      return errSecSuccess;
149  fail:
150      return errSecParam;
151  }
152  
153  static inline OSStatus ReadLongLongCompact(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint64_t* value)
154  {
155      bool moreBytes = true;
156  
157      require(bytesPtr != NULL, fail);
158      require(sizePtr != NULL, fail);
159      require(value != NULL, fail);
160  
161      *value = 0;
162  
163      while (moreBytes && *sizePtr > 0) {
164          uint8_t thisByte = **bytesPtr;
165  
166          moreBytes = (0x80 & thisByte) != 0;
167  
168          *value <<= 7;
169          *value |= (thisByte & 0x7F);
170  
171          ++*bytesPtr;
172          --*sizePtr;
173      }
174  
175  fail:
176      return !moreBytes ? errSecSuccess : errSecDecode;
177  }
178  
179  static inline OSStatus ReadLong(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint32_t* value)
180  {
181      require(bytesPtr != NULL, fail);
182      require(sizePtr != NULL, fail);
183      require(value != NULL, fail);
184      require(*sizePtr >= 4, fail);
185      
186      *value = (uint32_t)(*bytesPtr)[0] << 24 |
187      (uint32_t)(*bytesPtr)[1] << 16 |
188      (uint32_t)(*bytesPtr)[2] << 8  |
189      (uint32_t)(*bytesPtr)[3] << 0;
190      
191      *bytesPtr += 4;
192      *sizePtr -= 4;
193      
194      return errSecSuccess;
195  fail:
196      return errSecParam;
197  }
198      
199  static inline OSStatus ReadShort(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint16_t* value)
200  {
201      require(bytesPtr != NULL, fail);
202      require(sizePtr != NULL, fail);
203      require(value != NULL, fail);
204      require(*sizePtr >= 2, fail);
205      
206      *value = (*bytesPtr)[0] << 8  |
207      (*bytesPtr)[1] << 0;
208      
209      *bytesPtr += 2;
210      *sizePtr -= 2;
211      
212      return errSecSuccess;
213  fail:
214      return errSecParam;
215  }
216  
217  static inline OSStatus ReadByte(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, uint8_t* value)
218  {
219      require(bytesPtr != NULL, fail);
220      require(sizePtr != NULL, fail);
221      require(value != NULL, fail);
222      require(*sizePtr >= 1, fail);
223      
224      *value = *bytesPtr[0];
225      
226      *bytesPtr += 1;
227      *sizePtr -= 1;
228      
229      return errSecSuccess;
230  fail:
231      return errSecParam;
232  }
233  
234  static inline OSStatus ReadByteAsBool(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, bool* value)
235  {
236      uint8_t byte = 0;
237  
238      OSStatus result = ReadByte(bytesPtr, sizePtr, &byte);
239  
240      if (result == noErr)
241          *value = byte != 0;
242  
243      return result;
244  }
245      
246  static inline OSStatus ReadMessageType(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, OTRMessageType* type)
247  {
248      OSStatus result = errSecParam;
249      uint8_t value;
250  
251      require(type != NULL, fail);
252      require_noerr_quiet(result = ReadByte(bytesPtr, sizePtr, &value), fail);
253      
254      *type = value;
255  fail:
256      return result;
257  }
258  
259  static inline OSStatus ReadMPI(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, cc_size n, cc_unit *x)
260  {
261      require(bytesPtr != NULL, fail);
262      require(sizePtr != NULL, fail);
263      require(x != NULL, fail);
264      require_quiet(*sizePtr >= 5, fail);
265      
266      uint32_t mpiLength;
267      
268      ReadLong(bytesPtr, sizePtr, &mpiLength);
269      
270      require_quiet(mpiLength <= *sizePtr, fail);
271      
272      ccn_read_uint(n, x, mpiLength, *bytesPtr);
273      
274      *bytesPtr += mpiLength;
275      *sizePtr -= mpiLength;
276      
277      return errSecSuccess;
278  fail:
279      return errSecParam;
280      
281  }
282      
283  static inline OSStatus ReadDATA(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, size_t* dataSize, uint8_t* data)
284  {
285      require(bytesPtr != NULL, fail);
286      require(sizePtr != NULL, fail);
287      require(data != NULL, fail);
288      require_quiet(*sizePtr >= 5, fail);
289      
290      uint32_t dataLength;
291      
292      ReadLong(bytesPtr, sizePtr, &dataLength);
293      
294      require_quiet(dataLength <= *sizePtr, fail);
295      memmove(data, bytesPtr, dataLength);
296      
297      *bytesPtr += dataLength;
298      *sizePtr -= dataLength;
299      
300      *dataSize = dataLength;
301      
302      return errSecSuccess;
303  fail:
304      return errSecParam;
305      
306  }
307      
308  static inline OSStatus CreatePublicKey(const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr, _Nonnull SecOTRPublicIdentityRef *_Nonnull publicId)
309  {
310      require(bytesPtr != NULL, fail);
311      require(sizePtr != NULL, fail);
312      require(publicId != NULL, fail);
313      require(*sizePtr >= 7, fail);
314  
315      uint16_t type = 0;
316      ReadShort(bytesPtr, sizePtr, &type);
317  
318      require_quiet(type == 0xF000, fail);
319      require_quiet(*sizePtr >= 5, fail);
320      
321      uint32_t serializedIDLength = 0;
322      ReadLong(bytesPtr, sizePtr, &serializedIDLength);
323      
324      require_quiet(*sizePtr >= serializedIDLength, fail);
325      require_quiet(((CFIndex)serializedIDLength) >= 0, fail);
326      
327      CFDataRef serializedBytes = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, *bytesPtr, (CFIndex)serializedIDLength, kCFAllocatorNull);
328      
329      *publicId = SecOTRPublicIdentityCreateFromData(kCFAllocatorDefault, serializedBytes, NULL);
330      
331      *bytesPtr += serializedIDLength;
332      *sizePtr -= serializedIDLength;
333      
334      if(serializedBytes)
335          CFRelease(serializedBytes);
336      
337      return errSecSuccess;
338  fail:
339      return errSecParam;
340      
341  }
342      
343  static inline CFMutableDataRef CFDataCreateMutableFromOTRDATA(CFAllocatorRef _Nullable allocator, const uint8_t *_Nonnull *_Nonnull bytesPtr, size_t*sizePtr)
344  {
345      CFMutableDataRef result = NULL;
346      uint32_t sizeInStream;
347      require_noerr_quiet(ReadLong(bytesPtr, sizePtr, &sizeInStream), exit);
348      require_quiet(sizeInStream <= *sizePtr, exit);
349      require_quiet(((CFIndex)sizeInStream) >= 0, exit);
350      
351      result = CFDataCreateMutable(allocator, 0);
352      
353      CFDataAppendBytes(result, *bytesPtr, (CFIndex)sizeInStream);
354      
355      *bytesPtr += sizeInStream;
356      *sizePtr -= sizeInStream;
357  
358  exit:
359      return result;
360  }
361  
362  
363  //
364  // Parse and verify functions
365  //
366  static inline OSStatus ReadAndVerifyByte(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, uint8_t expected)
367  {
368      uint8_t found;
369      OSStatus result = ReadByte(bytes, size, &found);
370      require_noerr_quiet(result, exit);
371      require_action_quiet(found == expected, exit, result = errSecDecode);
372  exit:
373      return result;
374  }
375  
376  static inline OSStatus ReadAndVerifyShort(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, uint16_t expected)
377  {
378      uint16_t found;
379      OSStatus result = ReadShort(bytes, size, &found);
380      require_noerr_quiet(result, exit);
381      require_action_quiet(found == expected, exit, result = errSecDecode);
382  exit:
383      return result;
384  }
385  
386  static inline OSStatus ReadAndVerifyMessageType(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, OTRMessageType expected)
387  {
388      OTRMessageType found;
389      OSStatus result = ReadMessageType(bytes, size, &found);
390      require_noerr_quiet(result, exit);
391      require_action_quiet(found == expected, exit, result = errSecDecode);
392  exit:
393      return result;
394  }
395  
396  static inline OSStatus ReadAndVerifyVersion(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size)
397  {
398      return ReadAndVerifyShort(bytes, size, kCurrentOTRVersion);
399  }
400  
401  static inline OSStatus ReadAndVerifyHeader(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, OTRMessageType expected)
402  {
403      OSStatus result = ReadAndVerifyVersion(bytes, size);
404      require_noerr_quiet(result, exit);
405      
406      result = ReadAndVerifyMessageType(bytes, size, expected);
407      require_noerr_quiet(result, exit);
408      
409  exit:
410      return result;
411  }
412  
413  static inline OSStatus ReadHeader(const uint8_t *_Nonnull *_Nonnull bytes, size_t*size, OTRMessageType *messageType)
414  {
415      OSStatus result = ReadAndVerifyVersion(bytes, size);
416      require_noerr_quiet(result, exit);
417      
418      result = ReadMessageType(bytes, size, messageType);
419      require_noerr_quiet(result, exit);
420      
421  exit:
422      return result;
423  }
424  
425  static inline OSStatus SizeAndSkipDATA(const uint8_t *_Nonnull *_Nonnull bytes, size_t *size,
426                                  const uint8_t *_Nonnull *_Nonnull dataBytes, size_t *dataSize)
427  {
428      OSStatus result;
429      uint32_t sizeRead;
430      result = ReadLong(bytes, size, &sizeRead);
431      
432      require_noerr_quiet(result, exit);
433      require_action_quiet(sizeRead <= *size, exit, result = errSecDecode);
434      
435      *dataSize = sizeRead;
436      *dataBytes = *bytes;
437      *bytes += sizeRead;
438      *size -= sizeRead;
439  exit:
440      return result;
441  }
442  
443  static inline OSStatus SizeAndSkipMPI(const uint8_t *_Nonnull *_Nonnull bytes, size_t *size,
444                                 const uint8_t *_Nonnull *_Nonnull mpiBytes, size_t *mpiSize)
445  {
446      // MPIs looke like data for skipping.
447      return SizeAndSkipDATA(bytes, size, mpiBytes, mpiSize);
448  }
449  
450      
451  //
452  // Appending functions
453  //
454  static inline void AppendLongLongCompact(CFMutableDataRef appendTo, uint64_t value)
455  {
456      uint8_t compact[(sizeof(value) * 8 + 7) / 7]; // We can only need enough bytes to hold 8/7 expansion.
457  
458      uint8_t *end = compact + sizeof(compact);
459      uint8_t *lastFilled = end;
460  
461      --lastFilled;
462      *lastFilled = (value & 0x7F);
463  
464      for (value >>= 7; value != 0; value >>= 7) {
465          --lastFilled;
466          *lastFilled = (value & 0x7f) | 0x80;
467      }
468  
469      CFDataAppendBytes(appendTo, lastFilled, end - lastFilled);
470  }
471  
472  static inline void AppendLongLong(CFMutableDataRef appendTo, uint64_t value)
473  {
474      uint8_t bigEndian[sizeof(value)] = { value >> 56, value >> 48, value >> 40, value >> 32,
475                                           value >> 24, value >> 16, value >> 8 , value >> 0  };
476      
477      CFDataAppendBytes(appendTo, bigEndian, sizeof(bigEndian));
478  }
479  
480  static inline void AppendLong(CFMutableDataRef appendTo, uint32_t value)
481  {
482      uint8_t bigEndian[sizeof(value)] = { value >> 24, value >> 16, value >> 8, value };
483      
484      CFDataAppendBytes(appendTo, bigEndian, sizeof(bigEndian));
485  }
486  
487  static inline void AppendShort(CFMutableDataRef appendTo, uint16_t value)
488  {
489      uint8_t bigEndian[sizeof(value)] = { value >> 8, value };
490      
491      CFDataAppendBytes(appendTo, bigEndian, sizeof(bigEndian));
492  }
493  
494  static inline void AppendByte(CFMutableDataRef appendTo, uint8_t byte)
495  {
496      CFDataAppendBytes(appendTo, &byte, 1);
497  }
498  
499  static inline void AppendMessageType(CFMutableDataRef appendTo, OTRMessageType type)
500  {
501      AppendByte(appendTo, type);
502  }
503  
504  static inline void AppendMPI(CFMutableDataRef appendTo, cc_size n, const cc_unit *x)
505  {
506      size_t size = ccn_write_uint_size(n, x);
507      /* 64 bits cast: we are appending an identity, whose size is hardcoded and less then 2^32 bytes */
508      /* Worst case is we encoded a truncated length. No security issue. */
509      assert(size<UINT32_MAX); /* Debug check */
510      AppendLong(appendTo, (uint32_t)size);
511      assert(((CFIndex)size) >= 0);
512      CFIndex startOffset = CFDataGetLength(appendTo);
513      CFDataIncreaseLength(appendTo, (CFIndex)size);
514      uint8_t* insertionPtr = CFDataGetMutableBytePtr(appendTo) + startOffset;
515      ccn_write_uint(n, x, size, insertionPtr);
516  }
517  
518  static inline void AppendDATA(CFMutableDataRef appendTo, size_t size, const uint8_t*data)
519  {
520      /* 64 bits cast: we are appending Public Key or Signature, whose sizes are hardcoded and less then 2^32 bytes */
521      /* Worst case is we encoded a truncated length. No security issue. */
522      assert(size<=UINT32_MAX); /* Debug check */
523      AppendLong(appendTo, (uint32_t)size);
524      assert(((CFIndex)size) >= 0);
525      CFDataAppendBytes(appendTo, data, (CFIndex)size);
526  }
527      
528  static inline void AppendCFDataAsDATA(CFMutableDataRef appendTo, CFDataRef dataToAppend)
529  {
530      AppendDATA(appendTo, (size_t)CFDataGetLength(dataToAppend), CFDataGetBytePtr(dataToAppend));
531  }
532  
533  static inline void AppendPublicKey(CFMutableDataRef appendTo, SecOTRPublicIdentityRef publicId)
534  {
535      AppendShort(appendTo, 0xF000); // Custom type reserved by no one
536      
537      CFMutableDataRef serializedID = CFDataCreateMutable(kCFAllocatorDefault, 0);
538  
539      SecOTRPIAppendSerialization(publicId, serializedID, NULL);
540      AppendDATA(appendTo, (size_t)CFDataGetLength(serializedID), CFDataGetBytePtr(serializedID));
541      
542      if(serializedID)
543          CFRelease(serializedID);
544  }
545  
546  static inline void AppendVersion(CFMutableDataRef appendTo)
547  {
548      AppendShort(appendTo, kCurrentOTRVersion);
549  }
550  
551  static inline void AppendHeader(CFMutableDataRef appendTo, OTRMessageType type)
552  {
553      AppendVersion(appendTo);
554      AppendMessageType(appendTo, type);
555  }
556  
557  CF_ASSUME_NONNULL_END
558  
559  __END_DECLS
560  
561  #endif