projects / BearSSL / blob
? search:


e7d2403f3f39bd8bd5386409f71654689dc5b4dd
[BearSSL] / tools / 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_CBC_SHA256",
87 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
88 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
89 "ECDHE with ECDSA, AES-128/CBC + SHA-256 (TLS 1.2+)"
90 },
91 {
92 "ECDHE_RSA_WITH_AES_128_CBC_SHA256",
93 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
94 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
95 "ECDHE with RSA, AES-128/CBC + SHA-256 (TLS 1.2+)"
96 },
97 {
98 "ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
99 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
100 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA384 | REQ_TLS12,
101 "ECDHE with ECDSA, AES-256/CBC + SHA-384 (TLS 1.2+)"
102 },
103 {
104 "ECDHE_RSA_WITH_AES_256_CBC_SHA384",
105 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
106 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA384 | REQ_TLS12,
107 "ECDHE with RSA, AES-256/CBC + SHA-384 (TLS 1.2+)"
108 },
109 {
110 "ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
111 BR_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
112 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA1,
113 "ECDHE with ECDSA, AES-128/CBC + SHA-1"
114 },
115 {
116 "ECDHE_RSA_WITH_AES_128_CBC_SHA",
117 BR_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
118 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA1,
119 "ECDHE with RSA, AES-128/CBC + SHA-1"
120 },
121 {
122 "ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
123 BR_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
124 REQ_ECDHE_ECDSA | REQ_AESCBC | REQ_SHA1,
125 "ECDHE with ECDSA, AES-256/CBC + SHA-1"
126 },
127 {
128 "ECDHE_RSA_WITH_AES_256_CBC_SHA",
129 BR_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
130 REQ_ECDHE_RSA | REQ_AESCBC | REQ_SHA1,
131 "ECDHE with RSA, AES-256/CBC + SHA-1"
132 },
133 {
134 "ECDH_ECDSA_WITH_AES_128_GCM_SHA256",
135 BR_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
136 REQ_ECDH | REQ_AESGCM | REQ_SHA256 | REQ_TLS12,
137 "ECDH key exchange (EC cert), AES-128/GCM (TLS 1.2+)"
138 },
139 {
140 "ECDH_RSA_WITH_AES_128_GCM_SHA256",
141 BR_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
142 REQ_ECDH | REQ_AESGCM | REQ_SHA256 | REQ_TLS12,
143 "ECDH key exchange (RSA cert), AES-128/GCM (TLS 1.2+)"
144 },
145 {
146 "ECDH_ECDSA_WITH_AES_256_GCM_SHA384",
147 BR_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
148 REQ_ECDH | REQ_AESGCM | REQ_SHA384 | REQ_TLS12,
149 "ECDH key exchange (EC cert), AES-256/GCM (TLS 1.2+)"
150 },
151 {
152 "ECDH_RSA_WITH_AES_256_GCM_SHA384",
153 BR_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
154 REQ_ECDH | REQ_AESGCM | REQ_SHA384 | REQ_TLS12,
155 "ECDH key exchange (RSA cert), AES-256/GCM (TLS 1.2+)"
156 },
157 {
158 "ECDH_ECDSA_WITH_AES_128_CBC_SHA256",
159 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
160 REQ_ECDH | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
161 "ECDH key exchange (EC cert), AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)"
162 },
163 {
164 "ECDH_RSA_WITH_AES_128_CBC_SHA256",
165 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
166 REQ_ECDH | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
167 "ECDH key exchange (RSA cert), AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)"
168 },
169 {
170 "ECDH_ECDSA_WITH_AES_256_CBC_SHA384",
171 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
172 REQ_ECDH | REQ_AESCBC | REQ_SHA384 | REQ_TLS12,
173 "ECDH key exchange (EC cert), AES-256/CBC + HMAC/SHA-384 (TLS 1.2+)"
174 },
175 {
176 "ECDH_RSA_WITH_AES_256_CBC_SHA384",
177 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
178 REQ_ECDH | REQ_AESCBC | REQ_SHA384 | REQ_TLS12,
179 "ECDH key exchange (RSA cert), AES-256/CBC + HMAC/SHA-384 (TLS 1.2+)"
180 },
181 {
182 "ECDH_ECDSA_WITH_AES_128_CBC_SHA",
183 BR_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
184 REQ_ECDH | REQ_AESCBC | REQ_SHA1,
185 "ECDH key exchange (EC cert), AES-128/CBC + HMAC/SHA-1"
186 },
187 {
188 "ECDH_RSA_WITH_AES_128_CBC_SHA",
189 BR_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
190 REQ_ECDH | REQ_AESCBC | REQ_SHA1,
191 "ECDH key exchange (RSA cert), AES-128/CBC + HMAC/SHA-1"
192 },
193 {
194 "ECDH_ECDSA_WITH_AES_256_CBC_SHA",
195 BR_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
196 REQ_ECDH | REQ_AESCBC | REQ_SHA1,
197 "ECDH key exchange (EC cert), AES-256/CBC + HMAC/SHA-1"
198 },
199 {
200 "ECDH_RSA_WITH_AES_256_CBC_SHA",
201 BR_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
202 REQ_ECDH | REQ_AESCBC | REQ_SHA1,
203 "ECDH key exchange (RSA cert), AES-256/CBC + HMAC/SHA-1"
204 },
205 {
206 "RSA_WITH_AES_128_GCM_SHA256",
207 BR_TLS_RSA_WITH_AES_128_GCM_SHA256,
208 REQ_RSAKEYX | REQ_AESGCM | REQ_SHA256 | REQ_TLS12,
209 "RSA key exchange, AES-128/GCM encryption (TLS 1.2+)"
210 },
211 {
212 "RSA_WITH_AES_256_GCM_SHA384",
213 BR_TLS_RSA_WITH_AES_256_GCM_SHA384,
214 REQ_RSAKEYX | REQ_AESGCM | REQ_SHA384 | REQ_TLS12,
215 "RSA key exchange, AES-256/GCM encryption (TLS 1.2+)"
216 },
217 {
218 "RSA_WITH_AES_128_CBC_SHA256",
219 BR_TLS_RSA_WITH_AES_128_CBC_SHA256,
220 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
221 "RSA key exchange, AES-128/CBC + HMAC/SHA-256 (TLS 1.2+)"
222 },
223 {
224 "RSA_WITH_AES_256_CBC_SHA256",
225 BR_TLS_RSA_WITH_AES_256_CBC_SHA256,
226 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA256 | REQ_TLS12,
227 "RSA key exchange, AES-256/CBC + HMAC/SHA-256 (TLS 1.2+)"
228 },
229 {
230 "RSA_WITH_AES_128_CBC_SHA",
231 BR_TLS_RSA_WITH_AES_128_CBC_SHA,
232 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA1,
233 "RSA key exchange, AES-128/CBC + HMAC/SHA-1"
234 },
235 {
236 "RSA_WITH_AES_256_CBC_SHA",
237 BR_TLS_RSA_WITH_AES_256_CBC_SHA,
238 REQ_RSAKEYX | REQ_AESCBC | REQ_SHA1,
239 "RSA key exchange, AES-256/CBC + HMAC/SHA-1"
240 },
241 {
242 "ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
243 BR_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
244 REQ_ECDHE_ECDSA | REQ_3DESCBC | REQ_SHA1,
245 "ECDHE with ECDSA, 3DES/CBC + SHA-1"
246 },
247 {
248 "ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
249 BR_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
250 REQ_ECDHE_RSA | REQ_3DESCBC | REQ_SHA1,
251 "ECDHE with RSA, 3DES/CBC + SHA-1"
252 },
253 {
254 "ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA",
255 BR_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
256 REQ_ECDH | REQ_3DESCBC | REQ_SHA1,
257 "ECDH key exchange (EC cert), 3DES/CBC + HMAC/SHA-1"
258 },
259 {
260 "ECDH_RSA_WITH_3DES_EDE_CBC_SHA",
261 BR_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
262 REQ_ECDH | REQ_3DESCBC | REQ_SHA1,
263 "ECDH key exchange (RSA cert), 3DES/CBC + HMAC/SHA-1"
264 },
265 {
266 "RSA_WITH_3DES_EDE_CBC_SHA",
267 BR_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
268 REQ_RSAKEYX | REQ_3DESCBC | REQ_SHA1,
269 "RSA key exchange, 3DES/CBC + HMAC/SHA-1"
270 },
271 { NULL, 0, 0, NULL }
272 };
273
274 /* see brssl.h */
275 const char *
276 get_suite_name(unsigned suite)
277 {
278 size_t u;
279
280 for (u = 0; cipher_suites[u].name; u ++) {
281 if (cipher_suites[u].suite == suite) {
282 return cipher_suites[u].name;
283 }
284 }
285 return NULL;
286 }
287
288 /* see brssl.h */
289 int
290 get_suite_name_ext(unsigned suite, char *dst, size_t len)
291 {
292 const char *name;
293 char tmp[30];
294 size_t n;
295
296 name = get_suite_name(suite);
297 if (name == NULL) {
298 sprintf(tmp, "unknown (0x%04X)", suite);
299 name = tmp;
300 }
301 n = 1 + strlen(name);
302 if (n > len) {
303 if (len > 0) {
304 dst[0] = 0;
305 }
306 return -1;
307 }
308 memcpy(dst, name, n);
309 return 0;
310 }
311
312 /* see brssl.h */
313 void
314 list_names(void)
315 {
316 size_t u;
317
318 printf("Protocol versions:\n");
319 for (u = 0; protocol_versions[u].name; u ++) {
320 printf(" %-8s %s\n",
321 protocol_versions[u].name,
322 protocol_versions[u].comment);
323 }
324 printf("Hash functions:\n");
325 for (u = 0; hash_functions[u].name; u ++) {
326 printf(" %-8s %s\n",
327 hash_functions[u].name,
328 hash_functions[u].comment);
329 }
330 printf("Cipher suites:\n");
331 for (u = 0; cipher_suites[u].name; u ++) {
332 printf(" %s\n %s\n",
333 cipher_suites[u].name,
334 cipher_suites[u].comment);
335 }
336 }
337
338 static int
339 is_ign(int c)
340 {
341 if (c == 0) {
342 return 0;
343 }
344 if (c <= 32 || c == '-' || c == '_' || c == '.'
345 || c == '/' || c == '+' || c == ':')
346 {
347 return 1;
348 }
349 return 0;
350 }
351
352 /*
353 * Get next non-ignored character, normalised:
354 * ASCII letters are converted to lowercase
355 * control characters, space, '-', '_', '.', '/', '+' and ':' are ignored
356 * A terminating zero is returned as 0.
357 */
358 static int
359 next_char(const char **ps, const char *limit)
360 {
361 for (;;) {
362 int c;
363
364 if (*ps == limit) {
365 return 0;
366 }
367 c = *(*ps) ++;
368 if (c == 0) {
369 return 0;
370 }
371 if (c >= 'A' && c <= 'Z') {
372 c += 'a' - 'A';
373 }
374 if (!is_ign(c)) {
375 return c;
376 }
377 }
378 }
379
380 /*
381 * Partial string equality comparison, with normalisation.
382 */
383 static int
384 eqstr_chunk(const char *s1, size_t s1_len, const char *s2, size_t s2_len)
385 {
386 const char *lim1, *lim2;
387
388 lim1 = s1 + s1_len;
389 lim2 = s2 + s2_len;
390 for (;;) {
391 int c1, c2;
392
393 c1 = next_char(&s1, lim1);
394 c2 = next_char(&s2, lim2);
395 if (c1 != c2) {
396 return 0;
397 }
398 if (c1 == 0) {
399 return 1;
400 }
401 }
402 }
403
404 /* see brssl.h */
405 int
406 eqstr(const char *s1, const char *s2)
407 {
408 return eqstr_chunk(s1, strlen(s1), s2, strlen(s2));
409 }
410
411 static int
412 hexval(int c)
413 {
414 if (c >= '0' && c <= '9') {
415 return c - '0';
416 } else if (c >= 'A' && c <= 'F') {
417 return c - 'A' + 10;
418 } else if (c >= 'a' && c <= 'f') {
419 return c - 'a' + 10;
420 } else {
421 return -1;
422 }
423 }
424
425 /* see brssl.h */
426 size_t
427 parse_size(const char *s)
428 {
429 int radix;
430 size_t acc;
431 const char *t;
432
433 t = s;
434 if (t[0] == '0' && (t[1] == 'x' || t[1] == 'X')) {
435 radix = 16;
436 t += 2;
437 } else {
438 radix = 10;
439 }
440 acc = 0;
441 for (;;) {
442 int c, d;
443 size_t z;
444
445 c = *t ++;
446 if (c == 0) {
447 return acc;
448 }
449 d = hexval(c);
450 if (d < 0 || d >= radix) {
451 fprintf(stderr, "ERROR: not a valid digit: '%c'\n", c);
452 return (size_t)-1;
453 }
454 z = acc * (size_t)radix + (size_t)d;
455 if (z < (size_t)d || (z / (size_t)radix) != acc
456 || z == (size_t)-1)
457 {
458 fprintf(stderr, "ERROR: value too large: %s\n", s);
459 return (size_t)-1;
460 }
461 acc = z;
462 }
463 }
464
465 /*
466 * Comma-separated list enumeration. This returns a pointer to the first
467 * word in the string, skipping leading ignored characters. '*len' is
468 * set to the word length (not counting trailing ignored characters).
469 * '*str' is updated to point to immediately after the next comma, or to
470 * the terminating zero, whichever comes first.
471 *
472 * Empty words are skipped. If there is no next non-empty word, then this
473 * function returns NULL and sets *len to 0.
474 */
475 static const char *
476 next_word(const char **str, size_t *len)
477 {
478 int c;
479 const char *begin;
480 size_t u;
481
482 /*
483 * Find next non-ignored character which is not a comma.
484 */
485 for (;;) {
486 c = **str;
487 if (c == 0) {
488 *len = 0;
489 return NULL;
490 }
491 if (!is_ign(c) && c != ',') {
492 break;
493 }
494 (*str) ++;
495 }
496
497 /*
498 * Find next comma or terminator.
499 */
500 begin = *str;
501 for (;;) {
502 c = *(*str);
503 if (c == 0 || c == ',') {
504 break;
505 }
506 (*str) ++;
507 }
508
509 /*
510 * Remove trailing ignored characters.
511 */
512 u = (size_t)(*str - begin);
513 while (u > 0 && is_ign(begin[u - 1])) {
514 u --;
515 }
516 if (c == ',') {
517 (*str) ++;
518 }
519 *len = u;
520 return begin;
521 }
522
523 /* see brssl.h */
524 unsigned
525 parse_version(const char *name, size_t len)
526 {
527 size_t u;
528
529 for (u = 0;; u ++) {
530 const char *ref;
531
532 ref = protocol_versions[u].name;
533 if (ref == NULL) {
534 fprintf(stderr, "ERROR: unrecognised protocol"
535 " version name: '%s'\n", name);
536 return 0;
537 }
538 if (eqstr_chunk(ref, strlen(ref), name, len)) {
539 return protocol_versions[u].version;
540 }
541 }
542 }
543
544 /* see brssl.h */
545 unsigned
546 parse_hash_functions(const char *arg)
547 {
548 unsigned r;
549
550 r = 0;
551 for (;;) {
552 const char *name;
553 size_t len;
554 size_t u;
555
556 name = next_word(&arg, &len);
557 if (name == NULL) {
558 break;
559 }
560 for (u = 0;; u ++) {
561 const char *ref;
562
563 ref = hash_functions[u].name;
564 if (ref == 0) {
565 fprintf(stderr, "ERROR: unrecognised"
566 " hash function name: '");
567 fwrite(name, 1, len, stderr);
568 fprintf(stderr, "'\n");
569 return 0;
570 }
571 if (eqstr_chunk(ref, strlen(ref), name, len)) {
572 int id;
573
574 id = (hash_functions[u].hclass->desc
575 >> BR_HASHDESC_ID_OFF)
576 & BR_HASHDESC_ID_MASK;
577 r |= (unsigned)1 << id;
578 break;
579 }
580 }
581 }
582 if (r == 0) {
583 fprintf(stderr, "ERROR: no hash function name provided\n");
584 }
585 return r;
586 }
587
588 /* see brssl.h */
589 cipher_suite *
590 parse_suites(const char *arg, size_t *num)
591 {
592 VECTOR(cipher_suite) suites = VEC_INIT;
593 cipher_suite *r;
594
595 for (;;) {
596 const char *name;
597 size_t u, len;
598
599 name = next_word(&arg, &len);
600 if (name == NULL) {
601 break;
602 }
603 for (u = 0;; u ++) {
604 const char *ref;
605
606 ref = cipher_suites[u].name;
607 if (ref == NULL) {
608 fprintf(stderr, "ERROR: unrecognised"
609 " cipher suite '");
610 fwrite(name, 1, len, stderr);
611 fprintf(stderr, "'\n");
612 return 0;
613 }
614 if (eqstr_chunk(ref, strlen(ref), name, len)) {
615 VEC_ADD(suites, cipher_suites[u]);
616 break;
617 }
618 }
619 }
620 if (VEC_LEN(suites) == 0) {
621 fprintf(stderr, "ERROR: no cipher suite provided\n");
622 }
623 r = VEC_TOARRAY(suites);
624 *num = VEC_LEN(suites);
625 VEC_CLEAR(suites);
626 return r;
627 }
628
629 /* see brssl.h */
630 const char *
631 ec_curve_name(int curve)
632 {
633 switch (curve) {
634 case BR_EC_sect163k1: return "sect163k1";
635 case BR_EC_sect163r1: return "sect163r1";
636 case BR_EC_sect163r2: return "sect163r2";
637 case BR_EC_sect193r1: return "sect193r1";
638 case BR_EC_sect193r2: return "sect193r2";
639 case BR_EC_sect233k1: return "sect233k1";
640 case BR_EC_sect233r1: return "sect233r1";
641 case BR_EC_sect239k1: return "sect239k1";
642 case BR_EC_sect283k1: return "sect283k1";
643 case BR_EC_sect283r1: return "sect283r1";
644 case BR_EC_sect409k1: return "sect409k1";
645 case BR_EC_sect409r1: return "sect409r1";
646 case BR_EC_sect571k1: return "sect571k1";
647 case BR_EC_sect571r1: return "sect571r1";
648 case BR_EC_secp160k1: return "secp160k1";
649 case BR_EC_secp160r1: return "secp160r1";
650 case BR_EC_secp160r2: return "secp160r2";
651 case BR_EC_secp192k1: return "secp192k1";
652 case BR_EC_secp192r1: return "secp192r1";
653 case BR_EC_secp224k1: return "secp224k1";
654 case BR_EC_secp224r1: return "secp224r1";
655 case BR_EC_secp256k1: return "secp256k1";
656 case BR_EC_secp256r1: return "secp256r1";
657 case BR_EC_secp384r1: return "secp384r1";
658 case BR_EC_secp521r1: return "secp521r1";
659 case BR_EC_brainpoolP256r1: return "brainpoolP256r1";
660 case BR_EC_brainpoolP384r1: return "brainpoolP384r1";
661 case BR_EC_brainpoolP512r1: return "brainpoolP512r1";
662 default:
663 return "unknown";
664 }
665 }
666
667 /* see brssl.h */
668 const char *
669 hash_function_name(int id)
670 {
671 switch (id) {
672 case br_md5sha1_ID: return "MD5+SHA-1";
673 case br_md5_ID: return "MD5";
674 case br_sha1_ID: return "SHA-1";
675 case br_sha224_ID: return "SHA-224";
676 case br_sha256_ID: return "SHA-256";
677 case br_sha384_ID: return "SHA-384";
678 case br_sha512_ID: return "SHA-512";
679 default:
680 return "unknown";
681 }
682 }
The BearSSL library and tools.