sectransp.c@ 108333

最後變更在這個檔案從108333是 108048,由 vboxsync 提交於 7 週前
curl-8.11.1: Applied and adjusted our curl changes to 8.7.1. jiraref:VBP-1535
屬性 svn:eol-style 設為 `native`
檔案大小: 90.2 KB

行
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) Daniel Stenberg, <[email protected]>, et al.
9	* Copyright (C) Nick Zitzmann, <[email protected]>.
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 https://curl.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	* SPDX-License-Identifier: curl
23	*
24	***************************************************************************/
25
26	/*
27	* Source file for all iOS and macOS Secure Transport-specific code for the
28	* TLS/SSL layer. No code but vtls.c should ever call or use these functions.
29	*/
30
31	#include "curl_setup.h"
32
33	#ifdef USE_SECTRANSP
34
35	#include "urldata.h" /* for the Curl_easy definition */
36	#include "curl_base64.h"
37	#include "strtok.h"
38	#include "multiif.h"
39	#include "strcase.h"
40	#include "x509asn1.h"
41	#include "strerror.h"
42	#include "cipher_suite.h"
43
44	#ifdef __clang__
45	#pragma clang diagnostic push
46	#pragma clang diagnostic ignored "-Wunreachable-code"
47	#endif /* __clang__ */
48
49	#ifdef __GNUC__
50	#pragma GCC diagnostic push
51	#pragma GCC diagnostic ignored "-Waddress"
52	#endif
53
54	#include <limits.h>
55
56	#include <Security/Security.h>
57	/* For some reason, when building for iOS, the omnibus header above does
58	* not include SecureTransport.h as of iOS SDK 5.1. */
59	#include <Security/SecureTransport.h>
60	#include <CoreFoundation/CoreFoundation.h>
61	#include <CommonCrypto/CommonDigest.h>
62
63	/* The Security framework has changed greatly between iOS and different macOS
64	versions, and we will try to support as many of them as we can (back to
65	Leopard and iOS 5) by using macros and weak-linking.
66
67	In general, you want to build this using the most recent OS SDK, since some
68	features require curl to be built against the latest SDK. TLS 1.1 and 1.2
69	support, for instance, require the macOS 10.8 SDK or later. TLS 1.3
70	requires the macOS 10.13 or iOS 11 SDK or later. */
71	#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED \|\| TARGET_OS_IPHONE))
72
73	#if MAC_OS_X_VERSION_MAX_ALLOWED < 1050
74	#error "The Secure Transport backend requires Leopard or later."
75	#endif /* MAC_OS_X_VERSION_MAX_ALLOWED < 1050 */
76
77	#define CURL_BUILD_IOS 0
78	#define CURL_BUILD_IOS_7 0
79	#define CURL_BUILD_IOS_9 0
80	#define CURL_BUILD_IOS_11 0
81	#define CURL_BUILD_IOS_13 0
82	#define CURL_BUILD_MAC 1
83	/* This is the maximum API level we are allowed to use when building: */
84	#define CURL_BUILD_MAC_10_5 MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
85	#define CURL_BUILD_MAC_10_6 MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
86	#define CURL_BUILD_MAC_10_7 MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
87	#define CURL_BUILD_MAC_10_8 MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
88	#define CURL_BUILD_MAC_10_9 MAC_OS_X_VERSION_MAX_ALLOWED >= 1090
89	#define CURL_BUILD_MAC_10_11 MAC_OS_X_VERSION_MAX_ALLOWED >= 101100
90	#define CURL_BUILD_MAC_10_13 MAC_OS_X_VERSION_MAX_ALLOWED >= 101300
91	#define CURL_BUILD_MAC_10_15 MAC_OS_X_VERSION_MAX_ALLOWED >= 101500
92	/* These macros mean "the following code is present to allow runtime backward
93	compatibility with at least this cat or earlier":
94	(You set this at build-time using the compiler command line option
95	"-mmacosx-version-min.") */
96	#define CURL_SUPPORT_MAC_10_5 MAC_OS_X_VERSION_MIN_REQUIRED <= 1050
97	#define CURL_SUPPORT_MAC_10_6 MAC_OS_X_VERSION_MIN_REQUIRED <= 1060
98	#define CURL_SUPPORT_MAC_10_7 MAC_OS_X_VERSION_MIN_REQUIRED <= 1070
99	#define CURL_SUPPORT_MAC_10_8 MAC_OS_X_VERSION_MIN_REQUIRED <= 1080
100	#define CURL_SUPPORT_MAC_10_9 MAC_OS_X_VERSION_MIN_REQUIRED <= 1090
101
102	#elif TARGET_OS_EMBEDDED \|\| TARGET_OS_IPHONE
103	#define CURL_BUILD_IOS 1
104	#define CURL_BUILD_IOS_7 __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000
105	#define CURL_BUILD_IOS_9 __IPHONE_OS_VERSION_MAX_ALLOWED >= 90000
106	#define CURL_BUILD_IOS_11 __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000
107	#define CURL_BUILD_IOS_13 __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
108	#define CURL_BUILD_MAC 0
109	#define CURL_BUILD_MAC_10_5 0
110	#define CURL_BUILD_MAC_10_6 0
111	#define CURL_BUILD_MAC_10_7 0
112	#define CURL_BUILD_MAC_10_8 0
113	#define CURL_BUILD_MAC_10_9 0
114	#define CURL_BUILD_MAC_10_11 0
115	#define CURL_BUILD_MAC_10_13 0
116	#define CURL_BUILD_MAC_10_15 0
117	#define CURL_SUPPORT_MAC_10_5 0
118	#define CURL_SUPPORT_MAC_10_6 0
119	#define CURL_SUPPORT_MAC_10_7 0
120	#define CURL_SUPPORT_MAC_10_8 0
121	#define CURL_SUPPORT_MAC_10_9 0
122
123	#else
124	#error "The Secure Transport backend requires iOS or macOS."
125	#endif /* (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED \|\| TARGET_OS_IPHONE)) */
126
127	#if CURL_BUILD_MAC
128	#include <sys/sysctl.h>
129	#endif /* CURL_BUILD_MAC */
130
131	#include "sendf.h"
132	#include "inet_pton.h"
133	#include "connect.h"
134	#include "select.h"
135	#include "vtls.h"
136	#include "vtls_int.h"
137	#include "sectransp.h"
138	#include "curl_printf.h"
139	#include "strdup.h"
140
141	#include "curl_memory.h"
142	/* The last #include file should be: */
143	#include "memdebug.h"
144
145
146	/* From MacTypes.h (which we cannot include because it is not present in
147	iOS: */
148	#define ioErr -36
149	#define paramErr -50
150
151	struct st_ssl_backend_data {
152	SSLContextRef ssl_ctx;
153	bool ssl_direction; /* true if writing, false if reading */
154	size_t ssl_write_buffered_length;
155	BIT(sent_shutdown);
156	};
157
158	/* Create the list of default ciphers to use by making an intersection of the
159	* ciphers supported by Secure Transport and the list below, using the order
160	* of the former.
161	* This list is based on TLS recommendations by Mozilla, balancing between
162	* security and wide compatibility: "Most ciphers that are not clearly broken
163	* and dangerous to use are supported"
164	*/
165	static const uint16_t default_ciphers[] = {
166	TLS_RSA_WITH_3DES_EDE_CBC_SHA, /* 0x000A */
167	TLS_RSA_WITH_AES_128_CBC_SHA, /* 0x002F */
168	TLS_RSA_WITH_AES_256_CBC_SHA, /* 0x0035 */
169
170	#if CURL_BUILD_MAC_10_6 \|\| CURL_BUILD_IOS
171	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, /* 0xC009 */
172	TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, /* 0xC00A */
173	TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, /* 0xC013 */
174	TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, /* 0xC014 */
175	#endif /* CURL_BUILD_MAC_10_6 \|\| CURL_BUILD_IOS */
176
177	#if CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS
178	TLS_RSA_WITH_AES_128_CBC_SHA256, /* 0x003C */
179	TLS_RSA_WITH_AES_256_CBC_SHA256, /* 0x003D */
180	TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, /* 0x0067 */
181	TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, /* 0x006B */
182	TLS_RSA_WITH_AES_128_GCM_SHA256, /* 0x009C */
183	TLS_RSA_WITH_AES_256_GCM_SHA384, /* 0x009D */
184	TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, /* 0x009E */
185	TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, /* 0x009F */
186	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, /* 0xC023 */
187	TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, /* 0xC024 */
188	TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, /* 0xC027 */
189	TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, /* 0xC028 */
190	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, /* 0xC02B */
191	TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, /* 0xC02C */
192	TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, /* 0xC02F */
193	TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, /* 0xC030 */
194	#endif /* CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS */
195
196	#if CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11
197	TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, /* 0xCCA8 */
198	TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, /* 0xCCA9 */
199
200	/* TLSv1.3 is not supported by Secure Transport, but there is also other
201	* code referencing TLSv1.3, like: kTLSProtocol13 ? */
202	TLS_AES_128_GCM_SHA256, /* 0x1301 */
203	TLS_AES_256_GCM_SHA384, /* 0x1302 */
204	TLS_CHACHA20_POLY1305_SHA256, /* 0x1303 */
205	#endif /* CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11 */
206	};
207
208	#define DEFAULT_CIPHERS_LEN sizeof(default_ciphers)/sizeof(default_ciphers[0])
209
210
211	/* pinned public key support tests */
212
213	/* version 1 supports macOS 10.12+ and iOS 10+ */
214	#if ((TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000) \|\| \
215	(!TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200))
216	#define SECTRANSP_PINNEDPUBKEY_V1 1
217	#endif
218
219	/* version 2 supports macOS 10.7+ */
220	#if (!TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070)
221	#define SECTRANSP_PINNEDPUBKEY_V2 1
222	#endif
223
224	#if defined(SECTRANSP_PINNEDPUBKEY_V1) \|\| defined(SECTRANSP_PINNEDPUBKEY_V2)
225	/* this backend supports CURLOPT_PINNEDPUBLICKEY */
226	#define SECTRANSP_PINNEDPUBKEY 1
227	#endif /* SECTRANSP_PINNEDPUBKEY */
228
229	#ifdef SECTRANSP_PINNEDPUBKEY
230	/* both new and old APIs return rsa keys missing the spki header (not DER) */
231	static const unsigned char rsa4096SpkiHeader[] = {
232	0x30, 0x82, 0x02, 0x22, 0x30, 0x0d,
233	0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
234	0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
235	0x00, 0x03, 0x82, 0x02, 0x0f, 0x00};
236
237	static const unsigned char rsa2048SpkiHeader[] = {
238	0x30, 0x82, 0x01, 0x22, 0x30, 0x0d,
239	0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
240	0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
241	0x00, 0x03, 0x82, 0x01, 0x0f, 0x00};
242	#ifdef SECTRANSP_PINNEDPUBKEY_V1
243	/* the new version does not return DER encoded ecdsa certs like the old... */
244	static const unsigned char ecDsaSecp256r1SpkiHeader[] = {
245	0x30, 0x59, 0x30, 0x13, 0x06, 0x07,
246	0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
247	0x01, 0x06, 0x08, 0x2a, 0x86, 0x48,
248	0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
249	0x42, 0x00};
250
251	static const unsigned char ecDsaSecp384r1SpkiHeader[] = {
252	0x30, 0x76, 0x30, 0x10, 0x06, 0x07,
253	0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
254	0x01, 0x06, 0x05, 0x2b, 0x81, 0x04,
255	0x00, 0x22, 0x03, 0x62, 0x00};
256	#endif /* SECTRANSP_PINNEDPUBKEY_V1 */
257	#endif /* SECTRANSP_PINNEDPUBKEY */
258
259	static OSStatus sectransp_bio_cf_in_read(SSLConnectionRef connection,
260	void *buf,
261	size_t dataLength) / IN/OUT */
262	{
263	struct Curl_cfilter cf = (struct Curl_cfilter )connection;
264	struct ssl_connect_data *connssl = cf->ctx;
265	struct st_ssl_backend_data *backend =
266	(struct st_ssl_backend_data *)connssl->backend;
267	struct Curl_easy *data = CF_DATA_CURRENT(cf);
268	ssize_t nread;
269	CURLcode result;
270	OSStatus rtn = noErr;
271
272	DEBUGASSERT(data);
273	nread = Curl_conn_cf_recv(cf->next, data, buf, *dataLength, &result);
274	CURL_TRC_CF(data, cf, "bio_read(len=%zu) -> %zd, result=%d",
275	*dataLength, nread, result);
276	if(nread < 0) {
277	switch(result) {
278	case CURLE_OK:
279	case CURLE_AGAIN:
280	rtn = errSSLWouldBlock;
281	backend->ssl_direction = FALSE;
282	break;
283	default:
284	rtn = ioErr;
285	break;
286	}
287	nread = 0;
288	}
289	else if(nread == 0) {
290	rtn = errSSLClosedGraceful;
291	}
292	else if((size_t)nread < *dataLength) {
293	rtn = errSSLWouldBlock;
294	}
295	*dataLength = nread;
296	return rtn;
297	}
298
299	static OSStatus sectransp_bio_cf_out_write(SSLConnectionRef connection,
300	const void *buf,
301	size_t dataLength) / IN/OUT */
302	{
303	struct Curl_cfilter cf = (struct Curl_cfilter )connection;
304	struct ssl_connect_data *connssl = cf->ctx;
305	struct st_ssl_backend_data *backend =
306	(struct st_ssl_backend_data *)connssl->backend;
307	struct Curl_easy *data = CF_DATA_CURRENT(cf);
308	ssize_t nwritten;
309	CURLcode result;
310	OSStatus rtn = noErr;
311
312	DEBUGASSERT(data);
313	nwritten = Curl_conn_cf_send(cf->next, data, buf, *dataLength, FALSE,
314	&result);
315	CURL_TRC_CF(data, cf, "bio_send(len=%zu) -> %zd, result=%d",
316	*dataLength, nwritten, result);
317	if(nwritten <= 0) {
318	if(result == CURLE_AGAIN) {
319	rtn = errSSLWouldBlock;
320	backend->ssl_direction = TRUE;
321	}
322	else {
323	rtn = ioErr;
324	}
325	nwritten = 0;
326	}
327	else if((size_t)nwritten < *dataLength) {
328	rtn = errSSLWouldBlock;
329	}
330	*dataLength = nwritten;
331	return rtn;
332	}
333
334	#if CURL_BUILD_MAC
335	CF_INLINE void GetDarwinVersionNumber(int major, int minor)
336	{
337	int mib[2];
338	char *os_version;
339	size_t os_version_len;
340	char os_version_major, os_version_minor;
341	char *tok_buf;
342
343	/* Get the Darwin kernel version from the kernel using sysctl(): */
344	mib[0] = CTL_KERN;
345	mib[1] = KERN_OSRELEASE;
346	if(sysctl(mib, 2, NULL, &os_version_len, NULL, 0) == -1)
347	return;
348	os_version = malloc(os_version_len*sizeof(char));
349	if(!os_version)
350	return;
351	if(sysctl(mib, 2, os_version, &os_version_len, NULL, 0) == -1) {
352	free(os_version);
353	return;
354	}
355
356	/* Parse the version: */
357	os_version_major = Curl_strtok_r(os_version, ".", &tok_buf);
358	os_version_minor = Curl_strtok_r(NULL, ".", &tok_buf);
359	*major = atoi(os_version_major);
360	*minor = atoi(os_version_minor);
361	free(os_version);
362	}
363	#endif /* CURL_BUILD_MAC */
364
365	/* Apple provides a myriad of ways of getting information about a certificate
366	into a string. Some are not available under iOS or newer cats. Here's a
367	unified function for getting a string describing the certificate that ought
368	to work in all cats starting with Leopard. */
369	CF_INLINE CFStringRef getsubject(SecCertificateRef cert)
370	{
371	CFStringRef server_cert_summary = CFSTR("(null)");
372
373	#if CURL_BUILD_IOS
374	/* iOS: There is only one way to do this. */
375	server_cert_summary = SecCertificateCopySubjectSummary(cert);
376	#else
377	#if CURL_BUILD_MAC_10_7
378	/* Lion & later: Get the long description if we can. */
379	if(&SecCertificateCopyLongDescription)
380	server_cert_summary =
381	SecCertificateCopyLongDescription(NULL, cert, NULL);
382	else
383	#endif /* CURL_BUILD_MAC_10_7 */
384	#if CURL_BUILD_MAC_10_6
385	/* Snow Leopard: Get the certificate summary. */
386	if(&SecCertificateCopySubjectSummary)
387	server_cert_summary = SecCertificateCopySubjectSummary(cert);
388	else
389	#endif /* CURL_BUILD_MAC_10_6 */
390	/* Leopard is as far back as we go... */
391	(void)SecCertificateCopyCommonName(cert, &server_cert_summary);
392	#endif /* CURL_BUILD_IOS */
393	return server_cert_summary;
394	}
395
396	static CURLcode CopyCertSubject(struct Curl_easy *data,
397	SecCertificateRef cert, char **certp)
398	{
399	CFStringRef c = getsubject(cert);
400	CURLcode result = CURLE_OK;
401	const char *direct;
402	char *cbuf = NULL;
403	*certp = NULL;
404
405	if(!c) {
406	failf(data, "SSL: invalid CA certificate subject");
407	return CURLE_PEER_FAILED_VERIFICATION;
408	}
409
410	/* If the subject is already available as UTF-8 encoded (ie 'direct') then
411	use that, else convert it. */
412	direct = CFStringGetCStringPtr(c, kCFStringEncodingUTF8);
413	if(direct) {
414	*certp = strdup(direct);
415	if(!*certp) {
416	failf(data, "SSL: out of memory");
417	result = CURLE_OUT_OF_MEMORY;
418	}
419	}
420	else {
421	size_t cbuf_size = ((size_t)CFStringGetLength(c) * 4) + 1;
422	cbuf = calloc(1, cbuf_size);
423	if(cbuf) {
424	if(!CFStringGetCString(c, cbuf, (CFIndex)cbuf_size,
425	kCFStringEncodingUTF8)) {
426	failf(data, "SSL: invalid CA certificate subject");
427	result = CURLE_PEER_FAILED_VERIFICATION;
428	}
429	else
430	/* pass back the buffer */
431	*certp = cbuf;
432	}
433	else {
434	failf(data, "SSL: could not allocate %zu bytes of memory", cbuf_size);
435	result = CURLE_OUT_OF_MEMORY;
436	}
437	}
438	if(result)
439	free(cbuf);
440	CFRelease(c);
441	return result;
442	}
443
444	#if CURL_SUPPORT_MAC_10_6
445	/* The SecKeychainSearch API was deprecated in Lion, and using it will raise
446	deprecation warnings, so let's not compile this unless it is necessary: */
447	static OSStatus CopyIdentityWithLabelOldSchool(char *label,
448	SecIdentityRef *out_c_a_k)
449	{
450	OSStatus status = errSecItemNotFound;
451	SecKeychainAttributeList attr_list;
452	SecKeychainAttribute attr;
453	SecKeychainSearchRef search = NULL;
454	SecCertificateRef cert = NULL;
455
456	/* Set up the attribute list: */
457	attr_list.count = 1L;
458	attr_list.attr = &attr;
459
460	/* Set up our lone search criterion: */
461	attr.tag = kSecLabelItemAttr;
462	attr.data = label;
463	attr.length = (UInt32)strlen(label);
464
465	/* Start searching: */
466	status = SecKeychainSearchCreateFromAttributes(NULL,
467	kSecCertificateItemClass,
468	&attr_list,
469	&search);
470	if(status == noErr) {
471	status = SecKeychainSearchCopyNext(search,
472	(SecKeychainItemRef *)&cert);
473	if(status == noErr && cert) {
474	/* If we found a certificate, does it have a private key? */
475	status = SecIdentityCreateWithCertificate(NULL, cert, out_c_a_k);
476	CFRelease(cert);
477	}
478	}
479
480	if(search)
481	CFRelease(search);
482	return status;
483	}
484	#endif /* CURL_SUPPORT_MAC_10_6 */
485
486	static OSStatus CopyIdentityWithLabel(char *label,
487	SecIdentityRef *out_cert_and_key)
488	{
489	OSStatus status = errSecItemNotFound;
490
491	#if CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS
492	CFArrayRef keys_list;
493	CFIndex keys_list_count;
494	CFIndex i;
495
496	/* SecItemCopyMatching() was introduced in iOS and Snow Leopard.
497	kSecClassIdentity was introduced in Lion. If both exist, let's use them
498	to find the certificate. */
499	if(&SecItemCopyMatching && kSecClassIdentity) {
500	CFTypeRef keys[5];
501	CFTypeRef values[5];
502	CFDictionaryRef query_dict;
503	CFStringRef label_cf = CFStringCreateWithCString(NULL, label,
504	kCFStringEncodingUTF8);
505
506	/* Set up our search criteria and expected results: */
507	values[0] = kSecClassIdentity; /* we want a certificate and a key */
508	keys[0] = kSecClass;
509	values[1] = kCFBooleanTrue; /* we want a reference */
510	keys[1] = kSecReturnRef;
511	values[2] = kSecMatchLimitAll; /* kSecMatchLimitOne would be better if the
512	* label matching below worked correctly */
513	keys[2] = kSecMatchLimit;
514	/* identity searches need a SecPolicyRef in order to work */
515	values[3] = SecPolicyCreateSSL(FALSE, NULL);
516	keys[3] = kSecMatchPolicy;
517	/* match the name of the certificate (does not work in macOS 10.12.1) */
518	values[4] = label_cf;
519	keys[4] = kSecAttrLabel;
520	query_dict = CFDictionaryCreate(NULL, (const void **)keys,
521	(const void **)values, 5L,
522	&kCFCopyStringDictionaryKeyCallBacks,
523	&kCFTypeDictionaryValueCallBacks);
524	CFRelease(values[3]);
525
526	/* Do we have a match? */
527	status = SecItemCopyMatching(query_dict, (CFTypeRef *) &keys_list);
528
529	/* Because kSecAttrLabel matching does not work with kSecClassIdentity,
530	* we need to find the correct identity ourselves */
531	if(status == noErr) {
532	keys_list_count = CFArrayGetCount(keys_list);
533	*out_cert_and_key = NULL;
534	status = 1;
535	for(i = 0; i < keys_list_count; i++) {
536	OSStatus err = noErr;
537	SecCertificateRef cert = NULL;
538	SecIdentityRef identity =
539	(SecIdentityRef) CFArrayGetValueAtIndex(keys_list, i);
540	err = SecIdentityCopyCertificate(identity, &cert);
541	if(err == noErr) {
542	CFStringRef common_name = NULL;
543	OSStatus copy_status = noErr;
544	#if CURL_BUILD_IOS
545	common_name = SecCertificateCopySubjectSummary(cert);
546	#elif CURL_BUILD_MAC_10_7
547	copy_status = SecCertificateCopyCommonName(cert, &common_name);
548	#endif
549	if(copy_status == noErr &&
550	CFStringCompare(common_name, label_cf, 0) == kCFCompareEqualTo) {
551	CFRelease(cert);
552	CFRelease(common_name);
553	CFRetain(identity);
554	*out_cert_and_key = identity;
555	status = noErr;
556	break;
557	}
558	if(common_name)
559	CFRelease(common_name);
560	}
561	CFRelease(cert);
562	}
563	}
564
565	if(keys_list)
566	CFRelease(keys_list);
567	CFRelease(query_dict);
568	CFRelease(label_cf);
569	}
570	else {
571	#if CURL_SUPPORT_MAC_10_6
572	/* On Leopard and Snow Leopard, fall back to SecKeychainSearch. */
573	status = CopyIdentityWithLabelOldSchool(label, out_cert_and_key);
574	#endif /* CURL_SUPPORT_MAC_10_6 */
575	}
576	#elif CURL_SUPPORT_MAC_10_6
577	/* For developers building on older cats, we have no choice but to fall back
578	to SecKeychainSearch. */
579	status = CopyIdentityWithLabelOldSchool(label, out_cert_and_key);
580	#endif /* CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS */
581	return status;
582	}
583
584	static OSStatus CopyIdentityFromPKCS12File(const char *cPath,
585	const struct curl_blob *blob,
586	const char *cPassword,
587	SecIdentityRef *out_cert_and_key)
588	{
589	OSStatus status = errSecItemNotFound;
590	CFURLRef pkcs_url = NULL;
591	CFStringRef password = cPassword ? CFStringCreateWithCString(NULL,
592	cPassword, kCFStringEncodingUTF8) : NULL;
593	CFDataRef pkcs_data = NULL;
594
595	/* We can import P12 files on iOS or macOS 10.7 or later: */
596	/* These constants are documented as having first appeared in 10.6 but they
597	raise linker errors when used on that cat for some reason. */
598	#if CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS
599	bool resource_imported;
600
601	if(blob) {
602	pkcs_data = CFDataCreate(kCFAllocatorDefault,
603	(const unsigned char *)blob->data,
604	(CFIndex)blob->len);
605	status = (pkcs_data != NULL) ? errSecSuccess : errSecAllocate;
606	resource_imported = (pkcs_data != NULL);
607	}
608	else {
609	pkcs_url =
610	CFURLCreateFromFileSystemRepresentation(NULL,
611	(const UInt8 *)cPath,
612	(CFIndex)strlen(cPath), FALSE);
613	resource_imported =
614	CFURLCreateDataAndPropertiesFromResource(NULL,
615	pkcs_url, &pkcs_data,
616	NULL, NULL, &status);
617	}
618
619	if(resource_imported) {
620	CFArrayRef items = NULL;
621
622	/* On iOS SecPKCS12Import will never add the client certificate to the
623	* Keychain.
624	*
625	* It gives us back a SecIdentityRef that we can use directly. */
626	#if CURL_BUILD_IOS
627	const void *cKeys[] = {kSecImportExportPassphrase};
628	const void *cValues[] = {password};
629	CFDictionaryRef options = CFDictionaryCreate(NULL, cKeys, cValues,
630	password ? 1L : 0L, NULL, NULL);
631
632	if(options) {
633	status = SecPKCS12Import(pkcs_data, options, &items);
634	CFRelease(options);
635	}
636
637
638	/* On macOS SecPKCS12Import will always add the client certificate to
639	* the Keychain.
640	*
641	* As this does not match iOS, and apps may not want to see their client
642	* certificate saved in the user's keychain, we use SecItemImport
643	* with a NULL keychain to avoid importing it.
644	*
645	* This returns a SecCertificateRef from which we can construct a
646	* SecIdentityRef.
647	*/
648	#elif CURL_BUILD_MAC_10_7
649	SecItemImportExportKeyParameters keyParams;
650	SecExternalFormat inputFormat = kSecFormatPKCS12;
651	SecExternalItemType inputType = kSecItemTypeCertificate;
652
653	memset(&keyParams, 0x00, sizeof(keyParams));
654	keyParams.version = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION;
655	keyParams.passphrase = password;
656
657	status = SecItemImport(pkcs_data, NULL, &inputFormat, &inputType,
658	0, &keyParams, NULL, &items);
659	#endif
660
661
662	/* Extract the SecIdentityRef */
663	if(status == errSecSuccess && items && CFArrayGetCount(items)) {
664	CFIndex i, count;
665	count = CFArrayGetCount(items);
666
667	for(i = 0; i < count; i++) {
668	CFTypeRef item = (CFTypeRef) CFArrayGetValueAtIndex(items, i);
669	CFTypeID itemID = CFGetTypeID(item);
670
671	if(itemID == CFDictionaryGetTypeID()) {
672	CFTypeRef identity = (CFTypeRef) CFDictionaryGetValue(
673	(CFDictionaryRef) item,
674	kSecImportItemIdentity);
675	CFRetain(identity);
676	*out_cert_and_key = (SecIdentityRef) identity;
677	break;
678	}
679	#if CURL_BUILD_MAC_10_7
680	else if(itemID == SecCertificateGetTypeID()) {
681	status = SecIdentityCreateWithCertificate(NULL,
682	(SecCertificateRef) item,
683	out_cert_and_key);
684	break;
685	}
686	#endif
687	}
688	}
689
690	if(items)
691	CFRelease(items);
692	CFRelease(pkcs_data);
693	}
694	#endif /* CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS */
695	if(password)
696	CFRelease(password);
697	if(pkcs_url)
698	CFRelease(pkcs_url);
699	return status;
700	}
701
702	/* This code was borrowed from nss.c, with some modifications:
703	* Determine whether the nickname passed in is a filename that needs to
704	* be loaded as a PEM or a nickname.
705	*
706	* returns 1 for a file
707	* returns 0 for not a file
708	*/
709	CF_INLINE bool is_file(const char *filename)
710	{
711	struct_stat st;
712
713	if(!filename)
714	return FALSE;
715
716	if(stat(filename, &st) == 0)
717	return S_ISREG(st.st_mode);
718	return FALSE;
719	}
720
721	static CURLcode
722	sectransp_set_ssl_version_min_max(struct Curl_easy *data,
723	struct st_ssl_backend_data *backend,
724	struct ssl_primary_config *conn_config)
725	{
726	#if CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS
727	OSStatus err;
728	SSLProtocol ver_min;
729	SSLProtocol ver_max;
730
731	#if CURL_SUPPORT_MAC_10_7
732	if(!&SSLSetProtocolVersionMax)
733	goto legacy;
734	#endif
735
736	switch(conn_config->version) {
737	case CURL_SSLVERSION_DEFAULT:
738	case CURL_SSLVERSION_TLSv1:
739	case CURL_SSLVERSION_TLSv1_0:
740	ver_min = kTLSProtocol1;
741	break;
742	case CURL_SSLVERSION_TLSv1_1:
743	ver_min = kTLSProtocol11;
744	break;
745	case CURL_SSLVERSION_TLSv1_2:
746	ver_min = kTLSProtocol12;
747	break;
748	case CURL_SSLVERSION_TLSv1_3:
749	default:
750	failf(data, "SSL: unsupported minimum TLS version value");
751	return CURLE_SSL_CONNECT_ERROR;
752	}
753
754	switch(conn_config->version_max) {
755	case CURL_SSLVERSION_MAX_DEFAULT:
756	case CURL_SSLVERSION_MAX_NONE:
757	case CURL_SSLVERSION_MAX_TLSv1_3:
758	case CURL_SSLVERSION_MAX_TLSv1_2:
759	ver_max = kTLSProtocol12;
760	break;
761	case CURL_SSLVERSION_MAX_TLSv1_1:
762	ver_max = kTLSProtocol11;
763	break;
764	case CURL_SSLVERSION_MAX_TLSv1_0:
765	ver_max = kTLSProtocol1;
766	break;
767	default:
768	failf(data, "SSL: unsupported maximum TLS version value");
769	return CURLE_SSL_CONNECT_ERROR;
770	}
771
772	err = SSLSetProtocolVersionMin(backend->ssl_ctx, ver_min);
773	if(err != noErr) {
774	failf(data, "SSL: failed to set minimum TLS version");
775	return CURLE_SSL_CONNECT_ERROR;
776	}
777	err = SSLSetProtocolVersionMax(backend->ssl_ctx, ver_max);
778	if(err != noErr) {
779	failf(data, "SSL: failed to set maximum TLS version");
780	return CURLE_SSL_CONNECT_ERROR;
781	}
782
783	return CURLE_OK;
784	#endif
785	#if CURL_SUPPORT_MAC_10_7
786	goto legacy;
787	legacy:
788	switch(conn_config->version) {
789	case CURL_SSLVERSION_DEFAULT:
790	case CURL_SSLVERSION_TLSv1:
791	case CURL_SSLVERSION_TLSv1_0:
792	break;
793	default:
794	failf(data, "SSL: unsupported minimum TLS version value");
795	return CURLE_SSL_CONNECT_ERROR;
796	}
797
798	/* only TLS 1.0 is supported, disable SSL 3.0 and SSL 2.0 */
799	SSLSetProtocolVersionEnabled(backend->ssl_ctx, kSSLProtocolAll, FALSE);
800	SSLSetProtocolVersionEnabled(backend->ssl_ctx, kTLSProtocol1, TRUE);
801
802	return CURLE_OK;
803	#endif
804	}
805
806	static int sectransp_cipher_suite_get_str(uint16_t id, char *buf,
807	size_t buf_size, bool prefer_rfc)
808	{
809	/* are these fortezza suites even supported ? */
810	if(id == SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA)
811	msnprintf(buf, buf_size, "%s", "SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA");
812	else if(id == SSL_FORTEZZA_DMS_WITH_NULL_SHA)
813	msnprintf(buf, buf_size, "%s", "SSL_FORTEZZA_DMS_WITH_NULL_SHA");
814	/* can TLS_EMPTY_RENEGOTIATION_INFO_SCSV even be set ? */
815	else if(id == TLS_EMPTY_RENEGOTIATION_INFO_SCSV)
816	msnprintf(buf, buf_size, "%s", "TLS_EMPTY_RENEGOTIATION_INFO_SCSV");
817	/* do we still need to support these SSL2-only ciphers ? */
818	else if(id == SSL_RSA_WITH_RC2_CBC_MD5)
819	msnprintf(buf, buf_size, "%s", "SSL_RSA_WITH_RC2_CBC_MD5");
820	else if(id == SSL_RSA_WITH_IDEA_CBC_MD5)
821	msnprintf(buf, buf_size, "%s", "SSL_RSA_WITH_IDEA_CBC_MD5");
822	else if(id == SSL_RSA_WITH_DES_CBC_MD5)
823	msnprintf(buf, buf_size, "%s", "SSL_RSA_WITH_DES_CBC_MD5");
824	else if(id == SSL_RSA_WITH_3DES_EDE_CBC_MD5)
825	msnprintf(buf, buf_size, "%s", "SSL_RSA_WITH_3DES_EDE_CBC_MD5");
826	else
827	return Curl_cipher_suite_get_str(id, buf, buf_size, prefer_rfc);
828	return 0;
829	}
830
831	static uint16_t sectransp_cipher_suite_walk_str(const char **str,
832	const char **end)
833	{
834	uint16_t id = Curl_cipher_suite_walk_str(str, end);
835	size_t len = end - str;
836
837	if(!id) {
838	/* are these fortezza suites even supported ? */
839	if(strncasecompare("SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA", *str, len))
840	id = SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA;
841	else if(strncasecompare("SSL_FORTEZZA_DMS_WITH_NULL_SHA", *str, len))
842	id = SSL_FORTEZZA_DMS_WITH_NULL_SHA;
843	/* can TLS_EMPTY_RENEGOTIATION_INFO_SCSV even be set ? */
844	else if(strncasecompare("TLS_EMPTY_RENEGOTIATION_INFO_SCSV", *str, len))
845	id = TLS_EMPTY_RENEGOTIATION_INFO_SCSV;
846	/* do we still need to support these SSL2-only ciphers ? */
847	else if(strncasecompare("SSL_RSA_WITH_RC2_CBC_MD5", *str, len))
848	id = SSL_RSA_WITH_RC2_CBC_MD5;
849	else if(strncasecompare("SSL_RSA_WITH_IDEA_CBC_MD5", *str, len))
850	id = SSL_RSA_WITH_IDEA_CBC_MD5;
851	else if(strncasecompare("SSL_RSA_WITH_DES_CBC_MD5", *str, len))
852	id = SSL_RSA_WITH_DES_CBC_MD5;
853	else if(strncasecompare("SSL_RSA_WITH_3DES_EDE_CBC_MD5", *str, len))
854	id = SSL_RSA_WITH_3DES_EDE_CBC_MD5;
855	}
856	return id;
857	}
858
859	/* allocated memory must be freed */
860	static SSLCipherSuite * sectransp_get_supported_ciphers(SSLContextRef ssl_ctx,
861	size_t *len)
862	{
863	SSLCipherSuite *ciphers = NULL;
864	OSStatus err = noErr;
865	*len = 0;
866
867	err = SSLGetNumberSupportedCiphers(ssl_ctx, len);
868	if(err != noErr)
869	goto failed;
870
871	ciphers = malloc(len sizeof(SSLCipherSuite));
872	if(!ciphers)
873	goto failed;
874
875	err = SSLGetSupportedCiphers(ssl_ctx, ciphers, len);
876	if(err != noErr)
877	goto failed;
878
879	#if CURL_BUILD_MAC
880	{
881	int maj = 0, min = 0;
882	GetDarwinVersionNumber(&maj, &min);
883	/* There is a known bug in early versions of Mountain Lion where ST's ECC
884	ciphers (cipher suite 0xC001 through 0xC032) simply do not work.
885	Work around the problem here by disabling those ciphers if we are
886	running in an affected version of macOS. */
887	if(maj == 12 && min <= 3) {
888	size_t i = 0, j = 0;
889	for(; i < *len; i++) {
890	if(ciphers[i] >= 0xC001 && ciphers[i] <= 0xC032)
891	continue;
892	ciphers[j++] = ciphers[i];
893	}
894	*len = j;
895	}
896	}
897	#endif
898
899	return ciphers;
900	failed:
901	*len = 0;
902	Curl_safefree(ciphers);
903	return NULL;
904	}
905
906	static CURLcode sectransp_set_default_ciphers(struct Curl_easy *data,
907	SSLContextRef ssl_ctx)
908	{
909	CURLcode ret = CURLE_SSL_CIPHER;
910	size_t count = 0, i, j;
911	OSStatus err;
912	size_t supported_len;
913	SSLCipherSuite *ciphers = NULL;
914
915	ciphers = sectransp_get_supported_ciphers(ssl_ctx, &supported_len);
916	if(!ciphers) {
917	failf(data, "SSL: Failed to get supported ciphers");
918	goto failed;
919	}
920
921	/* Intersect the ciphers supported by Secure Transport with the default
922	* ciphers, using the order of the former. */
923	for(i = 0; i < supported_len; i++) {
924	for(j = 0; j < DEFAULT_CIPHERS_LEN; j++) {
925	if(default_ciphers[j] == ciphers[i]) {
926	ciphers[count++] = ciphers[i];
927	break;
928	}
929	}
930	}
931
932	if(count == 0) {
933	failf(data, "SSL: no supported default ciphers");
934	goto failed;
935	}
936
937	err = SSLSetEnabledCiphers(ssl_ctx, ciphers, count);
938	if(err != noErr) {
939	failf(data, "SSL: SSLSetEnabledCiphers() failed: OSStatus %d", err);
940	goto failed;
941	}
942
943	ret = CURLE_OK;
944	failed:
945	Curl_safefree(ciphers);
946	return ret;
947	}
948
949	static CURLcode sectransp_set_selected_ciphers(struct Curl_easy *data,
950	SSLContextRef ssl_ctx,
951	const char *ciphers)
952	{
953	CURLcode ret = CURLE_SSL_CIPHER;
954	size_t count = 0, i;
955	const char ptr, end;
956	OSStatus err;
957	size_t supported_len;
958	SSLCipherSuite *supported = NULL;
959	SSLCipherSuite *selected = NULL;
960
961	supported = sectransp_get_supported_ciphers(ssl_ctx, &supported_len);
962	if(!supported) {
963	failf(data, "SSL: Failed to get supported ciphers");
964	goto failed;
965	}
966
967	selected = malloc(supported_len * sizeof(SSLCipherSuite));
968	if(!selected) {
969	failf(data, "SSL: Failed to allocate memory");
970	goto failed;
971	}
972
973	for(ptr = ciphers; ptr[0] != '\0' && count < supported_len; ptr = end) {
974	uint16_t id = sectransp_cipher_suite_walk_str(&ptr, &end);
975
976	/* Check if cipher is supported */
977	if(id) {
978	for(i = 0; i < supported_len && supported[i] != id; i++);
979	if(i == supported_len)
980	id = 0;
981	}
982	if(!id) {
983	if(ptr[0] != '\0')
984	infof(data, "SSL: unknown cipher in list: \"%.*s\"", (int) (end - ptr),
985	ptr);
986	continue;
987	}
988
989	/* No duplicates allowed (so selected cannot overflow) */
990	for(i = 0; i < count && selected[i] != id; i++);
991	if(i < count) {
992	infof(data, "SSL: duplicate cipher in list: \"%.*s\"", (int) (end - ptr),
993	ptr);
994	continue;
995	}
996
997	selected[count++] = id;
998	}
999
1000	if(count == 0) {
1001	failf(data, "SSL: no supported cipher in list");
1002	goto failed;
1003	}
1004
1005	err = SSLSetEnabledCiphers(ssl_ctx, selected, count);
1006	if(err != noErr) {
1007	failf(data, "SSL: SSLSetEnabledCiphers() failed: OSStatus %d", err);
1008	goto failed;
1009	}
1010
1011	ret = CURLE_OK;
1012	failed:
1013	Curl_safefree(supported);
1014	Curl_safefree(selected);
1015	return ret;
1016	}
1017
1018	static void sectransp_session_free(void *sessionid, size_t idsize)
1019	{
1020	/* ST, as of iOS 5 and Mountain Lion, has no public method of deleting a
1021	cached session ID inside the Security framework. There is a private
1022	function that does this, but I do not want to have to explain to you why I
1023	got your application rejected from the App Store due to the use of a
1024	private API, so the best we can do is free up our own char array that we
1025	created way back in sectransp_connect_step1... */
1026	(void)idsize;
1027	Curl_safefree(sessionid);
1028	}
1029
1030	static CURLcode sectransp_connect_step1(struct Curl_cfilter *cf,
1031	struct Curl_easy *data)
1032	{
1033	struct ssl_connect_data *connssl = cf->ctx;
1034	struct st_ssl_backend_data *backend =
1035	(struct st_ssl_backend_data *)connssl->backend;
1036	struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
1037	struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
1038	const struct curl_blob *ssl_cablob = conn_config->ca_info_blob;
1039	const char * const ssl_cafile =
1040	/* CURLOPT_CAINFO_BLOB overrides CURLOPT_CAINFO */
1041	(ssl_cablob ? NULL : conn_config->CAfile);
1042	const bool verifypeer = conn_config->verifypeer;
1043	char * const ssl_cert = ssl_config->primary.clientcert;
1044	const struct curl_blob *ssl_cert_blob = ssl_config->primary.cert_blob;
1045	char *ciphers;
1046	OSStatus err = noErr;
1047	CURLcode result;
1048	#if CURL_BUILD_MAC
1049	int darwinver_maj = 0, darwinver_min = 0;
1050
1051	DEBUGASSERT(backend);
1052
1053	CURL_TRC_CF(data, cf, "connect_step1");
1054	GetDarwinVersionNumber(&darwinver_maj, &darwinver_min);
1055	#endif /* CURL_BUILD_MAC */
1056
1057	#if CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS
1058	if(&SSLCreateContext) { /* use the newer API if available */
1059	if(backend->ssl_ctx)
1060	CFRelease(backend->ssl_ctx);
1061	backend->ssl_ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);
1062	if(!backend->ssl_ctx) {
1063	failf(data, "SSL: could not create a context");
1064	return CURLE_OUT_OF_MEMORY;
1065	}
1066	}
1067	else {
1068	/* The old ST API does not exist under iOS, so do not compile it: */
1069	#if CURL_SUPPORT_MAC_10_8
1070	if(backend->ssl_ctx)
1071	(void)SSLDisposeContext(backend->ssl_ctx);
1072	err = SSLNewContext(FALSE, &(backend->ssl_ctx));
1073	if(err != noErr) {
1074	failf(data, "SSL: could not create a context: OSStatus %d", err);
1075	return CURLE_OUT_OF_MEMORY;
1076	}
1077	#endif /* CURL_SUPPORT_MAC_10_8 */
1078	}
1079	#else
1080	if(backend->ssl_ctx)
1081	(void)SSLDisposeContext(backend->ssl_ctx);
1082	err = SSLNewContext(FALSE, &(backend->ssl_ctx));
1083	if(err != noErr) {
1084	failf(data, "SSL: could not create a context: OSStatus %d", err);
1085	return CURLE_OUT_OF_MEMORY;
1086	}
1087	#endif /* CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS */
1088	backend->ssl_write_buffered_length = 0UL; /* reset buffered write length */
1089
1090	result = sectransp_set_ssl_version_min_max(data, backend, conn_config);
1091	if(result != CURLE_OK)
1092	return result;
1093
1094	#if (CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11) && \
1095	defined(HAVE_BUILTIN_AVAILABLE)
1096	if(connssl->alpn) {
1097	if(__builtin_available(macOS 10.13.4, iOS 11, tvOS 11, *)) {
1098	struct alpn_proto_buf proto;
1099	size_t i;
1100	CFStringRef cstr;
1101	CFMutableArrayRef alpnArr = CFArrayCreateMutable(NULL, 0,
1102	&kCFTypeArrayCallBacks);
1103	for(i = 0; i < connssl->alpn->count; ++i) {
1104	cstr = CFStringCreateWithCString(NULL, connssl->alpn->entries[i],
1105	kCFStringEncodingUTF8);
1106	if(!cstr)
1107	return CURLE_OUT_OF_MEMORY;
1108	CFArrayAppendValue(alpnArr, cstr);
1109	CFRelease(cstr);
1110	}
1111	err = SSLSetALPNProtocols(backend->ssl_ctx, alpnArr);
1112	if(err != noErr)
1113	infof(data, "WARNING: failed to set ALPN protocols; OSStatus %d",
1114	err);
1115	CFRelease(alpnArr);
1116	Curl_alpn_to_proto_str(&proto, connssl->alpn);
1117	infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);
1118	}
1119	}
1120	#endif
1121
1122	if(ssl_config->key) {
1123	infof(data, "WARNING: SSL: CURLOPT_SSLKEY is ignored by Secure "
1124	"Transport. The private key must be in the Keychain.");
1125	}
1126
1127	if(ssl_cert \|\| ssl_cert_blob) {
1128	bool is_cert_data = ssl_cert_blob != NULL;
1129	bool is_cert_file = (!is_cert_data) && is_file(ssl_cert);
1130	SecIdentityRef cert_and_key = NULL;
1131
1132	/* User wants to authenticate with a client cert. Look for it. Assume that
1133	the user wants to use an identity loaded from the Keychain. If not, try
1134	it as a file on disk */
1135
1136	if(!is_cert_data)
1137	err = CopyIdentityWithLabel(ssl_cert, &cert_and_key);
1138	else
1139	err = !noErr;
1140	if((err != noErr) && (is_cert_file \|\| is_cert_data)) {
1141	if(!ssl_config->cert_type)
1142	infof(data, "SSL: Certificate type not set, assuming "
1143	"PKCS#12 format.");
1144	else if(!strcasecompare(ssl_config->cert_type, "P12")) {
1145	failf(data, "SSL: The Security framework only supports "
1146	"loading identities that are in PKCS#12 format.");
1147	return CURLE_SSL_CERTPROBLEM;
1148	}
1149
1150	err = CopyIdentityFromPKCS12File(ssl_cert, ssl_cert_blob,
1151	ssl_config->key_passwd,
1152	&cert_and_key);
1153	}
1154
1155	if(err == noErr && cert_and_key) {
1156	SecCertificateRef cert = NULL;
1157	CFTypeRef certs_c[1];
1158	CFArrayRef certs;
1159
1160	/* If we found one, print it out: */
1161	err = SecIdentityCopyCertificate(cert_and_key, &cert);
1162	if(err == noErr) {
1163	char *certp;
1164	result = CopyCertSubject(data, cert, &certp);
1165	if(!result) {
1166	infof(data, "Client certificate: %s", certp);
1167	free(certp);
1168	}
1169
1170	CFRelease(cert);
1171	if(result == CURLE_PEER_FAILED_VERIFICATION)
1172	return CURLE_SSL_CERTPROBLEM;
1173	if(result)
1174	return result;
1175	}
1176	certs_c[0] = cert_and_key;
1177	certs = CFArrayCreate(NULL, (const void **)certs_c, 1L,
1178	&kCFTypeArrayCallBacks);
1179	err = SSLSetCertificate(backend->ssl_ctx, certs);
1180	if(certs)
1181	CFRelease(certs);
1182	if(err != noErr) {
1183	failf(data, "SSL: SSLSetCertificate() failed: OSStatus %d", err);
1184	return CURLE_SSL_CERTPROBLEM;
1185	}
1186	CFRelease(cert_and_key);
1187	}
1188	else {
1189	const char *cert_showfilename_error =
1190	is_cert_data ? "(memory blob)" : ssl_cert;
1191
1192	switch(err) {
1193	case errSecAuthFailed: case -25264: /* errSecPkcs12VerifyFailure */
1194	failf(data, "SSL: Incorrect password for the certificate \"%s\" "
1195	"and its private key.", cert_showfilename_error);
1196	break;
1197	case -26275: /* errSecDecode / case -25257: / errSecUnknownFormat */
1198	failf(data, "SSL: Couldn't make sense of the data in the "
1199	"certificate \"%s\" and its private key.",
1200	cert_showfilename_error);
1201	break;
1202	case -25260: /* errSecPassphraseRequired */
1203	failf(data, "SSL The certificate \"%s\" requires a password.",
1204	cert_showfilename_error);
1205	break;
1206	case errSecItemNotFound:
1207	failf(data, "SSL: cannot find the certificate \"%s\" and its private "
1208	"key in the Keychain.", cert_showfilename_error);
1209	break;
1210	default:
1211	failf(data, "SSL: cannot load the certificate \"%s\" and its private "
1212	"key: OSStatus %d", cert_showfilename_error, err);
1213	break;
1214	}
1215	return CURLE_SSL_CERTPROBLEM;
1216	}
1217	}
1218
1219	/* SSL always tries to verify the peer, this only says whether it should
1220	* fail to connect if the verification fails, or if it should continue
1221	* anyway. In the latter case the result of the verification is checked with
1222	* SSL_get_verify_result() below. */
1223	#if CURL_BUILD_MAC_10_6 \|\| CURL_BUILD_IOS
1224	/* Snow Leopard introduced the SSLSetSessionOption() function, but due to
1225	a library bug with the way the kSSLSessionOptionBreakOnServerAuth flag
1226	works, it does not work as expected under Snow Leopard, Lion or
1227	Mountain Lion.
1228	So we need to call SSLSetEnableCertVerify() on those older cats in order
1229	to disable certificate validation if the user turned that off.
1230	(Secure Transport always validates the certificate chain by default.)
1231	Note:
1232	Darwin 11.x.x is Lion (10.7)
1233	Darwin 12.x.x is Mountain Lion (10.8)
1234	Darwin 13.x.x is Mavericks (10.9)
1235	Darwin 14.x.x is Yosemite (10.10)
1236	Darwin 15.x.x is El Capitan (10.11)
1237	*/
1238	#if CURL_BUILD_MAC
1239	if(&SSLSetSessionOption && darwinver_maj >= 13) {
1240	#else
1241	if(&SSLSetSessionOption) {
1242	#endif /* CURL_BUILD_MAC */
1243	bool break_on_auth = !conn_config->verifypeer \|\|
1244	ssl_cafile \|\| ssl_cablob;
1245	err = SSLSetSessionOption(backend->ssl_ctx,
1246	kSSLSessionOptionBreakOnServerAuth,
1247	break_on_auth);
1248	if(err != noErr) {
1249	failf(data, "SSL: SSLSetSessionOption() failed: OSStatus %d", err);
1250	return CURLE_SSL_CONNECT_ERROR;
1251	}
1252	}
1253	else {
1254	#if CURL_SUPPORT_MAC_10_8
1255	err = SSLSetEnableCertVerify(backend->ssl_ctx,
1256	conn_config->verifypeer ? true : FALSE);
1257	if(err != noErr) {
1258	failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err);
1259	return CURLE_SSL_CONNECT_ERROR;
1260	}
1261	#endif /* CURL_SUPPORT_MAC_10_8 */
1262	}
1263	#else
1264	err = SSLSetEnableCertVerify(backend->ssl_ctx,
1265	conn_config->verifypeer ? true : FALSE);
1266	if(err != noErr) {
1267	failf(data, "SSL: SSLSetEnableCertVerify() failed: OSStatus %d", err);
1268	return CURLE_SSL_CONNECT_ERROR;
1269	}
1270	#endif /* CURL_BUILD_MAC_10_6 \|\| CURL_BUILD_IOS */
1271
1272	if((ssl_cafile \|\| ssl_cablob) && verifypeer) {
1273	bool is_cert_data = ssl_cablob != NULL;
1274	bool is_cert_file = (!is_cert_data) && is_file(ssl_cafile);
1275
1276	if(!(is_cert_file \|\| is_cert_data)) {
1277	failf(data, "SSL: cannot load CA certificate file %s",
1278	ssl_cafile ? ssl_cafile : "(blob memory)");
1279	return CURLE_SSL_CACERT_BADFILE;
1280	}
1281	}
1282
1283	/* Configure hostname check. SNI is used if available.
1284	* Both hostname check and SNI require SSLSetPeerDomainName().
1285	* Also: the verifyhost setting influences SNI usage */
1286	if(conn_config->verifyhost) {
1287	char *server = connssl->peer.sni ?
1288	connssl->peer.sni : connssl->peer.hostname;
1289	err = SSLSetPeerDomainName(backend->ssl_ctx, server, strlen(server));
1290
1291	if(err != noErr) {
1292	failf(data, "SSL: SSLSetPeerDomainName() failed: OSStatus %d",
1293	err);
1294	return CURLE_SSL_CONNECT_ERROR;
1295	}
1296
1297	if(connssl->peer.type != CURL_SSL_PEER_DNS) {
1298	infof(data, "WARNING: using IP address, SNI is being disabled by "
1299	"the OS.");
1300	}
1301	}
1302	else {
1303	infof(data, "WARNING: disabling hostname validation also disables SNI.");
1304	}
1305
1306	ciphers = conn_config->cipher_list;
1307	if(ciphers) {
1308	result = sectransp_set_selected_ciphers(data, backend->ssl_ctx, ciphers);
1309	}
1310	else {
1311	result = sectransp_set_default_ciphers(data, backend->ssl_ctx);
1312	}
1313	if(result != CURLE_OK) {
1314	failf(data, "SSL: Unable to set ciphers for SSL/TLS handshake. "
1315	"Error code: %d", (int)result);
1316	return CURLE_SSL_CIPHER;
1317	}
1318
1319	#if CURL_BUILD_MAC_10_9 \|\| CURL_BUILD_IOS_7
1320	/* We want to enable 1/n-1 when using a CBC cipher unless the user
1321	specifically does not want us doing that: */
1322	if(&SSLSetSessionOption) {
1323	SSLSetSessionOption(backend->ssl_ctx, kSSLSessionOptionSendOneByteRecord,
1324	!ssl_config->enable_beast);
1325	SSLSetSessionOption(backend->ssl_ctx, kSSLSessionOptionFalseStart,
1326	ssl_config->falsestart); /* false start support */
1327	}
1328	#endif /* CURL_BUILD_MAC_10_9 \|\| CURL_BUILD_IOS_7 */
1329
1330	/* Check if there is a cached ID we can/should use here! */
1331	if(ssl_config->primary.cache_session) {
1332	char *ssl_sessionid;
1333	size_t ssl_sessionid_len;
1334
1335	Curl_ssl_sessionid_lock(data);
1336	if(!Curl_ssl_getsessionid(cf, data, &connssl->peer,
1337	(void **)&ssl_sessionid, &ssl_sessionid_len,
1338	NULL)) {
1339	/* we got a session id, use it! */
1340	err = SSLSetPeerID(backend->ssl_ctx, ssl_sessionid, ssl_sessionid_len);
1341	Curl_ssl_sessionid_unlock(data);
1342	if(err != noErr) {
1343	failf(data, "SSL: SSLSetPeerID() failed: OSStatus %d", err);
1344	return CURLE_SSL_CONNECT_ERROR;
1345	}
1346	/* Informational message */
1347	infof(data, "SSL reusing session ID");
1348	}
1349	/* If there is not one, then let's make one up! This has to be done prior
1350	to starting the handshake. */
1351	else {
1352	ssl_sessionid =
1353	aprintf("%s:%d:%d:%s:%d",
1354	ssl_cafile ? ssl_cafile : "(blob memory)",
1355	verifypeer, conn_config->verifyhost, connssl->peer.hostname,
1356	connssl->peer.port);
1357	ssl_sessionid_len = strlen(ssl_sessionid);
1358
1359	err = SSLSetPeerID(backend->ssl_ctx, ssl_sessionid, ssl_sessionid_len);
1360	if(err != noErr) {
1361	Curl_ssl_sessionid_unlock(data);
1362	failf(data, "SSL: SSLSetPeerID() failed: OSStatus %d", err);
1363	return CURLE_SSL_CONNECT_ERROR;
1364	}
1365
1366	result = Curl_ssl_set_sessionid(cf, data, &connssl->peer, NULL,
1367	ssl_sessionid, ssl_sessionid_len,
1368	sectransp_session_free);
1369	Curl_ssl_sessionid_unlock(data);
1370	if(result)
1371	return result;
1372	}
1373	}
1374
1375	err = SSLSetIOFuncs(backend->ssl_ctx,
1376	sectransp_bio_cf_in_read,
1377	sectransp_bio_cf_out_write);
1378	if(err != noErr) {
1379	failf(data, "SSL: SSLSetIOFuncs() failed: OSStatus %d", err);
1380	return CURLE_SSL_CONNECT_ERROR;
1381	}
1382
1383	err = SSLSetConnection(backend->ssl_ctx, cf);
1384	if(err != noErr) {
1385	failf(data, "SSL: SSLSetConnection() failed: %d", err);
1386	return CURLE_SSL_CONNECT_ERROR;
1387	}
1388
1389	connssl->connecting_state = ssl_connect_2;
1390	return CURLE_OK;
1391	}
1392
1393	static long pem_to_der(const char in, unsigned char out, size_t outlen)
1394	{
1395	char sep_start, sep_end, cert_start, cert_end;
1396	size_t i, j, err;
1397	size_t len;
1398	char *b64;
1399
1400	/* Jump through the separators at the beginning of the certificate. */
1401	sep_start = strstr(in, "-----");
1402	if(!sep_start)
1403	return 0;
1404	cert_start = strstr(sep_start + 1, "-----");
1405	if(!cert_start)
1406	return -1;
1407
1408	cert_start += 5;
1409
1410	/* Find separator after the end of the certificate. */
1411	cert_end = strstr(cert_start, "-----");
1412	if(!cert_end)
1413	return -1;
1414
1415	sep_end = strstr(cert_end + 1, "-----");
1416	if(!sep_end)
1417	return -1;
1418	sep_end += 5;
1419
1420	len = cert_end - cert_start;
1421	b64 = malloc(len + 1);
1422	if(!b64)
1423	return -1;
1424
1425	/* Create base64 string without linefeeds. */
1426	for(i = 0, j = 0; i < len; i++) {
1427	if(cert_start[i] != '\r' && cert_start[i] != '\n')
1428	b64[j++] = cert_start[i];
1429	}
1430	b64[j] = '\0';
1431
1432	err = Curl_base64_decode((const char *)b64, out, outlen);
1433	free(b64);
1434	if(err) {
1435	free(*out);
1436	return -1;
1437	}
1438
1439	return sep_end - in;
1440	}
1441
1442	#define MAX_CERTS_SIZE (5010241024) /* arbitrary - to catch mistakes */
1443
1444	static int read_cert(const char file, unsigned char out, size_t outlen)
1445	{
1446	int fd;
1447	ssize_t n;
1448	unsigned char buf[512];
1449	struct dynbuf certs;
1450
1451	Curl_dyn_init(&certs, MAX_CERTS_SIZE);
1452
1453	fd = open(file, 0);
1454	if(fd < 0)
1455	return -1;
1456
1457	for(;;) {
1458	n = read(fd, buf, sizeof(buf));
1459	if(!n)
1460	break;
1461	if(n < 0) {
1462	close(fd);
1463	Curl_dyn_free(&certs);
1464	return -1;
1465	}
1466	if(Curl_dyn_addn(&certs, buf, n)) {
1467	close(fd);
1468	return -1;
1469	}
1470	}
1471	close(fd);
1472
1473	*out = Curl_dyn_uptr(&certs);
1474	*outlen = Curl_dyn_len(&certs);
1475
1476	return 0;
1477	}
1478
1479	static CURLcode append_cert_to_array(struct Curl_easy *data,
1480	const unsigned char *buf, size_t buflen,
1481	CFMutableArrayRef array)
1482	{
1483	char *certp;
1484	CURLcode result;
1485	SecCertificateRef cacert;
1486	CFDataRef certdata;
1487
1488	certdata = CFDataCreate(kCFAllocatorDefault, buf, (CFIndex)buflen);
1489	if(!certdata) {
1490	failf(data, "SSL: failed to allocate array for CA certificate");
1491	return CURLE_OUT_OF_MEMORY;
1492	}
1493
1494	cacert = SecCertificateCreateWithData(kCFAllocatorDefault, certdata);
1495	CFRelease(certdata);
1496	if(!cacert) {
1497	failf(data, "SSL: failed to create SecCertificate from CA certificate");
1498	return CURLE_SSL_CACERT_BADFILE;
1499	}
1500
1501	/* Check if cacert is valid. */
1502	result = CopyCertSubject(data, cacert, &certp);
1503	switch(result) {
1504	case CURLE_OK:
1505	break;
1506	case CURLE_PEER_FAILED_VERIFICATION:
1507	return CURLE_SSL_CACERT_BADFILE;
1508	case CURLE_OUT_OF_MEMORY:
1509	default:
1510	return result;
1511	}
1512	free(certp);
1513
1514	CFArrayAppendValue(array, cacert);
1515	CFRelease(cacert);
1516
1517	return CURLE_OK;
1518	}
1519
1520	static CURLcode verify_cert_buf(struct Curl_cfilter *cf,
1521	struct Curl_easy *data,
1522	const unsigned char *certbuf, size_t buflen,
1523	SSLContextRef ctx)
1524	{
1525	int n = 0;
1526	CURLcode rc;
1527	long res;
1528	unsigned char *der;
1529	size_t derlen, offset = 0;
1530	OSStatus ret;
1531	SecTrustResultType trust_eval;
1532	CFMutableArrayRef array = NULL;
1533	SecTrustRef trust = NULL;
1534	CURLcode result = CURLE_PEER_FAILED_VERIFICATION;
1535	(void)cf;
1536	/*
1537	* Certbuf now contains the contents of the certificate file, which can be
1538	* - a single DER certificate,
1539	* - a single PEM certificate or
1540	* - a bunch of PEM certificates (certificate bundle).
1541	*
1542	* Go through certbuf, and convert any PEM certificate in it into DER
1543	* format.
1544	*/
1545	array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
1546	if(!array) {
1547	failf(data, "SSL: out of memory creating CA certificate array");
1548	result = CURLE_OUT_OF_MEMORY;
1549	goto out;
1550	}
1551
1552	while(offset < buflen) {
1553	n++;
1554
1555	/*
1556	* Check if the certificate is in PEM format, and convert it to DER. If
1557	* this fails, we assume the certificate is in DER format.
1558	*/
1559	res = pem_to_der((const char *)certbuf + offset, &der, &derlen);
1560	if(res < 0) {
1561	failf(data, "SSL: invalid CA certificate #%d (offset %zu) in bundle",
1562	n, offset);
1563	result = CURLE_SSL_CACERT_BADFILE;
1564	goto out;
1565	}
1566	offset += res;
1567
1568	if(res == 0 && offset == 0) {
1569	/* This is not a PEM file, probably a certificate in DER format. */
1570	rc = append_cert_to_array(data, certbuf, buflen, array);
1571	if(rc != CURLE_OK) {
1572	CURL_TRC_CF(data, cf, "append_cert for CA failed");
1573	result = rc;
1574	goto out;
1575	}
1576	break;
1577	}
1578	else if(res == 0) {
1579	/* No more certificates in the bundle. */
1580	break;
1581	}
1582
1583	rc = append_cert_to_array(data, der, derlen, array);
1584	free(der);
1585	if(rc != CURLE_OK) {
1586	CURL_TRC_CF(data, cf, "append_cert for CA failed");
1587	result = rc;
1588	goto out;
1589	}
1590	}
1591
1592	ret = SSLCopyPeerTrust(ctx, &trust);
1593	if(!trust) {
1594	failf(data, "SSL: error getting certificate chain");
1595	goto out;
1596	}
1597	else if(ret != noErr) {
1598	failf(data, "SSLCopyPeerTrust() returned error %d", ret);
1599	goto out;
1600	}
1601
1602	CURL_TRC_CF(data, cf, "setting %d trust anchors", n);
1603	ret = SecTrustSetAnchorCertificates(trust, array);
1604	if(ret != noErr) {
1605	failf(data, "SecTrustSetAnchorCertificates() returned error %d", ret);
1606	goto out;
1607	}
1608	ret = SecTrustSetAnchorCertificatesOnly(trust, TRUE);
1609	if(ret != noErr) {
1610	failf(data, "SecTrustSetAnchorCertificatesOnly() returned error %d", ret);
1611	goto out;
1612	}
1613
1614	trust_eval = 0;
1615	ret = SecTrustEvaluate(trust, &trust_eval);
1616	if(ret != noErr) {
1617	failf(data, "SecTrustEvaluate() returned error %d", ret);
1618	goto out;
1619	}
1620
1621	switch(trust_eval) {
1622	case kSecTrustResultUnspecified:
1623	/* what does this really mean? */
1624	CURL_TRC_CF(data, cf, "trust result: Unspecified");
1625	result = CURLE_OK;
1626	goto out;
1627	case kSecTrustResultProceed:
1628	CURL_TRC_CF(data, cf, "trust result: Proceed");
1629	result = CURLE_OK;
1630	goto out;
1631
1632	case kSecTrustResultRecoverableTrustFailure:
1633	failf(data, "SSL: peer not verified: RecoverableTrustFailure");
1634	goto out;
1635	case kSecTrustResultDeny:
1636	failf(data, "SSL: peer not verified: Deny");
1637	goto out;
1638	default:
1639	failf(data, "SSL: perr not verified: result=%d", trust_eval);
1640	goto out;
1641	}
1642
1643	out:
1644	if(trust)
1645	CFRelease(trust);
1646	if(array)
1647	CFRelease(array);
1648	return result;
1649	}
1650
1651	static CURLcode verify_cert(struct Curl_cfilter *cf,
1652	struct Curl_easy data, const char cafile,
1653	const struct curl_blob *ca_info_blob,
1654	SSLContextRef ctx)
1655	{
1656	CURLcode result;
1657	unsigned char *certbuf;
1658	size_t buflen;
1659	bool free_certbuf = FALSE;
1660
1661	if(ca_info_blob) {
1662	CURL_TRC_CF(data, cf, "verify_peer, CA from config blob");
1663	certbuf = ca_info_blob->data;
1664	buflen = ca_info_blob->len;
1665	}
1666	else if(cafile) {
1667	CURL_TRC_CF(data, cf, "verify_peer, CA from file '%s'", cafile);
1668	if(read_cert(cafile, &certbuf, &buflen) < 0) {
1669	failf(data, "SSL: failed to read or invalid CA certificate");
1670	return CURLE_SSL_CACERT_BADFILE;
1671	}
1672	free_certbuf = TRUE;
1673	}
1674	else
1675	return CURLE_SSL_CACERT_BADFILE;
1676
1677	result = verify_cert_buf(cf, data, certbuf, buflen, ctx);
1678	if(free_certbuf)
1679	free(certbuf);
1680	return result;
1681	}
1682
1683
1684	#ifdef SECTRANSP_PINNEDPUBKEY
1685	static CURLcode pkp_pin_peer_pubkey(struct Curl_easy *data,
1686	SSLContextRef ctx,
1687	const char *pinnedpubkey)
1688	{ /* Scratch */
1689	size_t pubkeylen, realpubkeylen, spkiHeaderLength = 24;
1690	unsigned char pubkey = NULL, realpubkey = NULL;
1691	const unsigned char *spkiHeader = NULL;
1692	CFDataRef publicKeyBits = NULL;
1693
1694	/* Result is returned to caller */
1695	CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
1696
1697	/* if a path was not specified, do not pin */
1698	if(!pinnedpubkey)
1699	return CURLE_OK;
1700
1701
1702	if(!ctx)
1703	return result;
1704
1705	do {
1706	SecTrustRef trust;
1707	OSStatus ret;
1708	SecKeyRef keyRef;
1709
1710	ret = SSLCopyPeerTrust(ctx, &trust);
1711	if(ret != noErr \|\| !trust)
1712	break;
1713
1714	keyRef = SecTrustCopyPublicKey(trust);
1715	CFRelease(trust);
1716	if(!keyRef)
1717	break;
1718
1719	#ifdef SECTRANSP_PINNEDPUBKEY_V1
1720
1721	publicKeyBits = SecKeyCopyExternalRepresentation(keyRef, NULL);
1722	CFRelease(keyRef);
1723	if(!publicKeyBits)
1724	break;
1725
1726	#elif SECTRANSP_PINNEDPUBKEY_V2
1727
1728	{
1729	OSStatus success;
1730	success = SecItemExport(keyRef, kSecFormatOpenSSL, 0, NULL,
1731	&publicKeyBits);
1732	CFRelease(keyRef);
1733	if(success != errSecSuccess \|\| !publicKeyBits)
1734	break;
1735	}
1736
1737	#endif /* SECTRANSP_PINNEDPUBKEY_V2 */
1738
1739	pubkeylen = (size_t)CFDataGetLength(publicKeyBits);
1740	pubkey = (unsigned char *)CFDataGetBytePtr(publicKeyBits);
1741
1742	switch(pubkeylen) {
1743	case 526:
1744	/* 4096 bit RSA pubkeylen == 526 */
1745	spkiHeader = rsa4096SpkiHeader;
1746	break;
1747	case 270:
1748	/* 2048 bit RSA pubkeylen == 270 */
1749	spkiHeader = rsa2048SpkiHeader;
1750	break;
1751	#ifdef SECTRANSP_PINNEDPUBKEY_V1
1752	case 65:
1753	/* ecDSA secp256r1 pubkeylen == 65 */
1754	spkiHeader = ecDsaSecp256r1SpkiHeader;
1755	spkiHeaderLength = 26;
1756	break;
1757	case 97:
1758	/* ecDSA secp384r1 pubkeylen == 97 */
1759	spkiHeader = ecDsaSecp384r1SpkiHeader;
1760	spkiHeaderLength = 23;
1761	break;
1762	default:
1763	infof(data, "SSL: unhandled public key length: %zu", pubkeylen);
1764	#elif SECTRANSP_PINNEDPUBKEY_V2
1765	default:
1766	/* ecDSA secp256r1 pubkeylen == 91 header already included?
1767	* ecDSA secp384r1 header already included too
1768	* we assume rest of algorithms do same, so do nothing
1769	*/
1770	result = Curl_pin_peer_pubkey(data, pinnedpubkey, pubkey,
1771	pubkeylen);
1772	#endif /* SECTRANSP_PINNEDPUBKEY_V2 */
1773	continue; /* break from loop */
1774	}
1775
1776	realpubkeylen = pubkeylen + spkiHeaderLength;
1777	realpubkey = malloc(realpubkeylen);
1778	if(!realpubkey)
1779	break;
1780
1781	memcpy(realpubkey, spkiHeader, spkiHeaderLength);
1782	memcpy(realpubkey + spkiHeaderLength, pubkey, pubkeylen);
1783
1784	result = Curl_pin_peer_pubkey(data, pinnedpubkey, realpubkey,
1785	realpubkeylen);
1786
1787	} while(0);
1788
1789	Curl_safefree(realpubkey);
1790	if(publicKeyBits)
1791	CFRelease(publicKeyBits);
1792
1793	return result;
1794	}
1795	#endif /* SECTRANSP_PINNEDPUBKEY */
1796
1797	static CURLcode sectransp_connect_step2(struct Curl_cfilter *cf,
1798	struct Curl_easy *data)
1799	{
1800	struct ssl_connect_data *connssl = cf->ctx;
1801	struct st_ssl_backend_data *backend =
1802	(struct st_ssl_backend_data *)connssl->backend;
1803	struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
1804	OSStatus err;
1805	SSLCipherSuite cipher;
1806	SSLProtocol protocol = 0;
1807
1808	DEBUGASSERT(ssl_connect_2 == connssl->connecting_state);
1809	DEBUGASSERT(backend);
1810	CURL_TRC_CF(data, cf, "connect_step2");
1811
1812	/* Here goes nothing: */
1813	check_handshake:
1814	connssl->io_need = CURL_SSL_IO_NEED_NONE;
1815	err = SSLHandshake(backend->ssl_ctx);
1816
1817	if(err != noErr) {
1818	switch(err) {
1819	case errSSLWouldBlock: /* they are not done with us yet */
1820	connssl->io_need = backend->ssl_direction ?
1821	CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
1822	return CURLE_OK;
1823
1824	/* The below is errSSLServerAuthCompleted; it is not defined in
1825	Leopard's headers */
1826	case -9841:
1827	if((conn_config->CAfile \|\| conn_config->ca_info_blob) &&
1828	conn_config->verifypeer) {
1829	CURLcode result = verify_cert(cf, data, conn_config->CAfile,
1830	conn_config->ca_info_blob,
1831	backend->ssl_ctx);
1832	if(result)
1833	return result;
1834	}
1835	/* the documentation says we need to call SSLHandshake() again */
1836	goto check_handshake;
1837
1838	/* Problem with encrypt / decrypt */
1839	case errSSLPeerDecodeError:
1840	failf(data, "Decode failed");
1841	break;
1842	case errSSLDecryptionFail:
1843	case errSSLPeerDecryptionFail:
1844	failf(data, "Decryption failed");
1845	break;
1846	case errSSLPeerDecryptError:
1847	failf(data, "A decryption error occurred");
1848	break;
1849	case errSSLBadCipherSuite:
1850	failf(data, "A bad SSL cipher suite was encountered");
1851	break;
1852	case errSSLCrypto:
1853	failf(data, "An underlying cryptographic error was encountered");
1854	break;
1855	#if CURL_BUILD_MAC_10_11 \|\| CURL_BUILD_IOS_9
1856	case errSSLWeakPeerEphemeralDHKey:
1857	failf(data, "Indicates a weak ephemeral Diffie-Hellman key");
1858	break;
1859	#endif
1860
1861	/* Problem with the message record validation */
1862	case errSSLBadRecordMac:
1863	case errSSLPeerBadRecordMac:
1864	failf(data, "A record with a bad message authentication code (MAC) "
1865	"was encountered");
1866	break;
1867	case errSSLRecordOverflow:
1868	case errSSLPeerRecordOverflow:
1869	failf(data, "A record overflow occurred");
1870	break;
1871
1872	/* Problem with zlib decompression */
1873	case errSSLPeerDecompressFail:
1874	failf(data, "Decompression failed");
1875	break;
1876
1877	/* Problem with access */
1878	case errSSLPeerAccessDenied:
1879	failf(data, "Access was denied");
1880	break;
1881	case errSSLPeerInsufficientSecurity:
1882	failf(data, "There is insufficient security for this operation");
1883	break;
1884
1885	/* These are all certificate problems with the server: */
1886	case errSSLXCertChainInvalid:
1887	failf(data, "SSL certificate problem: Invalid certificate chain");
1888	return CURLE_PEER_FAILED_VERIFICATION;
1889	case errSSLUnknownRootCert:
1890	failf(data, "SSL certificate problem: Untrusted root certificate");
1891	return CURLE_PEER_FAILED_VERIFICATION;
1892	case errSSLNoRootCert:
1893	failf(data, "SSL certificate problem: No root certificate");
1894	return CURLE_PEER_FAILED_VERIFICATION;
1895	case errSSLCertNotYetValid:
1896	failf(data, "SSL certificate problem: The certificate chain had a "
1897	"certificate that is not yet valid");
1898	return CURLE_PEER_FAILED_VERIFICATION;
1899	case errSSLCertExpired:
1900	case errSSLPeerCertExpired:
1901	failf(data, "SSL certificate problem: Certificate chain had an "
1902	"expired certificate");
1903	return CURLE_PEER_FAILED_VERIFICATION;
1904	case errSSLBadCert:
1905	case errSSLPeerBadCert:
1906	failf(data, "SSL certificate problem: Couldn't understand the server "
1907	"certificate format");
1908	return CURLE_PEER_FAILED_VERIFICATION;
1909	case errSSLPeerUnsupportedCert:
1910	failf(data, "SSL certificate problem: An unsupported certificate "
1911	"format was encountered");
1912	return CURLE_PEER_FAILED_VERIFICATION;
1913	case errSSLPeerCertRevoked:
1914	failf(data, "SSL certificate problem: The certificate was revoked");
1915	return CURLE_PEER_FAILED_VERIFICATION;
1916	case errSSLPeerCertUnknown:
1917	failf(data, "SSL certificate problem: The certificate is unknown");
1918	return CURLE_PEER_FAILED_VERIFICATION;
1919
1920	/* These are all certificate problems with the client: */
1921	case errSecAuthFailed:
1922	failf(data, "SSL authentication failed");
1923	break;
1924	case errSSLPeerHandshakeFail:
1925	failf(data, "SSL peer handshake failed, the server most likely "
1926	"requires a client certificate to connect");
1927	break;
1928	case errSSLPeerUnknownCA:
1929	failf(data, "SSL server rejected the client certificate due to "
1930	"the certificate being signed by an unknown certificate "
1931	"authority");
1932	break;
1933
1934	/* This error is raised if the server's cert did not match the server's
1935	hostname: */
1936	case errSSLHostNameMismatch:
1937	failf(data, "SSL certificate peer verification failed, the "
1938	"certificate did not match \"%s\"\n", connssl->peer.dispname);
1939	return CURLE_PEER_FAILED_VERIFICATION;
1940
1941	/* Problem with SSL / TLS negotiation */
1942	case errSSLNegotiation:
1943	failf(data, "Could not negotiate an SSL cipher suite with the server");
1944	break;
1945	case errSSLBadConfiguration:
1946	failf(data, "A configuration error occurred");
1947	break;
1948	case errSSLProtocol:
1949	failf(data, "SSL protocol error");
1950	break;
1951	case errSSLPeerProtocolVersion:
1952	failf(data, "A bad protocol version was encountered");
1953	break;
1954	case errSSLPeerNoRenegotiation:
1955	failf(data, "No renegotiation is allowed");
1956	break;
1957
1958	/* Generic handshake errors: */
1959	case errSSLConnectionRefused:
1960	failf(data, "Server dropped the connection during the SSL handshake");
1961	break;
1962	case errSSLClosedAbort:
1963	failf(data, "Server aborted the SSL handshake");
1964	break;
1965	case errSSLClosedGraceful:
1966	failf(data, "The connection closed gracefully");
1967	break;
1968	case errSSLClosedNoNotify:
1969	failf(data, "The server closed the session with no notification");
1970	break;
1971	/* Sometimes paramErr happens with buggy ciphers: */
1972	case paramErr:
1973	case errSSLInternal:
1974	case errSSLPeerInternalError:
1975	failf(data, "Internal SSL engine error encountered during the "
1976	"SSL handshake");
1977	break;
1978	case errSSLFatalAlert:
1979	failf(data, "Fatal SSL engine error encountered during the SSL "
1980	"handshake");
1981	break;
1982	/* Unclassified error */
1983	case errSSLBufferOverflow:
1984	failf(data, "An insufficient buffer was provided");
1985	break;
1986	case errSSLIllegalParam:
1987	failf(data, "An illegal parameter was encountered");
1988	break;
1989	case errSSLModuleAttach:
1990	failf(data, "Module attach failure");
1991	break;
1992	case errSSLSessionNotFound:
1993	failf(data, "An attempt to restore an unknown session failed");
1994	break;
1995	case errSSLPeerExportRestriction:
1996	failf(data, "An export restriction occurred");
1997	break;
1998	case errSSLPeerUserCancelled:
1999	failf(data, "The user canceled the operation");
2000	break;
2001	case errSSLPeerUnexpectedMsg:
2002	failf(data, "Peer rejected unexpected message");
2003	break;
2004	#if CURL_BUILD_MAC_10_11 \|\| CURL_BUILD_IOS_9
2005	/* Treating non-fatal error as fatal like before */
2006	case errSSLClientHelloReceived:
2007	failf(data, "A non-fatal result for providing a server name "
2008	"indication");
2009	break;
2010	#endif
2011
2012	/* Error codes defined in the enum but should never be returned.
2013	We list them here just in case. */
2014	#if CURL_BUILD_MAC_10_6
2015	/* Only returned when kSSLSessionOptionBreakOnCertRequested is set */
2016	case errSSLClientCertRequested:
2017	failf(data, "Server requested a client certificate during the "
2018	"handshake");
2019	return CURLE_SSL_CLIENTCERT;
2020	#endif
2021	#if CURL_BUILD_MAC_10_9
2022	/* Alias for errSSLLast, end of error range */
2023	case errSSLUnexpectedRecord:
2024	failf(data, "Unexpected (skipped) record in DTLS");
2025	break;
2026	#endif
2027	default:
2028	/* May also return codes listed in Security Framework Result Codes */
2029	failf(data, "Unknown SSL protocol error in connection to %s:%d",
2030	connssl->peer.hostname, err);
2031	break;
2032	}
2033	return CURLE_SSL_CONNECT_ERROR;
2034	}
2035	else {
2036	char cipher_str[64];
2037	/* we have been connected fine, we are not waiting for anything else. */
2038	connssl->connecting_state = ssl_connect_3;
2039
2040	#ifdef SECTRANSP_PINNEDPUBKEY
2041	if(data->set.str[STRING_SSL_PINNEDPUBLICKEY]) {
2042	CURLcode result =
2043	pkp_pin_peer_pubkey(data, backend->ssl_ctx,
2044	data->set.str[STRING_SSL_PINNEDPUBLICKEY]);
2045	if(result) {
2046	failf(data, "SSL: public key does not match pinned public key");
2047	return result;
2048	}
2049	}
2050	#endif /* SECTRANSP_PINNEDPUBKEY */
2051
2052	/* Informational message */
2053	(void)SSLGetNegotiatedCipher(backend->ssl_ctx, &cipher);
2054	(void)SSLGetNegotiatedProtocolVersion(backend->ssl_ctx, &protocol);
2055
2056	sectransp_cipher_suite_get_str((uint16_t) cipher, cipher_str,
2057	sizeof(cipher_str), TRUE);
2058	switch(protocol) {
2059	case kSSLProtocol2:
2060	infof(data, "SSL 2.0 connection using %s", cipher_str);
2061	break;
2062	case kSSLProtocol3:
2063	infof(data, "SSL 3.0 connection using %s", cipher_str);
2064	break;
2065	case kTLSProtocol1:
2066	infof(data, "TLS 1.0 connection using %s", cipher_str);
2067	break;
2068	#if CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS
2069	case kTLSProtocol11:
2070	infof(data, "TLS 1.1 connection using %s", cipher_str);
2071	break;
2072	case kTLSProtocol12:
2073	infof(data, "TLS 1.2 connection using %s", cipher_str);
2074	break;
2075	#endif /* CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS */
2076	#if CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11
2077	case kTLSProtocol13:
2078	infof(data, "TLS 1.3 connection using %s", cipher_str);
2079	break;
2080	#endif /* CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11 */
2081	default:
2082	infof(data, "Unknown protocol connection");
2083	break;
2084	}
2085
2086	#if (CURL_BUILD_MAC_10_13 \|\| CURL_BUILD_IOS_11) && \
2087	defined(HAVE_BUILTIN_AVAILABLE)
2088	if(connssl->alpn) {
2089	if(__builtin_available(macOS 10.13.4, iOS 11, tvOS 11, *)) {
2090	CFArrayRef alpnArr = NULL;
2091	CFStringRef chosenProtocol = NULL;
2092	err = SSLCopyALPNProtocols(backend->ssl_ctx, &alpnArr);
2093
2094	if(err == noErr && alpnArr && CFArrayGetCount(alpnArr) >= 1)
2095	chosenProtocol = CFArrayGetValueAtIndex(alpnArr, 0);
2096
2097	#ifdef USE_HTTP2
2098	if(chosenProtocol &&
2099	!CFStringCompare(chosenProtocol, CFSTR(ALPN_H2), 0)) {
2100	cf->conn->alpn = CURL_HTTP_VERSION_2;
2101	}
2102	else
2103	#endif
2104	if(chosenProtocol &&
2105	!CFStringCompare(chosenProtocol, CFSTR(ALPN_HTTP_1_1), 0)) {
2106	cf->conn->alpn = CURL_HTTP_VERSION_1_1;
2107	}
2108	else
2109	infof(data, VTLS_INFOF_NO_ALPN);
2110
2111	/* chosenProtocol is a reference to the string within alpnArr
2112	and does not need to be freed separately */
2113	if(alpnArr)
2114	CFRelease(alpnArr);
2115	}
2116	}
2117	#endif
2118
2119	return CURLE_OK;
2120	}
2121	}
2122
2123	static CURLcode
2124	add_cert_to_certinfo(struct Curl_easy *data,
2125	SecCertificateRef server_cert,
2126	int idx)
2127	{
2128	CURLcode result = CURLE_OK;
2129	const char *beg;
2130	const char *end;
2131	CFDataRef cert_data = SecCertificateCopyData(server_cert);
2132
2133	if(!cert_data)
2134	return CURLE_PEER_FAILED_VERIFICATION;
2135
2136	beg = (const char *)CFDataGetBytePtr(cert_data);
2137	end = beg + CFDataGetLength(cert_data);
2138	result = Curl_extract_certinfo(data, idx, beg, end);
2139	CFRelease(cert_data);
2140	return result;
2141	}
2142
2143	static CURLcode
2144	collect_server_cert_single(struct Curl_cfilter cf, struct Curl_easy data,
2145	SecCertificateRef server_cert,
2146	CFIndex idx)
2147	{
2148	CURLcode result = CURLE_OK;
2149	struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
2150	#ifndef CURL_DISABLE_VERBOSE_STRINGS
2151	if(data->set.verbose) {
2152	char *certp;
2153	result = CopyCertSubject(data, server_cert, &certp);
2154	if(!result) {
2155	infof(data, "Server certificate: %s", certp);
2156	free(certp);
2157	}
2158	}
2159	#endif
2160	if(ssl_config->certinfo)
2161	result = add_cert_to_certinfo(data, server_cert, (int)idx);
2162	return result;
2163	}
2164
2165	/* This should be called during step3 of the connection at the earliest */
2166	static CURLcode collect_server_cert(struct Curl_cfilter *cf,
2167	struct Curl_easy *data)
2168	{
2169	#ifndef CURL_DISABLE_VERBOSE_STRINGS
2170	const bool show_verbose_server_cert = data->set.verbose;
2171	#else
2172	const bool show_verbose_server_cert = FALSE;
2173	#endif
2174	struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
2175	CURLcode result = ssl_config->certinfo ?
2176	CURLE_PEER_FAILED_VERIFICATION : CURLE_OK;
2177	struct ssl_connect_data *connssl = cf->ctx;
2178	struct st_ssl_backend_data *backend =
2179	(struct st_ssl_backend_data *)connssl->backend;
2180	CFArrayRef server_certs = NULL;
2181	SecCertificateRef server_cert;
2182	OSStatus err;
2183	CFIndex i, count;
2184	SecTrustRef trust = NULL;
2185
2186	DEBUGASSERT(backend);
2187
2188	if(!show_verbose_server_cert && !ssl_config->certinfo)
2189	return CURLE_OK;
2190
2191	if(!backend->ssl_ctx)
2192	return result;
2193
2194	#if CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS
2195	#if CURL_BUILD_IOS
2196	#pragma unused(server_certs)
2197	err = SSLCopyPeerTrust(backend->ssl_ctx, &trust);
2198	/* For some reason, SSLCopyPeerTrust() can return noErr and yet return
2199	a null trust, so be on guard for that: */
2200	if(err == noErr && trust) {
2201	count = SecTrustGetCertificateCount(trust);
2202	if(ssl_config->certinfo)
2203	result = Curl_ssl_init_certinfo(data, (int)count);
2204	for(i = 0L ; !result && (i < count) ; i++) {
2205	server_cert = SecTrustGetCertificateAtIndex(trust, i);
2206	result = collect_server_cert_single(cf, data, server_cert, i);
2207	}
2208	CFRelease(trust);
2209	}
2210	#else
2211	/* SSLCopyPeerCertificates() is deprecated as of Mountain Lion.
2212	The function SecTrustGetCertificateAtIndex() is officially present
2213	in Lion, but it is unfortunately also present in Snow Leopard as
2214	private API and does not work as expected. So we have to look for
2215	a different symbol to make sure this code is only executed under
2216	Lion or later. */
2217	if(&SecTrustCopyPublicKey) {
2218	#pragma unused(server_certs)
2219	err = SSLCopyPeerTrust(backend->ssl_ctx, &trust);
2220	/* For some reason, SSLCopyPeerTrust() can return noErr and yet return
2221	a null trust, so be on guard for that: */
2222	if(err == noErr && trust) {
2223	count = SecTrustGetCertificateCount(trust);
2224	if(ssl_config->certinfo)
2225	result = Curl_ssl_init_certinfo(data, (int)count);
2226	for(i = 0L ; !result && (i < count) ; i++) {
2227	server_cert = SecTrustGetCertificateAtIndex(trust, i);
2228	result = collect_server_cert_single(cf, data, server_cert, i);
2229	}
2230	CFRelease(trust);
2231	}
2232	}
2233	else {
2234	#if CURL_SUPPORT_MAC_10_8
2235	err = SSLCopyPeerCertificates(backend->ssl_ctx, &server_certs);
2236	/* Just in case SSLCopyPeerCertificates() returns null too... */
2237	if(err == noErr && server_certs) {
2238	count = CFArrayGetCount(server_certs);
2239	if(ssl_config->certinfo)
2240	result = Curl_ssl_init_certinfo(data, (int)count);
2241	for(i = 0L ; !result && (i < count) ; i++) {
2242	server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs,
2243	i);
2244	result = collect_server_cert_single(cf, data, server_cert, i);
2245	}
2246	CFRelease(server_certs);
2247	}
2248	#endif /* CURL_SUPPORT_MAC_10_8 */
2249	}
2250	#endif /* CURL_BUILD_IOS */
2251	#else
2252	#pragma unused(trust)
2253	err = SSLCopyPeerCertificates(backend->ssl_ctx, &server_certs);
2254	if(err == noErr) {
2255	count = CFArrayGetCount(server_certs);
2256	if(ssl_config->certinfo)
2257	result = Curl_ssl_init_certinfo(data, (int)count);
2258	for(i = 0L ; !result && (i < count) ; i++) {
2259	server_cert = (SecCertificateRef)CFArrayGetValueAtIndex(server_certs, i);
2260	result = collect_server_cert_single(cf, data, server_cert, i);
2261	}
2262	CFRelease(server_certs);
2263	}
2264	#endif /* CURL_BUILD_MAC_10_7 \|\| CURL_BUILD_IOS */
2265	return result;
2266	}
2267
2268	static CURLcode sectransp_connect_step3(struct Curl_cfilter *cf,
2269	struct Curl_easy *data)
2270	{
2271	struct ssl_connect_data *connssl = cf->ctx;
2272	CURLcode result;
2273
2274	CURL_TRC_CF(data, cf, "connect_step3");
2275	/* There is no step 3!
2276	* Well, okay, let's collect server certificates, and if verbose mode is on,
2277	* let's print the details of the server certificates. */
2278	result = collect_server_cert(cf, data);
2279	if(result)
2280	return result;
2281
2282	connssl->connecting_state = ssl_connect_done;
2283	return CURLE_OK;
2284	}
2285
2286	static CURLcode
2287	sectransp_connect_common(struct Curl_cfilter cf, struct Curl_easy data,
2288	bool nonblocking,
2289	bool *done)
2290	{
2291	CURLcode result;
2292	struct ssl_connect_data *connssl = cf->ctx;
2293	curl_socket_t sockfd = Curl_conn_cf_get_socket(cf, data);
2294	int what;
2295
2296	/* check if the connection has already been established */
2297	if(ssl_connection_complete == connssl->state) {
2298	*done = TRUE;
2299	return CURLE_OK;
2300	}
2301
2302	if(ssl_connect_1 == connssl->connecting_state) {
2303	/* Find out how much more time we are allowed */
2304	const timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
2305
2306	if(timeout_ms < 0) {
2307	/* no need to continue if time already is up */
2308	failf(data, "SSL connection timeout");
2309	return CURLE_OPERATION_TIMEDOUT;
2310	}
2311
2312	result = sectransp_connect_step1(cf, data);
2313	if(result)
2314	return result;
2315	}
2316
2317	while(ssl_connect_2 == connssl->connecting_state) {
2318
2319	/* check allowed time left */
2320	const timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
2321
2322	if(timeout_ms < 0) {
2323	/* no need to continue if time already is up */
2324	failf(data, "SSL connection timeout");
2325	return CURLE_OPERATION_TIMEDOUT;
2326	}
2327
2328	/* if ssl is expecting something, check if it is available. */
2329	if(connssl->io_need) {
2330
2331	curl_socket_t writefd = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ?
2332	sockfd : CURL_SOCKET_BAD;
2333	curl_socket_t readfd = (connssl->io_need & CURL_SSL_IO_NEED_RECV) ?
2334	sockfd : CURL_SOCKET_BAD;
2335
2336	what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
2337	nonblocking ? 0 : timeout_ms);
2338	if(what < 0) {
2339	/* fatal error */
2340	failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
2341	return CURLE_SSL_CONNECT_ERROR;
2342	}
2343	else if(0 == what) {
2344	if(nonblocking) {
2345	*done = FALSE;
2346	return CURLE_OK;
2347	}
2348	else {
2349	/* timeout */
2350	failf(data, "SSL connection timeout");
2351	return CURLE_OPERATION_TIMEDOUT;
2352	}
2353	}
2354	/* socket is readable or writable */
2355	}
2356
2357	/* Run transaction, and return to the caller if it failed or if this
2358	* connection is done nonblocking and this loop would execute again. This
2359	* permits the owner of a multi handle to abort a connection attempt
2360	* before step2 has completed while ensuring that a client using select()
2361	* or epoll() will always have a valid fdset to wait on.
2362	*/
2363	result = sectransp_connect_step2(cf, data);
2364	if(result \|\| (nonblocking && (ssl_connect_2 == connssl->connecting_state)))
2365	return result;
2366
2367	} /* repeat step2 until all transactions are done. */
2368
2369
2370	if(ssl_connect_3 == connssl->connecting_state) {
2371	result = sectransp_connect_step3(cf, data);
2372	if(result)
2373	return result;
2374	}
2375
2376	if(ssl_connect_done == connssl->connecting_state) {
2377	CURL_TRC_CF(data, cf, "connected");
2378	connssl->state = ssl_connection_complete;
2379	*done = TRUE;
2380	}
2381	else
2382	*done = FALSE;
2383
2384	/* Reset our connect state machine */
2385	connssl->connecting_state = ssl_connect_1;
2386
2387	return CURLE_OK;
2388	}
2389
2390	static CURLcode sectransp_connect_nonblocking(struct Curl_cfilter *cf,
2391	struct Curl_easy *data,
2392	bool *done)
2393	{
2394	return sectransp_connect_common(cf, data, TRUE, done);
2395	}
2396
2397	static CURLcode sectransp_connect(struct Curl_cfilter *cf,
2398	struct Curl_easy *data)
2399	{
2400	CURLcode result;
2401	bool done = FALSE;
2402
2403	result = sectransp_connect_common(cf, data, FALSE, &done);
2404
2405	if(result)
2406	return result;
2407
2408	DEBUGASSERT(done);
2409
2410	return CURLE_OK;
2411	}
2412
2413	static ssize_t sectransp_recv(struct Curl_cfilter *cf,
2414	struct Curl_easy *data,
2415	char *buf,
2416	size_t buffersize,
2417	CURLcode *curlcode);
2418
2419	static CURLcode sectransp_shutdown(struct Curl_cfilter *cf,
2420	struct Curl_easy *data,
2421	bool send_shutdown, bool *done)
2422	{
2423	struct ssl_connect_data *connssl = cf->ctx;
2424	struct st_ssl_backend_data *backend =
2425	(struct st_ssl_backend_data *)connssl->backend;
2426	CURLcode result = CURLE_OK;
2427	ssize_t nread;
2428	char buf[1024];
2429	size_t i;
2430
2431	DEBUGASSERT(backend);
2432	if(!backend->ssl_ctx \|\| cf->shutdown) {
2433	*done = TRUE;
2434	goto out;
2435	}
2436
2437	connssl->io_need = CURL_SSL_IO_NEED_NONE;
2438	*done = FALSE;
2439
2440	if(send_shutdown && !backend->sent_shutdown) {
2441	OSStatus err;
2442
2443	CURL_TRC_CF(data, cf, "shutdown, send close notify");
2444	err = SSLClose(backend->ssl_ctx);
2445	switch(err) {
2446	case noErr:
2447	backend->sent_shutdown = TRUE;
2448	break;
2449	case errSSLWouldBlock:
2450	connssl->io_need = CURL_SSL_IO_NEED_SEND;
2451	result = CURLE_OK;
2452	goto out;
2453	default:
2454	CURL_TRC_CF(data, cf, "shutdown, error: %d", (int)err);
2455	result = CURLE_SEND_ERROR;
2456	goto out;
2457	}
2458	}
2459
2460	for(i = 0; i < 10; ++i) {
2461	if(!backend->sent_shutdown) {
2462	nread = sectransp_recv(cf, data, buf, (int)sizeof(buf), &result);
2463	}
2464	else {
2465	/* We would like to read the close notify from the server using
2466	* Secure Transport, however SSLRead() no longer works after we
2467	* sent the notify from our side. So, we just read from the
2468	* underlying filter and hope it will end. */
2469	nread = Curl_conn_cf_recv(cf->next, data, buf, sizeof(buf), &result);
2470	}
2471	CURL_TRC_CF(data, cf, "shutdown read -> %zd, %d", nread, result);
2472	if(nread <= 0)
2473	break;
2474	}
2475
2476	if(nread > 0) {
2477	/* still data coming in? */
2478	connssl->io_need = CURL_SSL_IO_NEED_RECV;
2479	}
2480	else if(nread == 0) {
2481	/* We got the close notify alert and are done. */
2482	CURL_TRC_CF(data, cf, "shutdown done");
2483	*done = TRUE;
2484	}
2485	else if(result == CURLE_AGAIN) {
2486	connssl->io_need = CURL_SSL_IO_NEED_RECV;
2487	result = CURLE_OK;
2488	}
2489	else {
2490	DEBUGASSERT(result);
2491	CURL_TRC_CF(data, cf, "shutdown, error: %d", result);
2492	}
2493
2494	out:
2495	cf->shutdown = (result \|\| *done);
2496	return result;
2497	}
2498
2499	static void sectransp_close(struct Curl_cfilter cf, struct Curl_easy data)
2500	{
2501	struct ssl_connect_data *connssl = cf->ctx;
2502	struct st_ssl_backend_data *backend =
2503	(struct st_ssl_backend_data *)connssl->backend;
2504
2505	(void) data;
2506
2507	DEBUGASSERT(backend);
2508
2509	if(backend->ssl_ctx) {
2510	CURL_TRC_CF(data, cf, "close");
2511	#if CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS
2512	if(&SSLCreateContext)
2513	CFRelease(backend->ssl_ctx);
2514	#if CURL_SUPPORT_MAC_10_8
2515	else
2516	(void)SSLDisposeContext(backend->ssl_ctx);
2517	#endif /* CURL_SUPPORT_MAC_10_8 */
2518	#else
2519	(void)SSLDisposeContext(backend->ssl_ctx);
2520	#endif /* CURL_BUILD_MAC_10_8 \|\| CURL_BUILD_IOS */
2521	backend->ssl_ctx = NULL;
2522	}
2523	}
2524
2525	static size_t sectransp_version(char *buffer, size_t size)
2526	{
2527	return msnprintf(buffer, size, "SecureTransport");
2528	}
2529
2530	static bool sectransp_data_pending(struct Curl_cfilter *cf,
2531	const struct Curl_easy *data)
2532	{
2533	const struct ssl_connect_data *connssl = cf->ctx;
2534	struct st_ssl_backend_data *backend =
2535	(struct st_ssl_backend_data *)connssl->backend;
2536	OSStatus err;
2537	size_t buffer;
2538
2539	(void)data;
2540	DEBUGASSERT(backend);
2541
2542	if(backend->ssl_ctx) { /* SSL is in use */
2543	CURL_TRC_CF((struct Curl_easy *)data, cf, "data_pending");
2544	err = SSLGetBufferedReadSize(backend->ssl_ctx, &buffer);
2545	if(err == noErr)
2546	return buffer > 0UL;
2547	return FALSE;
2548	}
2549	else
2550	return FALSE;
2551	}
2552
2553	static CURLcode sectransp_random(struct Curl_easy *data UNUSED_PARAM,
2554	unsigned char *entropy, size_t length)
2555	{
2556	/* arc4random_buf() is not available on cats older than Lion, so let's
2557	do this manually for the benefit of the older cats. */
2558	size_t i;
2559	u_int32_t random_number = 0;
2560
2561	(void)data;
2562
2563	for(i = 0 ; i < length ; i++) {
2564	if(i % sizeof(u_int32_t) == 0)
2565	random_number = arc4random();
2566	entropy[i] = random_number & 0xFF;
2567	random_number >>= 8;
2568	}
2569	i = random_number = 0;
2570	return CURLE_OK;
2571	}
2572
2573	static CURLcode sectransp_sha256sum(const unsigned char tmp, / input */
2574	size_t tmplen,
2575	unsigned char sha256sum, / output */
2576	size_t sha256len)
2577	{
2578	(void)sha256len;
2579	assert(sha256len >= CURL_SHA256_DIGEST_LENGTH);
2580	(void)CC_SHA256(tmp, (CC_LONG)tmplen, sha256sum);
2581	return CURLE_OK;
2582	}
2583
2584	static bool sectransp_false_start(void)
2585	{
2586	#if CURL_BUILD_MAC_10_9 \|\| CURL_BUILD_IOS_7
2587	if(&SSLSetSessionOption)
2588	return TRUE;
2589	#endif
2590	return FALSE;
2591	}
2592
2593	static ssize_t sectransp_send(struct Curl_cfilter *cf,
2594	struct Curl_easy *data,
2595	const void *mem,
2596	size_t len,
2597	CURLcode *curlcode)
2598	{
2599	struct ssl_connect_data *connssl = cf->ctx;
2600	struct st_ssl_backend_data *backend =
2601	(struct st_ssl_backend_data *)connssl->backend;
2602	size_t processed = 0UL;
2603	OSStatus err;
2604
2605	DEBUGASSERT(backend);
2606
2607	/* The SSLWrite() function works a little differently than expected. The
2608	fourth argument (processed) is currently documented in Apple's
2609	documentation as: "On return, the length, in bytes, of the data actually
2610	written."
2611
2612	Now, one could interpret that as "written to the socket," but actually,
2613	it returns the amount of data that was written to a buffer internal to
2614	the SSLContextRef instead. So it is possible for SSLWrite() to return
2615	errSSLWouldBlock and a number of bytes "written" because those bytes were
2616	encrypted and written to a buffer, not to the socket.
2617
2618	So if this happens, then we need to keep calling SSLWrite() over and
2619	over again with no new data until it quits returning errSSLWouldBlock. */
2620
2621	/* Do we have buffered data to write from the last time we were called? */
2622	if(backend->ssl_write_buffered_length) {
2623	/* Write the buffered data: */
2624	err = SSLWrite(backend->ssl_ctx, NULL, 0UL, &processed);
2625	switch(err) {
2626	case noErr:
2627	/* processed is always going to be 0 because we did not write to
2628	the buffer, so return how much was written to the socket */
2629	processed = backend->ssl_write_buffered_length;
2630	backend->ssl_write_buffered_length = 0UL;
2631	break;
2632	case errSSLWouldBlock: /* argh, try again */
2633	*curlcode = CURLE_AGAIN;
2634	return -1L;
2635	default:
2636	failf(data, "SSLWrite() returned error %d", err);
2637	*curlcode = CURLE_SEND_ERROR;
2638	return -1L;
2639	}
2640	}
2641	else {
2642	/* We have got new data to write: */
2643	err = SSLWrite(backend->ssl_ctx, mem, len, &processed);
2644	if(err != noErr) {
2645	switch(err) {
2646	case errSSLWouldBlock:
2647	/* Data was buffered but not sent, we have to tell the caller
2648	to try sending again, and remember how much was buffered */
2649	backend->ssl_write_buffered_length = len;
2650	*curlcode = CURLE_AGAIN;
2651	return -1L;
2652	default:
2653	failf(data, "SSLWrite() returned error %d", err);
2654	*curlcode = CURLE_SEND_ERROR;
2655	return -1L;
2656	}
2657	}
2658	}
2659	return (ssize_t)processed;
2660	}
2661
2662	static ssize_t sectransp_recv(struct Curl_cfilter *cf,
2663	struct Curl_easy *data,
2664	char *buf,
2665	size_t buffersize,
2666	CURLcode *curlcode)
2667	{
2668	struct ssl_connect_data *connssl = cf->ctx;
2669	struct st_ssl_backend_data *backend =
2670	(struct st_ssl_backend_data *)connssl->backend;
2671	struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
2672	size_t processed = 0UL;
2673	OSStatus err;
2674
2675	DEBUGASSERT(backend);
2676
2677	again:
2678	*curlcode = CURLE_OK;
2679	err = SSLRead(backend->ssl_ctx, buf, buffersize, &processed);
2680
2681	if(err != noErr) {
2682	switch(err) {
2683	case errSSLWouldBlock: /* return how much we read (if anything) */
2684	if(processed) {
2685	return (ssize_t)processed;
2686	}
2687	*curlcode = CURLE_AGAIN;
2688	return -1L;
2689
2690	/* errSSLClosedGraceful - server gracefully shut down the SSL session
2691	errSSLClosedNoNotify - server hung up on us instead of sending a
2692	closure alert notice, read() is returning 0
2693	Either way, inform the caller that the server disconnected. */
2694	case errSSLClosedGraceful:
2695	case errSSLClosedNoNotify:
2696	*curlcode = CURLE_OK;
2697	return 0;
2698
2699	/* The below is errSSLPeerAuthCompleted; it is not defined in
2700	Leopard's headers */
2701	case -9841:
2702	if((conn_config->CAfile \|\| conn_config->ca_info_blob) &&
2703	conn_config->verifypeer) {
2704	CURLcode result = verify_cert(cf, data, conn_config->CAfile,
2705	conn_config->ca_info_blob,
2706	backend->ssl_ctx);
2707	if(result) {
2708	*curlcode = result;
2709	return -1;
2710	}
2711	}
2712	goto again;
2713	default:
2714	failf(data, "SSLRead() return error %d", err);
2715	*curlcode = CURLE_RECV_ERROR;
2716	return -1L;
2717	}
2718	}
2719	return (ssize_t)processed;
2720	}
2721
2722	static void sectransp_get_internals(struct ssl_connect_data connssl,
2723	CURLINFO info UNUSED_PARAM)
2724	{
2725	struct st_ssl_backend_data *backend =
2726	(struct st_ssl_backend_data *)connssl->backend;
2727	(void)info;
2728	DEBUGASSERT(backend);
2729	return backend->ssl_ctx;
2730	}
2731
2732	const struct Curl_ssl Curl_ssl_sectransp = {
2733	{ CURLSSLBACKEND_SECURETRANSPORT, "secure-transport" }, /* info */
2734
2735	SSLSUPP_CAINFO_BLOB \|
2736	SSLSUPP_CERTINFO \|
2737	#ifdef SECTRANSP_PINNEDPUBKEY
2738	SSLSUPP_PINNEDPUBKEY \|
2739	#endif /* SECTRANSP_PINNEDPUBKEY */
2740	SSLSUPP_HTTPS_PROXY \|
2741	SSLSUPP_CIPHER_LIST,
2742
2743	sizeof(struct st_ssl_backend_data),
2744
2745	Curl_none_init, /* init */
2746	Curl_none_cleanup, /* cleanup */
2747	sectransp_version, /* version */
2748	Curl_none_check_cxn, /* check_cxn */
2749	sectransp_shutdown, /* shutdown */
2750	sectransp_data_pending, /* data_pending */
2751	sectransp_random, /* random */
2752	Curl_none_cert_status_request, /* cert_status_request */
2753	sectransp_connect, /* connect */
2754	sectransp_connect_nonblocking, /* connect_nonblocking */
2755	Curl_ssl_adjust_pollset, /* adjust_pollset */
2756	sectransp_get_internals, /* get_internals */
2757	sectransp_close, /* close_one */
2758	Curl_none_close_all, /* close_all */
2759	Curl_none_set_engine, /* set_engine */
2760	Curl_none_set_engine_default, /* set_engine_default */
2761	Curl_none_engines_list, /* engines_list */
2762	sectransp_false_start, /* false_start */
2763	sectransp_sha256sum, /* sha256sum */
2764	NULL, /* associate_connection */
2765	NULL, /* disassociate_connection */
2766	sectransp_recv, /* recv decrypted data */
2767	sectransp_send, /* send data to encrypt */
2768	NULL, /* get_channel_binding */
2769	};
2770
2771	#ifdef __GNUC__
2772	#pragma GCC diagnostic pop
2773	#endif
2774
2775	#ifdef __clang__
2776	#pragma clang diagnostic pop
2777	#endif
2778
2779	#endif /* USE_SECTRANSP */

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/curl-8.11.1/lib/vtls/sectransp.c@ 108333

以其他格式下載: