custom_profile.c
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 #include "bearssl.h" 26 27 /* 28 * A "profile" is an initialisation function for a SSL context, that 29 * configures a list of cipher suites and algorithm implementations. 30 * While BearSSL comes with a few predefined profiles, you might one 31 * to define you own, using the example below as guidance. 32 * 33 * Each individual initialisation call sets a parameter or an algorithm 34 * support. Setting a specific algorithm pulls in the implementation of 35 * that algorithm in the compiled binary, as per static linking 36 * behaviour. Removing some of this calls will then reduce total code 37 * footprint, but also mechanically prevents some features to be 38 * supported (protocol versions and cipher suites). 39 * 40 * The two below define profiles for the client and the server contexts, 41 * respectively. Of course, in a typical size-constrained application, 42 * you would use one or the other, not both, to avoid pulling in code 43 * for both. 44 */ 45 46 void 47 example_client_profile(br_ssl_client_context *cc 48 /* and possibly some other arguments */) 49 { 50 /* 51 * A list of cipher suites, by preference (first is most 52 * preferred). The list below contains all cipher suites supported 53 * by BearSSL; trim it done to your needs. 54 */ 55 static const uint16_t suites[] = { 56 BR_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 57 BR_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 58 BR_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 59 BR_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 60 BR_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 61 BR_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 62 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, 63 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 64 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, 65 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, 66 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, 67 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, 68 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, 69 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, 70 BR_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, 71 BR_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, 72 BR_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, 73 BR_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, 74 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, 75 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, 76 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, 77 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, 78 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, 79 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, 80 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, 81 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, 82 BR_TLS_RSA_WITH_AES_128_GCM_SHA256, 83 BR_TLS_RSA_WITH_AES_256_GCM_SHA384, 84 BR_TLS_RSA_WITH_AES_128_CBC_SHA256, 85 BR_TLS_RSA_WITH_AES_256_CBC_SHA256, 86 BR_TLS_RSA_WITH_AES_128_CBC_SHA, 87 BR_TLS_RSA_WITH_AES_256_CBC_SHA, 88 BR_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, 89 BR_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, 90 BR_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, 91 BR_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, 92 BR_TLS_RSA_WITH_3DES_EDE_CBC_SHA 93 }; 94 95 /* 96 * Client context must be cleared at some point. This sets 97 * every value and pointer to 0 or NULL. 98 */ 99 br_ssl_client_zero(cc); 100 101 /* 102 * Define minimum and maximum protocol versions. Supported 103 * versions are: 104 * BR_TLS10 TLS 1.0 105 * BR_TLS11 TLS 1.1 106 * BR_TLS12 TLS 1.2 107 */ 108 br_ssl_engine_set_versions(&cc->eng, BR_TLS10, BR_TLS12); 109 110 /* 111 * Set the PRF implementation(s). 112 * For TLS 1.0 and 1.1, the "prf10" is needed. 113 * For TLS 1.2, this depends on the cipher suite: 114 * -- cipher suites with a name ending in "SHA384" need "prf_sha384"; 115 * -- all others need "prf_sha256". 116 * 117 * Note that a cipher suite like TLS_RSA_WITH_AES_128_CBC_SHA will 118 * use SHA-1 for the per-record MAC (that's what the final "SHA" 119 * means), but still SHA-256 for the PRF when selected along with 120 * the TLS-1.2 protocol version. 121 */ 122 br_ssl_engine_set_prf10(&cc->eng, &br_tls10_prf); 123 br_ssl_engine_set_prf_sha256(&cc->eng, &br_tls12_sha256_prf); 124 br_ssl_engine_set_prf_sha384(&cc->eng, &br_tls12_sha384_prf); 125 126 /* 127 * Set hash functions for the engine. Required hash functions 128 * depend on the protocol and cipher suite: 129 * 130 * -- TLS 1.0 and 1.1 require both MD5 and SHA-1. 131 * -- With TLS 1.2, cipher suites with a name ending in "SHA384" 132 * require SHA-384. 133 * -- With TLS 1.2, cipher suites with a name ending in "SHA256" 134 * require SHA-256. 135 * -- With TLS 1.2, cipher suites with a name ending in "SHA" 136 * require both SHA-256 and SHA-1. 137 * 138 * Moreover, these hash functions are also used to compute 139 * hashes supporting signatures on the server side (for ECDHE_* 140 * cipher suites), and on the client side (for client 141 * certificates, except in the case of full static ECDH). In TLS 142 * 1.0 and 1.1, SHA-1 (and also MD5) will be used, but with TLS 143 * 1.2 these hash functions are negotiated between client and 144 * server; SHA-256 and/or SHA-384 should be sufficient in 145 * practice. 146 * 147 * Note that with current implementations, SHA-224 and SHA-256 148 * share the same file, so if you use one, you may have the other 149 * one with no additional overhead. Similarly, SHA-384 and SHA-512 150 * share the same implementation code. 151 */ 152 br_ssl_engine_set_hash(&cc->eng, br_md5_ID, &br_md5_vtable); 153 br_ssl_engine_set_hash(&cc->eng, br_sha1_ID, &br_sha1_vtable); 154 br_ssl_engine_set_hash(&cc->eng, br_sha224_ID, &br_sha224_vtable); 155 br_ssl_engine_set_hash(&cc->eng, br_sha256_ID, &br_sha256_vtable); 156 br_ssl_engine_set_hash(&cc->eng, br_sha384_ID, &br_sha384_vtable); 157 br_ssl_engine_set_hash(&cc->eng, br_sha512_ID, &br_sha512_vtable); 158 159 /* 160 * Set the cipher suites. All specified cipher suite MUST be 161 * supported, and the relevant algorithms MUST have been 162 * configured (failure to provide needed implementations may 163 * trigger unwanted behaviours like segfaults or overflows). 164 */ 165 br_ssl_engine_set_suites(&cc->eng, suites, 166 (sizeof suites) / (sizeof suites[0])); 167 168 /* 169 * Public-key algorithm implementations. 170 * 171 * -- RSA public core ("rsapub") is needed for "RSA" key exchange 172 * (cipher suites whose name starts with TLS_RSA). 173 * 174 * -- RSA signature verification ("rsavrfy") is needed for 175 * "ECDHE_RSA" cipher suites (not ECDH_RSA). 176 * 177 * -- Elliptic curve implementation ("ec") is needed for cipher 178 * suites that use elliptic curves (both "ECDH" and "ECDHE" 179 * cipher suites). 180 * 181 * -- ECDSA signature verification is needed for "ECDHE_ECDSA" 182 * cipher suites (but not for ECDHE_RSA, ECDH_ECDSA or ECDH_RSA). 183 * 184 * Normally, you use the "default" implementations, obtained 185 * through relevant function calls. These functions return 186 * implementations that are deemed "best" for the current 187 * platform, where "best" means "fastest within constant-time 188 * implementations". Selecting the default implementation is a 189 * mixture of compile-time and runtime checks. 190 * 191 * Nevertheless, specific implementations may be selected 192 * explicitly, e.g. to use code which is slower but with a 193 * smaller footprint. 194 * 195 * The RSA code comes in three variants, called "i15", "i31" and 196 * "i32". The "i31" code is somewhat faster than the "i32" code. 197 * Usually, "i31" is faster than "i15", except on some specific 198 * architectures (ARM Cortex M0, M0+, M1 and M3) where the "i15" 199 * should be preferred (the "i15" code is constant-time, while 200 * the "i31" is not, and the "i15" code is faster anyway). 201 * 202 * ECDSA code also comes in "i15" and "i31" variants. As in the 203 * case of RSA, the "i31" code is faster, except on the small 204 * ARM Cortex M, where the "i15" code is faster and safer. 205 * 206 * There are no less than 10 elliptic curve implementations: 207 * 208 * - ec_c25519_i15, ec_c25519_i31, ec_c25519_m15 and ec_c25519_m31 209 * implement Curve25519. 210 * 211 * - ec_p256_m15 and ec_p256_m31 implement NIST curve P-256. 212 * 213 * - ec_prime_i15 and ec_prime_i31 implement NIST curves P-256, 214 * P-384 and P-521. 215 * 216 * - ec_all_m15 is an aggregate implementation that uses 217 * ec_c25519_m15, ec_p256_m15 and ec_prime_i15. 218 * 219 * - ec_all_m31 is an aggregate implementation that uses 220 * ec_c25519_m31, ec_p256_m31 and ec_prime_i31. 221 * 222 * For a given curve, "m15" is faster than "i15" (but possibly 223 * with a larger code footprint) and "m31" is faster than "i31" 224 * (there again with a larger code footprint). For best 225 * performance, use ec_all_m31, except on the small ARM Cortex M 226 * where ec_all_m15 should be used. Referencing the other 227 * implementations directly will result in smaller code, but 228 * support for fewer curves and possibly lower performance. 229 */ 230 br_ssl_client_set_default_rsapub(cc); 231 br_ssl_engine_set_default_rsavrfy(&cc->eng); 232 br_ssl_engine_set_default_ecdsa(&cc->eng); 233 /* Alternate: set implementations explicitly. 234 br_ssl_client_set_rsapub(cc, &br_rsa_i31_public); 235 br_ssl_client_set_rsavrfy(cc, &br_rsa_i31_pkcs1_vrfy); 236 br_ssl_engine_set_ec(&cc->eng, &br_ec_all_m31); 237 br_ssl_engine_set_ecdsa(&cc->eng, &br_ecdsa_i31_vrfy_asn1); 238 */ 239 240 /* 241 * Record handler: 242 * -- Cipher suites in AES_128_CBC, AES_256_CBC and 3DES_EDE_CBC 243 * need the CBC record handler ("set_cbc"). 244 * -- Cipher suites in AES_128_GCM and AES_256_GCM need the GCM 245 * record handler ("set_gcm"). 246 * -- Cipher suites in CHACHA20_POLY1305 need the ChaCha20+Poly1305 247 * record handler ("set_chapol"). 248 */ 249 br_ssl_engine_set_cbc(&cc->eng, 250 &br_sslrec_in_cbc_vtable, 251 &br_sslrec_out_cbc_vtable); 252 br_ssl_engine_set_gcm(&cc->eng, 253 &br_sslrec_in_gcm_vtable, 254 &br_sslrec_out_gcm_vtable); 255 br_ssl_engine_set_chapol(&cc->eng, 256 &br_sslrec_in_chapol_vtable, 257 &br_sslrec_out_chapol_vtable); 258 259 /* 260 * Symmetric encryption: 261 * -- AES_128_CBC and AES_256_CBC require an "aes_cbc" implementation 262 * (actually two implementations, for encryption and decryption). 263 * -- 3DES_EDE_CBC requires a "des_cbc" implementation 264 * (actually two implementations, for encryption and decryption). 265 * -- AES_128_GCM and AES_256_GCM require an "aes_ctr" imeplementation 266 * and also a GHASH implementation. 267 * 268 * Two 3DES implementations are provided: 269 * 270 * des_tab Classical table-based implementation; it is 271 * not constant-time. 272 * 273 * dest_ct Constant-time DES/3DES implementation. It is 274 * slower than des_tab. 275 * 276 * Four AES implementations are provided: 277 * 278 * aes_ct Constant-time AES implementation, for 32-bit 279 * systems. 280 * 281 * aes_ct64 Constant-time AES implementation, for 64-bit 282 * systems. It actually also runs on 32-bit systems, 283 * but, on such systems, it yields larger code and 284 * slightly worse performance. On 64-bit systems, 285 * aes_ct64 is about twice faster than aes_ct for 286 * CTR processing (GCM encryption and decryption), 287 * and for CBC (decryption only). 288 * 289 * aes_small Smallest implementation provided, but also the 290 * slowest, and it is not constant-time. Use it 291 * only if desperate for code size. 292 * 293 * aes_big Classical table-based AES implementation. This 294 * is decently fast and still resonably compact, 295 * but it is not constant-time. 296 * 297 * aes_x86ni Very fast implementation that uses the AES-NI 298 * opcodes on recent x86 CPU. But it may not be 299 * compiled in the library if the compiler or 300 * architecture is not supported; and the CPU 301 * may also not support the opcodes. Selection 302 * functions are provided to test for availability 303 * of the code and the opcodes. 304 * 305 * Whether having constant-time implementations is absolutely 306 * required for security depends on the context (in particular 307 * whether the target architecture actually has cache memory), 308 * and while side-channel analysis for non-constant-time AES 309 * code has been demonstrated in lab conditions, it certainly 310 * does not apply to all actual usages, and it has never been 311 * spotted in the wild. It is still considered cautious to use 312 * constant-time code by default, and to consider the other 313 * implementations only if duly measured performance issues make 314 * it mandatory. 315 */ 316 br_ssl_engine_set_aes_cbc(&cc->eng, 317 &br_aes_ct_cbcenc_vtable, 318 &br_aes_ct_cbcdec_vtable); 319 br_ssl_engine_set_aes_ctr(&cc->eng, 320 &br_aes_ct_ctr_vtable); 321 /* Alternate: aes_ct64 322 br_ssl_engine_set_aes_cbc(&cc->eng, 323 &br_aes_ct64_cbcenc_vtable, 324 &br_aes_ct64_cbcdec_vtable); 325 br_ssl_engine_set_aes_ctr(&cc->eng, 326 &br_aes_ct64_ctr_vtable); 327 */ 328 /* Alternate: aes_small 329 br_ssl_engine_set_aes_cbc(&cc->eng, 330 &br_aes_small_cbcenc_vtable, 331 &br_aes_small_cbcdec_vtable); 332 br_ssl_engine_set_aes_ctr(&cc->eng, 333 &br_aes_small_ctr_vtable); 334 */ 335 /* Alternate: aes_big 336 br_ssl_engine_set_aes_cbc(&cc->eng, 337 &br_aes_big_cbcenc_vtable, 338 &br_aes_big_cbcdec_vtable); 339 br_ssl_engine_set_aes_ctr(&cc->eng, 340 &br_aes_big_ctr_vtable); 341 */ 342 br_ssl_engine_set_des_cbc(&cc->eng, 343 &br_des_ct_cbcenc_vtable, 344 &br_des_ct_cbcdec_vtable); 345 /* Alternate: des_tab 346 br_ssl_engine_set_des_cbc(&cc->eng, 347 &br_des_tab_cbcenc_vtable, 348 &br_des_tab_cbcdec_vtable); 349 */ 350 351 /* 352 * GHASH is needed for AES_128_GCM and AES_256_GCM. Three 353 * implementations are provided: 354 * 355 * ctmul Uses 32-bit multiplications with a 64-bit result. 356 * 357 * ctmul32 Uses 32-bit multiplications with a 32-bit result. 358 * 359 * ctmul64 Uses 64-bit multiplications with a 64-bit result. 360 * 361 * On 64-bit platforms, ctmul64 is the smallest and fastest of 362 * the three. On 32-bit systems, ctmul should be preferred. The 363 * ctmul32 implementation is meant to be used for the specific 364 * 32-bit systems that do not have a 32x32->64 multiplier (i.e. 365 * the ARM Cortex-M0 and Cortex-M0+). 366 * 367 * These implementations are all constant-time as long as the 368 * underlying multiplication opcode is constant-time (which is 369 * true for all modern systems, but not for older architectures 370 * such that ARM9 or 80486). 371 */ 372 br_ssl_engine_set_ghash(&cc->eng, 373 &br_ghash_ctmul); 374 /* Alternate: ghash_ctmul32 375 br_ssl_engine_set_ghash(&cc->eng, 376 &br_ghash_ctmul32); 377 */ 378 /* Alternate: ghash_ctmul64 379 br_ssl_engine_set_ghash(&cc->eng, 380 &br_ghash_ctmul64); 381 */ 382 383 #if 0 384 /* 385 * For a client, the normal case is to validate the server 386 * certificate with regards to a set of trust anchors. This 387 * entails using a br_x509_minimal_context structure, configured 388 * with the relevant algorithms, as shown below. 389 * 390 * Alternatively, the client could "know" the intended server 391 * public key through an out-of-band mechanism, in which case 392 * a br_x509_knownkey_context is appropriate, for a much reduced 393 * code footprint. 394 * 395 * We assume here that the following extra parameters have been 396 * provided: 397 * 398 * xc engine context (br_x509_minimal_context *) 399 * trust_anchors trust anchors (br_x509_trust_anchor *) 400 * trust_anchors_num number of trust anchors (size_t) 401 */ 402 403 /* 404 * The X.509 engine needs a hash function for processing the 405 * subject and issuer DN of certificates and trust anchors. Any 406 * supported hash function is appropriate; here we use SHA-256. 407 * The trust an 408 */ 409 br_x509_minimal_init(xc, &br_sha256_vtable, 410 trust_anchors, trust_anchors_num); 411 412 /* 413 * Set suites and asymmetric crypto implementations. We use the 414 * "i31" code for RSA (it is somewhat faster than the "i32" 415 * implementation). These implementations are used for 416 * signature verification on certificates, but not for the 417 * SSL-specific usage of the server's public key. For instance, 418 * if the server has an EC public key but the rest of the chain 419 * (intermediate CA, root...) use RSA, then you would need only 420 * the RSA verification function below. 421 */ 422 br_x509_minimal_set_rsa(xc, &br_rsa_i31_pkcs1_vrfy); 423 br_x509_minimal_set_ecdsa(xc, 424 &br_ec_prime_i31, &br_ecdsa_i31_vrfy_asn1); 425 426 /* 427 * Set supported hash functions. These are for signatures on 428 * certificates. There again, you only need the hash functions 429 * that are actually used in certificates, but if a given 430 * function was included for the SSL engine, you may as well 431 * add it here. 432 * 433 * Note: the engine explicitly rejects signatures that use MD5. 434 * Thus, there is no need for MD5 here. 435 */ 436 br_ssl_engine_set_hash(xc, br_sha1_ID, &br_sha1_vtable); 437 br_ssl_engine_set_hash(xc, br_sha224_ID, &br_sha224_vtable); 438 br_ssl_engine_set_hash(xc, br_sha256_ID, &br_sha256_vtable); 439 br_ssl_engine_set_hash(xc, br_sha384_ID, &br_sha384_vtable); 440 br_ssl_engine_set_hash(xc, br_sha512_ID, &br_sha512_vtable); 441 442 /* 443 * Link the X.509 engine in the SSL engine. 444 */ 445 br_ssl_engine_set_x509(&cc->eng, &xc->vtable); 446 #endif 447 } 448 449 /* 450 * Example server profile. Most of it is shared with the client 451 * profile, so see the comments in the client function for details. 452 * 453 * This example function assumes a server with a (unique) RSA private 454 * key, so the list of cipher suites is trimmed down for RSA. 455 */ 456 void 457 example_server_profile(br_ssl_server_context *cc, 458 const br_x509_certificate *chain, size_t chain_len, 459 const br_rsa_private_key *sk) 460 { 461 static const uint16_t suites[] = { 462 BR_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 463 BR_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 464 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 465 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, 466 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, 467 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, 468 BR_TLS_RSA_WITH_AES_128_GCM_SHA256, 469 BR_TLS_RSA_WITH_AES_256_GCM_SHA384, 470 BR_TLS_RSA_WITH_AES_128_CBC_SHA256, 471 BR_TLS_RSA_WITH_AES_256_CBC_SHA256, 472 BR_TLS_RSA_WITH_AES_128_CBC_SHA, 473 BR_TLS_RSA_WITH_AES_256_CBC_SHA, 474 BR_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, 475 BR_TLS_RSA_WITH_3DES_EDE_CBC_SHA 476 }; 477 478 br_ssl_server_zero(cc); 479 br_ssl_engine_set_versions(&cc->eng, BR_TLS10, BR_TLS12); 480 481 br_ssl_engine_set_prf10(&cc->eng, &br_tls10_prf); 482 br_ssl_engine_set_prf_sha256(&cc->eng, &br_tls12_sha256_prf); 483 br_ssl_engine_set_prf_sha384(&cc->eng, &br_tls12_sha384_prf); 484 485 /* 486 * Apart from the requirements listed in the client side, these 487 * hash functions are also used by the server to compute its 488 * signature on ECDHE parameters. Which functions are needed 489 * depends on what the client may support; furthermore, the 490 * client may fail to send the relevant extension, in which 491 * case the server will default to whatever it can (as per the 492 * standard, it should be SHA-1 in that case). 493 */ 494 br_ssl_engine_set_hash(&cc->eng, br_md5_ID, &br_md5_vtable); 495 br_ssl_engine_set_hash(&cc->eng, br_sha1_ID, &br_sha1_vtable); 496 br_ssl_engine_set_hash(&cc->eng, br_sha224_ID, &br_sha224_vtable); 497 br_ssl_engine_set_hash(&cc->eng, br_sha256_ID, &br_sha256_vtable); 498 br_ssl_engine_set_hash(&cc->eng, br_sha384_ID, &br_sha384_vtable); 499 br_ssl_engine_set_hash(&cc->eng, br_sha512_ID, &br_sha512_vtable); 500 501 br_ssl_engine_set_suites(&cc->eng, suites, 502 (sizeof suites) / (sizeof suites[0])); 503 504 /* 505 * Elliptic curve implementation is used for ECDHE suites (but 506 * not for ECDH). 507 */ 508 br_ssl_engine_set_ec(&cc->eng, &br_ec_prime_i31); 509 510 /* 511 * Set the "server policy": handler for the certificate chain 512 * and private key operations. Here, we indicate that the RSA 513 * private key is fit for both signing and decrypting, and we 514 * provide the two relevant implementations. 515 516 * BR_KEYTYPE_KEYX allows TLS_RSA_*, BR_KEYTYPE_SIGN allows 517 * TLS_ECDHE_RSA_*. 518 */ 519 br_ssl_server_set_single_rsa(cc, chain, chain_len, sk, 520 BR_KEYTYPE_KEYX | BR_KEYTYPE_SIGN, 521 br_rsa_i31_private, br_rsa_i31_pkcs1_sign); 522 /* 523 * If the server used an EC private key, this call would look 524 * like this: 525 526 br_ssl_server_set_single_ec(cc, chain, chain_len, sk, 527 BR_KEYTYPE_KEYX | BR_KEYTYPE_SIGN, 528 cert_issuer_key_type, 529 &br_ec_prime_i31, br_ecdsa_i31_sign_asn1); 530 531 * Note the tricky points: 532 * 533 * -- "ECDH" cipher suites use only the EC code (&br_ec_prime_i31); 534 * the ECDHE_ECDSA cipher suites need both the EC code and 535 * the ECDSA signature implementation. 536 * 537 * -- For "ECDH" (not "ECDHE") cipher suites, the engine must 538 * know the key type (RSA or EC) for the intermediate CA that 539 * issued the server's certificate; this is an artefact of 540 * how the protocol is defined. BearSSL won't try to decode 541 * the server's certificate to obtain that information (it 542 * could do that, the code is there, but it would increase the 543 * footprint). So this must be provided by the caller. 544 * 545 * -- BR_KEYTYPE_KEYX allows ECDH, BR_KEYTYPE_SIGN allows 546 * ECDHE_ECDSA. 547 */ 548 549 br_ssl_engine_set_cbc(&cc->eng, 550 &br_sslrec_in_cbc_vtable, 551 &br_sslrec_out_cbc_vtable); 552 br_ssl_engine_set_gcm(&cc->eng, 553 &br_sslrec_in_gcm_vtable, 554 &br_sslrec_out_gcm_vtable); 555 556 br_ssl_engine_set_aes_cbc(&cc->eng, 557 &br_aes_ct_cbcenc_vtable, 558 &br_aes_ct_cbcdec_vtable); 559 br_ssl_engine_set_aes_ctr(&cc->eng, 560 &br_aes_ct_ctr_vtable); 561 /* Alternate: aes_ct64 562 br_ssl_engine_set_aes_cbc(&cc->eng, 563 &br_aes_ct64_cbcenc_vtable, 564 &br_aes_ct64_cbcdec_vtable); 565 br_ssl_engine_set_aes_ctr(&cc->eng, 566 &br_aes_ct64_ctr_vtable); 567 */ 568 /* Alternate: aes_small 569 br_ssl_engine_set_aes_cbc(&cc->eng, 570 &br_aes_small_cbcenc_vtable, 571 &br_aes_small_cbcdec_vtable); 572 br_ssl_engine_set_aes_ctr(&cc->eng, 573 &br_aes_small_ctr_vtable); 574 */ 575 /* Alternate: aes_big 576 br_ssl_engine_set_aes_cbc(&cc->eng, 577 &br_aes_big_cbcenc_vtable, 578 &br_aes_big_cbcdec_vtable); 579 br_ssl_engine_set_aes_ctr(&cc->eng, 580 &br_aes_big_ctr_vtable); 581 */ 582 br_ssl_engine_set_des_cbc(&cc->eng, 583 &br_des_ct_cbcenc_vtable, 584 &br_des_ct_cbcdec_vtable); 585 /* Alternate: des_tab 586 br_ssl_engine_set_des_cbc(&cc->eng, 587 &br_des_tab_cbcenc_vtable, 588 &br_des_tab_cbcdec_vtable); 589 */ 590 591 br_ssl_engine_set_ghash(&cc->eng, 592 &br_ghash_ctmul); 593 /* Alternate: ghash_ctmul32 594 br_ssl_engine_set_ghash(&cc->eng, 595 &br_ghash_ctmul32); 596 */ 597 /* Alternate: ghash_ctmul64 598 br_ssl_engine_set_ghash(&cc->eng, 599 &br_ghash_ctmul64); 600 */ 601 }