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