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  #include <stdlib.h>
 25  
 26  #include <CoreFoundation/CFBase.h>
 27  #include <CoreFoundation/CFError.h>
 28  
 29  #include <Security/SecBasePriv.h>
 30  #include <Security/SecOTR.h>
 31  #include <Security/SecOTRSession.h>
 32  #include <Security/SecOTRSessionPriv.h>
 33  #include "keychain/SecureObjectSync/SOSInternal.h"
 34  #include "keychain/SecureObjectSync/SOSFullPeerInfo.h"
 35  #include <Security/SecureObjectSync/SOSPeerInfo.h>
 36  #include "keychain/SecureObjectSync/SOSPeer.h"
 37  #include "keychain/SecureObjectSync/SOSCoder.h"
 38  
 39  #include <utilities/SecCFRelease.h>
 40  #include <utilities/SecCFWrappers.h>
 41  #include <utilities/SecIOFormat.h>
 42  #include <utilities/SecCFError.h>
 43  #include <utilities/SecCoreCrypto.h>
 44  #include <utilities/debugging.h>
 45  
 46  #include <utilities/der_plist.h>
 47  #include <utilities/der_plist_internal.h>
 48  
 49  #include <corecrypto/ccder.h>
 50  #include <utilities/iCloudKeychainTrace.h>
 51  
 52  #include "AssertMacros.h"
 53  
 54  struct __OpaqueSOSCoder {
 55      CFRuntimeBase _base;
 56  
 57      CFStringRef peer_id;
 58      SecOTRSessionRef sessRef;
 59      bool waitingForDataPacket;
 60      CFDataRef pendingResponse;
 61  
 62      CFDataRef hashOfLastReceived;
 63      bool      lastReceivedWasOld;
 64  };
 65  
 66  #define lastReceived_di ccsha1_di
 67  
 68  CFGiblisWithCompareFor(SOSCoder)
 69  
 70  static CFStringRef SOSCoderCopyFormatDescription(CFTypeRef cf, CFDictionaryRef formatOptions) {
 71      SOSCoderRef coder = (SOSCoderRef)cf;
 72      if(coder){
 73          __block CFStringRef desc = NULL;
 74          CFDataPerformWithHexString(coder->hashOfLastReceived, ^(CFStringRef dataString) {
 75              desc = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("<Coder %@ %@ %s%s>"),
 76                                              coder->sessRef,
 77                                              dataString,
 78                                              coder->waitingForDataPacket ? "W" : "w",
 79                                              coder->lastReceivedWasOld ? "O" : "o"
 80                                              );
 81  
 82          });
 83          return desc;
 84      }
 85      else
 86          return CFSTR("NULL");
 87  }
 88  
 89  static Boolean SOSCoderCompare(CFTypeRef cfA, CFTypeRef cfB) {
 90      SOSCoderRef coderA = (SOSCoderRef)cfA, coderB = (SOSCoderRef)cfB;
 91      // Use mainly to see if peerB is actually this device (peerA)
 92      return CFStringCompare(coderA->peer_id, coderB->peer_id, 0) == kCFCompareEqualTo;
 93  }
 94  
 95  
 96  static const char *SOSCoderString(SOSCoderStatus coderStatus) {
 97      switch (coderStatus) {
 98          case kSOSCoderDataReturned: return "DataReturned";
 99          case kSOSCoderNegotiating: return "Negotiating";
100          case kSOSCoderNegotiationCompleted: return "NegotiationCompleted";
101          case kSOSCoderFailure: return "Failure";
102          case kSOSCoderStaleEvent: return "StaleEvent";
103          case kSOSCoderTooNew: return "TooNew";
104          default: return "StatusUnknown";
105      }
106  }
107  
108  static CFMutableDataRef sessSerializedCreate(SOSCoderRef coder, CFErrorRef *error) {
109      CFMutableDataRef otr_state = NULL;
110          
111      if(!coder || !coder->sessRef) {
112          SOSCreateErrorWithFormat(kSOSErrorUnexpectedType, NULL, error, 0, CFSTR("No session reference."));
113          return NULL;
114      }
115      
116      if ((otr_state = CFDataCreateMutable(NULL, 0)) == NULL) {
117          SOSCreateErrorWithFormat(kSOSErrorAllocationFailure, NULL, error, 0, CFSTR("Mutable Data allocation failed."));
118          return NULL;
119      }
120      
121      if (errSecSuccess != SecOTRSAppendSerialization(coder->sessRef, otr_state)) {
122          SOSCreateErrorWithFormat(kSOSErrorEncodeFailure, NULL, error, 0, CFSTR("Append Serialization failed."));
123          CFReleaseSafe(otr_state);
124          return NULL;
125      }
126      
127      return otr_state;
128  
129  }
130  
131  static size_t der_sizeof_optional_data(CFDataRef data) {
132      return data ? der_sizeof_data(data, NULL) : 0;
133  }
134  
135  static uint8_t* der_encode_optional_data(CFDataRef data, CFErrorRef *error, const uint8_t* der, uint8_t* der_end) {
136      return data ? der_encode_data(data, error, der, der_end) : der_end;
137  }
138  
139  
140  
141  static size_t SOSCoderGetDEREncodedSize(SOSCoderRef coder, CFErrorRef *error) {
142      size_t encoded_size = 0;
143      CFMutableDataRef otr_state = sessSerializedCreate(coder, error);
144  
145      if (otr_state) {
146          size_t data_size = der_sizeof_data(otr_state, error);
147          size_t waiting_size = ccder_sizeof_bool(coder->waitingForDataPacket, error);
148          size_t pending_size = der_sizeof_optional_data(coder->pendingResponse);
149          
150          if ((data_size != 0) && (waiting_size != 0))
151          {
152              encoded_size = ccder_sizeof(CCDER_CONSTRUCTED_SEQUENCE, data_size + waiting_size + pending_size);
153          }
154          CFReleaseSafe(otr_state);
155      }
156      return encoded_size;
157  }
158  
159  
160  static uint8_t* SOSCoderEncodeToDER(SOSCoderRef coder, CFErrorRef* error, const uint8_t* der, uint8_t* der_end) {
161      if(!der_end) return NULL;
162      uint8_t* result = NULL;
163      CFMutableDataRef otr_state = sessSerializedCreate(coder, error);
164      
165      if(otr_state) {
166          result = ccder_encode_constructed_tl(CCDER_CONSTRUCTED_SEQUENCE, der_end, der,
167                                               der_encode_data(otr_state, error, der,
168                                               ccder_encode_bool(coder->waitingForDataPacket, der,
169                                               der_encode_optional_data(coder->pendingResponse, error, der, der_end))));
170          CFReleaseSafe(otr_state);
171      }
172      return result;
173  }
174  
175  bool SOSCoderIsCoderInAwaitingState(SOSCoderRef coder){
176      return SecOTRSessionIsSessionInAwaitingState(coder->sessRef);
177  }
178  
179  CFDataRef SOSCoderCopyDER(SOSCoderRef coder, CFErrorRef* error) {
180      CFMutableDataRef encoded = NULL;
181      size_t encoded_size = SOSCoderGetDEREncodedSize(coder, error);
182      
183      if (encoded_size > 0) {
184          encoded = CFDataCreateMutable(NULL, encoded_size);
185          if (encoded) {
186              CFDataSetLength(encoded, encoded_size);
187              uint8_t * der = CFDataGetMutableBytePtr(encoded);
188              uint8_t * der_end = der + encoded_size;
189              if (!SOSCoderEncodeToDER(coder, error, der, der_end)) {
190                  CFReleaseNull(encoded);
191                  encoded = NULL;
192              }
193          }
194      }
195      return encoded;
196  }
197  
198  static SOSCoderRef SOSCoderCreate_internal() {
199      SOSCoderRef p = CFTypeAllocate(SOSCoder, struct __OpaqueSOSCoder, kCFAllocatorDefault);
200  
201      p->peer_id = NULL;
202      p->sessRef = NULL;
203      p->pendingResponse = NULL;
204      p->waitingForDataPacket = false;
205  
206      p->hashOfLastReceived = NULL;
207      p->lastReceivedWasOld = false;
208  
209      return p;
210  
211  }
212  
213  // 0 - Type not understood
214  // 1 - OCTET_STRING, just stored the data for OTR
215  // 2 - SEQUENCE with no version value
216  // 3 - SEQUENCE with version value we pull out of the CCDER_INTEGER
217  
218  typedef enum coderExportFormatVersion {
219      kNotUnderstood = 0,
220      kCoderAsOTRDataOnly = 1,
221      kCoderAsSequence = 2,
222      kCoderAsVersionedSequence = 3,
223  
224      kCurrentCoderExportVersion = kCoderAsVersionedSequence
225  } CoderExportFormatVersion;
226  
227  static uint64_t SOSCoderGetExportedVersion(const uint8_t *der, const uint8_t *der_end) {
228      ccder_tag tag;
229      uint64_t result = kNotUnderstood;
230      require(ccder_decode_tag(&tag, der, der_end),xit);
231      switch (tag) {
232          case CCDER_OCTET_STRING: // TODO: this code is safe to delete?
233              result = kCoderAsOTRDataOnly;
234              break;
235  
236          case CCDER_CONSTRUCTED_SEQUENCE:
237          {
238              const uint8_t *sequence_end = NULL;
239              der = ccder_decode_sequence_tl(&sequence_end, der, der_end);
240              ccder_tag firstSequenceTag;
241              require(ccder_decode_tag(&firstSequenceTag, der, der_end),xit);
242  
243              switch (firstSequenceTag) {
244                  case CCDER_OCTET_STRING:
245                      result = kCoderAsSequence;
246                      break;
247                  case CCDER_INTEGER:
248                      der = ccder_decode_uint64(NULL, der, sequence_end);
249                      if (der == NULL) {
250                          result = kNotUnderstood;
251                      } else {
252                          result = kCoderAsVersionedSequence;
253                      }
254                      break;
255              }
256          }
257      }
258  xit:
259      return result;
260  
261  }
262  
263  SOSCoderRef SOSCoderCreateFromData(CFDataRef exportedData, CFErrorRef *error) {
264      // TODO: fill in errors for all failure cases
265      //require_action_quiet(coder, xit, SOSCreateError(kSOSErrorSendFailure, CFSTR("No coder for peer"), NULL, error));
266  
267      SOSCoderRef p = SOSCoderCreate_internal();
268      
269      const uint8_t *der = CFDataGetBytePtr(exportedData);
270      const uint8_t *der_end = der + CFDataGetLength(exportedData);
271      
272      CFDataRef otr_data = NULL;
273  
274      switch (SOSCoderGetExportedVersion(der, der_end)) {
275          case kCoderAsOTRDataOnly:
276              der = der_decode_data(kCFAllocatorDefault, &otr_data, error, der, der_end);
277              p->waitingForDataPacket = false;
278              break;
279  
280          case kCoderAsSequence:
281          {
282              const uint8_t *sequence_end = NULL;
283              der = ccder_decode_sequence_tl(&sequence_end, der, der_end);
284  
285              require_action_quiet(sequence_end == der_end, fail, SecCFDERCreateError(kSOSErrorDecodeFailure, CFSTR("Extra data in SOS coder"), NULL, error));
286  
287              der = der_decode_data(kCFAllocatorDefault, &otr_data, error, der, sequence_end);
288              der = ccder_decode_bool(&p->waitingForDataPacket, der, sequence_end);
289              if (der != sequence_end) { // optionally a pending response
290                  der = der_decode_data(kCFAllocatorDefault, &p->pendingResponse, error, der, sequence_end);
291              }
292          }
293              break;
294  
295          case kCoderAsVersionedSequence:
296          {
297              const uint8_t *sequence_end = NULL;
298              der = ccder_decode_sequence_tl(&sequence_end, der, der_end);
299  
300              require_action_quiet(sequence_end == der_end, fail, SecCFDERCreateError(kSOSErrorDecodeFailure, CFSTR("Extra data in SOS coder"), NULL, error));
301  
302              uint64_t version;
303              der = ccder_decode_uint64(&version, der, sequence_end);
304              if (version != kCoderAsVersionedSequence) {
305                  SOSErrorCreate(kSOSErrorDecodeFailure, error, NULL, CFSTR("Unsupported Sequence Version: %lld"), version);
306                  goto fail;
307              }
308  
309              der = der_decode_data(kCFAllocatorDefault, &otr_data, error, der, sequence_end);
310              der = ccder_decode_bool(&p->waitingForDataPacket, der, sequence_end);
311              der = ccder_decode_bool(&p->lastReceivedWasOld, der, sequence_end);
312              der = der_decode_data(kCFAllocatorDefault, &p->hashOfLastReceived, error, der, sequence_end);
313              if (der != sequence_end) { // optionally a pending response
314                  der = der_decode_data(kCFAllocatorDefault, &p->pendingResponse, error, der, sequence_end);
315              }
316          }
317              break;
318  
319          default:
320              SOSErrorCreate(kSOSErrorDecodeFailure, error, NULL, CFSTR("Unsupported SOS Coder DER"));
321              goto fail;
322      }
323  
324      require(der, fail);
325      
326      p->sessRef = SecOTRSessionCreateFromData(NULL, otr_data);
327      require(p->sessRef, fail);
328  
329      if (p->hashOfLastReceived == NULL)
330          p->hashOfLastReceived = CFDataCreateMutableWithScratch(kCFAllocatorDefault, lastReceived_di()->output_size);
331  
332      CFReleaseSafe(otr_data);
333      return p;
334          
335  fail:
336      CFReleaseNull(p);
337      CFReleaseSafe(otr_data);
338      return NULL;
339  }
340  
341  
342  SOSCoderRef SOSCoderCreate(SOSPeerInfoRef peerInfo, SOSFullPeerInfoRef myPeerInfo, CFBooleanRef useCompact, CFErrorRef *error) {
343      CFAllocatorRef allocator = CFGetAllocator(peerInfo);
344      
345      SOSCoderRef coder = SOSCoderCreate_internal();
346  
347      CFErrorRef localError = NULL;
348  
349      SecOTRFullIdentityRef myRef = NULL;
350      SecOTRPublicIdentityRef peerRef = NULL;
351      SecKeyRef privateKey = NULL;
352      SecKeyRef publicKey = NULL;
353  
354      if (myPeerInfo && peerInfo) {
355          privateKey = SOSFullPeerInfoCopyDeviceKey(myPeerInfo, &localError);
356          require_quiet(privateKey, errOut);
357  
358          myRef = SecOTRFullIdentityCreateFromSecKeyRefSOS(allocator, privateKey, &localError);
359          require_quiet(myRef, errOut);
360          
361          CFReleaseNull(privateKey);
362      
363          publicKey = SOSPeerInfoCopyPubKey(peerInfo, &localError);
364          require(publicKey, errOut);
365          
366          peerRef = SecOTRPublicIdentityCreateFromSecKeyRef(allocator, publicKey, &localError);
367          require_quiet(peerRef, errOut);
368          
369          if(useCompact == kCFBooleanTrue)
370              coder->sessRef = SecOTRSessionCreateFromIDAndFlags(allocator, myRef, peerRef, kSecOTRUseAppleCustomMessageFormat);
371          
372          else
373              coder->sessRef = SecOTRSessionCreateFromID(allocator, myRef, peerRef);
374  
375          require(coder->sessRef, errOut);
376          
377          coder->waitingForDataPacket = false;
378          coder->pendingResponse = NULL;
379  
380          CFReleaseNull(publicKey);
381          CFReleaseNull(privateKey);
382          CFReleaseNull(myRef);
383          CFReleaseNull(peerRef);
384      } else {
385          secnotice("coder", "NULL Coder requested, no transport security");
386      }
387  
388      coder->hashOfLastReceived = CFDataCreateMutableWithScratch(kCFAllocatorDefault, lastReceived_di()->output_size);
389      coder->lastReceivedWasOld = false;
390  
391      SOSCoderStart(coder, NULL);
392  
393      return coder;
394  
395  errOut:
396      secerror("Coder create failed: %@\n", localError ? localError : (CFTypeRef)CFSTR("No local error in SOSCoderCreate"));
397      secerror("Coder create failed: %@\n", error ? *error : (CFTypeRef)CFSTR("WTF NULL?"));
398      CFReleaseNull(myRef);
399      CFReleaseNull(peerRef);
400      CFReleaseNull(publicKey);
401      CFReleaseNull(privateKey);
402  
403      CFReleaseNull(coder);
404      return NULL;
405  }
406  
407  static void SOSCoderDestroy(CFTypeRef cf)
408  {
409      SOSCoderRef coder = (SOSCoderRef) cf;
410      if (coder) {
411          CFReleaseNull(coder->sessRef);
412          CFReleaseNull(coder->pendingResponse);
413          CFReleaseNull(coder->hashOfLastReceived);
414      }
415  }
416  
417  void SOSCoderReset(SOSCoderRef coder)
418  {
419      SecOTRSessionReset(coder->sessRef);
420      coder->waitingForDataPacket = false;
421      CFReleaseNull(coder->pendingResponse);
422  
423      coder->lastReceivedWasOld = false;
424      CFReleaseNull(coder->hashOfLastReceived);
425      coder->hashOfLastReceived = CFDataCreateMutableWithScratch(kCFAllocatorDefault, lastReceived_di()->output_size);
426  }
427  
428  bool SOSCoderIsFor(SOSCoderRef coder, SOSPeerInfoRef peerInfo, SOSFullPeerInfoRef myPeerInfo) {
429      SecKeyRef theirPublicKey = NULL;
430      SecKeyRef myPublicKey = NULL;
431      bool isForThisPair = false;
432      CFErrorRef localError = NULL;
433  
434      myPublicKey = SOSPeerInfoCopyPubKey(SOSFullPeerInfoGetPeerInfo(myPeerInfo), &localError);
435      require(myPublicKey, errOut);
436  
437      theirPublicKey = SOSPeerInfoCopyPubKey(peerInfo, &localError);
438      require(theirPublicKey, errOut);
439  
440      isForThisPair = SecOTRSIsForKeys(coder->sessRef, myPublicKey, theirPublicKey);
441  
442  errOut:
443      if (localError) {
444          secerror("SOSCoderIsFor failed: %@\n", localError ? localError : (CFTypeRef)CFSTR("No local error in SOSCoderCreate"));
445      }
446  
447      CFReleaseNull(myPublicKey);
448      CFReleaseNull(theirPublicKey);
449      CFReleaseNull(localError);
450      return isForThisPair;
451  }
452  
453  CFDataRef SOSCoderCopyPendingResponse(SOSCoderRef coder)
454  {
455      return coder->pendingResponse ? CFDataCreateCopy(kCFAllocatorDefault, coder->pendingResponse) : NULL;
456  }
457  
458  void SOSCoderConsumeResponse(SOSCoderRef coder)
459  {
460      CFReleaseNull(coder->pendingResponse);
461  }
462  
463  static bool SOSOTRSAppendStartPacket(SecOTRSessionRef session, CFMutableDataRef appendPacket, CFErrorRef *error) {
464      OSStatus otrStatus = SecOTRSAppendStartPacket(session, appendPacket);
465      if (otrStatus != errSecSuccess) {
466          SOSCreateErrorWithFormat(kSOSErrorEncodeFailure, (error != NULL) ? *error : NULL, error, NULL, CFSTR("append start packet returned: %" PRIdOSStatus), otrStatus);
467      }
468      return otrStatus == errSecSuccess;
469  }
470  
471  // Start OTR negotiation if we haven't already done so.
472  SOSCoderStatus
473  SOSCoderStart(SOSCoderRef coder, CFErrorRef *error) {
474      CFMutableStringRef action = CFStringCreateMutable(kCFAllocatorDefault, 0);
475      CFStringRef beginState = NULL;
476      SOSCoderStatus result = kSOSCoderFailure;
477      CFMutableDataRef startPacket = NULL;
478  
479      require_action_quiet(coder->sessRef, coderFailure, CFStringAppend(action, CFSTR("*** no otr session ***")));
480      beginState = CFCopyDescription(coder->sessRef);
481      require_action_quiet(!coder->waitingForDataPacket, negotiatingOut, CFStringAppend(action, CFSTR("waiting for peer to send first data packet")));
482      require_action_quiet(!SecOTRSGetIsReadyForMessages(coder->sessRef), coderFailure, CFStringAppend(action, CFSTR("otr session ready"));
483                           result = kSOSCoderDataReturned);
484      require_action_quiet(SecOTRSGetIsIdle(coder->sessRef), negotiatingOut, CFStringAppend(action, CFSTR("otr negotiating already")));
485      require_action_quiet(startPacket = CFDataCreateMutable(kCFAllocatorDefault, 0), coderFailure, SOSCreateError(kSOSErrorAllocationFailure, CFSTR("alloc failed"), NULL, error));
486      require_quiet(SOSOTRSAppendStartPacket(coder->sessRef, startPacket, error), coderFailure);
487      CFRetainAssign(coder->pendingResponse, startPacket);
488  
489  negotiatingOut:
490      result = kSOSCoderNegotiating;
491  coderFailure:
492      // Uber state log
493      if (result == kSOSCoderFailure && error && *error)
494          CFStringAppendFormat(action, NULL, CFSTR(" %@"), *error);
495      secinfo("coder", "%@ %s %@ %@ returned %s", beginState,
496                SecOTRPacketTypeString(startPacket), action, coder->sessRef, SOSCoderString(result));
497      CFReleaseNull(startPacket);
498      CFReleaseSafe(beginState);
499      CFRelease(action);
500  
501      return result;
502  
503  }
504  
505  SOSCoderStatus
506  SOSCoderResendDH(SOSCoderRef coder, CFErrorRef *error) {
507      if(coder->sessRef == NULL) return kSOSCoderDataReturned;
508      CFMutableDataRef startPacket = CFDataCreateMutable(kCFAllocatorDefault, 0);
509      SOSCoderStatus result = kSOSCoderFailure;
510      require_noerr_quiet(SecOTRSAppendRestartPacket(coder->sessRef, startPacket), exit);
511      secnotice("coder", "Resending OTR Start %@", startPacket);
512      CFRetainAssign(coder->pendingResponse, startPacket);
513      result = kSOSCoderNegotiating;
514  exit:
515      CFReleaseNull(startPacket);
516      return result;
517  }
518  
519  
520  static SOSCoderStatus nullCoder(CFDataRef from, CFMutableDataRef *to) {
521      *to = CFDataCreateMutableCopy(NULL, CFDataGetLength(from), from);
522      return kSOSCoderDataReturned;
523  }
524  
525  SOSCoderStatus SOSCoderUnwrap(SOSCoderRef coder, CFDataRef codedMessage, CFMutableDataRef *message,
526                                CFStringRef clientId, CFErrorRef *error) {
527      if(codedMessage == NULL) return kSOSCoderDataReturned;
528      if(coder->sessRef == NULL) return nullCoder(codedMessage, message);
529      CFMutableStringRef action = CFStringCreateMutable(kCFAllocatorDefault, 0);
530      /* This should be the "normal" case.  We just use OTR to unwrap the received message. */
531      SOSCoderStatus result = kSOSCoderFailure;
532  
533      CFStringRef beginState = CFCopyDescription(coder->sessRef);
534      enum SecOTRSMessageKind kind = SecOTRSGetMessageKind(coder->sessRef, codedMessage);
535  
536  
537      switch (kind) {
538          case kOTRNegotiationPacket: {
539              /* If we're in here we haven't completed negotiating a session.  Use SecOTRSProcessPacket() to go through
540               the negotiation steps and immediately send a reply back if necessary using the sendBlock.  This
541               assumes the sendBlock is still available.
542               */
543              CFMutableDataRef response = CFDataCreateMutable(kCFAllocatorDefault, 0);
544              OSStatus ppstatus = errSecSuccess;
545              if (response) {
546                  switch (ppstatus = SecOTRSProcessPacket(coder->sessRef, codedMessage, response)) {
547                      case errSecSuccess:
548                          if (CFDataGetLength(response) > 1) {
549                              CFStringAppendFormat(action, NULL, CFSTR("Sending OTR Response %s"), SecOTRPacketTypeString(response));
550                              CFRetainAssign(coder->pendingResponse, response);
551                              result = kSOSCoderNegotiating;
552                              if (SecOTRSGetIsReadyForMessages(coder->sessRef)) {
553                                  CFStringAppend(action, CFSTR(" begin waiting for data packet"));
554                                  coder->waitingForDataPacket = true;
555                              }
556                          } else if(!SecOTRSGetIsReadyForMessages(coder->sessRef)) {
557                              CFStringAppend(action, CFSTR("stuck?"));
558                              result = kSOSCoderNegotiating;
559                          } else {
560                              CFStringAppend(action, CFSTR("completed negotiation"));
561                              result = kSOSCoderNegotiationCompleted;
562                              coder->waitingForDataPacket = false;
563                          }
564                          break;
565                      case errSecDecode:
566                          CFStringAppend(action, CFSTR("resending dh"));
567                          result = SOSCoderResendDH(coder, error);
568                          break;
569                      default:
570                          SOSCreateErrorWithFormat(kSOSErrorEncodeFailure, (error != NULL) ? *error : NULL, error, NULL, CFSTR("%@ Cannot negotiate session (%ld)"), clientId, (long)ppstatus);
571                          result = kSOSCoderFailure;
572                          break;
573                  };
574              } else {
575                  SOSCreateErrorWithFormat(kSOSErrorAllocationFailure, (error != NULL) ? *error : NULL, error, NULL, CFSTR("%@ Cannot allocate CFData"), clientId);
576                  result = kSOSCoderFailure;
577              }
578              
579              CFReleaseNull(response);
580              
581              break;
582          }
583  
584          case kOTRDataPacket:
585          {
586              CFDataRef previousMessageHash = coder->hashOfLastReceived;
587              coder->hashOfLastReceived = CFDataCreateWithHash(kCFAllocatorDefault, lastReceived_di(), CFDataGetBytePtr(codedMessage), CFDataGetLength(codedMessage));
588              bool lastWasOld = coder->lastReceivedWasOld;
589              coder->lastReceivedWasOld = false;
590  
591              if(!SecOTRSGetIsReadyForMessages(coder->sessRef)) {
592                  CFStringAppend(action, CFSTR("not ready for data; resending DH packet"));
593                  result = SOSCoderResendDH(coder, error);
594              } else {
595                  if (coder->waitingForDataPacket) {
596                      CFStringAppend(action, CFSTR("got data packet we were waiting for "));
597                      coder->waitingForDataPacket = false;
598                  }
599                  CFMutableDataRef exposed = CFDataCreateMutable(0, 0);
600                  OSStatus otrResult = SecOTRSVerifyAndExposeMessage(coder->sessRef, codedMessage, exposed);
601                  CFStringAppend(action, CFSTR("verify and expose message"));
602                  switch(otrResult) {
603                      case errSecSuccess:
604                          CFStringAppend(action, CFSTR("decoded OTR protected packet"));
605                          CFTransferRetained(*message, exposed);
606                          result = kSOSCoderDataReturned;
607                          break;
608                      case errSecOTRTooOld:
609                          if (CFEqualSafe(previousMessageHash, coder->hashOfLastReceived)) {
610                              CFStringAppend(action, CFSTR(" repeated"));
611                              result = kSOSCoderStaleEvent;
612                          } else {
613                              coder->lastReceivedWasOld = true;
614                              if (lastWasOld) {
615                                  CFStringAppend(action, CFSTR(" too old, repeated renegotiating"));
616                                  // Fail so we will renegotiate
617                                  result = kSOSCoderFailure;
618                              } else {
619                                  CFStringAppend(action, CFSTR(" too old, forcing message"));
620                                  // Force message send.
621                                  result = kSOSCoderForceMessage;
622                              }
623                          }
624                          break;
625                      case errSecOTRIDTooNew:
626                          CFStringAppend(action, CFSTR(" too new"));
627                          result = kSOSCoderTooNew;
628                          break;
629                      default:
630                          SecError(otrResult, error, CFSTR("%@ Cannot expose message: %" PRIdOSStatus), clientId, otrResult);
631                          secerror("%@ Decode OTR Protected Packet: %@", clientId, error ? *error : NULL);
632                          result = kSOSCoderFailure;
633                          break;
634                  }
635  
636                  CFReleaseNull(exposed);
637              }
638              CFReleaseNull(previousMessageHash);
639          }
640              break;
641  
642          default:
643              secerror("%@ Unknown packet type: %@", clientId, codedMessage);
644              SOSCreateError(kSOSErrorDecodeFailure, CFSTR("Unknown packet type"), (error != NULL) ? *error : NULL, error);
645              result = kSOSCoderFailure;
646              break;
647      };
648  
649      // Uber state log
650      if (result == kSOSCoderFailure && error && *error)
651          CFStringAppendFormat(action, NULL, CFSTR(" %@"), *error);
652      secnotice("coder", "%@ %@ %s %@ %@ returned %s", clientId, beginState,
653                SecOTRPacketTypeString(codedMessage), action, coder->sessRef, SOSCoderString(result));
654      CFReleaseSafe(beginState);
655      CFRelease(action);
656  
657      return result;
658  }
659  
660  
661  SOSCoderStatus SOSCoderWrap(SOSCoderRef coder, CFDataRef message, CFMutableDataRef *codedMessage, CFStringRef clientId, CFErrorRef *error) {
662      CFMutableStringRef action = CFStringCreateMutable(kCFAllocatorDefault, 0);
663      SOSCoderStatus result = kSOSCoderDataReturned;
664      CFStringRef beginState = NULL;
665      CFMutableDataRef encoded = NULL;
666      OSStatus otrStatus = 0;
667  
668      require_action_quiet(coder->sessRef, errOut,
669                           CFStringAppend(action, CFSTR("*** using null coder ***"));
670                           result = nullCoder(message, codedMessage));
671      beginState = CFCopyDescription(coder->sessRef);
672      require_action_quiet(SecOTRSGetIsReadyForMessages(coder->sessRef), errOut,
673                           CFStringAppend(action, CFSTR("not ready"));
674                           result = kSOSCoderNegotiating);
675      require_action_quiet(!coder->waitingForDataPacket, errOut,
676                           CFStringAppend(action, CFSTR("waiting for peer to send data packet first"));
677                           result = kSOSCoderNegotiating);
678      require_action_quiet(encoded = CFDataCreateMutable(kCFAllocatorDefault, 0), errOut,
679                           SOSCreateErrorWithFormat(kSOSErrorAllocationFailure, NULL, error, NULL, CFSTR("%@ alloc failed"), clientId);
680                           result = kSOSCoderFailure);
681      require_noerr_action_quiet(otrStatus = SecOTRSSignAndProtectMessage(coder->sessRef, message, encoded), errOut,
682                                 SOSCreateErrorWithFormat(kSOSErrorEncodeFailure, (error != NULL) ? *error : NULL, error, NULL, CFSTR("%@ cannot protect message: %" PRIdOSStatus), clientId, otrStatus);
683                                 CFReleaseNull(encoded);
684                                 result = kSOSCoderFailure);
685      *codedMessage = encoded;
686  
687  errOut:
688      // Uber state log
689      if (result == kSOSCoderFailure && error && *error)
690          CFStringAppendFormat(action, NULL, CFSTR(" %@"), *error);
691      secinfo("coder", "%@ %@ %s %@ %@ returned %s", clientId, beginState,
692                SecOTRPacketTypeString(encoded), action, coder->sessRef, SOSCoderString(result));
693      CFReleaseSafe(beginState);
694      CFRelease(action);
695  
696      return result;
697  }
698  
699  bool SOSCoderCanWrap(SOSCoderRef coder) {
700      return coder->sessRef && SecOTRSGetIsReadyForMessages(coder->sessRef) && !coder->waitingForDataPacket;
701  }