1 /* 2 * util/net_help.c - implementation of the network helper code 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /** 36 * \file 37 * Implementation of net_help.h. 38 */ 39 40 #include "config.h" 41 #include "util/net_help.h" 42 #include "util/log.h" 43 #include "util/data/dname.h" 44 #include "util/module.h" 45 #include "util/regional.h" 46 #include "util/config_file.h" 47 #include "sldns/parseutil.h" 48 #include "sldns/wire2str.h" 49 #include <fcntl.h> 50 #ifdef HAVE_OPENSSL_SSL_H 51 #include <openssl/ssl.h> 52 #include <openssl/evp.h> 53 #include <openssl/rand.h> 54 #endif 55 #ifdef HAVE_OPENSSL_ERR_H 56 #include <openssl/err.h> 57 #endif 58 #ifdef HAVE_OPENSSL_CORE_NAMES_H 59 #include <openssl/core_names.h> 60 #endif 61 #ifdef USE_WINSOCK 62 #include <wincrypt.h> 63 #endif 64 #ifdef HAVE_NGHTTP2_NGHTTP2_H 65 #include <nghttp2/nghttp2.h> 66 #endif 67 68 /** max length of an IP address (the address portion) that we allow */ 69 #define MAX_ADDR_STRLEN 128 /* characters */ 70 /** default value for EDNS ADVERTISED size */ 71 uint16_t EDNS_ADVERTISED_SIZE = 4096; 72 73 /** minimal responses when positive answer: default is no */ 74 int MINIMAL_RESPONSES = 0; 75 76 /** rrset order roundrobin: default is yes */ 77 int RRSET_ROUNDROBIN = 1; 78 79 /** log tag queries with name instead of 'info' for filtering */ 80 int LOG_TAG_QUERYREPLY = 0; 81 82 static struct tls_session_ticket_key { 83 unsigned char *key_name; 84 unsigned char *aes_key; 85 unsigned char *hmac_key; 86 } *ticket_keys; 87 88 #ifdef HAVE_SSL 89 /** 90 * callback TLS session ticket encrypt and decrypt 91 * For use with SSL_CTX_set_tlsext_ticket_key_cb or 92 * SSL_CTX_set_tlsext_ticket_key_evp_cb 93 * @param s: the SSL_CTX to use (from connect_sslctx_create()) 94 * @param key_name: secret name, 16 bytes 95 * @param iv: up to EVP_MAX_IV_LENGTH. 96 * @param evp_ctx: the evp cipher context, function sets this. 97 * @param hmac_ctx: the hmac context, function sets this. 98 * with ..key_cb it is of type HMAC_CTX* 99 * with ..key_evp_cb it is of type EVP_MAC_CTX* 100 * @param enc: 1 is encrypt, 0 is decrypt 101 * @return 0 on no ticket, 1 for okay, and 2 for okay but renew the ticket 102 * (the ticket is decrypt only). and <0 for failures. 103 */ 104 int tls_session_ticket_key_cb(SSL *s, unsigned char* key_name, 105 unsigned char* iv, EVP_CIPHER_CTX *evp_ctx, 106 #ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 107 EVP_MAC_CTX *hmac_ctx, 108 #else 109 HMAC_CTX* hmac_ctx, 110 #endif 111 int enc); 112 #endif /* HAVE_SSL */ 113 114 /* returns true is string addr is an ip6 specced address */ 115 int 116 str_is_ip6(const char* str) 117 { 118 if(strchr(str, ':')) 119 return 1; 120 else return 0; 121 } 122 123 int 124 fd_set_nonblock(int s) 125 { 126 #ifdef HAVE_FCNTL 127 int flag; 128 if((flag = fcntl(s, F_GETFL)) == -1) { 129 log_err("can't fcntl F_GETFL: %s", strerror(errno)); 130 flag = 0; 131 } 132 flag |= O_NONBLOCK; 133 if(fcntl(s, F_SETFL, flag) == -1) { 134 log_err("can't fcntl F_SETFL: %s", strerror(errno)); 135 return 0; 136 } 137 #elif defined(HAVE_IOCTLSOCKET) 138 unsigned long on = 1; 139 if(ioctlsocket(s, FIONBIO, &on) != 0) { 140 log_err("can't ioctlsocket FIONBIO on: %s", 141 wsa_strerror(WSAGetLastError())); 142 } 143 #endif 144 return 1; 145 } 146 147 int 148 fd_set_block(int s) 149 { 150 #ifdef HAVE_FCNTL 151 int flag; 152 if((flag = fcntl(s, F_GETFL)) == -1) { 153 log_err("cannot fcntl F_GETFL: %s", strerror(errno)); 154 flag = 0; 155 } 156 flag &= ~O_NONBLOCK; 157 if(fcntl(s, F_SETFL, flag) == -1) { 158 log_err("cannot fcntl F_SETFL: %s", strerror(errno)); 159 return 0; 160 } 161 #elif defined(HAVE_IOCTLSOCKET) 162 unsigned long off = 0; 163 if(ioctlsocket(s, FIONBIO, &off) != 0) { 164 if(WSAGetLastError() != WSAEINVAL || verbosity >= 4) 165 log_err("can't ioctlsocket FIONBIO off: %s", 166 wsa_strerror(WSAGetLastError())); 167 } 168 #endif 169 return 1; 170 } 171 172 int 173 is_pow2(size_t num) 174 { 175 if(num == 0) return 1; 176 return (num & (num-1)) == 0; 177 } 178 179 void* 180 memdup(void* data, size_t len) 181 { 182 void* d; 183 if(!data) return NULL; 184 if(len == 0) return NULL; 185 d = malloc(len); 186 if(!d) return NULL; 187 memcpy(d, data, len); 188 return d; 189 } 190 191 void 192 log_addr(enum verbosity_value v, const char* str, 193 struct sockaddr_storage* addr, socklen_t addrlen) 194 { 195 uint16_t port; 196 const char* family = "unknown"; 197 char dest[100]; 198 int af = (int)((struct sockaddr_in*)addr)->sin_family; 199 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 200 if(verbosity < v) 201 return; 202 switch(af) { 203 case AF_INET: family="ip4"; break; 204 case AF_INET6: family="ip6"; 205 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 206 break; 207 case AF_LOCAL: 208 dest[0]=0; 209 (void)inet_ntop(af, sinaddr, dest, 210 (socklen_t)sizeof(dest)); 211 verbose(v, "%s local %s", str, dest); 212 return; /* do not continue and try to get port */ 213 default: break; 214 } 215 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 216 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 217 } 218 dest[sizeof(dest)-1] = 0; 219 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 220 if(verbosity >= 4) 221 verbose(v, "%s %s %s port %d (len %d)", str, family, dest, 222 (int)port, (int)addrlen); 223 else verbose(v, "%s %s port %d", str, dest, (int)port); 224 } 225 226 int 227 extstrtoaddr(const char* str, struct sockaddr_storage* addr, 228 socklen_t* addrlen) 229 { 230 char* s; 231 int port = UNBOUND_DNS_PORT; 232 if((s=strchr(str, '@'))) { 233 char buf[MAX_ADDR_STRLEN]; 234 if(s-str >= MAX_ADDR_STRLEN) { 235 return 0; 236 } 237 (void)strlcpy(buf, str, sizeof(buf)); 238 buf[s-str] = 0; 239 port = atoi(s+1); 240 if(port == 0 && strcmp(s+1,"0")!=0) { 241 return 0; 242 } 243 return ipstrtoaddr(buf, port, addr, addrlen); 244 } 245 return ipstrtoaddr(str, port, addr, addrlen); 246 } 247 248 249 int 250 ipstrtoaddr(const char* ip, int port, struct sockaddr_storage* addr, 251 socklen_t* addrlen) 252 { 253 uint16_t p; 254 if(!ip) return 0; 255 p = (uint16_t) port; 256 if(str_is_ip6(ip)) { 257 char buf[MAX_ADDR_STRLEN]; 258 char* s; 259 struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 260 *addrlen = (socklen_t)sizeof(struct sockaddr_in6); 261 memset(sa, 0, *addrlen); 262 sa->sin6_family = AF_INET6; 263 sa->sin6_port = (in_port_t)htons(p); 264 if((s=strchr(ip, '%'))) { /* ip6%interface, rfc 4007 */ 265 if(s-ip >= MAX_ADDR_STRLEN) 266 return 0; 267 (void)strlcpy(buf, ip, sizeof(buf)); 268 buf[s-ip]=0; 269 sa->sin6_scope_id = (uint32_t)atoi(s+1); 270 ip = buf; 271 } 272 if(inet_pton((int)sa->sin6_family, ip, &sa->sin6_addr) <= 0) { 273 return 0; 274 } 275 } else { /* ip4 */ 276 struct sockaddr_in* sa = (struct sockaddr_in*)addr; 277 *addrlen = (socklen_t)sizeof(struct sockaddr_in); 278 memset(sa, 0, *addrlen); 279 sa->sin_family = AF_INET; 280 sa->sin_port = (in_port_t)htons(p); 281 if(inet_pton((int)sa->sin_family, ip, &sa->sin_addr) <= 0) { 282 return 0; 283 } 284 } 285 return 1; 286 } 287 288 int netblockstrtoaddr(const char* str, int port, struct sockaddr_storage* addr, 289 socklen_t* addrlen, int* net) 290 { 291 char buf[64]; 292 char* s; 293 *net = (str_is_ip6(str)?128:32); 294 if((s=strchr(str, '/'))) { 295 if(atoi(s+1) > *net) { 296 log_err("netblock too large: %s", str); 297 return 0; 298 } 299 *net = atoi(s+1); 300 if(*net == 0 && strcmp(s+1, "0") != 0) { 301 log_err("cannot parse netblock: '%s'", str); 302 return 0; 303 } 304 strlcpy(buf, str, sizeof(buf)); 305 s = strchr(buf, '/'); 306 if(s) *s = 0; 307 s = buf; 308 } 309 if(!ipstrtoaddr(s?s:str, port, addr, addrlen)) { 310 log_err("cannot parse ip address: '%s'", str); 311 return 0; 312 } 313 if(s) { 314 addr_mask(addr, *addrlen, *net); 315 } 316 return 1; 317 } 318 319 /* RPZ format address dname to network byte order address */ 320 static int ipdnametoaddr(uint8_t* dname, size_t dnamelen, 321 struct sockaddr_storage* addr, socklen_t* addrlen, int* af) 322 { 323 uint8_t* ia; 324 int dnamelabs = dname_count_labels(dname); 325 uint8_t lablen; 326 char* e = NULL; 327 int z = 0; 328 size_t len = 0; 329 int i; 330 *af = AF_INET; 331 332 /* need 1 byte for label length */ 333 if(dnamelen < 1) 334 return 0; 335 336 if(dnamelabs > 6 || 337 dname_has_label(dname, dnamelen, (uint8_t*)"\002zz")) { 338 *af = AF_INET6; 339 } 340 len = *dname; 341 lablen = *dname++; 342 i = (*af == AF_INET) ? 3 : 15; 343 if(*af == AF_INET6) { 344 struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 345 *addrlen = (socklen_t)sizeof(struct sockaddr_in6); 346 memset(sa, 0, *addrlen); 347 sa->sin6_family = AF_INET6; 348 ia = (uint8_t*)&sa->sin6_addr; 349 } else { /* ip4 */ 350 struct sockaddr_in* sa = (struct sockaddr_in*)addr; 351 *addrlen = (socklen_t)sizeof(struct sockaddr_in); 352 memset(sa, 0, *addrlen); 353 sa->sin_family = AF_INET; 354 ia = (uint8_t*)&sa->sin_addr; 355 } 356 while(lablen && i >= 0 && len <= dnamelen) { 357 char buff[LDNS_MAX_LABELLEN+1]; 358 uint16_t chunk; /* big enough to not overflow on IPv6 hextet */ 359 if((*af == AF_INET && (lablen > 3 || dnamelabs > 6)) || 360 (*af == AF_INET6 && (lablen > 4 || dnamelabs > 10))) { 361 return 0; 362 } 363 if(memcmp(dname, "zz", 2) == 0 && *af == AF_INET6) { 364 /* Add one or more 0 labels. Address is initialised at 365 * 0, so just skip the zero part. */ 366 int zl = 11 - dnamelabs; 367 if(z || zl < 0) 368 return 0; 369 z = 1; 370 i -= (zl*2); 371 } else { 372 memcpy(buff, dname, lablen); 373 buff[lablen] = '\0'; 374 chunk = strtol(buff, &e, (*af == AF_INET) ? 10 : 16); 375 if(!e || *e != '\0' || (*af == AF_INET && chunk > 255)) 376 return 0; 377 if(*af == AF_INET) { 378 log_assert(i < 4 && i >= 0); 379 ia[i] = (uint8_t)chunk; 380 i--; 381 } else { 382 log_assert(i < 16 && i >= 1); 383 /* ia in network byte order */ 384 ia[i-1] = (uint8_t)(chunk >> 8); 385 ia[i] = (uint8_t)(chunk & 0x00FF); 386 i -= 2; 387 } 388 } 389 dname += lablen; 390 lablen = *dname++; 391 len += lablen; 392 } 393 if(i != -1) 394 /* input too short */ 395 return 0; 396 return 1; 397 } 398 399 int netblockdnametoaddr(uint8_t* dname, size_t dnamelen, 400 struct sockaddr_storage* addr, socklen_t* addrlen, int* net, int* af) 401 { 402 char buff[3 /* 3 digit netblock */ + 1]; 403 size_t nlablen; 404 if(dnamelen < 1 || *dname > 3) 405 /* netblock invalid */ 406 return 0; 407 nlablen = *dname; 408 409 if(dnamelen < 1 + nlablen) 410 return 0; 411 412 memcpy(buff, dname+1, nlablen); 413 buff[nlablen] = '\0'; 414 *net = atoi(buff); 415 if(*net == 0 && strcmp(buff, "0") != 0) 416 return 0; 417 dname += nlablen; 418 dname++; 419 if(!ipdnametoaddr(dname, dnamelen-1-nlablen, addr, addrlen, af)) 420 return 0; 421 if((*af == AF_INET6 && *net > 128) || (*af == AF_INET && *net > 32)) 422 return 0; 423 return 1; 424 } 425 426 int authextstrtoaddr(char* str, struct sockaddr_storage* addr, 427 socklen_t* addrlen, char** auth_name) 428 { 429 char* s; 430 int port = UNBOUND_DNS_PORT; 431 if((s=strchr(str, '@'))) { 432 char buf[MAX_ADDR_STRLEN]; 433 size_t len = (size_t)(s-str); 434 char* hash = strchr(s+1, '#'); 435 if(hash) { 436 *auth_name = hash+1; 437 } else { 438 *auth_name = NULL; 439 } 440 if(len >= MAX_ADDR_STRLEN) { 441 return 0; 442 } 443 (void)strlcpy(buf, str, sizeof(buf)); 444 buf[len] = 0; 445 port = atoi(s+1); 446 if(port == 0) { 447 if(!hash && strcmp(s+1,"0")!=0) 448 return 0; 449 if(hash && strncmp(s+1,"0#",2)!=0) 450 return 0; 451 } 452 return ipstrtoaddr(buf, port, addr, addrlen); 453 } 454 if((s=strchr(str, '#'))) { 455 char buf[MAX_ADDR_STRLEN]; 456 size_t len = (size_t)(s-str); 457 if(len >= MAX_ADDR_STRLEN) { 458 return 0; 459 } 460 (void)strlcpy(buf, str, sizeof(buf)); 461 buf[len] = 0; 462 port = UNBOUND_DNS_OVER_TLS_PORT; 463 *auth_name = s+1; 464 return ipstrtoaddr(buf, port, addr, addrlen); 465 } 466 *auth_name = NULL; 467 return ipstrtoaddr(str, port, addr, addrlen); 468 } 469 470 /** store port number into sockaddr structure */ 471 void 472 sockaddr_store_port(struct sockaddr_storage* addr, socklen_t addrlen, int port) 473 { 474 if(addr_is_ip6(addr, addrlen)) { 475 struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 476 sa->sin6_port = (in_port_t)htons((uint16_t)port); 477 } else { 478 struct sockaddr_in* sa = (struct sockaddr_in*)addr; 479 sa->sin_port = (in_port_t)htons((uint16_t)port); 480 } 481 } 482 483 void 484 log_nametypeclass(enum verbosity_value v, const char* str, uint8_t* name, 485 uint16_t type, uint16_t dclass) 486 { 487 char buf[LDNS_MAX_DOMAINLEN+1]; 488 char t[12], c[12]; 489 const char *ts, *cs; 490 if(verbosity < v) 491 return; 492 dname_str(name, buf); 493 if(type == LDNS_RR_TYPE_TSIG) ts = "TSIG"; 494 else if(type == LDNS_RR_TYPE_IXFR) ts = "IXFR"; 495 else if(type == LDNS_RR_TYPE_AXFR) ts = "AXFR"; 496 else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; 497 else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; 498 else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; 499 else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name) 500 ts = sldns_rr_descript(type)->_name; 501 else { 502 snprintf(t, sizeof(t), "TYPE%d", (int)type); 503 ts = t; 504 } 505 if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) && 506 sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name) 507 cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name; 508 else { 509 snprintf(c, sizeof(c), "CLASS%d", (int)dclass); 510 cs = c; 511 } 512 log_info("%s %s %s %s", str, buf, ts, cs); 513 } 514 515 void 516 log_query_in(const char* str, uint8_t* name, uint16_t type, uint16_t dclass) 517 { 518 char buf[LDNS_MAX_DOMAINLEN+1]; 519 char t[12], c[12]; 520 const char *ts, *cs; 521 dname_str(name, buf); 522 if(type == LDNS_RR_TYPE_TSIG) ts = "TSIG"; 523 else if(type == LDNS_RR_TYPE_IXFR) ts = "IXFR"; 524 else if(type == LDNS_RR_TYPE_AXFR) ts = "AXFR"; 525 else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; 526 else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; 527 else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; 528 else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name) 529 ts = sldns_rr_descript(type)->_name; 530 else { 531 snprintf(t, sizeof(t), "TYPE%d", (int)type); 532 ts = t; 533 } 534 if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) && 535 sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name) 536 cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name; 537 else { 538 snprintf(c, sizeof(c), "CLASS%d", (int)dclass); 539 cs = c; 540 } 541 if(LOG_TAG_QUERYREPLY) 542 log_query("%s %s %s %s", str, buf, ts, cs); 543 else log_info("%s %s %s %s", str, buf, ts, cs); 544 } 545 546 void log_name_addr(enum verbosity_value v, const char* str, uint8_t* zone, 547 struct sockaddr_storage* addr, socklen_t addrlen) 548 { 549 uint16_t port; 550 const char* family = "unknown_family "; 551 char namebuf[LDNS_MAX_DOMAINLEN+1]; 552 char dest[100]; 553 int af = (int)((struct sockaddr_in*)addr)->sin_family; 554 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 555 if(verbosity < v) 556 return; 557 switch(af) { 558 case AF_INET: family=""; break; 559 case AF_INET6: family=""; 560 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 561 break; 562 case AF_LOCAL: family="local "; break; 563 default: break; 564 } 565 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 566 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 567 } 568 dest[sizeof(dest)-1] = 0; 569 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 570 dname_str(zone, namebuf); 571 if(af != AF_INET && af != AF_INET6) 572 verbose(v, "%s <%s> %s%s#%d (addrlen %d)", 573 str, namebuf, family, dest, (int)port, (int)addrlen); 574 else verbose(v, "%s <%s> %s%s#%d", 575 str, namebuf, family, dest, (int)port); 576 } 577 578 void log_err_addr(const char* str, const char* err, 579 struct sockaddr_storage* addr, socklen_t addrlen) 580 { 581 uint16_t port; 582 char dest[100]; 583 int af = (int)((struct sockaddr_in*)addr)->sin_family; 584 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 585 if(af == AF_INET6) 586 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 587 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 588 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 589 } 590 dest[sizeof(dest)-1] = 0; 591 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 592 if(verbosity >= 4) 593 log_err("%s: %s for %s port %d (len %d)", str, err, dest, 594 (int)port, (int)addrlen); 595 else log_err("%s: %s for %s port %d", str, err, dest, (int)port); 596 } 597 598 int 599 sockaddr_cmp(struct sockaddr_storage* addr1, socklen_t len1, 600 struct sockaddr_storage* addr2, socklen_t len2) 601 { 602 struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 603 struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 604 struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 605 struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 606 if(len1 < len2) 607 return -1; 608 if(len1 > len2) 609 return 1; 610 log_assert(len1 == len2); 611 if( p1_in->sin_family < p2_in->sin_family) 612 return -1; 613 if( p1_in->sin_family > p2_in->sin_family) 614 return 1; 615 log_assert( p1_in->sin_family == p2_in->sin_family ); 616 /* compare ip4 */ 617 if( p1_in->sin_family == AF_INET ) { 618 /* just order it, ntohs not required */ 619 if(p1_in->sin_port < p2_in->sin_port) 620 return -1; 621 if(p1_in->sin_port > p2_in->sin_port) 622 return 1; 623 log_assert(p1_in->sin_port == p2_in->sin_port); 624 return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 625 } else if (p1_in6->sin6_family == AF_INET6) { 626 /* just order it, ntohs not required */ 627 if(p1_in6->sin6_port < p2_in6->sin6_port) 628 return -1; 629 if(p1_in6->sin6_port > p2_in6->sin6_port) 630 return 1; 631 log_assert(p1_in6->sin6_port == p2_in6->sin6_port); 632 return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 633 INET6_SIZE); 634 } else { 635 /* eek unknown type, perform this comparison for sanity. */ 636 return memcmp(addr1, addr2, len1); 637 } 638 } 639 640 int 641 sockaddr_cmp_addr(struct sockaddr_storage* addr1, socklen_t len1, 642 struct sockaddr_storage* addr2, socklen_t len2) 643 { 644 struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 645 struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 646 struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 647 struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 648 if(len1 < len2) 649 return -1; 650 if(len1 > len2) 651 return 1; 652 log_assert(len1 == len2); 653 if( p1_in->sin_family < p2_in->sin_family) 654 return -1; 655 if( p1_in->sin_family > p2_in->sin_family) 656 return 1; 657 log_assert( p1_in->sin_family == p2_in->sin_family ); 658 /* compare ip4 */ 659 if( p1_in->sin_family == AF_INET ) { 660 return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 661 } else if (p1_in6->sin6_family == AF_INET6) { 662 return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 663 INET6_SIZE); 664 } else { 665 /* eek unknown type, perform this comparison for sanity. */ 666 return memcmp(addr1, addr2, len1); 667 } 668 } 669 670 int 671 addr_is_ip6(struct sockaddr_storage* addr, socklen_t len) 672 { 673 if(len == (socklen_t)sizeof(struct sockaddr_in6) && 674 ((struct sockaddr_in6*)addr)->sin6_family == AF_INET6) 675 return 1; 676 else return 0; 677 } 678 679 void 680 addr_mask(struct sockaddr_storage* addr, socklen_t len, int net) 681 { 682 uint8_t mask[8] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe}; 683 int i, max; 684 uint8_t* s; 685 if(addr_is_ip6(addr, len)) { 686 s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 687 max = 128; 688 } else { 689 s = (uint8_t*)&((struct sockaddr_in*)addr)->sin_addr; 690 max = 32; 691 } 692 if(net >= max) 693 return; 694 for(i=net/8+1; i<max/8; i++) { 695 s[i] = 0; 696 } 697 s[net/8] &= mask[net&0x7]; 698 } 699 700 int 701 addr_in_common(struct sockaddr_storage* addr1, int net1, 702 struct sockaddr_storage* addr2, int net2, socklen_t addrlen) 703 { 704 int min = (net1<net2)?net1:net2; 705 int i, to; 706 int match = 0; 707 uint8_t* s1, *s2; 708 if(addr_is_ip6(addr1, addrlen)) { 709 s1 = (uint8_t*)&((struct sockaddr_in6*)addr1)->sin6_addr; 710 s2 = (uint8_t*)&((struct sockaddr_in6*)addr2)->sin6_addr; 711 to = 16; 712 } else { 713 s1 = (uint8_t*)&((struct sockaddr_in*)addr1)->sin_addr; 714 s2 = (uint8_t*)&((struct sockaddr_in*)addr2)->sin_addr; 715 to = 4; 716 } 717 /* match = bits_in_common(s1, s2, to); */ 718 for(i=0; i<to; i++) { 719 if(s1[i] == s2[i]) { 720 match += 8; 721 } else { 722 uint8_t z = s1[i]^s2[i]; 723 log_assert(z); 724 while(!(z&0x80)) { 725 match++; 726 z<<=1; 727 } 728 break; 729 } 730 } 731 if(match > min) match = min; 732 return match; 733 } 734 735 void 736 addr_to_str(struct sockaddr_storage* addr, socklen_t addrlen, 737 char* buf, size_t len) 738 { 739 int af = (int)((struct sockaddr_in*)addr)->sin_family; 740 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 741 if(addr_is_ip6(addr, addrlen)) 742 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 743 if(inet_ntop(af, sinaddr, buf, (socklen_t)len) == 0) { 744 snprintf(buf, len, "(inet_ntop_error)"); 745 } 746 } 747 748 int 749 addr_is_ip4mapped(struct sockaddr_storage* addr, socklen_t addrlen) 750 { 751 /* prefix for ipv4 into ipv6 mapping is ::ffff:x.x.x.x */ 752 const uint8_t map_prefix[16] = 753 {0,0,0,0, 0,0,0,0, 0,0,0xff,0xff, 0,0,0,0}; 754 uint8_t* s; 755 if(!addr_is_ip6(addr, addrlen)) 756 return 0; 757 /* s is 16 octet ipv6 address string */ 758 s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 759 return (memcmp(s, map_prefix, 12) == 0); 760 } 761 762 int addr_is_broadcast(struct sockaddr_storage* addr, socklen_t addrlen) 763 { 764 int af = (int)((struct sockaddr_in*)addr)->sin_family; 765 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 766 return af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 767 && memcmp(sinaddr, "\377\377\377\377", 4) == 0; 768 } 769 770 int addr_is_any(struct sockaddr_storage* addr, socklen_t addrlen) 771 { 772 int af = (int)((struct sockaddr_in*)addr)->sin_family; 773 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 774 void* sin6addr = &((struct sockaddr_in6*)addr)->sin6_addr; 775 if(af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 776 && memcmp(sinaddr, "\000\000\000\000", 4) == 0) 777 return 1; 778 else if(af==AF_INET6 && addrlen>=(socklen_t)sizeof(struct sockaddr_in6) 779 && memcmp(sin6addr, "\000\000\000\000\000\000\000\000" 780 "\000\000\000\000\000\000\000\000", 16) == 0) 781 return 1; 782 return 0; 783 } 784 785 void sock_list_insert(struct sock_list** list, struct sockaddr_storage* addr, 786 socklen_t len, struct regional* region) 787 { 788 struct sock_list* add = (struct sock_list*)regional_alloc(region, 789 sizeof(*add) - sizeof(add->addr) + (size_t)len); 790 if(!add) { 791 log_err("out of memory in socketlist insert"); 792 return; 793 } 794 log_assert(list); 795 add->next = *list; 796 add->len = len; 797 *list = add; 798 if(len) memmove(&add->addr, addr, len); 799 } 800 801 void sock_list_prepend(struct sock_list** list, struct sock_list* add) 802 { 803 struct sock_list* last = add; 804 if(!last) 805 return; 806 while(last->next) 807 last = last->next; 808 last->next = *list; 809 *list = add; 810 } 811 812 int sock_list_find(struct sock_list* list, struct sockaddr_storage* addr, 813 socklen_t len) 814 { 815 while(list) { 816 if(len == list->len) { 817 if(len == 0 || sockaddr_cmp_addr(addr, len, 818 &list->addr, list->len) == 0) 819 return 1; 820 } 821 list = list->next; 822 } 823 return 0; 824 } 825 826 void sock_list_merge(struct sock_list** list, struct regional* region, 827 struct sock_list* add) 828 { 829 struct sock_list* p; 830 for(p=add; p; p=p->next) { 831 if(!sock_list_find(*list, &p->addr, p->len)) 832 sock_list_insert(list, &p->addr, p->len, region); 833 } 834 } 835 836 void 837 log_crypto_err(const char* str) 838 { 839 #ifdef HAVE_SSL 840 log_crypto_err_code(str, ERR_get_error()); 841 #else 842 (void)str; 843 #endif /* HAVE_SSL */ 844 } 845 846 void log_crypto_err_code(const char* str, unsigned long err) 847 { 848 #ifdef HAVE_SSL 849 /* error:[error code]:[library name]:[function name]:[reason string] */ 850 char buf[128]; 851 unsigned long e; 852 ERR_error_string_n(err, buf, sizeof(buf)); 853 log_err("%s crypto %s", str, buf); 854 while( (e=ERR_get_error()) ) { 855 ERR_error_string_n(e, buf, sizeof(buf)); 856 log_err("and additionally crypto %s", buf); 857 } 858 #else 859 (void)str; 860 (void)err; 861 #endif /* HAVE_SSL */ 862 } 863 864 #ifdef HAVE_SSL 865 /** log certificate details */ 866 void 867 log_cert(unsigned level, const char* str, void* cert) 868 { 869 BIO* bio; 870 char nul = 0; 871 char* pp = NULL; 872 long len; 873 if(verbosity < level) return; 874 bio = BIO_new(BIO_s_mem()); 875 if(!bio) return; 876 X509_print_ex(bio, (X509*)cert, 0, (unsigned long)-1 877 ^(X509_FLAG_NO_SUBJECT 878 |X509_FLAG_NO_ISSUER|X509_FLAG_NO_VALIDITY 879 |X509_FLAG_NO_EXTENSIONS|X509_FLAG_NO_AUX 880 |X509_FLAG_NO_ATTRIBUTES)); 881 BIO_write(bio, &nul, (int)sizeof(nul)); 882 len = BIO_get_mem_data(bio, &pp); 883 if(len != 0 && pp) { 884 verbose(level, "%s: \n%s", str, pp); 885 } 886 BIO_free(bio); 887 } 888 #endif /* HAVE_SSL */ 889 890 #if defined(HAVE_SSL) && defined(HAVE_NGHTTP2) 891 static int alpn_select_cb(SSL* ATTR_UNUSED(ssl), const unsigned char** out, 892 unsigned char* outlen, const unsigned char* in, unsigned int inlen, 893 void* ATTR_UNUSED(arg)) 894 { 895 int rv = nghttp2_select_next_protocol((unsigned char **)out, outlen, in, 896 inlen); 897 if(rv == -1) { 898 return SSL_TLSEXT_ERR_NOACK; 899 } 900 /* either http/1.1 or h2 selected */ 901 return SSL_TLSEXT_ERR_OK; 902 } 903 #endif 904 905 int 906 listen_sslctx_setup(void* ctxt) 907 { 908 #ifdef HAVE_SSL 909 SSL_CTX* ctx = (SSL_CTX*)ctxt; 910 /* no SSLv2, SSLv3 because has defects */ 911 #if SSL_OP_NO_SSLv2 != 0 912 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 913 != SSL_OP_NO_SSLv2){ 914 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 915 return 0; 916 } 917 #endif 918 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 919 != SSL_OP_NO_SSLv3){ 920 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 921 return 0; 922 } 923 #if defined(SSL_OP_NO_TLSv1) && defined(SSL_OP_NO_TLSv1_1) 924 /* if we have tls 1.1 disable 1.0 */ 925 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1) & SSL_OP_NO_TLSv1) 926 != SSL_OP_NO_TLSv1){ 927 log_crypto_err("could not set SSL_OP_NO_TLSv1"); 928 return 0; 929 } 930 #endif 931 #if defined(SSL_OP_NO_TLSv1_1) && defined(SSL_OP_NO_TLSv1_2) 932 /* if we have tls 1.2 disable 1.1 */ 933 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1_1) & SSL_OP_NO_TLSv1_1) 934 != SSL_OP_NO_TLSv1_1){ 935 log_crypto_err("could not set SSL_OP_NO_TLSv1_1"); 936 return 0; 937 } 938 #endif 939 #if defined(SSL_OP_NO_RENEGOTIATION) 940 /* disable client renegotiation */ 941 if((SSL_CTX_set_options(ctx, SSL_OP_NO_RENEGOTIATION) & 942 SSL_OP_NO_RENEGOTIATION) != SSL_OP_NO_RENEGOTIATION) { 943 log_crypto_err("could not set SSL_OP_NO_RENEGOTIATION"); 944 return 0; 945 } 946 #endif 947 #if defined(SHA256_DIGEST_LENGTH) && defined(USE_ECDSA) 948 /* if we have sha256, set the cipher list to have no known vulns */ 949 if(!SSL_CTX_set_cipher_list(ctx, "TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-256-GCM-SHA384:TLS13-AES-128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256")) 950 log_crypto_err("could not set cipher list with SSL_CTX_set_cipher_list"); 951 #endif 952 953 if((SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE) & 954 SSL_OP_CIPHER_SERVER_PREFERENCE) != 955 SSL_OP_CIPHER_SERVER_PREFERENCE) { 956 log_crypto_err("could not set SSL_OP_CIPHER_SERVER_PREFERENCE"); 957 return 0; 958 } 959 960 #ifdef HAVE_SSL_CTX_SET_SECURITY_LEVEL 961 SSL_CTX_set_security_level(ctx, 0); 962 #endif 963 #if defined(HAVE_SSL_CTX_SET_ALPN_SELECT_CB) && defined(HAVE_NGHTTP2) 964 SSL_CTX_set_alpn_select_cb(ctx, alpn_select_cb, NULL); 965 #endif 966 #else 967 (void)ctxt; 968 #endif /* HAVE_SSL */ 969 return 1; 970 } 971 972 void 973 listen_sslctx_setup_2(void* ctxt) 974 { 975 #ifdef HAVE_SSL 976 SSL_CTX* ctx = (SSL_CTX*)ctxt; 977 (void)ctx; 978 #if HAVE_DECL_SSL_CTX_SET_ECDH_AUTO 979 if(!SSL_CTX_set_ecdh_auto(ctx,1)) { 980 log_crypto_err("Error in SSL_CTX_ecdh_auto, not enabling ECDHE"); 981 } 982 #elif defined(USE_ECDSA) 983 if(1) { 984 EC_KEY *ecdh = EC_KEY_new_by_curve_name (NID_X9_62_prime256v1); 985 if (!ecdh) { 986 log_crypto_err("could not find p256, not enabling ECDHE"); 987 } else { 988 if (1 != SSL_CTX_set_tmp_ecdh (ctx, ecdh)) { 989 log_crypto_err("Error in SSL_CTX_set_tmp_ecdh, not enabling ECDHE"); 990 } 991 EC_KEY_free (ecdh); 992 } 993 } 994 #endif 995 #else 996 (void)ctxt; 997 #endif /* HAVE_SSL */ 998 } 999 1000 void* listen_sslctx_create(char* key, char* pem, char* verifypem) 1001 { 1002 #ifdef HAVE_SSL 1003 SSL_CTX* ctx = SSL_CTX_new(SSLv23_server_method()); 1004 if(!ctx) { 1005 log_crypto_err("could not SSL_CTX_new"); 1006 return NULL; 1007 } 1008 if(!key || key[0] == 0) { 1009 log_err("error: no tls-service-key file specified"); 1010 SSL_CTX_free(ctx); 1011 return NULL; 1012 } 1013 if(!pem || pem[0] == 0) { 1014 log_err("error: no tls-service-pem file specified"); 1015 SSL_CTX_free(ctx); 1016 return NULL; 1017 } 1018 if(!listen_sslctx_setup(ctx)) { 1019 SSL_CTX_free(ctx); 1020 return NULL; 1021 } 1022 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 1023 log_err("error for cert file: %s", pem); 1024 log_crypto_err("error in SSL_CTX use_certificate_chain_file"); 1025 SSL_CTX_free(ctx); 1026 return NULL; 1027 } 1028 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 1029 log_err("error for private key file: %s", key); 1030 log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 1031 SSL_CTX_free(ctx); 1032 return NULL; 1033 } 1034 if(!SSL_CTX_check_private_key(ctx)) { 1035 log_err("error for key file: %s", key); 1036 log_crypto_err("Error in SSL_CTX check_private_key"); 1037 SSL_CTX_free(ctx); 1038 return NULL; 1039 } 1040 listen_sslctx_setup_2(ctx); 1041 if(verifypem && verifypem[0]) { 1042 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 1043 log_crypto_err("Error in SSL_CTX verify locations"); 1044 SSL_CTX_free(ctx); 1045 return NULL; 1046 } 1047 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file( 1048 verifypem)); 1049 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL); 1050 } 1051 return ctx; 1052 #else 1053 (void)key; (void)pem; (void)verifypem; 1054 return NULL; 1055 #endif 1056 } 1057 1058 #ifdef USE_WINSOCK 1059 /* For windows, the CA trust store is not read by openssl. 1060 Add code to open the trust store using wincrypt API and add 1061 the root certs into openssl trust store */ 1062 static int 1063 add_WIN_cacerts_to_openssl_store(SSL_CTX* tls_ctx) 1064 { 1065 HCERTSTORE hSystemStore; 1066 PCCERT_CONTEXT pTargetCert = NULL; 1067 X509_STORE* store; 1068 1069 verbose(VERB_ALGO, "Adding Windows certificates from system root store to CA store"); 1070 1071 /* load just once per context lifetime for this version 1072 TODO: dynamically update CA trust changes as they are available */ 1073 if (!tls_ctx) 1074 return 0; 1075 1076 /* Call wincrypt's CertOpenStore to open the CA root store. */ 1077 1078 if ((hSystemStore = CertOpenStore( 1079 CERT_STORE_PROV_SYSTEM, 1080 0, 1081 0, 1082 /* NOTE: mingw does not have this const: replace with 1 << 16 from code 1083 CERT_SYSTEM_STORE_CURRENT_USER, */ 1084 1 << 16, 1085 L"root")) == 0) 1086 { 1087 return 0; 1088 } 1089 1090 store = SSL_CTX_get_cert_store(tls_ctx); 1091 if (!store) 1092 return 0; 1093 1094 /* failure if the CA store is empty or the call fails */ 1095 if ((pTargetCert = CertEnumCertificatesInStore( 1096 hSystemStore, pTargetCert)) == 0) { 1097 verbose(VERB_ALGO, "CA certificate store for Windows is empty."); 1098 return 0; 1099 } 1100 /* iterate over the windows cert store and add to openssl store */ 1101 do 1102 { 1103 X509 *cert1 = d2i_X509(NULL, 1104 (const unsigned char **)&pTargetCert->pbCertEncoded, 1105 pTargetCert->cbCertEncoded); 1106 if (!cert1) { 1107 /* return error if a cert fails */ 1108 verbose(VERB_ALGO, "%s %d:%s", 1109 "Unable to parse certificate in memory", 1110 (int)ERR_get_error(), ERR_error_string(ERR_get_error(), NULL)); 1111 return 0; 1112 } 1113 else { 1114 /* return error if a cert add to store fails */ 1115 if (X509_STORE_add_cert(store, cert1) == 0) { 1116 unsigned long error = ERR_peek_last_error(); 1117 1118 /* Ignore error X509_R_CERT_ALREADY_IN_HASH_TABLE which means the 1119 * certificate is already in the store. */ 1120 if(ERR_GET_LIB(error) != ERR_LIB_X509 || 1121 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) { 1122 verbose(VERB_ALGO, "%s %d:%s\n", 1123 "Error adding certificate", (int)ERR_get_error(), 1124 ERR_error_string(ERR_get_error(), NULL)); 1125 X509_free(cert1); 1126 return 0; 1127 } 1128 } 1129 X509_free(cert1); 1130 } 1131 } while ((pTargetCert = CertEnumCertificatesInStore( 1132 hSystemStore, pTargetCert)) != 0); 1133 1134 /* Clean up memory and quit. */ 1135 if (pTargetCert) 1136 CertFreeCertificateContext(pTargetCert); 1137 if (hSystemStore) 1138 { 1139 if (!CertCloseStore( 1140 hSystemStore, 0)) 1141 return 0; 1142 } 1143 verbose(VERB_ALGO, "Completed adding Windows certificates to CA store successfully"); 1144 return 1; 1145 } 1146 #endif /* USE_WINSOCK */ 1147 1148 void* connect_sslctx_create(char* key, char* pem, char* verifypem, int wincert) 1149 { 1150 #ifdef HAVE_SSL 1151 SSL_CTX* ctx = SSL_CTX_new(SSLv23_client_method()); 1152 if(!ctx) { 1153 log_crypto_err("could not allocate SSL_CTX pointer"); 1154 return NULL; 1155 } 1156 #if SSL_OP_NO_SSLv2 != 0 1157 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 1158 != SSL_OP_NO_SSLv2) { 1159 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 1160 SSL_CTX_free(ctx); 1161 return NULL; 1162 } 1163 #endif 1164 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 1165 != SSL_OP_NO_SSLv3) { 1166 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 1167 SSL_CTX_free(ctx); 1168 return NULL; 1169 } 1170 #if defined(SSL_OP_NO_RENEGOTIATION) 1171 /* disable client renegotiation */ 1172 if((SSL_CTX_set_options(ctx, SSL_OP_NO_RENEGOTIATION) & 1173 SSL_OP_NO_RENEGOTIATION) != SSL_OP_NO_RENEGOTIATION) { 1174 log_crypto_err("could not set SSL_OP_NO_RENEGOTIATION"); 1175 return 0; 1176 } 1177 #endif 1178 if(key && key[0]) { 1179 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 1180 log_err("error in client certificate %s", pem); 1181 log_crypto_err("error in certificate file"); 1182 SSL_CTX_free(ctx); 1183 return NULL; 1184 } 1185 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 1186 log_err("error in client private key %s", key); 1187 log_crypto_err("error in key file"); 1188 SSL_CTX_free(ctx); 1189 return NULL; 1190 } 1191 if(!SSL_CTX_check_private_key(ctx)) { 1192 log_err("error in client key %s", key); 1193 log_crypto_err("error in SSL_CTX_check_private_key"); 1194 SSL_CTX_free(ctx); 1195 return NULL; 1196 } 1197 } 1198 if((verifypem && verifypem[0]) || wincert) { 1199 if(verifypem && verifypem[0]) { 1200 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 1201 log_crypto_err("error in SSL_CTX verify"); 1202 SSL_CTX_free(ctx); 1203 return NULL; 1204 } 1205 } 1206 #ifdef USE_WINSOCK 1207 if(wincert) { 1208 if(!add_WIN_cacerts_to_openssl_store(ctx)) { 1209 log_crypto_err("error in add_WIN_cacerts_to_openssl_store"); 1210 SSL_CTX_free(ctx); 1211 return NULL; 1212 } 1213 } 1214 #else 1215 (void)wincert; 1216 #endif 1217 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 1218 } 1219 return ctx; 1220 #else 1221 (void)key; (void)pem; (void)verifypem; (void)wincert; 1222 return NULL; 1223 #endif 1224 } 1225 1226 void* incoming_ssl_fd(void* sslctx, int fd) 1227 { 1228 #ifdef HAVE_SSL 1229 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1230 if(!ssl) { 1231 log_crypto_err("could not SSL_new"); 1232 return NULL; 1233 } 1234 SSL_set_accept_state(ssl); 1235 (void)SSL_set_mode(ssl, (long)SSL_MODE_AUTO_RETRY); 1236 if(!SSL_set_fd(ssl, fd)) { 1237 log_crypto_err("could not SSL_set_fd"); 1238 SSL_free(ssl); 1239 return NULL; 1240 } 1241 return ssl; 1242 #else 1243 (void)sslctx; (void)fd; 1244 return NULL; 1245 #endif 1246 } 1247 1248 void* outgoing_ssl_fd(void* sslctx, int fd) 1249 { 1250 #ifdef HAVE_SSL 1251 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1252 if(!ssl) { 1253 log_crypto_err("could not SSL_new"); 1254 return NULL; 1255 } 1256 SSL_set_connect_state(ssl); 1257 (void)SSL_set_mode(ssl, (long)SSL_MODE_AUTO_RETRY); 1258 if(!SSL_set_fd(ssl, fd)) { 1259 log_crypto_err("could not SSL_set_fd"); 1260 SSL_free(ssl); 1261 return NULL; 1262 } 1263 return ssl; 1264 #else 1265 (void)sslctx; (void)fd; 1266 return NULL; 1267 #endif 1268 } 1269 1270 int check_auth_name_for_ssl(char* auth_name) 1271 { 1272 if(!auth_name) return 1; 1273 #if defined(HAVE_SSL) && !defined(HAVE_SSL_SET1_HOST) && !defined(HAVE_X509_VERIFY_PARAM_SET1_HOST) 1274 log_err("the query has an auth_name %s, but libssl has no call to " 1275 "perform TLS authentication. Remove that name from config " 1276 "or upgrade the ssl crypto library.", auth_name); 1277 return 0; 1278 #else 1279 return 1; 1280 #endif 1281 } 1282 1283 /** set the authname on an SSL structure, SSL* ssl */ 1284 int set_auth_name_on_ssl(void* ssl, char* auth_name, int use_sni) 1285 { 1286 if(!auth_name) return 1; 1287 #ifdef HAVE_SSL 1288 if(use_sni) { 1289 (void)SSL_set_tlsext_host_name(ssl, auth_name); 1290 } 1291 #else 1292 (void)ssl; 1293 (void)use_sni; 1294 #endif 1295 #ifdef HAVE_SSL_SET1_HOST 1296 SSL_set_verify(ssl, SSL_VERIFY_PEER, NULL); 1297 /* setting the hostname makes openssl verify the 1298 * host name in the x509 certificate in the 1299 * SSL connection*/ 1300 if(!SSL_set1_host(ssl, auth_name)) { 1301 log_err("SSL_set1_host failed"); 1302 return 0; 1303 } 1304 #elif defined(HAVE_X509_VERIFY_PARAM_SET1_HOST) 1305 /* openssl 1.0.2 has this function that can be used for 1306 * set1_host like verification */ 1307 if(auth_name) { 1308 X509_VERIFY_PARAM* param = SSL_get0_param(ssl); 1309 # ifdef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 1310 X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS); 1311 # endif 1312 if(!X509_VERIFY_PARAM_set1_host(param, auth_name, strlen(auth_name))) { 1313 log_err("X509_VERIFY_PARAM_set1_host failed"); 1314 return 0; 1315 } 1316 SSL_set_verify(ssl, SSL_VERIFY_PEER, NULL); 1317 } 1318 #else 1319 verbose(VERB_ALGO, "the query has an auth_name, but libssl has no call to perform TLS authentication"); 1320 #endif /* HAVE_SSL_SET1_HOST */ 1321 return 1; 1322 } 1323 1324 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1325 /** global lock list for openssl locks */ 1326 static lock_basic_type *ub_openssl_locks = NULL; 1327 1328 /** callback that gets thread id for openssl */ 1329 #ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1330 static void 1331 ub_crypto_id_cb(CRYPTO_THREADID *id) 1332 { 1333 CRYPTO_THREADID_set_numeric(id, (unsigned long)log_thread_get()); 1334 } 1335 #else 1336 static unsigned long 1337 ub_crypto_id_cb(void) 1338 { 1339 return (unsigned long)log_thread_get(); 1340 } 1341 #endif 1342 1343 static void 1344 ub_crypto_lock_cb(int mode, int type, const char *ATTR_UNUSED(file), 1345 int ATTR_UNUSED(line)) 1346 { 1347 if((mode&CRYPTO_LOCK)) { 1348 lock_basic_lock(&ub_openssl_locks[type]); 1349 } else { 1350 lock_basic_unlock(&ub_openssl_locks[type]); 1351 } 1352 } 1353 #endif /* OPENSSL_THREADS */ 1354 1355 int ub_openssl_lock_init(void) 1356 { 1357 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1358 int i; 1359 ub_openssl_locks = (lock_basic_type*)reallocarray( 1360 NULL, (size_t)CRYPTO_num_locks(), sizeof(lock_basic_type)); 1361 if(!ub_openssl_locks) 1362 return 0; 1363 for(i=0; i<CRYPTO_num_locks(); i++) { 1364 lock_basic_init(&ub_openssl_locks[i]); 1365 } 1366 # ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1367 CRYPTO_THREADID_set_callback(&ub_crypto_id_cb); 1368 # else 1369 CRYPTO_set_id_callback(&ub_crypto_id_cb); 1370 # endif 1371 CRYPTO_set_locking_callback(&ub_crypto_lock_cb); 1372 #endif /* OPENSSL_THREADS */ 1373 return 1; 1374 } 1375 1376 void ub_openssl_lock_delete(void) 1377 { 1378 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1379 int i; 1380 if(!ub_openssl_locks) 1381 return; 1382 # ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1383 CRYPTO_THREADID_set_callback(NULL); 1384 # else 1385 CRYPTO_set_id_callback(NULL); 1386 # endif 1387 CRYPTO_set_locking_callback(NULL); 1388 for(i=0; i<CRYPTO_num_locks(); i++) { 1389 lock_basic_destroy(&ub_openssl_locks[i]); 1390 } 1391 free(ub_openssl_locks); 1392 #endif /* OPENSSL_THREADS */ 1393 } 1394 1395 int listen_sslctx_setup_ticket_keys(void* sslctx, struct config_strlist* tls_session_ticket_keys) { 1396 #ifdef HAVE_SSL 1397 size_t s = 1; 1398 struct config_strlist* p; 1399 struct tls_session_ticket_key *keys; 1400 for(p = tls_session_ticket_keys; p; p = p->next) { 1401 s++; 1402 } 1403 keys = calloc(s, sizeof(struct tls_session_ticket_key)); 1404 if(!keys) 1405 return 0; 1406 memset(keys, 0, s*sizeof(*keys)); 1407 ticket_keys = keys; 1408 1409 for(p = tls_session_ticket_keys; p; p = p->next) { 1410 size_t n; 1411 unsigned char *data; 1412 FILE *f; 1413 1414 data = (unsigned char *)malloc(80); 1415 if(!data) 1416 return 0; 1417 1418 f = fopen(p->str, "rb"); 1419 if(!f) { 1420 log_err("could not read tls-session-ticket-key %s: %s", p->str, strerror(errno)); 1421 free(data); 1422 return 0; 1423 } 1424 n = fread(data, 1, 80, f); 1425 fclose(f); 1426 1427 if(n != 80) { 1428 log_err("tls-session-ticket-key %s is %d bytes, must be 80 bytes", p->str, (int)n); 1429 free(data); 1430 return 0; 1431 } 1432 verbose(VERB_OPS, "read tls-session-ticket-key: %s", p->str); 1433 1434 keys->key_name = data; 1435 keys->aes_key = data + 16; 1436 keys->hmac_key = data + 48; 1437 keys++; 1438 } 1439 /* terminate array with NULL key name entry */ 1440 keys->key_name = NULL; 1441 # ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1442 if(SSL_CTX_set_tlsext_ticket_key_evp_cb(sslctx, tls_session_ticket_key_cb) == 0) { 1443 log_err("no support for TLS session ticket"); 1444 return 0; 1445 } 1446 # else 1447 if(SSL_CTX_set_tlsext_ticket_key_cb(sslctx, tls_session_ticket_key_cb) == 0) { 1448 log_err("no support for TLS session ticket"); 1449 return 0; 1450 } 1451 # endif 1452 return 1; 1453 #else 1454 (void)sslctx; 1455 (void)tls_session_ticket_keys; 1456 return 0; 1457 #endif 1458 1459 } 1460 1461 #ifdef HAVE_SSL 1462 int tls_session_ticket_key_cb(SSL *ATTR_UNUSED(sslctx), unsigned char* key_name, 1463 unsigned char* iv, EVP_CIPHER_CTX *evp_sctx, 1464 #ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1465 EVP_MAC_CTX *hmac_ctx, 1466 #else 1467 HMAC_CTX* hmac_ctx, 1468 #endif 1469 int enc) 1470 { 1471 #ifdef HAVE_SSL 1472 # ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1473 OSSL_PARAM params[3]; 1474 # else 1475 const EVP_MD *digest; 1476 # endif 1477 const EVP_CIPHER *cipher; 1478 int evp_cipher_length; 1479 # ifndef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1480 digest = EVP_sha256(); 1481 # endif 1482 cipher = EVP_aes_256_cbc(); 1483 evp_cipher_length = EVP_CIPHER_iv_length(cipher); 1484 if( enc == 1 ) { 1485 /* encrypt */ 1486 verbose(VERB_CLIENT, "start session encrypt"); 1487 memcpy(key_name, ticket_keys->key_name, 16); 1488 if (RAND_bytes(iv, evp_cipher_length) != 1) { 1489 verbose(VERB_CLIENT, "RAND_bytes failed"); 1490 return -1; 1491 } 1492 if (EVP_EncryptInit_ex(evp_sctx, cipher, NULL, ticket_keys->aes_key, iv) != 1) { 1493 verbose(VERB_CLIENT, "EVP_EncryptInit_ex failed"); 1494 return -1; 1495 } 1496 #ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1497 params[0] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY, 1498 ticket_keys->hmac_key, 32); 1499 params[1] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, 1500 "sha256", 0); 1501 params[2] = OSSL_PARAM_construct_end(); 1502 #ifdef HAVE_EVP_MAC_CTX_SET_PARAMS 1503 EVP_MAC_CTX_set_params(hmac_ctx, params); 1504 #else 1505 EVP_MAC_set_ctx_params(hmac_ctx, params); 1506 #endif 1507 #elif !defined(HMAC_INIT_EX_RETURNS_VOID) 1508 if (HMAC_Init_ex(hmac_ctx, ticket_keys->hmac_key, 32, digest, NULL) != 1) { 1509 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1510 return -1; 1511 } 1512 #else 1513 HMAC_Init_ex(hmac_ctx, ticket_keys->hmac_key, 32, digest, NULL); 1514 #endif 1515 return 1; 1516 } else if (enc == 0) { 1517 /* decrypt */ 1518 struct tls_session_ticket_key *key; 1519 verbose(VERB_CLIENT, "start session decrypt"); 1520 for(key = ticket_keys; key->key_name != NULL; key++) { 1521 if (!memcmp(key_name, key->key_name, 16)) { 1522 verbose(VERB_CLIENT, "Found session_key"); 1523 break; 1524 } 1525 } 1526 if(key->key_name == NULL) { 1527 verbose(VERB_CLIENT, "Not found session_key"); 1528 return 0; 1529 } 1530 1531 #ifdef HAVE_SSL_CTX_SET_TLSEXT_TICKET_KEY_EVP_CB 1532 params[0] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, 1533 key->hmac_key, 32); 1534 params[1] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, 1535 "sha256", 0); 1536 params[2] = OSSL_PARAM_construct_end(); 1537 #ifdef HAVE_EVP_MAC_CTX_SET_PARAMS 1538 EVP_MAC_CTX_set_params(hmac_ctx, params); 1539 #else 1540 EVP_MAC_set_ctx_params(hmac_ctx, params); 1541 #endif 1542 #elif !defined(HMAC_INIT_EX_RETURNS_VOID) 1543 if (HMAC_Init_ex(hmac_ctx, key->hmac_key, 32, digest, NULL) != 1) { 1544 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1545 return -1; 1546 } 1547 #else 1548 HMAC_Init_ex(hmac_ctx, key->hmac_key, 32, digest, NULL); 1549 #endif 1550 if (EVP_DecryptInit_ex(evp_sctx, cipher, NULL, key->aes_key, iv) != 1) { 1551 log_err("EVP_DecryptInit_ex failed"); 1552 return -1; 1553 } 1554 1555 return (key == ticket_keys) ? 1 : 2; 1556 } 1557 return -1; 1558 #else 1559 (void)key_name; 1560 (void)iv; 1561 (void)evp_sctx; 1562 (void)hmac_ctx; 1563 (void)enc; 1564 return 0; 1565 #endif 1566 } 1567 #endif /* HAVE_SSL */ 1568 1569 void 1570 listen_sslctx_delete_ticket_keys(void) 1571 { 1572 struct tls_session_ticket_key *key; 1573 if(!ticket_keys) return; 1574 for(key = ticket_keys; key->key_name != NULL; key++) { 1575 /* wipe key data from memory*/ 1576 #ifdef HAVE_EXPLICIT_BZERO 1577 explicit_bzero(key->key_name, 80); 1578 #else 1579 memset(key->key_name, 0xdd, 80); 1580 #endif 1581 free(key->key_name); 1582 } 1583 free(ticket_keys); 1584 ticket_keys = NULL; 1585 } 1586 1587 # ifndef USE_WINSOCK 1588 char* 1589 sock_strerror(int errn) 1590 { 1591 return strerror(errn); 1592 } 1593 1594 void 1595 sock_close(int socket) 1596 { 1597 close(socket); 1598 } 1599 1600 # else 1601 char* 1602 sock_strerror(int ATTR_UNUSED(errn)) 1603 { 1604 return wsa_strerror(WSAGetLastError()); 1605 } 1606 1607 void 1608 sock_close(int socket) 1609 { 1610 closesocket(socket); 1611 } 1612 1613 # endif /* USE_WINSOCK */ 1614