1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ***************************************************************************/
24 * Source file for all CyaSSL-specific code for the TLS/SSL layer. No code
25 * but vtls.c should ever call or use these functions.
29 #include "curl_setup.h"
39 #include "inet_pton.h"
42 #include "parsedate.h"
43 #include "connect.h" /* for the connect timeout */
47 #define _MPRINTF_REPLACE /* use our functions only */
48 #include <curl/mprintf.h>
49 #include "curl_memory.h"
51 #include <cyassl/ssl.h>
52 #ifdef HAVE_CYASSL_ERROR_SSL_H
53 #include <cyassl/error-ssl.h>
55 #include <cyassl/error.h>
57 #include <cyassl/ctaocrypt/random.h>
59 /* The last #include file should be: */
62 static Curl_recv cyassl_recv;
63 static Curl_send cyassl_send;
66 static int do_file_type(const char *type)
69 return SSL_FILETYPE_PEM;
70 if(Curl_raw_equal(type, "PEM"))
71 return SSL_FILETYPE_PEM;
72 if(Curl_raw_equal(type, "DER"))
73 return SSL_FILETYPE_ASN1;
78 * This function loads all the client/CA certificates and CRLs. Setup the TLS
79 * layer and do all necessary magic.
82 cyassl_connect_step1(struct connectdata *conn,
85 struct SessionHandle *data = conn->data;
86 struct ssl_connect_data* conssl = &conn->ssl[sockindex];
87 SSL_METHOD* req_method = NULL;
88 void* ssl_sessionid = NULL;
89 curl_socket_t sockfd = conn->sock[sockindex];
91 if(conssl->state == ssl_connection_complete)
94 /* CyaSSL doesn't support SSLv2 */
95 if(data->set.ssl.version == CURL_SSLVERSION_SSLv2) {
96 failf(data, "CyaSSL does not support SSLv2");
97 return CURLE_SSL_CONNECT_ERROR;
100 /* check to see if we've been told to use an explicit SSL/TLS version */
101 switch(data->set.ssl.version) {
103 case CURL_SSLVERSION_DEFAULT:
104 case CURL_SSLVERSION_TLSv1:
105 infof(data, "CyaSSL cannot be configured to use TLS 1.0-1.2, "
106 "TLS 1.0 is used exclusively\n");
107 req_method = TLSv1_client_method();
109 case CURL_SSLVERSION_TLSv1_0:
110 req_method = TLSv1_client_method();
112 case CURL_SSLVERSION_TLSv1_1:
113 req_method = TLSv1_1_client_method();
115 case CURL_SSLVERSION_TLSv1_2:
116 req_method = TLSv1_2_client_method();
118 case CURL_SSLVERSION_SSLv3:
119 req_method = SSLv3_client_method();
124 failf(data, "SSL: couldn't create a method!");
125 return CURLE_OUT_OF_MEMORY;
129 SSL_CTX_free(conssl->ctx);
130 conssl->ctx = SSL_CTX_new(req_method);
133 failf(data, "SSL: couldn't create a context!");
134 return CURLE_OUT_OF_MEMORY;
137 #ifndef NO_FILESYSTEM
138 /* load trusted cacert */
139 if(data->set.str[STRING_SSL_CAFILE]) {
140 if(!SSL_CTX_load_verify_locations(conssl->ctx,
141 data->set.str[STRING_SSL_CAFILE],
142 data->set.str[STRING_SSL_CAPATH])) {
143 if(data->set.ssl.verifypeer) {
144 /* Fail if we insist on successfully verifying the server. */
145 failf(data,"error setting certificate verify locations:\n"
146 " CAfile: %s\n CApath: %s",
147 data->set.str[STRING_SSL_CAFILE]?
148 data->set.str[STRING_SSL_CAFILE]: "none",
149 data->set.str[STRING_SSL_CAPATH]?
150 data->set.str[STRING_SSL_CAPATH] : "none");
151 return CURLE_SSL_CACERT_BADFILE;
154 /* Just continue with a warning if no strict certificate
155 verification is required. */
156 infof(data, "error setting certificate verify locations,"
157 " continuing anyway:\n");
161 /* Everything is fine. */
162 infof(data, "successfully set certificate verify locations:\n");
167 data->set.str[STRING_SSL_CAFILE] ? data->set.str[STRING_SSL_CAFILE]:
169 data->set.str[STRING_SSL_CAPATH] ? data->set.str[STRING_SSL_CAPATH]:
173 /* Load the client certificate, and private key */
174 if(data->set.str[STRING_CERT] && data->set.str[STRING_KEY]) {
175 int file_type = do_file_type(data->set.str[STRING_CERT_TYPE]);
177 if(SSL_CTX_use_certificate_file(conssl->ctx, data->set.str[STRING_CERT],
179 failf(data, "unable to use client certificate (no key or wrong pass"
181 return CURLE_SSL_CONNECT_ERROR;
184 file_type = do_file_type(data->set.str[STRING_KEY_TYPE]);
185 if(SSL_CTX_use_PrivateKey_file(conssl->ctx, data->set.str[STRING_KEY],
187 failf(data, "unable to set private key");
188 return CURLE_SSL_CONNECT_ERROR;
192 if(CyaSSL_no_filesystem_verify(conssl->ctx)!= SSL_SUCCESS) {
193 return CURLE_SSL_CONNECT_ERROR;
195 #endif /* NO_FILESYSTEM */
197 /* SSL always tries to verify the peer, this only says whether it should
198 * fail to connect if the verification fails, or if it should continue
199 * anyway. In the latter case the result of the verification is checked with
200 * SSL_get_verify_result() below. */
201 SSL_CTX_set_verify(conssl->ctx,
202 data->set.ssl.verifypeer?SSL_VERIFY_PEER:SSL_VERIFY_NONE,
205 /* Let's make an SSL structure */
207 SSL_free(conssl->handle);
208 conssl->handle = SSL_new(conssl->ctx);
209 if(!conssl->handle) {
210 failf(data, "SSL: couldn't create a context (handle)!");
211 return CURLE_OUT_OF_MEMORY;
214 /* Check if there's a cached ID we can/should use here! */
215 if(!Curl_ssl_getsessionid(conn, &ssl_sessionid, NULL)) {
216 /* we got a session id, use it! */
217 if(!SSL_set_session(conssl->handle, ssl_sessionid)) {
218 failf(data, "SSL: SSL_set_session failed: %s",
219 ERR_error_string(SSL_get_error(conssl->handle, 0),NULL));
220 return CURLE_SSL_CONNECT_ERROR;
222 /* Informational message */
223 infof (data, "SSL re-using session ID\n");
226 /* pass the raw socket into the SSL layer */
227 if(!SSL_set_fd(conssl->handle, (int)sockfd)) {
228 failf(data, "SSL: SSL_set_fd failed");
229 return CURLE_SSL_CONNECT_ERROR;
232 conssl->connecting_state = ssl_connect_2;
238 cyassl_connect_step2(struct connectdata *conn,
242 struct SessionHandle *data = conn->data;
243 struct ssl_connect_data* conssl = &conn->ssl[sockindex];
245 infof(data, "CyaSSL: Connecting to %s:%d\n",
246 conn->host.name, conn->remote_port);
248 conn->recv[sockindex] = cyassl_recv;
249 conn->send[sockindex] = cyassl_send;
251 /* Enable RFC2818 checks */
252 if(data->set.ssl.verifyhost) {
253 ret = CyaSSL_check_domain_name(conssl->handle, conn->host.name);
254 if(ret == SSL_FAILURE)
255 return CURLE_OUT_OF_MEMORY;
258 ret = SSL_connect(conssl->handle);
260 char error_buffer[80];
261 int detail = SSL_get_error(conssl->handle, ret);
263 if(SSL_ERROR_WANT_READ == detail) {
264 conssl->connecting_state = ssl_connect_2_reading;
267 else if(SSL_ERROR_WANT_WRITE == detail) {
268 conssl->connecting_state = ssl_connect_2_writing;
271 /* There is no easy way to override only the CN matching.
272 * This will enable the override of both mismatching SubjectAltNames
273 * as also mismatching CN fields */
274 else if(DOMAIN_NAME_MISMATCH == detail) {
276 failf(data, "\tsubject alt name(s) or common name do not match \"%s\"\n",
277 conn->host.dispname);
278 return CURLE_PEER_FAILED_VERIFICATION;
280 /* When the CyaSSL_check_domain_name() is used and you desire to continue
281 * on a DOMAIN_NAME_MISMATCH, i.e. 'data->set.ssl.verifyhost == 0',
282 * CyaSSL version 2.4.0 will fail with an INCOMPLETE_DATA error. The only
283 * way to do this is currently to switch the CyaSSL_check_domain_name()
284 * in and out based on the 'data->set.ssl.verifyhost' value. */
285 if(data->set.ssl.verifyhost) {
287 "\tsubject alt name(s) or common name do not match \"%s\"\n",
288 conn->host.dispname);
289 return CURLE_PEER_FAILED_VERIFICATION;
293 "\tsubject alt name(s) and/or common name do not match \"%s\"\n",
294 conn->host.dispname);
299 #if LIBCYASSL_VERSION_HEX >= 0x02007000 /* 2.7.0 */
300 else if(ASN_NO_SIGNER_E == detail) {
301 if(data->set.ssl.verifypeer) {
302 failf(data, "\tCA signer not available for verification\n");
303 return CURLE_SSL_CACERT_BADFILE;
306 /* Just continue with a warning if no strict certificate
307 verification is required. */
308 infof(data, "CA signer not available for verification, "
309 "continuing anyway\n");
314 failf(data, "SSL_connect failed with error %d: %s", detail,
315 ERR_error_string(detail, error_buffer));
316 return CURLE_SSL_CONNECT_ERROR;
320 conssl->connecting_state = ssl_connect_3;
321 infof(data, "SSL connected\n");
328 cyassl_connect_step3(struct connectdata *conn,
331 CURLcode result = CURLE_OK;
332 void *old_ssl_sessionid=NULL;
333 struct SessionHandle *data = conn->data;
334 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
336 SSL_SESSION *our_ssl_sessionid;
338 DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
340 our_ssl_sessionid = SSL_get_session(connssl->handle);
342 incache = !(Curl_ssl_getsessionid(conn, &old_ssl_sessionid, NULL));
344 if(old_ssl_sessionid != our_ssl_sessionid) {
345 infof(data, "old SSL session ID is stale, removing\n");
346 Curl_ssl_delsessionid(conn, old_ssl_sessionid);
352 result = Curl_ssl_addsessionid(conn, our_ssl_sessionid,
353 0 /* unknown size */);
355 failf(data, "failed to store ssl session");
360 connssl->connecting_state = ssl_connect_done;
366 static ssize_t cyassl_send(struct connectdata *conn,
372 char error_buffer[80];
373 int memlen = (len > (size_t)INT_MAX) ? INT_MAX : (int)len;
374 int rc = SSL_write(conn->ssl[sockindex].handle, mem, memlen);
377 int err = SSL_get_error(conn->ssl[sockindex].handle, rc);
380 case SSL_ERROR_WANT_READ:
381 case SSL_ERROR_WANT_WRITE:
382 /* there's data pending, re-invoke SSL_write() */
383 *curlcode = CURLE_AGAIN;
386 failf(conn->data, "SSL write: %s, errno %d",
387 ERR_error_string(err, error_buffer),
389 *curlcode = CURLE_SEND_ERROR;
396 void Curl_cyassl_close_all(struct SessionHandle *data)
401 void Curl_cyassl_close(struct connectdata *conn, int sockindex)
403 struct ssl_connect_data *conssl = &conn->ssl[sockindex];
406 (void)SSL_shutdown(conssl->handle);
407 SSL_free (conssl->handle);
408 conssl->handle = NULL;
411 SSL_CTX_free (conssl->ctx);
416 static ssize_t cyassl_recv(struct connectdata *conn,
422 char error_buffer[80];
423 int buffsize = (buffersize > (size_t)INT_MAX) ? INT_MAX : (int)buffersize;
424 int nread = SSL_read(conn->ssl[num].handle, buf, buffsize);
427 int err = SSL_get_error(conn->ssl[num].handle, nread);
430 case SSL_ERROR_ZERO_RETURN: /* no more data */
432 case SSL_ERROR_WANT_READ:
433 case SSL_ERROR_WANT_WRITE:
434 /* there's data pending, re-invoke SSL_read() */
435 *curlcode = CURLE_AGAIN;
438 failf(conn->data, "SSL read: %s, errno %d",
439 ERR_error_string(err, error_buffer),
441 *curlcode = CURLE_RECV_ERROR;
449 void Curl_cyassl_session_free(void *ptr)
452 /* CyaSSL reuses sessions on own, no free */
456 size_t Curl_cyassl_version(char *buffer, size_t size)
458 #ifdef CYASSL_VERSION
459 return snprintf(buffer, size, "CyaSSL/%s", CYASSL_VERSION);
461 return snprintf(buffer, size, "CyaSSL/%s", "<1.8.8");
466 int Curl_cyassl_init(void)
468 if(CyaSSL_Init() == 0)
475 bool Curl_cyassl_data_pending(const struct connectdata* conn, int connindex)
477 if(conn->ssl[connindex].handle) /* SSL is in use */
478 return (0 != SSL_pending(conn->ssl[connindex].handle)) ? TRUE : FALSE;
485 * This function is called to shut down the SSL layer but keep the
486 * socket open (CCC - Clear Command Channel)
488 int Curl_cyassl_shutdown(struct connectdata *conn, int sockindex)
491 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
493 if(connssl->handle) {
494 SSL_free (connssl->handle);
495 connssl->handle = NULL;
502 cyassl_connect_common(struct connectdata *conn,
508 struct SessionHandle *data = conn->data;
509 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
510 curl_socket_t sockfd = conn->sock[sockindex];
514 /* check if the connection has already been established */
515 if(ssl_connection_complete == connssl->state) {
520 if(ssl_connect_1==connssl->connecting_state) {
521 /* Find out how much more time we're allowed */
522 timeout_ms = Curl_timeleft(data, NULL, TRUE);
525 /* no need to continue if time already is up */
526 failf(data, "SSL connection timeout");
527 return CURLE_OPERATION_TIMEDOUT;
530 result = cyassl_connect_step1(conn, sockindex);
535 while(ssl_connect_2 == connssl->connecting_state ||
536 ssl_connect_2_reading == connssl->connecting_state ||
537 ssl_connect_2_writing == connssl->connecting_state) {
539 /* check allowed time left */
540 timeout_ms = Curl_timeleft(data, NULL, TRUE);
543 /* no need to continue if time already is up */
544 failf(data, "SSL connection timeout");
545 return CURLE_OPERATION_TIMEDOUT;
548 /* if ssl is expecting something, check if it's available. */
549 if(connssl->connecting_state == ssl_connect_2_reading
550 || connssl->connecting_state == ssl_connect_2_writing) {
552 curl_socket_t writefd = ssl_connect_2_writing==
553 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
554 curl_socket_t readfd = ssl_connect_2_reading==
555 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
557 what = Curl_socket_ready(readfd, writefd, nonblocking?0:timeout_ms);
560 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
561 return CURLE_SSL_CONNECT_ERROR;
570 failf(data, "SSL connection timeout");
571 return CURLE_OPERATION_TIMEDOUT;
574 /* socket is readable or writable */
577 /* Run transaction, and return to the caller if it failed or if
578 * this connection is part of a multi handle and this loop would
579 * execute again. This permits the owner of a multi handle to
580 * abort a connection attempt before step2 has completed while
581 * ensuring that a client using select() or epoll() will always
582 * have a valid fdset to wait on.
584 result = cyassl_connect_step2(conn, sockindex);
585 if(result || (nonblocking &&
586 (ssl_connect_2 == connssl->connecting_state ||
587 ssl_connect_2_reading == connssl->connecting_state ||
588 ssl_connect_2_writing == connssl->connecting_state)))
590 } /* repeat step2 until all transactions are done. */
592 if(ssl_connect_3 == connssl->connecting_state) {
593 result = cyassl_connect_step3(conn, sockindex);
598 if(ssl_connect_done == connssl->connecting_state) {
599 connssl->state = ssl_connection_complete;
600 conn->recv[sockindex] = cyassl_recv;
601 conn->send[sockindex] = cyassl_send;
607 /* Reset our connect state machine */
608 connssl->connecting_state = ssl_connect_1;
615 Curl_cyassl_connect_nonblocking(struct connectdata *conn,
619 return cyassl_connect_common(conn, sockindex, TRUE, done);
624 Curl_cyassl_connect(struct connectdata *conn,
630 result = cyassl_connect_common(conn, sockindex, FALSE, &done);
639 int Curl_cyassl_random(struct SessionHandle *data,
640 unsigned char *entropy,
647 if(RNG_GenerateBlock(&rng, entropy, length))