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