lib/curl_darwinssl.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 2012-2013, Nick Zitzmann, <nickzman@gmail.com>.
   9  * Copyright (C) 2012-2013, Daniel Stenberg, <daniel@haxx.se>, et al.
  10  *
  11  * This software is licensed as described in the file COPYING, which
  12  * you should have received as part of this distribution. The terms
  13  * are also available at http://curl.haxx.se/docs/copyright.html.
  14  *
  15  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  16  * copies of the Software, and permit persons to whom the Software is
  17  * furnished to do so, under the terms of the COPYING file.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ***************************************************************************/
  23
  24 /*
  25  * Source file for all iOS and Mac OS X SecureTransport-specific code for the
  26  * TLS/SSL layer. No code but sslgen.c should ever call or use these functions.
  27  */
  28
  29 #include "curl_setup.h"
  30
  31 #ifdef USE_DARWINSSL
  32
  33 #ifdef HAVE_LIMITS_H
  34 #include <limits.h>
  35 #endif
  36
  37 #include <Security/Security.h>
  38 #include <Security/SecureTransport.h>
  39 #include <CoreFoundation/CoreFoundation.h>
  40 #include <CommonCrypto/CommonDigest.h>
  41
  42 /* The Security framework has changed greatly between iOS and different OS X
  43    versions, and we will try to support as many of them as we can (back to
  44    Leopard and iOS 5) by using macros and weak-linking.
  45
  46    IMPORTANT: If TLS 1.1 and 1.2 support are important for you on OS X, then
  47    you must build this project against the 10.8 SDK or later. */
  48 #if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE))
  49
  50 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1050
  51 #error "The darwinssl back-end requires Leopard or later."
  52 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED < 1050 */
  53
  54 #define CURL_BUILD_IOS 0
  55 #define CURL_BUILD_MAC 1
  56 /* This is the maximum API level we are allowed to use when building: */
  57 #define CURL_BUILD_MAC_10_5 MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
  58 #define CURL_BUILD_MAC_10_6 MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
  59 #define CURL_BUILD_MAC_10_7 MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
  60 #define CURL_BUILD_MAC_10_8 MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
  61 /* These macros mean "the following code is present to allow runtime backward
  62    compatibility with at least this cat or earlier":
  63    (You set this at build-time by setting the MACOSX_DEPLOYMENT_TARGET
  64    environmental variable.) */
  65 #define CURL_SUPPORT_MAC_10_5 MAC_OS_X_VERSION_MIN_REQUIRED <= 1050
  66 #define CURL_SUPPORT_MAC_10_6 MAC_OS_X_VERSION_MIN_REQUIRED <= 1060
  67 #define CURL_SUPPORT_MAC_10_7 MAC_OS_X_VERSION_MIN_REQUIRED <= 1070
  68 #define CURL_SUPPORT_MAC_10_8 MAC_OS_X_VERSION_MIN_REQUIRED <= 1080
  69
  70 #elif TARGET_OS_EMBEDDED || TARGET_OS_IPHONE
  71 #define CURL_BUILD_IOS 1
  72 #define CURL_BUILD_MAC 0
  73 #define CURL_BUILD_MAC_10_5 0
  74 #define CURL_BUILD_MAC_10_6 0
  75 #define CURL_BUILD_MAC_10_7 0
  76 #define CURL_BUILD_MAC_10_8 0
  77 #define CURL_SUPPORT_MAC_10_5 0
  78 #define CURL_SUPPORT_MAC_10_6 0
  79 #define CURL_SUPPORT_MAC_10_7 0
  80 #define CURL_SUPPORT_MAC_10_8 0
  81
  82 #else
  83 #error "The darwinssl back-end requires iOS or OS X."
  84 #endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */
  85
  86 #if CURL_BUILD_MAC
  87 #include <sys/sysctl.h>
  88 #endif /* CURL_BUILD_MAC */
  89
  90 #include "urldata.h"
  91 #include "sendf.h"
  92 #include "inet_pton.h"
  93 #include "connect.h"
  94 #include "select.h"
  95 #include "sslgen.h"
  96 #include "curl_darwinssl.h"
  97
  98 #define _MPRINTF_REPLACE /* use our functions only */
  99 #include <curl/mprintf.h>
 100
 101 #include "curl_memory.h"
 102 /* The last #include file should be: */
 103 #include "memdebug.h"
 104
 105 /* From MacTypes.h (which we can't include because it isn't present in iOS: */
 106 #define ioErr -36
 107 #define paramErr -50
 108
 109 /* The following two functions were ripped from Apple sample code,
 110  * with some modifications: */
 111 static OSStatus SocketRead(SSLConnectionRef connection,
 112                            void *data,          /* owned by
 113                                                  * caller, data
 114                                                  * RETURNED */
 115                            size_t *dataLength)  /* IN/OUT */
 116 {
 117   size_t bytesToGo = *dataLength;
 118   size_t initLen = bytesToGo;
 119   UInt8 *currData = (UInt8 *)data;
 120   /*int sock = *(int *)connection;*/
 121   struct ssl_connect_data *connssl = (struct ssl_connect_data *)connection;
 122   int sock = connssl->ssl_sockfd;
 123   OSStatus rtn = noErr;
 124   size_t bytesRead;
 125   ssize_t rrtn;
 126   int theErr;
 127
 128   *dataLength = 0;
 129
 130   for(;;) {
 131     bytesRead = 0;
 132     rrtn = read(sock, currData, bytesToGo);
 133     if(rrtn <= 0) {
 134       /* this is guesswork... */
 135       theErr = errno;
 136       if(rrtn == 0) { /* EOF = server hung up */
 137         /* the framework will turn this into errSSLClosedNoNotify */
 138         rtn = errSSLClosedGraceful;
 139       }
 140       else /* do the switch */
 141         switch(theErr) {
 142           case ENOENT:
 143             /* connection closed */
 144             rtn = errSSLClosedGraceful;
 145             break;
 146           case ECONNRESET:
 147             rtn = errSSLClosedAbort;
 148             break;
 149           case EAGAIN:
 150             rtn = errSSLWouldBlock;
 151             connssl->ssl_direction = false;
 152             break;
 153           default:
 154             rtn = ioErr;
 155             break;
 156         }
 157       break;
 158     }
 159     else {
 160       bytesRead = rrtn;
 161     }
 162     bytesToGo -= bytesRead;
 163     currData  += bytesRead;
 164
 165     if(bytesToGo == 0) {
 166       /* filled buffer with incoming data, done */
 167       break;
 168     }
 169   }
 170   *dataLength = initLen - bytesToGo;
 171
 172   return rtn;
 173 }
 174
 175 static OSStatus SocketWrite(SSLConnectionRef connection,
 176                             const void *data,
 177                             size_t *dataLength)  /* IN/OUT */
 178 {
 179   size_t bytesSent = 0;
 180   /*int sock = *(int *)connection;*/
 181   struct ssl_connect_data *connssl = (struct ssl_connect_data *)connection;
 182   int sock = connssl->ssl_sockfd;
 183   ssize_t length;
 184   size_t dataLen = *dataLength;
 185   const UInt8 *dataPtr = (UInt8 *)data;
 186   OSStatus ortn;
 187   int theErr;
 188
 189   *dataLength = 0;
 190
 191   do {
 192     length = write(sock,
 193                    (char*)dataPtr + bytesSent,
 194                    dataLen - bytesSent);
 195   } while((length > 0) &&
 196            ( (bytesSent += length) < dataLen) );
 197
 198   if(length <= 0) {
 199     theErr = errno;
 200     if(theErr == EAGAIN) {
 201       ortn = errSSLWouldBlock;
 202       connssl->ssl_direction = true;
 203     }
 204     else {
 205       ortn = ioErr;
 206     }
 207   }
 208   else {
 209     ortn = noErr;
 210   }
 211   *dataLength = bytesSent;
 212   return ortn;
 213 }
 214
 215 CF_INLINE const char *SSLCipherNameForNumber(SSLCipherSuite cipher) {
 216   switch (cipher) {
 217     /* SSL version 3.0 */
 218     case SSL_RSA_WITH_NULL_MD5:
 219       return "SSL_RSA_WITH_NULL_MD5";
 220       break;
 221     case SSL_RSA_WITH_NULL_SHA:
 222       return "SSL_RSA_WITH_NULL_SHA";
 223       break;
 224     case SSL_RSA_EXPORT_WITH_RC4_40_MD5:
 225       return "SSL_RSA_EXPORT_WITH_RC4_40_MD5";
 226       break;
 227     case SSL_RSA_WITH_RC4_128_MD5:
 228       return "SSL_RSA_WITH_RC4_128_MD5";
 229       break;
 230     case SSL_RSA_WITH_RC4_128_SHA:
 231       return "SSL_RSA_WITH_RC4_128_SHA";
 232       break;
 233     case SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5:
 234       return "SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5";
 235       break;
 236     case SSL_RSA_WITH_IDEA_CBC_SHA:
 237       return "SSL_RSA_WITH_IDEA_CBC_SHA";
 238       break;
 239     case SSL_RSA_EXPORT_WITH_DES40_CBC_SHA:
 240       return "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA";
 241       break;
 242     case SSL_RSA_WITH_DES_CBC_SHA:
 243       return "SSL_RSA_WITH_DES_CBC_SHA";
 244       break;
 245     case SSL_RSA_WITH_3DES_EDE_CBC_SHA:
 246       return "SSL_RSA_WITH_3DES_EDE_CBC_SHA";
 247       break;
 248     case SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA:
 249       return "SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA";
 250       break;
 251     case SSL_DH_DSS_WITH_DES_CBC_SHA:
 252       return "SSL_DH_DSS_WITH_DES_CBC_SHA";
 253       break;
 254     case SSL_DH_DSS_WITH_3DES_EDE_CBC_SHA:
 255       return "SSL_DH_DSS_WITH_3DES_EDE_CBC_SHA";
 256       break;
 257     case SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA:
 258       return "SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA";
 259       break;
 260     case SSL_DH_RSA_WITH_DES_CBC_SHA:
 261       return "SSL_DH_RSA_WITH_DES_CBC_SHA";
 262       break;
 263     case SSL_DH_RSA_WITH_3DES_EDE_CBC_SHA:
 264       return "SSL_DH_RSA_WITH_3DES_EDE_CBC_SHA";
 265       break;
 266     case SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA:
 267       return "SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA";
 268       break;
 269     case SSL_DHE_DSS_WITH_DES_CBC_SHA:
 270       return "SSL_DHE_DSS_WITH_DES_CBC_SHA";
 271       break;
 272     case SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA:
 273       return "SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA";
 274       break;
 275     case SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA:
 276       return "SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA";
 277       break;
 278     case SSL_DHE_RSA_WITH_DES_CBC_SHA:
 279       return "SSL_DHE_RSA_WITH_DES_CBC_SHA";
 280       break;
 281     case SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
 282       return "SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA";
 283       break;
 284     case SSL_DH_anon_EXPORT_WITH_RC4_40_MD5:
 285       return "SSL_DH_anon_EXPORT_WITH_RC4_40_MD5";
 286       break;
 287     case SSL_DH_anon_WITH_RC4_128_MD5:
 288       return "SSL_DH_anon_WITH_RC4_128_MD5";
 289       break;
 290     case SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA:
 291       return "SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA";
 292       break;
 293     case SSL_DH_anon_WITH_DES_CBC_SHA:
 294       return "SSL_DH_anon_WITH_DES_CBC_SHA";
 295       break;
 296     case SSL_DH_anon_WITH_3DES_EDE_CBC_SHA:
 297       return "SSL_DH_anon_WITH_3DES_EDE_CBC_SHA";
 298       break;
 299     case SSL_FORTEZZA_DMS_WITH_NULL_SHA:
 300       return "SSL_FORTEZZA_DMS_WITH_NULL_SHA";
 301       break;
 302     case SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA:
 303       return "SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA";
 304       break;
 305     /* TLS 1.0 with AES (RFC 3268)
 306        (Apparently these are used in SSLv3 implementations as well.) */
 307     case TLS_RSA_WITH_AES_128_CBC_SHA:
 308       return "TLS_RSA_WITH_AES_128_CBC_SHA";
 309       break;
 310     case TLS_DH_DSS_WITH_AES_128_CBC_SHA:
 311       return "TLS_DH_DSS_WITH_AES_128_CBC_SHA";
 312       break;
 313     case TLS_DH_RSA_WITH_AES_128_CBC_SHA:
 314       return "TLS_DH_RSA_WITH_AES_128_CBC_SHA";
 315       break;
 316     case TLS_DHE_DSS_WITH_AES_128_CBC_SHA:
 317       return "TLS_DHE_DSS_WITH_AES_128_CBC_SHA";
 318       break;
 319     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
 320       return "TLS_DHE_RSA_WITH_AES_128_CBC_SHA";
 321       break;
 322     case TLS_DH_anon_WITH_AES_128_CBC_SHA:
 323       return "TLS_DH_anon_WITH_AES_128_CBC_SHA";
 324       break;
 325     case TLS_RSA_WITH_AES_256_CBC_SHA:
 326       return "TLS_RSA_WITH_AES_256_CBC_SHA";
 327       break;
 328     case TLS_DH_DSS_WITH_AES_256_CBC_SHA:
 329       return "TLS_DH_DSS_WITH_AES_256_CBC_SHA";
 330       break;
 331     case TLS_DH_RSA_WITH_AES_256_CBC_SHA:
 332       return "TLS_DH_RSA_WITH_AES_256_CBC_SHA";
 333       break;
 334     case TLS_DHE_DSS_WITH_AES_256_CBC_SHA:
 335       return "TLS_DHE_DSS_WITH_AES_256_CBC_SHA";
 336       break;
 337     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
 338       return "TLS_DHE_RSA_WITH_AES_256_CBC_SHA";
 339       break;
 340     case TLS_DH_anon_WITH_AES_256_CBC_SHA:
 341       return "TLS_DH_anon_WITH_AES_256_CBC_SHA";
 342       break;
 343     /* SSL version 2.0 */
 344     case SSL_RSA_WITH_RC2_CBC_MD5:
 345       return "SSL_RSA_WITH_RC2_CBC_MD5";
 346       break;
 347     case SSL_RSA_WITH_IDEA_CBC_MD5:
 348       return "SSL_RSA_WITH_IDEA_CBC_MD5";
 349       break;
 350     case SSL_RSA_WITH_DES_CBC_MD5:
 351       return "SSL_RSA_WITH_DES_CBC_MD5";
 352       break;
 353     case SSL_RSA_WITH_3DES_EDE_CBC_MD5:
 354       return "SSL_RSA_WITH_3DES_EDE_CBC_MD5";
 355       break;
 356   }
 357   return "SSL_NULL_WITH_NULL_NULL";
 358 }
 359
 360 CF_INLINE const char *TLSCipherNameForNumber(SSLCipherSuite cipher) {
 361   switch(cipher) {
 362     /* TLS 1.0 with AES (RFC 3268) */
 363     case TLS_RSA_WITH_AES_128_CBC_SHA:
 364       return "TLS_RSA_WITH_AES_128_CBC_SHA";
 365       break;
 366     case TLS_DH_DSS_WITH_AES_128_CBC_SHA:
 367       return "TLS_DH_DSS_WITH_AES_128_CBC_SHA";
 368       break;
 369     case TLS_DH_RSA_WITH_AES_128_CBC_SHA:
 370       return "TLS_DH_RSA_WITH_AES_128_CBC_SHA";
 371       break;
 372     case TLS_DHE_DSS_WITH_AES_128_CBC_SHA:
 373       return "TLS_DHE_DSS_WITH_AES_128_CBC_SHA";
 374       break;
 375     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
 376       return "TLS_DHE_RSA_WITH_AES_128_CBC_SHA";
 377       break;
 378     case TLS_DH_anon_WITH_AES_128_CBC_SHA:
 379       return "TLS_DH_anon_WITH_AES_128_CBC_SHA";
 380       break;
 381     case TLS_RSA_WITH_AES_256_CBC_SHA:
 382       return "TLS_RSA_WITH_AES_256_CBC_SHA";
 383       break;
 384     case TLS_DH_DSS_WITH_AES_256_CBC_SHA:
 385       return "TLS_DH_DSS_WITH_AES_256_CBC_SHA";
 386       break;
 387     case TLS_DH_RSA_WITH_AES_256_CBC_SHA:
 388       return "TLS_DH_RSA_WITH_AES_256_CBC_SHA";
 389       break;
 390     case TLS_DHE_DSS_WITH_AES_256_CBC_SHA:
 391       return "TLS_DHE_DSS_WITH_AES_256_CBC_SHA";
 392       break;
 393     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
 394       return "TLS_DHE_RSA_WITH_AES_256_CBC_SHA";
 395       break;
 396     case TLS_DH_anon_WITH_AES_256_CBC_SHA:
 397       return "TLS_DH_anon_WITH_AES_256_CBC_SHA";
 398       break;
 399 #if CURL_BUILD_MAC_10_6 || CURL_BUILD_IOS
 400     /* TLS 1.0 with ECDSA (RFC 4492) */
 401     case TLS_ECDH_ECDSA_WITH_NULL_SHA:
 402       return "TLS_ECDH_ECDSA_WITH_NULL_SHA";
 403       break;
 404     case TLS_ECDH_ECDSA_WITH_RC4_128_SHA:
 405       return "TLS_ECDH_ECDSA_WITH_RC4_128_SHA";
 406       break;
 407     case TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA:
 408       return "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA";
 409       break;
 410     case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA:
 411       return "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA";
 412       break;
 413     case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
 414       return "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA";
 415       break;
 416     case TLS_ECDHE_ECDSA_WITH_NULL_SHA:
 417       return "TLS_ECDHE_ECDSA_WITH_NULL_SHA";
 418       break;
 419     case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:
 420       return "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA";
 421       break;
 422     case TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA:
 423       return "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA";
 424       break;
 425     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:
 426       return "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA";
 427       break;
 428     case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
 429       return "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA";
 430       break;
 431     case TLS_ECDH_RSA_WITH_NULL_SHA:
 432       return "TLS_ECDH_RSA_WITH_NULL_SHA";
 433       break;
 434     case TLS_ECDH_RSA_WITH_RC4_128_SHA:
 435       return "TLS_ECDH_RSA_WITH_RC4_128_SHA";
 436       break;
 437     case TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA:
 438       return "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA";
 439       break;
 440     case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA:
 441       return "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA";
 442       break;
 443     case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
 444       return "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA";
 445       break;
 446     case TLS_ECDHE_RSA_WITH_NULL_SHA:
 447       return "TLS_ECDHE_RSA_WITH_NULL_SHA";
 448       break;
 449     case TLS_ECDHE_RSA_WITH_RC4_128_SHA:
 450       return "TLS_ECDHE_RSA_WITH_RC4_128_SHA";
 451       break;
 452     case TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:
 453       return "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA";
 454       break;
 455     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:
 456       return "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA";
 457       break;
 458     case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
 459       return "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA";
 460       break;
 461     case TLS_ECDH_anon_WITH_NULL_SHA:
 462       return "TLS_ECDH_anon_WITH_NULL_SHA";
 463       break;
 464     case TLS_ECDH_anon_WITH_RC4_128_SHA:
 465       return "TLS_ECDH_anon_WITH_RC4_128_SHA";
 466       break;
 467     case TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA:
 468       return "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA";
 469       break;
 470     case TLS_ECDH_anon_WITH_AES_128_CBC_SHA:
 471       return "TLS_ECDH_anon_WITH_AES_128_CBC_SHA";
 472       break;
 473     case TLS_ECDH_anon_WITH_AES_256_CBC_SHA:
 474       return "TLS_ECDH_anon_WITH_AES_256_CBC_SHA";
 475       break;
 476 #endif /* CURL_BUILD_MAC_10_6 || CURL_BUILD_IOS */
 477 #if CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS
 478     /* TLS 1.2 (RFC 5246) */
 479     case TLS_RSA_WITH_NULL_MD5:
 480       return "TLS_RSA_WITH_NULL_MD5";
 481       break;
 482     case TLS_RSA_WITH_NULL_SHA:
 483       return "TLS_RSA_WITH_NULL_SHA";
 484       break;
 485     case TLS_RSA_WITH_RC4_128_MD5:
 486       return "TLS_RSA_WITH_RC4_128_MD5";
 487       break;
 488     case TLS_RSA_WITH_RC4_128_SHA:
 489       return "TLS_RSA_WITH_RC4_128_SHA";
 490       break;
 491     case TLS_RSA_WITH_3DES_EDE_CBC_SHA:
 492       return "TLS_RSA_WITH_3DES_EDE_CBC_SHA";
 493       break;
 494     case TLS_RSA_WITH_NULL_SHA256:
 495       return "TLS_RSA_WITH_NULL_SHA256";
 496       break;
 497     case TLS_RSA_WITH_AES_128_CBC_SHA256:
 498       return "TLS_RSA_WITH_AES_128_CBC_SHA256";
 499       break;
 500     case TLS_RSA_WITH_AES_256_CBC_SHA256:
 501       return "TLS_RSA_WITH_AES_256_CBC_SHA256";
 502       break;
 503     case TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
 504       return "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA";
 505       break;
 506     case TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA:
 507       return "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA";
 508       break;
 509     case TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA:
 510       return "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA";
 511       break;
 512     case TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
 513       return "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA";
 514       break;
 515     case TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
 516       return "TLS_DH_DSS_WITH_AES_128_CBC_SHA256";
 517       break;
 518     case TLS_DH_RSA_WITH_AES_128_CBC_SHA256:
 519       return "TLS_DH_RSA_WITH_AES_128_CBC_SHA256";
 520       break;
 521     case TLS_DHE_DSS_WITH_AES_128_CBC_SHA256:
 522       return "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256";
 523       break;
 524     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:
 525       return "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256";
 526       break;
 527     case TLS_DH_DSS_WITH_AES_256_CBC_SHA256:
 528       return "TLS_DH_DSS_WITH_AES_256_CBC_SHA256";
 529       break;
 530     case TLS_DH_RSA_WITH_AES_256_CBC_SHA256:
 531       return "TLS_DH_RSA_WITH_AES_256_CBC_SHA256";
 532       break;
 533     case TLS_DHE_DSS_WITH_AES_256_CBC_SHA256:
 534       return "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256";
 535       break;
 536     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:
 537       return "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256";
 538       break;
 539     case TLS_DH_anon_WITH_RC4_128_MD5:
 540       return "TLS_DH_anon_WITH_RC4_128_MD5";
 541       break;
 542     case TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
 543       return "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA";
 544       break;
 545     case TLS_DH_anon_WITH_AES_128_CBC_SHA256:
 546       return "TLS_DH_anon_WITH_AES_128_CBC_SHA256";
 547       break;
 548     case TLS_DH_anon_WITH_AES_256_CBC_SHA256:
 549       return "TLS_DH_anon_WITH_AES_256_CBC_SHA256";
 550       break;
 551     /* TLS 1.2 with AES GCM (RFC 5288) */
 552     case TLS_RSA_WITH_AES_128_GCM_SHA256:
 553       return "TLS_RSA_WITH_AES_128_GCM_SHA256";
 554       break;
 555     case TLS_RSA_WITH_AES_256_GCM_SHA384:
 556       return "TLS_RSA_WITH_AES_256_GCM_SHA384";
 557       break;
 558     case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:
 559       return "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256";
 560       break;
 561     case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:
 562       return "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384";
 563       break;
 564     case TLS_DH_RSA_WITH_AES_128_GCM_SHA256:
 565       return "TLS_DH_RSA_WITH_AES_128_GCM_SHA256";
 566       break;
 567     case TLS_DH_RSA_WITH_AES_256_GCM_SHA384:
 568       return "TLS_DH_RSA_WITH_AES_256_GCM_SHA384";
 569       break;
 570     case TLS_DHE_DSS_WITH_AES_128_GCM_SHA256:
 571       return "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256";
 572       break;
 573     case TLS_DHE_DSS_WITH_AES_256_GCM_SHA384:
 574       return "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384";
 575       break;
 576     case TLS_DH_DSS_WITH_AES_128_GCM_SHA256:
 577       return "TLS_DH_DSS_WITH_AES_128_GCM_SHA256";
 578       break;
 579     case TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
 580       return "TLS_DH_DSS_WITH_AES_256_GCM_SHA384";
 581       break;
 582     case TLS_DH_anon_WITH_AES_128_GCM_SHA256:
 583       return "TLS_DH_anon_WITH_AES_128_GCM_SHA256";
 584       break;
 585     case TLS_DH_anon_WITH_AES_256_GCM_SHA384:
 586       return "TLS_DH_anon_WITH_AES_256_GCM_SHA384";
 587       break;
 588     /* TLS 1.2 with elliptic curve ciphers (RFC 5289) */
 589     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
 590       return "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256";
 591       break;
 592     case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
 593       return "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384";
 594       break;
 595     case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256:
 596       return "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256";
 597       break;
 598     case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384:
 599       return "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384";
 600       break;
 601     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
 602       return "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256";
 603       break;
 604     case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:
 605       return "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384";
 606       break;
 607     case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256:
 608       return "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256";
 609       break;
 610     case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384:
 611       return "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384";
 612       break;
 613     case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
 614       return "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256";
 615       break;
 616     case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
 617       return "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384";
 618       break;
 619     case TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256:
 620       return "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256";
 621       break;
 622     case TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384:
 623       return "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384";
 624       break;
 625     case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
 626       return "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256";
 627       break;
 628     case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
 629       return "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384";
 630       break;
 631     case TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256:
 632       return "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256";
 633       break;
 634     case TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384:
 635       return "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384";
 636       break;
 637     case TLS_EMPTY_RENEGOTIATION_INFO_SCSV:
 638       return "TLS_EMPTY_RENEGOTIATION_INFO_SCSV";
 639       break;
 640 #else
 641     case SSL_RSA_WITH_NULL_MD5:
 642       return "TLS_RSA_WITH_NULL_MD5";
 643       break;
 644     case SSL_RSA_WITH_NULL_SHA:
 645       return "TLS_RSA_WITH_NULL_SHA";
 646       break;
 647     case SSL_RSA_WITH_RC4_128_MD5:
 648       return "TLS_RSA_WITH_RC4_128_MD5";
 649       break;
 650     case SSL_RSA_WITH_RC4_128_SHA:
 651       return "TLS_RSA_WITH_RC4_128_SHA";
 652       break;
 653     case SSL_RSA_WITH_3DES_EDE_CBC_SHA:
 654       return "TLS_RSA_WITH_3DES_EDE_CBC_SHA";
 655       break;
 656     case SSL_DH_anon_WITH_RC4_128_MD5:
 657       return "TLS_DH_anon_WITH_RC4_128_MD5";
 658       break;
 659     case SSL_DH_anon_WITH_3DES_EDE_CBC_SHA:
 660       return "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA";
 661       break;
 662 #endif /* CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS */
 663   }
 664   return "TLS_NULL_WITH_NULL_NULL";
 665 }
 666
 667 #if CURL_BUILD_MAC
 668 CF_INLINE void GetDarwinVersionNumber(int *major, int *minor)
 669 {
 670   int mib[2];
 671   char *os_version;
 672   size_t os_version_len;
 673   char *os_version_major, *os_version_minor/*, *os_version_point*/;
 674
 675   /* Get the Darwin kernel version from the kernel using sysctl(): */
 676   mib[0] = CTL_KERN;
 677   mib[1] = KERN_OSRELEASE;
 678   if(sysctl(mib, 2, NULL, &os_version_len, NULL, 0) == -1)
 679     return;
 680   os_version = malloc(os_version_len*sizeof(char));
 681   if(!os_version)
 682     return;
 683   if(sysctl(mib, 2, os_version, &os_version_len, NULL, 0) == -1) {
 684     free(os_version);
 685     return;
 686   }
 687
 688   /* Parse the version: */
 689   os_version_major = strtok(os_version, ".");
 690   os_version_minor = strtok(NULL, ".");
 691   /*os_version_point = strtok(NULL, ".");*/
 692   *major = atoi(os_version_major);
 693   *minor = atoi(os_version_minor);
 694   free(os_version);
 695 }
 696 #endif /* CURL_BUILD_MAC */
 697
 698 /* Apple provides a myriad of ways of getting information about a certificate
 699    into a string. Some aren't available under iOS or newer cats. So here's
 700    a unified function for getting a string describing the certificate that
 701    ought to work in all cats starting with Leopard. */
 702 CF_INLINE CFStringRef CopyCertSubject(SecCertificateRef cert)
 703 {
 704   CFStringRef server_cert_summary = CFSTR("(null)");
 705
 706 #if CURL_BUILD_IOS
 707   /* iOS: There's only one way to do this. */
 708   server_cert_summary = SecCertificateCopySubjectSummary(cert);
 709 #else
 710 #if CURL_BUILD_MAC_10_7
 711   /* Lion & later: Get the long description if we can. */
 712   if(SecCertificateCopyLongDescription != NULL)
 713     server_cert_summary =
 714       SecCertificateCopyLongDescription(NULL, cert, NULL);
 715   else
 716 #endif /* CURL_BUILD_MAC_10_7 */
 717 #if CURL_BUILD_MAC_10_6
 718   /* Snow Leopard: Get the certificate summary. */
 719   if(SecCertificateCopySubjectSummary != NULL)
 720     server_cert_summary = SecCertificateCopySubjectSummary(cert);
 721   else
 722 #endif /* CURL_BUILD_MAC_10_6 */
 723   /* Leopard is as far back as we go... */
 724   (void)SecCertificateCopyCommonName(cert, &server_cert_summary);
 725 #endif /* CURL_BUILD_IOS */
 726   return server_cert_summary;
 727 }
 728
 729 #if CURL_SUPPORT_MAC_10_7
 730 /* The SecKeychainSearch API was deprecated in Lion, and using it will raise
 731    deprecation warnings, so let's not compile this unless it's necessary: */
 732 static OSStatus CopyIdentityWithLabelOldSchool(char *label,
 733                                                SecIdentityRef *out_c_a_k)
 734 {
 735   OSStatus status = errSecItemNotFound;
 736   SecKeychainAttributeList attr_list;
 737   SecKeychainAttribute attr;
 738   SecKeychainSearchRef search = NULL;
 739   SecCertificateRef cert = NULL;
 740
 741   /* Set up the attribute list: */
 742   attr_list.count = 1L;
 743   attr_list.attr = &attr;
 744
 745   /* Set up our lone search criterion: */
 746   attr.tag = kSecLabelItemAttr;
 747   attr.data = label;
 748   attr.length = (UInt32)strlen(label);
 749
 750   /* Start searching: */
 751   status = SecKeychainSearchCreateFromAttributes(NULL,
 752                                                  kSecCertificateItemClass,
 753                                                  &attr_list,
 754                                                  &search);
 755   if(status == noErr) {
 756     status = SecKeychainSearchCopyNext(search,
 757                                        (SecKeychainItemRef *)&cert);
 758     if(status == noErr && cert) {
 759       /* If we found a certificate, does it have a private key? */
 760       status = SecIdentityCreateWithCertificate(NULL, cert, out_c_a_k);
 761       CFRelease(cert);
 762     }
 763   }
 764
 765   if(search)
 766     CFRelease(search);
 767   return status;
 768 }
 769 #endif /* CURL_SUPPORT_MAC_10_7 */
 770
 771 static OSStatus CopyIdentityWithLabel(char *label,
 772                                       SecIdentityRef *out_cert_and_key)
 773 {
 774   OSStatus status = errSecItemNotFound;
 775
 776 #if CURL_BUILD_MAC_10_7 || CURL_BUILD_IOS
 777   /* SecItemCopyMatching() was introduced in iOS and Snow Leopard.
 778      kSecClassIdentity was introduced in Lion. If both exist, let's use them
 779      to find the certificate. */
 780   if(SecItemCopyMatching != NULL && kSecClassIdentity != NULL) {
 781     CFTypeRef keys[4];
 782     CFTypeRef values[4];
 783     CFDictionaryRef query_dict;
 784     CFStringRef label_cf = CFStringCreateWithCString(NULL, label,
 785       kCFStringEncodingUTF8);
 786
 787     /* Set up our search criteria and expected results: */
 788     values[0] = kSecClassIdentity; /* we want a certificate and a key */
 789     keys[0] = kSecClass;
 790     values[1] = kCFBooleanTrue;    /* we want a reference */
 791     keys[1] = kSecReturnRef;
 792     values[2] = kSecMatchLimitOne; /* one is enough, thanks */
 793     keys[2] = kSecMatchLimit;
 794     /* identity searches need a SecPolicyRef in order to work */
 795     values[3] = SecPolicyCreateSSL(false, label_cf);
 796     keys[3] = kSecMatchPolicy;
 797     query_dict = CFDictionaryCreate(NULL, (const void **)keys,
 798                                    (const void **)values, 4L,
 799                                    &kCFCopyStringDictionaryKeyCallBacks,
 800                                    &kCFTypeDictionaryValueCallBacks);
 801     CFRelease(values[3]);
 802     CFRelease(label_cf);
 803
 804     /* Do we have a match? */
 805     status = SecItemCopyMatching(query_dict, (CFTypeRef *)out_cert_and_key);
 806     CFRelease(query_dict);
 807   }
 808   else {
 809 #if CURL_SUPPORT_MAC_10_7
 810     /* On Leopard and Snow Leopard, fall back to SecKeychainSearch. */
 811     status = CopyIdentityWithLabelOldSchool(label, out_cert_and_key);
 812 #endif /* CURL_SUPPORT_MAC_10_7 */
 813   }
 814 #elif CURL_SUPPORT_MAC_10_7
 815   /* For developers building on older cats, we have no choice but to fall back
 816      to SecKeychainSearch. */
 817   status = CopyIdentityWithLabelOldSchool(label, out_cert_and_key);
 818 #endif /* CURL_BUILD_MAC_10_7 || CURL_BUILD_IOS */
 819   return status;
 820 }
 821
 822 static CURLcode darwinssl_connect_step1(struct connectdata *conn,
 823                                         int sockindex)
 824 {
 825   struct SessionHandle *data = conn->data;
 826   curl_socket_t sockfd = conn->sock[sockindex];
 827   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
 828 #ifdef ENABLE_IPV6
 829   struct in6_addr addr;
 830 #else
 831   struct in_addr addr;
 832 #endif /* ENABLE_IPV6 */
 833   size_t all_ciphers_count = 0UL, allowed_ciphers_count = 0UL, i;
 834   SSLCipherSuite *all_ciphers = NULL, *allowed_ciphers = NULL;
 835   char *ssl_sessionid;
 836   size_t ssl_sessionid_len;
 837   OSStatus err = noErr;
 838 #if CURL_BUILD_MAC
 839   int darwinver_maj = 0, darwinver_min = 0;
 840
 841   GetDarwinVersionNumber(&darwinver_maj, &darwinver_min);
 842 #endif /* CURL_BUILD_MAC */
 843
 844 #if CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS
 845   if(SSLCreateContext != NULL) {  /* use the newer API if avaialble */
 846     if(connssl->ssl_ctx)
 847       CFRelease(connssl->ssl_ctx);
 848     connssl->ssl_ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);
 849     if(!connssl->ssl_ctx) {
 850       failf(data, "SSL: couldn't create a context!");
 851       return CURLE_OUT_OF_MEMORY;
 852     }
 853   }
 854   else {
 855   /* The old ST API does not exist under iOS, so don't compile it: */
 856 #if CURL_SUPPORT_MAC_10_8
 857     if(connssl->ssl_ctx)
 858       (void)SSLDisposeContext(connssl->ssl_ctx);
 859     err = SSLNewContext(false, &(connssl->ssl_ctx));
 860     if(err != noErr) {
 861       failf(data, "SSL: couldn't create a context: OSStatus %d", err);
 862       return CURLE_OUT_OF_MEMORY;
 863     }
 864 #endif /* CURL_SUPPORT_MAC_10_8 */
 865   }
 866 #else
 867   if(connssl->ssl_ctx)
 868     (void)SSLDisposeContext(connssl->ssl_ctx);
 869   err = SSLNewContext(false, &(connssl->ssl_ctx));
 870   if(err != noErr) {
 871     failf(data, "SSL: couldn't create a context: OSStatus %d", err);
 872     return CURLE_OUT_OF_MEMORY;
 873   }
 874 #endif /* CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS */
 875   connssl->ssl_write_buffered_length = 0UL; /* reset buffered write length */
 876
 877   /* check to see if we've been told to use an explicit SSL/TLS version */
 878 #if CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS
 879   if(SSLSetProtocolVersionMax != NULL) {
 880     switch(data->set.ssl.version) {
 881       case CURL_SSLVERSION_DEFAULT: default:
 882         (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol3);
 883         (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kTLSProtocol12);
 884         break;
 885       case CURL_SSLVERSION_TLSv1:
 886         (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kTLSProtocol1);
 887         (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kTLSProtocol12);
 888         break;
 889       case CURL_SSLVERSION_SSLv3:
 890         (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol3);
 891         (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kSSLProtocol3);
 892         break;
 893       case CURL_SSLVERSION_SSLv2:
 894         err = SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol2);
 895         if(err != noErr) {
 896           failf(data, "Your version of the OS does not support SSLv2");
 897           return CURLE_SSL_CONNECT_ERROR;
 898         }
 899         (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kSSLProtocol2);
 900     }
 901   }
 902   else {
 903 #if CURL_SUPPORT_MAC_10_8
 904     (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 905                                        kSSLProtocolAll,
 906                                        false);
 907     switch (data->set.ssl.version) {
 908       case CURL_SSLVERSION_DEFAULT: default:
 909         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 910                                            kSSLProtocol3,
 911                                            true);
 912         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 913                                            kTLSProtocol1,
 914                                            true);
 915         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 916                                            kTLSProtocol11,
 917                                            true);
 918         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 919                                            kTLSProtocol12,
 920                                            true);
 921         break;
 922       case CURL_SSLVERSION_TLSv1:
 923         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 924                                            kTLSProtocol1,
 925                                            true);
 926         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 927                                            kTLSProtocol11,
 928                                            true);
 929         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 930                                            kTLSProtocol12,
 931                                            true);
 932         break;
 933       case CURL_SSLVERSION_SSLv3:
 934         (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 935                                            kSSLProtocol3,
 936                                            true);
 937         break;
 938       case CURL_SSLVERSION_SSLv2:
 939         err = SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 940                                            kSSLProtocol2,
 941                                            true);
 942         if(err != noErr) {
 943           failf(data, "Your version of the OS does not support SSLv2");
 944           return CURLE_SSL_CONNECT_ERROR;
 945         }
 946         break;
 947     }
 948 #endif  /* CURL_SUPPORT_MAC_10_8 */
 949   }
 950 #else
 951   (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, kSSLProtocolAll, false);
 952   switch(data->set.ssl.version) {
 953     default:
 954     case CURL_SSLVERSION_DEFAULT:
 955       (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 956                                          kSSLProtocol3,
 957                                          true);
 958       (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 959                                          kTLSProtocol1,
 960                                          true);
 961       break;
 962     case CURL_SSLVERSION_TLSv1:
 963       (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 964                                          kTLSProtocol1,
 965                                          true);
 966       break;
 967     case CURL_SSLVERSION_SSLv2:
 968       err = SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 969                                          kSSLProtocol2,
 970                                          true);
 971       if(err != noErr) {
 972         failf(data, "Your version of the OS does not support SSLv2");
 973         return CURLE_SSL_CONNECT_ERROR;
 974       }
 975       break;
 976     case CURL_SSLVERSION_SSLv3:
 977       (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx,
 978                                          kSSLProtocol3,
 979                                          true);
 980       break;
 981   }
 982 #endif /* CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS */
 983
 984   if(data->set.str[STRING_KEY]) {
 985     infof(data, "WARNING: SSL: CURLOPT_SSLKEY is ignored by Secure "
 986                 "Transport. The private key must be in the Keychain.\n");
 987   }
 988
 989   if(data->set.str[STRING_CERT]) {
 990     SecIdentityRef cert_and_key = NULL;
 991
 992     /* User wants to authenticate with a client cert. Look for it: */
 993     err = CopyIdentityWithLabel(data->set.str[STRING_CERT], &cert_and_key);
 994     if(err == noErr) {
 995       SecCertificateRef cert = NULL;
 996       CFTypeRef certs_c[1];
 997       CFArrayRef certs;
 998
 999       /* If we found one, print it out: */
1000       err = SecIdentityCopyCertificate(cert_and_key, &cert);
1001       if(err == noErr) {
1002         CFStringRef cert_summary = CopyCertSubject(cert);
1003         char cert_summary_c[128];
1004
1005         if(cert_summary) {
1006           memset(cert_summary_c, 0, 128);
1007           if(CFStringGetCString(cert_summary,
1008                                 cert_summary_c,
1009                                 128,
1010                                 kCFStringEncodingUTF8)) {
1011             infof(data, "Client certificate: %s\n", cert_summary_c);
1012           }
1013           CFRelease(cert_summary);
1014           CFRelease(cert);
1015         }
1016       }
1017       certs_c[0] = cert_and_key;
1018       certs = CFArrayCreate(NULL, (const void **)certs_c, 1L,
1019                             &kCFTypeArrayCallBacks);
1020       err = SSLSetCertificate(connssl->ssl_ctx, certs);
1021       if(certs)
1022         CFRelease(certs);
1023       if(err != noErr) {
1024         failf(data, "SSL: SSLSetCertificate() failed: OSStatus %d", err);
1025         return CURLE_SSL_CERTPROBLEM;
1026       }
1027       CFRelease(cert_and_key);
1028     }
1029     else {
1030       failf(data, "SSL: Can't find the certificate \"%s\" and its private key "
1031                   "in the Keychain.", data->set.str[STRING_CERT]);
1032       return CURLE_SSL_CERTPROBLEM;
1033     }
1034   }
1035
1036   /* SSL always tries to verify the peer, this only says whether it should
1037    * fail to connect if the verification fails, or if it should continue
1038    * anyway. In the latter case the result of the verification is checked with
1039    * SSL_get_verify_result() below. */
1040 #if CURL_BUILD_MAC_10_6 || CURL_BUILD_IOS
1041   /* Snow Leopard introduced the SSLSetSessionOption() function, but due to
1042      a library bug with the way the kSSLSessionOptionBreakOnServerAuth flag
1043      works, it doesn't work as expected under Snow Leopard or Lion.
1044      So we need to call SSLSetEnableCertVerify() on those older cats in order
1045      to disable certificate validation if the user turned that off.
1046      (SecureTransport will always validate the certificate chain by
1047      default.) */
1048   /* (Note: Darwin 12.x.x is Mountain Lion.) */
1049 #if CURL_BUILD_MAC
1050   if(SSLSetSessionOption != NULL && darwinver_maj >= 12) {
1051 #else
1052   if(SSLSetSessionOption != NULL) {
1053 #endif /* CURL_BUILD_MAC */
1054     err = SSLSetSessionOption(connssl->ssl_ctx,
1055                               kSSLSessionOptionBreakOnServerAuth,
1056                               data->set.ssl.verifypeer?false:true);
1057     if(err != noErr) {
1058       failf(data, "SSL: SSLSetSessionOption() failed: OSStatus %d", err);
1059       return CURLE_SSL_CONNECT_ERROR;
1060     }
1061   }
1062   else {
1063 #if CURL_SUPPORT_MAC_10_8
1064     err = SSLSetEnableCertVerify(connssl->ssl_ctx,
1065                                  data->set.ssl.verifypeer?true:false);
1066     if(err != noErr) {
1067       failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err);
1068       return CURLE_SSL_CONNECT_ERROR;
1069     }
1070 #endif /* CURL_SUPPORT_MAC_10_8 */
1071   }
1072 #else
1073   err = SSLSetEnableCertVerify(connssl->ssl_ctx,
1074                                data->set.ssl.verifypeer?true:false);
1075   if(err != noErr) {
1076     failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err);
1077     return CURLE_SSL_CONNECT_ERROR;
1078   }
1079 #endif /* CURL_BUILD_MAC_10_6 || CURL_BUILD_IOS */
1080
1081   /* If this is a domain name and not an IP address, then configure SNI.
1082    * Also: the verifyhost setting influences SNI usage */
1083   /* If this is a domain name and not an IP address, then configure SNI: */
1084   if((0 == Curl_inet_pton(AF_INET, conn->host.name, &addr)) &&
1085 #ifdef ENABLE_IPV6
1086      (0 == Curl_inet_pton(AF_INET6, conn->host.name, &addr)) &&
1087 #endif
1088      data->set.ssl.verifyhost) {
1089     err = SSLSetPeerDomainName(connssl->ssl_ctx, conn->host.name,
1090                                strlen(conn->host.name));
1091     if(err != noErr) {
1092       infof(data, "WARNING: SSL: SSLSetPeerDomainName() failed: OSStatus %d\n",
1093             err);
1094     }
1095   }
1096
1097   /* Disable cipher suites that ST supports but are not safe. These ciphers
1098      are unlikely to be used in any case since ST gives other ciphers a much
1099      higher priority, but it's probably better that we not connect at all than
1100      to give the user a false sense of security if the server only supports
1101      insecure ciphers. (Note: We don't care about SSLv2-only ciphers.) */
1102   (void)SSLGetNumberSupportedCiphers(connssl->ssl_ctx, &all_ciphers_count);
1103   all_ciphers = malloc(all_ciphers_count*sizeof(SSLCipherSuite));
1104   allowed_ciphers = malloc(all_ciphers_count*sizeof(SSLCipherSuite));
1105   if(all_ciphers && allowed_ciphers &&
1106      SSLGetSupportedCiphers(connssl->ssl_ctx, all_ciphers,
1107        &all_ciphers_count) == noErr) {
1108     for(i = 0UL ; i < all_ciphers_count ; i++) {
1109 #if CURL_BUILD_MAC
1110      /* There's a known bug in early versions of Mountain Lion where ST's ECC
1111         ciphers (cipher suite 0xC001 through 0xC032) simply do not work.
1112         Work around the problem here by disabling those ciphers if we are
1113         running in an affected version of OS X. */
1114       if(darwinver_maj == 12 && darwinver_min <= 3 &&
1115          all_ciphers[i] >= 0xC001 && all_ciphers[i] <= 0xC032) {
1116            continue;
1117       }
1118 #endif /* CURL_BUILD_MAC */
1119       switch(all_ciphers[i]) {
1120         /* Disable NULL ciphersuites: */
1121         case SSL_NULL_WITH_NULL_NULL:
1122         case SSL_RSA_WITH_NULL_MD5:
1123         case SSL_RSA_WITH_NULL_SHA:
1124         case SSL_FORTEZZA_DMS_WITH_NULL_SHA:
1125         case 0xC001: /* TLS_ECDH_ECDSA_WITH_NULL_SHA */
1126         case 0xC006: /* TLS_ECDHE_ECDSA_WITH_NULL_SHA */
1127         case 0xC00B: /* TLS_ECDH_RSA_WITH_NULL_SHA */
1128         case 0xC010: /* TLS_ECDHE_RSA_WITH_NULL_SHA */
1129         /* Disable anonymous ciphersuites: */
1130         case SSL_DH_anon_EXPORT_WITH_RC4_40_MD5:
1131         case SSL_DH_anon_WITH_RC4_128_MD5:
1132         case SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA:
1133         case SSL_DH_anon_WITH_DES_CBC_SHA:
1134         case SSL_DH_anon_WITH_3DES_EDE_CBC_SHA:
1135         case TLS_DH_anon_WITH_AES_128_CBC_SHA:
1136         case TLS_DH_anon_WITH_AES_256_CBC_SHA:
1137         case 0xC015: /* TLS_ECDH_anon_WITH_NULL_SHA */
1138         case 0xC016: /* TLS_ECDH_anon_WITH_RC4_128_SHA */
1139         case 0xC017: /* TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA */
1140         case 0xC018: /* TLS_ECDH_anon_WITH_AES_128_CBC_SHA */
1141         case 0xC019: /* TLS_ECDH_anon_WITH_AES_256_CBC_SHA */
1142         case 0x006C: /* TLS_DH_anon_WITH_AES_128_CBC_SHA256 */
1143         case 0x006D: /* TLS_DH_anon_WITH_AES_256_CBC_SHA256 */
1144         case 0x00A6: /* TLS_DH_anon_WITH_AES_128_GCM_SHA256 */
1145         case 0x00A7: /* TLS_DH_anon_WITH_AES_256_GCM_SHA384 */
1146         /* Disable weak key ciphersuites: */
1147         case SSL_RSA_EXPORT_WITH_RC4_40_MD5:
1148         case SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5:
1149         case SSL_RSA_EXPORT_WITH_DES40_CBC_SHA:
1150         case SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA:
1151         case SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA:
1152         case SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA:
1153         case SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA:
1154         case SSL_RSA_WITH_DES_CBC_SHA:
1155         case SSL_DH_DSS_WITH_DES_CBC_SHA:
1156         case SSL_DH_RSA_WITH_DES_CBC_SHA:
1157         case SSL_DHE_DSS_WITH_DES_CBC_SHA:
1158         case SSL_DHE_RSA_WITH_DES_CBC_SHA:
1159         /* Disable IDEA: */
1160         case SSL_RSA_WITH_IDEA_CBC_SHA:
1161         case SSL_RSA_WITH_IDEA_CBC_MD5:
1162           break;
1163         default: /* enable everything else */
1164           allowed_ciphers[allowed_ciphers_count++] = all_ciphers[i];
1165           break;
1166       }
1167     }
1168     err = SSLSetEnabledCiphers(connssl->ssl_ctx, allowed_ciphers,
1169                                allowed_ciphers_count);
1170     if(err != noErr) {
1171       failf(data, "SSL: SSLSetEnabledCiphers() failed: OSStatus %d", err);
1172       return CURLE_SSL_CONNECT_ERROR;
1173     }
1174   }
1175   else {
1176     Curl_safefree(all_ciphers);
1177     Curl_safefree(allowed_ciphers);
1178     failf(data, "SSL: Failed to allocate memory for allowed ciphers");
1179     return CURLE_OUT_OF_MEMORY;
1180   }
1181   Curl_safefree(all_ciphers);
1182   Curl_safefree(allowed_ciphers);
1183
1184   /* Check if there's a cached ID we can/should use here! */
1185   if(!Curl_ssl_getsessionid(conn, (void **)&ssl_sessionid,
1186     &ssl_sessionid_len)) {
1187     /* we got a session id, use it! */
1188     err = SSLSetPeerID(connssl->ssl_ctx, ssl_sessionid, ssl_sessionid_len);
1189     if(err != noErr) {
1190       failf(data, "SSL: SSLSetPeerID() failed: OSStatus %d", err);
1191       return CURLE_SSL_CONNECT_ERROR;
1192     }
1193     /* Informational message */
1194     infof(data, "SSL re-using session ID\n");
1195   }
1196   /* If there isn't one, then let's make one up! This has to be done prior
1197      to starting the handshake. */
1198   else {
1199     CURLcode retcode;
1200
1201     ssl_sessionid = malloc(256*sizeof(char));
1202     ssl_sessionid_len = snprintf(ssl_sessionid, 256, "curl:%s:%hu",
1203       conn->host.name, conn->remote_port);
1204     err = SSLSetPeerID(connssl->ssl_ctx, ssl_sessionid, ssl_sessionid_len);
1205     if(err != noErr) {
1206       failf(data, "SSL: SSLSetPeerID() failed: OSStatus %d", err);
1207       return CURLE_SSL_CONNECT_ERROR;
1208     }
1209     retcode = Curl_ssl_addsessionid(conn, ssl_sessionid, ssl_sessionid_len);
1210     if(retcode!= CURLE_OK) {
1211       failf(data, "failed to store ssl session");
1212       return retcode;
1213     }
1214   }
1215
1216   err = SSLSetIOFuncs(connssl->ssl_ctx, SocketRead, SocketWrite);
1217   if(err != noErr) {
1218     failf(data, "SSL: SSLSetIOFuncs() failed: OSStatus %d", err);
1219     return CURLE_SSL_CONNECT_ERROR;
1220   }
1221
1222   /* pass the raw socket into the SSL layers */
1223   /* We need to store the FD in a constant memory address, because
1224    * SSLSetConnection() will not copy that address. I've found that
1225    * conn->sock[sockindex] may change on its own. */
1226   connssl->ssl_sockfd = sockfd;
1227   err = SSLSetConnection(connssl->ssl_ctx, connssl);
1228   if(err != noErr) {
1229     failf(data, "SSL: SSLSetConnection() failed: %d", err);
1230     return CURLE_SSL_CONNECT_ERROR;
1231   }
1232
1233   connssl->connecting_state = ssl_connect_2;
1234   return CURLE_OK;
1235 }
1236
1237 static CURLcode
1238 darwinssl_connect_step2(struct connectdata *conn, int sockindex)
1239 {
1240   struct SessionHandle *data = conn->data;
1241   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1242   OSStatus err;
1243   SSLCipherSuite cipher;
1244   SSLProtocol protocol = 0;
1245
1246   DEBUGASSERT(ssl_connect_2 == connssl->connecting_state
1247               || ssl_connect_2_reading == connssl->connecting_state
1248               || ssl_connect_2_writing == connssl->connecting_state);
1249
1250   /* Here goes nothing: */
1251   err = SSLHandshake(connssl->ssl_ctx);
1252
1253   if(err != noErr) {
1254     switch (err) {
1255       case errSSLWouldBlock:  /* they're not done with us yet */
1256         connssl->connecting_state = connssl->ssl_direction ?
1257             ssl_connect_2_writing : ssl_connect_2_reading;
1258         return CURLE_OK;
1259
1260       /* The below is errSSLServerAuthCompleted; it's not defined in
1261         Leopard's headers */
1262       case -9841:
1263         /* the documentation says we need to call SSLHandshake() again */
1264         return darwinssl_connect_step2(conn, sockindex);
1265
1266       /* These are all certificate problems with the server: */
1267       case errSSLXCertChainInvalid:
1268         failf(data, "SSL certificate problem: Invalid certificate chain");
1269         return CURLE_SSL_CACERT;
1270       case errSSLUnknownRootCert:
1271         failf(data, "SSL certificate problem: Untrusted root certificate");
1272         return CURLE_SSL_CACERT;
1273       case errSSLNoRootCert:
1274         failf(data, "SSL certificate problem: No root certificate");
1275         return CURLE_SSL_CACERT;
1276       case errSSLCertExpired:
1277         failf(data, "SSL certificate problem: Certificate chain had an "
1278               "expired certificate");
1279         return CURLE_SSL_CACERT;
1280       case errSSLBadCert:
1281         failf(data, "SSL certificate problem: Couldn't understand the server "
1282               "certificate format");
1283         return CURLE_SSL_CONNECT_ERROR;
1284
1285       /* These are all certificate problems with the client: */
1286       case errSecAuthFailed:
1287         failf(data, "SSL authentication failed");
1288         return CURLE_SSL_CONNECT_ERROR;
1289       case errSSLPeerHandshakeFail:
1290         failf(data, "SSL peer handshake failed, the server most likely "
1291               "requires a client certificate to connect");
1292         return CURLE_SSL_CONNECT_ERROR;
1293       case errSSLPeerUnknownCA:
1294         failf(data, "SSL server rejected the client certificate due to "
1295               "the certificate being signed by an unknown certificate "
1296               "authority");
1297         return CURLE_SSL_CONNECT_ERROR;
1298
1299       /* This error is raised if the server's cert didn't match the server's
1300          host name: */
1301       case errSSLHostNameMismatch:
1302         failf(data, "SSL certificate peer verification failed, the "
1303               "certificate did not match \"%s\"\n", conn->host.dispname);
1304         return CURLE_PEER_FAILED_VERIFICATION;
1305
1306       /* Generic handshake errors: */
1307       case errSSLConnectionRefused:
1308         failf(data, "Server dropped the connection during the SSL handshake");
1309         return CURLE_SSL_CONNECT_ERROR;
1310       case errSSLClosedAbort:
1311         failf(data, "Server aborted the SSL handshake");
1312         return CURLE_SSL_CONNECT_ERROR;
1313       case errSSLNegotiation:
1314         failf(data, "Could not negotiate an SSL cipher suite with the server");
1315         return CURLE_SSL_CONNECT_ERROR;
1316       /* Sometimes paramErr happens with buggy ciphers: */
1317       case paramErr: case errSSLInternal:
1318         failf(data, "Internal SSL engine error encountered during the "
1319               "SSL handshake");
1320         return CURLE_SSL_CONNECT_ERROR;
1321       case errSSLFatalAlert:
1322         failf(data, "Fatal SSL engine error encountered during the SSL "
1323               "handshake");
1324         return CURLE_SSL_CONNECT_ERROR;
1325       default:
1326         failf(data, "Unknown SSL protocol error in connection to %s:%d",
1327               conn->host.name, err);
1328         return CURLE_SSL_CONNECT_ERROR;
1329     }
1330   }
1331   else {
1332     /* we have been connected fine, we're not waiting for anything else. */
1333     connssl->connecting_state = ssl_connect_3;
1334
1335     /* Informational message */
1336     (void)SSLGetNegotiatedCipher(connssl->ssl_ctx, &cipher);
1337     (void)SSLGetNegotiatedProtocolVersion(connssl->ssl_ctx, &protocol);
1338     switch (protocol) {
1339       case kSSLProtocol2:
1340         infof(data, "SSL 2.0 connection using %s\n",
1341               SSLCipherNameForNumber(cipher));
1342         break;
1343       case kSSLProtocol3:
1344         infof(data, "SSL 3.0 connection using %s\n",
1345               SSLCipherNameForNumber(cipher));
1346         break;
1347       case kTLSProtocol1:
1348         infof(data, "TLS 1.0 connection using %s\n",
1349               TLSCipherNameForNumber(cipher));
1350         break;
1351 #if CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS
1352       case kTLSProtocol11:
1353         infof(data, "TLS 1.1 connection using %s\n",
1354               TLSCipherNameForNumber(cipher));
1355         break;
1356       case kTLSProtocol12:
1357         infof(data, "TLS 1.2 connection using %s\n",
1358               TLSCipherNameForNumber(cipher));
1359         break;
1360 #endif
1361       default:
1362         infof(data, "Unknown protocol connection\n");
1363         break;
1364     }
1365
1366     return CURLE_OK;
1367   }
1368 }
1369
1370 static CURLcode
1371 darwinssl_connect_step3(struct connectdata *conn,
1372                         int sockindex)
1373 {
1374   struct SessionHandle *data = conn->data;
1375   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1376   CFStringRef server_cert_summary;
1377   char server_cert_summary_c[128];
1378   CFArrayRef server_certs = NULL;
1379   SecCertificateRef server_cert;
1380   OSStatus err;
1381   CFIndex i, count;
1382   SecTrustRef trust = NULL;
1383
1384   /* There is no step 3!
1385    * Well, okay, if verbose mode is on, let's print the details of the
1386    * server certificates. */
1387 #if CURL_BUILD_MAC_10_7 || CURL_BUILD_IOS
1388 #if CURL_BUILD_IOS
1389 #pragma unused(server_certs)
1390   err = SSLCopyPeerTrust(connssl->ssl_ctx, &trust);
1391   /* For some reason, SSLCopyPeerTrust() can return noErr and yet return
1392      a null trust, so be on guard for that: */
1393   if(err == noErr && trust) {
1394     count = SecTrustGetCertificateCount(trust);
1395     for(i = 0L ; i < count ; i++) {
1396       server_cert = SecTrustGetCertificateAtIndex(trust, i);
1397       server_cert_summary = CopyCertSubject(server_cert);
1398       memset(server_cert_summary_c, 0, 128);
1399       if(CFStringGetCString(server_cert_summary,
1400                             server_cert_summary_c,
1401                             128,
1402                             kCFStringEncodingUTF8)) {
1403         infof(data, "Server certificate: %s\n", server_cert_summary_c);
1404       }
1405       CFRelease(server_cert_summary);
1406     }
1407     CFRelease(trust);
1408   }
1409 #else
1410   /* SSLCopyPeerCertificates() is deprecated as of Mountain Lion.
1411      The function SecTrustGetCertificateAtIndex() is officially present
1412      in Lion, but it is unfortunately also present in Snow Leopard as
1413      private API and doesn't work as expected. So we have to look for
1414      a different symbol to make sure this code is only executed under
1415      Lion or later. */
1416   if(SecTrustEvaluateAsync != NULL) {
1417 #pragma unused(server_certs)
1418     err = SSLCopyPeerTrust(connssl->ssl_ctx, &trust);
1419     /* For some reason, SSLCopyPeerTrust() can return noErr and yet return
1420        a null trust, so be on guard for that: */
1421     if(err == noErr && trust) {
1422       count = SecTrustGetCertificateCount(trust);
1423       for(i = 0L ; i < count ; i++) {
1424         server_cert = SecTrustGetCertificateAtIndex(trust, i);
1425         server_cert_summary = CopyCertSubject(server_cert);
1426         memset(server_cert_summary_c, 0, 128);
1427         if(CFStringGetCString(server_cert_summary,
1428                               server_cert_summary_c,
1429                               128,
1430                               kCFStringEncodingUTF8)) {
1431           infof(data, "Server certificate: %s\n", server_cert_summary_c);
1432         }
1433         CFRelease(server_cert_summary);
1434       }
1435       CFRelease(trust);
1436     }
1437   }
1438   else {
1439 #if CURL_SUPPORT_MAC_10_8
1440     err = SSLCopyPeerCertificates(connssl->ssl_ctx, &server_certs);
1441     /* Just in case SSLCopyPeerCertificates() returns null too... */
1442     if(err == noErr && server_certs) {
1443       count = CFArrayGetCount(server_certs);
1444       for(i = 0L ; i < count ; i++) {
1445         server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs,
1446                                                                 i);
1447
1448         server_cert_summary = CopyCertSubject(server_cert);
1449         memset(server_cert_summary_c, 0, 128);
1450         if(CFStringGetCString(server_cert_summary,
1451                               server_cert_summary_c,
1452                               128,
1453                               kCFStringEncodingUTF8)) {
1454           infof(data, "Server certificate: %s\n", server_cert_summary_c);
1455         }
1456         CFRelease(server_cert_summary);
1457       }
1458       CFRelease(server_certs);
1459     }
1460 #endif /* CURL_SUPPORT_MAC_10_8 */
1461   }
1462 #endif /* CURL_BUILD_IOS */
1463 #else
1464 #pragma unused(trust)
1465   err = SSLCopyPeerCertificates(connssl->ssl_ctx, &server_certs);
1466   if(err == noErr) {
1467     count = CFArrayGetCount(server_certs);
1468     for(i = 0L ; i < count ; i++) {
1469       server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs, i);
1470       server_cert_summary = CopyCertSubject(server_cert);
1471       memset(server_cert_summary_c, 0, 128);
1472       if(CFStringGetCString(server_cert_summary,
1473                             server_cert_summary_c,
1474                             128,
1475                             kCFStringEncodingUTF8)) {
1476         infof(data, "Server certificate: %s\n", server_cert_summary_c);
1477       }
1478       CFRelease(server_cert_summary);
1479     }
1480     CFRelease(server_certs);
1481   }
1482 #endif /* CURL_BUILD_MAC_10_7 || CURL_BUILD_IOS */
1483
1484   connssl->connecting_state = ssl_connect_done;
1485   return CURLE_OK;
1486 }
1487
1488 static Curl_recv darwinssl_recv;
1489 static Curl_send darwinssl_send;
1490
1491 static CURLcode
1492 darwinssl_connect_common(struct connectdata *conn,
1493                          int sockindex,
1494                          bool nonblocking,
1495                          bool *done)
1496 {
1497   CURLcode retcode;
1498   struct SessionHandle *data = conn->data;
1499   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1500   curl_socket_t sockfd = conn->sock[sockindex];
1501   long timeout_ms;
1502   int what;
1503
1504   /* check if the connection has already been established */
1505   if(ssl_connection_complete == connssl->state) {
1506     *done = TRUE;
1507     return CURLE_OK;
1508   }
1509
1510   if(ssl_connect_1==connssl->connecting_state) {
1511     /* Find out how much more time we're allowed */
1512     timeout_ms = Curl_timeleft(data, NULL, TRUE);
1513
1514     if(timeout_ms < 0) {
1515       /* no need to continue if time already is up */
1516       failf(data, "SSL connection timeout");
1517       return CURLE_OPERATION_TIMEDOUT;
1518     }
1519     retcode = darwinssl_connect_step1(conn, sockindex);
1520     if(retcode)
1521       return retcode;
1522   }
1523
1524   while(ssl_connect_2 == connssl->connecting_state ||
1525         ssl_connect_2_reading == connssl->connecting_state ||
1526         ssl_connect_2_writing == connssl->connecting_state) {
1527
1528     /* check allowed time left */
1529     timeout_ms = Curl_timeleft(data, NULL, TRUE);
1530
1531     if(timeout_ms < 0) {
1532       /* no need to continue if time already is up */
1533       failf(data, "SSL connection timeout");
1534       return CURLE_OPERATION_TIMEDOUT;
1535     }
1536
1537     /* if ssl is expecting something, check if it's available. */
1538     if(connssl->connecting_state == ssl_connect_2_reading
1539        || connssl->connecting_state == ssl_connect_2_writing) {
1540
1541       curl_socket_t writefd = ssl_connect_2_writing ==
1542       connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1543       curl_socket_t readfd = ssl_connect_2_reading ==
1544       connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1545
1546       what = Curl_socket_ready(readfd, writefd, nonblocking?0:timeout_ms);
1547       if(what < 0) {
1548         /* fatal error */
1549         failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
1550         return CURLE_SSL_CONNECT_ERROR;
1551       }
1552       else if(0 == what) {
1553         if(nonblocking) {
1554           *done = FALSE;
1555           return CURLE_OK;
1556         }
1557         else {
1558           /* timeout */
1559           failf(data, "SSL connection timeout");
1560           return CURLE_OPERATION_TIMEDOUT;
1561         }
1562       }
1563       /* socket is readable or writable */
1564     }
1565
1566     /* Run transaction, and return to the caller if it failed or if this
1567      * connection is done nonblocking and this loop would execute again. This
1568      * permits the owner of a multi handle to abort a connection attempt
1569      * before step2 has completed while ensuring that a client using select()
1570      * or epoll() will always have a valid fdset to wait on.
1571      */
1572     retcode = darwinssl_connect_step2(conn, sockindex);
1573     if(retcode || (nonblocking &&
1574                    (ssl_connect_2 == connssl->connecting_state ||
1575                     ssl_connect_2_reading == connssl->connecting_state ||
1576                     ssl_connect_2_writing == connssl->connecting_state)))
1577       return retcode;
1578
1579   } /* repeat step2 until all transactions are done. */
1580
1581
1582   if(ssl_connect_3==connssl->connecting_state) {
1583     retcode = darwinssl_connect_step3(conn, sockindex);
1584     if(retcode)
1585       return retcode;
1586   }
1587
1588   if(ssl_connect_done==connssl->connecting_state) {
1589     connssl->state = ssl_connection_complete;
1590     conn->recv[sockindex] = darwinssl_recv;
1591     conn->send[sockindex] = darwinssl_send;
1592     *done = TRUE;
1593   }
1594   else
1595     *done = FALSE;
1596
1597   /* Reset our connect state machine */
1598   connssl->connecting_state = ssl_connect_1;
1599
1600   return CURLE_OK;
1601 }
1602
1603 CURLcode
1604 Curl_darwinssl_connect_nonblocking(struct connectdata *conn,
1605                                    int sockindex,
1606                                    bool *done)
1607 {
1608   return darwinssl_connect_common(conn, sockindex, TRUE, done);
1609 }
1610
1611 CURLcode
1612 Curl_darwinssl_connect(struct connectdata *conn,
1613                        int sockindex)
1614 {
1615   CURLcode retcode;
1616   bool done = FALSE;
1617
1618   retcode = darwinssl_connect_common(conn, sockindex, FALSE, &done);
1619
1620   if(retcode)
1621     return retcode;
1622
1623   DEBUGASSERT(done);
1624
1625   return CURLE_OK;
1626 }
1627
1628 void Curl_darwinssl_close(struct connectdata *conn, int sockindex)
1629 {
1630   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1631
1632   if(connssl->ssl_ctx) {
1633     (void)SSLClose(connssl->ssl_ctx);
1634 #if CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS
1635     if(SSLCreateContext != NULL)
1636       CFRelease(connssl->ssl_ctx);
1637 #if CURL_SUPPORT_MAC_10_8
1638     else
1639       (void)SSLDisposeContext(connssl->ssl_ctx);
1640 #endif  /* CURL_SUPPORT_MAC_10_8 */
1641 #else
1642     (void)SSLDisposeContext(connssl->ssl_ctx);
1643 #endif /* CURL_BUILD_MAC_10_8 || CURL_BUILD_IOS */
1644     connssl->ssl_ctx = NULL;
1645   }
1646   connssl->ssl_sockfd = 0;
1647 }
1648
1649 void Curl_darwinssl_close_all(struct SessionHandle *data)
1650 {
1651   /* SecureTransport doesn't separate sessions from contexts, so... */
1652   (void)data;
1653 }
1654
1655 int Curl_darwinssl_shutdown(struct connectdata *conn, int sockindex)
1656 {
1657   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1658   struct SessionHandle *data = conn->data;
1659   ssize_t nread;
1660   int what;
1661   int rc;
1662   char buf[120];
1663
1664   if(!connssl->ssl_ctx)
1665     return 0;
1666
1667   if(data->set.ftp_ccc != CURLFTPSSL_CCC_ACTIVE)
1668     return 0;
1669
1670   Curl_darwinssl_close(conn, sockindex);
1671
1672   rc = 0;
1673
1674   what = Curl_socket_ready(conn->sock[sockindex],
1675                            CURL_SOCKET_BAD, SSL_SHUTDOWN_TIMEOUT);
1676
1677   for(;;) {
1678     if(what < 0) {
1679       /* anything that gets here is fatally bad */
1680       failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
1681       rc = -1;
1682       break;
1683     }
1684
1685     if(!what) {                                /* timeout */
1686       failf(data, "SSL shutdown timeout");
1687       break;
1688     }
1689
1690     /* Something to read, let's do it and hope that it is the close
1691      notify alert from the server. No way to SSL_Read now, so use read(). */
1692
1693     nread = read(conn->sock[sockindex], buf, sizeof(buf));
1694
1695     if(nread < 0) {
1696       failf(data, "read: %s", strerror(errno));
1697       rc = -1;
1698     }
1699
1700     if(nread <= 0)
1701       break;
1702
1703     what = Curl_socket_ready(conn->sock[sockindex], CURL_SOCKET_BAD, 0);
1704   }
1705
1706   return rc;
1707 }
1708
1709 void Curl_darwinssl_session_free(void *ptr)
1710 {
1711   /* ST, as of iOS 5 and Mountain Lion, has no public method of deleting a
1712      cached session ID inside the Security framework. There is a private
1713      function that does this, but I don't want to have to explain to you why I
1714      got your application rejected from the App Store due to the use of a
1715      private API, so the best we can do is free up our own char array that we
1716      created way back in darwinssl_connect_step1... */
1717   Curl_safefree(ptr);
1718 }
1719
1720 size_t Curl_darwinssl_version(char *buffer, size_t size)
1721 {
1722   return snprintf(buffer, size, "SecureTransport");
1723 }
1724
1725 /*
1726  * This function uses SSLGetSessionState to determine connection status.
1727  *
1728  * Return codes:
1729  *     1 means the connection is still in place
1730  *     0 means the connection has been closed
1731  *    -1 means the connection status is unknown
1732  */
1733 int Curl_darwinssl_check_cxn(struct connectdata *conn)
1734 {
1735   struct ssl_connect_data *connssl = &conn->ssl[FIRSTSOCKET];
1736   OSStatus err;
1737   SSLSessionState state;
1738
1739   if(connssl->ssl_ctx) {
1740     err = SSLGetSessionState(connssl->ssl_ctx, &state);
1741     if(err == noErr)
1742       return state == kSSLConnected || state == kSSLHandshake;
1743     return -1;
1744   }
1745   return 0;
1746 }
1747
1748 bool Curl_darwinssl_data_pending(const struct connectdata *conn,
1749                                  int connindex)
1750 {
1751   const struct ssl_connect_data *connssl = &conn->ssl[connindex];
1752   OSStatus err;
1753   size_t buffer;
1754
1755   if(connssl->ssl_ctx) {  /* SSL is in use */
1756     err = SSLGetBufferedReadSize(connssl->ssl_ctx, &buffer);
1757     if(err == noErr)
1758       return buffer > 0UL;
1759     return false;
1760   }
1761   else
1762     return false;
1763 }
1764
1765 void Curl_darwinssl_random(struct SessionHandle *data,
1766                            unsigned char *entropy,
1767                            size_t length)
1768 {
1769   /* arc4random_buf() isn't available on cats older than Lion, so let's
1770      do this manually for the benefit of the older cats. */
1771   size_t i;
1772   u_int32_t random_number = 0;
1773
1774   for(i = 0 ; i < length ; i++) {
1775     if(i % sizeof(u_int32_t) == 0)
1776       random_number = arc4random();
1777     entropy[i] = random_number & 0xFF;
1778     random_number >>= 8;
1779   }
1780   i = random_number = 0;
1781   (void)data;
1782 }
1783
1784 void Curl_darwinssl_md5sum(unsigned char *tmp, /* input */
1785                            size_t tmplen,
1786                            unsigned char *md5sum, /* output */
1787                            size_t md5len)
1788 {
1789   (void)md5len;
1790   (void)CC_MD5(tmp, (CC_LONG)tmplen, md5sum);
1791 }
1792
1793 static ssize_t darwinssl_send(struct connectdata *conn,
1794                               int sockindex,
1795                               const void *mem,
1796                               size_t len,
1797                               CURLcode *curlcode)
1798 {
1799   /*struct SessionHandle *data = conn->data;*/
1800   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1801   size_t processed = 0UL;
1802   OSStatus err;
1803
1804   /* The SSLWrite() function works a little differently than expected. The
1805      fourth argument (processed) is currently documented in Apple's
1806      documentation as: "On return, the length, in bytes, of the data actually
1807      written."
1808
1809      Now, one could interpret that as "written to the socket," but actually,
1810      it returns the amount of data that was written to a buffer internal to
1811      the SSLContextRef instead. So it's possible for SSLWrite() to return
1812      errSSLWouldBlock and a number of bytes "written" because those bytes were
1813      encrypted and written to a buffer, not to the socket.
1814
1815      So if this happens, then we need to keep calling SSLWrite() over and
1816      over again with no new data until it quits returning errSSLWouldBlock. */
1817
1818   /* Do we have buffered data to write from the last time we were called? */
1819   if(connssl->ssl_write_buffered_length) {
1820     /* Write the buffered data: */
1821     err = SSLWrite(connssl->ssl_ctx, NULL, 0UL, &processed);
1822     switch (err) {
1823       case noErr:
1824         /* processed is always going to be 0 because we didn't write to
1825            the buffer, so return how much was written to the socket */
1826         processed = connssl->ssl_write_buffered_length;
1827         connssl->ssl_write_buffered_length = 0UL;
1828         break;
1829       case errSSLWouldBlock: /* argh, try again */
1830         *curlcode = CURLE_AGAIN;
1831         return -1L;
1832       default:
1833         failf(conn->data, "SSLWrite() returned error %d", err);
1834         *curlcode = CURLE_SEND_ERROR;
1835         return -1L;
1836     }
1837   }
1838   else {
1839     /* We've got new data to write: */
1840     err = SSLWrite(connssl->ssl_ctx, mem, len, &processed);
1841     if(err != noErr) {
1842       switch (err) {
1843         case errSSLWouldBlock:
1844           /* Data was buffered but not sent, we have to tell the caller
1845              to try sending again, and remember how much was buffered */
1846           connssl->ssl_write_buffered_length = len;
1847           *curlcode = CURLE_AGAIN;
1848           return -1L;
1849         default:
1850           failf(conn->data, "SSLWrite() returned error %d", err);
1851           *curlcode = CURLE_SEND_ERROR;
1852           return -1L;
1853       }
1854     }
1855   }
1856   return (ssize_t)processed;
1857 }
1858
1859 static ssize_t darwinssl_recv(struct connectdata *conn,
1860                               int num,
1861                               char *buf,
1862                               size_t buffersize,
1863                               CURLcode *curlcode)
1864 {
1865   /*struct SessionHandle *data = conn->data;*/
1866   struct ssl_connect_data *connssl = &conn->ssl[num];
1867   size_t processed = 0UL;
1868   OSStatus err = SSLRead(connssl->ssl_ctx, buf, buffersize, &processed);
1869
1870   if(err != noErr) {
1871     switch (err) {
1872       case errSSLWouldBlock:  /* return how much we read (if anything) */
1873         if(processed)
1874           return (ssize_t)processed;
1875         *curlcode = CURLE_AGAIN;
1876         return -1L;
1877         break;
1878
1879       /* errSSLClosedGraceful - server gracefully shut down the SSL session
1880          errSSLClosedNoNotify - server hung up on us instead of sending a
1881            closure alert notice, read() is returning 0
1882          Either way, inform the caller that the server disconnected. */
1883       case errSSLClosedGraceful:
1884       case errSSLClosedNoNotify:
1885         *curlcode = CURLE_OK;
1886         return -1L;
1887         break;
1888
1889       default:
1890         failf(conn->data, "SSLRead() return error %d", err);
1891         *curlcode = CURLE_RECV_ERROR;
1892         return -1L;
1893         break;
1894     }
1895   }
1896   return (ssize_t)processed;
1897 }
1898
1899 #endif /* USE_DARWINSSL */