projects / BearSSL / blob
? search:


a62302fcc670aca216ec3f7d905eb76d38eaf4e5
[BearSSL] / tools / server.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 <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdint.h>
29 #include <errno.h>
30 #include <signal.h>
31
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <netdb.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37 #include <unistd.h>
38 #include <fcntl.h>
39
40 #include "brssl.h"
41 #include "bearssl.h"
42
43 static int
44 host_bind(const char *host, const char *port, int verbose)
45 {
46 struct addrinfo hints, *si, *p;
47 int fd;
48 int err;
49
50 memset(&hints, 0, sizeof hints);
51 hints.ai_family = PF_UNSPEC;
52 hints.ai_socktype = SOCK_STREAM;
53 err = getaddrinfo(host, port, &hints, &si);
54 if (err != 0) {
55 fprintf(stderr, "ERROR: getaddrinfo(): %s\n",
56 gai_strerror(err));
57 return -1;
58 }
59 fd = -1;
60 for (p = si; p != NULL; p = p->ai_next) {
61 struct sockaddr *sa;
62 struct sockaddr_in sa4;
63 struct sockaddr_in6 sa6;
64 size_t sa_len;
65 void *addr;
66 int opt;
67
68 sa = (struct sockaddr *)p->ai_addr;
69 if (sa->sa_family == AF_INET) {
70 sa4 = *(struct sockaddr_in *)sa;
71 sa = (struct sockaddr *)&sa4;
72 sa_len = sizeof sa4;
73 addr = &sa4.sin_addr;
74 if (host == NULL) {
75 sa4.sin_addr.s_addr = INADDR_ANY;
76 }
77 } else if (sa->sa_family == AF_INET6) {
78 sa6 = *(struct sockaddr_in6 *)sa;
79 sa = (struct sockaddr *)&sa6;
80 sa_len = sizeof sa6;
81 addr = &sa6.sin6_addr;
82 if (host == NULL) {
83 sa6.sin6_addr = in6addr_any;
84 }
85 } else {
86 addr = NULL;
87 sa_len = p->ai_addrlen;
88 }
89 if (verbose) {
90 char tmp[INET6_ADDRSTRLEN + 50];
91
92 if (addr != NULL) {
93 if (!inet_ntop(p->ai_family, addr,
94 tmp, sizeof tmp))
95 {
96 strcpy(tmp, "<invalid>");
97 }
98 } else {
99 sprintf(tmp, "<unknown family: %d>",
100 (int)sa->sa_family);
101 }
102 fprintf(stderr, "binding to: %s\n", tmp);
103 }
104 fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
105 if (fd < 0) {
106 if (verbose) {
107 perror("socket()");
108 }
109 continue;
110 }
111 opt = 1;
112 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof opt);
113 opt = 0;
114 setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof opt);
115 if (bind(fd, sa, sa_len) < 0) {
116 if (verbose) {
117 perror("bind()");
118 }
119 close(fd);
120 continue;
121 }
122 break;
123 }
124 if (p == NULL) {
125 freeaddrinfo(si);
126 fprintf(stderr, "ERROR: failed to bind\n");
127 return -1;
128 }
129 freeaddrinfo(si);
130 if (listen(fd, 5) < 0) {
131 if (verbose) {
132 perror("listen()");
133 }
134 close(fd);
135 return -1;
136 }
137 if (verbose) {
138 fprintf(stderr, "bound.\n");
139 }
140 return fd;
141 }
142
143 static int
144 accept_client(int server_fd, int verbose)
145 {
146 int fd;
147 struct sockaddr sa;
148 socklen_t sa_len;
149
150 sa_len = sizeof sa;
151 fd = accept(server_fd, &sa, &sa_len);
152 if (fd < 0) {
153 if (verbose) {
154 perror("accept()");
155 }
156 return -1;
157 }
158 if (verbose) {
159 char tmp[INET6_ADDRSTRLEN + 50];
160 const char *name;
161
162 name = NULL;
163 switch (sa.sa_family) {
164 case AF_INET:
165 name = inet_ntop(AF_INET,
166 &((struct sockaddr_in *)&sa)->sin_addr,
167 tmp, sizeof tmp);
168 break;
169 case AF_INET6:
170 name = inet_ntop(AF_INET6,
171 &((struct sockaddr_in6 *)&sa)->sin6_addr,
172 tmp, sizeof tmp);
173 break;
174 }
175 if (name == NULL) {
176 sprintf(tmp, "<unknown: %lu>",
177 (unsigned long)sa.sa_family);
178 name = tmp;
179 }
180 fprintf(stderr, "accepting connection from: %s\n", name);
181 }
182
183 /*
184 * We make the socket non-blocking, since we are going to use
185 * poll() to organise I/O.
186 */
187 fcntl(fd, F_SETFL, O_NONBLOCK);
188 return fd;
189 }
190
191 static void
192 usage_server(void)
193 {
194 fprintf(stderr,
195 "usage: brssl server [ options ]\n");
196 fprintf(stderr,
197 "options:\n");
198 fprintf(stderr,
199 " -q suppress verbose messages\n");
200 fprintf(stderr,
201 " -trace activate extra debug messages (dump of all packets)\n");
202 fprintf(stderr,
203 " -b name bind to a specific address or host name\n");
204 fprintf(stderr,
205 " -p port bind to a specific port (default: 4433)\n");
206 fprintf(stderr,
207 " -mono use monodirectional buffering\n");
208 fprintf(stderr,
209 " -buf length set the I/O buffer length (in bytes)\n");
210 fprintf(stderr,
211 " -cache length set the session cache storage length (in bytes)\n");
212 fprintf(stderr,
213 " -cert fname read certificate chain from file 'fname'\n");
214 fprintf(stderr,
215 " -key fname read private key from file 'fname'\n");
216 fprintf(stderr,
217 " -CA file add trust anchors from 'file' (for client auth)\n");
218 fprintf(stderr,
219 " -anon_ok request but do not require a client certificate\n");
220 fprintf(stderr,
221 " -list list supported names (protocols, algorithms...)\n");
222 fprintf(stderr,
223 " -vmin name set minimum supported version (default: TLS-1.0)\n");
224 fprintf(stderr,
225 " -vmax name set maximum supported version (default: TLS-1.2)\n");
226 fprintf(stderr,
227 " -cs names set list of supported cipher suites (comma-separated)\n");
228 fprintf(stderr,
229 " -hf names add support for some hash functions (comma-separated)\n");
230 fprintf(stderr,
231 " -cbhash test hashing in policy callback\n");
232 fprintf(stderr,
233 " -serverpref enforce server's preferences for cipher suites\n");
234 fprintf(stderr,
235 " -noreneg prohibit renegotiations\n");
236 fprintf(stderr,
237 " -alpn name add protocol name to list of protocols (ALPN extension)\n");
238 fprintf(stderr,
239 " -strictalpn fail on ALPN mismatch\n");
240 exit(EXIT_FAILURE);
241 }
242
243 typedef struct {
244 const br_ssl_server_policy_class *vtable;
245 int verbose;
246 br_x509_certificate *chain;
247 size_t chain_len;
248 int cert_signer_algo;
249 private_key *sk;
250 int cbhash;
251 } policy_context;
252
253 static void
254 print_hashes(unsigned chashes)
255 {
256 int i;
257
258 for (i = 2; i <= 6; i ++) {
259 if ((chashes >> i) & 1) {
260 int z;
261
262 switch (i) {
263 case 3: z = 224; break;
264 case 4: z = 256; break;
265 case 5: z = 384; break;
266 case 6: z = 512; break;
267 default:
268 z = 1;
269 break;
270 }
271 fprintf(stderr, " sha%d", z);
272 }
273 }
274 }
275
276 static unsigned
277 choose_hash(unsigned chashes)
278 {
279 unsigned hash_id;
280
281 for (hash_id = 6; hash_id >= 2; hash_id --) {
282 if (((chashes >> hash_id) & 1) != 0) {
283 return hash_id;
284 }
285 }
286 /*
287 * Normally unreachable.
288 */
289 return 0;
290 }
291
292 static int
293 sp_choose(const br_ssl_server_policy_class **pctx,
294 const br_ssl_server_context *cc,
295 br_ssl_server_choices *choices)
296 {
297 policy_context *pc;
298 const br_suite_translated *st;
299 size_t u, st_num;
300 unsigned chashes;
301
302 pc = (policy_context *)pctx;
303 st = br_ssl_server_get_client_suites(cc, &st_num);
304 chashes = br_ssl_server_get_client_hashes(cc);
305 if (pc->verbose) {
306 fprintf(stderr, "Client parameters:\n");
307 fprintf(stderr, " Maximum version: ");
308 switch (cc->client_max_version) {
309 case BR_SSL30:
310 fprintf(stderr, "SSL 3.0");
311 break;
312 case BR_TLS10:
313 fprintf(stderr, "TLS 1.0");
314 break;
315 case BR_TLS11:
316 fprintf(stderr, "TLS 1.1");
317 break;
318 case BR_TLS12:
319 fprintf(stderr, "TLS 1.2");
320 break;
321 default:
322 fprintf(stderr, "unknown (0x%04X)",
323 (unsigned)cc->client_max_version);
324 break;
325 }
326 fprintf(stderr, "\n");
327 fprintf(stderr, " Compatible cipher suites:\n");
328 for (u = 0; u < st_num; u ++) {
329 char csn[80];
330
331 get_suite_name_ext(st[u][0], csn, sizeof csn);
332 fprintf(stderr, " %s\n", csn);
333 }
334 fprintf(stderr, " Common sign+hash functions:\n");
335 if ((chashes & 0xFF) != 0) {
336 fprintf(stderr, " with RSA:");
337 print_hashes(chashes);
338 fprintf(stderr, "\n");
339 }
340 if ((chashes >> 8) != 0) {
341 fprintf(stderr, " with ECDSA:");
342 print_hashes(chashes >> 8);
343 fprintf(stderr, "\n");
344 }
345 }
346 for (u = 0; u < st_num; u ++) {
347 unsigned tt;
348
349 tt = st[u][1];
350 switch (tt >> 12) {
351 case BR_SSLKEYX_RSA:
352 if (pc->sk->key_type == BR_KEYTYPE_RSA) {
353 choices->cipher_suite = st[u][0];
354 goto choose_ok;
355 }
356 break;
357 case BR_SSLKEYX_ECDHE_RSA:
358 if (pc->sk->key_type == BR_KEYTYPE_RSA) {
359 choices->cipher_suite = st[u][0];
360 if (br_ssl_engine_get_version(&cc->eng)
361 < BR_TLS12)
362 {
363 if (pc->cbhash) {
364 choices->algo_id = 0x0001;
365 } else {
366 choices->algo_id = 0xFF00;
367 }
368 } else {
369 unsigned id;
370
371 id = choose_hash(chashes);
372 if (pc->cbhash) {
373 choices->algo_id =
374 (id << 8) + 0x01;
375 } else {
376 choices->algo_id = 0xFF00 + id;
377 }
378 }
379 goto choose_ok;
380 }
381 break;
382 case BR_SSLKEYX_ECDHE_ECDSA:
383 if (pc->sk->key_type == BR_KEYTYPE_EC) {
384 choices->cipher_suite = st[u][0];
385 if (br_ssl_engine_get_version(&cc->eng)
386 < BR_TLS12)
387 {
388 if (pc->cbhash) {
389 choices->algo_id = 0x0203;
390 } else {
391 choices->algo_id =
392 0xFF00 + br_sha1_ID;
393 }
394 } else {
395 unsigned id;
396
397 id = choose_hash(chashes >> 8);
398 if (pc->cbhash) {
399 choices->algo_id =
400 (id << 8) + 0x03;
401 } else {
402 choices->algo_id =
403 0xFF00 + id;
404 }
405 }
406 goto choose_ok;
407 }
408 break;
409 case BR_SSLKEYX_ECDH_RSA:
410 if (pc->sk->key_type == BR_KEYTYPE_EC
411 && pc->cert_signer_algo == BR_KEYTYPE_RSA)
412 {
413 choices->cipher_suite = st[u][0];
414 goto choose_ok;
415 }
416 break;
417 case BR_SSLKEYX_ECDH_ECDSA:
418 if (pc->sk->key_type == BR_KEYTYPE_EC
419 && pc->cert_signer_algo == BR_KEYTYPE_EC)
420 {
421 choices->cipher_suite = st[u][0];
422 goto choose_ok;
423 }
424 break;
425 }
426 }
427 return 0;
428
429 choose_ok:
430 choices->chain = pc->chain;
431 choices->chain_len = pc->chain_len;
432 if (pc->verbose) {
433 char csn[80];
434
435 get_suite_name_ext(choices->cipher_suite, csn, sizeof csn);
436 fprintf(stderr, "Using: %s\n", csn);
437 }
438 return 1;
439 }
440
441 static uint32_t
442 sp_do_keyx(const br_ssl_server_policy_class **pctx,
443 unsigned char *data, size_t *len)
444 {
445 policy_context *pc;
446 uint32_t r;
447 size_t xoff, xlen;
448
449 pc = (policy_context *)pctx;
450 switch (pc->sk->key_type) {
451 case BR_KEYTYPE_RSA:
452 return br_rsa_ssl_decrypt(
453 &br_rsa_i31_private, &pc->sk->key.rsa,
454 data, *len);
455 case BR_KEYTYPE_EC:
456 r = br_ec_all_m15.mul(data, *len, pc->sk->key.ec.x,
457 pc->sk->key.ec.xlen, pc->sk->key.ec.curve);
458 xoff = br_ec_all_m15.xoff(pc->sk->key.ec.curve, &xlen);
459 memmove(data, data + xoff, xlen);
460 *len = xlen;
461 return r;
462 default:
463 fprintf(stderr, "ERROR: unknown private key type (%d)\n",
464 (int)pc->sk->key_type);
465 return 0;
466 }
467 }
468
469 static size_t
470 sp_do_sign(const br_ssl_server_policy_class **pctx,
471 unsigned algo_id, unsigned char *data, size_t hv_len, size_t len)
472 {
473 policy_context *pc;
474 unsigned char hv[64];
475
476 pc = (policy_context *)pctx;
477 if (algo_id >= 0xFF00) {
478 algo_id &= 0xFF;
479 memcpy(hv, data, hv_len);
480 } else {
481 const br_hash_class *hc;
482 br_hash_compat_context zc;
483
484 if (pc->verbose) {
485 fprintf(stderr, "Callback hashing, algo = 0x%04X,"
486 " data_len = %lu\n",
487 algo_id, (unsigned long)hv_len);
488 }
489 algo_id >>= 8;
490 hc = get_hash_impl(algo_id);
491 if (hc == NULL) {
492 if (pc->verbose) {
493 fprintf(stderr,
494 "ERROR: unsupported hash function %u\n",
495 algo_id);
496 }
497 return 0;
498 }
499 hc->init(&zc.vtable);
500 hc->update(&zc.vtable, data, hv_len);
501 hc->out(&zc.vtable, hv);
502 hv_len = (hc->desc >> BR_HASHDESC_OUT_OFF)
503 & BR_HASHDESC_OUT_MASK;
504 }
505 switch (pc->sk->key_type) {
506 size_t sig_len;
507 uint32_t x;
508 const unsigned char *hash_oid;
509 const br_hash_class *hc;
510
511 case BR_KEYTYPE_RSA:
512 hash_oid = get_hash_oid(algo_id);
513 if (hash_oid == NULL && algo_id != 0) {
514 if (pc->verbose) {
515 fprintf(stderr, "ERROR: cannot RSA-sign with"
516 " unknown hash function: %u\n",
517 algo_id);
518 }
519 return 0;
520 }
521 sig_len = (pc->sk->key.rsa.n_bitlen + 7) >> 3;
522 if (len < sig_len) {
523 if (pc->verbose) {
524 fprintf(stderr, "ERROR: cannot RSA-sign,"
525 " buffer is too small"
526 " (sig=%lu, buf=%lu)\n",
527 (unsigned long)sig_len,
528 (unsigned long)len);
529 }
530 return 0;
531 }
532 x = br_rsa_i31_pkcs1_sign(hash_oid, hv, hv_len,
533 &pc->sk->key.rsa, data);
534 if (!x) {
535 if (pc->verbose) {
536 fprintf(stderr, "ERROR: RSA-sign failure\n");
537 }
538 return 0;
539 }
540 return sig_len;
541
542 case BR_KEYTYPE_EC:
543 hc = get_hash_impl(algo_id);
544 if (hc == NULL) {
545 if (pc->verbose) {
546 fprintf(stderr, "ERROR: cannot ECDSA-sign with"
547 " unknown hash function: %u\n",
548 algo_id);
549 }
550 return 0;
551 }
552 if (len < 139) {
553 if (pc->verbose) {
554 fprintf(stderr, "ERROR: cannot ECDSA-sign"
555 " (output buffer = %lu)\n",
556 (unsigned long)len);
557 }
558 return 0;
559 }
560 sig_len = br_ecdsa_i31_sign_asn1(&br_ec_all_m15,
561 hc, hv, &pc->sk->key.ec, data);
562 if (sig_len == 0) {
563 if (pc->verbose) {
564 fprintf(stderr, "ERROR: ECDSA-sign failure\n");
565 }
566 return 0;
567 }
568 return sig_len;
569
570 default:
571 return 0;
572 }
573 }
574
575 static const br_ssl_server_policy_class policy_vtable = {
576 sizeof(policy_context),
577 sp_choose,
578 sp_do_keyx,
579 sp_do_sign
580 };
581
582 void
583 free_alpn(void *alpn)
584 {
585 xfree(*(char **)alpn);
586 }
587
588 /* see brssl.h */
589 int
590 do_server(int argc, char *argv[])
591 {
592 int retcode;
593 int verbose;
594 int trace;
595 int i, bidi;
596 const char *bind_name;
597 const char *port;
598 unsigned vmin, vmax;
599 cipher_suite *suites;
600 size_t num_suites;
601 uint16_t *suite_ids;
602 unsigned hfuns;
603 int cbhash;
604 br_x509_certificate *chain;
605 size_t chain_len;
606 int cert_signer_algo;
607 private_key *sk;
608 anchor_list anchors = VEC_INIT;
609 VECTOR(const char *) alpn_names = VEC_INIT;
610 br_x509_minimal_context xc;
611 const br_hash_class *dnhash;
612 size_t u;
613 br_ssl_server_context cc;
614 policy_context pc;
615 br_ssl_session_cache_lru lru;
616 unsigned char *iobuf, *cache;
617 size_t iobuf_len, cache_len;
618 uint32_t flags;
619 int server_fd, fd;
620
621 retcode = 0;
622 verbose = 1;
623 trace = 0;
624 bind_name = NULL;
625 port = NULL;
626 bidi = 1;
627 vmin = 0;
628 vmax = 0;
629 suites = NULL;
630 num_suites = 0;
631 hfuns = 0;
632 cbhash = 0;
633 suite_ids = NULL;
634 chain = NULL;
635 chain_len = 0;
636 sk = NULL;
637 iobuf = NULL;
638 iobuf_len = 0;
639 cache = NULL;
640 cache_len = (size_t)-1;
641 flags = 0;
642 server_fd = -1;
643 fd = -1;
644 for (i = 0; i < argc; i ++) {
645 const char *arg;
646
647 arg = argv[i];
648 if (arg[0] != '-') {
649 usage_server();
650 goto server_exit_error;
651 }
652 if (eqstr(arg, "-v") || eqstr(arg, "-verbose")) {
653 verbose = 1;
654 } else if (eqstr(arg, "-q") || eqstr(arg, "-quiet")) {
655 verbose = 0;
656 } else if (eqstr(arg, "-trace")) {
657 trace = 1;
658 } else if (eqstr(arg, "-b")) {
659 if (++ i >= argc) {
660 fprintf(stderr,
661 "ERROR: no argument for '-b'\n");
662 usage_server();
663 goto server_exit_error;
664 }
665 if (bind_name != NULL) {
666 fprintf(stderr, "ERROR: duplicate bind host\n");
667 usage_server();
668 goto server_exit_error;
669 }
670 bind_name = argv[i];
671 } else if (eqstr(arg, "-p")) {
672 if (++ i >= argc) {
673 fprintf(stderr,
674 "ERROR: no argument for '-p'\n");
675 usage_server();
676 goto server_exit_error;
677 }
678 if (port != NULL) {
679 fprintf(stderr, "ERROR: duplicate bind port\n");
680 usage_server();
681 goto server_exit_error;
682 }
683 port = argv[i];
684 } else if (eqstr(arg, "-mono")) {
685 bidi = 0;
686 } else if (eqstr(arg, "-buf")) {
687 if (++ i >= argc) {
688 fprintf(stderr,
689 "ERROR: no argument for '-buf'\n");
690 usage_server();
691 goto server_exit_error;
692 }
693 arg = argv[i];
694 if (iobuf_len != 0) {
695 fprintf(stderr,
696 "ERROR: duplicate I/O buffer length\n");
697 usage_server();
698 goto server_exit_error;
699 }
700 iobuf_len = parse_size(arg);
701 if (iobuf_len == (size_t)-1) {
702 usage_server();
703 goto server_exit_error;
704 }
705 } else if (eqstr(arg, "-cache")) {
706 if (++ i >= argc) {
707 fprintf(stderr,
708 "ERROR: no argument for '-cache'\n");
709 usage_server();
710 goto server_exit_error;
711 }
712 arg = argv[i];
713 if (cache_len != (size_t)-1) {
714 fprintf(stderr, "ERROR: duplicate session"
715 " cache length\n");
716 usage_server();
717 goto server_exit_error;
718 }
719 cache_len = parse_size(arg);
720 if (cache_len == (size_t)-1) {
721 usage_server();
722 goto server_exit_error;
723 }
724 } else if (eqstr(arg, "-cert")) {
725 if (++ i >= argc) {
726 fprintf(stderr,
727 "ERROR: no argument for '-cert'\n");
728 usage_server();
729 goto server_exit_error;
730 }
731 if (chain != NULL) {
732 fprintf(stderr,
733 "ERROR: duplicate certificate chain\n");
734 usage_server();
735 goto server_exit_error;
736 }
737 arg = argv[i];
738 chain = read_certificates(arg, &chain_len);
739 if (chain == NULL || chain_len == 0) {
740 goto server_exit_error;
741 }
742 } else if (eqstr(arg, "-key")) {
743 if (++ i >= argc) {
744 fprintf(stderr,
745 "ERROR: no argument for '-key'\n");
746 usage_server();
747 goto server_exit_error;
748 }
749 if (sk != NULL) {
750 fprintf(stderr,
751 "ERROR: duplicate private key\n");
752 usage_server();
753 goto server_exit_error;
754 }
755 arg = argv[i];
756 sk = read_private_key(arg);
757 if (sk == NULL) {
758 goto server_exit_error;
759 }
760 } else if (eqstr(arg, "-CA")) {
761 if (++ i >= argc) {
762 fprintf(stderr,
763 "ERROR: no argument for '-CA'\n");
764 usage_server();
765 goto server_exit_error;
766 }
767 arg = argv[i];
768 if (read_trust_anchors(&anchors, arg) == 0) {
769 usage_server();
770 goto server_exit_error;
771 }
772 } else if (eqstr(arg, "-anon_ok")) {
773 flags |= BR_OPT_TOLERATE_NO_CLIENT_AUTH;
774 } else if (eqstr(arg, "-list")) {
775 list_names();
776 goto server_exit;
777 } else if (eqstr(arg, "-vmin")) {
778 if (++ i >= argc) {
779 fprintf(stderr,
780 "ERROR: no argument for '-vmin'\n");
781 usage_server();
782 goto server_exit_error;
783 }
784 arg = argv[i];
785 if (vmin != 0) {
786 fprintf(stderr,
787 "ERROR: duplicate minimum version\n");
788 usage_server();
789 goto server_exit_error;
790 }
791 vmin = parse_version(arg, strlen(arg));
792 if (vmin == 0) {
793 fprintf(stderr,
794 "ERROR: unrecognised version '%s'\n",
795 arg);
796 usage_server();
797 goto server_exit_error;
798 }
799 } else if (eqstr(arg, "-vmax")) {
800 if (++ i >= argc) {
801 fprintf(stderr,
802 "ERROR: no argument for '-vmax'\n");
803 usage_server();
804 goto server_exit_error;
805 }
806 arg = argv[i];
807 if (vmax != 0) {
808 fprintf(stderr,
809 "ERROR: duplicate maximum version\n");
810 usage_server();
811 goto server_exit_error;
812 }
813 vmax = parse_version(arg, strlen(arg));
814 if (vmax == 0) {
815 fprintf(stderr,
816 "ERROR: unrecognised version '%s'\n",
817 arg);
818 usage_server();
819 goto server_exit_error;
820 }
821 } else if (eqstr(arg, "-cs")) {
822 if (++ i >= argc) {
823 fprintf(stderr,
824 "ERROR: no argument for '-cs'\n");
825 usage_server();
826 goto server_exit_error;
827 }
828 arg = argv[i];
829 if (suites != NULL) {
830 fprintf(stderr, "ERROR: duplicate list"
831 " of cipher suites\n");
832 usage_server();
833 goto server_exit_error;
834 }
835 suites = parse_suites(arg, &num_suites);
836 if (suites == NULL) {
837 usage_server();
838 goto server_exit_error;
839 }
840 } else if (eqstr(arg, "-hf")) {
841 unsigned x;
842
843 if (++ i >= argc) {
844 fprintf(stderr,
845 "ERROR: no argument for '-hf'\n");
846 usage_server();
847 goto server_exit_error;
848 }
849 arg = argv[i];
850 x = parse_hash_functions(arg);
851 if (x == 0) {
852 usage_server();
853 goto server_exit_error;
854 }
855 hfuns |= x;
856 } else if (eqstr(arg, "-cbhash")) {
857 cbhash = 1;
858 } else if (eqstr(arg, "-serverpref")) {
859 flags |= BR_OPT_ENFORCE_SERVER_PREFERENCES;
860 } else if (eqstr(arg, "-noreneg")) {
861 flags |= BR_OPT_NO_RENEGOTIATION;
862 } else if (eqstr(arg, "-alpn")) {
863 if (++ i >= argc) {
864 fprintf(stderr,
865 "ERROR: no argument for '-alpn'\n");
866 usage_server();
867 goto server_exit_error;
868 }
869 VEC_ADD(alpn_names, xstrdup(argv[i]));
870 } else if (eqstr(arg, "-strictalpn")) {
871 flags |= BR_OPT_FAIL_ON_ALPN_MISMATCH;
872 } else {
873 fprintf(stderr, "ERROR: unknown option: '%s'\n", arg);
874 usage_server();
875 goto server_exit_error;
876 }
877 }
878 if (port == NULL) {
879 port = "4433";
880 }
881 if (vmin == 0) {
882 vmin = BR_TLS10;
883 }
884 if (vmax == 0) {
885 vmax = BR_TLS12;
886 }
887 if (vmax < vmin) {
888 fprintf(stderr, "ERROR: impossible minimum/maximum protocol"
889 " version combination\n");
890 usage_server();
891 goto server_exit_error;
892 }
893 if (suites == NULL) {
894 num_suites = 0;
895
896 for (u = 0; cipher_suites[u].name; u ++) {
897 if ((cipher_suites[u].req & REQ_TLS12) == 0
898 || vmax >= BR_TLS12)
899 {
900 num_suites ++;
901 }
902 }
903 suites = xmalloc(num_suites * sizeof *suites);
904 num_suites = 0;
905 for (u = 0; cipher_suites[u].name; u ++) {
906 if ((cipher_suites[u].req & REQ_TLS12) == 0
907 || vmax >= BR_TLS12)
908 {
909 suites[num_suites ++] = cipher_suites[u];
910 }
911 }
912 }
913 if (hfuns == 0) {
914 hfuns = (unsigned)-1;
915 }
916 if (chain == NULL || chain_len == 0) {
917 fprintf(stderr, "ERROR: no certificate chain provided\n");
918 goto server_exit_error;
919 }
920 if (sk == NULL) {
921 fprintf(stderr, "ERROR: no private key provided\n");
922 goto server_exit_error;
923 }
924 switch (sk->key_type) {
925 int curve;
926 uint32_t supp;
927
928 case BR_KEYTYPE_RSA:
929 break;
930 case BR_KEYTYPE_EC:
931 curve = sk->key.ec.curve;
932 supp = br_ec_all_m15.supported_curves;
933 if (curve > 31 || !((supp >> curve) & 1)) {
934 fprintf(stderr, "ERROR: private key curve (%d)"
935 " is not supported\n", curve);
936 goto server_exit_error;
937 }
938 break;
939 default:
940 fprintf(stderr, "ERROR: unsupported private key type (%d)\n",
941 sk->key_type);
942 break;
943 }
944 cert_signer_algo = get_cert_signer_algo(chain);
945 if (cert_signer_algo == 0) {
946 goto server_exit_error;
947 }
948 if (verbose) {
949 const char *csas;
950
951 switch (cert_signer_algo) {
952 case BR_KEYTYPE_RSA: csas = "RSA"; break;
953 case BR_KEYTYPE_EC: csas = "EC"; break;
954 default:
955 csas = "unknown";
956 break;
957 }
958 fprintf(stderr, "Issuing CA key type: %d (%s)\n",
959 cert_signer_algo, csas);
960 }
961 if (iobuf_len == 0) {
962 if (bidi) {
963 iobuf_len = BR_SSL_BUFSIZE_BIDI;
964 } else {
965 iobuf_len = BR_SSL_BUFSIZE_MONO;
966 }
967 }
968 iobuf = xmalloc(iobuf_len);
969 if (cache_len == (size_t)-1) {
970 cache_len = 5000;
971 }
972 cache = xmalloc(cache_len);
973
974 /*
975 * Compute implementation requirements and inject implementations.
976 */
977 suite_ids = xmalloc(num_suites * sizeof *suite_ids);
978 br_ssl_server_zero(&cc);
979 br_ssl_engine_set_versions(&cc.eng, vmin, vmax);
980 br_ssl_engine_set_all_flags(&cc.eng, flags);
981 if (vmin <= BR_TLS11) {
982 if (!(hfuns & (1 << br_md5_ID))) {
983 fprintf(stderr, "ERROR: TLS 1.0 and 1.1 need MD5\n");
984 goto server_exit_error;
985 }
986 if (!(hfuns & (1 << br_sha1_ID))) {
987 fprintf(stderr, "ERROR: TLS 1.0 and 1.1 need SHA-1\n");
988 goto server_exit_error;
989 }
990 }
991 for (u = 0; u < num_suites; u ++) {
992 unsigned req;
993
994 req = suites[u].req;
995 suite_ids[u] = suites[u].suite;
996 if ((req & REQ_TLS12) != 0 && vmax < BR_TLS12) {
997 fprintf(stderr,
998 "ERROR: cipher suite %s requires TLS 1.2\n",
999 suites[u].name);
1000 goto server_exit_error;
1001 }
1002 if ((req & REQ_SHA1) != 0 && !(hfuns & (1 << br_sha1_ID))) {
1003 fprintf(stderr,
1004 "ERROR: cipher suite %s requires SHA-1\n",
1005 suites[u].name);
1006 goto server_exit_error;
1007 }
1008 if ((req & REQ_SHA256) != 0 && !(hfuns & (1 << br_sha256_ID))) {
1009 fprintf(stderr,
1010 "ERROR: cipher suite %s requires SHA-256\n",
1011 suites[u].name);
1012 goto server_exit_error;
1013 }
1014 if ((req & REQ_SHA384) != 0 && !(hfuns & (1 << br_sha384_ID))) {
1015 fprintf(stderr,
1016 "ERROR: cipher suite %s requires SHA-384\n",
1017 suites[u].name);
1018 goto server_exit_error;
1019 }
1020 /* TODO: algorithm implementation selection */
1021 if ((req & REQ_AESCBC) != 0) {
1022 br_ssl_engine_set_aes_cbc(&cc.eng,
1023 &br_aes_ct_cbcenc_vtable,
1024 &br_aes_ct_cbcdec_vtable);
1025 br_ssl_engine_set_cbc(&cc.eng,
1026 &br_sslrec_in_cbc_vtable,
1027 &br_sslrec_out_cbc_vtable);
1028 }
1029 if ((req & REQ_AESGCM) != 0) {
1030 br_ssl_engine_set_aes_ctr(&cc.eng,
1031 &br_aes_ct_ctr_vtable);
1032 br_ssl_engine_set_ghash(&cc.eng,
1033 &br_ghash_ctmul);
1034 br_ssl_engine_set_gcm(&cc.eng,
1035 &br_sslrec_in_gcm_vtable,
1036 &br_sslrec_out_gcm_vtable);
1037 }
1038 if ((req & REQ_CHAPOL) != 0) {
1039 br_ssl_engine_set_chacha20(&cc.eng,
1040 &br_chacha20_ct_run);
1041 br_ssl_engine_set_poly1305(&cc.eng,
1042 &br_poly1305_ctmul_run);
1043 br_ssl_engine_set_chapol(&cc.eng,
1044 &br_sslrec_in_chapol_vtable,
1045 &br_sslrec_out_chapol_vtable);
1046 }
1047 if ((req & REQ_3DESCBC) != 0) {
1048 br_ssl_engine_set_des_cbc(&cc.eng,
1049 &br_des_ct_cbcenc_vtable,
1050 &br_des_ct_cbcdec_vtable);
1051 br_ssl_engine_set_cbc(&cc.eng,
1052 &br_sslrec_in_cbc_vtable,
1053 &br_sslrec_out_cbc_vtable);
1054 }
1055 if ((req & (REQ_ECDHE_RSA | REQ_ECDHE_ECDSA)) != 0) {
1056 br_ssl_engine_set_ec(&cc.eng, &br_ec_all_m15);
1057 }
1058 }
1059 br_ssl_engine_set_suites(&cc.eng, suite_ids, num_suites);
1060
1061 dnhash = NULL;
1062 for (u = 0; hash_functions[u].name; u ++) {
1063 const br_hash_class *hc;
1064 int id;
1065
1066 hc = hash_functions[u].hclass;
1067 id = (hc->desc >> BR_HASHDESC_ID_OFF) & BR_HASHDESC_ID_MASK;
1068 if ((hfuns & ((unsigned)1 << id)) != 0) {
1069 dnhash = hc;
1070 br_ssl_engine_set_hash(&cc.eng, id, hc);
1071 }
1072 }
1073 if (vmin <= BR_TLS11) {
1074 br_ssl_engine_set_prf10(&cc.eng, &br_tls10_prf);
1075 }
1076 if (vmax >= BR_TLS12) {
1077 if ((hfuns & ((unsigned)1 << br_sha256_ID)) != 0) {
1078 br_ssl_engine_set_prf_sha256(&cc.eng,
1079 &br_tls12_sha256_prf);
1080 }
1081 if ((hfuns & ((unsigned)1 << br_sha384_ID)) != 0) {
1082 br_ssl_engine_set_prf_sha384(&cc.eng,
1083 &br_tls12_sha384_prf);
1084 }
1085 }
1086
1087 br_ssl_session_cache_lru_init(&lru, cache, cache_len);
1088 br_ssl_server_set_cache(&cc, &lru.vtable);
1089
1090 if (VEC_LEN(alpn_names) != 0) {
1091 br_ssl_engine_set_protocol_names(&cc.eng,
1092 &VEC_ELT(alpn_names, 0), VEC_LEN(alpn_names));
1093 }
1094
1095 /*
1096 * Set the policy handler (that chooses the actual cipher suite,
1097 * selects the certificate chain, and runs the private key
1098 * operations).
1099 */
1100 pc.vtable = &policy_vtable;
1101 pc.verbose = verbose;
1102 pc.chain = chain;
1103 pc.chain_len = chain_len;
1104 pc.cert_signer_algo = cert_signer_algo;
1105 pc.sk = sk;
1106 pc.cbhash = cbhash;
1107 br_ssl_server_set_policy(&cc, &pc.vtable);
1108
1109 /*
1110 * If trust anchors have been configured, then set an X.509
1111 * validation engine and activate client certificate
1112 * authentication.
1113 */
1114 if (VEC_LEN(anchors) != 0) {
1115 br_x509_minimal_init(&xc, dnhash,
1116 &VEC_ELT(anchors, 0), VEC_LEN(anchors));
1117 for (u = 0; hash_functions[u].name; u ++) {
1118 const br_hash_class *hc;
1119 int id;
1120
1121 hc = hash_functions[u].hclass;
1122 id = (hc->desc >> BR_HASHDESC_ID_OFF)
1123 & BR_HASHDESC_ID_MASK;
1124 if ((hfuns & ((unsigned)1 << id)) != 0) {
1125 br_x509_minimal_set_hash(&xc, id, hc);
1126 }
1127 }
1128 br_ssl_engine_set_rsavrfy(&cc.eng, &br_rsa_i31_pkcs1_vrfy);
1129 br_ssl_engine_set_ec(&cc.eng, &br_ec_all_m15);
1130 br_ssl_engine_set_ecdsa(&cc.eng, &br_ecdsa_i31_vrfy_asn1);
1131 br_x509_minimal_set_rsa(&xc, &br_rsa_i31_pkcs1_vrfy);
1132 br_x509_minimal_set_ecdsa(&xc,
1133 &br_ec_all_m15, &br_ecdsa_i31_vrfy_asn1);
1134 br_ssl_engine_set_x509(&cc.eng, &xc.vtable);
1135 br_ssl_server_set_trust_anchor_names_alt(&cc,
1136 &VEC_ELT(anchors, 0), VEC_LEN(anchors));
1137 }
1138
1139 br_ssl_engine_set_buffer(&cc.eng, iobuf, iobuf_len, bidi);
1140
1141 /*
1142 * We need to ignore SIGPIPE.
1143 */
1144 signal(SIGPIPE, SIG_IGN);
1145
1146 /*
1147 * Open the server socket.
1148 */
1149 server_fd = host_bind(bind_name, port, verbose);
1150 if (server_fd < 0) {
1151 goto server_exit_error;
1152 }
1153
1154 /*
1155 * Process incoming clients, one at a time. Note that we do not
1156 * accept any client until the previous connection has finished:
1157 * this is voluntary, since the tool uses stdin/stdout for
1158 * application data, and thus cannot really run two connections
1159 * simultaneously.
1160 */
1161 for (;;) {
1162 int x;
1163
1164 fd = accept_client(server_fd, verbose);
1165 if (fd < 0) {
1166 goto server_exit_error;
1167 }
1168 br_ssl_server_reset(&cc);
1169 x = run_ssl_engine(&cc.eng, fd,
1170 (verbose ? RUN_ENGINE_VERBOSE : 0)
1171 | (trace ? RUN_ENGINE_TRACE : 0));
1172 close(fd);
1173 fd = -1;
1174 if (x < -1) {
1175 goto server_exit_error;
1176 }
1177 }
1178
1179 /*
1180 * Release allocated structures.
1181 */
1182 server_exit:
1183 xfree(suites);
1184 xfree(suite_ids);
1185 free_certificates(chain, chain_len);
1186 free_private_key(sk);
1187 VEC_CLEAREXT(anchors, &free_ta_contents);
1188 VEC_CLEAREXT(alpn_names, &free_alpn);
1189 xfree(iobuf);
1190 xfree(cache);
1191 if (fd >= 0) {
1192 close(fd);
1193 }
1194 return retcode;
1195
1196 server_exit_error:
1197 retcode = -1;
1198 goto server_exit;
1199 }
The BearSSL library and tools.