names.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 "brssl.h" 26 #include "bearssl.h" 27 28 /* see brssl.h */ 29 const protocol_version protocol_versions[] = { 30 { "tls10", BR_TLS10, "TLS 1.0" }, 31 { "tls11", BR_TLS11, "TLS 1.1" }, 32 { "tls12", BR_TLS12, "TLS 1.2" }, 33 { NULL, 0, NULL } 34 }; 35 36 /* see brssl.h */ 37 const hash_function hash_functions[] = { 38 { "md5", &br_md5_vtable, "MD5" }, 39 { "sha1", &br_sha1_vtable, "SHA-1" }, 40 { "sha224", &br_sha224_vtable, "SHA-224" }, 41 { "sha256", &br_sha256_vtable, "SHA-256" }, 42 { "sha384", &br_sha384_vtable, "SHA-384" }, 43 { "sha512", &br_sha512_vtable, "SHA-512" }, 44 { NULL, 0, NULL } 45 }; 46 47 /* see brssl.h */ 48 const cipher_suite cipher_suites[] = { 49 { 50 "ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", 51 BR_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 52 REQ_ECDHE_ECDSA | REQ_CHAPOL | REQ_SHA256 | REQ_TLS12, 53 "ECDHE with ECDSA, ChaCha20+Poly1305 encryption (TLS 1.2+)" 54 }, 55 { 56 "ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 57 BR_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 58 REQ_ECDHE_RSA | REQ_CHAPOL | REQ_SHA256 | REQ_TLS12, 59 "ECDHE with RSA, ChaCha20+Poly1305 encryption (TLS 1.2+)" 60 }, 61 { 62 "ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", 63 BR_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 64 REQ_ECDHE_ECDSA | REQ_AESGCM | REQ_SHA256 | REQ_TLS12, 65 "ECDHE with ECDSA, AES-128/GCM encryption (TLS 1.2+)" 66 }, 67 { 68 "ECDHE_RSA_WITH_AES_128_GCM_SHA256", 69 BR_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 70 REQ_ECDHE_RSA | REQ_AESGCM | REQ_SHA256 | REQ_TLS12, 71 "ECDHE with RSA, AES-128/GCM encryption (TLS 1.2+)" 72 }, 73 { 74 "ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", 75 BR_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 76 REQ_ECDHE_ECDSA | REQ_AESGCM | REQ_SHA384 | REQ_TLS12, 77 "ECDHE with ECDSA, AES-256/GCM encryption (TLS 1.2+)" 78 }, 79 { 80 "ECDHE_RSA_WITH_AES_256_GCM_SHA384", 81 BR_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 82 REQ_ECDHE_RSA | REQ_AESGCM | REQ_SHA384 | REQ_TLS12, 83 "ECDHE with RSA, AES-256/GCM encryption (TLS 1.2+)" 84 }, 85 { 86 "ECDHE_ECDSA_WITH_AES_128_CCM", 87 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CCM, 88 REQ_ECDHE_ECDSA | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 89 "ECDHE with ECDSA, AES-128/CCM encryption (TLS 1.2+)" 90 }, 91 { 92 "ECDHE_ECDSA_WITH_AES_256_CCM", 93 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CCM, 94 REQ_ECDHE_ECDSA | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 95 "ECDHE with ECDSA, AES-256/CCM encryption (TLS 1.2+)" 96 }, 97 { 98 "ECDHE_ECDSA_WITH_AES_128_CCM_8", 99 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, 100 REQ_ECDHE_ECDSA | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 101 "ECDHE with ECDSA, AES-128/CCM_8 encryption (TLS 1.2+)" 102 }, 103 { 104 "ECDHE_ECDSA_WITH_AES_256_CCM_8", 105 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8, 106 REQ_ECDHE_ECDSA | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 107 "ECDHE with ECDSA, AES-256/CCM_8 encryption (TLS 1.2+)" 108 }, 109 { 110 "ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", 111 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, 112 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 113 "ECDHE with ECDSA, AES-128/CBC + SHA-256 (TLS 1.2+)" 114 }, 115 { 116 "ECDHE_RSA_WITH_AES_128_CBC_SHA256", 117 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 118 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 119 "ECDHE with RSA, AES-128/CBC + SHA-256 (TLS 1.2+)" 120 }, 121 { 122 "ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", 123 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, 124 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA384 | REQ_TLS12, 125 "ECDHE with ECDSA, AES-256/CBC + SHA-384 (TLS 1.2+)" 126 }, 127 { 128 "ECDHE_RSA_WITH_AES_256_CBC_SHA384", 129 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, 130 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA384 | REQ_TLS12, 131 "ECDHE with RSA, AES-256/CBC + SHA-384 (TLS 1.2+)" 132 }, 133 { 134 "ECDHE_ECDSA_WITH_AES_128_CBC_SHA", 135 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, 136 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA1, 137 "ECDHE with ECDSA, AES-128/CBC + SHA-1" 138 }, 139 { 140 "ECDHE_RSA_WITH_AES_128_CBC_SHA", 141 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, 142 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA1, 143 "ECDHE with RSA, AES-128/CBC + SHA-1" 144 }, 145 { 146 "ECDHE_ECDSA_WITH_AES_256_CBC_SHA", 147 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, 148 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA1, 149 "ECDHE with ECDSA, AES-256/CBC + SHA-1" 150 }, 151 { 152 "ECDHE_RSA_WITH_AES_256_CBC_SHA", 153 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, 154 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA1, 155 "ECDHE with RSA, AES-256/CBC + SHA-1" 156 }, 157 { 158 "ECDH_ECDSA_WITH_AES_128_GCM_SHA256", 159 BR_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, 160 REQ_ECDH | REQ_AESGCM | REQ_SHA256 | REQ_TLS12, 161 "ECDH key exchange (EC cert), AES-128/GCM (TLS 1.2+)" 162 }, 163 { 164 "ECDH_RSA_WITH_AES_128_GCM_SHA256", 165 BR_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, 166 REQ_ECDH | REQ_AESGCM | REQ_SHA256 | REQ_TLS12, 167 "ECDH key exchange (RSA cert), AES-128/GCM (TLS 1.2+)" 168 }, 169 { 170 "ECDH_ECDSA_WITH_AES_256_GCM_SHA384", 171 BR_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, 172 REQ_ECDH | REQ_AESGCM | REQ_SHA384 | REQ_TLS12, 173 "ECDH key exchange (EC cert), AES-256/GCM (TLS 1.2+)" 174 }, 175 { 176 "ECDH_RSA_WITH_AES_256_GCM_SHA384", 177 BR_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, 178 REQ_ECDH | REQ_AESGCM | REQ_SHA384 | REQ_TLS12, 179 "ECDH key exchange (RSA cert), AES-256/GCM (TLS 1.2+)" 180 }, 181 { 182 "ECDH_ECDSA_WITH_AES_128_CBC_SHA256", 183 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, 184 REQ_ECDH | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 185 "ECDH key exchange (EC cert), AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)" 186 }, 187 { 188 "ECDH_RSA_WITH_AES_128_CBC_SHA256", 189 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, 190 REQ_ECDH | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 191 "ECDH key exchange (RSA cert), AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)" 192 }, 193 { 194 "ECDH_ECDSA_WITH_AES_256_CBC_SHA384", 195 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, 196 REQ_ECDH | REQ_AESCBC | REQ_SHA384 | REQ_TLS12, 197 "ECDH key exchange (EC cert), AES-256/CBC + HMAC/SHA-384 (TLS 1.2+)" 198 }, 199 { 200 "ECDH_RSA_WITH_AES_256_CBC_SHA384", 201 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, 202 REQ_ECDH | REQ_AESCBC | REQ_SHA384 | REQ_TLS12, 203 "ECDH key exchange (RSA cert), AES-256/CBC + HMAC/SHA-384 (TLS 1.2+)" 204 }, 205 { 206 "ECDH_ECDSA_WITH_AES_128_CBC_SHA", 207 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, 208 REQ_ECDH | REQ_AESCBC | REQ_SHA1, 209 "ECDH key exchange (EC cert), AES-128/CBC + HMAC/SHA-1" 210 }, 211 { 212 "ECDH_RSA_WITH_AES_128_CBC_SHA", 213 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, 214 REQ_ECDH | REQ_AESCBC | REQ_SHA1, 215 "ECDH key exchange (RSA cert), AES-128/CBC + HMAC/SHA-1" 216 }, 217 { 218 "ECDH_ECDSA_WITH_AES_256_CBC_SHA", 219 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, 220 REQ_ECDH | REQ_AESCBC | REQ_SHA1, 221 "ECDH key exchange (EC cert), AES-256/CBC + HMAC/SHA-1" 222 }, 223 { 224 "ECDH_RSA_WITH_AES_256_CBC_SHA", 225 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, 226 REQ_ECDH | REQ_AESCBC | REQ_SHA1, 227 "ECDH key exchange (RSA cert), AES-256/CBC + HMAC/SHA-1" 228 }, 229 { 230 "RSA_WITH_AES_128_GCM_SHA256", 231 BR_TLS_RSA_WITH_AES_128_GCM_SHA256, 232 REQ_RSAKEYX | REQ_AESGCM | REQ_SHA256 | REQ_TLS12, 233 "RSA key exchange, AES-128/GCM encryption (TLS 1.2+)" 234 }, 235 { 236 "RSA_WITH_AES_256_GCM_SHA384", 237 BR_TLS_RSA_WITH_AES_256_GCM_SHA384, 238 REQ_RSAKEYX | REQ_AESGCM | REQ_SHA384 | REQ_TLS12, 239 "RSA key exchange, AES-256/GCM encryption (TLS 1.2+)" 240 }, 241 { 242 "RSA_WITH_AES_128_CCM", 243 BR_TLS_RSA_WITH_AES_128_CCM, 244 REQ_RSAKEYX | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 245 "RSA key exchange, AES-128/CCM encryption (TLS 1.2+)" 246 }, 247 { 248 "RSA_WITH_AES_256_CCM", 249 BR_TLS_RSA_WITH_AES_256_CCM, 250 REQ_RSAKEYX | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 251 "RSA key exchange, AES-256/CCM encryption (TLS 1.2+)" 252 }, 253 { 254 "RSA_WITH_AES_128_CCM_8", 255 BR_TLS_RSA_WITH_AES_128_CCM_8, 256 REQ_RSAKEYX | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 257 "RSA key exchange, AES-128/CCM_8 encryption (TLS 1.2+)" 258 }, 259 { 260 "RSA_WITH_AES_256_CCM_8", 261 BR_TLS_RSA_WITH_AES_256_CCM_8, 262 REQ_RSAKEYX | REQ_AESCCM | REQ_SHA256 | REQ_TLS12, 263 "RSA key exchange, AES-256/CCM_8 encryption (TLS 1.2+)" 264 }, 265 { 266 "RSA_WITH_AES_128_CBC_SHA256", 267 BR_TLS_RSA_WITH_AES_128_CBC_SHA256, 268 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 269 "RSA key exchange, AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)" 270 }, 271 { 272 "RSA_WITH_AES_256_CBC_SHA256", 273 BR_TLS_RSA_WITH_AES_256_CBC_SHA256, 274 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA256 | REQ_TLS12, 275 "RSA key exchange, AES-256/CBC + HMAC/SHA-256 (TLS 1.2+)" 276 }, 277 { 278 "RSA_WITH_AES_128_CBC_SHA", 279 BR_TLS_RSA_WITH_AES_128_CBC_SHA, 280 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA1, 281 "RSA key exchange, AES-128/CBC + HMAC/SHA-1" 282 }, 283 { 284 "RSA_WITH_AES_256_CBC_SHA", 285 BR_TLS_RSA_WITH_AES_256_CBC_SHA, 286 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA1, 287 "RSA key exchange, AES-256/CBC + HMAC/SHA-1" 288 }, 289 { 290 "ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA", 291 BR_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, 292 REQ_ECDHE_ECDSA | REQ_3DESCBC | REQ_SHA1, 293 "ECDHE with ECDSA, 3DES/CBC + SHA-1" 294 }, 295 { 296 "ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", 297 BR_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, 298 REQ_ECDHE_RSA | REQ_3DESCBC | REQ_SHA1, 299 "ECDHE with RSA, 3DES/CBC + SHA-1" 300 }, 301 { 302 "ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", 303 BR_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, 304 REQ_ECDH | REQ_3DESCBC | REQ_SHA1, 305 "ECDH key exchange (EC cert), 3DES/CBC + HMAC/SHA-1" 306 }, 307 { 308 "ECDH_RSA_WITH_3DES_EDE_CBC_SHA", 309 BR_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, 310 REQ_ECDH | REQ_3DESCBC | REQ_SHA1, 311 "ECDH key exchange (RSA cert), 3DES/CBC + HMAC/SHA-1" 312 }, 313 { 314 "RSA_WITH_3DES_EDE_CBC_SHA", 315 BR_TLS_RSA_WITH_3DES_EDE_CBC_SHA, 316 REQ_RSAKEYX | REQ_3DESCBC | REQ_SHA1, 317 "RSA key exchange, 3DES/CBC + HMAC/SHA-1" 318 }, 319 { NULL, 0, 0, NULL } 320 }; 321 322 static const struct { 323 int id; 324 const char *name; 325 const char *sid[4]; 326 } curves[] = { 327 { BR_EC_sect163k1, 328 "sect163k1", 329 { "sect163k1", "K-163", NULL, NULL } }, 330 { BR_EC_sect163r1, 331 "sect163r1", 332 { "sect163r1", NULL, NULL, NULL } }, 333 { BR_EC_sect163r2, 334 "sect163r2", 335 { "sect163r2", "B-163", NULL, NULL } }, 336 { BR_EC_sect193r1, 337 "sect193r1", 338 { "sect193r1", NULL, NULL, NULL } }, 339 { BR_EC_sect193r2, 340 "sect193r2", 341 { "sect193r2", NULL, NULL, NULL } }, 342 { BR_EC_sect233k1, 343 "sect233k1", 344 { "sect233k1", "K-233", NULL, NULL } }, 345 { BR_EC_sect233r1, 346 "sect233r1", 347 { "sect233r1", "B-233", NULL, NULL } }, 348 { BR_EC_sect239k1, 349 "sect239k1", 350 { "sect239k1", NULL, NULL, NULL } }, 351 { BR_EC_sect283k1, 352 "sect283k1", 353 { "sect283k1", "K-283", NULL, NULL } }, 354 { BR_EC_sect283r1, 355 "sect283r1", 356 { "sect283r1", "B-283", NULL, NULL } }, 357 { BR_EC_sect409k1, 358 "sect409k1", 359 { "sect409k1", "K-409", NULL, NULL } }, 360 { BR_EC_sect409r1, 361 "sect409r1", 362 { "sect409r1", "B-409", NULL, NULL } }, 363 { BR_EC_sect571k1, 364 "sect571k1", 365 { "sect571k1", "K-571", NULL, NULL } }, 366 { BR_EC_sect571r1, 367 "sect571r1", 368 { "sect571r1", "B-571", NULL, NULL } }, 369 { BR_EC_secp160k1, 370 "secp160k1", 371 { "secp160k1", NULL, NULL, NULL } }, 372 { BR_EC_secp160r1, 373 "secp160r1", 374 { "secp160r1", NULL, NULL, NULL } }, 375 { BR_EC_secp160r2, 376 "secp160r2", 377 { "secp160r2", NULL, NULL, NULL } }, 378 { BR_EC_secp192k1, 379 "secp192k1", 380 { "secp192k1", NULL, NULL, NULL } }, 381 { BR_EC_secp192r1, 382 "secp192r1", 383 { "secp192r1", "P-192", NULL, NULL } }, 384 { BR_EC_secp224k1, 385 "secp224k1", 386 { "secp224k1", NULL, NULL, NULL } }, 387 { BR_EC_secp224r1, 388 "secp224r1", 389 { "secp224r1", "P-224", NULL, NULL } }, 390 { BR_EC_secp256k1, 391 "secp256k1", 392 { "secp256k1", NULL, NULL, NULL } }, 393 { BR_EC_secp256r1, 394 "secp256r1 (P-256)", 395 { "secp256r1", "P-256", "prime256v1", NULL } }, 396 { BR_EC_secp384r1, 397 "secp384r1 (P-384)", 398 { "secp384r1", "P-384", NULL, NULL } }, 399 { BR_EC_secp521r1, 400 "secp521r1 (P-521)", 401 { "secp521r1", "P-521", NULL, NULL } }, 402 { BR_EC_brainpoolP256r1, 403 "brainpoolP256r1", 404 { "brainpoolP256r1", NULL, NULL, NULL } }, 405 { BR_EC_brainpoolP384r1, 406 "brainpoolP384r1", 407 { "brainpoolP384r1", NULL, NULL, NULL } }, 408 { BR_EC_brainpoolP512r1, 409 "brainpoolP512r1", 410 { "brainpoolP512r1", NULL, NULL, NULL } }, 411 { BR_EC_curve25519, 412 "Curve25519", 413 { "curve25519", "c25519", NULL, NULL } }, 414 { BR_EC_curve448, 415 "Curve448", 416 { "curve448", "c448", NULL, NULL } }, 417 { 0, 0, { 0, 0, 0, 0 } } 418 }; 419 420 static const struct { 421 const char *long_name; 422 const char *short_name; 423 const void *impl; 424 } algo_names[] = { 425 /* Block ciphers */ 426 { "aes_big_cbcenc", "big", &br_aes_big_cbcenc_vtable }, 427 { "aes_big_cbcdec", "big", &br_aes_big_cbcdec_vtable }, 428 { "aes_big_ctr", "big", &br_aes_big_ctr_vtable }, 429 { "aes_big_ctrcbc", "big", &br_aes_big_ctrcbc_vtable }, 430 { "aes_small_cbcenc", "small", &br_aes_small_cbcenc_vtable }, 431 { "aes_small_cbcdec", "small", &br_aes_small_cbcdec_vtable }, 432 { "aes_small_ctr", "small", &br_aes_small_ctr_vtable }, 433 { "aes_small_ctrcbc", "small", &br_aes_small_ctrcbc_vtable }, 434 { "aes_ct_cbcenc", "ct", &br_aes_ct_cbcenc_vtable }, 435 { "aes_ct_cbcdec", "ct", &br_aes_ct_cbcdec_vtable }, 436 { "aes_ct_ctr", "ct", &br_aes_ct_ctr_vtable }, 437 { "aes_ct_ctrcbc", "ct", &br_aes_ct_ctrcbc_vtable }, 438 { "aes_ct64_cbcenc", "ct64", &br_aes_ct64_cbcenc_vtable }, 439 { "aes_ct64_cbcdec", "ct64", &br_aes_ct64_cbcdec_vtable }, 440 { "aes_ct64_ctr", "ct64", &br_aes_ct64_ctr_vtable }, 441 { "aes_ct64_ctrcbc", "ct64", &br_aes_ct64_ctrcbc_vtable }, 442 443 { "des_tab_cbcenc", "tab", &br_des_tab_cbcenc_vtable }, 444 { "des_tab_cbcdec", "tab", &br_des_tab_cbcdec_vtable }, 445 { "des_ct_cbcenc", "ct", &br_des_ct_cbcenc_vtable }, 446 { "des_ct_cbcdec", "ct", &br_des_ct_cbcdec_vtable }, 447 448 { "chacha20_ct", "ct", &br_chacha20_ct_run }, 449 450 { "ghash_ctmul", "ctmul", &br_ghash_ctmul }, 451 { "ghash_ctmul32", "ctmul32", &br_ghash_ctmul32 }, 452 { "ghash_ctmul64", "ctmul64", &br_ghash_ctmul64 }, 453 454 { "poly1305_ctmul", "ctmul", &br_poly1305_ctmul_run }, 455 { "poly1305_ctmul32", "ctmul32", &br_poly1305_ctmul32_run }, 456 457 { "ec_all_m15", "all_m15", &br_ec_all_m15 }, 458 { "ec_all_m31", "all_m31", &br_ec_all_m31 }, 459 { "ec_c25519_i15", "c25519_i15", &br_ec_c25519_i15 }, 460 { "ec_c25519_i31", "c25519_i31", &br_ec_c25519_i31 }, 461 { "ec_c25519_m15", "c25519_m15", &br_ec_c25519_m15 }, 462 { "ec_c25519_m31", "c25519_m31", &br_ec_c25519_m31 }, 463 { "ec_p256_m15", "p256_m15", &br_ec_p256_m15 }, 464 { "ec_p256_m31", "p256_m31", &br_ec_p256_m31 }, 465 { "ec_prime_i15", "prime_i15", &br_ec_prime_i15 }, 466 { "ec_prime_i31", "prime_i31", &br_ec_prime_i31 }, 467 468 { "ecdsa_i15_sign_asn1", "i15_asn1", &br_ecdsa_i15_sign_asn1 }, 469 { "ecdsa_i15_sign_raw", "i15_raw", &br_ecdsa_i15_sign_raw }, 470 { "ecdsa_i31_sign_asn1", "i31_asn1", &br_ecdsa_i31_sign_asn1 }, 471 { "ecdsa_i31_sign_raw", "i31_raw", &br_ecdsa_i31_sign_raw }, 472 { "ecdsa_i15_vrfy_asn1", "i15_asn1", &br_ecdsa_i15_vrfy_asn1 }, 473 { "ecdsa_i15_vrfy_raw", "i15_raw", &br_ecdsa_i15_vrfy_raw }, 474 { "ecdsa_i31_vrfy_asn1", "i31_asn1", &br_ecdsa_i31_vrfy_asn1 }, 475 { "ecdsa_i31_vrfy_raw", "i31_raw", &br_ecdsa_i31_vrfy_raw }, 476 477 { "rsa_i15_pkcs1_sign", "i15", &br_rsa_i15_pkcs1_sign }, 478 { "rsa_i31_pkcs1_sign", "i31", &br_rsa_i31_pkcs1_sign }, 479 { "rsa_i32_pkcs1_sign", "i32", &br_rsa_i32_pkcs1_sign }, 480 { "rsa_i15_pkcs1_vrfy", "i15", &br_rsa_i15_pkcs1_vrfy }, 481 { "rsa_i31_pkcs1_vrfy", "i31", &br_rsa_i31_pkcs1_vrfy }, 482 { "rsa_i32_pkcs1_vrfy", "i32", &br_rsa_i32_pkcs1_vrfy }, 483 484 { 0, 0, 0 } 485 }; 486 487 static const struct { 488 const char *long_name; 489 const char *short_name; 490 const void *(*get)(void); 491 } algo_names_dyn[] = { 492 { "aes_pwr8_cbcenc", "pwr8", 493 (const void *(*)(void))&br_aes_pwr8_cbcenc_get_vtable }, 494 { "aes_pwr8_cbcdec", "pwr8", 495 (const void *(*)(void))&br_aes_pwr8_cbcdec_get_vtable }, 496 { "aes_pwr8_ctr", "pwr8", 497 (const void *(*)(void))&br_aes_pwr8_ctr_get_vtable }, 498 { "aes_pwr8_ctrcbc", "pwr8", 499 (const void *(*)(void))&br_aes_pwr8_ctrcbc_get_vtable }, 500 { "aes_x86ni_cbcenc", "x86ni", 501 (const void *(*)(void))&br_aes_x86ni_cbcenc_get_vtable }, 502 { "aes_x86ni_cbcdec", "x86ni", 503 (const void *(*)(void))&br_aes_x86ni_cbcdec_get_vtable }, 504 { "aes_x86ni_ctr", "x86ni", 505 (const void *(*)(void))&br_aes_x86ni_ctr_get_vtable }, 506 { "aes_x86ni_ctrcbc", "x86ni", 507 (const void *(*)(void))&br_aes_x86ni_ctrcbc_get_vtable }, 508 { "chacha20_sse2", "sse2", 509 (const void *(*)(void))&br_chacha20_sse2_get }, 510 { "ghash_pclmul", "pclmul", 511 (const void *(*)(void))&br_ghash_pclmul_get }, 512 { "ghash_pwr8", "pwr8", 513 (const void *(*)(void))&br_ghash_pwr8_get }, 514 { "poly1305_ctmulq", "ctmulq", 515 (const void *(*)(void))&br_poly1305_ctmulq_get }, 516 { "rsa_i62_pkcs1_sign", "i62", 517 (const void *(*)(void))&br_rsa_i62_pkcs1_sign_get }, 518 { "rsa_i62_pkcs1_vrfy", "i62", 519 (const void *(*)(void))&br_rsa_i62_pkcs1_vrfy_get }, 520 { "ec_c25519_m62", "m62", 521 (const void *(*)(void))&br_ec_c25519_m62_get }, 522 { "ec_c25519_m64", "m64", 523 (const void *(*)(void))&br_ec_c25519_m64_get }, 524 { "ec_p256_m62", "m62", 525 (const void *(*)(void))&br_ec_p256_m62_get }, 526 { "ec_p256_m64", "m64", 527 (const void *(*)(void))&br_ec_p256_m64_get }, 528 { 0, 0, 0, } 529 }; 530 531 /* see brssl.h */ 532 const char * 533 get_algo_name(const void *impl, int long_name) 534 { 535 size_t u; 536 537 for (u = 0; algo_names[u].long_name; u ++) { 538 if (impl == algo_names[u].impl) { 539 return long_name 540 ? algo_names[u].long_name 541 : algo_names[u].short_name; 542 } 543 } 544 for (u = 0; algo_names_dyn[u].long_name; u ++) { 545 if (impl == algo_names_dyn[u].get()) { 546 return long_name 547 ? algo_names_dyn[u].long_name 548 : algo_names_dyn[u].short_name; 549 } 550 } 551 return "UNKNOWN"; 552 } 553 554 /* see brssl.h */ 555 const char * 556 get_curve_name(int id) 557 { 558 size_t u; 559 560 for (u = 0; curves[u].name; u ++) { 561 if (curves[u].id == id) { 562 return curves[u].name; 563 } 564 } 565 return NULL; 566 } 567 568 /* see brssl.h */ 569 int 570 get_curve_name_ext(int id, char *dst, size_t len) 571 { 572 const char *name; 573 char tmp[30]; 574 size_t n; 575 576 name = get_curve_name(id); 577 if (name == NULL) { 578 sprintf(tmp, "unknown (%d)", id); 579 name = tmp; 580 } 581 n = 1 + strlen(name); 582 if (n > len) { 583 if (len > 0) { 584 dst[0] = 0; 585 } 586 return -1; 587 } 588 memcpy(dst, name, n); 589 return 0; 590 } 591 592 /* see brssl.h */ 593 const char * 594 get_suite_name(unsigned suite) 595 { 596 size_t u; 597 598 for (u = 0; cipher_suites[u].name; u ++) { 599 if (cipher_suites[u].suite == suite) { 600 return cipher_suites[u].name; 601 } 602 } 603 return NULL; 604 } 605 606 /* see brssl.h */ 607 int 608 get_suite_name_ext(unsigned suite, char *dst, size_t len) 609 { 610 const char *name; 611 char tmp[30]; 612 size_t n; 613 614 name = get_suite_name(suite); 615 if (name == NULL) { 616 sprintf(tmp, "unknown (0x%04X)", suite); 617 name = tmp; 618 } 619 n = 1 + strlen(name); 620 if (n > len) { 621 if (len > 0) { 622 dst[0] = 0; 623 } 624 return -1; 625 } 626 memcpy(dst, name, n); 627 return 0; 628 } 629 630 /* see brssl.h */ 631 int 632 uses_ecdhe(unsigned suite) 633 { 634 size_t u; 635 636 for (u = 0; cipher_suites[u].name; u ++) { 637 if (cipher_suites[u].suite == suite) { 638 return (cipher_suites[u].req 639 & (REQ_ECDHE_RSA | REQ_ECDHE_ECDSA)) != 0; 640 } 641 } 642 return 0; 643 } 644 645 /* see brssl.h */ 646 void 647 list_names(void) 648 { 649 size_t u; 650 651 printf("Protocol versions:\n"); 652 for (u = 0; protocol_versions[u].name; u ++) { 653 printf(" %-8s %s\n", 654 protocol_versions[u].name, 655 protocol_versions[u].comment); 656 } 657 printf("Hash functions:\n"); 658 for (u = 0; hash_functions[u].name; u ++) { 659 printf(" %-8s %s\n", 660 hash_functions[u].name, 661 hash_functions[u].comment); 662 } 663 printf("Cipher suites:\n"); 664 for (u = 0; cipher_suites[u].name; u ++) { 665 printf(" %s\n %s\n", 666 cipher_suites[u].name, 667 cipher_suites[u].comment); 668 } 669 } 670 671 /* see brssl.h */ 672 void 673 list_curves(void) 674 { 675 size_t u; 676 for (u = 0; curves[u].name; u ++) { 677 size_t v; 678 679 for (v = 0; curves[u].sid[v]; v ++) { 680 if (v == 0) { 681 printf(" "); 682 } else if (v == 1) { 683 printf(" ("); 684 } else { 685 printf(", "); 686 } 687 printf("%s", curves[u].sid[v]); 688 } 689 if (v > 1) { 690 printf(")"); 691 } 692 printf("\n"); 693 } 694 } 695 696 static int 697 is_ign(int c) 698 { 699 if (c == 0) { 700 return 0; 701 } 702 if (c <= 32 || c == '-' || c == '_' || c == '.' 703 || c == '/' || c == '+' || c == ':') 704 { 705 return 1; 706 } 707 return 0; 708 } 709 710 /* 711 * Get next non-ignored character, normalised: 712 * ASCII letters are converted to lowercase 713 * control characters, space, '-', '_', '.', '/', '+' and ':' are ignored 714 * A terminating zero is returned as 0. 715 */ 716 static int 717 next_char(const char **ps, const char *limit) 718 { 719 for (;;) { 720 int c; 721 722 if (*ps == limit) { 723 return 0; 724 } 725 c = *(*ps) ++; 726 if (c == 0) { 727 return 0; 728 } 729 if (c >= 'A' && c <= 'Z') { 730 c += 'a' - 'A'; 731 } 732 if (!is_ign(c)) { 733 return c; 734 } 735 } 736 } 737 738 /* 739 * Partial string equality comparison, with normalisation. 740 */ 741 static int 742 eqstr_chunk(const char *s1, size_t s1_len, const char *s2, size_t s2_len) 743 { 744 const char *lim1, *lim2; 745 746 lim1 = s1 + s1_len; 747 lim2 = s2 + s2_len; 748 for (;;) { 749 int c1, c2; 750 751 c1 = next_char(&s1, lim1); 752 c2 = next_char(&s2, lim2); 753 if (c1 != c2) { 754 return 0; 755 } 756 if (c1 == 0) { 757 return 1; 758 } 759 } 760 } 761 762 /* see brssl.h */ 763 int 764 eqstr(const char *s1, const char *s2) 765 { 766 return eqstr_chunk(s1, strlen(s1), s2, strlen(s2)); 767 } 768 769 static int 770 hexval(int c) 771 { 772 if (c >= '0' && c <= '9') { 773 return c - '0'; 774 } else if (c >= 'A' && c <= 'F') { 775 return c - 'A' + 10; 776 } else if (c >= 'a' && c <= 'f') { 777 return c - 'a' + 10; 778 } else { 779 return -1; 780 } 781 } 782 783 /* see brssl.h */ 784 size_t 785 parse_size(const char *s) 786 { 787 int radix; 788 size_t acc; 789 const char *t; 790 791 t = s; 792 if (t[0] == '0' && (t[1] == 'x' || t[1] == 'X')) { 793 radix = 16; 794 t += 2; 795 } else { 796 radix = 10; 797 } 798 acc = 0; 799 for (;;) { 800 int c, d; 801 size_t z; 802 803 c = *t ++; 804 if (c == 0) { 805 return acc; 806 } 807 d = hexval(c); 808 if (d < 0 || d >= radix) { 809 fprintf(stderr, "ERROR: not a valid digit: '%c'\n", c); 810 return (size_t)-1; 811 } 812 z = acc * (size_t)radix + (size_t)d; 813 if (z < (size_t)d || (z / (size_t)radix) != acc 814 || z == (size_t)-1) 815 { 816 fprintf(stderr, "ERROR: value too large: %s\n", s); 817 return (size_t)-1; 818 } 819 acc = z; 820 } 821 } 822 823 /* 824 * Comma-separated list enumeration. This returns a pointer to the first 825 * word in the string, skipping leading ignored characters. '*len' is 826 * set to the word length (not counting trailing ignored characters). 827 * '*str' is updated to point to immediately after the next comma, or to 828 * the terminating zero, whichever comes first. 829 * 830 * Empty words are skipped. If there is no next non-empty word, then this 831 * function returns NULL and sets *len to 0. 832 */ 833 static const char * 834 next_word(const char **str, size_t *len) 835 { 836 int c; 837 const char *begin; 838 size_t u; 839 840 /* 841 * Find next non-ignored character which is not a comma. 842 */ 843 for (;;) { 844 c = **str; 845 if (c == 0) { 846 *len = 0; 847 return NULL; 848 } 849 if (!is_ign(c) && c != ',') { 850 break; 851 } 852 (*str) ++; 853 } 854 855 /* 856 * Find next comma or terminator. 857 */ 858 begin = *str; 859 for (;;) { 860 c = *(*str); 861 if (c == 0 || c == ',') { 862 break; 863 } 864 (*str) ++; 865 } 866 867 /* 868 * Remove trailing ignored characters. 869 */ 870 u = (size_t)(*str - begin); 871 while (u > 0 && is_ign(begin[u - 1])) { 872 u --; 873 } 874 if (c == ',') { 875 (*str) ++; 876 } 877 *len = u; 878 return begin; 879 } 880 881 /* see brssl.h */ 882 unsigned 883 parse_version(const char *name, size_t len) 884 { 885 size_t u; 886 887 for (u = 0;; u ++) { 888 const char *ref; 889 890 ref = protocol_versions[u].name; 891 if (ref == NULL) { 892 fprintf(stderr, "ERROR: unrecognised protocol" 893 " version name: '%s'\n", name); 894 return 0; 895 } 896 if (eqstr_chunk(ref, strlen(ref), name, len)) { 897 return protocol_versions[u].version; 898 } 899 } 900 } 901 902 /* see brssl.h */ 903 unsigned 904 parse_hash_functions(const char *arg) 905 { 906 unsigned r; 907 908 r = 0; 909 for (;;) { 910 const char *name; 911 size_t len; 912 size_t u; 913 914 name = next_word(&arg, &len); 915 if (name == NULL) { 916 break; 917 } 918 for (u = 0;; u ++) { 919 const char *ref; 920 921 ref = hash_functions[u].name; 922 if (ref == 0) { 923 fprintf(stderr, "ERROR: unrecognised" 924 " hash function name: '"); 925 fwrite(name, 1, len, stderr); 926 fprintf(stderr, "'\n"); 927 return 0; 928 } 929 if (eqstr_chunk(ref, strlen(ref), name, len)) { 930 int id; 931 932 id = (hash_functions[u].hclass->desc 933 >> BR_HASHDESC_ID_OFF) 934 & BR_HASHDESC_ID_MASK; 935 r |= (unsigned)1 << id; 936 break; 937 } 938 } 939 } 940 if (r == 0) { 941 fprintf(stderr, "ERROR: no hash function name provided\n"); 942 } 943 return r; 944 } 945 946 /* see brssl.h */ 947 cipher_suite * 948 parse_suites(const char *arg, size_t *num) 949 { 950 VECTOR(cipher_suite) suites = VEC_INIT; 951 cipher_suite *r; 952 953 for (;;) { 954 const char *name; 955 size_t u, len; 956 957 name = next_word(&arg, &len); 958 if (name == NULL) { 959 break; 960 } 961 for (u = 0;; u ++) { 962 const char *ref; 963 964 ref = cipher_suites[u].name; 965 if (ref == NULL) { 966 fprintf(stderr, "ERROR: unrecognised" 967 " cipher suite '"); 968 fwrite(name, 1, len, stderr); 969 fprintf(stderr, "'\n"); 970 return 0; 971 } 972 if (eqstr_chunk(ref, strlen(ref), name, len)) { 973 VEC_ADD(suites, cipher_suites[u]); 974 break; 975 } 976 } 977 } 978 if (VEC_LEN(suites) == 0) { 979 fprintf(stderr, "ERROR: no cipher suite provided\n"); 980 } 981 r = VEC_TOARRAY(suites); 982 *num = VEC_LEN(suites); 983 VEC_CLEAR(suites); 984 return r; 985 } 986 987 /* see brssl.h */ 988 const char * 989 ec_curve_name(int curve) 990 { 991 switch (curve) { 992 case BR_EC_sect163k1: return "sect163k1"; 993 case BR_EC_sect163r1: return "sect163r1"; 994 case BR_EC_sect163r2: return "sect163r2"; 995 case BR_EC_sect193r1: return "sect193r1"; 996 case BR_EC_sect193r2: return "sect193r2"; 997 case BR_EC_sect233k1: return "sect233k1"; 998 case BR_EC_sect233r1: return "sect233r1"; 999 case BR_EC_sect239k1: return "sect239k1"; 1000 case BR_EC_sect283k1: return "sect283k1"; 1001 case BR_EC_sect283r1: return "sect283r1"; 1002 case BR_EC_sect409k1: return "sect409k1"; 1003 case BR_EC_sect409r1: return "sect409r1"; 1004 case BR_EC_sect571k1: return "sect571k1"; 1005 case BR_EC_sect571r1: return "sect571r1"; 1006 case BR_EC_secp160k1: return "secp160k1"; 1007 case BR_EC_secp160r1: return "secp160r1"; 1008 case BR_EC_secp160r2: return "secp160r2"; 1009 case BR_EC_secp192k1: return "secp192k1"; 1010 case BR_EC_secp192r1: return "secp192r1"; 1011 case BR_EC_secp224k1: return "secp224k1"; 1012 case BR_EC_secp224r1: return "secp224r1"; 1013 case BR_EC_secp256k1: return "secp256k1"; 1014 case BR_EC_secp256r1: return "secp256r1"; 1015 case BR_EC_secp384r1: return "secp384r1"; 1016 case BR_EC_secp521r1: return "secp521r1"; 1017 case BR_EC_brainpoolP256r1: return "brainpoolP256r1"; 1018 case BR_EC_brainpoolP384r1: return "brainpoolP384r1"; 1019 case BR_EC_brainpoolP512r1: return "brainpoolP512r1"; 1020 default: 1021 return "unknown"; 1022 } 1023 } 1024 1025 /* see brssl.h */ 1026 int 1027 get_curve_by_name(const char *str) 1028 { 1029 size_t u, v; 1030 1031 for (u = 0; curves[u].name; u ++) { 1032 for (v = 0; curves[u].sid[v]; v ++) { 1033 if (eqstr(curves[u].sid[v], str)) { 1034 return curves[u].id; 1035 } 1036 } 1037 } 1038 return -1; 1039 } 1040 1041 /* see brssl.h */ 1042 const char * 1043 hash_function_name(int id) 1044 { 1045 switch (id) { 1046 case br_md5sha1_ID: return "MD5+SHA-1"; 1047 case br_md5_ID: return "MD5"; 1048 case br_sha1_ID: return "SHA-1"; 1049 case br_sha224_ID: return "SHA-224"; 1050 case br_sha256_ID: return "SHA-256"; 1051 case br_sha384_ID: return "SHA-384"; 1052 case br_sha512_ID: return "SHA-512"; 1053 default: 1054 return "unknown"; 1055 } 1056 }