zhaobu
/
zhujimajiang_redis
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
诸暨麻将添加redis
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
6 提交
2 分支
57 MiB
 
 
 
 
 
 
目录树: 522a9556dd
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '522a9556dd'
${ noResults }
zhujimajiang_redis/俱乐部/Source/ServerControl/curl-7.32.0/lib/curl_darwinssl.c

1900 行
65 KiB
原始文件 Blame 文件历史 

  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 */