Debian Codegraph @

deps/curl/lib/vtls/bearssl.c

raw
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2019, Michael Forney, <[email protected]>
9 *
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 https://curl.haxx.se/docs/copyright.html.
13 *
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.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 ***************************************************************************/
22 #include "curl_setup.h"
23
24 #ifdef USE_BEARSSL
25
26 #include <bearssl.h>
27
28 #include "bearssl.h"
29 #include "urldata.h"
30 #include "sendf.h"
31 #include "inet_pton.h"
32 #include "vtls.h"
33 #include "connect.h"
34 #include "select.h"
35 #include "multiif.h"
36 #include "curl_printf.h"
37 #include "curl_memory.h"
38
39 struct x509_context {
40 const br_x509_class *vtable;
41 br_x509_minimal_context minimal;
42 bool verifyhost;
43 bool verifypeer;
44 };
45
46 struct ssl_backend_data {
47 br_ssl_client_context ctx;
48 struct x509_context x509;
49 unsigned char buf[BR_SSL_BUFSIZE_BIDI];
50 br_x509_trust_anchor *anchors;
51 size_t anchors_len;
52 const char *protocols[2];
53 /* SSL client context is active */
54 bool active;
55 /* size of pending write, yet to be flushed */
56 size_t pending_write;
57 };
58
59 #define BACKEND connssl->backend
60
61 struct cafile_parser {
62 CURLcode err;
63 bool in_cert;
64 br_x509_decoder_context xc;
65 /* array of trust anchors loaded from CAfile */
66 br_x509_trust_anchor *anchors;
67 size_t anchors_len;
68 /* buffer for DN data */
69 unsigned char dn[1024];
70 size_t dn_len;
71 };
72
73 static void append_dn(void *ctx, const void *buf, size_t len)
74 {
75 struct cafile_parser *ca = ctx;
76
77 if(ca->err != CURLE_OK || !ca->in_cert)
78 return;
79 if(sizeof(ca->dn) - ca->dn_len < len) {
80 ca->err = CURLE_FAILED_INIT;
81 return;
82 }
83 memcpy(ca->dn + ca->dn_len, buf, len);
84 ca->dn_len += len;
85 }
86
87 static void x509_push(void *ctx, const void *buf, size_t len)
88 {
89 struct cafile_parser *ca = ctx;
90
91 if(ca->in_cert)
92 br_x509_decoder_push(&ca->xc, buf, len);
93 }
94
95 static CURLcode load_cafile(const char *path, br_x509_trust_anchor **anchors,
96 size_t *anchors_len)
97 {
98 struct cafile_parser ca;
99 br_pem_decoder_context pc;
100 br_x509_trust_anchor *ta;
101 size_t ta_size;
102 br_x509_trust_anchor *new_anchors;
103 size_t new_anchors_len;
104 br_x509_pkey *pkey;
105 FILE *fp;
106 unsigned char buf[BUFSIZ], *p;
107 const char *name;
108 size_t n, i, pushed;
109
110 fp = fopen(path, "rb");
111 if(!fp)
112 return CURLE_SSL_CACERT_BADFILE;
113
114 ca.err = CURLE_OK;
115 ca.in_cert = FALSE;
116 ca.anchors = NULL;
117 ca.anchors_len = 0;
118 br_pem_decoder_init(&pc);
119 br_pem_decoder_setdest(&pc, x509_push, &ca);
120 for(;;) {
121 n = fread(buf, 1, sizeof(buf), fp);
122 if(n == 0)
123 break;
124 p = buf;
125 while(n) {
126 pushed = br_pem_decoder_push(&pc, p, n);
127 if(ca.err)
128 goto fail;
129 p += pushed;
130 n -= pushed;
131
132 switch(br_pem_decoder_event(&pc)) {
133 case 0:
134 break;
135 case BR_PEM_BEGIN_OBJ:
136 name = br_pem_decoder_name(&pc);
137 if(strcmp(name, "CERTIFICATE") && strcmp(name, "X509 CERTIFICATE"))
138 break;
139 br_x509_decoder_init(&ca.xc, append_dn, &ca);
140 if(ca.anchors_len == SIZE_MAX / sizeof(ca.anchors[0])) {
141 ca.err = CURLE_OUT_OF_MEMORY;
142 goto fail;
143 }
144 new_anchors_len = ca.anchors_len + 1;
145 new_anchors = realloc(ca.anchors,
146 new_anchors_len * sizeof(ca.anchors[0]));
147 if(!new_anchors) {
148 ca.err = CURLE_OUT_OF_MEMORY;
149 goto fail;
150 }
151 ca.anchors = new_anchors;
152 ca.anchors_len = new_anchors_len;
153 ca.in_cert = TRUE;
154 ca.dn_len = 0;
155 ta = &ca.anchors[ca.anchors_len - 1];
156 ta->dn.data = NULL;
157 break;
158 case BR_PEM_END_OBJ:
159 if(!ca.in_cert)
160 break;
161 ca.in_cert = FALSE;
162 if(br_x509_decoder_last_error(&ca.xc)) {
163 ca.err = CURLE_SSL_CACERT_BADFILE;
164 goto fail;
165 }
166 ta->flags = 0;
167 if(br_x509_decoder_isCA(&ca.xc))
168 ta->flags |= BR_X509_TA_CA;
169 pkey = br_x509_decoder_get_pkey(&ca.xc);
170 if(!pkey) {
171 ca.err = CURLE_SSL_CACERT_BADFILE;
172 goto fail;
173 }
174 ta->pkey = *pkey;
175
176 /* calculate space needed for trust anchor data */
177 ta_size = ca.dn_len;
178 switch(pkey->key_type) {
179 case BR_KEYTYPE_RSA:
180 ta_size += pkey->key.rsa.nlen + pkey->key.rsa.elen;
181 break;
182 case BR_KEYTYPE_EC:
183 ta_size += pkey->key.ec.qlen;
184 break;
185 default:
186 ca.err = CURLE_FAILED_INIT;
187 goto fail;
188 }
189
190 /* fill in trust anchor DN and public key data */
191 ta->dn.data = malloc(ta_size);
192 if(!ta->dn.data) {
193 ca.err = CURLE_OUT_OF_MEMORY;
194 goto fail;
195 }
196 memcpy(ta->dn.data, ca.dn, ca.dn_len);
197 ta->dn.len = ca.dn_len;
198 switch(pkey->key_type) {
199 case BR_KEYTYPE_RSA:
200 ta->pkey.key.rsa.n = ta->dn.data + ta->dn.len;
201 memcpy(ta->pkey.key.rsa.n, pkey->key.rsa.n, pkey->key.rsa.nlen);
202 ta->pkey.key.rsa.e = ta->pkey.key.rsa.n + ta->pkey.key.rsa.nlen;
203 memcpy(ta->pkey.key.rsa.e, pkey->key.rsa.e, pkey->key.rsa.elen);
204 break;
205 case BR_KEYTYPE_EC:
206 ta->pkey.key.ec.q = ta->dn.data + ta->dn.len;
207 memcpy(ta->pkey.key.ec.q, pkey->key.ec.q, pkey->key.ec.qlen);
208 break;
209 }
210 break;
211 default:
212 ca.err = CURLE_SSL_CACERT_BADFILE;
213 goto fail;
214 }
215 }
216 }
217 if(ferror(fp))
218 ca.err = CURLE_READ_ERROR;
219
220 fail:
221 fclose(fp);
222 if(ca.err == CURLE_OK) {
223 *anchors = ca.anchors;
224 *anchors_len = ca.anchors_len;
225 }
226 else {
227 for(i = 0; i < ca.anchors_len; ++i)
228 free(ca.anchors[i].dn.data);
229 free(ca.anchors);
230 }
231
232 return ca.err;
233 }
234
235 static void x509_start_chain(const br_x509_class **ctx,
236 const char *server_name)
237 {
238 struct x509_context *x509 = (struct x509_context *)ctx;
239
240 if(!x509->verifyhost)
241 server_name = NULL;
242 x509->minimal.vtable->start_chain(&x509->minimal.vtable, server_name);
243 }
244
245 static void x509_start_cert(const br_x509_class **ctx, uint32_t length)
246 {
247 struct x509_context *x509 = (struct x509_context *)ctx;
248
249 x509->minimal.vtable->start_cert(&x509->minimal.vtable, length);
250 }
251
252 static void x509_append(const br_x509_class **ctx, const unsigned char *buf,
253 size_t len)
254 {
255 struct x509_context *x509 = (struct x509_context *)ctx;
256
257 x509->minimal.vtable->append(&x509->minimal.vtable, buf, len);
258 }
259
260 static void x509_end_cert(const br_x509_class **ctx)
261 {
262 struct x509_context *x509 = (struct x509_context *)ctx;
263
264 x509->minimal.vtable->end_cert(&x509->minimal.vtable);
265 }
266
267 static unsigned x509_end_chain(const br_x509_class **ctx)
268 {
269 struct x509_context *x509 = (struct x509_context *)ctx;
270 unsigned err;
271
272 err = x509->minimal.vtable->end_chain(&x509->minimal.vtable);
273 if(err && !x509->verifypeer) {
274 /* ignore any X.509 errors */
275 err = BR_ERR_OK;
276 }
277
278 return err;
279 }
280
281 static const br_x509_pkey *x509_get_pkey(const br_x509_class *const *ctx,
282 unsigned *usages)
283 {
284 struct x509_context *x509 = (struct x509_context *)ctx;
285
286 return x509->minimal.vtable->get_pkey(&x509->minimal.vtable, usages);
287 }
288
289 static const br_x509_class x509_vtable = {
290 sizeof(struct x509_context),
291 x509_start_chain,
292 x509_start_cert,
293 x509_append,
294 x509_end_cert,
295 x509_end_chain,
296 x509_get_pkey
297 };
298
299 static CURLcode bearssl_connect_step1(struct connectdata *conn, int sockindex)
300 {
301 struct Curl_easy *data = conn->data;
302 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
303 const char * const ssl_cafile = SSL_CONN_CONFIG(CAfile);
304 const char *hostname = SSL_IS_PROXY() ? conn->http_proxy.host.name :
305 conn->host.name;
306 const bool verifypeer = SSL_CONN_CONFIG(verifypeer);
307 const bool verifyhost = SSL_CONN_CONFIG(verifyhost);
308 CURLcode ret;
309 unsigned version_min, version_max;
310 #ifdef ENABLE_IPV6
311 struct in6_addr addr;
312 #else
313 struct in_addr addr;
314 #endif
315
316 switch(SSL_CONN_CONFIG(version)) {
317 case CURL_SSLVERSION_SSLv2:
318 failf(data, "BearSSL does not support SSLv2");
319 return CURLE_SSL_CONNECT_ERROR;
320 case CURL_SSLVERSION_SSLv3:
321 failf(data, "BearSSL does not support SSLv3");
322 return CURLE_SSL_CONNECT_ERROR;
323 case CURL_SSLVERSION_TLSv1_0:
324 version_min = BR_TLS10;
325 version_max = BR_TLS10;
326 break;
327 case CURL_SSLVERSION_TLSv1_1:
328 version_min = BR_TLS11;
329 version_max = BR_TLS11;
330 break;
331 case CURL_SSLVERSION_TLSv1_2:
332 version_min = BR_TLS12;
333 version_max = BR_TLS12;
334 break;
335 case CURL_SSLVERSION_DEFAULT:
336 case CURL_SSLVERSION_TLSv1:
337 version_min = BR_TLS10;
338 version_max = BR_TLS12;
339 break;
340 default:
341 failf(data, "BearSSL: unknown CURLOPT_SSLVERSION");
342 return CURLE_SSL_CONNECT_ERROR;
343 }
344
345 if(ssl_cafile) {
346 ret = load_cafile(ssl_cafile, &BACKEND->anchors, &BACKEND->anchors_len);
347 if(ret != CURLE_OK) {
348 if(verifypeer) {
349 failf(data, "error setting certificate verify locations:\n"
350 " CAfile: %s\n", ssl_cafile);
351 return ret;
352 }
353 infof(data, "error setting certificate verify locations,"
354 " continuing anyway:\n");
355 }
356 }
357
358 /* initialize SSL context */
359 br_ssl_client_init_full(&BACKEND->ctx, &BACKEND->x509.minimal,
360 BACKEND->anchors, BACKEND->anchors_len);
361 br_ssl_engine_set_versions(&BACKEND->ctx.eng, version_min, version_max);
362 br_ssl_engine_set_buffer(&BACKEND->ctx.eng, BACKEND->buf,
363 sizeof(BACKEND->buf), 1);
364
365 /* initialize X.509 context */
366 BACKEND->x509.vtable = &x509_vtable;
367 BACKEND->x509.verifypeer = verifypeer;
368 BACKEND->x509.verifyhost = verifyhost;
369 br_ssl_engine_set_x509(&BACKEND->ctx.eng, &BACKEND->x509.vtable);
370
371 if(SSL_SET_OPTION(primary.sessionid)) {
372 void *session;
373
374 Curl_ssl_sessionid_lock(conn);
375 if(!Curl_ssl_getsessionid(conn, &session, NULL, sockindex)) {
376 br_ssl_engine_set_session_parameters(&BACKEND->ctx.eng, session);
377 infof(data, "BearSSL: re-using session ID\n");
378 }
379 Curl_ssl_sessionid_unlock(conn);
380 }
381
382 if(conn->bits.tls_enable_alpn) {
383 int cur = 0;
384
385 /* NOTE: when adding more protocols here, increase the size of the
386 * protocols array in `struct ssl_backend_data`.
387 */
388
389 #ifdef USE_NGHTTP2
390 if(data->set.httpversion >= CURL_HTTP_VERSION_2 &&
391 (!SSL_IS_PROXY() || !conn->bits.tunnel_proxy)) {
392 BACKEND->protocols[cur++] = NGHTTP2_PROTO_VERSION_ID;
393 infof(data, "ALPN, offering %s\n", NGHTTP2_PROTO_VERSION_ID);
394 }
395 #endif
396
397 BACKEND->protocols[cur++] = ALPN_HTTP_1_1;
398 infof(data, "ALPN, offering %s\n", ALPN_HTTP_1_1);
399
400 br_ssl_engine_set_protocol_names(&BACKEND->ctx.eng,
401 BACKEND->protocols, cur);
402 }
403
404 if((1 == Curl_inet_pton(AF_INET, hostname, &addr))
405 #ifdef ENABLE_IPV6
406 || (1 == Curl_inet_pton(AF_INET6, hostname, &addr))
407 #endif
408 ) {
409 if(verifyhost) {
410 failf(data, "BearSSL: "
411 "host verification of IP address is not supported");
412 return CURLE_PEER_FAILED_VERIFICATION;
413 }
414 hostname = NULL;
415 }
416
417 if(!br_ssl_client_reset(&BACKEND->ctx, hostname, 0))
418 return CURLE_FAILED_INIT;
419 BACKEND->active = TRUE;
420
421 connssl->connecting_state = ssl_connect_2;
422
423 return CURLE_OK;
424 }
425
426 static CURLcode bearssl_run_until(struct connectdata *conn, int sockindex,
427 unsigned target)
428 {
429 struct Curl_easy *data = conn->data;
430 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
431 curl_socket_t sockfd = conn->sock[sockindex];
432 unsigned state;
433 unsigned char *buf;
434 size_t len;
435 ssize_t ret;
436 int err;
437
438 for(;;) {
439 state = br_ssl_engine_current_state(&BACKEND->ctx.eng);
440 if(state & BR_SSL_CLOSED) {
441 err = br_ssl_engine_last_error(&BACKEND->ctx.eng);
442 switch(err) {
443 case BR_ERR_OK:
444 /* TLS close notify */
445 if(connssl->state != ssl_connection_complete) {
446 failf(data, "SSL: connection closed during handshake");
447 return CURLE_SSL_CONNECT_ERROR;
448 }
449 return CURLE_OK;
450 case BR_ERR_X509_EXPIRED:
451 failf(data, "SSL: X.509 verification: "
452 "certificate is expired or not yet valid");
453 return CURLE_PEER_FAILED_VERIFICATION;
454 case BR_ERR_X509_BAD_SERVER_NAME:
455 failf(data, "SSL: X.509 verification: "
456 "expected server name was not found in the chain");
457 return CURLE_PEER_FAILED_VERIFICATION;
458 case BR_ERR_X509_NOT_TRUSTED:
459 failf(data, "SSL: X.509 verification: "
460 "chain could not be linked to a trust anchor");
461 return CURLE_PEER_FAILED_VERIFICATION;
462 }
463 /* X.509 errors are documented to have the range 32..63 */
464 if(err >= 32 && err < 64)
465 return CURLE_PEER_FAILED_VERIFICATION;
466 return CURLE_SSL_CONNECT_ERROR;
467 }
468 if(state & target)
469 return CURLE_OK;
470 if(state & BR_SSL_SENDREC) {
471 buf = br_ssl_engine_sendrec_buf(&BACKEND->ctx.eng, &len);
472 ret = swrite(sockfd, buf, len);
473 if(ret == -1) {
474 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
475 if(connssl->state != ssl_connection_complete)
476 connssl->connecting_state = ssl_connect_2_writing;
477 return CURLE_AGAIN;
478 }
479 return CURLE_WRITE_ERROR;
480 }
481 br_ssl_engine_sendrec_ack(&BACKEND->ctx.eng, ret);
482 }
483 else if(state & BR_SSL_RECVREC) {
484 buf = br_ssl_engine_recvrec_buf(&BACKEND->ctx.eng, &len);
485 ret = sread(sockfd, buf, len);
486 if(ret == 0) {
487 failf(data, "SSL: EOF without close notify");
488 return CURLE_READ_ERROR;
489 }
490 if(ret == -1) {
491 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
492 if(connssl->state != ssl_connection_complete)
493 connssl->connecting_state = ssl_connect_2_reading;
494 return CURLE_AGAIN;
495 }
496 return CURLE_READ_ERROR;
497 }
498 br_ssl_engine_recvrec_ack(&BACKEND->ctx.eng, ret);
499 }
500 }
501 }
502
503 static CURLcode bearssl_connect_step2(struct connectdata *conn, int sockindex)
504 {
505 struct Curl_easy *data = conn->data;
506 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
507 CURLcode ret;
508
509 ret = bearssl_run_until(conn, sockindex, BR_SSL_SENDAPP | BR_SSL_RECVAPP);
510 if(ret == CURLE_AGAIN)
511 return CURLE_OK;
512 if(ret == CURLE_OK) {
513 if(br_ssl_engine_current_state(&BACKEND->ctx.eng) == BR_SSL_CLOSED) {
514 failf(data, "SSL: connection closed during handshake");
515 return CURLE_SSL_CONNECT_ERROR;
516 }
517 connssl->connecting_state = ssl_connect_3;
518 }
519 return ret;
520 }
521
522 static CURLcode bearssl_connect_step3(struct connectdata *conn, int sockindex)
523 {
524 struct Curl_easy *data = conn->data;
525 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
526 CURLcode ret;
527
528 DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
529
530 if(conn->bits.tls_enable_alpn) {
531 const char *protocol;
532
533 protocol = br_ssl_engine_get_selected_protocol(&BACKEND->ctx.eng);
534 if(protocol) {
535 infof(data, "ALPN, server accepted to use %s\n", protocol);
536
537 #ifdef USE_NGHTTP2
538 if(!strcmp(protocol, NGHTTP2_PROTO_VERSION_ID))
539 conn->negnpn = CURL_HTTP_VERSION_2;
540 else
541 #endif
542 if(!strcmp(protocol, ALPN_HTTP_1_1))
543 conn->negnpn = CURL_HTTP_VERSION_1_1;
544 else
545 infof(data, "ALPN, unrecognized protocol %s\n", protocol);
546 Curl_multiuse_state(conn, conn->negnpn == CURL_HTTP_VERSION_2 ?
547 BUNDLE_MULTIPLEX : BUNDLE_NO_MULTIUSE);
548 }
549 else
550 infof(data, "ALPN, server did not agree to a protocol\n");
551 }
552
553 if(SSL_SET_OPTION(primary.sessionid)) {
554 bool incache;
555 void *oldsession;
556 br_ssl_session_parameters *session;
557
558 session = malloc(sizeof(*session));
559 if(!session)
560 return CURLE_OUT_OF_MEMORY;
561 br_ssl_engine_get_session_parameters(&BACKEND->ctx.eng, session);
562 Curl_ssl_sessionid_lock(conn);
563 incache = !(Curl_ssl_getsessionid(conn, &oldsession, NULL, sockindex));
564 if(incache)
565 Curl_ssl_delsessionid(conn, oldsession);
566 ret = Curl_ssl_addsessionid(conn, session, 0, sockindex);
567 Curl_ssl_sessionid_unlock(conn);
568 if(ret) {
569 free(session);
570 return CURLE_OUT_OF_MEMORY;
571 }
572 }
573
574 connssl->connecting_state = ssl_connect_done;
575
576 return CURLE_OK;
577 }
578
579 static ssize_t bearssl_send(struct connectdata *conn, int sockindex,
580 const void *buf, size_t len, CURLcode *err)
581 {
582 struct Curl_easy *data = conn->data;
583 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
584 unsigned char *app;
585 size_t applen;
586
587 for(;;) {
588 *err = bearssl_run_until(conn, sockindex, BR_SSL_SENDAPP);
589 if (*err != CURLE_OK)
590 return -1;
591 app = br_ssl_engine_sendapp_buf(&BACKEND->ctx.eng, &applen);
592 if(!app) {
593 failf(data, "SSL: connection closed during write");
594 *err = CURLE_SEND_ERROR;
595 return -1;
596 }
597 if(BACKEND->pending_write) {
598 applen = BACKEND->pending_write;
599 BACKEND->pending_write = 0;
600 return applen;
601 }
602 if(applen > len)
603 applen = len;
604 memcpy(app, buf, applen);
605 br_ssl_engine_sendapp_ack(&BACKEND->ctx.eng, applen);
606 br_ssl_engine_flush(&BACKEND->ctx.eng, 0);
607 BACKEND->pending_write = applen;
608 }
609 }
610
611 static ssize_t bearssl_recv(struct connectdata *conn, int sockindex,
612 char *buf, size_t len, CURLcode *err)
613 {
614 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
615 unsigned char *app;
616 size_t applen;
617
618 *err = bearssl_run_until(conn, sockindex, BR_SSL_RECVAPP);
619 if(*err != CURLE_OK)
620 return -1;
621 app = br_ssl_engine_recvapp_buf(&BACKEND->ctx.eng, &applen);
622 if(!app)
623 return 0;
624 if(applen > len)
625 applen = len;
626 memcpy(buf, app, applen);
627 br_ssl_engine_recvapp_ack(&BACKEND->ctx.eng, applen);
628
629 return applen;
630 }
631
632 static CURLcode bearssl_connect_common(struct connectdata *conn,
633 int sockindex,
634 bool nonblocking,
635 bool *done)
636 {
637 CURLcode ret;
638 struct Curl_easy *data = conn->data;
639 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
640 curl_socket_t sockfd = conn->sock[sockindex];
641 time_t timeout_ms;
642 int what;
643
644 /* check if the connection has already been established */
645 if(ssl_connection_complete == connssl->state) {
646 *done = TRUE;
647 return CURLE_OK;
648 }
649
650 if(ssl_connect_1 == connssl->connecting_state) {
651 ret = bearssl_connect_step1(conn, sockindex);
652 if(ret)
653 return ret;
654 }
655
656 while(ssl_connect_2 == connssl->connecting_state ||
657 ssl_connect_2_reading == connssl->connecting_state ||
658 ssl_connect_2_writing == connssl->connecting_state) {
659 /* check allowed time left */
660 timeout_ms = Curl_timeleft(data, NULL, TRUE);
661
662 if(timeout_ms < 0) {
663 /* no need to continue if time already is up */
664 failf(data, "SSL connection timeout");
665 return CURLE_OPERATION_TIMEDOUT;
666 }
667
668 /* if ssl is expecting something, check if it's available. */
669 if(ssl_connect_2_reading == connssl->connecting_state ||
670 ssl_connect_2_writing == connssl->connecting_state) {
671
672 curl_socket_t writefd = ssl_connect_2_writing ==
673 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
674 curl_socket_t readfd = ssl_connect_2_reading ==
675 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
676
677 what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
678 nonblocking?0:timeout_ms);
679 if(what < 0) {
680 /* fatal error */
681 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
682 return CURLE_SSL_CONNECT_ERROR;
683 }
684 else if(0 == what) {
685 if(nonblocking) {
686 *done = FALSE;
687 return CURLE_OK;
688 }
689 else {
690 /* timeout */
691 failf(data, "SSL connection timeout");
692 return CURLE_OPERATION_TIMEDOUT;
693 }
694 }
695 /* socket is readable or writable */
696 }
697
698 /* Run transaction, and return to the caller if it failed or if this
699 * connection is done nonblocking and this loop would execute again. This
700 * permits the owner of a multi handle to abort a connection attempt
701 * before step2 has completed while ensuring that a client using select()
702 * or epoll() will always have a valid fdset to wait on.
703 */
704 ret = bearssl_connect_step2(conn, sockindex);
705 if(ret || (nonblocking &&
706 (ssl_connect_2 == connssl->connecting_state ||
707 ssl_connect_2_reading == connssl->connecting_state ||
708 ssl_connect_2_writing == connssl->connecting_state)))
709 return ret;
710 }
711
712 if(ssl_connect_3 == connssl->connecting_state) {
713 ret = bearssl_connect_step3(conn, sockindex);
714 if(ret)
715 return ret;
716 }
717
718 if(ssl_connect_done == connssl->connecting_state) {
719 connssl->state = ssl_connection_complete;
720 conn->recv[sockindex] = bearssl_recv;
721 conn->send[sockindex] = bearssl_send;
722 *done = TRUE;
723 }
724 else
725 *done = FALSE;
726
727 /* Reset our connect state machine */
728 connssl->connecting_state = ssl_connect_1;
729
730 return CURLE_OK;
731 }
732
733 static size_t Curl_bearssl_version(char *buffer, size_t size)
734 {
735 return msnprintf(buffer, size, "BearSSL");
736 }
737
738 static bool Curl_bearssl_data_pending(const struct connectdata *conn,
739 int connindex)
740 {
741 const struct ssl_connect_data *connssl = &conn->ssl[connindex];
742
743 return br_ssl_engine_current_state(&BACKEND->ctx.eng) & BR_SSL_RECVAPP;
744 }
745
746 static CURLcode Curl_bearssl_random(struct Curl_easy *data UNUSED_PARAM,
747 unsigned char *entropy, size_t length)
748 {
749 static br_hmac_drbg_context ctx;
750 static bool seeded = FALSE;
751
752 if(!seeded) {
753 br_prng_seeder seeder;
754
755 br_hmac_drbg_init(&ctx, &br_sha256_vtable, NULL, 0);
756 seeder = br_prng_seeder_system(NULL);
757 if(!seeder || !seeder(&ctx.vtable))
758 return CURLE_FAILED_INIT;
759 seeded = TRUE;
760 }
761 br_hmac_drbg_generate(&ctx, entropy, length);
762
763 return CURLE_OK;
764 }
765
766 static CURLcode Curl_bearssl_connect(struct connectdata *conn, int sockindex)
767 {
768 CURLcode ret;
769 bool done = FALSE;
770
771 ret = bearssl_connect_common(conn, sockindex, FALSE, &done);
772 if(ret)
773 return ret;
774
775 DEBUGASSERT(done);
776
777 return CURLE_OK;
778 }
779
780 static CURLcode Curl_bearssl_connect_nonblocking(struct connectdata *conn,
781 int sockindex, bool *done)
782 {
783 return bearssl_connect_common(conn, sockindex, TRUE, done);
784 }
785
786 static void *Curl_bearssl_get_internals(struct ssl_connect_data *connssl,
787 CURLINFO info UNUSED_PARAM)
788 {
789 return &BACKEND->ctx;
790 }
791
792 static void Curl_bearssl_close(struct connectdata *conn, int sockindex)
793 {
794 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
795 size_t i;
796
797 if(BACKEND->active) {
798 br_ssl_engine_close(&BACKEND->ctx.eng);
799 (void)bearssl_run_until(conn, sockindex, BR_SSL_CLOSED);
800 }
801 for(i = 0; i < BACKEND->anchors_len; ++i)
802 free(BACKEND->anchors[i].dn.data);
803 free(BACKEND->anchors);
804 }
805
806 static void Curl_bearssl_session_free(void *ptr)
807 {
808 free(ptr);
809 }
810
811 static CURLcode Curl_bearssl_md5sum(unsigned char *input,
812 size_t inputlen,
813 unsigned char *md5sum,
814 size_t md5len UNUSED_PARAM)
815 {
816 br_md5_context ctx;
817
818 br_md5_init(&ctx);
819 br_md5_update(&ctx, input, inputlen);
820 br_md5_out(&ctx, md5sum);
821 return CURLE_OK;
822 }
823
824 static CURLcode Curl_bearssl_sha256sum(const unsigned char *input,
825 size_t inputlen,
826 unsigned char *sha256sum,
827 size_t sha256len UNUSED_PARAM)
828 {
829 br_sha256_context ctx;
830
831 br_sha256_init(&ctx);
832 br_sha256_update(&ctx, input, inputlen);
833 br_sha256_out(&ctx, sha256sum);
834 return CURLE_OK;
835 }
836
837 const struct Curl_ssl Curl_ssl_bearssl = {
838 { CURLSSLBACKEND_BEARSSL, "bearssl" },
839
840 0,
841
842 sizeof(struct ssl_backend_data),
843
844 Curl_none_init,
845 Curl_none_cleanup,
846 Curl_bearssl_version,
847 Curl_none_check_cxn,
848 Curl_none_shutdown,
849 Curl_bearssl_data_pending,
850 Curl_bearssl_random,
851 Curl_none_cert_status_request,
852 Curl_bearssl_connect,
853 Curl_bearssl_connect_nonblocking,
854 Curl_bearssl_get_internals,
855 Curl_bearssl_close,
856 Curl_none_close_all,
857 Curl_bearssl_session_free,
858 Curl_none_set_engine,
859 Curl_none_set_engine_default,
860 Curl_none_engines_list,
861 Curl_none_false_start,
862 Curl_bearssl_md5sum,
863 Curl_bearssl_sha256sum
864 };
865
866 #endif /* USE_BEARSSL */