1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Michael Forney, <mforney@mforney.org>
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.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 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24 #include "curl_setup.h"
25
26 #ifdef USE_BEARSSL
27
28 #include <bearssl.h>
29
30 #include "bearssl.h"
31 #include "urldata.h"
32 #include "sendf.h"
33 #include "inet_pton.h"
34 #include "vtls.h"
35 #include "vtls_int.h"
36 #include "connect.h"
37 #include "select.h"
38 #include "multiif.h"
39 #include "curl_printf.h"
40 #include "strcase.h"
41
42 /* The last #include files should be: */
43 #include "curl_memory.h"
44 #include "memdebug.h"
45
46 struct x509_context {
47 const br_x509_class *vtable;
48 br_x509_minimal_context minimal;
49 br_x509_decoder_context decoder;
50 bool verifyhost;
51 bool verifypeer;
52 int cert_num;
53 };
54
55 struct bearssl_ssl_backend_data {
56 br_ssl_client_context ctx;
57 struct x509_context x509;
58 unsigned char buf[BR_SSL_BUFSIZE_BIDI];
59 br_x509_trust_anchor *anchors;
60 size_t anchors_len;
61 const char *protocols[ALPN_ENTRIES_MAX];
62 /* SSL client context is active */
63 bool active;
64 /* size of pending write, yet to be flushed */
65 size_t pending_write;
66 };
67
68 struct cafile_parser {
69 CURLcode err;
70 bool in_cert;
71 br_x509_decoder_context xc;
72 /* array of trust anchors loaded from CAfile */
73 br_x509_trust_anchor *anchors;
74 size_t anchors_len;
75 /* buffer for DN data */
76 unsigned char dn[1024];
77 size_t dn_len;
78 };
79
80 #define CAFILE_SOURCE_PATH 1
81 #define CAFILE_SOURCE_BLOB 2
82 struct cafile_source {
83 int type;
84 const char *data;
85 size_t len;
86 };
87
append_dn(void *ctx, const void *buf, size_t len)88 static void append_dn(void *ctx, const void *buf, size_t len)
89 {
90 struct cafile_parser *ca = ctx;
91
92 if(ca->err != CURLE_OK || !ca->in_cert)
93 return;
94 if(sizeof(ca->dn) - ca->dn_len < len) {
95 ca->err = CURLE_FAILED_INIT;
96 return;
97 }
98 memcpy(ca->dn + ca->dn_len, buf, len);
99 ca->dn_len += len;
100 }
101
x509_push(void *ctx, const void *buf, size_t len)102 static void x509_push(void *ctx, const void *buf, size_t len)
103 {
104 struct cafile_parser *ca = ctx;
105
106 if(ca->in_cert)
107 br_x509_decoder_push(&ca->xc, buf, len);
108 }
109
load_cafile(struct cafile_source *source, br_x509_trust_anchor **anchors, size_t *anchors_len)110 static CURLcode load_cafile(struct cafile_source *source,
111 br_x509_trust_anchor **anchors,
112 size_t *anchors_len)
113 {
114 struct cafile_parser ca;
115 br_pem_decoder_context pc;
116 br_x509_trust_anchor *ta;
117 size_t ta_size;
118 br_x509_trust_anchor *new_anchors;
119 size_t new_anchors_len;
120 br_x509_pkey *pkey;
121 FILE *fp = 0;
122 unsigned char buf[BUFSIZ];
123 const unsigned char *p;
124 const char *name;
125 size_t n, i, pushed;
126
127 DEBUGASSERT(source->type == CAFILE_SOURCE_PATH
128 || source->type == CAFILE_SOURCE_BLOB);
129
130 if(source->type == CAFILE_SOURCE_PATH) {
131 fp = fopen(source->data, "rb");
132 if(!fp)
133 return CURLE_SSL_CACERT_BADFILE;
134 }
135
136 if(source->type == CAFILE_SOURCE_BLOB && source->len > (size_t)INT_MAX)
137 return CURLE_SSL_CACERT_BADFILE;
138
139 ca.err = CURLE_OK;
140 ca.in_cert = FALSE;
141 ca.anchors = NULL;
142 ca.anchors_len = 0;
143 br_pem_decoder_init(&pc);
144 br_pem_decoder_setdest(&pc, x509_push, &ca);
145 do {
146 if(source->type == CAFILE_SOURCE_PATH) {
147 n = fread(buf, 1, sizeof(buf), fp);
148 if(n == 0)
149 break;
150 p = buf;
151 }
152 else if(source->type == CAFILE_SOURCE_BLOB) {
153 n = source->len;
154 p = (unsigned char *) source->data;
155 }
156 while(n) {
157 pushed = br_pem_decoder_push(&pc, p, n);
158 if(ca.err)
159 goto fail;
160 p += pushed;
161 n -= pushed;
162
163 switch(br_pem_decoder_event(&pc)) {
164 case 0:
165 break;
166 case BR_PEM_BEGIN_OBJ:
167 name = br_pem_decoder_name(&pc);
168 if(strcmp(name, "CERTIFICATE") && strcmp(name, "X509 CERTIFICATE"))
169 break;
170 br_x509_decoder_init(&ca.xc, append_dn, &ca);
171 ca.in_cert = TRUE;
172 ca.dn_len = 0;
173 break;
174 case BR_PEM_END_OBJ:
175 if(!ca.in_cert)
176 break;
177 ca.in_cert = FALSE;
178 if(br_x509_decoder_last_error(&ca.xc)) {
179 ca.err = CURLE_SSL_CACERT_BADFILE;
180 goto fail;
181 }
182 /* add trust anchor */
183 if(ca.anchors_len == SIZE_MAX / sizeof(ca.anchors[0])) {
184 ca.err = CURLE_OUT_OF_MEMORY;
185 goto fail;
186 }
187 new_anchors_len = ca.anchors_len + 1;
188 new_anchors = realloc(ca.anchors,
189 new_anchors_len * sizeof(ca.anchors[0]));
190 if(!new_anchors) {
191 ca.err = CURLE_OUT_OF_MEMORY;
192 goto fail;
193 }
194 ca.anchors = new_anchors;
195 ca.anchors_len = new_anchors_len;
196 ta = &ca.anchors[ca.anchors_len - 1];
197 ta->dn.data = NULL;
198 ta->flags = 0;
199 if(br_x509_decoder_isCA(&ca.xc))
200 ta->flags |= BR_X509_TA_CA;
201 pkey = br_x509_decoder_get_pkey(&ca.xc);
202 if(!pkey) {
203 ca.err = CURLE_SSL_CACERT_BADFILE;
204 goto fail;
205 }
206 ta->pkey = *pkey;
207
208 /* calculate space needed for trust anchor data */
209 ta_size = ca.dn_len;
210 switch(pkey->key_type) {
211 case BR_KEYTYPE_RSA:
212 ta_size += pkey->key.rsa.nlen + pkey->key.rsa.elen;
213 break;
214 case BR_KEYTYPE_EC:
215 ta_size += pkey->key.ec.qlen;
216 break;
217 default:
218 ca.err = CURLE_FAILED_INIT;
219 goto fail;
220 }
221
222 /* fill in trust anchor DN and public key data */
223 ta->dn.data = malloc(ta_size);
224 if(!ta->dn.data) {
225 ca.err = CURLE_OUT_OF_MEMORY;
226 goto fail;
227 }
228 memcpy(ta->dn.data, ca.dn, ca.dn_len);
229 ta->dn.len = ca.dn_len;
230 switch(pkey->key_type) {
231 case BR_KEYTYPE_RSA:
232 ta->pkey.key.rsa.n = ta->dn.data + ta->dn.len;
233 memcpy(ta->pkey.key.rsa.n, pkey->key.rsa.n, pkey->key.rsa.nlen);
234 ta->pkey.key.rsa.e = ta->pkey.key.rsa.n + ta->pkey.key.rsa.nlen;
235 memcpy(ta->pkey.key.rsa.e, pkey->key.rsa.e, pkey->key.rsa.elen);
236 break;
237 case BR_KEYTYPE_EC:
238 ta->pkey.key.ec.q = ta->dn.data + ta->dn.len;
239 memcpy(ta->pkey.key.ec.q, pkey->key.ec.q, pkey->key.ec.qlen);
240 break;
241 }
242 break;
243 default:
244 ca.err = CURLE_SSL_CACERT_BADFILE;
245 goto fail;
246 }
247 }
248 } while(source->type != CAFILE_SOURCE_BLOB);
249 if(fp && ferror(fp))
250 ca.err = CURLE_READ_ERROR;
251 else if(ca.in_cert)
252 ca.err = CURLE_SSL_CACERT_BADFILE;
253
254 fail:
255 if(fp)
256 fclose(fp);
257 if(ca.err == CURLE_OK) {
258 *anchors = ca.anchors;
259 *anchors_len = ca.anchors_len;
260 }
261 else {
262 for(i = 0; i < ca.anchors_len; ++i)
263 free(ca.anchors[i].dn.data);
264 free(ca.anchors);
265 }
266
267 return ca.err;
268 }
269
x509_start_chain(const br_x509_class **ctx, const char *server_name)270 static void x509_start_chain(const br_x509_class **ctx,
271 const char *server_name)
272 {
273 struct x509_context *x509 = (struct x509_context *)ctx;
274
275 if(!x509->verifypeer) {
276 x509->cert_num = 0;
277 return;
278 }
279
280 if(!x509->verifyhost)
281 server_name = NULL;
282 x509->minimal.vtable->start_chain(&x509->minimal.vtable, server_name);
283 }
284
x509_start_cert(const br_x509_class **ctx, uint32_t length)285 static void x509_start_cert(const br_x509_class **ctx, uint32_t length)
286 {
287 struct x509_context *x509 = (struct x509_context *)ctx;
288
289 if(!x509->verifypeer) {
290 /* Only decode the first cert in the chain to obtain the public key */
291 if(x509->cert_num == 0)
292 br_x509_decoder_init(&x509->decoder, NULL, NULL);
293 return;
294 }
295
296 x509->minimal.vtable->start_cert(&x509->minimal.vtable, length);
297 }
298
x509_append(const br_x509_class **ctx, const unsigned char *buf, size_t len)299 static void x509_append(const br_x509_class **ctx, const unsigned char *buf,
300 size_t len)
301 {
302 struct x509_context *x509 = (struct x509_context *)ctx;
303
304 if(!x509->verifypeer) {
305 if(x509->cert_num == 0)
306 br_x509_decoder_push(&x509->decoder, buf, len);
307 return;
308 }
309
310 x509->minimal.vtable->append(&x509->minimal.vtable, buf, len);
311 }
312
x509_end_cert(const br_x509_class **ctx)313 static void x509_end_cert(const br_x509_class **ctx)
314 {
315 struct x509_context *x509 = (struct x509_context *)ctx;
316
317 if(!x509->verifypeer) {
318 x509->cert_num++;
319 return;
320 }
321
322 x509->minimal.vtable->end_cert(&x509->minimal.vtable);
323 }
324
x509_end_chain(const br_x509_class **ctx)325 static unsigned x509_end_chain(const br_x509_class **ctx)
326 {
327 struct x509_context *x509 = (struct x509_context *)ctx;
328
329 if(!x509->verifypeer) {
330 return br_x509_decoder_last_error(&x509->decoder);
331 }
332
333 return x509->minimal.vtable->end_chain(&x509->minimal.vtable);
334 }
335
x509_get_pkey(const br_x509_class *const *ctx, unsigned *usages)336 static const br_x509_pkey *x509_get_pkey(const br_x509_class *const *ctx,
337 unsigned *usages)
338 {
339 struct x509_context *x509 = (struct x509_context *)ctx;
340
341 if(!x509->verifypeer) {
342 /* Nothing in the chain is verified, just return the public key of the
343 first certificate and allow its usage for both TLS_RSA_* and
344 TLS_ECDHE_* */
345 if(usages)
346 *usages = BR_KEYTYPE_KEYX | BR_KEYTYPE_SIGN;
347 return br_x509_decoder_get_pkey(&x509->decoder);
348 }
349
350 return x509->minimal.vtable->get_pkey(&x509->minimal.vtable, usages);
351 }
352
353 static const br_x509_class x509_vtable = {
354 sizeof(struct x509_context),
355 x509_start_chain,
356 x509_start_cert,
357 x509_append,
358 x509_end_cert,
359 x509_end_chain,
360 x509_get_pkey
361 };
362
363 struct st_cipher {
364 const char *name; /* Cipher suite IANA name. It starts with "TLS_" prefix */
365 const char *alias_name; /* Alias name is the same as OpenSSL cipher name */
366 uint16_t num; /* BearSSL cipher suite */
367 };
368
369 /* Macro to initialize st_cipher data structure */
370 #define CIPHER_DEF(num, alias) { #num, alias, BR_##num }
371
372 static const struct st_cipher ciphertable[] = {
373 /* RFC 2246 TLS 1.0 */
374 CIPHER_DEF(TLS_RSA_WITH_3DES_EDE_CBC_SHA, /* 0x000A */
375 "DES-CBC3-SHA"),
376
377 /* RFC 3268 TLS 1.0 AES */
378 CIPHER_DEF(TLS_RSA_WITH_AES_128_CBC_SHA, /* 0x002F */
379 "AES128-SHA"),
380 CIPHER_DEF(TLS_RSA_WITH_AES_256_CBC_SHA, /* 0x0035 */
381 "AES256-SHA"),
382
383 /* RFC 5246 TLS 1.2 */
384 CIPHER_DEF(TLS_RSA_WITH_AES_128_CBC_SHA256, /* 0x003C */
385 "AES128-SHA256"),
386 CIPHER_DEF(TLS_RSA_WITH_AES_256_CBC_SHA256, /* 0x003D */
387 "AES256-SHA256"),
388
389 /* RFC 5288 TLS 1.2 AES GCM */
390 CIPHER_DEF(TLS_RSA_WITH_AES_128_GCM_SHA256, /* 0x009C */
391 "AES128-GCM-SHA256"),
392 CIPHER_DEF(TLS_RSA_WITH_AES_256_GCM_SHA384, /* 0x009D */
393 "AES256-GCM-SHA384"),
394
395 /* RFC 4492 TLS 1.0 ECC */
396 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, /* 0xC003 */
397 "ECDH-ECDSA-DES-CBC3-SHA"),
398 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, /* 0xC004 */
399 "ECDH-ECDSA-AES128-SHA"),
400 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, /* 0xC005 */
401 "ECDH-ECDSA-AES256-SHA"),
402 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, /* 0xC008 */
403 "ECDHE-ECDSA-DES-CBC3-SHA"),
404 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, /* 0xC009 */
405 "ECDHE-ECDSA-AES128-SHA"),
406 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, /* 0xC00A */
407 "ECDHE-ECDSA-AES256-SHA"),
408 CIPHER_DEF(TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, /* 0xC00D */
409 "ECDH-RSA-DES-CBC3-SHA"),
410 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, /* 0xC00E */
411 "ECDH-RSA-AES128-SHA"),
412 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, /* 0xC00F */
413 "ECDH-RSA-AES256-SHA"),
414 CIPHER_DEF(TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, /* 0xC012 */
415 "ECDHE-RSA-DES-CBC3-SHA"),
416 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, /* 0xC013 */
417 "ECDHE-RSA-AES128-SHA"),
418 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, /* 0xC014 */
419 "ECDHE-RSA-AES256-SHA"),
420
421 /* RFC 5289 TLS 1.2 ECC HMAC SHA256/384 */
422 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, /* 0xC023 */
423 "ECDHE-ECDSA-AES128-SHA256"),
424 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, /* 0xC024 */
425 "ECDHE-ECDSA-AES256-SHA384"),
426 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, /* 0xC025 */
427 "ECDH-ECDSA-AES128-SHA256"),
428 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, /* 0xC026 */
429 "ECDH-ECDSA-AES256-SHA384"),
430 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, /* 0xC027 */
431 "ECDHE-RSA-AES128-SHA256"),
432 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, /* 0xC028 */
433 "ECDHE-RSA-AES256-SHA384"),
434 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, /* 0xC029 */
435 "ECDH-RSA-AES128-SHA256"),
436 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, /* 0xC02A */
437 "ECDH-RSA-AES256-SHA384"),
438
439 /* RFC 5289 TLS 1.2 GCM */
440 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, /* 0xC02B */
441 "ECDHE-ECDSA-AES128-GCM-SHA256"),
442 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, /* 0xC02C */
443 "ECDHE-ECDSA-AES256-GCM-SHA384"),
444 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, /* 0xC02D */
445 "ECDH-ECDSA-AES128-GCM-SHA256"),
446 CIPHER_DEF(TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, /* 0xC02E */
447 "ECDH-ECDSA-AES256-GCM-SHA384"),
448 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, /* 0xC02F */
449 "ECDHE-RSA-AES128-GCM-SHA256"),
450 CIPHER_DEF(TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, /* 0xC030 */
451 "ECDHE-RSA-AES256-GCM-SHA384"),
452 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, /* 0xC031 */
453 "ECDH-RSA-AES128-GCM-SHA256"),
454 CIPHER_DEF(TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, /* 0xC032 */
455 "ECDH-RSA-AES256-GCM-SHA384"),
456 #ifdef BR_TLS_RSA_WITH_AES_128_CCM
457
458 /* RFC 6655 TLS 1.2 CCM
459 Supported since BearSSL 0.6 */
460 CIPHER_DEF(TLS_RSA_WITH_AES_128_CCM, /* 0xC09C */
461 "AES128-CCM"),
462 CIPHER_DEF(TLS_RSA_WITH_AES_256_CCM, /* 0xC09D */
463 "AES256-CCM"),
464 CIPHER_DEF(TLS_RSA_WITH_AES_128_CCM_8, /* 0xC0A0 */
465 "AES128-CCM8"),
466 CIPHER_DEF(TLS_RSA_WITH_AES_256_CCM_8, /* 0xC0A1 */
467 "AES256-CCM8"),
468
469 /* RFC 7251 TLS 1.2 ECC CCM
470 Supported since BearSSL 0.6 */
471 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_128_CCM, /* 0xC0AC */
472 "ECDHE-ECDSA-AES128-CCM"),
473 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_256_CCM, /* 0xC0AD */
474 "ECDHE-ECDSA-AES256-CCM"),
475 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, /* 0xC0AE */
476 "ECDHE-ECDSA-AES128-CCM8"),
477 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8, /* 0xC0AF */
478 "ECDHE-ECDSA-AES256-CCM8"),
479 #endif
480
481 /* RFC 7905 TLS 1.2 ChaCha20-Poly1305
482 Supported since BearSSL 0.2 */
483 CIPHER_DEF(TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, /* 0xCCA8 */
484 "ECDHE-RSA-CHACHA20-POLY1305"),
485 CIPHER_DEF(TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, /* 0xCCA9 */
486 "ECDHE-ECDSA-CHACHA20-POLY1305"),
487 };
488
489 #define NUM_OF_CIPHERS (sizeof(ciphertable) / sizeof(ciphertable[0]))
490 #define CIPHER_NAME_BUF_LEN 64
491
is_separator(char c)492 static bool is_separator(char c)
493 {
494 /* Return whether character is a cipher list separator. */
495 switch(c) {
496 case ' ':
497 case '\t':
498 case ':':
499 case ',':
500 case ';':
501 return true;
502 }
503 return false;
504 }
505
bearssl_set_selected_ciphers(struct Curl_easy *data, br_ssl_engine_context *ssl_eng, const char *ciphers)506 static CURLcode bearssl_set_selected_ciphers(struct Curl_easy *data,
507 br_ssl_engine_context *ssl_eng,
508 const char *ciphers)
509 {
510 uint16_t selected_ciphers[NUM_OF_CIPHERS];
511 size_t selected_count = 0;
512 const char *cipher_start = ciphers;
513 const char *cipher_end;
514 size_t i, j;
515
516 if(!cipher_start)
517 return CURLE_SSL_CIPHER;
518
519 while(true) {
520 const char *cipher;
521 size_t clen;
522
523 /* Extract the next cipher name from the ciphers string */
524 while(is_separator(*cipher_start))
525 ++cipher_start;
526 if(!*cipher_start)
527 break;
528 cipher_end = cipher_start;
529 while(*cipher_end && !is_separator(*cipher_end))
530 ++cipher_end;
531
532 clen = cipher_end - cipher_start;
533 cipher = cipher_start;
534
535 cipher_start = cipher_end;
536
537 /* Lookup the cipher name in the table of available ciphers. If the cipher
538 name starts with "TLS_" we do the lookup by IANA name. Otherwise, we try
539 to match cipher name by an (OpenSSL) alias. */
540 if(strncasecompare(cipher, "TLS_", 4)) {
541 for(i = 0; i < NUM_OF_CIPHERS &&
542 (strlen(ciphertable[i].name) == clen) &&
543 !strncasecompare(cipher, ciphertable[i].name, clen); ++i);
544 }
545 else {
546 for(i = 0; i < NUM_OF_CIPHERS &&
547 (strlen(ciphertable[i].alias_name) == clen) &&
548 !strncasecompare(cipher, ciphertable[i].alias_name, clen); ++i);
549 }
550 if(i == NUM_OF_CIPHERS) {
551 infof(data, "BearSSL: unknown cipher in list: %.*s",
552 (int)clen, cipher);
553 continue;
554 }
555
556 /* No duplicates allowed */
557 for(j = 0; j < selected_count &&
558 selected_ciphers[j] != ciphertable[i].num; j++);
559 if(j < selected_count) {
560 infof(data, "BearSSL: duplicate cipher in list: %.*s",
561 (int)clen, cipher);
562 continue;
563 }
564
565 DEBUGASSERT(selected_count < NUM_OF_CIPHERS);
566 selected_ciphers[selected_count] = ciphertable[i].num;
567 ++selected_count;
568 }
569
570 if(selected_count == 0) {
571 failf(data, "BearSSL: no supported cipher in list");
572 return CURLE_SSL_CIPHER;
573 }
574
575 br_ssl_engine_set_suites(ssl_eng, selected_ciphers, selected_count);
576 return CURLE_OK;
577 }
578
bearssl_connect_step1(struct Curl_cfilter *cf, struct Curl_easy *data)579 static CURLcode bearssl_connect_step1(struct Curl_cfilter *cf,
580 struct Curl_easy *data)
581 {
582 struct ssl_connect_data *connssl = cf->ctx;
583 struct bearssl_ssl_backend_data *backend =
584 (struct bearssl_ssl_backend_data *)connssl->backend;
585 struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
586 struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
587 const struct curl_blob *ca_info_blob = conn_config->ca_info_blob;
588 const char * const ssl_cafile =
589 /* CURLOPT_CAINFO_BLOB overrides CURLOPT_CAINFO */
590 (ca_info_blob ? NULL : conn_config->CAfile);
591 const char *hostname = connssl->peer.hostname;
592 const bool verifypeer = conn_config->verifypeer;
593 const bool verifyhost = conn_config->verifyhost;
594 CURLcode ret;
595 unsigned version_min, version_max;
596 int session_set = 0;
597
598 DEBUGASSERT(backend);
599 CURL_TRC_CF(data, cf, "connect_step1");
600
601 switch(conn_config->version) {
602 case CURL_SSLVERSION_SSLv2:
603 failf(data, "BearSSL does not support SSLv2");
604 return CURLE_SSL_CONNECT_ERROR;
605 case CURL_SSLVERSION_SSLv3:
606 failf(data, "BearSSL does not support SSLv3");
607 return CURLE_SSL_CONNECT_ERROR;
608 case CURL_SSLVERSION_TLSv1_0:
609 version_min = BR_TLS10;
610 version_max = BR_TLS10;
611 break;
612 case CURL_SSLVERSION_TLSv1_1:
613 version_min = BR_TLS11;
614 version_max = BR_TLS11;
615 break;
616 case CURL_SSLVERSION_TLSv1_2:
617 version_min = BR_TLS12;
618 version_max = BR_TLS12;
619 break;
620 case CURL_SSLVERSION_DEFAULT:
621 case CURL_SSLVERSION_TLSv1:
622 version_min = BR_TLS10;
623 version_max = BR_TLS12;
624 break;
625 default:
626 failf(data, "BearSSL: unknown CURLOPT_SSLVERSION");
627 return CURLE_SSL_CONNECT_ERROR;
628 }
629
630 if(verifypeer) {
631 if(ca_info_blob) {
632 struct cafile_source source;
633 source.type = CAFILE_SOURCE_BLOB;
634 source.data = ca_info_blob->data;
635 source.len = ca_info_blob->len;
636
637 CURL_TRC_CF(data, cf, "connect_step1, load ca_info_blob");
638 ret = load_cafile(&source, &backend->anchors, &backend->anchors_len);
639 if(ret != CURLE_OK) {
640 failf(data, "error importing CA certificate blob");
641 return ret;
642 }
643 }
644
645 if(ssl_cafile) {
646 struct cafile_source source;
647 source.type = CAFILE_SOURCE_PATH;
648 source.data = ssl_cafile;
649 source.len = 0;
650
651 CURL_TRC_CF(data, cf, "connect_step1, load cafile");
652 ret = load_cafile(&source, &backend->anchors, &backend->anchors_len);
653 if(ret != CURLE_OK) {
654 failf(data, "error setting certificate verify locations."
655 " CAfile: %s", ssl_cafile);
656 return ret;
657 }
658 }
659 }
660
661 /* initialize SSL context */
662 br_ssl_client_init_full(&backend->ctx, &backend->x509.minimal,
663 backend->anchors, backend->anchors_len);
664 br_ssl_engine_set_versions(&backend->ctx.eng, version_min, version_max);
665 br_ssl_engine_set_buffer(&backend->ctx.eng, backend->buf,
666 sizeof(backend->buf), 1);
667
668 if(conn_config->cipher_list) {
669 /* Override the ciphers as specified. For the default cipher list see the
670 BearSSL source code of br_ssl_client_init_full() */
671 CURL_TRC_CF(data, cf, "connect_step1, set ciphers");
672 ret = bearssl_set_selected_ciphers(data, &backend->ctx.eng,
673 conn_config->cipher_list);
674 if(ret)
675 return ret;
676 }
677
678 /* initialize X.509 context */
679 backend->x509.vtable = &x509_vtable;
680 backend->x509.verifypeer = verifypeer;
681 backend->x509.verifyhost = verifyhost;
682 br_ssl_engine_set_x509(&backend->ctx.eng, &backend->x509.vtable);
683
684 if(ssl_config->primary.sessionid) {
685 void *session;
686
687 CURL_TRC_CF(data, cf, "connect_step1, check session cache");
688 Curl_ssl_sessionid_lock(data);
689 if(!Curl_ssl_getsessionid(cf, data, &session, NULL)) {
690 br_ssl_engine_set_session_parameters(&backend->ctx.eng, session);
691 session_set = 1;
692 infof(data, "BearSSL: reusing session ID");
693 }
694 Curl_ssl_sessionid_unlock(data);
695 }
696
697 if(connssl->alpn) {
698 struct alpn_proto_buf proto;
699 size_t i;
700
701 for(i = 0; i < connssl->alpn->count; ++i) {
702 backend->protocols[i] = connssl->alpn->entries[i];
703 }
704 br_ssl_engine_set_protocol_names(&backend->ctx.eng, backend->protocols,
705 connssl->alpn->count);
706 Curl_alpn_to_proto_str(&proto, connssl->alpn);
707 infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);
708 }
709
710 if(connssl->peer.is_ip_address) {
711 if(verifyhost) {
712 failf(data, "BearSSL: "
713 "host verification of IP address is not supported");
714 return CURLE_PEER_FAILED_VERIFICATION;
715 }
716 hostname = NULL;
717 }
718 else {
719 if(!connssl->peer.sni) {
720 failf(data, "Failed to set SNI");
721 return CURLE_SSL_CONNECT_ERROR;
722 }
723 hostname = connssl->peer.sni;
724 CURL_TRC_CF(data, cf, "connect_step1, SNI set");
725 }
726
727 /* give application a chance to interfere with SSL set up. */
728 if(data->set.ssl.fsslctx) {
729 Curl_set_in_callback(data, true);
730 ret = (*data->set.ssl.fsslctx)(data, &backend->ctx,
731 data->set.ssl.fsslctxp);
732 Curl_set_in_callback(data, false);
733 if(ret) {
734 failf(data, "BearSSL: error signaled by ssl ctx callback");
735 return ret;
736 }
737 }
738
739 if(!br_ssl_client_reset(&backend->ctx, hostname, session_set))
740 return CURLE_FAILED_INIT;
741 backend->active = TRUE;
742
743 connssl->connecting_state = ssl_connect_2;
744
745 return CURLE_OK;
746 }
747
bearssl_adjust_pollset(struct Curl_cfilter *cf, struct Curl_easy *data, struct easy_pollset *ps)748 static void bearssl_adjust_pollset(struct Curl_cfilter *cf,
749 struct Curl_easy *data,
750 struct easy_pollset *ps)
751 {
752 if(!cf->connected) {
753 curl_socket_t sock = Curl_conn_cf_get_socket(cf->next, data);
754 if(sock != CURL_SOCKET_BAD) {
755 struct ssl_connect_data *connssl = cf->ctx;
756 struct bearssl_ssl_backend_data *backend =
757 (struct bearssl_ssl_backend_data *)connssl->backend;
758 unsigned state = br_ssl_engine_current_state(&backend->ctx.eng);
759
760 if(state & BR_SSL_SENDREC) {
761 Curl_pollset_set_out_only(data, ps, sock);
762 }
763 else {
764 Curl_pollset_set_in_only(data, ps, sock);
765 }
766 }
767 }
768 }
769
bearssl_run_until(struct Curl_cfilter *cf, struct Curl_easy *data, unsigned target)770 static CURLcode bearssl_run_until(struct Curl_cfilter *cf,
771 struct Curl_easy *data,
772 unsigned target)
773 {
774 struct ssl_connect_data *connssl = cf->ctx;
775 struct bearssl_ssl_backend_data *backend =
776 (struct bearssl_ssl_backend_data *)connssl->backend;
777 unsigned state;
778 unsigned char *buf;
779 size_t len;
780 ssize_t ret;
781 CURLcode result;
782 int err;
783
784 DEBUGASSERT(backend);
785
786 for(;;) {
787 state = br_ssl_engine_current_state(&backend->ctx.eng);
788 if(state & BR_SSL_CLOSED) {
789 err = br_ssl_engine_last_error(&backend->ctx.eng);
790 switch(err) {
791 case BR_ERR_OK:
792 /* TLS close notify */
793 if(connssl->state != ssl_connection_complete) {
794 failf(data, "SSL: connection closed during handshake");
795 return CURLE_SSL_CONNECT_ERROR;
796 }
797 return CURLE_OK;
798 case BR_ERR_X509_EXPIRED:
799 failf(data, "SSL: X.509 verification: "
800 "certificate is expired or not yet valid");
801 return CURLE_PEER_FAILED_VERIFICATION;
802 case BR_ERR_X509_BAD_SERVER_NAME:
803 failf(data, "SSL: X.509 verification: "
804 "expected server name was not found in the chain");
805 return CURLE_PEER_FAILED_VERIFICATION;
806 case BR_ERR_X509_NOT_TRUSTED:
807 failf(data, "SSL: X.509 verification: "
808 "chain could not be linked to a trust anchor");
809 return CURLE_PEER_FAILED_VERIFICATION;
810 }
811 /* X.509 errors are documented to have the range 32..63 */
812 if(err >= 32 && err < 64)
813 return CURLE_PEER_FAILED_VERIFICATION;
814 return CURLE_SSL_CONNECT_ERROR;
815 }
816 if(state & target)
817 return CURLE_OK;
818 if(state & BR_SSL_SENDREC) {
819 buf = br_ssl_engine_sendrec_buf(&backend->ctx.eng, &len);
820 ret = Curl_conn_cf_send(cf->next, data, (char *)buf, len, &result);
821 CURL_TRC_CF(data, cf, "ssl_send(len=%zu) -> %zd, %d", len, ret, result);
822 if(ret <= 0) {
823 return result;
824 }
825 br_ssl_engine_sendrec_ack(&backend->ctx.eng, ret);
826 }
827 else if(state & BR_SSL_RECVREC) {
828 buf = br_ssl_engine_recvrec_buf(&backend->ctx.eng, &len);
829 ret = Curl_conn_cf_recv(cf->next, data, (char *)buf, len, &result);
830 CURL_TRC_CF(data, cf, "ssl_recv(len=%zu) -> %zd, %d", len, ret, result);
831 if(ret == 0) {
832 failf(data, "SSL: EOF without close notify");
833 return CURLE_READ_ERROR;
834 }
835 if(ret <= 0) {
836 return result;
837 }
838 br_ssl_engine_recvrec_ack(&backend->ctx.eng, ret);
839 }
840 }
841 }
842
bearssl_connect_step2(struct Curl_cfilter *cf, struct Curl_easy *data)843 static CURLcode bearssl_connect_step2(struct Curl_cfilter *cf,
844 struct Curl_easy *data)
845 {
846 struct ssl_connect_data *connssl = cf->ctx;
847 struct bearssl_ssl_backend_data *backend =
848 (struct bearssl_ssl_backend_data *)connssl->backend;
849 CURLcode ret;
850
851 DEBUGASSERT(backend);
852 CURL_TRC_CF(data, cf, "connect_step2");
853
854 ret = bearssl_run_until(cf, data, BR_SSL_SENDAPP | BR_SSL_RECVAPP);
855 if(ret == CURLE_AGAIN)
856 return CURLE_OK;
857 if(ret == CURLE_OK) {
858 unsigned int tver;
859 if(br_ssl_engine_current_state(&backend->ctx.eng) == BR_SSL_CLOSED) {
860 failf(data, "SSL: connection closed during handshake");
861 return CURLE_SSL_CONNECT_ERROR;
862 }
863 connssl->connecting_state = ssl_connect_3;
864 /* Informational message */
865 tver = br_ssl_engine_get_version(&backend->ctx.eng);
866 if(tver == 0x0303)
867 infof(data, "SSL connection using TLSv1.2");
868 else if(tver == 0x0304)
869 infof(data, "SSL connection using TLSv1.3");
870 else
871 infof(data, "SSL connection using TLS 0x%x", tver);
872 }
873 return ret;
874 }
875
bearssl_connect_step3(struct Curl_cfilter *cf, struct Curl_easy *data)876 static CURLcode bearssl_connect_step3(struct Curl_cfilter *cf,
877 struct Curl_easy *data)
878 {
879 struct ssl_connect_data *connssl = cf->ctx;
880 struct bearssl_ssl_backend_data *backend =
881 (struct bearssl_ssl_backend_data *)connssl->backend;
882 struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
883 CURLcode ret;
884
885 DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
886 DEBUGASSERT(backend);
887 CURL_TRC_CF(data, cf, "connect_step3");
888
889 if(connssl->alpn) {
890 const char *proto;
891
892 proto = br_ssl_engine_get_selected_protocol(&backend->ctx.eng);
893 Curl_alpn_set_negotiated(cf, data, (const unsigned char *)proto,
894 proto? strlen(proto) : 0);
895 }
896
897 if(ssl_config->primary.sessionid) {
898 bool incache;
899 bool added = FALSE;
900 void *oldsession;
901 br_ssl_session_parameters *session;
902
903 session = malloc(sizeof(*session));
904 if(!session)
905 return CURLE_OUT_OF_MEMORY;
906 br_ssl_engine_get_session_parameters(&backend->ctx.eng, session);
907 Curl_ssl_sessionid_lock(data);
908 incache = !(Curl_ssl_getsessionid(cf, data, &oldsession, NULL));
909 if(incache)
910 Curl_ssl_delsessionid(data, oldsession);
911 ret = Curl_ssl_addsessionid(cf, data, session, 0, &added);
912 Curl_ssl_sessionid_unlock(data);
913 if(!added)
914 free(session);
915 if(ret) {
916 return CURLE_OUT_OF_MEMORY;
917 }
918 }
919
920 connssl->connecting_state = ssl_connect_done;
921
922 return CURLE_OK;
923 }
924
bearssl_send(struct Curl_cfilter *cf, struct Curl_easy *data, const void *buf, size_t len, CURLcode *err)925 static ssize_t bearssl_send(struct Curl_cfilter *cf, struct Curl_easy *data,
926 const void *buf, size_t len, CURLcode *err)
927 {
928 struct ssl_connect_data *connssl = cf->ctx;
929 struct bearssl_ssl_backend_data *backend =
930 (struct bearssl_ssl_backend_data *)connssl->backend;
931 unsigned char *app;
932 size_t applen;
933
934 DEBUGASSERT(backend);
935
936 for(;;) {
937 *err = bearssl_run_until(cf, data, BR_SSL_SENDAPP);
938 if(*err)
939 return -1;
940 app = br_ssl_engine_sendapp_buf(&backend->ctx.eng, &applen);
941 if(!app) {
942 failf(data, "SSL: connection closed during write");
943 *err = CURLE_SEND_ERROR;
944 return -1;
945 }
946 if(backend->pending_write) {
947 applen = backend->pending_write;
948 backend->pending_write = 0;
949 return applen;
950 }
951 if(applen > len)
952 applen = len;
953 memcpy(app, buf, applen);
954 br_ssl_engine_sendapp_ack(&backend->ctx.eng, applen);
955 br_ssl_engine_flush(&backend->ctx.eng, 0);
956 backend->pending_write = applen;
957 }
958 }
959
bearssl_recv(struct Curl_cfilter *cf, struct Curl_easy *data, char *buf, size_t len, CURLcode *err)960 static ssize_t bearssl_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
961 char *buf, size_t len, CURLcode *err)
962 {
963 struct ssl_connect_data *connssl = cf->ctx;
964 struct bearssl_ssl_backend_data *backend =
965 (struct bearssl_ssl_backend_data *)connssl->backend;
966 unsigned char *app;
967 size_t applen;
968
969 DEBUGASSERT(backend);
970
971 *err = bearssl_run_until(cf, data, BR_SSL_RECVAPP);
972 if(*err != CURLE_OK)
973 return -1;
974 app = br_ssl_engine_recvapp_buf(&backend->ctx.eng, &applen);
975 if(!app)
976 return 0;
977 if(applen > len)
978 applen = len;
979 memcpy(buf, app, applen);
980 br_ssl_engine_recvapp_ack(&backend->ctx.eng, applen);
981
982 return applen;
983 }
984
bearssl_connect_common(struct Curl_cfilter *cf, struct Curl_easy *data, bool nonblocking, bool *done)985 static CURLcode bearssl_connect_common(struct Curl_cfilter *cf,
986 struct Curl_easy *data,
987 bool nonblocking,
988 bool *done)
989 {
990 CURLcode ret;
991 struct ssl_connect_data *connssl = cf->ctx;
992 curl_socket_t sockfd = Curl_conn_cf_get_socket(cf, data);
993 timediff_t timeout_ms;
994 int what;
995
996 CURL_TRC_CF(data, cf, "connect_common(blocking=%d)", !nonblocking);
997 /* check if the connection has already been established */
998 if(ssl_connection_complete == connssl->state) {
999 CURL_TRC_CF(data, cf, "connect_common, connected");
1000 *done = TRUE;
1001 return CURLE_OK;
1002 }
1003
1004 if(ssl_connect_1 == connssl->connecting_state) {
1005 ret = bearssl_connect_step1(cf, data);
1006 if(ret)
1007 return ret;
1008 }
1009
1010 while(ssl_connect_2 == connssl->connecting_state ||
1011 ssl_connect_2_reading == connssl->connecting_state ||
1012 ssl_connect_2_writing == connssl->connecting_state) {
1013 /* check allowed time left */
1014 timeout_ms = Curl_timeleft(data, NULL, TRUE);
1015
1016 if(timeout_ms < 0) {
1017 /* no need to continue if time already is up */
1018 failf(data, "SSL connection timeout");
1019 return CURLE_OPERATION_TIMEDOUT;
1020 }
1021
1022 /* if ssl is expecting something, check if it's available. */
1023 if(ssl_connect_2_reading == connssl->connecting_state ||
1024 ssl_connect_2_writing == connssl->connecting_state) {
1025
1026 curl_socket_t writefd = ssl_connect_2_writing ==
1027 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1028 curl_socket_t readfd = ssl_connect_2_reading ==
1029 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1030
1031 CURL_TRC_CF(data, cf, "connect_common, check socket");
1032 what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
1033 nonblocking?0:timeout_ms);
1034 CURL_TRC_CF(data, cf, "connect_common, check socket -> %d", what);
1035 if(what < 0) {
1036 /* fatal error */
1037 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
1038 return CURLE_SSL_CONNECT_ERROR;
1039 }
1040 else if(0 == what) {
1041 if(nonblocking) {
1042 *done = FALSE;
1043 return CURLE_OK;
1044 }
1045 else {
1046 /* timeout */
1047 failf(data, "SSL connection timeout");
1048 return CURLE_OPERATION_TIMEDOUT;
1049 }
1050 }
1051 /* socket is readable or writable */
1052 }
1053
1054 /* Run transaction, and return to the caller if it failed or if this
1055 * connection is done nonblocking and this loop would execute again. This
1056 * permits the owner of a multi handle to abort a connection attempt
1057 * before step2 has completed while ensuring that a client using select()
1058 * or epoll() will always have a valid fdset to wait on.
1059 */
1060 ret = bearssl_connect_step2(cf, data);
1061 if(ret || (nonblocking &&
1062 (ssl_connect_2 == connssl->connecting_state ||
1063 ssl_connect_2_reading == connssl->connecting_state ||
1064 ssl_connect_2_writing == connssl->connecting_state)))
1065 return ret;
1066 }
1067
1068 if(ssl_connect_3 == connssl->connecting_state) {
1069 ret = bearssl_connect_step3(cf, data);
1070 if(ret)
1071 return ret;
1072 }
1073
1074 if(ssl_connect_done == connssl->connecting_state) {
1075 connssl->state = ssl_connection_complete;
1076 *done = TRUE;
1077 }
1078 else
1079 *done = FALSE;
1080
1081 /* Reset our connect state machine */
1082 connssl->connecting_state = ssl_connect_1;
1083
1084 return CURLE_OK;
1085 }
1086
bearssl_version(char *buffer, size_t size)1087 static size_t bearssl_version(char *buffer, size_t size)
1088 {
1089 return msnprintf(buffer, size, "BearSSL");
1090 }
1091
bearssl_data_pending(struct Curl_cfilter *cf, const struct Curl_easy *data)1092 static bool bearssl_data_pending(struct Curl_cfilter *cf,
1093 const struct Curl_easy *data)
1094 {
1095 struct ssl_connect_data *ctx = cf->ctx;
1096 struct bearssl_ssl_backend_data *backend;
1097
1098 (void)data;
1099 DEBUGASSERT(ctx && ctx->backend);
1100 backend = (struct bearssl_ssl_backend_data *)ctx->backend;
1101 return br_ssl_engine_current_state(&backend->ctx.eng) & BR_SSL_RECVAPP;
1102 }
1103
bearssl_random(struct Curl_easy *data UNUSED_PARAM, unsigned char *entropy, size_t length)1104 static CURLcode bearssl_random(struct Curl_easy *data UNUSED_PARAM,
1105 unsigned char *entropy, size_t length)
1106 {
1107 static br_hmac_drbg_context ctx;
1108 static bool seeded = FALSE;
1109
1110 if(!seeded) {
1111 br_prng_seeder seeder;
1112
1113 br_hmac_drbg_init(&ctx, &br_sha256_vtable, NULL, 0);
1114 seeder = br_prng_seeder_system(NULL);
1115 if(!seeder || !seeder(&ctx.vtable))
1116 return CURLE_FAILED_INIT;
1117 seeded = TRUE;
1118 }
1119 br_hmac_drbg_generate(&ctx, entropy, length);
1120
1121 return CURLE_OK;
1122 }
1123
bearssl_connect(struct Curl_cfilter *cf, struct Curl_easy *data)1124 static CURLcode bearssl_connect(struct Curl_cfilter *cf,
1125 struct Curl_easy *data)
1126 {
1127 CURLcode ret;
1128 bool done = FALSE;
1129
1130 ret = bearssl_connect_common(cf, data, FALSE, &done);
1131 if(ret)
1132 return ret;
1133
1134 DEBUGASSERT(done);
1135
1136 return CURLE_OK;
1137 }
1138
bearssl_connect_nonblocking(struct Curl_cfilter *cf, struct Curl_easy *data, bool *done)1139 static CURLcode bearssl_connect_nonblocking(struct Curl_cfilter *cf,
1140 struct Curl_easy *data,
1141 bool *done)
1142 {
1143 return bearssl_connect_common(cf, data, TRUE, done);
1144 }
1145
bearssl_get_internals(struct ssl_connect_data *connssl, CURLINFO info UNUSED_PARAM)1146 static void *bearssl_get_internals(struct ssl_connect_data *connssl,
1147 CURLINFO info UNUSED_PARAM)
1148 {
1149 struct bearssl_ssl_backend_data *backend =
1150 (struct bearssl_ssl_backend_data *)connssl->backend;
1151 DEBUGASSERT(backend);
1152 return &backend->ctx;
1153 }
1154
bearssl_close(struct Curl_cfilter *cf, struct Curl_easy *data)1155 static void bearssl_close(struct Curl_cfilter *cf, struct Curl_easy *data)
1156 {
1157 struct ssl_connect_data *connssl = cf->ctx;
1158 struct bearssl_ssl_backend_data *backend =
1159 (struct bearssl_ssl_backend_data *)connssl->backend;
1160 size_t i;
1161
1162 DEBUGASSERT(backend);
1163
1164 if(backend->active) {
1165 backend->active = FALSE;
1166 br_ssl_engine_close(&backend->ctx.eng);
1167 (void)bearssl_run_until(cf, data, BR_SSL_CLOSED);
1168 }
1169 if(backend->anchors) {
1170 for(i = 0; i < backend->anchors_len; ++i)
1171 free(backend->anchors[i].dn.data);
1172 Curl_safefree(backend->anchors);
1173 }
1174 }
1175
bearssl_session_free(void *ptr)1176 static void bearssl_session_free(void *ptr)
1177 {
1178 free(ptr);
1179 }
1180
bearssl_sha256sum(const unsigned char *input, size_t inputlen, unsigned char *sha256sum, size_t sha256len UNUSED_PARAM)1181 static CURLcode bearssl_sha256sum(const unsigned char *input,
1182 size_t inputlen,
1183 unsigned char *sha256sum,
1184 size_t sha256len UNUSED_PARAM)
1185 {
1186 br_sha256_context ctx;
1187
1188 br_sha256_init(&ctx);
1189 br_sha256_update(&ctx, input, inputlen);
1190 br_sha256_out(&ctx, sha256sum);
1191 return CURLE_OK;
1192 }
1193
1194 const struct Curl_ssl Curl_ssl_bearssl = {
1195 { CURLSSLBACKEND_BEARSSL, "bearssl" }, /* info */
1196 SSLSUPP_CAINFO_BLOB | SSLSUPP_SSL_CTX | SSLSUPP_HTTPS_PROXY,
1197 sizeof(struct bearssl_ssl_backend_data),
1198
1199 Curl_none_init, /* init */
1200 Curl_none_cleanup, /* cleanup */
1201 bearssl_version, /* version */
1202 Curl_none_check_cxn, /* check_cxn */
1203 Curl_none_shutdown, /* shutdown */
1204 bearssl_data_pending, /* data_pending */
1205 bearssl_random, /* random */
1206 Curl_none_cert_status_request, /* cert_status_request */
1207 bearssl_connect, /* connect */
1208 bearssl_connect_nonblocking, /* connect_nonblocking */
1209 bearssl_adjust_pollset, /* adjust_pollset */
1210 bearssl_get_internals, /* get_internals */
1211 bearssl_close, /* close_one */
1212 Curl_none_close_all, /* close_all */
1213 bearssl_session_free, /* session_free */
1214 Curl_none_set_engine, /* set_engine */
1215 Curl_none_set_engine_default, /* set_engine_default */
1216 Curl_none_engines_list, /* engines_list */
1217 Curl_none_false_start, /* false_start */
1218 bearssl_sha256sum, /* sha256sum */
1219 NULL, /* associate_connection */
1220 NULL, /* disassociate_connection */
1221 NULL, /* free_multi_ssl_backend_data */
1222 bearssl_recv, /* recv decrypted data */
1223 bearssl_send, /* send data to encrypt */
1224 };
1225
1226 #endif /* USE_BEARSSL */
1227