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: */ 76static 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 140static 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 180CF_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 325CF_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)) 633CF_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. */ 667CF_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 694static CURLcode darwinssl_connect_step1(struct connectdata *conn, 695 int sockindex) 696{ 697 struct SessionHandle *data = conn->data; 698 curl_socket_t sockfd = conn->sock[sockindex]; 699 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 700#ifdef ENABLE_IPV6 701 struct in6_addr addr; 702#else 703 struct in_addr addr; 704#endif 705 size_t all_ciphers_count = 0UL, allowed_ciphers_count = 0UL, i; 706 SSLCipherSuite *all_ciphers = NULL, *allowed_ciphers = NULL; 707 OSStatus err = noErr; 708#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 709 int darwinver_maj = 0, darwinver_min = 0; 710 711 GetDarwinVersionNumber(&darwinver_maj, &darwinver_min); 712#endif 713 714#if defined(__MAC_10_8) || defined(__IPHONE_5_0) 715 if(SSLCreateContext != NULL) { /* use the newer API if avaialble */ 716 if(connssl->ssl_ctx) 717 CFRelease(connssl->ssl_ctx); 718 connssl->ssl_ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType); 719 if(!connssl->ssl_ctx) { 720 failf(data, "SSL: couldn't create a context!"); 721 return CURLE_OUT_OF_MEMORY; 722 } 723 } 724 else { 725 /* The old ST API does not exist under iOS, so don't compile it: */ 726#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 727 if(connssl->ssl_ctx) 728 (void)SSLDisposeContext(connssl->ssl_ctx); 729 err = SSLNewContext(false, &(connssl->ssl_ctx)); 730 if(err != noErr) { 731 failf(data, "SSL: couldn't create a context: OSStatus %d", err); 732 return CURLE_OUT_OF_MEMORY; 733 } 734#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */ 735 } 736#else 737 if(connssl->ssl_ctx) 738 (void)SSLDisposeContext(connssl->ssl_ctx); 739 err = SSLNewContext(false, &(connssl->ssl_ctx)); 740 if(err != noErr) { 741 failf(data, "SSL: couldn't create a context: OSStatus %d", err); 742 return CURLE_OUT_OF_MEMORY; 743 } 744#endif /* defined(__MAC_10_8) || defined(__IPHONE_5_0) */ 745 connssl->ssl_write_buffered_length = 0UL; /* reset buffered write length */ 746 747 /* check to see if we've been told to use an explicit SSL/TLS version */ 748#if defined(__MAC_10_8) || defined(__IPHONE_5_0) 749 if(SSLSetProtocolVersionMax != NULL) { 750 switch(data->set.ssl.version) { 751 case CURL_SSLVERSION_DEFAULT: default: 752 (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol3); 753 (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kTLSProtocol12); 754 break; 755 case CURL_SSLVERSION_TLSv1: 756 (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kTLSProtocol1); 757 (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kTLSProtocol12); 758 break; 759 case CURL_SSLVERSION_SSLv3: 760 (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol3); 761 (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kSSLProtocol3); 762 break; 763 case CURL_SSLVERSION_SSLv2: 764 (void)SSLSetProtocolVersionMin(connssl->ssl_ctx, kSSLProtocol2); 765 (void)SSLSetProtocolVersionMax(connssl->ssl_ctx, kSSLProtocol2); 766 } 767 } 768 else { 769#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 770 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 771 kSSLProtocolAll, 772 false); 773 switch (data->set.ssl.version) { 774 case CURL_SSLVERSION_DEFAULT: default: 775 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 776 kSSLProtocol3, 777 true); 778 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 779 kTLSProtocol1, 780 true); 781 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 782 kTLSProtocol11, 783 true); 784 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 785 kTLSProtocol12, 786 true); 787 break; 788 case CURL_SSLVERSION_TLSv1: 789 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 790 kTLSProtocol1, 791 true); 792 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 793 kTLSProtocol11, 794 true); 795 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 796 kTLSProtocol12, 797 true); 798 break; 799 case CURL_SSLVERSION_SSLv3: 800 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 801 kSSLProtocol3, 802 true); 803 break; 804 case CURL_SSLVERSION_SSLv2: 805 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 806 kSSLProtocol2, 807 true); 808 break; 809 } 810#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */ 811 } 812#else 813 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, kSSLProtocolAll, false); 814 switch(data->set.ssl.version) { 815 default: 816 case CURL_SSLVERSION_DEFAULT: 817 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 818 kSSLProtocol3, 819 true); 820 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 821 kTLSProtocol1, 822 true); 823 break; 824 case CURL_SSLVERSION_TLSv1: 825 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 826 kTLSProtocol1, 827 true); 828 break; 829 case CURL_SSLVERSION_SSLv2: 830 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 831 kSSLProtocol2, 832 true); 833 break; 834 case CURL_SSLVERSION_SSLv3: 835 (void)SSLSetProtocolVersionEnabled(connssl->ssl_ctx, 836 kSSLProtocol3, 837 true); 838 break; 839 } 840#endif /* defined(__MAC_10_8) || defined(__IPHONE_5_0) */ 841 842 /* No need to load certificates here. SecureTransport uses the Keychain 843 * (which is also part of the Security framework) to evaluate trust. */ 844 845 /* SSL always tries to verify the peer, this only says whether it should 846 * fail to connect if the verification fails, or if it should continue 847 * anyway. In the latter case the result of the verification is checked with 848 * SSL_get_verify_result() below. */ 849#if defined(__MAC_10_6) || defined(__IPHONE_5_0) 850 /* Snow Leopard introduced the SSLSetSessionOption() function, but due to 851 a library bug with the way the kSSLSessionOptionBreakOnServerAuth flag 852 works, it doesn't work as expected under Snow Leopard or Lion. 853 So we need to call SSLSetEnableCertVerify() on those older cats in order 854 to disable certificate validation if the user turned that off. 855 (SecureTransport will always validate the certificate chain by 856 default.) */ 857 /* (Note: Darwin 12.x.x is Mountain Lion.) */ 858#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 859 if(SSLSetSessionOption != NULL && darwinver_maj >= 12) { 860#else 861 if(SSLSetSessionOption != NULL) { 862#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */ 863 err = SSLSetSessionOption(connssl->ssl_ctx, 864 kSSLSessionOptionBreakOnServerAuth, 865 data->set.ssl.verifypeer?false:true); 866 if(err != noErr) { 867 failf(data, "SSL: SSLSetSessionOption() failed: OSStatus %d", err); 868 return CURLE_SSL_CONNECT_ERROR; 869 } 870 } 871 else { 872#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 873 err = SSLSetEnableCertVerify(connssl->ssl_ctx, 874 data->set.ssl.verifypeer?true:false); 875 if(err != noErr) { 876 failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err); 877 return CURLE_SSL_CONNECT_ERROR; 878 } 879#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */ 880 } 881#else 882 err = SSLSetEnableCertVerify(connssl->ssl_ctx, 883 data->set.ssl.verifypeer?true:false); 884 if(err != noErr) { 885 failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err); 886 return CURLE_SSL_CONNECT_ERROR; 887 } 888#endif /* defined(__MAC_10_6) || defined(__IPHONE_5_0) */ 889 890 /* If this is a domain name and not an IP address, then configure SNI. 891 * Also: the verifyhost setting influences SNI usage */ 892 /* If this is a domain name and not an IP address, then configure SNI: */ 893#ifdef __APPLE__ 894 if(data->set.ssl.verifyhost) { 895#else /* !__APPLE__ */ 896 if((0 == Curl_inet_pton(AF_INET, conn->host.name, &addr)) && 897#ifdef ENABLE_IPV6 898 (0 == Curl_inet_pton(AF_INET6, conn->host.name, &addr)) && 899#endif 900 data->set.ssl.verifyhost) { 901#endif /* __APPLE__ */ 902 err = SSLSetPeerDomainName(connssl->ssl_ctx, conn->host.name, 903 strlen(conn->host.name)); 904 if(err != noErr) { 905 infof(data, "WARNING: SSL: SSLSetPeerDomainName() failed: OSStatus %d", 906 err); 907 } 908 } 909 910 /* Disable cipher suites that ST supports but are not safe. These ciphers 911 are unlikely to be used in any case since ST gives other ciphers a much 912 higher priority, but it's probably better that we not connect at all than 913 to give the user a false sense of security if the server only supports 914 insecure ciphers. (Note: We don't care about SSLv2-only ciphers.) */ 915 (void)SSLGetNumberSupportedCiphers(connssl->ssl_ctx, &all_ciphers_count); 916 all_ciphers = malloc(all_ciphers_count*sizeof(SSLCipherSuite)); 917 allowed_ciphers = malloc(all_ciphers_count*sizeof(SSLCipherSuite)); 918 if(all_ciphers && allowed_ciphers && 919 SSLGetSupportedCiphers(connssl->ssl_ctx, all_ciphers, 920 &all_ciphers_count) == noErr) { 921 for(i = 0UL ; i < all_ciphers_count ; i++) { 922#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 923 /* There's a known bug in early versions of Mountain Lion where ST's ECC 924 ciphers (cipher suite 0xC001 through 0xC032) simply do not work. 925 Work around the problem here by disabling those ciphers if we are 926 running in an affected version of OS X. */ 927 if(darwinver_maj == 12 && darwinver_min <= 3 && 928 all_ciphers[i] >= 0xC001 && all_ciphers[i] <= 0xC032) { 929 continue; 930 } 931#endif 932 switch(all_ciphers[i]) { 933 /* Disable NULL ciphersuites: */ 934 case SSL_NULL_WITH_NULL_NULL: 935 case SSL_RSA_WITH_NULL_MD5: 936 case SSL_RSA_WITH_NULL_SHA: 937 case SSL_FORTEZZA_DMS_WITH_NULL_SHA: 938 case 0xC001: /* TLS_ECDH_ECDSA_WITH_NULL_SHA */ 939 case 0xC006: /* TLS_ECDHE_ECDSA_WITH_NULL_SHA */ 940 case 0xC00B: /* TLS_ECDH_RSA_WITH_NULL_SHA */ 941 case 0xC010: /* TLS_ECDHE_RSA_WITH_NULL_SHA */ 942 /* Disable anonymous ciphersuites: */ 943 case SSL_DH_anon_EXPORT_WITH_RC4_40_MD5: 944 case SSL_DH_anon_WITH_RC4_128_MD5: 945 case SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA: 946 case SSL_DH_anon_WITH_DES_CBC_SHA: 947 case SSL_DH_anon_WITH_3DES_EDE_CBC_SHA: 948 case TLS_DH_anon_WITH_AES_128_CBC_SHA: 949 case TLS_DH_anon_WITH_AES_256_CBC_SHA: 950 case 0xC015: /* TLS_ECDH_anon_WITH_NULL_SHA */ 951 case 0xC016: /* TLS_ECDH_anon_WITH_RC4_128_SHA */ 952 case 0xC017: /* TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA */ 953 case 0xC018: /* TLS_ECDH_anon_WITH_AES_128_CBC_SHA */ 954 case 0xC019: /* TLS_ECDH_anon_WITH_AES_256_CBC_SHA */ 955 case 0x006C: /* TLS_DH_anon_WITH_AES_128_CBC_SHA256 */ 956 case 0x006D: /* TLS_DH_anon_WITH_AES_256_CBC_SHA256 */ 957 case 0x00A6: /* TLS_DH_anon_WITH_AES_128_GCM_SHA256 */ 958 case 0x00A7: /* TLS_DH_anon_WITH_AES_256_GCM_SHA384 */ 959 /* Disable weak key ciphersuites: */ 960 case SSL_RSA_EXPORT_WITH_RC4_40_MD5: 961 case SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5: 962 case SSL_RSA_EXPORT_WITH_DES40_CBC_SHA: 963 case SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA: 964 case SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA: 965 case SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA: 966 case SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA: 967 case SSL_RSA_WITH_DES_CBC_SHA: 968 case SSL_DH_DSS_WITH_DES_CBC_SHA: 969 case SSL_DH_RSA_WITH_DES_CBC_SHA: 970 case SSL_DHE_DSS_WITH_DES_CBC_SHA: 971 case SSL_DHE_RSA_WITH_DES_CBC_SHA: 972 /* Disable IDEA: */ 973 case SSL_RSA_WITH_IDEA_CBC_SHA: 974 case SSL_RSA_WITH_IDEA_CBC_MD5: 975 break; 976 default: /* enable everything else */ 977 allowed_ciphers[allowed_ciphers_count++] = all_ciphers[i]; 978 break; 979 } 980 } 981 err = SSLSetEnabledCiphers(connssl->ssl_ctx, allowed_ciphers, 982 allowed_ciphers_count); 983 if(err != noErr) { 984 failf(data, "SSL: SSLSetEnabledCiphers() failed: OSStatus %d", err); 985 return CURLE_SSL_CONNECT_ERROR; 986 } 987 } 988 else { 989 Curl_safefree(all_ciphers); 990 Curl_safefree(allowed_ciphers); 991 failf(data, "SSL: Failed to allocate memory for allowed ciphers"); 992 return CURLE_OUT_OF_MEMORY; 993 } 994 Curl_safefree(all_ciphers); 995 Curl_safefree(allowed_ciphers); 996 997 err = SSLSetIOFuncs(connssl->ssl_ctx, SocketRead, SocketWrite); 998 if(err != noErr) { 999 failf(data, "SSL: SSLSetIOFuncs() failed: OSStatus %d", err); 1000 return CURLE_SSL_CONNECT_ERROR; 1001 } 1002 1003 /* pass the raw socket into the SSL layers */ 1004 /* We need to store the FD in a constant memory address, because 1005 * SSLSetConnection() will not copy that address. I've found that 1006 * conn->sock[sockindex] may change on its own. */ 1007 connssl->ssl_sockfd = sockfd; 1008 err = SSLSetConnection(connssl->ssl_ctx, connssl); 1009 if(err != noErr) { 1010 failf(data, "SSL: SSLSetConnection() failed: %d", err); 1011 return CURLE_SSL_CONNECT_ERROR; 1012 } 1013 1014 connssl->connecting_state = ssl_connect_2; 1015 return CURLE_OK; 1016} 1017 1018static CURLcode 1019darwinssl_connect_step2(struct connectdata *conn, int sockindex) 1020{ 1021 struct SessionHandle *data = conn->data; 1022 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1023 OSStatus err; 1024 SSLCipherSuite cipher; 1025 SSLProtocol protocol = 0; 1026 1027 DEBUGASSERT(ssl_connect_2 == connssl->connecting_state 1028 || ssl_connect_2_reading == connssl->connecting_state 1029 || ssl_connect_2_writing == connssl->connecting_state); 1030 1031 /* Here goes nothing: */ 1032 err = SSLHandshake(connssl->ssl_ctx); 1033 1034 if(err != noErr) { 1035 switch (err) { 1036 case errSSLWouldBlock: /* they're not done with us yet */ 1037 connssl->connecting_state = connssl->ssl_direction ? 1038 ssl_connect_2_writing : ssl_connect_2_reading; 1039 return CURLE_OK; 1040 1041 /* The below is errSSLServerAuthCompleted; it's not defined in 1042 Leopard's headers */ 1043 case -9841: 1044 /* the documentation says we need to call SSLHandshake() again */ 1045 return darwinssl_connect_step2(conn, sockindex); 1046 1047 /* These are all certificate problems with the server: */ 1048 case errSSLXCertChainInvalid: 1049 failf(data, "SSL certificate problem: Invalid certificate chain"); 1050 return CURLE_SSL_CACERT; 1051 case errSSLUnknownRootCert: 1052 failf(data, "SSL certificate problem: Untrusted root certificate"); 1053 return CURLE_SSL_CACERT; 1054 case errSSLNoRootCert: 1055 failf(data, "SSL certificate problem: No root certificate"); 1056 return CURLE_SSL_CACERT; 1057 case errSSLCertExpired: 1058 failf(data, "SSL certificate problem: Certificate chain had an " 1059 "expired certificate"); 1060 return CURLE_SSL_CACERT; 1061 case errSSLBadCert: 1062 failf(data, "SSL certificate problem: Couldn't understand the server " 1063 "certificate format"); 1064 return CURLE_SSL_CONNECT_ERROR; 1065 1066 /* This error is raised if the server's cert didn't match the server's 1067 host name: */ 1068 case errSSLHostNameMismatch: 1069 failf(data, "SSL certificate peer verification failed, the " 1070 "certificate did not match \"%s\"\n", conn->host.dispname); 1071 return CURLE_PEER_FAILED_VERIFICATION; 1072 1073 /* Generic handshake errors: */ 1074 case errSSLConnectionRefused: 1075 failf(data, "Server dropped the connection during the SSL handshake"); 1076 return CURLE_SSL_CONNECT_ERROR; 1077 case errSSLClosedAbort: 1078 failf(data, "Server aborted the SSL handshake"); 1079 return CURLE_SSL_CONNECT_ERROR; 1080 case errSSLNegotiation: 1081 failf(data, "Could not negotiate an SSL cipher suite with the server"); 1082 return CURLE_SSL_CONNECT_ERROR; 1083 /* Sometimes paramErr happens with buggy ciphers: */ 1084 case paramErr: case errSSLInternal: 1085 failf(data, "Internal SSL engine error encountered during the " 1086 "SSL handshake"); 1087 return CURLE_SSL_CONNECT_ERROR; 1088 case errSSLFatalAlert: 1089 failf(data, "Fatal SSL engine error encountered during the SSL " 1090 "handshake"); 1091 return CURLE_SSL_CONNECT_ERROR; 1092 default: 1093 failf(data, "Unknown SSL protocol error in connection to %s:%d", 1094 conn->host.name, err); 1095 return CURLE_SSL_CONNECT_ERROR; 1096 } 1097 } 1098 else { 1099 /* we have been connected fine, we're not waiting for anything else. */ 1100 connssl->connecting_state = ssl_connect_3; 1101 1102 /* Informational message */ 1103 (void)SSLGetNegotiatedCipher(connssl->ssl_ctx, &cipher); 1104 (void)SSLGetNegotiatedProtocolVersion(connssl->ssl_ctx, &protocol); 1105 switch (protocol) { 1106 case kSSLProtocol2: 1107 infof(data, "SSL 2.0 connection using %s\n", 1108 SSLCipherNameForNumber(cipher)); 1109 break; 1110 case kSSLProtocol3: 1111 infof(data, "SSL 3.0 connection using %s\n", 1112 SSLCipherNameForNumber(cipher)); 1113 break; 1114 case kTLSProtocol1: 1115 infof(data, "TLS 1.0 connection using %s\n", 1116 TLSCipherNameForNumber(cipher)); 1117 break; 1118#if defined(__MAC_10_8) || defined(__IPHONE_5_0) 1119 case kTLSProtocol11: 1120 infof(data, "TLS 1.1 connection using %s\n", 1121 TLSCipherNameForNumber(cipher)); 1122 break; 1123 case kTLSProtocol12: 1124 infof(data, "TLS 1.2 connection using %s\n", 1125 TLSCipherNameForNumber(cipher)); 1126 break; 1127#endif 1128 default: 1129 infof(data, "Unknown protocol connection\n"); 1130 break; 1131 } 1132 1133 return CURLE_OK; 1134 } 1135} 1136 1137static CURLcode 1138darwinssl_connect_step3(struct connectdata *conn, 1139 int sockindex) 1140{ 1141 struct SessionHandle *data = conn->data; 1142 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1143 CFStringRef server_cert_summary; 1144 char server_cert_summary_c[128]; 1145 CFArrayRef server_certs; 1146 SecCertificateRef server_cert; 1147 OSStatus err; 1148 CFIndex i, count; 1149 SecTrustRef trust; 1150 1151 /* There is no step 3! 1152 * Well, okay, if verbose mode is on, let's print the details of the 1153 * server certificates. */ 1154#if defined(__MAC_10_7) || defined(__IPHONE_5_0) 1155#if (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE) 1156#pragma unused(server_certs) 1157 err = SSLCopyPeerTrust(connssl->ssl_ctx, &trust); 1158 if(err == noErr) { 1159 count = SecTrustGetCertificateCount(trust); 1160 for(i = 0L ; i < count ; i++) { 1161 server_cert = SecTrustGetCertificateAtIndex(trust, i); 1162 server_cert_summary = CopyCertSubject(server_cert); 1163 memset(server_cert_summary_c, 0, 128); 1164 if(CFStringGetCString(server_cert_summary, 1165 server_cert_summary_c, 1166 128, 1167 kCFStringEncodingUTF8)) { 1168 infof(data, "Server certificate: %s\n", server_cert_summary_c); 1169 } 1170 CFRelease(server_cert_summary); 1171 } 1172 CFRelease(trust); 1173 } 1174#else 1175 /* SSLCopyPeerCertificates() is deprecated as of Mountain Lion. 1176 The function SecTrustGetCertificateAtIndex() is officially present 1177 in Lion, but it is unfortunately also present in Snow Leopard as 1178 private API and doesn't work as expected. So we have to look for 1179 a different symbol to make sure this code is only executed under 1180 Lion or later. */ 1181 if(SecTrustEvaluateAsync != NULL) { 1182#pragma unused(server_certs) 1183 err = SSLCopyPeerTrust(connssl->ssl_ctx, &trust); 1184 if(err == noErr) { 1185 count = SecTrustGetCertificateCount(trust); 1186 for(i = 0L ; i < count ; i++) { 1187 server_cert = SecTrustGetCertificateAtIndex(trust, i); 1188 server_cert_summary = CopyCertSubject(server_cert); 1189 memset(server_cert_summary_c, 0, 128); 1190 if(CFStringGetCString(server_cert_summary, 1191 server_cert_summary_c, 1192 128, 1193 kCFStringEncodingUTF8)) { 1194 infof(data, "Server certificate: %s\n", server_cert_summary_c); 1195 } 1196 CFRelease(server_cert_summary); 1197 } 1198 CFRelease(trust); 1199 } 1200 } 1201 else { 1202 err = SSLCopyPeerCertificates(connssl->ssl_ctx, &server_certs); 1203 if(err == noErr) { 1204 count = CFArrayGetCount(server_certs); 1205 for(i = 0L ; i < count ; i++) { 1206 server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs, 1207 i); 1208 1209 server_cert_summary = CopyCertSubject(server_cert); 1210 memset(server_cert_summary_c, 0, 128); 1211 if(CFStringGetCString(server_cert_summary, 1212 server_cert_summary_c, 1213 128, 1214 kCFStringEncodingUTF8)) { 1215 infof(data, "Server certificate: %s\n", server_cert_summary_c); 1216 } 1217 CFRelease(server_cert_summary); 1218 } 1219 CFRelease(server_certs); 1220 } 1221 } 1222#endif /* (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE) */ 1223#else 1224#pragma unused(trust) 1225 err = SSLCopyPeerCertificates(connssl->ssl_ctx, &server_certs); 1226 if(err == noErr) { 1227 count = CFArrayGetCount(server_certs); 1228 for(i = 0L ; i < count ; i++) { 1229 server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs, i); 1230 server_cert_summary = CopyCertSubject(server_cert); 1231 memset(server_cert_summary_c, 0, 128); 1232 if(CFStringGetCString(server_cert_summary, 1233 server_cert_summary_c, 1234 128, 1235 kCFStringEncodingUTF8)) { 1236 infof(data, "Server certificate: %s\n", server_cert_summary_c); 1237 } 1238 CFRelease(server_cert_summary); 1239 } 1240 CFRelease(server_certs); 1241 } 1242#endif /* defined(__MAC_10_7) || defined(__IPHONE_5_0) */ 1243 1244 connssl->connecting_state = ssl_connect_done; 1245 return CURLE_OK; 1246} 1247 1248static Curl_recv darwinssl_recv; 1249static Curl_send darwinssl_send; 1250 1251static CURLcode 1252darwinssl_connect_common(struct connectdata *conn, 1253 int sockindex, 1254 bool nonblocking, 1255 bool *done) 1256{ 1257 CURLcode retcode; 1258 struct SessionHandle *data = conn->data; 1259 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1260 curl_socket_t sockfd = conn->sock[sockindex]; 1261 long timeout_ms; 1262 int what; 1263 1264 /* check if the connection has already been established */ 1265 if(ssl_connection_complete == connssl->state) { 1266 *done = TRUE; 1267 return CURLE_OK; 1268 } 1269 1270 if(ssl_connect_1==connssl->connecting_state) { 1271 /* Find out how much more time we're allowed */ 1272 timeout_ms = Curl_timeleft(data, NULL, TRUE); 1273 1274 if(timeout_ms < 0) { 1275 /* no need to continue if time already is up */ 1276 failf(data, "SSL connection timeout"); 1277 return CURLE_OPERATION_TIMEDOUT; 1278 } 1279 retcode = darwinssl_connect_step1(conn, sockindex); 1280 if(retcode) 1281 return retcode; 1282 } 1283 1284 while(ssl_connect_2 == connssl->connecting_state || 1285 ssl_connect_2_reading == connssl->connecting_state || 1286 ssl_connect_2_writing == connssl->connecting_state) { 1287 1288 /* check allowed time left */ 1289 timeout_ms = Curl_timeleft(data, NULL, TRUE); 1290 1291 if(timeout_ms < 0) { 1292 /* no need to continue if time already is up */ 1293 failf(data, "SSL connection timeout"); 1294 return CURLE_OPERATION_TIMEDOUT; 1295 } 1296 1297 /* if ssl is expecting something, check if it's available. */ 1298 if(connssl->connecting_state == ssl_connect_2_reading 1299 || connssl->connecting_state == ssl_connect_2_writing) { 1300 1301 curl_socket_t writefd = ssl_connect_2_writing == 1302 connssl->connecting_state?sockfd:CURL_SOCKET_BAD; 1303 curl_socket_t readfd = ssl_connect_2_reading == 1304 connssl->connecting_state?sockfd:CURL_SOCKET_BAD; 1305 1306 what = Curl_socket_ready(readfd, writefd, nonblocking?0:timeout_ms); 1307 if(what < 0) { 1308 /* fatal error */ 1309 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO); 1310 return CURLE_SSL_CONNECT_ERROR; 1311 } 1312 else if(0 == what) { 1313 if(nonblocking) { 1314 *done = FALSE; 1315 return CURLE_OK; 1316 } 1317 else { 1318 /* timeout */ 1319 failf(data, "SSL connection timeout"); 1320 return CURLE_OPERATION_TIMEDOUT; 1321 } 1322 } 1323 /* socket is readable or writable */ 1324 } 1325 1326 /* Run transaction, and return to the caller if it failed or if this 1327 * connection is done nonblocking and this loop would execute again. This 1328 * permits the owner of a multi handle to abort a connection attempt 1329 * before step2 has completed while ensuring that a client using select() 1330 * or epoll() will always have a valid fdset to wait on. 1331 */ 1332 retcode = darwinssl_connect_step2(conn, sockindex); 1333 if(retcode || (nonblocking && 1334 (ssl_connect_2 == connssl->connecting_state || 1335 ssl_connect_2_reading == connssl->connecting_state || 1336 ssl_connect_2_writing == connssl->connecting_state))) 1337 return retcode; 1338 1339 } /* repeat step2 until all transactions are done. */ 1340 1341 1342 if(ssl_connect_3==connssl->connecting_state) { 1343 retcode = darwinssl_connect_step3(conn, sockindex); 1344 if(retcode) 1345 return retcode; 1346 } 1347 1348 if(ssl_connect_done==connssl->connecting_state) { 1349 connssl->state = ssl_connection_complete; 1350 conn->recv[sockindex] = darwinssl_recv; 1351 conn->send[sockindex] = darwinssl_send; 1352 *done = TRUE; 1353 } 1354 else 1355 *done = FALSE; 1356 1357 /* Reset our connect state machine */ 1358 connssl->connecting_state = ssl_connect_1; 1359 1360 return CURLE_OK; 1361} 1362 1363CURLcode 1364Curl_darwinssl_connect_nonblocking(struct connectdata *conn, 1365 int sockindex, 1366 bool *done) 1367{ 1368 return darwinssl_connect_common(conn, sockindex, TRUE, done); 1369} 1370 1371CURLcode 1372Curl_darwinssl_connect(struct connectdata *conn, 1373 int sockindex) 1374{ 1375 CURLcode retcode; 1376 bool done = FALSE; 1377 1378 retcode = darwinssl_connect_common(conn, sockindex, FALSE, &done); 1379 1380 if(retcode) 1381 return retcode; 1382 1383 DEBUGASSERT(done); 1384 1385 return CURLE_OK; 1386} 1387 1388void Curl_darwinssl_close(struct connectdata *conn, int sockindex) 1389{ 1390 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1391 1392 if(connssl->ssl_ctx) { 1393 (void)SSLClose(connssl->ssl_ctx); 1394#if defined(__MAC_10_8) || defined(__IPHONE_5_0) 1395 if(SSLCreateContext != NULL) 1396 CFRelease(connssl->ssl_ctx); 1397#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) 1398 else 1399 (void)SSLDisposeContext(connssl->ssl_ctx); 1400#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) */ 1401#else 1402 (void)SSLDisposeContext(connssl->ssl_ctx); 1403#endif /* defined(__MAC_10_8) || defined(__IPHONE_5_0) */ 1404 connssl->ssl_ctx = NULL; 1405 } 1406 connssl->ssl_sockfd = 0; 1407} 1408 1409void Curl_darwinssl_close_all(struct SessionHandle *data) 1410{ 1411 /* SecureTransport doesn't separate sessions from contexts, so... */ 1412 (void)data; 1413} 1414 1415int Curl_darwinssl_shutdown(struct connectdata *conn, int sockindex) 1416{ 1417 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1418 struct SessionHandle *data = conn->data; 1419 ssize_t nread; 1420 int what; 1421 int rc; 1422 char buf[120]; 1423 1424 if(!connssl->ssl_ctx) 1425 return 0; 1426 1427 if(data->set.ftp_ccc != CURLFTPSSL_CCC_ACTIVE) 1428 return 0; 1429 1430 Curl_darwinssl_close(conn, sockindex); 1431 1432 rc = 0; 1433 1434 what = Curl_socket_ready(conn->sock[sockindex], 1435 CURL_SOCKET_BAD, SSL_SHUTDOWN_TIMEOUT); 1436 1437 for(;;) { 1438 if(what < 0) { 1439 /* anything that gets here is fatally bad */ 1440 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO); 1441 rc = -1; 1442 break; 1443 } 1444 1445 if(!what) { /* timeout */ 1446 failf(data, "SSL shutdown timeout"); 1447 break; 1448 } 1449 1450 /* Something to read, let's do it and hope that it is the close 1451 notify alert from the server. No way to SSL_Read now, so use read(). */ 1452 1453 nread = read(conn->sock[sockindex], buf, sizeof(buf)); 1454 1455 if(nread < 0) { 1456 failf(data, "read: %s", strerror(errno)); 1457 rc = -1; 1458 } 1459 1460 if(nread <= 0) 1461 break; 1462 1463 what = Curl_socket_ready(conn->sock[sockindex], CURL_SOCKET_BAD, 0); 1464 } 1465 1466 return rc; 1467} 1468 1469size_t Curl_darwinssl_version(char *buffer, size_t size) 1470{ 1471 return snprintf(buffer, size, "SecureTransport"); 1472} 1473 1474/* 1475 * This function uses SSLGetSessionState to determine connection status. 1476 * 1477 * Return codes: 1478 * 1 means the connection is still in place 1479 * 0 means the connection has been closed 1480 * -1 means the connection status is unknown 1481 */ 1482int Curl_darwinssl_check_cxn(struct connectdata *conn) 1483{ 1484 struct ssl_connect_data *connssl = &conn->ssl[FIRSTSOCKET]; 1485 OSStatus err; 1486 SSLSessionState state; 1487 1488 if(connssl->ssl_ctx) { 1489 err = SSLGetSessionState(connssl->ssl_ctx, &state); 1490 if(err == noErr) 1491 return state == kSSLConnected || state == kSSLHandshake; 1492 return -1; 1493 } 1494 return 0; 1495} 1496 1497bool Curl_darwinssl_data_pending(const struct connectdata *conn, 1498 int connindex) 1499{ 1500 const struct ssl_connect_data *connssl = &conn->ssl[connindex]; 1501 OSStatus err; 1502 size_t buffer; 1503 1504 if(connssl->ssl_ctx) { /* SSL is in use */ 1505 err = SSLGetBufferedReadSize(connssl->ssl_ctx, &buffer); 1506 if(err == noErr) 1507 return buffer > 0UL; 1508 return false; 1509 } 1510 else 1511 return false; 1512} 1513 1514void Curl_darwinssl_random(struct SessionHandle *data, 1515 unsigned char *entropy, 1516 size_t length) 1517{ 1518 /* arc4random_buf() isn't available on cats older than Lion, so let's 1519 do this manually for the benefit of the older cats. */ 1520 size_t i; 1521 u_int32_t random_number = 0; 1522 1523 for(i = 0 ; i < length ; i++) { 1524 if(i % sizeof(u_int32_t) == 0) 1525 random_number = arc4random(); 1526 entropy[i] = random_number & 0xFF; 1527 random_number >>= 8; 1528 } 1529 i = random_number = 0; 1530 (void)data; 1531} 1532 1533void Curl_darwinssl_md5sum(unsigned char *tmp, /* input */ 1534 size_t tmplen, 1535 unsigned char *md5sum, /* output */ 1536 size_t md5len) 1537{ 1538 (void)md5len; 1539 (void)CC_MD5(tmp, (CC_LONG)tmplen, md5sum); 1540} 1541 1542static ssize_t darwinssl_send(struct connectdata *conn, 1543 int sockindex, 1544 const void *mem, 1545 size_t len, 1546 CURLcode *curlcode) 1547{ 1548 /*struct SessionHandle *data = conn->data;*/ 1549 struct ssl_connect_data *connssl = &conn->ssl[sockindex]; 1550 size_t processed = 0UL; 1551 OSStatus err; 1552 1553 /* The SSLWrite() function works a little differently than expected. The 1554 fourth argument (processed) is currently documented in Apple's 1555 documentation as: "On return, the length, in bytes, of the data actually 1556 written." 1557 1558 Now, one could interpret that as "written to the socket," but actually, 1559 it returns the amount of data that was written to a buffer internal to 1560 the SSLContextRef instead. So it's possible for SSLWrite() to return 1561 errSSLWouldBlock and a number of bytes "written" because those bytes were 1562 encrypted and written to a buffer, not to the socket. 1563 1564 So if this happens, then we need to keep calling SSLWrite() over and 1565 over again with no new data until it quits returning errSSLWouldBlock. */ 1566 1567 /* Do we have buffered data to write from the last time we were called? */ 1568 if(connssl->ssl_write_buffered_length) { 1569 /* Write the buffered data: */ 1570 err = SSLWrite(connssl->ssl_ctx, NULL, 0UL, &processed); 1571 switch (err) { 1572 case noErr: 1573 /* processed is always going to be 0 because we didn't write to 1574 the buffer, so return how much was written to the socket */ 1575 processed = connssl->ssl_write_buffered_length; 1576 connssl->ssl_write_buffered_length = 0UL; 1577 break; 1578 case errSSLWouldBlock: /* argh, try again */ 1579 *curlcode = CURLE_AGAIN; 1580 return -1L; 1581 default: 1582 failf(conn->data, "SSLWrite() returned error %d", err); 1583 *curlcode = CURLE_SEND_ERROR; 1584 return -1L; 1585 } 1586 } 1587 else { 1588 /* We've got new data to write: */ 1589 err = SSLWrite(connssl->ssl_ctx, mem, len, &processed); 1590 if(err != noErr) { 1591 switch (err) { 1592 case errSSLWouldBlock: 1593 /* Data was buffered but not sent, we have to tell the caller 1594 to try sending again, and remember how much was buffered */ 1595 connssl->ssl_write_buffered_length = len; 1596 *curlcode = CURLE_AGAIN; 1597 return -1L; 1598 default: 1599 failf(conn->data, "SSLWrite() returned error %d", err); 1600 *curlcode = CURLE_SEND_ERROR; 1601 return -1L; 1602 } 1603 } 1604 } 1605 return (ssize_t)processed; 1606} 1607 1608static ssize_t darwinssl_recv(struct connectdata *conn, 1609 int num, 1610 char *buf, 1611 size_t buffersize, 1612 CURLcode *curlcode) 1613{ 1614 /*struct SessionHandle *data = conn->data;*/ 1615 struct ssl_connect_data *connssl = &conn->ssl[num]; 1616 size_t processed = 0UL; 1617 OSStatus err = SSLRead(connssl->ssl_ctx, buf, buffersize, &processed); 1618 1619 if(err != noErr) { 1620 switch (err) { 1621 case errSSLWouldBlock: /* return how much we read (if anything) */ 1622 if(processed) 1623 return (ssize_t)processed; 1624 *curlcode = CURLE_AGAIN; 1625 return -1L; 1626 break; 1627 1628 /* errSSLClosedGraceful - server gracefully shut down the SSL session 1629 errSSLClosedNoNotify - server hung up on us instead of sending a 1630 closure alert notice, read() is returning 0 1631 Either way, inform the caller that the server disconnected. */ 1632 case errSSLClosedGraceful: 1633 case errSSLClosedNoNotify: 1634 *curlcode = CURLE_OK; 1635 return -1L; 1636 break; 1637 1638 default: 1639 failf(conn->data, "SSLRead() return error %d", err); 1640 *curlcode = CURLE_RECV_ERROR; 1641 return -1L; 1642 break; 1643 } 1644 } 1645 return (ssize_t)processed; 1646} 1647 1648#endif /* USE_DARWINSSL */ 1649