Extra Makefile hack for compatibility with OpenBSD 'make'.
[BearSSL] / inc / bearssl_ssl.h
1 /*
2 * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 #ifndef BR_BEARSSL_SSL_H__
26 #define BR_BEARSSL_SSL_H__
27
28 #include <stddef.h>
29 #include <stdint.h>
30
31 #include "bearssl_block.h"
32 #include "bearssl_hash.h"
33 #include "bearssl_hmac.h"
34 #include "bearssl_prf.h"
35 #include "bearssl_rand.h"
36 #include "bearssl_x509.h"
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41
42 /** \file bearssl_ssl.h
43 *
44 * # SSL
45 *
46 * For an overview of the SSL/TLS API, see [the BearSSL Web
47 * site](https://www.bearssl.org/api1.html).
48 *
49 * The `BR_TLS_*` constants correspond to the standard cipher suites and
50 * their values in the [IANA
51 * registry](http://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-4).
52 *
53 * The `BR_ALERT_*` constants are for standard TLS alert messages. When
54 * a fatal alert message is sent of received, then the SSL engine context
55 * status is set to the sum of that alert value (an integer in the 0..255
56 * range) and a fixed offset (`BR_ERR_SEND_FATAL_ALERT` for a sent alert,
57 * `BR_ERR_RECV_FATAL_ALERT` for a received alert).
58 */
59
60 /** \brief Optimal input buffer size. */
61 #define BR_SSL_BUFSIZE_INPUT (16384 + 325)
62
63 /** \brief Optimal output buffer size. */
64 #define BR_SSL_BUFSIZE_OUTPUT (16384 + 85)
65
66 /** \brief Optimal buffer size for monodirectional engine
67 (shared input/output buffer). */
68 #define BR_SSL_BUFSIZE_MONO BR_SSL_BUFSIZE_INPUT
69
70 /** \brief Optimal buffer size for bidirectional engine
71 (single buffer split into two separate input/output buffers). */
72 #define BR_SSL_BUFSIZE_BIDI (BR_SSL_BUFSIZE_INPUT + BR_SSL_BUFSIZE_OUTPUT)
73
74 /*
75 * Constants for known SSL/TLS protocol versions (SSL 3.0, TLS 1.0, TLS 1.1
76 * and TLS 1.2). Note that though there is a constant for SSL 3.0, that
77 * protocol version is not actually supported.
78 */
79
80 /** \brief Protocol version: SSL 3.0 (unsupported). */
81 #define BR_SSL30 0x0300
82 /** \brief Protocol version: TLS 1.0. */
83 #define BR_TLS10 0x0301
84 /** \brief Protocol version: TLS 1.1. */
85 #define BR_TLS11 0x0302
86 /** \brief Protocol version: TLS 1.2. */
87 #define BR_TLS12 0x0303
88
89 /*
90 * Error constants. They are used to report the reason why a context has
91 * been marked as failed.
92 *
93 * Implementation note: SSL-level error codes should be in the 1..31
94 * range. The 32..63 range is for certificate decoding and validation
95 * errors. Received fatal alerts imply an error code in the 256..511 range.
96 */
97
98 /** \brief SSL status: no error so far (0). */
99 #define BR_ERR_OK 0
100
101 /** \brief SSL status: caller-provided parameter is incorrect. */
102 #define BR_ERR_BAD_PARAM 1
103
104 /** \brief SSL status: operation requested by the caller cannot be applied
105 with the current context state (e.g. reading data while outgoing data
106 is waiting to be sent). */
107 #define BR_ERR_BAD_STATE 2
108
109 /** \brief SSL status: incoming protocol or record version is unsupported. */
110 #define BR_ERR_UNSUPPORTED_VERSION 3
111
112 /** \brief SSL status: incoming record version does not match the expected
113 version. */
114 #define BR_ERR_BAD_VERSION 4
115
116 /** \brief SSL status: incoming record length is invalid. */
117 #define BR_ERR_BAD_LENGTH 5
118
119 /** \brief SSL status: incoming record is too large to be processed, or
120 buffer is too small for the handshake message to send. */
121 #define BR_ERR_TOO_LARGE 6
122
123 /** \brief SSL status: decryption found an invalid padding, or the record
124 MAC is not correct. */
125 #define BR_ERR_BAD_MAC 7
126
127 /** \brief SSL status: no initial entropy was provided, and none can be
128 obtained from the OS. */
129 #define BR_ERR_NO_RANDOM 8
130
131 /** \brief SSL status: incoming record type is unknown. */
132 #define BR_ERR_UNKNOWN_TYPE 9
133
134 /** \brief SSL status: incoming record or message has wrong type with
135 regards to the current engine state. */
136 #define BR_ERR_UNEXPECTED 10
137
138 /** \brief SSL status: ChangeCipherSpec message from the peer has invalid
139 contents. */
140 #define BR_ERR_BAD_CCS 12
141
142 /** \brief SSL status: alert message from the peer has invalid contents
143 (odd length). */
144 #define BR_ERR_BAD_ALERT 13
145
146 /** \brief SSL status: incoming handshake message decoding failed. */
147 #define BR_ERR_BAD_HANDSHAKE 14
148
149 /** \brief SSL status: ServerHello contains a session ID which is larger
150 than 32 bytes. */
151 #define BR_ERR_OVERSIZED_ID 15
152
153 /** \brief SSL status: server wants to use a cipher suite that we did
154 not claim to support. This is also reported if we tried to advertise
155 a cipher suite that we do not support. */
156 #define BR_ERR_BAD_CIPHER_SUITE 16
157
158 /** \brief SSL status: server wants to use a compression that we did not
159 claim to support. */
160 #define BR_ERR_BAD_COMPRESSION 17
161
162 /** \brief SSL status: server's max fragment length does not match
163 client's. */
164 #define BR_ERR_BAD_FRAGLEN 18
165
166 /** \brief SSL status: secure renegotiation failed. */
167 #define BR_ERR_BAD_SECRENEG 19
168
169 /** \brief SSL status: server sent an extension type that we did not
170 announce, or used the same extension type several times in a single
171 ServerHello. */
172 #define BR_ERR_EXTRA_EXTENSION 20
173
174 /** \brief SSL status: invalid Server Name Indication contents (when
175 used by the server, this extension shall be empty). */
176 #define BR_ERR_BAD_SNI 21
177
178 /** \brief SSL status: invalid ServerHelloDone from the server (length
179 is not 0). */
180 #define BR_ERR_BAD_HELLO_DONE 22
181
182 /** \brief SSL status: internal limit exceeded (e.g. server's public key
183 is too large). */
184 #define BR_ERR_LIMIT_EXCEEDED 23
185
186 /** \brief SSL status: Finished message from peer does not match the
187 expected value. */
188 #define BR_ERR_BAD_FINISHED 24
189
190 /** \brief SSL status: session resumption attempt with distinct version
191 or cipher suite. */
192 #define BR_ERR_RESUME_MISMATCH 25
193
194 /** \brief SSL status: unsupported or invalid algorithm (ECDHE curve,
195 signature algorithm, hash function). */
196 #define BR_ERR_INVALID_ALGORITHM 26
197
198 /** \brief SSL status: invalid signature (on ServerKeyExchange from
199 server, or in CertificateVerify from client). */
200 #define BR_ERR_BAD_SIGNATURE 27
201
202 /** \brief SSL status: peer's public key does not have the proper type
203 or is not allowed for requested operation. */
204 #define BR_ERR_WRONG_KEY_USAGE 28
205
206 /** \brief SSL status: client did not send a certificate upon request,
207 or the client certificate could not be validated. */
208 #define BR_ERR_NO_CLIENT_AUTH 29
209
210 /** \brief SSL status: I/O error or premature close on underlying
211 transport stream. This error code is set only by the simplified
212 I/O API ("br_sslio_*"). */
213 #define BR_ERR_IO 31
214
215 /** \brief SSL status: base value for a received fatal alert.
216
217 When a fatal alert is received from the peer, the alert value
218 is added to this constant. */
219 #define BR_ERR_RECV_FATAL_ALERT 256
220
221 /** \brief SSL status: base value for a sent fatal alert.
222
223 When a fatal alert is sent to the peer, the alert value is added
224 to this constant. */
225 #define BR_ERR_SEND_FATAL_ALERT 512
226
227 /* ===================================================================== */
228
229 /**
230 * \brief Decryption engine for SSL.
231 *
232 * When processing incoming records, the SSL engine will use a decryption
233 * engine that uses a specific context structure, and has a set of
234 * methods (a vtable) that follows this template.
235 *
236 * The decryption engine is responsible for applying decryption, verifying
237 * MAC, and keeping track of the record sequence number.
238 */
239 typedef struct br_sslrec_in_class_ br_sslrec_in_class;
240 struct br_sslrec_in_class_ {
241 /**
242 * \brief Context size (in bytes).
243 */
244 size_t context_size;
245
246 /**
247 * \brief Test validity of the incoming record length.
248 *
249 * This function returns 1 if the announced length for an
250 * incoming record is valid, 0 otherwise,
251 *
252 * \param ctx decryption engine context.
253 * \param record_len incoming record length.
254 * \return 1 of a valid length, 0 otherwise.
255 */
256 int (*check_length)(const br_sslrec_in_class *const *ctx,
257 size_t record_len);
258
259 /**
260 * \brief Decrypt the incoming record.
261 *
262 * This function may assume that the record length is valid
263 * (it has been previously tested with `check_length()`).
264 * Decryption is done in place; `*len` is updated with the
265 * cleartext length, and the address of the first plaintext
266 * byte is returned. If the record is correct but empty, then
267 * `*len` is set to 0 and a non-`NULL` pointer is returned.
268 *
269 * On decryption/MAC error, `NULL` is returned.
270 *
271 * \param ctx decryption engine context.
272 * \param record_type record type (23 for application data, etc).
273 * \param version record version.
274 * \param payload address of encrypted payload.
275 * \param len pointer to payload length (updated).
276 * \return pointer to plaintext, or `NULL` on error.
277 */
278 unsigned char *(*decrypt)(const br_sslrec_in_class **ctx,
279 int record_type, unsigned version,
280 void *payload, size_t *len);
281 };
282
283 /**
284 * \brief Encryption engine for SSL.
285 *
286 * When building outgoing records, the SSL engine will use an encryption
287 * engine that uses a specific context structure, and has a set of
288 * methods (a vtable) that follows this template.
289 *
290 * The encryption engine is responsible for applying encryption and MAC,
291 * and keeping track of the record sequence number.
292 */
293 typedef struct br_sslrec_out_class_ br_sslrec_out_class;
294 struct br_sslrec_out_class_ {
295 /**
296 * \brief Context size (in bytes).
297 */
298 size_t context_size;
299
300 /**
301 * \brief Compute maximum plaintext sizes and offsets.
302 *
303 * When this function is called, the `*start` and `*end`
304 * values contain offsets designating the free area in the
305 * outgoing buffer for plaintext data; that free area is
306 * preceded by a 5-byte space which will receive the record
307 * header.
308 *
309 * The `max_plaintext()` function is responsible for adjusting
310 * both `*start` and `*end` to make room for any record-specific
311 * header, MAC, padding, and possible split.
312 *
313 * \param ctx encryption engine context.
314 * \param start pointer to start of plaintext offset (updated).
315 * \param end pointer to start of plaintext offset (updated).
316 */
317 void (*max_plaintext)(const br_sslrec_out_class *const *ctx,
318 size_t *start, size_t *end);
319
320 /**
321 * \brief Perform record encryption.
322 *
323 * This function encrypts the record. The plaintext address and
324 * length are provided. Returned value is the start of the
325 * encrypted record (or sequence of records, if a split was
326 * performed), _including_ the 5-byte header, and `*len` is
327 * adjusted to the total size of the record(s), there again
328 * including the header(s).
329 *
330 * \param ctx decryption engine context.
331 * \param record_type record type (23 for application data, etc).
332 * \param version record version.
333 * \param plaintext address of plaintext.
334 * \param len pointer to plaintext length (updated).
335 * \return pointer to start of built record.
336 */
337 unsigned char *(*encrypt)(const br_sslrec_out_class **ctx,
338 int record_type, unsigned version,
339 void *plaintext, size_t *len);
340 };
341
342 /**
343 * \brief Context for a no-encryption engine.
344 *
345 * The no-encryption engine processes outgoing records during the initial
346 * handshake, before encryption is applied.
347 */
348 typedef struct {
349 /** \brief No-encryption engine vtable. */
350 const br_sslrec_out_class *vtable;
351 } br_sslrec_out_clear_context;
352
353 /** \brief Static, constant vtable for the no-encryption engine. */
354 extern const br_sslrec_out_class br_sslrec_out_clear_vtable;
355
356 /* ===================================================================== */
357
358 /**
359 * \brief Record decryption engine class, for CBC mode.
360 *
361 * This class type extends the decryption engine class with an
362 * initialisation method that receives the parameters needed
363 * for CBC processing: block cipher implementation, block cipher key,
364 * HMAC parameters (hash function, key, MAC length), and IV. If the
365 * IV is `NULL`, then a per-record IV will be used (TLS 1.1+).
366 */
367 typedef struct br_sslrec_in_cbc_class_ br_sslrec_in_cbc_class;
368 struct br_sslrec_in_cbc_class_ {
369 /**
370 * \brief Superclass, as first vtable field.
371 */
372 br_sslrec_in_class inner;
373
374 /**
375 * \brief Engine initialisation method.
376 *
377 * This method sets the vtable field in the context.
378 *
379 * \param ctx context to initialise.
380 * \param bc_impl block cipher implementation (CBC decryption).
381 * \param bc_key block cipher key.
382 * \param bc_key_len block cipher key length (in bytes).
383 * \param dig_impl hash function for HMAC.
384 * \param mac_key HMAC key.
385 * \param mac_key_len HMAC key length (in bytes).
386 * \param mac_out_len HMAC output length (in bytes).
387 * \param iv initial IV (or `NULL`).
388 */
389 void (*init)(const br_sslrec_in_cbc_class **ctx,
390 const br_block_cbcdec_class *bc_impl,
391 const void *bc_key, size_t bc_key_len,
392 const br_hash_class *dig_impl,
393 const void *mac_key, size_t mac_key_len, size_t mac_out_len,
394 const void *iv);
395 };
396
397 /**
398 * \brief Record encryption engine class, for CBC mode.
399 *
400 * This class type extends the encryption engine class with an
401 * initialisation method that receives the parameters needed
402 * for CBC processing: block cipher implementation, block cipher key,
403 * HMAC parameters (hash function, key, MAC length), and IV. If the
404 * IV is `NULL`, then a per-record IV will be used (TLS 1.1+).
405 */
406 typedef struct br_sslrec_out_cbc_class_ br_sslrec_out_cbc_class;
407 struct br_sslrec_out_cbc_class_ {
408 /**
409 * \brief Superclass, as first vtable field.
410 */
411 br_sslrec_out_class inner;
412
413 /**
414 * \brief Engine initialisation method.
415 *
416 * This method sets the vtable field in the context.
417 *
418 * \param ctx context to initialise.
419 * \param bc_impl block cipher implementation (CBC encryption).
420 * \param bc_key block cipher key.
421 * \param bc_key_len block cipher key length (in bytes).
422 * \param dig_impl hash function for HMAC.
423 * \param mac_key HMAC key.
424 * \param mac_key_len HMAC key length (in bytes).
425 * \param mac_out_len HMAC output length (in bytes).
426 * \param iv initial IV (or `NULL`).
427 */
428 void (*init)(const br_sslrec_out_cbc_class **ctx,
429 const br_block_cbcenc_class *bc_impl,
430 const void *bc_key, size_t bc_key_len,
431 const br_hash_class *dig_impl,
432 const void *mac_key, size_t mac_key_len, size_t mac_out_len,
433 const void *iv);
434 };
435
436 /**
437 * \brief Context structure for decrypting incoming records with
438 * CBC + HMAC.
439 *
440 * The first field points to the vtable. The other fields are opaque
441 * and shall not be accessed directly.
442 */
443 typedef struct {
444 /** \brief Pointer to vtable. */
445 const br_sslrec_in_cbc_class *vtable;
446 #ifndef BR_DOXYGEN_IGNORE
447 uint64_t seq;
448 union {
449 const br_block_cbcdec_class *vtable;
450 br_aes_gen_cbcdec_keys aes;
451 br_des_gen_cbcdec_keys des;
452 } bc;
453 br_hmac_key_context mac;
454 size_t mac_len;
455 unsigned char iv[16];
456 int explicit_IV;
457 #endif
458 } br_sslrec_in_cbc_context;
459
460 /**
461 * \brief Static, constant vtable for record decryption with CBC.
462 */
463 extern const br_sslrec_in_cbc_class br_sslrec_in_cbc_vtable;
464
465 /**
466 * \brief Context structure for encrypting outgoing records with
467 * CBC + HMAC.
468 *
469 * The first field points to the vtable. The other fields are opaque
470 * and shall not be accessed directly.
471 */
472 typedef struct {
473 /** \brief Pointer to vtable. */
474 const br_sslrec_out_cbc_class *vtable;
475 #ifndef BR_DOXYGEN_IGNORE
476 uint64_t seq;
477 union {
478 const br_block_cbcenc_class *vtable;
479 br_aes_gen_cbcenc_keys aes;
480 br_des_gen_cbcenc_keys des;
481 } bc;
482 br_hmac_key_context mac;
483 size_t mac_len;
484 unsigned char iv[16];
485 int explicit_IV;
486 #endif
487 } br_sslrec_out_cbc_context;
488
489 /**
490 * \brief Static, constant vtable for record encryption with CBC.
491 */
492 extern const br_sslrec_out_cbc_class br_sslrec_out_cbc_vtable;
493
494 /* ===================================================================== */
495
496 /**
497 * \brief Record decryption engine class, for GCM mode.
498 *
499 * This class type extends the decryption engine class with an
500 * initialisation method that receives the parameters needed
501 * for GCM processing: block cipher implementation, block cipher key,
502 * GHASH implementation, and 4-byte IV.
503 */
504 typedef struct br_sslrec_in_gcm_class_ br_sslrec_in_gcm_class;
505 struct br_sslrec_in_gcm_class_ {
506 /**
507 * \brief Superclass, as first vtable field.
508 */
509 br_sslrec_in_class inner;
510
511 /**
512 * \brief Engine initialisation method.
513 *
514 * This method sets the vtable field in the context.
515 *
516 * \param ctx context to initialise.
517 * \param bc_impl block cipher implementation (CTR).
518 * \param key block cipher key.
519 * \param key_len block cipher key length (in bytes).
520 * \param gh_impl GHASH implementation.
521 * \param iv static IV (4 bytes).
522 */
523 void (*init)(const br_sslrec_in_gcm_class **ctx,
524 const br_block_ctr_class *bc_impl,
525 const void *key, size_t key_len,
526 br_ghash gh_impl,
527 const void *iv);
528 };
529
530 /**
531 * \brief Record encryption engine class, for GCM mode.
532 *
533 * This class type extends the encryption engine class with an
534 * initialisation method that receives the parameters needed
535 * for GCM processing: block cipher implementation, block cipher key,
536 * GHASH implementation, and 4-byte IV.
537 */
538 typedef struct br_sslrec_out_gcm_class_ br_sslrec_out_gcm_class;
539 struct br_sslrec_out_gcm_class_ {
540 /**
541 * \brief Superclass, as first vtable field.
542 */
543 br_sslrec_out_class inner;
544
545 /**
546 * \brief Engine initialisation method.
547 *
548 * This method sets the vtable field in the context.
549 *
550 * \param ctx context to initialise.
551 * \param bc_impl block cipher implementation (CTR).
552 * \param key block cipher key.
553 * \param key_len block cipher key length (in bytes).
554 * \param gh_impl GHASH implementation.
555 * \param iv static IV (4 bytes).
556 */
557 void (*init)(const br_sslrec_out_gcm_class **ctx,
558 const br_block_ctr_class *bc_impl,
559 const void *key, size_t key_len,
560 br_ghash gh_impl,
561 const void *iv);
562 };
563
564 /**
565 * \brief Context structure for processing records with GCM.
566 *
567 * The same context structure is used for encrypting and decrypting.
568 *
569 * The first field points to the vtable. The other fields are opaque
570 * and shall not be accessed directly.
571 */
572 typedef struct {
573 /** \brief Pointer to vtable. */
574 union {
575 const void *gen;
576 const br_sslrec_in_gcm_class *in;
577 const br_sslrec_out_gcm_class *out;
578 } vtable;
579 #ifndef BR_DOXYGEN_IGNORE
580 uint64_t seq;
581 union {
582 const br_block_ctr_class *vtable;
583 br_aes_gen_ctr_keys aes;
584 } bc;
585 br_ghash gh;
586 unsigned char iv[4];
587 unsigned char h[16];
588 #endif
589 } br_sslrec_gcm_context;
590
591 /**
592 * \brief Static, constant vtable for record decryption with GCM.
593 */
594 extern const br_sslrec_in_gcm_class br_sslrec_in_gcm_vtable;
595
596 /**
597 * \brief Static, constant vtable for record encryption with GCM.
598 */
599 extern const br_sslrec_out_gcm_class br_sslrec_out_gcm_vtable;
600
601 /* ===================================================================== */
602
603 /**
604 * \brief Record decryption engine class, for ChaCha20+Poly1305.
605 *
606 * This class type extends the decryption engine class with an
607 * initialisation method that receives the parameters needed
608 * for ChaCha20+Poly1305 processing: ChaCha20 implementation,
609 * Poly1305 implementation, key, and 12-byte IV.
610 */
611 typedef struct br_sslrec_in_chapol_class_ br_sslrec_in_chapol_class;
612 struct br_sslrec_in_chapol_class_ {
613 /**
614 * \brief Superclass, as first vtable field.
615 */
616 br_sslrec_in_class inner;
617
618 /**
619 * \brief Engine initialisation method.
620 *
621 * This method sets the vtable field in the context.
622 *
623 * \param ctx context to initialise.
624 * \param ichacha ChaCha20 implementation.
625 * \param ipoly Poly1305 implementation.
626 * \param key secret key (32 bytes).
627 * \param iv static IV (12 bytes).
628 */
629 void (*init)(const br_sslrec_in_chapol_class **ctx,
630 br_chacha20_run ichacha,
631 br_poly1305_run ipoly,
632 const void *key, const void *iv);
633 };
634
635 /**
636 * \brief Record encryption engine class, for ChaCha20+Poly1305.
637 *
638 * This class type extends the encryption engine class with an
639 * initialisation method that receives the parameters needed
640 * for ChaCha20+Poly1305 processing: ChaCha20 implementation,
641 * Poly1305 implementation, key, and 12-byte IV.
642 */
643 typedef struct br_sslrec_out_chapol_class_ br_sslrec_out_chapol_class;
644 struct br_sslrec_out_chapol_class_ {
645 /**
646 * \brief Superclass, as first vtable field.
647 */
648 br_sslrec_out_class inner;
649
650 /**
651 * \brief Engine initialisation method.
652 *
653 * This method sets the vtable field in the context.
654 *
655 * \param ctx context to initialise.
656 * \param ichacha ChaCha20 implementation.
657 * \param ipoly Poly1305 implementation.
658 * \param key secret key (32 bytes).
659 * \param iv static IV (12 bytes).
660 */
661 void (*init)(const br_sslrec_out_chapol_class **ctx,
662 br_chacha20_run ichacha,
663 br_poly1305_run ipoly,
664 const void *key, const void *iv);
665 };
666
667 /**
668 * \brief Context structure for processing records with ChaCha20+Poly1305.
669 *
670 * The same context structure is used for encrypting and decrypting.
671 *
672 * The first field points to the vtable. The other fields are opaque
673 * and shall not be accessed directly.
674 */
675 typedef struct {
676 /** \brief Pointer to vtable. */
677 union {
678 const void *gen;
679 const br_sslrec_in_chapol_class *in;
680 const br_sslrec_out_chapol_class *out;
681 } vtable;
682 #ifndef BR_DOXYGEN_IGNORE
683 uint64_t seq;
684 unsigned char key[32];
685 unsigned char iv[12];
686 br_chacha20_run ichacha;
687 br_poly1305_run ipoly;
688 #endif
689 } br_sslrec_chapol_context;
690
691 /**
692 * \brief Static, constant vtable for record decryption with ChaCha20+Poly1305.
693 */
694 extern const br_sslrec_in_chapol_class br_sslrec_in_chapol_vtable;
695
696 /**
697 * \brief Static, constant vtable for record encryption with ChaCha20+Poly1305.
698 */
699 extern const br_sslrec_out_chapol_class br_sslrec_out_chapol_vtable;
700
701 /* ===================================================================== */
702
703 /**
704 * \brief Type for session parameters, to be saved for session resumption.
705 */
706 typedef struct {
707 /** \brief Session ID buffer. */
708 unsigned char session_id[32];
709 /** \brief Session ID length (in bytes, at most 32). */
710 unsigned char session_id_len;
711 /** \brief Protocol version. */
712 uint16_t version;
713 /** \brief Cipher suite. */
714 uint16_t cipher_suite;
715 /** \brief Master secret. */
716 unsigned char master_secret[48];
717 } br_ssl_session_parameters;
718
719 #ifndef BR_DOXYGEN_IGNORE
720 /*
721 * Maximum numnber of cipher suites supported by a client or server.
722 */
723 #define BR_MAX_CIPHER_SUITES 40
724 #endif
725
726 /**
727 * \brief Context structure for SSL engine.
728 *
729 * This strucuture is common to the client and server; both the client
730 * context (`br_ssl_client_context`) and the server context
731 * (`br_ssl_server_context`) include a `br_ssl_engine_context` as their
732 * first field.
733 *
734 * The engine context manages records, including alerts, closures, and
735 * transitions to new encryption/MAC algorithms. Processing of handshake
736 * records is delegated to externally provided code. This structure
737 * should not be used directly.
738 *
739 * Structure contents are opaque and shall not be accessed directly.
740 */
741 typedef struct {
742 #ifndef BR_DOXYGEN_IGNORE
743 /*
744 * The error code. When non-zero, then the state is "failed" and
745 * no I/O may occur until reset.
746 */
747 int err;
748
749 /*
750 * Configured I/O buffers. They are either disjoint, or identical.
751 */
752 unsigned char *ibuf, *obuf;
753 size_t ibuf_len, obuf_len;
754
755 /*
756 * Maximum fragment length applies to outgoing records; incoming
757 * records can be processed as long as they fit in the input
758 * buffer. It is guaranteed that incoming records at least as big
759 * as max_frag_len can be processed.
760 */
761 uint16_t max_frag_len;
762 unsigned char log_max_frag_len;
763 unsigned char peer_log_max_frag_len;
764
765 /*
766 * Buffering management registers.
767 */
768 size_t ixa, ixb, ixc;
769 size_t oxa, oxb, oxc;
770 unsigned char iomode;
771 unsigned char incrypt;
772
773 /*
774 * Shutdown flag: when set to non-zero, incoming record bytes
775 * will not be accepted anymore. This is used after a close_notify
776 * has been received: afterwards, the engine no longer claims that
777 * it could receive bytes from the transport medium.
778 */
779 unsigned char shutdown_recv;
780
781 /*
782 * 'record_type_in' is set to the incoming record type when the
783 * record header has been received.
784 * 'record_type_out' is used to make the next outgoing record
785 * header when it is ready to go.
786 */
787 unsigned char record_type_in, record_type_out;
788
789 /*
790 * When a record is received, its version is extracted:
791 * -- if 'version_in' is 0, then it is set to the received version;
792 * -- otherwise, if the received version is not identical to
793 * the 'version_in' contents, then a failure is reported.
794 *
795 * This implements the SSL requirement that all records shall
796 * use the negotiated protocol version, once decided (in the
797 * ServerHello). It is up to the handshake handler to adjust this
798 * field when necessary.
799 */
800 uint16_t version_in;
801
802 /*
803 * 'version_out' is used when the next outgoing record is ready
804 * to go.
805 */
806 uint16_t version_out;
807
808 /*
809 * Record handler contexts.
810 */
811 union {
812 const br_sslrec_in_class *vtable;
813 br_sslrec_in_cbc_context cbc;
814 br_sslrec_gcm_context gcm;
815 br_sslrec_chapol_context chapol;
816 } in;
817 union {
818 const br_sslrec_out_class *vtable;
819 br_sslrec_out_clear_context clear;
820 br_sslrec_out_cbc_context cbc;
821 br_sslrec_gcm_context gcm;
822 br_sslrec_chapol_context chapol;
823 } out;
824
825 /*
826 * The "application data" flag. Value:
827 * 0 handshake is in process, no application data acceptable
828 * 1 application data can be sent and received
829 * 2 closing, no application data can be sent, but some
830 * can still be received (and discarded)
831 */
832 unsigned char application_data;
833
834 /*
835 * Context RNG.
836 */
837 br_hmac_drbg_context rng;
838 int rng_init_done;
839 int rng_os_rand_done;
840
841 /*
842 * Supported minimum and maximum versions, and cipher suites.
843 */
844 uint16_t version_min;
845 uint16_t version_max;
846 uint16_t suites_buf[BR_MAX_CIPHER_SUITES];
847 unsigned char suites_num;
848
849 /*
850 * For clients, the server name to send as a SNI extension. For
851 * servers, the name received in the SNI extension (if any).
852 */
853 char server_name[256];
854
855 /*
856 * "Security parameters". These are filled by the handshake
857 * handler, and used when switching encryption state.
858 */
859 unsigned char client_random[32];
860 unsigned char server_random[32];
861 br_ssl_session_parameters session;
862
863 /*
864 * ECDHE elements: curve and point from the peer. The server also
865 * uses that buffer for the point to send to the client.
866 */
867 unsigned char ecdhe_curve;
868 unsigned char ecdhe_point[133];
869 unsigned char ecdhe_point_len;
870
871 /*
872 * Secure renegotiation (RFC 5746): 'reneg' can be:
873 * 0 first handshake (server support is not known)
874 * 1 peer does not support secure renegotiation
875 * 2 peer supports secure renegotiation
876 *
877 * The saved_finished buffer contains the client and the
878 * server "Finished" values from the last handshake, in
879 * that order (12 bytes each).
880 */
881 unsigned char reneg;
882 unsigned char saved_finished[24];
883
884 /*
885 * Behavioural flags.
886 */
887 uint32_t flags;
888
889 /*
890 * Context variables for the handshake processor. The 'pad' must
891 * be large enough to accommodate an RSA-encrypted pre-master
892 * secret, or an RSA signature; since we want to support up to
893 * RSA-4096, this means at least 512 bytes. (Other pad usages
894 * require its length to be at least 256.)
895 */
896 struct {
897 uint32_t *dp;
898 uint32_t *rp;
899 const unsigned char *ip;
900 } cpu;
901 uint32_t dp_stack[32];
902 uint32_t rp_stack[32];
903 unsigned char pad[512];
904 unsigned char *hbuf_in, *hbuf_out, *saved_hbuf_out;
905 size_t hlen_in, hlen_out;
906 void (*hsrun)(void *ctx);
907
908 /*
909 * The 'action' value communicates OOB information between the
910 * engine and the handshake processor.
911 *
912 * From the engine:
913 * 0 invocation triggered by I/O
914 * 1 invocation triggered by explicit close
915 * 2 invocation triggered by explicit renegotiation
916 */
917 unsigned char action;
918
919 /*
920 * State for alert messages. Value is either 0, or the value of
921 * the alert level byte (level is either 1 for warning, or 2 for
922 * fatal; we convert all other values to 'fatal').
923 */
924 unsigned char alert;
925
926 /*
927 * Closure flags. This flag is set when a close_notify has been
928 * received from the peer.
929 */
930 unsigned char close_received;
931
932 /*
933 * Multi-hasher for the handshake messages. The handshake handler
934 * is responsible for resetting it when appropriate.
935 */
936 br_multihash_context mhash;
937
938 /*
939 * Pointer to the X.509 engine. The engine is supposed to be
940 * already initialized. It is used to validate the peer's
941 * certificate.
942 */
943 const br_x509_class **x509ctx;
944
945 /*
946 * Certificate chain to send. This is used by both client and
947 * server, when they send their respective Certificate messages.
948 * If chain_len is 0, then chain may be NULL.
949 */
950 const br_x509_certificate *chain;
951 size_t chain_len;
952 const unsigned char *cert_cur;
953 size_t cert_len;
954
955 /*
956 * List of supported protocol names (ALPN extension). If unset,
957 * (number of names is 0), then:
958 * - the client sends no ALPN extension;
959 * - the server ignores any incoming ALPN extension.
960 *
961 * Otherwise:
962 * - the client sends an ALPN extension with all the names;
963 * - the server selects the first protocol in its list that
964 * the client also supports, or fails (fatal alert 120)
965 * if the client sends an ALPN extension and there is no
966 * match.
967 *
968 * The 'selected_protocol' field contains 1+n if the matching
969 * name has index n in the list (the value is 0 if no match was
970 * performed, e.g. the peer did not send an ALPN extension).
971 */
972 const char **protocol_names;
973 uint16_t protocol_names_num;
974 uint16_t selected_protocol;
975
976 /*
977 * Pointers to implementations; left to NULL for unsupported
978 * functions. For the raw hash functions, implementations are
979 * referenced from the multihasher (mhash field).
980 */
981 br_tls_prf_impl prf10;
982 br_tls_prf_impl prf_sha256;
983 br_tls_prf_impl prf_sha384;
984 const br_block_cbcenc_class *iaes_cbcenc;
985 const br_block_cbcdec_class *iaes_cbcdec;
986 const br_block_ctr_class *iaes_ctr;
987 const br_block_cbcenc_class *ides_cbcenc;
988 const br_block_cbcdec_class *ides_cbcdec;
989 br_ghash ighash;
990 br_chacha20_run ichacha;
991 br_poly1305_run ipoly;
992 const br_sslrec_in_cbc_class *icbc_in;
993 const br_sslrec_out_cbc_class *icbc_out;
994 const br_sslrec_in_gcm_class *igcm_in;
995 const br_sslrec_out_gcm_class *igcm_out;
996 const br_sslrec_in_chapol_class *ichapol_in;
997 const br_sslrec_out_chapol_class *ichapol_out;
998 const br_ec_impl *iec;
999 br_rsa_pkcs1_vrfy irsavrfy;
1000 br_ecdsa_vrfy iecdsa;
1001 #endif
1002 } br_ssl_engine_context;
1003
1004 /**
1005 * \brief Get currently defined engine behavioural flags.
1006 *
1007 * \param cc SSL engine context.
1008 * \return the flags.
1009 */
1010 static inline uint32_t
1011 br_ssl_engine_get_flags(br_ssl_engine_context *cc)
1012 {
1013 return cc->flags;
1014 }
1015
1016 /**
1017 * \brief Set all engine behavioural flags.
1018 *
1019 * \param cc SSL engine context.
1020 * \param flags new value for all flags.
1021 */
1022 static inline void
1023 br_ssl_engine_set_all_flags(br_ssl_engine_context *cc, uint32_t flags)
1024 {
1025 cc->flags = flags;
1026 }
1027
1028 /**
1029 * \brief Set some engine behavioural flags.
1030 *
1031 * The flags set in the `flags` parameter are set in the context; other
1032 * flags are untouched.
1033 *
1034 * \param cc SSL engine context.
1035 * \param flags additional set flags.
1036 */
1037 static inline void
1038 br_ssl_engine_add_flags(br_ssl_engine_context *cc, uint32_t flags)
1039 {
1040 cc->flags |= flags;
1041 }
1042
1043 /**
1044 * \brief Clear some engine behavioural flags.
1045 *
1046 * The flags set in the `flags` parameter are cleared from the context; other
1047 * flags are untouched.
1048 *
1049 * \param cc SSL engine context.
1050 * \param flags flags to remove.
1051 */
1052 static inline void
1053 br_ssl_engine_remove_flags(br_ssl_engine_context *cc, uint32_t flags)
1054 {
1055 cc->flags &= ~flags;
1056 }
1057
1058 /**
1059 * \brief Behavioural flag: enforce server preferences.
1060 *
1061 * If this flag is set, then the server will enforce its own cipher suite
1062 * preference order; otherwise, it follows the client preferences.
1063 */
1064 #define BR_OPT_ENFORCE_SERVER_PREFERENCES ((uint32_t)1 << 0)
1065
1066 /**
1067 * \brief Behavioural flag: disable renegotiation.
1068 *
1069 * If this flag is set, then renegotiations are rejected unconditionally:
1070 * they won't be honoured if asked for programmatically, and requests from
1071 * the peer are rejected.
1072 */
1073 #define BR_OPT_NO_RENEGOTIATION ((uint32_t)1 << 1)
1074
1075 /**
1076 * \brief Behavioural flag: tolerate lack of client authentication.
1077 *
1078 * If this flag is set in a server and the server requests a client
1079 * certificate, but the authentication fails (the client does not send
1080 * a certificate, or the client's certificate chain cannot be validated),
1081 * then the connection keeps on. Without this flag, a failed client
1082 * authentication terminates the connection.
1083 *
1084 * Notes:
1085 *
1086 * - If the client's certificate can be validated and its public key is
1087 * supported, then a wrong signature value terminates the connection
1088 * regardless of that flag.
1089 *
1090 * - If using full-static ECDH, then a failure to validate the client's
1091 * certificate prevents the handshake from succeeding.
1092 */
1093 #define BR_OPT_TOLERATE_NO_CLIENT_AUTH ((uint32_t)1 << 2)
1094
1095 /**
1096 * \brief Behavioural flag: fail on application protocol mismatch.
1097 *
1098 * The ALPN extension ([RFC 7301](https://tools.ietf.org/html/rfc7301))
1099 * allows the client to send a list of application protocol names, and
1100 * the server to select one. A mismatch is one of the following occurrences:
1101 *
1102 * - On the client: the client sends a list of names, the server
1103 * responds with a protocol name which is _not_ part of the list of
1104 * names sent by the client.
1105 *
1106 * - On the server: the client sends a list of names, and the server
1107 * is also configured with a list of names, but there is no common
1108 * protocol name between the two lists.
1109 *
1110 * Normal behaviour in case of mismatch is to report no matching name
1111 * (`br_ssl_engine_get_selected_protocol()` returns `NULL`) and carry on.
1112 * If the flag is set, then a mismatch implies a protocol failure (if
1113 * the mismatch is detected by the server, it will send a fatal alert).
1114 *
1115 * Note: even with this flag, `br_ssl_engine_get_selected_protocol()`
1116 * may still return `NULL` if the client or the server does not send an
1117 * ALPN extension at all.
1118 */
1119 #define BR_OPT_FAIL_ON_ALPN_MISMATCH ((uint32_t)1 << 3)
1120
1121 /**
1122 * \brief Set the minimum and maximum supported protocol versions.
1123 *
1124 * The two provided versions MUST be supported by the implementation
1125 * (i.e. TLS 1.0, 1.1 and 1.2), and `version_max` MUST NOT be lower
1126 * than `version_min`.
1127 *
1128 * \param cc SSL engine context.
1129 * \param version_min minimum supported TLS version.
1130 * \param version_max maximum supported TLS version.
1131 */
1132 static inline void
1133 br_ssl_engine_set_versions(br_ssl_engine_context *cc,
1134 unsigned version_min, unsigned version_max)
1135 {
1136 cc->version_min = version_min;
1137 cc->version_max = version_max;
1138 }
1139
1140 /**
1141 * \brief Set the list of cipher suites advertised by this context.
1142 *
1143 * The provided array is copied into the context. It is the caller
1144 * responsibility to ensure that all provided suites will be supported
1145 * by the context. The engine context has enough room to receive _all_
1146 * suites supported by the implementation. The provided array MUST NOT
1147 * contain duplicates.
1148 *
1149 * If the engine is for a client, the "signaling" pseudo-cipher suite
1150 * `TLS_FALLBACK_SCSV` can be added at the end of the list, if the
1151 * calling application is performing a voluntary downgrade (voluntary
1152 * downgrades are not recommended, but if such a downgrade is done, then
1153 * adding the fallback pseudo-suite is a good idea).
1154 *
1155 * \param cc SSL engine context.
1156 * \param suites cipher suites.
1157 * \param suites_num number of cipher suites.
1158 */
1159 void br_ssl_engine_set_suites(br_ssl_engine_context *cc,
1160 const uint16_t *suites, size_t suites_num);
1161
1162 /**
1163 * \brief Set the X.509 engine.
1164 *
1165 * The caller shall ensure that the X.509 engine is properly initialised.
1166 *
1167 * \param cc SSL engine context.
1168 * \param x509ctx X.509 certificate validation context.
1169 */
1170 static inline void
1171 br_ssl_engine_set_x509(br_ssl_engine_context *cc, const br_x509_class **x509ctx)
1172 {
1173 cc->x509ctx = x509ctx;
1174 }
1175
1176 /**
1177 * \brief Set the supported protocol names.
1178 *
1179 * Protocol names are part of the ALPN extension ([RFC
1180 * 7301](https://tools.ietf.org/html/rfc7301)). Each protocol name is a
1181 * character string, containing no more than 255 characters (256 with the
1182 * terminating zero). When names are set, then:
1183 *
1184 * - The client will send an ALPN extension, containing the names. If
1185 * the server responds with an ALPN extension, the client will verify
1186 * that the response contains one of its name, and report that name
1187 * through `br_ssl_engine_get_selected_protocol()`.
1188 *
1189 * - The server will parse incoming ALPN extension (from clients), and
1190 * try to find a common protocol; if none is found, the connection
1191 * is aborted with a fatal alert. On match, a response ALPN extension
1192 * is sent, and name is reported through
1193 * `br_ssl_engine_get_selected_protocol()`.
1194 *
1195 * The provided array is linked in, and must remain valid while the
1196 * connection is live.
1197 *
1198 * Names MUST NOT be empty. Names MUST NOT be longer than 255 characters
1199 * (excluding the terminating 0).
1200 *
1201 * \param ctx SSL engine context.
1202 * \param names list of protocol names (zero-terminated).
1203 * \param num number of protocol names (MUST be 1 or more).
1204 */
1205 static inline void
1206 br_ssl_engine_set_protocol_names(br_ssl_engine_context *ctx,
1207 const char **names, size_t num)
1208 {
1209 ctx->protocol_names = names;
1210 ctx->protocol_names_num = num;
1211 }
1212
1213 /**
1214 * \brief Get the selected protocol.
1215 *
1216 * If this context was initialised with a non-empty list of protocol
1217 * names, and both client and server sent ALPN extensions during the
1218 * handshake, and a common name was found, then that name is returned.
1219 * Otherwise, `NULL` is returned.
1220 *
1221 * The returned pointer is one of the pointers provided to the context
1222 * with `br_ssl_engine_set_protocol_names()`.
1223 *
1224 * \return the selected protocol, or `NULL`.
1225 */
1226 static inline const char *
1227 br_ssl_engine_get_selected_protocol(br_ssl_engine_context *ctx)
1228 {
1229 unsigned k;
1230
1231 k = ctx->selected_protocol;
1232 return (k == 0 || k == 0xFFFF) ? NULL : ctx->protocol_names[k - 1];
1233 }
1234
1235 /**
1236 * \brief Set a hash function implementation (by ID).
1237 *
1238 * Hash functions set with this call will be used for SSL/TLS specific
1239 * usages, not X.509 certificate validation. Only "standard" hash functions
1240 * may be set (MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512). If `impl`
1241 * is `NULL`, then the hash function support is removed, not added.
1242 *
1243 * \param ctx SSL engine context.
1244 * \param id hash function identifier.
1245 * \param impl hash function implementation (or `NULL`).
1246 */
1247 static inline void
1248 br_ssl_engine_set_hash(br_ssl_engine_context *ctx,
1249 int id, const br_hash_class *impl)
1250 {
1251 br_multihash_setimpl(&ctx->mhash, id, impl);
1252 }
1253
1254 /**
1255 * \brief Get a hash function implementation (by ID).
1256 *
1257 * This function retrieves a hash function implementation which was
1258 * set with `br_ssl_engine_set_hash()`.
1259 *
1260 * \param ctx SSL engine context.
1261 * \param id hash function identifier.
1262 * \return the hash function implementation (or `NULL`).
1263 */
1264 static inline const br_hash_class *
1265 br_ssl_engine_get_hash(br_ssl_engine_context *ctx, int id)
1266 {
1267 return br_multihash_getimpl(&ctx->mhash, id);
1268 }
1269
1270 /**
1271 * \brief Set the PRF implementation (for TLS 1.0 and 1.1).
1272 *
1273 * This function sets (or removes, if `impl` is `NULL`) the implemenation
1274 * for the PRF used in TLS 1.0 and 1.1.
1275 *
1276 * \param cc SSL engine context.
1277 * \param impl PRF implementation (or `NULL`).
1278 */
1279 static inline void
1280 br_ssl_engine_set_prf10(br_ssl_engine_context *cc, br_tls_prf_impl impl)
1281 {
1282 cc->prf10 = impl;
1283 }
1284
1285 /**
1286 * \brief Set the PRF implementation with SHA-256 (for TLS 1.2).
1287 *
1288 * This function sets (or removes, if `impl` is `NULL`) the implemenation
1289 * for the SHA-256 variant of the PRF used in TLS 1.2.
1290 *
1291 * \param cc SSL engine context.
1292 * \param impl PRF implementation (or `NULL`).
1293 */
1294 static inline void
1295 br_ssl_engine_set_prf_sha256(br_ssl_engine_context *cc, br_tls_prf_impl impl)
1296 {
1297 cc->prf_sha256 = impl;
1298 }
1299
1300 /**
1301 * \brief Set the PRF implementation with SHA-384 (for TLS 1.2).
1302 *
1303 * This function sets (or removes, if `impl` is `NULL`) the implemenation
1304 * for the SHA-384 variant of the PRF used in TLS 1.2.
1305 *
1306 * \param cc SSL engine context.
1307 * \param impl PRF implementation (or `NULL`).
1308 */
1309 static inline void
1310 br_ssl_engine_set_prf_sha384(br_ssl_engine_context *cc, br_tls_prf_impl impl)
1311 {
1312 cc->prf_sha384 = impl;
1313 }
1314
1315 /**
1316 * \brief Set the AES/CBC implementations.
1317 *
1318 * \param cc SSL engine context.
1319 * \param impl_enc AES/CBC encryption implementation (or `NULL`).
1320 * \param impl_dec AES/CBC decryption implementation (or `NULL`).
1321 */
1322 static inline void
1323 br_ssl_engine_set_aes_cbc(br_ssl_engine_context *cc,
1324 const br_block_cbcenc_class *impl_enc,
1325 const br_block_cbcdec_class *impl_dec)
1326 {
1327 cc->iaes_cbcenc = impl_enc;
1328 cc->iaes_cbcdec = impl_dec;
1329 }
1330
1331 /**
1332 * \brief Set the "default" AES/CBC implementations.
1333 *
1334 * This function configures in the engine the AES implementations that
1335 * should provide best runtime performance on the local system, while
1336 * still being safe (in particular, constant-time). It also sets the
1337 * handlers for CBC records.
1338 *
1339 * \param cc SSL engine context.
1340 */
1341 void br_ssl_engine_set_default_aes_cbc(br_ssl_engine_context *cc);
1342
1343 /**
1344 * \brief Set the AES/CTR implementation.
1345 *
1346 * \param cc SSL engine context.
1347 * \param impl AES/CTR encryption/decryption implementation (or `NULL`).
1348 */
1349 static inline void
1350 br_ssl_engine_set_aes_ctr(br_ssl_engine_context *cc,
1351 const br_block_ctr_class *impl)
1352 {
1353 cc->iaes_ctr = impl;
1354 }
1355
1356 /**
1357 * \brief Set the "default" implementations for AES/GCM (AES/CTR + GHASH).
1358 *
1359 * This function configures in the engine the AES/CTR and GHASH
1360 * implementation that should provide best runtime performance on the local
1361 * system, while still being safe (in particular, constant-time). It also
1362 * sets the handlers for GCM records.
1363 *
1364 * \param cc SSL engine context.
1365 */
1366 void br_ssl_engine_set_default_aes_gcm(br_ssl_engine_context *cc);
1367
1368 /**
1369 * \brief Set the DES/CBC implementations.
1370 *
1371 * \param cc SSL engine context.
1372 * \param impl_enc DES/CBC encryption implementation (or `NULL`).
1373 * \param impl_dec DES/CBC decryption implementation (or `NULL`).
1374 */
1375 static inline void
1376 br_ssl_engine_set_des_cbc(br_ssl_engine_context *cc,
1377 const br_block_cbcenc_class *impl_enc,
1378 const br_block_cbcdec_class *impl_dec)
1379 {
1380 cc->ides_cbcenc = impl_enc;
1381 cc->ides_cbcdec = impl_dec;
1382 }
1383
1384 /**
1385 * \brief Set the "default" DES/CBC implementations.
1386 *
1387 * This function configures in the engine the DES implementations that
1388 * should provide best runtime performance on the local system, while
1389 * still being safe (in particular, constant-time). It also sets the
1390 * handlers for CBC records.
1391 *
1392 * \param cc SSL engine context.
1393 */
1394 void br_ssl_engine_set_default_des_cbc(br_ssl_engine_context *cc);
1395
1396 /**
1397 * \brief Set the GHASH implementation (used in GCM mode).
1398 *
1399 * \param cc SSL engine context.
1400 * \param impl GHASH implementation (or `NULL`).
1401 */
1402 static inline void
1403 br_ssl_engine_set_ghash(br_ssl_engine_context *cc, br_ghash impl)
1404 {
1405 cc->ighash = impl;
1406 }
1407
1408 /**
1409 * \brief Set the ChaCha20 implementation.
1410 *
1411 * \param cc SSL engine context.
1412 * \param ichacha ChaCha20 implementation (or `NULL`).
1413 */
1414 static inline void
1415 br_ssl_engine_set_chacha20(br_ssl_engine_context *cc,
1416 br_chacha20_run ichacha)
1417 {
1418 cc->ichacha = ichacha;
1419 }
1420
1421 /**
1422 * \brief Set the Poly1305 implementation.
1423 *
1424 * \param cc SSL engine context.
1425 * \param ipoly Poly1305 implementation (or `NULL`).
1426 */
1427 static inline void
1428 br_ssl_engine_set_poly1305(br_ssl_engine_context *cc,
1429 br_poly1305_run ipoly)
1430 {
1431 cc->ipoly = ipoly;
1432 }
1433
1434 /**
1435 * \brief Set the "default" ChaCha20 and Poly1305 implementations.
1436 *
1437 * This function configures in the engine the ChaCha20 and Poly1305
1438 * implementations that should provide best runtime performance on the
1439 * local system, while still being safe (in particular, constant-time).
1440 * It also sets the handlers for ChaCha20+Poly1305 records.
1441 *
1442 * \param cc SSL engine context.
1443 */
1444 void br_ssl_engine_set_default_chapol(br_ssl_engine_context *cc);
1445
1446 /**
1447 * \brief Set the record encryption and decryption engines for CBC + HMAC.
1448 *
1449 * \param cc SSL engine context.
1450 * \param impl_in record CBC decryption implementation (or `NULL`).
1451 * \param impl_out record CBC encryption implementation (or `NULL`).
1452 */
1453 static inline void
1454 br_ssl_engine_set_cbc(br_ssl_engine_context *cc,
1455 const br_sslrec_in_cbc_class *impl_in,
1456 const br_sslrec_out_cbc_class *impl_out)
1457 {
1458 cc->icbc_in = impl_in;
1459 cc->icbc_out = impl_out;
1460 }
1461
1462 /**
1463 * \brief Set the record encryption and decryption engines for GCM.
1464 *
1465 * \param cc SSL engine context.
1466 * \param impl_in record GCM decryption implementation (or `NULL`).
1467 * \param impl_out record GCM encryption implementation (or `NULL`).
1468 */
1469 static inline void
1470 br_ssl_engine_set_gcm(br_ssl_engine_context *cc,
1471 const br_sslrec_in_gcm_class *impl_in,
1472 const br_sslrec_out_gcm_class *impl_out)
1473 {
1474 cc->igcm_in = impl_in;
1475 cc->igcm_out = impl_out;
1476 }
1477
1478 /**
1479 * \brief Set the record encryption and decryption engines for
1480 * ChaCha20+Poly1305.
1481 *
1482 * \param cc SSL engine context.
1483 * \param impl_in record ChaCha20 decryption implementation (or `NULL`).
1484 * \param impl_out record ChaCha20 encryption implementation (or `NULL`).
1485 */
1486 static inline void
1487 br_ssl_engine_set_chapol(br_ssl_engine_context *cc,
1488 const br_sslrec_in_chapol_class *impl_in,
1489 const br_sslrec_out_chapol_class *impl_out)
1490 {
1491 cc->ichapol_in = impl_in;
1492 cc->ichapol_out = impl_out;
1493 }
1494
1495 /**
1496 * \brief Set the EC implementation.
1497 *
1498 * The elliptic curve implementation will be used for ECDH and ECDHE
1499 * cipher suites, and for ECDSA support.
1500 *
1501 * \param cc SSL engine context.
1502 * \param iec EC implementation (or `NULL`).
1503 */
1504 static inline void
1505 br_ssl_engine_set_ec(br_ssl_engine_context *cc, const br_ec_impl *iec)
1506 {
1507 cc->iec = iec;
1508 }
1509
1510 /**
1511 * \brief Set the "default" EC implementation.
1512 *
1513 * This function sets the elliptic curve implementation for ECDH and
1514 * ECDHE cipher suites, and for ECDSA support. It selects the fastest
1515 * implementation on the current system.
1516 *
1517 * \param cc SSL engine context.
1518 */
1519 void br_ssl_engine_set_default_ec(br_ssl_engine_context *cc);
1520
1521 /**
1522 * \brief Get the EC implementation configured in the provided engine.
1523 *
1524 * \param cc SSL engine context.
1525 * \return the EC implementation.
1526 */
1527 static inline const br_ec_impl *
1528 br_ssl_engine_get_ec(br_ssl_engine_context *cc)
1529 {
1530 return cc->iec;
1531 }
1532
1533 /**
1534 * \brief Set the RSA signature verification implementation.
1535 *
1536 * On the client, this is used to verify the server's signature on its
1537 * ServerKeyExchange message (for ECDHE_RSA cipher suites). On the server,
1538 * this is used to verify the client's CertificateVerify message (if a
1539 * client certificate is requested, and that certificate contains a RSA key).
1540 *
1541 * \param cc SSL engine context.
1542 * \param irsavrfy RSA signature verification implementation.
1543 */
1544 static inline void
1545 br_ssl_engine_set_rsavrfy(br_ssl_engine_context *cc, br_rsa_pkcs1_vrfy irsavrfy)
1546 {
1547 cc->irsavrfy = irsavrfy;
1548 }
1549
1550 /**
1551 * \brief Set the "default" RSA implementation (signature verification).
1552 *
1553 * This function sets the RSA implementation (signature verification)
1554 * to the fastest implementation available on the current platform.
1555 *
1556 * \param cc SSL engine context.
1557 */
1558 void br_ssl_engine_set_default_rsavrfy(br_ssl_engine_context *cc);
1559
1560 /**
1561 * \brief Get the RSA implementation (signature verification) configured
1562 * in the provided engine.
1563 *
1564 * \param cc SSL engine context.
1565 * \return the RSA signature verification implementation.
1566 */
1567 static inline br_rsa_pkcs1_vrfy
1568 br_ssl_engine_get_rsavrfy(br_ssl_engine_context *cc)
1569 {
1570 return cc->irsavrfy;
1571 }
1572
1573 /*
1574 * \brief Set the ECDSA implementation (signature verification).
1575 *
1576 * On the client, this is used to verify the server's signature on its
1577 * ServerKeyExchange message (for ECDHE_ECDSA cipher suites). On the server,
1578 * this is used to verify the client's CertificateVerify message (if a
1579 * client certificate is requested, that certificate contains an EC key,
1580 * and full-static ECDH is not used).
1581 *
1582 * The ECDSA implementation will use the EC core implementation configured
1583 * in the engine context.
1584 *
1585 * \param cc client context.
1586 * \param iecdsa ECDSA verification implementation.
1587 */
1588 static inline void
1589 br_ssl_engine_set_ecdsa(br_ssl_engine_context *cc, br_ecdsa_vrfy iecdsa)
1590 {
1591 cc->iecdsa = iecdsa;
1592 }
1593
1594 /**
1595 * \brief Set the "default" ECDSA implementation (signature verification).
1596 *
1597 * This function sets the ECDSA implementation (signature verification)
1598 * to the fastest implementation available on the current platform. This
1599 * call also sets the elliptic curve implementation itself, there again
1600 * to the fastest EC implementation available.
1601 *
1602 * \param cc SSL engine context.
1603 */
1604 void br_ssl_engine_set_default_ecdsa(br_ssl_engine_context *cc);
1605
1606 /**
1607 * \brief Get the ECDSA implementation (signature verification) configured
1608 * in the provided engine.
1609 *
1610 * \param cc SSL engine context.
1611 * \return the ECDSA signature verification implementation.
1612 */
1613 static inline br_ecdsa_vrfy
1614 br_ssl_engine_get_ecdsa(br_ssl_engine_context *cc)
1615 {
1616 return cc->iecdsa;
1617 }
1618
1619 /**
1620 * \brief Set the I/O buffer for the SSL engine.
1621 *
1622 * Once this call has been made, `br_ssl_client_reset()` or
1623 * `br_ssl_server_reset()` MUST be called before using the context.
1624 *
1625 * The provided buffer will be used as long as the engine context is
1626 * used. The caller is responsible for keeping it available.
1627 *
1628 * If `bidi` is 0, then the engine will operate in half-duplex mode
1629 * (it won't be able to send data while there is unprocessed incoming
1630 * data in the buffer, and it won't be able to receive data while there
1631 * is unsent data in the buffer). The optimal buffer size in half-duplex
1632 * mode is `BR_SSL_BUFSIZE_MONO`; if the buffer is larger, then extra
1633 * bytes are ignored. If the buffer is smaller, then this limits the
1634 * capacity of the engine to support all allowed record sizes.
1635 *
1636 * If `bidi` is 1, then the engine will split the buffer into two
1637 * parts, for separate handling of outgoing and incoming data. This
1638 * enables full-duplex processing, but requires more RAM. The optimal
1639 * buffer size in full-duplex mode is `BR_SSL_BUFSIZE_BIDI`; if the
1640 * buffer is larger, then extra bytes are ignored. If the buffer is
1641 * smaller, then the split will favour the incoming part, so that
1642 * interoperability is maximised.
1643 *
1644 * \param cc SSL engine context
1645 * \param iobuf I/O buffer.
1646 * \param iobuf_len I/O buffer length (in bytes).
1647 * \param bidi non-zero for full-duplex mode.
1648 */
1649 void br_ssl_engine_set_buffer(br_ssl_engine_context *cc,
1650 void *iobuf, size_t iobuf_len, int bidi);
1651
1652 /**
1653 * \brief Set the I/O buffers for the SSL engine.
1654 *
1655 * Once this call has been made, `br_ssl_client_reset()` or
1656 * `br_ssl_server_reset()` MUST be called before using the context.
1657 *
1658 * This function is similar to `br_ssl_engine_set_buffer()`, except
1659 * that it enforces full-duplex mode, and the two I/O buffers are
1660 * provided as separate chunks.
1661 *
1662 * The macros `BR_SSL_BUFSIZE_INPUT` and `BR_SSL_BUFSIZE_OUTPUT`
1663 * evaluate to the optimal (maximum) sizes for the input and output
1664 * buffer, respectively.
1665 *
1666 * \param cc SSL engine context
1667 * \param ibuf input buffer.
1668 * \param ibuf_len input buffer length (in bytes).
1669 * \param obuf output buffer.
1670 * \param obuf_len output buffer length (in bytes).
1671 */
1672 void br_ssl_engine_set_buffers_bidi(br_ssl_engine_context *cc,
1673 void *ibuf, size_t ibuf_len, void *obuf, size_t obuf_len);
1674
1675 /**
1676 * \brief Inject some "initial entropy" in the context.
1677 *
1678 * This entropy will be added to what can be obtained from the
1679 * underlying operating system, if that OS is supported.
1680 *
1681 * This function may be called several times; all injected entropy chunks
1682 * are cumulatively mixed.
1683 *
1684 * If entropy gathering from the OS is supported and compiled in, then this
1685 * step is optional. Otherwise, it is mandatory to inject randomness, and
1686 * the caller MUST take care to push (as one or several successive calls)
1687 * enough entropy to achieve cryptographic resistance (at least 80 bits,
1688 * preferably 128 or more). The engine will report an error if no entropy
1689 * was provided and none can be obtained from the OS.
1690 *
1691 * Take care that this function cannot assess the cryptographic quality of
1692 * the provided bytes.
1693 *
1694 * In all generality, "entropy" must here be considered to mean "that
1695 * which the attacker cannot predict". If your OS/architecture does not
1696 * have a suitable source of randomness, then you can make do with the
1697 * combination of a large enough secret value (possibly a copy of an
1698 * asymmetric private key that you also store on the system) AND a
1699 * non-repeating value (e.g. current time, provided that the local clock
1700 * cannot be reset or altered by the attacker).
1701 *
1702 * \param cc SSL engine context.
1703 * \param data extra entropy to inject.
1704 * \param len length of the extra data (in bytes).
1705 */
1706 void br_ssl_engine_inject_entropy(br_ssl_engine_context *cc,
1707 const void *data, size_t len);
1708
1709 /**
1710 * \brief Get the "server name" in this engine.
1711 *
1712 * For clients, this is the name provided with `br_ssl_client_reset()`;
1713 * for servers, this is the name received from the client as part of the
1714 * ClientHello message. If there is no such name (e.g. the client did
1715 * not send an SNI extension) then the returned string is empty
1716 * (returned pointer points to a byte of value 0).
1717 *
1718 * The returned pointer refers to a buffer inside the context, which may
1719 * be overwritten as part of normal SSL activity (even within the same
1720 * connection, if a renegotiation occurs).
1721 *
1722 * \param cc SSL engine context.
1723 * \return the server name (possibly empty).
1724 */
1725 static inline const char *
1726 br_ssl_engine_get_server_name(const br_ssl_engine_context *cc)
1727 {
1728 return cc->server_name;
1729 }
1730
1731 /**
1732 * \brief Get the protocol version.
1733 *
1734 * This function returns the protocol version that is used by the
1735 * engine. That value is set after sending (for a server) or receiving
1736 * (for a client) the ServerHello message.
1737 *
1738 * \param cc SSL engine context.
1739 * \return the protocol version.
1740 */
1741 static inline unsigned
1742 br_ssl_engine_get_version(const br_ssl_engine_context *cc)
1743 {
1744 return cc->session.version;
1745 }
1746
1747 /**
1748 * \brief Get a copy of the session parameters.
1749 *
1750 * The session parameters are filled during the handshake, so this
1751 * function shall not be called before completion of the handshake.
1752 * The initial handshake is completed when the context first allows
1753 * application data to be injected.
1754 *
1755 * This function copies the current session parameters into the provided
1756 * structure. Beware that the session parameters include the master
1757 * secret, which is sensitive data, to handle with great care.
1758 *
1759 * \param cc SSL engine context.
1760 * \param pp destination structure for the session parameters.
1761 */
1762 static inline void
1763 br_ssl_engine_get_session_parameters(const br_ssl_engine_context *cc,
1764 br_ssl_session_parameters *pp)
1765 {
1766 memcpy(pp, &cc->session, sizeof *pp);
1767 }
1768
1769 /**
1770 * \brief Set the session parameters to the provided values.
1771 *
1772 * This function is meant to be used in the client, before doing a new
1773 * handshake; a session resumption will be attempted with these
1774 * parameters. In the server, this function has no effect.
1775 *
1776 * \param cc SSL engine context.
1777 * \param pp source structure for the session parameters.
1778 */
1779 static inline void
1780 br_ssl_engine_set_session_parameters(br_ssl_engine_context *cc,
1781 const br_ssl_session_parameters *pp)
1782 {
1783 memcpy(&cc->session, pp, sizeof *pp);
1784 }
1785
1786 /**
1787 * \brief Get identifier for the curve used for key exchange.
1788 *
1789 * If the cipher suite uses ECDHE, then this function returns the
1790 * identifier for the curve used for transient parameters. This is
1791 * defined during the course of the handshake, when the ServerKeyExchange
1792 * is sent (on the server) or received (on the client). If the
1793 * cipher suite does not use ECDHE (e.g. static ECDH, or RSA key
1794 * exchange), then this value is indeterminate.
1795 *
1796 * @param cc SSL engine context.
1797 * @return the ECDHE curve identifier.
1798 */
1799 static inline int
1800 br_ssl_engine_get_ecdhe_curve(br_ssl_engine_context *cc)
1801 {
1802 return cc->ecdhe_curve;
1803 }
1804
1805 /**
1806 * \brief Get the current engine state.
1807 *
1808 * An SSL engine (client or server) has, at any time, a state which is
1809 * the combination of zero, one or more of these flags:
1810 *
1811 * - `BR_SSL_CLOSED`
1812 *
1813 * Engine is finished, no more I/O (until next reset).
1814 *
1815 * - `BR_SSL_SENDREC`
1816 *
1817 * Engine has some bytes to send to the peer.
1818 *
1819 * - `BR_SSL_RECVREC`
1820 *
1821 * Engine expects some bytes from the peer.
1822 *
1823 * - `BR_SSL_SENDAPP`
1824 *
1825 * Engine may receive application data to send (or flush).
1826 *
1827 * - `BR_SSL_RECVAPP`
1828 *
1829 * Engine has obtained some application data from the peer,
1830 * that should be read by the caller.
1831 *
1832 * If no flag at all is set (state value is 0), then the engine is not
1833 * fully initialised yet.
1834 *
1835 * The `BR_SSL_CLOSED` flag is exclusive; when it is set, no other flag
1836 * is set. To distinguish between a normal closure and an error, use
1837 * `br_ssl_engine_last_error()`.
1838 *
1839 * Generally speaking, `BR_SSL_SENDREC` and `BR_SSL_SENDAPP` are mutually
1840 * exclusive: the input buffer, at any point, either accumulates
1841 * plaintext data, or contains an assembled record that is being sent.
1842 * Similarly, `BR_SSL_RECVREC` and `BR_SSL_RECVAPP` are mutually exclusive.
1843 * This may change in a future library version.
1844 *
1845 * \param cc SSL engine context.
1846 * \return the current engine state.
1847 */
1848 unsigned br_ssl_engine_current_state(const br_ssl_engine_context *cc);
1849
1850 /** \brief SSL engine state: closed or failed. */
1851 #define BR_SSL_CLOSED 0x0001
1852 /** \brief SSL engine state: record data is ready to be sent to the peer. */
1853 #define BR_SSL_SENDREC 0x0002
1854 /** \brief SSL engine state: engine may receive records from the peer. */
1855 #define BR_SSL_RECVREC 0x0004
1856 /** \brief SSL engine state: engine may accept application data to send. */
1857 #define BR_SSL_SENDAPP 0x0008
1858 /** \brief SSL engine state: engine has received application data. */
1859 #define BR_SSL_RECVAPP 0x0010
1860
1861 /**
1862 * \brief Get the engine error indicator.
1863 *
1864 * The error indicator is `BR_ERR_OK` (0) if no error was encountered
1865 * since the last call to `br_ssl_client_reset()` or
1866 * `br_ssl_server_reset()`. Other status values are "sticky": they
1867 * remain set, and prevent all I/O activity, until cleared. Only the
1868 * reset calls clear the error indicator.
1869 *
1870 * \param cc SSL engine context.
1871 * \return 0, or a non-zero error code.
1872 */
1873 static inline int
1874 br_ssl_engine_last_error(const br_ssl_engine_context *cc)
1875 {
1876 return cc->err;
1877 }
1878
1879 /*
1880 * There are four I/O operations, each identified by a symbolic name:
1881 *
1882 * sendapp inject application data in the engine
1883 * recvapp retrieving application data from the engine
1884 * sendrec sending records on the transport medium
1885 * recvrec receiving records from the transport medium
1886 *
1887 * Terminology works thus: in a layered model where the SSL engine sits
1888 * between the application and the network, "send" designates operations
1889 * where bytes flow from application to network, and "recv" for the
1890 * reverse operation. Application data (the plaintext that is to be
1891 * conveyed through SSL) is "app", while encrypted records are "rec".
1892 * Note that from the SSL engine point of view, "sendapp" and "recvrec"
1893 * designate bytes that enter the engine ("inject" operation), while
1894 * "recvapp" and "sendrec" designate bytes that exit the engine
1895 * ("extract" operation).
1896 *
1897 * For the operation 'xxx', two functions are defined:
1898 *
1899 * br_ssl_engine_xxx_buf
1900 * Returns a pointer and length to the buffer to use for that
1901 * operation. '*len' is set to the number of bytes that may be read
1902 * from the buffer (extract operation) or written to the buffer
1903 * (inject operation). If no byte may be exchanged for that operation
1904 * at that point, then '*len' is set to zero, and NULL is returned.
1905 * The engine state is unmodified by this call.
1906 *
1907 * br_ssl_engine_xxx_ack
1908 * Informs the engine that 'len' bytes have been read from the buffer
1909 * (extract operation) or written to the buffer (inject operation).
1910 * The 'len' value MUST NOT be zero. The 'len' value MUST NOT exceed
1911 * that which was obtained from a preceeding br_ssl_engine_xxx_buf()
1912 * call.
1913 */
1914
1915 /**
1916 * \brief Get buffer for application data to send.
1917 *
1918 * If the engine is ready to accept application data to send to the
1919 * peer, then this call returns a pointer to the buffer where such
1920 * data shall be written, and its length is written in `*len`.
1921 * Otherwise, `*len` is set to 0 and `NULL` is returned.
1922 *
1923 * \param cc SSL engine context.
1924 * \param len receives the application data output buffer length, or 0.
1925 * \return the application data output buffer, or `NULL`.
1926 */
1927 unsigned char *br_ssl_engine_sendapp_buf(
1928 const br_ssl_engine_context *cc, size_t *len);
1929
1930 /**
1931 * \brief Inform the engine of some new application data.
1932 *
1933 * After writing `len` bytes in the buffer returned by
1934 * `br_ssl_engine_sendapp_buf()`, the application shall call this
1935 * function to trigger any relevant processing. The `len` parameter
1936 * MUST NOT be 0, and MUST NOT exceed the value obtained in the
1937 * `br_ssl_engine_sendapp_buf()` call.
1938 *
1939 * \param cc SSL engine context.
1940 * \param len number of bytes pushed (not zero).
1941 */
1942 void br_ssl_engine_sendapp_ack(br_ssl_engine_context *cc, size_t len);
1943
1944 /**
1945 * \brief Get buffer for received application data.
1946 *
1947 * If the engine has received application data from the peer, hen this
1948 * call returns a pointer to the buffer from where such data shall be
1949 * read, and its length is written in `*len`. Otherwise, `*len` is set
1950 * to 0 and `NULL` is returned.
1951 *
1952 * \param cc SSL engine context.
1953 * \param len receives the application data input buffer length, or 0.
1954 * \return the application data input buffer, or `NULL`.
1955 */
1956 unsigned char *br_ssl_engine_recvapp_buf(
1957 const br_ssl_engine_context *cc, size_t *len);
1958
1959 /**
1960 * \brief Acknowledge some received application data.
1961 *
1962 * After reading `len` bytes from the buffer returned by
1963 * `br_ssl_engine_recvapp_buf()`, the application shall call this
1964 * function to trigger any relevant processing. The `len` parameter
1965 * MUST NOT be 0, and MUST NOT exceed the value obtained in the
1966 * `br_ssl_engine_recvapp_buf()` call.
1967 *
1968 * \param cc SSL engine context.
1969 * \param len number of bytes read (not zero).
1970 */
1971 void br_ssl_engine_recvapp_ack(br_ssl_engine_context *cc, size_t len);
1972
1973 /**
1974 * \brief Get buffer for record data to send.
1975 *
1976 * If the engine has prepared some records to send to the peer, then this
1977 * call returns a pointer to the buffer from where such data shall be
1978 * read, and its length is written in `*len`. Otherwise, `*len` is set
1979 * to 0 and `NULL` is returned.
1980 *
1981 * \param cc SSL engine context.
1982 * \param len receives the record data output buffer length, or 0.
1983 * \return the record data output buffer, or `NULL`.
1984 */
1985 unsigned char *br_ssl_engine_sendrec_buf(
1986 const br_ssl_engine_context *cc, size_t *len);
1987
1988 /**
1989 * \brief Acknowledge some sent record data.
1990 *
1991 * After reading `len` bytes from the buffer returned by
1992 * `br_ssl_engine_sendrec_buf()`, the application shall call this
1993 * function to trigger any relevant processing. The `len` parameter
1994 * MUST NOT be 0, and MUST NOT exceed the value obtained in the
1995 * `br_ssl_engine_sendrec_buf()` call.
1996 *
1997 * \param cc SSL engine context.
1998 * \param len number of bytes read (not zero).
1999 */
2000 void br_ssl_engine_sendrec_ack(br_ssl_engine_context *cc, size_t len);
2001
2002 /**
2003 * \brief Get buffer for incoming records.
2004 *
2005 * If the engine is ready to accept records from the peer, then this
2006 * call returns a pointer to the buffer where such data shall be
2007 * written, and its length is written in `*len`. Otherwise, `*len` is
2008 * set to 0 and `NULL` is returned.
2009 *
2010 * \param cc SSL engine context.
2011 * \param len receives the record data input buffer length, or 0.
2012 * \return the record data input buffer, or `NULL`.
2013 */
2014 unsigned char *br_ssl_engine_recvrec_buf(
2015 const br_ssl_engine_context *cc, size_t *len);
2016
2017 /**
2018 * \brief Inform the engine of some new record data.
2019 *
2020 * After writing `len` bytes in the buffer returned by
2021 * `br_ssl_engine_recvrec_buf()`, the application shall call this
2022 * function to trigger any relevant processing. The `len` parameter
2023 * MUST NOT be 0, and MUST NOT exceed the value obtained in the
2024 * `br_ssl_engine_recvrec_buf()` call.
2025 *
2026 * \param cc SSL engine context.
2027 * \param len number of bytes pushed (not zero).
2028 */
2029 void br_ssl_engine_recvrec_ack(br_ssl_engine_context *cc, size_t len);
2030
2031 /**
2032 * \brief Flush buffered application data.
2033 *
2034 * If some application data has been buffered in the engine, then wrap
2035 * it into a record and mark it for sending. If no application data has
2036 * been buffered but the engine would be ready to accept some, AND the
2037 * `force` parameter is non-zero, then an empty record is assembled and
2038 * marked for sending. In all other cases, this function does nothing.
2039 *
2040 * Empty records are technically legal, but not all existing SSL/TLS
2041 * implementations support them. Empty records can be useful as a
2042 * transparent "keep-alive" mechanism to maintain some low-level
2043 * network activity.
2044 *
2045 * \param cc SSL engine context.
2046 * \param force non-zero to force sending an empty record.
2047 */
2048 void br_ssl_engine_flush(br_ssl_engine_context *cc, int force);
2049
2050 /**
2051 * \brief Initiate a closure.
2052 *
2053 * If, at that point, the context is open and in ready state, then a
2054 * `close_notify` alert is assembled and marked for sending; this
2055 * triggers the closure protocol. Otherwise, no such alert is assembled.
2056 *
2057 * \param cc SSL engine context.
2058 */
2059 void br_ssl_engine_close(br_ssl_engine_context *cc);
2060
2061 /**
2062 * \brief Initiate a renegotiation.
2063 *
2064 * If the engine is failed or closed, or if the peer is known not to
2065 * support secure renegotiation (RFC 5746), or if renegotiations have
2066 * been disabled with the `BR_OPT_NO_RENEGOTIATION` flag, or if there
2067 * is buffered incoming application data, then this function returns 0
2068 * and nothing else happens.
2069 *
2070 * Otherwise, this function returns 1, and a renegotiation attempt is
2071 * triggered (if a handshake is already ongoing at that point, then
2072 * no new handshake is triggered).
2073 *
2074 * \param cc SSL engine context.
2075 * \return 1 on success, 0 on error.
2076 */
2077 int br_ssl_engine_renegotiate(br_ssl_engine_context *cc);
2078
2079 /**
2080 * \brief Export key material from a connected SSL engine (RFC 5705).
2081 *
2082 * This calls compute a secret key of arbitrary length from the master
2083 * secret of a connected SSL engine. If the provided context is not
2084 * currently in "application data" state (initial handshake is not
2085 * finished, another handshake is ongoing, or the connection failed or
2086 * was closed), then this function returns 0. Otherwise, a secret key of
2087 * length `len` bytes is computed and written in the buffer pointed to
2088 * by `dst`, and 1 is returned.
2089 *
2090 * The computed key follows the specification described in RFC 5705.
2091 * That RFC includes two key computations, with and without a "context
2092 * value". If `context` is `NULL`, then the variant without context is
2093 * used; otherwise, the `context_len` bytes located at the address
2094 * pointed to by `context` are used in the computation. Note that it
2095 * is possible to have a "with context" key with a context length of
2096 * zero bytes, by setting `context` to a non-`NULL` value but
2097 * `context_len` to 0.
2098 *
2099 * When context bytes are used, the context length MUST NOT exceed
2100 * 65535 bytes.
2101 *
2102 * \param cc SSL engine context.
2103 * \param dst destination buffer for exported key.
2104 * \param len exported key length (in bytes).
2105 * \param label disambiguation label.
2106 * \param context context value (or `NULL`).
2107 * \param context_len context length (in bytes).
2108 * \return 1 on success, 0 on error.
2109 */
2110 int br_ssl_key_export(br_ssl_engine_context *cc,
2111 void *dst, size_t len, const char *label,
2112 const void *context, size_t context_len);
2113
2114 /*
2115 * Pre-declaration for the SSL client context.
2116 */
2117 typedef struct br_ssl_client_context_ br_ssl_client_context;
2118
2119 /**
2120 * \brief Type for the client certificate, if requested by the server.
2121 */
2122 typedef struct {
2123 /**
2124 * \brief Authentication type.
2125 *
2126 * This is either `BR_AUTH_RSA` (RSA signature), `BR_AUTH_ECDSA`
2127 * (ECDSA signature), or `BR_AUTH_ECDH` (static ECDH key exchange).
2128 */
2129 int auth_type;
2130
2131 /**
2132 * \brief Hash function for computing the CertificateVerify.
2133 *
2134 * This is the symbolic identifier for the hash function that
2135 * will be used to produce the hash of handshake messages, to
2136 * be signed into the CertificateVerify. For full static ECDH
2137 * (client and server certificates are both EC in the same
2138 * curve, and static ECDH is used), this value is set to -1.
2139 *
2140 * Take care that with TLS 1.0 and 1.1, that value MUST match
2141 * the protocol requirements: value must be 0 (MD5+SHA-1) for
2142 * a RSA signature, or 2 (SHA-1) for an ECDSA signature. Only
2143 * TLS 1.2 allows for other hash functions.
2144 */
2145 int hash_id;
2146
2147 /**
2148 * \brief Certificate chain to send to the server.
2149 *
2150 * This is an array of `br_x509_certificate` objects, each
2151 * normally containing a DER-encoded certificate. The client
2152 * code does not try to decode these elements. If there is no
2153 * chain to send to the server, then this pointer shall be
2154 * set to `NULL`.
2155 */
2156 const br_x509_certificate *chain;
2157
2158 /**
2159 * \brief Certificate chain length (number of certificates).
2160 *
2161 * If there is no chain to send to the server, then this value
2162 * shall be set to 0.
2163 */
2164 size_t chain_len;
2165
2166 } br_ssl_client_certificate;
2167
2168 /*
2169 * Note: the constants below for signatures match the TLS constants.
2170 */
2171
2172 /** \brief Client authentication type: static ECDH. */
2173 #define BR_AUTH_ECDH 0
2174 /** \brief Client authentication type: RSA signature. */
2175 #define BR_AUTH_RSA 1
2176 /** \brief Client authentication type: ECDSA signature. */
2177 #define BR_AUTH_ECDSA 3
2178
2179 /**
2180 * \brief Class type for a certificate handler (client side).
2181 *
2182 * A certificate handler selects a client certificate chain to send to
2183 * the server, upon explicit request from that server. It receives
2184 * the list of trust anchor DN from the server, and supported types
2185 * of certificates and signatures, and returns the chain to use. It
2186 * is also invoked to perform the corresponding private key operation
2187 * (a signature, or an ECDH computation).
2188 *
2189 * The SSL client engine will first push the trust anchor DN with
2190 * `start_name_list()`, `start_name()`, `append_name()`, `end_name()`
2191 * and `end_name_list()`. Then it will call `choose()`, to select the
2192 * actual chain (and signature/hash algorithms). Finally, it will call
2193 * either `do_sign()` or `do_keyx()`, depending on the algorithm choices.
2194 */
2195 typedef struct br_ssl_client_certificate_class_ br_ssl_client_certificate_class;
2196 struct br_ssl_client_certificate_class_ {
2197 /**
2198 * \brief Context size (in bytes).
2199 */
2200 size_t context_size;
2201
2202 /**
2203 * \brief Begin reception of a list of trust anchor names. This
2204 * is called while parsing the incoming CertificateRequest.
2205 *
2206 * \param pctx certificate handler context.
2207 */
2208 void (*start_name_list)(const br_ssl_client_certificate_class **pctx);
2209
2210 /**
2211 * \brief Begin reception of a new trust anchor name.
2212 *
2213 * The total encoded name length is provided; it is less than
2214 * 65535 bytes.
2215 *
2216 * \param pctx certificate handler context.
2217 * \param len encoded name length (in bytes).
2218 */
2219 void (*start_name)(const br_ssl_client_certificate_class **pctx,
2220 size_t len);
2221
2222 /**
2223 * \brief Receive some more bytes for the current trust anchor name.
2224 *
2225 * The provided reference (`data`) points to a transient buffer
2226 * they may be reused as soon as this function returns. The chunk
2227 * length (`len`) is never zero.
2228 *
2229 * \param pctx certificate handler context.
2230 * \param data anchor name chunk.
2231 * \param len anchor name chunk length (in bytes).
2232 */
2233 void (*append_name)(const br_ssl_client_certificate_class **pctx,
2234 const unsigned char *data, size_t len);
2235
2236 /**
2237 * \brief End current trust anchor name.
2238 *
2239 * This function is called when all the encoded anchor name data
2240 * has been provided.
2241 *
2242 * \param pctx certificate handler context.
2243 */
2244 void (*end_name)(const br_ssl_client_certificate_class **pctx);
2245
2246 /**
2247 * \brief End list of trust anchor names.
2248 *
2249 * This function is called when all the anchor names in the
2250 * CertificateRequest message have been obtained.
2251 *
2252 * \param pctx certificate handler context.
2253 */
2254 void (*end_name_list)(const br_ssl_client_certificate_class **pctx);
2255
2256 /**
2257 * \brief Select client certificate and algorithms.
2258 *
2259 * This callback function shall fill the provided `choices`
2260 * structure with the selected algorithms and certificate chain.
2261 * The `hash_id`, `chain` and `chain_len` fields must be set. If
2262 * the client cannot or does not wish to send a certificate,
2263 * then it shall set `chain` to `NULL` and `chain_len` to 0.
2264 *
2265 * The `auth_types` parameter describes the authentication types,
2266 * signature algorithms and hash functions that are supported by
2267 * both the client context and the server, and compatible with
2268 * the current protocol version. This is a bit field with the
2269 * following contents:
2270 *
2271 * - If RSA signatures with hash function x are supported, then
2272 * bit x is set.
2273 *
2274 * - If ECDSA signatures with hash function x are supported,
2275 * then bit 8+x is set.
2276 *
2277 * - If static ECDH is supported, with a RSA-signed certificate,
2278 * then bit 16 is set.
2279 *
2280 * - If static ECDH is supported, with an ECDSA-signed certificate,
2281 * then bit 17 is set.
2282 *
2283 * Notes:
2284 *
2285 * - When using TLS 1.0 or 1.1, the hash function for RSA
2286 * signatures is always the special MD5+SHA-1 (id 0), and the
2287 * hash function for ECDSA signatures is always SHA-1 (id 2).
2288 *
2289 * - When using TLS 1.2, the list of hash functions is trimmed
2290 * down to include only hash functions that the client context
2291 * can support. The actual server list can be obtained with
2292 * `br_ssl_client_get_server_hashes()`; that list may be used
2293 * to select the certificate chain to send to the server.
2294 *
2295 * \param pctx certificate handler context.
2296 * \param cc SSL client context.
2297 * \param auth_types supported authentication types and algorithms.
2298 * \param choices destination structure for the policy choices.
2299 */
2300 void (*choose)(const br_ssl_client_certificate_class **pctx,
2301 const br_ssl_client_context *cc, uint32_t auth_types,
2302 br_ssl_client_certificate *choices);
2303
2304 /**
2305 * \brief Perform key exchange (client part).
2306 *
2307 * This callback is invoked in case of a full static ECDH key
2308 * exchange:
2309 *
2310 * - the cipher suite uses `ECDH_RSA` or `ECDH_ECDSA`;
2311 *
2312 * - the server requests a client certificate;
2313 *
2314 * - the client has, and sends, a client certificate that
2315 * uses an EC key in the same curve as the server's key,
2316 * and chooses static ECDH (the `hash_id` field in the choice
2317 * structure was set to -1).
2318 *
2319 * In that situation, this callback is invoked to compute the
2320 * client-side ECDH: the provided `data` (of length `*len` bytes)
2321 * is the server's public key point (as decoded from its
2322 * certificate), and the client shall multiply that point with
2323 * its own private key, and write back the X coordinate of the
2324 * resulting point in the same buffer, starting at offset 0.
2325 * The `*len` value shall be modified to designate the actual
2326 * length of the X coordinate.
2327 *
2328 * The callback must uphold the following:
2329 *
2330 * - If the input array does not have the proper length for
2331 * an encoded curve point, then an error (0) shall be reported.
2332 *
2333 * - If the input array has the proper length, then processing
2334 * MUST be constant-time, even if the data is not a valid
2335 * encoded point.
2336 *
2337 * - This callback MUST check that the input point is valid.
2338 *
2339 * Returned value is 1 on success, 0 on error.
2340 *
2341 * \param pctx certificate handler context.
2342 * \param data server public key point.
2343 * \param len public key point length / X coordinate length.
2344 * \return 1 on success, 0 on error.
2345 */
2346 uint32_t (*do_keyx)(const br_ssl_client_certificate_class **pctx,
2347 unsigned char *data, size_t *len);
2348
2349 /**
2350 * \brief Perform a signature (client authentication).
2351 *
2352 * This callback is invoked when a client certificate was sent,
2353 * and static ECDH is not used. It shall compute a signature,
2354 * using the client's private key, over the provided hash value
2355 * (which is the hash of all previous handshake messages).
2356 *
2357 * On input, the hash value to sign is in `data`, of size
2358 * `hv_len`; the involved hash function is identified by
2359 * `hash_id`. The signature shall be computed and written
2360 * back into `data`; the total size of that buffer is `len`
2361 * bytes.
2362 *
2363 * This callback shall verify that the signature length does not
2364 * exceed `len` bytes, and abstain from writing the signature if
2365 * it does not fit.
2366 *
2367 * For RSA signatures, the `hash_id` may be 0, in which case
2368 * this is the special header-less signature specified in TLS 1.0
2369 * and 1.1, with a 36-byte hash value. Otherwise, normal PKCS#1
2370 * v1.5 signatures shall be computed.
2371 *
2372 * For ECDSA signatures, the signature value shall use the ASN.1
2373 * based encoding.
2374 *
2375 * Returned value is the signature length (in bytes), or 0 on error.
2376 *
2377 * \param pctx certificate handler context.
2378 * \param hash_id hash function identifier.
2379 * \param hv_len hash value length (in bytes).
2380 * \param data input/output buffer (hash value, then signature).
2381 * \param len total buffer length (in bytes).
2382 * \return signature length (in bytes) on success, or 0 on error.
2383 */
2384 size_t (*do_sign)(const br_ssl_client_certificate_class **pctx,
2385 int hash_id, size_t hv_len, unsigned char *data, size_t len);
2386 };
2387
2388 /**
2389 * \brief A single-chain RSA client certificate handler.
2390 *
2391 * This handler uses a single certificate chain, with a RSA
2392 * signature. The list of trust anchor DN is ignored.
2393 *
2394 * Apart from the first field (vtable pointer), its contents are
2395 * opaque and shall not be accessed directly.
2396 */
2397 typedef struct {
2398 /** \brief Pointer to vtable. */
2399 const br_ssl_client_certificate_class *vtable;
2400 #ifndef BR_DOXYGEN_IGNORE
2401 const br_x509_certificate *chain;
2402 size_t chain_len;
2403 const br_rsa_private_key *sk;
2404 br_rsa_pkcs1_sign irsasign;
2405 #endif
2406 } br_ssl_client_certificate_rsa_context;
2407
2408 /**
2409 * \brief A single-chain EC client certificate handler.
2410 *
2411 * This handler uses a single certificate chain, with a RSA
2412 * signature. The list of trust anchor DN is ignored.
2413 *
2414 * This handler may support both static ECDH, and ECDSA signatures
2415 * (either usage may be selectively disabled).
2416 *
2417 * Apart from the first field (vtable pointer), its contents are
2418 * opaque and shall not be accessed directly.
2419 */
2420 typedef struct {
2421 /** \brief Pointer to vtable. */
2422 const br_ssl_client_certificate_class *vtable;
2423 #ifndef BR_DOXYGEN_IGNORE
2424 const br_x509_certificate *chain;
2425 size_t chain_len;
2426 const br_ec_private_key *sk;
2427 unsigned allowed_usages;
2428 unsigned issuer_key_type;
2429 const br_multihash_context *mhash;
2430 const br_ec_impl *iec;
2431 br_ecdsa_sign iecdsa;
2432 #endif
2433 } br_ssl_client_certificate_ec_context;
2434
2435 /**
2436 * \brief Context structure for a SSL client.
2437 *
2438 * The first field (called `eng`) is the SSL engine; all functions that
2439 * work on a `br_ssl_engine_context` structure shall take as parameter
2440 * a pointer to that field. The other structure fields are opaque and
2441 * must not be accessed directly.
2442 */
2443 struct br_ssl_client_context_ {
2444 /**
2445 * \brief The encapsulated engine context.
2446 */
2447 br_ssl_engine_context eng;
2448
2449 #ifndef BR_DOXYGEN_IGNORE
2450 /*
2451 * Minimum ClientHello length; padding with an extension (RFC
2452 * 7685) is added if necessary to match at least that length.
2453 * Such padding is nominally unnecessary, but it has been used
2454 * to work around some server implementation bugs.
2455 */
2456 uint16_t min_clienthello_len;
2457
2458 /*
2459 * Bit field for algoithms (hash + signature) supported by the
2460 * server when requesting a client certificate.
2461 */
2462 uint32_t hashes;
2463
2464 /*
2465 * Server's public key curve.
2466 */
2467 int server_curve;
2468
2469 /*
2470 * Context for certificate handler.
2471 */
2472 const br_ssl_client_certificate_class **client_auth_vtable;
2473
2474 /*
2475 * Client authentication type.
2476 */
2477 unsigned char auth_type;
2478
2479 /*
2480 * Hash function to use for the client signature. This is 0xFF
2481 * if static ECDH is used.
2482 */
2483 unsigned char hash_id;
2484
2485 /*
2486 * For the core certificate handlers, thus avoiding (in most
2487 * cases) the need for an externally provided policy context.
2488 */
2489 union {
2490 const br_ssl_client_certificate_class *vtable;
2491 br_ssl_client_certificate_rsa_context single_rsa;
2492 br_ssl_client_certificate_ec_context single_ec;
2493 } client_auth;
2494
2495 /*
2496 * Implementations.
2497 */
2498 br_rsa_public irsapub;
2499 #endif
2500 };
2501
2502 /**
2503 * \brief Get the hash functions and signature algorithms supported by
2504 * the server.
2505 *
2506 * This value is a bit field:
2507 *
2508 * - If RSA (PKCS#1 v1.5) is supported with hash function of ID `x`,
2509 * then bit `x` is set (hash function ID is 0 for the special MD5+SHA-1,
2510 * or 2 to 6 for the SHA family).
2511 *
2512 * - If ECDSA is suported with hash function of ID `x`, then bit `8+x`
2513 * is set.
2514 *
2515 * - Newer algorithms are symbolic 16-bit identifiers that do not
2516 * represent signature algorithm and hash function separately. If
2517 * the TLS-level identifier is `0x0800+x` for a `x` in the 0..15
2518 * range, then bit `16+x` is set.
2519 *
2520 * "New algorithms" are currently defined only in draft documents, so
2521 * this support is subject to possible change. Right now (early 2017),
2522 * this maps ed25519 (EdDSA on Curve25519) to bit 23, and ed448 (EdDSA
2523 * on Curve448) to bit 24. If the identifiers on the wire change in
2524 * future document, then the decoding mechanism in BearSSL will be
2525 * amended to keep mapping ed25519 and ed448 on bits 23 and 24,
2526 * respectively. Mapping of other new algorithms (e.g. RSA/PSS) is not
2527 * guaranteed yet.
2528 *
2529 * \param cc client context.
2530 * \return the server-supported hash functions and signature algorithms.
2531 */
2532 static inline uint32_t
2533 br_ssl_client_get_server_hashes(const br_ssl_client_context *cc)
2534 {
2535 return cc->hashes;
2536 }
2537
2538 /**
2539 * \brief Get the server key curve.
2540 *
2541 * This function returns the ID for the curve used by the server's public
2542 * key. This is set when the server's certificate chain is processed;
2543 * this value is 0 if the server's key is not an EC key.
2544 *
2545 * \return the server's public key curve ID, or 0.
2546 */
2547 static inline int
2548 br_ssl_client_get_server_curve(const br_ssl_client_context *cc)
2549 {
2550 return cc->server_curve;
2551 }
2552
2553 /*
2554 * Each br_ssl_client_init_xxx() function sets the list of supported
2555 * cipher suites and used implementations, as specified by the profile
2556 * name 'xxx'. Defined profile names are:
2557 *
2558 * full all supported versions and suites; constant-time implementations
2559 * TODO: add other profiles
2560 */
2561
2562 /**
2563 * \brief SSL client profile: full.
2564 *
2565 * This function initialises the provided SSL client context with
2566 * all supported algorithms and cipher suites. It also initialises
2567 * a companion X.509 validation engine with all supported algorithms,
2568 * and the provided trust anchors; the X.509 engine will be used by
2569 * the client context to validate the server's certificate.
2570 *
2571 * \param cc client context to initialise.
2572 * \param xc X.509 validation context to initialise.
2573 * \param trust_anchors trust anchors to use.
2574 * \param trust_anchors_num number of trust anchors.
2575 */
2576 void br_ssl_client_init_full(br_ssl_client_context *cc,
2577 br_x509_minimal_context *xc,
2578 const br_x509_trust_anchor *trust_anchors, size_t trust_anchors_num);
2579
2580 /**
2581 * \brief Clear the complete contents of a SSL client context.
2582 *
2583 * Everything is cleared, including the reference to the configured buffer,
2584 * implementations, cipher suites and state. This is a preparatory step
2585 * to assembling a custom profile.
2586 *
2587 * \param cc client context to clear.
2588 */
2589 void br_ssl_client_zero(br_ssl_client_context *cc);
2590
2591 /**
2592 * \brief Set an externally provided client certificate handler context.
2593 *
2594 * The handler's methods are invoked when the server requests a client
2595 * certificate.
2596 *
2597 * \param cc client context.
2598 * \param pctx certificate handler context (pointer to its vtable field).
2599 */
2600 static inline void
2601 br_ssl_client_set_client_certificate(br_ssl_client_context *cc,
2602 const br_ssl_client_certificate_class **pctx)
2603 {
2604 cc->client_auth_vtable = pctx;
2605 }
2606
2607 /**
2608 * \brief Set the RSA public-key operations implementation.
2609 *
2610 * This will be used to encrypt the pre-master secret with the server's
2611 * RSA public key (RSA-encryption cipher suites only).
2612 *
2613 * \param cc client context.
2614 * \param irsapub RSA public-key encryption implementation.
2615 */
2616 static inline void
2617 br_ssl_client_set_rsapub(br_ssl_client_context *cc, br_rsa_public irsapub)
2618 {
2619 cc->irsapub = irsapub;
2620 }
2621
2622 /**
2623 * \brief Set the "default" RSA implementation for public-key operations.
2624 *
2625 * This sets the RSA implementation in the client context (for encrypting
2626 * the pre-master secret, in `TLS_RSA_*` cipher suites) to the fastest
2627 * available on the current platform.
2628 *
2629 * \param cc client context.
2630 */
2631 void br_ssl_client_set_default_rsapub(br_ssl_client_context *cc);
2632
2633 /**
2634 * \brief Set the minimum ClientHello length (RFC 7685 padding).
2635 *
2636 * If this value is set and the ClientHello would be shorter, then
2637 * the Pad ClientHello extension will be added with enough padding bytes
2638 * to reach the target size. Because of the extension header, the resulting
2639 * size will sometimes be slightly more than `len` bytes if the target
2640 * size cannot be exactly met.
2641 *
2642 * The target length relates to the _contents_ of the ClientHello, not
2643 * counting its 4-byte header. For instance, if `len` is set to 512,
2644 * then the padding will bring the ClientHello size to 516 bytes with its
2645 * header, and 521 bytes when counting the 5-byte record header.
2646 *
2647 * \param cc client context.
2648 * \param len minimum ClientHello length (in bytes).
2649 */
2650 static inline void
2651 br_ssl_client_set_min_clienthello_len(br_ssl_client_context *cc, uint16_t len)
2652 {
2653 cc->min_clienthello_len = len;
2654 }
2655
2656 /**
2657 * \brief Prepare or reset a client context for a new connection.
2658 *
2659 * The `server_name` parameter is used to fill the SNI extension; the
2660 * X.509 "minimal" engine will also match that name against the server
2661 * names included in the server's certificate. If the parameter is
2662 * `NULL` then no SNI extension will be sent, and the X.509 "minimal"
2663 * engine (if used for server certificate validation) will not check
2664 * presence of any specific name in the received certificate.
2665 *
2666 * Therefore, setting the `server_name` to `NULL` shall be reserved
2667 * to cases where alternate or additional methods are used to ascertain
2668 * that the right server public key is used (e.g. a "known key" model).
2669 *
2670 * If `resume_session` is non-zero and the context was previously used
2671 * then the session parameters may be reused (depending on whether the
2672 * server previously sent a non-empty session ID, and accepts the session
2673 * resumption). The session parameters for session resumption can also
2674 * be set explicitly with `br_ssl_engine_set_session_parameters()`.
2675 *
2676 * On failure, the context is marked as failed, and this function
2677 * returns 0. A possible failure condition is when no initial entropy
2678 * was injected, and none could be obtained from the OS (either OS
2679 * randomness gathering is not supported, or it failed).
2680 *
2681 * \param cc client context.
2682 * \param server_name target server name, or `NULL`.
2683 * \param resume_session non-zero to try session resumption.
2684 * \return 0 on failure, 1 on success.
2685 */
2686 int br_ssl_client_reset(br_ssl_client_context *cc,
2687 const char *server_name, int resume_session);
2688
2689 /**
2690 * \brief Forget any session in the context.
2691 *
2692 * This means that the next handshake that uses this context will
2693 * necessarily be a full handshake (this applies both to new connections
2694 * and to renegotiations).
2695 *
2696 * \param cc client context.
2697 */
2698 static inline void
2699 br_ssl_client_forget_session(br_ssl_client_context *cc)
2700 {
2701 cc->eng.session.session_id_len = 0;
2702 }
2703
2704 /**
2705 * \brief Set client certificate chain and key (single RSA case).
2706 *
2707 * This function sets a client certificate chain, that the client will
2708 * send to the server whenever a client certificate is requested. This
2709 * certificate uses an RSA public key; the corresponding private key is
2710 * invoked for authentication. Trust anchor names sent by the server are
2711 * ignored.
2712 *
2713 * The provided chain and private key are linked in the client context;
2714 * they must remain valid as long as they may be used, i.e. normally
2715 * for the duration of the connection, since they might be invoked
2716 * again upon renegotiations.
2717 *
2718 * \param cc SSL client context.
2719 * \param chain client certificate chain (SSL order: EE comes first).
2720 * \param chain_len client chain length (number of certificates).
2721 * \param sk client private key.
2722 * \param irsasign RSA signature implementation (PKCS#1 v1.5).
2723 */
2724 void br_ssl_client_set_single_rsa(br_ssl_client_context *cc,
2725 const br_x509_certificate *chain, size_t chain_len,
2726 const br_rsa_private_key *sk, br_rsa_pkcs1_sign irsasign);
2727
2728 /*
2729 * \brief Set the client certificate chain and key (single EC case).
2730 *
2731 * This function sets a client certificate chain, that the client will
2732 * send to the server whenever a client certificate is requested. This
2733 * certificate uses an EC public key; the corresponding private key is
2734 * invoked for authentication. Trust anchor names sent by the server are
2735 * ignored.
2736 *
2737 * The provided chain and private key are linked in the client context;
2738 * they must remain valid as long as they may be used, i.e. normally
2739 * for the duration of the connection, since they might be invoked
2740 * again upon renegotiations.
2741 *
2742 * The `allowed_usages` is a combination of usages, namely
2743 * `BR_KEYTYPE_KEYX` and/or `BR_KEYTYPE_SIGN`. The `BR_KEYTYPE_KEYX`
2744 * value allows full static ECDH, while the `BR_KEYTYPE_SIGN` value
2745 * allows ECDSA signatures. If ECDSA signatures are used, then an ECDSA
2746 * signature implementation must be provided; otherwise, the `iecdsa`
2747 * parameter may be 0.
2748 *
2749 * The `cert_issuer_key_type` value is either `BR_KEYTYPE_RSA` or
2750 * `BR_KEYTYPE_EC`; it is the type of the public key used the the CA
2751 * that issued (signed) the client certificate. That value is used with
2752 * full static ECDH: support of the certificate by the server depends
2753 * on how the certificate was signed. (Note: when using TLS 1.2, this
2754 * parameter is ignored; but its value matters for TLS 1.0 and 1.1.)
2755 *
2756 * \param cc server context.
2757 * \param chain server certificate chain to send.
2758 * \param chain_len chain length (number of certificates).
2759 * \param sk server private key (EC).
2760 * \param allowed_usages allowed private key usages.
2761 * \param cert_issuer_key_type issuing CA's key type.
2762 * \param iec EC core implementation.
2763 * \param iecdsa ECDSA signature implementation ("asn1" format).
2764 */
2765 void br_ssl_client_set_single_ec(br_ssl_client_context *cc,
2766 const br_x509_certificate *chain, size_t chain_len,
2767 const br_ec_private_key *sk, unsigned allowed_usages,
2768 unsigned cert_issuer_key_type,
2769 const br_ec_impl *iec, br_ecdsa_sign iecdsa);
2770
2771 /**
2772 * \brief Type for a "translated cipher suite", as an array of two
2773 * 16-bit integers.
2774 *
2775 * The first element is the cipher suite identifier (as used on the wire).
2776 * The second element is the concatenation of four 4-bit elements which
2777 * characterise the cipher suite contents. In most to least significant
2778 * order, these 4-bit elements are:
2779 *
2780 * - Bits 12 to 15: key exchange + server key type
2781 *
2782 * | val | symbolic constant | suite type | details |
2783 * | :-- | :----------------------- | :---------- | :----------------------------------------------- |
2784 * | 0 | `BR_SSLKEYX_RSA` | RSA | RSA key exchange, key is RSA (encryption) |
2785 * | 1 | `BR_SSLKEYX_ECDHE_RSA` | ECDHE_RSA | ECDHE key exchange, key is RSA (signature) |
2786 * | 2 | `BR_SSLKEYX_ECDHE_ECDSA` | ECDHE_ECDSA | ECDHE key exchange, key is EC (signature) |
2787 * | 3 | `BR_SSLKEYX_ECDH_RSA` | ECDH_RSA | Key is EC (key exchange), cert signed with RSA |
2788 * | 4 | `BR_SSLKEYX_ECDH_ECDSA` | ECDH_ECDSA | Key is EC (key exchange), cert signed with ECDSA |
2789 *
2790 * - Bits 8 to 11: symmetric encryption algorithm
2791 *
2792 * | val | symbolic constant | symmetric encryption | key strength (bits) |
2793 * | :-- | :--------------------- | :------------------- | :------------------ |
2794 * | 0 | `BR_SSLENC_3DES_CBC` | 3DES/CBC | 168 |
2795 * | 1 | `BR_SSLENC_AES128_CBC` | AES-128/CBC | 128 |
2796 * | 2 | `BR_SSLENC_AES256_CBC` | AES-256/CBC | 256 |
2797 * | 3 | `BR_SSLENC_AES128_GCM` | AES-128/GCM | 128 |
2798 * | 4 | `BR_SSLENC_AES256_GCM` | AES-256/GCM | 256 |
2799 * | 5 | `BR_SSLENC_CHACHA20` | ChaCha20/Poly1305 | 256 |
2800 *
2801 * - Bits 4 to 7: MAC algorithm
2802 *
2803 * | val | symbolic constant | MAC type | details |
2804 * | :-- | :----------------- | :----------- | :------------------------------------ |
2805 * | 0 | `BR_SSLMAC_AEAD` | AEAD | No dedicated MAC (encryption is AEAD) |
2806 * | 2 | `BR_SSLMAC_SHA1` | HMAC/SHA-1 | Value matches `br_sha1_ID` |
2807 * | 4 | `BR_SSLMAC_SHA256` | HMAC/SHA-256 | Value matches `br_sha256_ID` |
2808 * | 5 | `BR_SSLMAC_SHA384` | HMAC/SHA-384 | Value matches `br_sha384_ID` |
2809 *
2810 * - Bits 0 to 3: hash function for PRF when used with TLS-1.2
2811 *
2812 * | val | symbolic constant | hash function | details |
2813 * | :-- | :----------------- | :------------ | :----------------------------------- |
2814 * | 4 | `BR_SSLPRF_SHA256` | SHA-256 | Value matches `br_sha256_ID` |
2815 * | 5 | `BR_SSLPRF_SHA384` | SHA-384 | Value matches `br_sha384_ID` |
2816 *
2817 * For instance, cipher suite `TLS_RSA_WITH_AES_128_GCM_SHA256` has
2818 * standard identifier 0x009C, and is translated to 0x0304, for, in
2819 * that order: RSA key exchange (0), AES-128/GCM (3), AEAD integrity (0),
2820 * SHA-256 in the TLS PRF (4).
2821 */
2822 typedef uint16_t br_suite_translated[2];
2823
2824 #ifndef BR_DOXYGEN_IGNORE
2825 /*
2826 * Constants are already documented in the br_suite_translated type.
2827 */
2828
2829 #define BR_SSLKEYX_RSA 0
2830 #define BR_SSLKEYX_ECDHE_RSA 1
2831 #define BR_SSLKEYX_ECDHE_ECDSA 2
2832 #define BR_SSLKEYX_ECDH_RSA 3
2833 #define BR_SSLKEYX_ECDH_ECDSA 4
2834
2835 #define BR_SSLENC_3DES_CBC 0
2836 #define BR_SSLENC_AES128_CBC 1
2837 #define BR_SSLENC_AES256_CBC 2
2838 #define BR_SSLENC_AES128_GCM 3
2839 #define BR_SSLENC_AES256_GCM 4
2840 #define BR_SSLENC_CHACHA20 5
2841
2842 #define BR_SSLMAC_AEAD 0
2843 #define BR_SSLMAC_SHA1 br_sha1_ID
2844 #define BR_SSLMAC_SHA256 br_sha256_ID
2845 #define BR_SSLMAC_SHA384 br_sha384_ID
2846
2847 #define BR_SSLPRF_SHA256 br_sha256_ID
2848 #define BR_SSLPRF_SHA384 br_sha384_ID
2849
2850 #endif
2851
2852 /*
2853 * Pre-declaration for the SSL server context.
2854 */
2855 typedef struct br_ssl_server_context_ br_ssl_server_context;
2856
2857 /**
2858 * \brief Type for the server policy choices, taken after analysis of
2859 * the client message (ClientHello).
2860 */
2861 typedef struct {
2862 /**
2863 * \brief Cipher suite to use with that client.
2864 */
2865 uint16_t cipher_suite;
2866
2867 /**
2868 * \brief Hash function or algorithm for signing the ServerKeyExchange.
2869 *
2870 * This parameter is ignored for `TLS_RSA_*` and `TLS_ECDH_*`
2871 * cipher suites; it is used only for `TLS_ECDHE_*` suites, in
2872 * which the server _signs_ the ephemeral EC Diffie-Hellman
2873 * parameters sent to the client.
2874 *
2875 * This identifier must be one of the following values:
2876 *
2877 * - `0xFF00 + id`, where `id` is a hash function identifier
2878 * (0 for MD5+SHA-1, or 2 to 6 for one of the SHA functions);
2879 *
2880 * - a full 16-bit identifier, lower than `0xFF00`.
2881 *
2882 * If the first option is used, then the SSL engine will
2883 * compute the hash of the data that is to be signed, with the
2884 * designated hash function. The `do_sign()` method will be
2885 * invoked with that hash value provided in the the `data`
2886 * buffer.
2887 *
2888 * If the second option is used, then the SSL engine will NOT
2889 * compute a hash on the data; instead, it will provide the
2890 * to-be-signed data itself in `data`, i.e. the concatenation of
2891 * the client random, server random, and encoded ECDH
2892 * parameters. Furthermore, with TLS-1.2 and later, the 16-bit
2893 * identifier will be used "as is" in the protocol, in the
2894 * SignatureAndHashAlgorithm; for instance, `0x0401` stands for
2895 * RSA PKCS#1 v1.5 signature (the `01`) with SHA-256 as hash
2896 * function (the `04`).
2897 *
2898 * Take care that with TLS 1.0 and 1.1, the hash function is
2899 * constrainted by the protocol: RSA signature must use
2900 * MD5+SHA-1 (so use `0xFF00`), while ECDSA must use SHA-1
2901 * (`0xFF02`). Since TLS 1.0 and 1.1 don't include a
2902 * SignatureAndHashAlgorithm field in their ServerKeyExchange
2903 * messages, any value below `0xFF00` will be usable to send the
2904 * raw ServerKeyExchange data to the `do_sign()` callback, but
2905 * that callback must still follow the protocol requirements
2906 * when generating the signature.
2907 */
2908 unsigned algo_id;
2909
2910 /**
2911 * \brief Certificate chain to send to the client.
2912 *
2913 * This is an array of `br_x509_certificate` objects, each
2914 * normally containing a DER-encoded certificate. The server
2915 * code does not try to decode these elements.
2916 */
2917 const br_x509_certificate *chain;
2918
2919 /**
2920 * \brief Certificate chain length (number of certificates).
2921 */
2922 size_t chain_len;
2923
2924 } br_ssl_server_choices;
2925
2926 /**
2927 * \brief Class type for a policy handler (server side).
2928 *
2929 * A policy handler selects the policy parameters for a connection
2930 * (cipher suite and other algorithms, and certificate chain to send to
2931 * the client); it also performs the server-side computations involving
2932 * its permanent private key.
2933 *
2934 * The SSL server engine will invoke first `choose()`, once the
2935 * ClientHello message has been received, then either `do_keyx()`
2936 * `do_sign()`, depending on the cipher suite.
2937 */
2938 typedef struct br_ssl_server_policy_class_ br_ssl_server_policy_class;
2939 struct br_ssl_server_policy_class_ {
2940 /**
2941 * \brief Context size (in bytes).
2942 */
2943 size_t context_size;
2944
2945 /**
2946 * \brief Select algorithms and certificates for this connection.
2947 *
2948 * This callback function shall fill the provided `choices`
2949 * structure with the policy choices for this connection. This
2950 * entails selecting the cipher suite, hash function for signing
2951 * the ServerKeyExchange (applicable only to ECDHE cipher suites),
2952 * and certificate chain to send.
2953 *
2954 * The callback receives a pointer to the server context that
2955 * contains the relevant data. In particular, the functions
2956 * `br_ssl_server_get_client_suites()`,
2957 * `br_ssl_server_get_client_hashes()` and
2958 * `br_ssl_server_get_client_curves()` can be used to obtain
2959 * the cipher suites, hash functions and elliptic curves
2960 * supported by both the client and server, respectively. The
2961 * `br_ssl_engine_get_version()` and `br_ssl_engine_get_server_name()`
2962 * functions yield the protocol version and requested server name
2963 * (SNI), respectively.
2964 *
2965 * This function may modify its context structure (`pctx`) in
2966 * arbitrary ways to keep track of its own choices.
2967 *
2968 * This function shall return 1 if appropriate policy choices
2969 * could be made, or 0 if this connection cannot be pursued.
2970 *
2971 * \param pctx policy context.
2972 * \param cc SSL server context.
2973 * \param choices destination structure for the policy choices.
2974 * \return 1 on success, 0 on error.
2975 */
2976 int (*choose)(const br_ssl_server_policy_class **pctx,
2977 const br_ssl_server_context *cc,
2978 br_ssl_server_choices *choices);
2979
2980 /**
2981 * \brief Perform key exchange (server part).
2982 *
2983 * This callback is invoked to perform the server-side cryptographic
2984 * operation for a key exchange that is not ECDHE. This callback
2985 * uses the private key.
2986 *
2987 * **For RSA key exchange**, the provided `data` (of length `*len`
2988 * bytes) shall be decrypted with the server's private key, and
2989 * the 48-byte premaster secret copied back to the first 48 bytes
2990 * of `data`.
2991 *
2992 * - The caller makes sure that `*len` is at least 59 bytes.
2993 *
2994 * - This callback MUST check that the provided length matches
2995 * that of the key modulus; it shall report an error otherwise.
2996 *
2997 * - If the length matches that of the RSA key modulus, then
2998 * processing MUST be constant-time, even if decryption fails,
2999 * or the padding is incorrect, or the plaintext message length
3000 * is not exactly 48 bytes.
3001 *
3002 * - This callback needs not check the two first bytes of the
3003 * obtained pre-master secret (the caller will do that).
3004 *
3005 * - If an error is reported (0), then what the callback put
3006 * in the first 48 bytes of `data` is unimportant (the caller
3007 * will use random bytes instead).
3008 *
3009 * **For ECDH key exchange**, the provided `data` (of length `*len`
3010 * bytes) is the elliptic curve point from the client. The
3011 * callback shall multiply it with its private key, and store
3012 * the resulting X coordinate in `data`, starting at offset 0,
3013 * and set `*len` to the length of the X coordinate.
3014 *
3015 * - If the input array does not have the proper length for
3016 * an encoded curve point, then an error (0) shall be reported.
3017 *
3018 * - If the input array has the proper length, then processing
3019 * MUST be constant-time, even if the data is not a valid
3020 * encoded point.
3021 *
3022 * - This callback MUST check that the input point is valid.
3023 *
3024 * Returned value is 1 on success, 0 on error.
3025 *
3026 * \param pctx policy context.
3027 * \param data key exchange data from the client.
3028 * \param len key exchange data length (in bytes).
3029 * \return 1 on success, 0 on error.
3030 */
3031 uint32_t (*do_keyx)(const br_ssl_server_policy_class **pctx,
3032 unsigned char *data, size_t *len);
3033
3034 /**
3035 * \brief Perform a signature (for a ServerKeyExchange message).
3036 *
3037 * This callback function is invoked for ECDHE cipher suites. On
3038 * input, the hash value or message to sign is in `data`, of
3039 * size `hv_len`; the involved hash function or algorithm is
3040 * identified by `algo_id`. The signature shall be computed and
3041 * written back into `data`; the total size of that buffer is
3042 * `len` bytes.
3043 *
3044 * This callback shall verify that the signature length does not
3045 * exceed `len` bytes, and abstain from writing the signature if
3046 * it does not fit.
3047 *
3048 * The `algo_id` value matches that which was written in the
3049 * `choices` structures by the `choose()` callback. This will be
3050 * one of the following:
3051 *
3052 * - `0xFF00 + id` for a hash function identifier `id`. In
3053 * that case, the `data` buffer contains a hash value
3054 * already computed over the data that is to be signed,
3055 * of length `hv_len`. The `id` may be 0 to designate the
3056 * special MD5+SHA-1 concatenation (old-style RSA signing).
3057 *
3058 * - Another value, lower than `0xFF00`. The `data` buffer
3059 * then contains the raw, non-hashed data to be signed
3060 * (concatenation of the client and server randoms and
3061 * ECDH parameters). The callback is responsible to apply
3062 * any relevant hashing as part of the signing process.
3063 *
3064 * Returned value is the signature length (in bytes), or 0 on error.
3065 *
3066 * \param pctx policy context.
3067 * \param algo_id hash function / algorithm identifier.
3068 * \param data input/output buffer (message/hash, then signature).
3069 * \param hv_len hash value or message length (in bytes).
3070 * \param len total buffer length (in bytes).
3071 * \return signature length (in bytes) on success, or 0 on error.
3072 */
3073 size_t (*do_sign)(const br_ssl_server_policy_class **pctx,
3074 unsigned algo_id,
3075 unsigned char *data, size_t hv_len, size_t len);
3076 };
3077
3078 /**
3079 * \brief A single-chain RSA policy handler.
3080 *
3081 * This policy context uses a single certificate chain, and a RSA
3082 * private key. The context can be restricted to only signatures or
3083 * only key exchange.
3084 *
3085 * Apart from the first field (vtable pointer), its contents are
3086 * opaque and shall not be accessed directly.
3087 */
3088 typedef struct {
3089 /** \brief Pointer to vtable. */
3090 const br_ssl_server_policy_class *vtable;
3091 #ifndef BR_DOXYGEN_IGNORE
3092 const br_x509_certificate *chain;
3093 size_t chain_len;
3094 const br_rsa_private_key *sk;
3095 unsigned allowed_usages;
3096 br_rsa_private irsacore;
3097 br_rsa_pkcs1_sign irsasign;
3098 #endif
3099 } br_ssl_server_policy_rsa_context;
3100
3101 /**
3102 * \brief A single-chain EC policy handler.
3103 *
3104 * This policy context uses a single certificate chain, and an EC
3105 * private key. The context can be restricted to only signatures or
3106 * only key exchange.
3107 *
3108 * Due to how TLS is defined, this context must be made aware whether
3109 * the server certificate was itself signed with RSA or ECDSA. The code
3110 * does not try to decode the certificate to obtain that information.
3111 *
3112 * Apart from the first field (vtable pointer), its contents are
3113 * opaque and shall not be accessed directly.
3114 */
3115 typedef struct {
3116 /** \brief Pointer to vtable. */
3117 const br_ssl_server_policy_class *vtable;
3118 #ifndef BR_DOXYGEN_IGNORE
3119 const br_x509_certificate *chain;
3120 size_t chain_len;
3121 const br_ec_private_key *sk;
3122 unsigned allowed_usages;
3123 unsigned cert_issuer_key_type;
3124 const br_multihash_context *mhash;
3125 const br_ec_impl *iec;
3126 br_ecdsa_sign iecdsa;
3127 #endif
3128 } br_ssl_server_policy_ec_context;
3129
3130 /**
3131 * \brief Class type for a session parameter cache.
3132 *
3133 * Session parameters are saved in the cache with `save()`, and
3134 * retrieved with `load()`. The cache implementation can apply any
3135 * storage and eviction strategy that it sees fit. The SSL server
3136 * context that performs the request is provided, so that its
3137 * functionalities may be used by the implementation (e.g. hash
3138 * functions or random number generation).
3139 */
3140 typedef struct br_ssl_session_cache_class_ br_ssl_session_cache_class;
3141 struct br_ssl_session_cache_class_ {
3142 /**
3143 * \brief Context size (in bytes).
3144 */
3145 size_t context_size;
3146
3147 /**
3148 * \brief Record a session.
3149 *
3150 * This callback should record the provided session parameters.
3151 * The `params` structure is transient, so its contents shall
3152 * be copied into the cache. The session ID has been randomly
3153 * generated and always has length exactly 32 bytes.
3154 *
3155 * \param ctx session cache context.
3156 * \param server_ctx SSL server context.
3157 * \param params session parameters to save.
3158 */
3159 void (*save)(const br_ssl_session_cache_class **ctx,
3160 br_ssl_server_context *server_ctx,
3161 const br_ssl_session_parameters *params);
3162
3163 /**
3164 * \brief Lookup a session in the cache.
3165 *
3166 * The session ID to lookup is in `params` and always has length
3167 * exactly 32 bytes. If the session parameters are found in the
3168 * cache, then the parameters shall be copied into the `params`
3169 * structure. Returned value is 1 on successful lookup, 0
3170 * otherwise.
3171 *
3172 * \param ctx session cache context.
3173 * \param server_ctx SSL server context.
3174 * \param params destination for session parameters.
3175 * \return 1 if found, 0 otherwise.
3176 */
3177 int (*load)(const br_ssl_session_cache_class **ctx,
3178 br_ssl_server_context *server_ctx,
3179 br_ssl_session_parameters *params);
3180 };
3181
3182 /**
3183 * \brief Context for a basic cache system.
3184 *
3185 * The system stores session parameters in a buffer provided at
3186 * initialisation time. Each entry uses exactly 100 bytes, and
3187 * buffer sizes up to 4294967295 bytes are supported.
3188 *
3189 * Entries are evicted with a LRU (Least Recently Used) policy. A
3190 * search tree is maintained to keep lookups fast even with large
3191 * caches.
3192 *
3193 * Apart from the first field (vtable pointer), the structure
3194 * contents are opaque and shall not be accessed directly.
3195 */
3196 typedef struct {
3197 /** \brief Pointer to vtable. */
3198 const br_ssl_session_cache_class *vtable;
3199 #ifndef BR_DOXYGEN_IGNORE
3200 unsigned char *store;
3201 size_t store_len, store_ptr;
3202 unsigned char index_key[32];
3203 const br_hash_class *hash;
3204 int init_done;
3205 uint32_t head, tail, root;
3206 #endif
3207 } br_ssl_session_cache_lru;
3208
3209 /**
3210 * \brief Initialise a LRU session cache with the provided storage space.
3211 *
3212 * The provided storage space must remain valid as long as the cache
3213 * is used. Arbitrary lengths are supported, up to 4294967295 bytes;
3214 * each entry uses up exactly 100 bytes.
3215 *
3216 * \param cc session cache context.
3217 * \param store storage space for cached entries.
3218 * \param store_len storage space length (in bytes).
3219 */
3220 void br_ssl_session_cache_lru_init(br_ssl_session_cache_lru *cc,
3221 unsigned char *store, size_t store_len);
3222
3223 /**
3224 * \brief Forget an entry in an LRU session cache.
3225 *
3226 * The session cache context must have been initialised. The entry
3227 * with the provided session ID (of exactly 32 bytes) is looked for
3228 * in the cache; if located, it is disabled.
3229 *
3230 * \param cc session cache context.
3231 * \param id session ID to forget.
3232 */
3233 void br_ssl_session_cache_lru_forget(
3234 br_ssl_session_cache_lru *cc, const unsigned char *id);
3235
3236 /**
3237 * \brief Context structure for a SSL server.
3238 *
3239 * The first field (called `eng`) is the SSL engine; all functions that
3240 * work on a `br_ssl_engine_context` structure shall take as parameter
3241 * a pointer to that field. The other structure fields are opaque and
3242 * must not be accessed directly.
3243 */
3244 struct br_ssl_server_context_ {
3245 /**
3246 * \brief The encapsulated engine context.
3247 */
3248 br_ssl_engine_context eng;
3249
3250 #ifndef BR_DOXYGEN_IGNORE
3251 /*
3252 * Maximum version from the client.
3253 */
3254 uint16_t client_max_version;
3255
3256 /*
3257 * Session cache.
3258 */
3259 const br_ssl_session_cache_class **cache_vtable;
3260
3261 /*
3262 * Translated cipher suites supported by the client. The list
3263 * is trimmed to include only the cipher suites that the
3264 * server also supports; they are in the same order as in the
3265 * client message.
3266 */
3267 br_suite_translated client_suites[BR_MAX_CIPHER_SUITES];
3268 unsigned char client_suites_num;
3269
3270 /*
3271 * Hash functions supported by the client, with ECDSA and RSA
3272 * (bit mask). For hash function with id 'x', set bit index is
3273 * x for RSA, x+8 for ECDSA. For newer algorithms, with ID
3274 * 0x08**, bit 16+k is set for algorithm 0x0800+k.
3275 */
3276 uint32_t hashes;
3277
3278 /*
3279 * Curves supported by the client (bit mask, for named curves).
3280 */
3281 uint32_t curves;
3282
3283 /*
3284 * Context for chain handler.
3285 */
3286 const br_ssl_server_policy_class **policy_vtable;
3287 uint16_t sign_hash_id;
3288
3289 /*
3290 * For the core handlers, thus avoiding (in most cases) the
3291 * need for an externally provided policy context.
3292 */
3293 union {
3294 const br_ssl_server_policy_class *vtable;
3295 br_ssl_server_policy_rsa_context single_rsa;
3296 br_ssl_server_policy_ec_context single_ec;
3297 } chain_handler;
3298
3299 /*
3300 * Buffer for the ECDHE private key.
3301 */
3302 unsigned char ecdhe_key[70];
3303 size_t ecdhe_key_len;
3304
3305 /*
3306 * Trust anchor names for client authentication. "ta_names" and
3307 * "tas" cannot be both non-NULL.
3308 */
3309 const br_x500_name *ta_names;
3310 const br_x509_trust_anchor *tas;
3311 size_t num_tas;
3312 size_t cur_dn_index;
3313 const unsigned char *cur_dn;
3314 size_t cur_dn_len;
3315
3316 /*
3317 * Buffer for the hash value computed over all handshake messages
3318 * prior to CertificateVerify, and identifier for the hash function.
3319 */
3320 unsigned char hash_CV[64];
3321 size_t hash_CV_len;
3322 int hash_CV_id;
3323
3324 /*
3325 * Server-specific implementations.
3326 * (none for now)
3327 */
3328 #endif
3329 };
3330
3331 /*
3332 * Each br_ssl_server_init_xxx() function sets the list of supported
3333 * cipher suites and used implementations, as specified by the profile
3334 * name 'xxx'. Defined profile names are:
3335 *
3336 * full_rsa all supported algorithm, server key type is RSA
3337 * full_ec all supported algorithm, server key type is EC
3338 * TODO: add other profiles
3339 *
3340 * Naming scheme for "minimal" profiles: min123
3341 *
3342 * -- character 1: key exchange
3343 * r = RSA
3344 * e = ECDHE_RSA
3345 * f = ECDHE_ECDSA
3346 * u = ECDH_RSA
3347 * v = ECDH_ECDSA
3348 * -- character 2: version / PRF
3349 * 0 = TLS 1.0 / 1.1 with MD5+SHA-1
3350 * 2 = TLS 1.2 with SHA-256
3351 * 3 = TLS 1.2 with SHA-384
3352 * -- character 3: encryption
3353 * a = AES/CBC
3354 * d = 3DES/CBC
3355 * g = AES/GCM
3356 * c = ChaCha20+Poly1305
3357 */
3358
3359 /**
3360 * \brief SSL server profile: full_rsa.
3361 *
3362 * This function initialises the provided SSL server context with
3363 * all supported algorithms and cipher suites that rely on a RSA
3364 * key pair.
3365 *
3366 * \param cc server context to initialise.
3367 * \param chain server certificate chain.
3368 * \param chain_len certificate chain length (number of certificate).
3369 * \param sk RSA private key.
3370 */
3371 void br_ssl_server_init_full_rsa(br_ssl_server_context *cc,
3372 const br_x509_certificate *chain, size_t chain_len,
3373 const br_rsa_private_key *sk);
3374
3375 /**
3376 * \brief SSL server profile: full_ec.
3377 *
3378 * This function initialises the provided SSL server context with
3379 * all supported algorithms and cipher suites that rely on an EC
3380 * key pair.
3381 *
3382 * The key type of the CA that issued the server's certificate must
3383 * be provided, since it matters for ECDH cipher suites (ECDH_RSA
3384 * suites require a RSA-powered CA). The key type is either
3385 * `BR_KEYTYPE_RSA` or `BR_KEYTYPE_EC`.
3386 *
3387 * \param cc server context to initialise.
3388 * \param chain server certificate chain.
3389 * \param chain_len chain length (number of certificates).
3390 * \param cert_issuer_key_type certificate issuer's key type.
3391 * \param sk EC private key.
3392 */
3393 void br_ssl_server_init_full_ec(br_ssl_server_context *cc,
3394 const br_x509_certificate *chain, size_t chain_len,
3395 unsigned cert_issuer_key_type, const br_ec_private_key *sk);
3396
3397 /**
3398 * \brief SSL server profile: minr2g.
3399 *
3400 * This profile uses only TLS_RSA_WITH_AES_128_GCM_SHA256. Server key is
3401 * RSA, and RSA key exchange is used (not forward secure, but uses little
3402 * CPU in the client).
3403 *
3404 * \param cc server context to initialise.
3405 * \param chain server certificate chain.
3406 * \param chain_len certificate chain length (number of certificate).
3407 * \param sk RSA private key.
3408 */
3409 void br_ssl_server_init_minr2g(br_ssl_server_context *cc,
3410 const br_x509_certificate *chain, size_t chain_len,
3411 const br_rsa_private_key *sk);
3412
3413 /**
3414 * \brief SSL server profile: mine2g.
3415 *
3416 * This profile uses only TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256. Server key
3417 * is RSA, and ECDHE key exchange is used. This suite provides forward
3418 * security, with a higher CPU expense on the client, and a somewhat
3419 * larger code footprint (compared to "minr2g").
3420 *
3421 * \param cc server context to initialise.
3422 * \param chain server certificate chain.
3423 * \param chain_len certificate chain length (number of certificate).
3424 * \param sk RSA private key.
3425 */
3426 void br_ssl_server_init_mine2g(br_ssl_server_context *cc,
3427 const br_x509_certificate *chain, size_t chain_len,
3428 const br_rsa_private_key *sk);
3429
3430 /**
3431 * \brief SSL server profile: minf2g.
3432 *
3433 * This profile uses only TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.
3434 * Server key is EC, and ECDHE key exchange is used. This suite provides
3435 * forward security, with a higher CPU expense on the client and server
3436 * (by a factor of about 3 to 4), and a somewhat larger code footprint
3437 * (compared to "minu2g" and "minv2g").
3438 *
3439 * \param cc server context to initialise.
3440 * \param chain server certificate chain.
3441 * \param chain_len certificate chain length (number of certificate).
3442 * \param sk EC private key.
3443 */
3444 void br_ssl_server_init_minf2g(br_ssl_server_context *cc,
3445 const br_x509_certificate *chain, size_t chain_len,
3446 const br_ec_private_key *sk);
3447
3448 /**
3449 * \brief SSL server profile: minu2g.
3450 *
3451 * This profile uses only TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256.
3452 * Server key is EC, and ECDH key exchange is used; the issuing CA used
3453 * a RSA key.
3454 *
3455 * The "minu2g" and "minv2g" profiles do not provide forward secrecy,
3456 * but are the lightest on the server (for CPU usage), and are rather
3457 * inexpensive on the client as well.
3458 *
3459 * \param cc server context to initialise.
3460 * \param chain server certificate chain.
3461 * \param chain_len certificate chain length (number of certificate).
3462 * \param sk EC private key.
3463 */
3464 void br_ssl_server_init_minu2g(br_ssl_server_context *cc,
3465 const br_x509_certificate *chain, size_t chain_len,
3466 const br_ec_private_key *sk);
3467
3468 /**
3469 * \brief SSL server profile: minv2g.
3470 *
3471 * This profile uses only TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256.
3472 * Server key is EC, and ECDH key exchange is used; the issuing CA used
3473 * an EC key.
3474 *
3475 * The "minu2g" and "minv2g" profiles do not provide forward secrecy,
3476 * but are the lightest on the server (for CPU usage), and are rather
3477 * inexpensive on the client as well.
3478 *
3479 * \param cc server context to initialise.
3480 * \param chain server certificate chain.
3481 * \param chain_len certificate chain length (number of certificate).
3482 * \param sk EC private key.
3483 */
3484 void br_ssl_server_init_minv2g(br_ssl_server_context *cc,
3485 const br_x509_certificate *chain, size_t chain_len,
3486 const br_ec_private_key *sk);
3487
3488 /**
3489 * \brief SSL server profile: mine2c.
3490 *
3491 * This profile uses only TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256.
3492 * Server key is RSA, and ECDHE key exchange is used. This suite
3493 * provides forward security.
3494 *
3495 * \param cc server context to initialise.
3496 * \param chain server certificate chain.
3497 * \param chain_len certificate chain length (number of certificate).
3498 * \param sk RSA private key.
3499 */
3500 void br_ssl_server_init_mine2c(br_ssl_server_context *cc,
3501 const br_x509_certificate *chain, size_t chain_len,
3502 const br_rsa_private_key *sk);
3503
3504 /**
3505 * \brief SSL server profile: minf2c.
3506 *
3507 * This profile uses only TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256.
3508 * Server key is EC, and ECDHE key exchange is used. This suite provides
3509 * forward security.
3510 *
3511 * \param cc server context to initialise.
3512 * \param chain server certificate chain.
3513 * \param chain_len certificate chain length (number of certificate).
3514 * \param sk EC private key.
3515 */
3516 void br_ssl_server_init_minf2c(br_ssl_server_context *cc,
3517 const br_x509_certificate *chain, size_t chain_len,
3518 const br_ec_private_key *sk);
3519
3520 /**
3521 * \brief Get the supported client suites.
3522 *
3523 * This function shall be called only after the ClientHello has been
3524 * processed, typically from the policy engine. The returned array
3525 * contains the cipher suites that are supported by both the client
3526 * and the server; these suites are in client preference order, unless
3527 * the `BR_OPT_ENFORCE_SERVER_PREFERENCES` flag was set, in which case
3528 * they are in server preference order.
3529 *
3530 * The suites are _translated_, which means that each suite is given
3531 * as two 16-bit integers: the standard suite identifier, and its
3532 * translated version, broken down into its individual components,
3533 * as explained with the `br_suite_translated` type.
3534 *
3535 * The returned array is allocated in the context and will be rewritten
3536 * by each handshake.
3537 *
3538 * \param cc server context.
3539 * \param num receives the array size (number of suites).
3540 * \return the translated common cipher suites, in preference order.
3541 */
3542 static inline const br_suite_translated *
3543 br_ssl_server_get_client_suites(const br_ssl_server_context *cc, size_t *num)
3544 {
3545 *num = cc->client_suites_num;
3546 return cc->client_suites;
3547 }
3548
3549 /**
3550 * \brief Get the hash functions and signature algorithms supported by
3551 * the client.
3552 *
3553 * This value is a bit field:
3554 *
3555 * - If RSA (PKCS#1 v1.5) is supported with hash function of ID `x`,
3556 * then bit `x` is set (hash function ID is 0 for the special MD5+SHA-1,
3557 * or 2 to 6 for the SHA family).
3558 *
3559 * - If ECDSA is suported with hash function of ID `x`, then bit `8+x`
3560 * is set.
3561 *
3562 * - Newer algorithms are symbolic 16-bit identifiers that do not
3563 * represent signature algorithm and hash function separately. If
3564 * the TLS-level identifier is `0x0800+x` for a `x` in the 0..15
3565 * range, then bit `16+x` is set.
3566 *
3567 * "New algorithms" are currently defined only in draft documents, so
3568 * this support is subject to possible change. Right now (early 2017),
3569 * this maps ed25519 (EdDSA on Curve25519) to bit 23, and ed448 (EdDSA
3570 * on Curve448) to bit 24. If the identifiers on the wire change in
3571 * future document, then the decoding mechanism in BearSSL will be
3572 * amended to keep mapping ed25519 and ed448 on bits 23 and 24,
3573 * respectively. Mapping of other new algorithms (e.g. RSA/PSS) is not
3574 * guaranteed yet.
3575 *
3576 * \param cc server context.
3577 * \return the client-supported hash functions and signature algorithms.
3578 */
3579 static inline uint32_t
3580 br_ssl_server_get_client_hashes(const br_ssl_server_context *cc)
3581 {
3582 return cc->hashes;
3583 }
3584
3585 /**
3586 * \brief Get the elliptic curves supported by the client.
3587 *
3588 * This is a bit field (bit x is set if curve of ID x is supported).
3589 *
3590 * \param cc server context.
3591 * \return the client-supported elliptic curves.
3592 */
3593 static inline uint32_t
3594 br_ssl_server_get_client_curves(const br_ssl_server_context *cc)
3595 {
3596 return cc->curves;
3597 }
3598
3599 /**
3600 * \brief Clear the complete contents of a SSL server context.
3601 *
3602 * Everything is cleared, including the reference to the configured buffer,
3603 * implementations, cipher suites and state. This is a preparatory step
3604 * to assembling a custom profile.
3605 *
3606 * \param cc server context to clear.
3607 */
3608 void br_ssl_server_zero(br_ssl_server_context *cc);
3609
3610 /**
3611 * \brief Set an externally provided policy context.
3612 *
3613 * The policy context's methods are invoked to decide the cipher suite
3614 * and certificate chain, and to perform operations involving the server's
3615 * private key.
3616 *
3617 * \param cc server context.
3618 * \param pctx policy context (pointer to its vtable field).
3619 */
3620 static inline void
3621 br_ssl_server_set_policy(br_ssl_server_context *cc,
3622 const br_ssl_server_policy_class **pctx)
3623 {
3624 cc->policy_vtable = pctx;
3625 }
3626
3627 /**
3628 * \brief Set the server certificate chain and key (single RSA case).
3629 *
3630 * This function uses a policy context included in the server context.
3631 * It configures use of a single server certificate chain with a RSA
3632 * private key. The `allowed_usages` is a combination of usages, namely
3633 * `BR_KEYTYPE_KEYX` and/or `BR_KEYTYPE_SIGN`; this enables or disables
3634 * the corresponding cipher suites (i.e. `TLS_RSA_*` use the RSA key for
3635 * key exchange, while `TLS_ECDHE_RSA_*` use the RSA key for signatures).
3636 *
3637 * \param cc server context.
3638 * \param chain server certificate chain to send to the client.
3639 * \param chain_len chain length (number of certificates).
3640 * \param sk server private key (RSA).
3641 * \param allowed_usages allowed private key usages.
3642 * \param irsacore RSA core implementation.
3643 * \param irsasign RSA signature implementation (PKCS#1 v1.5).
3644 */
3645 void br_ssl_server_set_single_rsa(br_ssl_server_context *cc,
3646 const br_x509_certificate *chain, size_t chain_len,
3647 const br_rsa_private_key *sk, unsigned allowed_usages,
3648 br_rsa_private irsacore, br_rsa_pkcs1_sign irsasign);
3649
3650 /**
3651 * \brief Set the server certificate chain and key (single EC case).
3652 *
3653 * This function uses a policy context included in the server context.
3654 * It configures use of a single server certificate chain with an EC
3655 * private key. The `allowed_usages` is a combination of usages, namely
3656 * `BR_KEYTYPE_KEYX` and/or `BR_KEYTYPE_SIGN`; this enables or disables
3657 * the corresponding cipher suites (i.e. `TLS_ECDH_*` use the EC key for
3658 * key exchange, while `TLS_ECDHE_ECDSA_*` use the EC key for signatures).
3659 *
3660 * In order to support `TLS_ECDH_*` cipher suites (non-ephemeral ECDH),
3661 * the algorithm type of the key used by the issuing CA to sign the
3662 * server's certificate must be provided, as `cert_issuer_key_type`
3663 * parameter (this value is either `BR_KEYTYPE_RSA` or `BR_KEYTYPE_EC`).
3664 *
3665 * \param cc server context.
3666 * \param chain server certificate chain to send.
3667 * \param chain_len chain length (number of certificates).
3668 * \param sk server private key (EC).
3669 * \param allowed_usages allowed private key usages.
3670 * \param cert_issuer_key_type issuing CA's key type.
3671 * \param iec EC core implementation.
3672 * \param iecdsa ECDSA signature implementation ("asn1" format).
3673 */
3674 void br_ssl_server_set_single_ec(br_ssl_server_context *cc,
3675 const br_x509_certificate *chain, size_t chain_len,
3676 const br_ec_private_key *sk, unsigned allowed_usages,
3677 unsigned cert_issuer_key_type,
3678 const br_ec_impl *iec, br_ecdsa_sign iecdsa);
3679
3680 /**
3681 * \brief Activate client certificate authentication.
3682 *
3683 * The trust anchor encoded X.500 names (DN) to send to the client are
3684 * provided. A client certificate will be requested and validated through
3685 * the X.509 validator configured in the SSL engine. If `num` is 0, then
3686 * client certificate authentication is disabled.
3687 *
3688 * If the client does not send a certificate, or on validation failure,
3689 * the handshake aborts. Unauthenticated clients can be tolerated by
3690 * setting the `BR_OPT_TOLERATE_NO_CLIENT_AUTH` flag.
3691 *
3692 * The provided array is linked in, not copied, so that pointer must
3693 * remain valid as long as anchor names may be used.
3694 *
3695 * \param cc server context.
3696 * \param ta_names encoded trust anchor names.
3697 * \param num number of encoded trust anchor names.
3698 */
3699 static inline void
3700 br_ssl_server_set_trust_anchor_names(br_ssl_server_context *cc,
3701 const br_x500_name *ta_names, size_t num)
3702 {
3703 cc->ta_names = ta_names;
3704 cc->tas = NULL;
3705 cc->num_tas = num;
3706 }
3707
3708 /**
3709 * \brief Activate client certificate authentication.
3710 *
3711 * This is a variant for `br_ssl_server_set_trust_anchor_names()`: the
3712 * trust anchor names are provided not as an array of stand-alone names
3713 * (`br_x500_name` structures), but as an array of trust anchors
3714 * (`br_x509_trust_anchor` structures). The server engine itself will
3715 * only use the `dn` field of each trust anchor. This is meant to allow
3716 * defining a single array of trust anchors, to be used here and in the
3717 * X.509 validation engine itself.
3718 *
3719 * The provided array is linked in, not copied, so that pointer must
3720