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 USE_WINSOCK 59 #include <wincrypt.h> 60 #endif 61 62 /** max length of an IP address (the address portion) that we allow */ 63 #define MAX_ADDR_STRLEN 128 /* characters */ 64 /** default value for EDNS ADVERTISED size */ 65 uint16_t EDNS_ADVERTISED_SIZE = 4096; 66 67 /** minimal responses when positive answer: default is no */ 68 int MINIMAL_RESPONSES = 0; 69 70 /** rrset order roundrobin: default is no */ 71 int RRSET_ROUNDROBIN = 0; 72 73 /** log tag queries with name instead of 'info' for filtering */ 74 int LOG_TAG_QUERYREPLY = 0; 75 76 static struct tls_session_ticket_key { 77 unsigned char *key_name; 78 unsigned char *aes_key; 79 unsigned char *hmac_key; 80 } *ticket_keys; 81 82 /* returns true is string addr is an ip6 specced address */ 83 int 84 str_is_ip6(const char* str) 85 { 86 if(strchr(str, ':')) 87 return 1; 88 else return 0; 89 } 90 91 int 92 fd_set_nonblock(int s) 93 { 94 #ifdef HAVE_FCNTL 95 int flag; 96 if((flag = fcntl(s, F_GETFL)) == -1) { 97 log_err("can't fcntl F_GETFL: %s", strerror(errno)); 98 flag = 0; 99 } 100 flag |= O_NONBLOCK; 101 if(fcntl(s, F_SETFL, flag) == -1) { 102 log_err("can't fcntl F_SETFL: %s", strerror(errno)); 103 return 0; 104 } 105 #elif defined(HAVE_IOCTLSOCKET) 106 unsigned long on = 1; 107 if(ioctlsocket(s, FIONBIO, &on) != 0) { 108 log_err("can't ioctlsocket FIONBIO on: %s", 109 wsa_strerror(WSAGetLastError())); 110 } 111 #endif 112 return 1; 113 } 114 115 int 116 fd_set_block(int s) 117 { 118 #ifdef HAVE_FCNTL 119 int flag; 120 if((flag = fcntl(s, F_GETFL)) == -1) { 121 log_err("cannot fcntl F_GETFL: %s", strerror(errno)); 122 flag = 0; 123 } 124 flag &= ~O_NONBLOCK; 125 if(fcntl(s, F_SETFL, flag) == -1) { 126 log_err("cannot fcntl F_SETFL: %s", strerror(errno)); 127 return 0; 128 } 129 #elif defined(HAVE_IOCTLSOCKET) 130 unsigned long off = 0; 131 if(ioctlsocket(s, FIONBIO, &off) != 0) { 132 if(WSAGetLastError() != WSAEINVAL || verbosity >= 4) 133 log_err("can't ioctlsocket FIONBIO off: %s", 134 wsa_strerror(WSAGetLastError())); 135 } 136 #endif 137 return 1; 138 } 139 140 int 141 is_pow2(size_t num) 142 { 143 if(num == 0) return 1; 144 return (num & (num-1)) == 0; 145 } 146 147 void* 148 memdup(void* data, size_t len) 149 { 150 void* d; 151 if(!data) return NULL; 152 if(len == 0) return NULL; 153 d = malloc(len); 154 if(!d) return NULL; 155 memcpy(d, data, len); 156 return d; 157 } 158 159 void 160 log_addr(enum verbosity_value v, const char* str, 161 struct sockaddr_storage* addr, socklen_t addrlen) 162 { 163 uint16_t port; 164 const char* family = "unknown"; 165 char dest[100]; 166 int af = (int)((struct sockaddr_in*)addr)->sin_family; 167 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 168 if(verbosity < v) 169 return; 170 switch(af) { 171 case AF_INET: family="ip4"; break; 172 case AF_INET6: family="ip6"; 173 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 174 break; 175 case AF_LOCAL: 176 dest[0]=0; 177 (void)inet_ntop(af, sinaddr, dest, 178 (socklen_t)sizeof(dest)); 179 verbose(v, "%s local %s", str, dest); 180 return; /* do not continue and try to get port */ 181 default: break; 182 } 183 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 184 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 185 } 186 dest[sizeof(dest)-1] = 0; 187 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 188 if(verbosity >= 4) 189 verbose(v, "%s %s %s port %d (len %d)", str, family, dest, 190 (int)port, (int)addrlen); 191 else verbose(v, "%s %s port %d", str, dest, (int)port); 192 } 193 194 int 195 extstrtoaddr(const char* str, struct sockaddr_storage* addr, 196 socklen_t* addrlen) 197 { 198 char* s; 199 int port = UNBOUND_DNS_PORT; 200 if((s=strchr(str, '@'))) { 201 char buf[MAX_ADDR_STRLEN]; 202 if(s-str >= MAX_ADDR_STRLEN) { 203 return 0; 204 } 205 (void)strlcpy(buf, str, sizeof(buf)); 206 buf[s-str] = 0; 207 port = atoi(s+1); 208 if(port == 0 && strcmp(s+1,"0")!=0) { 209 return 0; 210 } 211 return ipstrtoaddr(buf, port, addr, addrlen); 212 } 213 return ipstrtoaddr(str, port, addr, addrlen); 214 } 215 216 217 int 218 ipstrtoaddr(const char* ip, int port, struct sockaddr_storage* addr, 219 socklen_t* addrlen) 220 { 221 uint16_t p; 222 if(!ip) return 0; 223 p = (uint16_t) port; 224 if(str_is_ip6(ip)) { 225 char buf[MAX_ADDR_STRLEN]; 226 char* s; 227 struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 228 *addrlen = (socklen_t)sizeof(struct sockaddr_in6); 229 memset(sa, 0, *addrlen); 230 sa->sin6_family = AF_INET6; 231 sa->sin6_port = (in_port_t)htons(p); 232 if((s=strchr(ip, '%'))) { /* ip6%interface, rfc 4007 */ 233 if(s-ip >= MAX_ADDR_STRLEN) 234 return 0; 235 (void)strlcpy(buf, ip, sizeof(buf)); 236 buf[s-ip]=0; 237 sa->sin6_scope_id = (uint32_t)atoi(s+1); 238 ip = buf; 239 } 240 if(inet_pton((int)sa->sin6_family, ip, &sa->sin6_addr) <= 0) { 241 return 0; 242 } 243 } else { /* ip4 */ 244 struct sockaddr_in* sa = (struct sockaddr_in*)addr; 245 *addrlen = (socklen_t)sizeof(struct sockaddr_in); 246 memset(sa, 0, *addrlen); 247 sa->sin_family = AF_INET; 248 sa->sin_port = (in_port_t)htons(p); 249 if(inet_pton((int)sa->sin_family, ip, &sa->sin_addr) <= 0) { 250 return 0; 251 } 252 } 253 return 1; 254 } 255 256 int netblockstrtoaddr(const char* str, int port, struct sockaddr_storage* addr, 257 socklen_t* addrlen, int* net) 258 { 259 char buf[64]; 260 char* s; 261 *net = (str_is_ip6(str)?128:32); 262 if((s=strchr(str, '/'))) { 263 if(atoi(s+1) > *net) { 264 log_err("netblock too large: %s", str); 265 return 0; 266 } 267 *net = atoi(s+1); 268 if(*net == 0 && strcmp(s+1, "0") != 0) { 269 log_err("cannot parse netblock: '%s'", str); 270 return 0; 271 } 272 strlcpy(buf, str, sizeof(buf)); 273 s = strchr(buf, '/'); 274 if(s) *s = 0; 275 s = buf; 276 } 277 if(!ipstrtoaddr(s?s:str, port, addr, addrlen)) { 278 log_err("cannot parse ip address: '%s'", str); 279 return 0; 280 } 281 if(s) { 282 addr_mask(addr, *addrlen, *net); 283 } 284 return 1; 285 } 286 287 int authextstrtoaddr(char* str, struct sockaddr_storage* addr, 288 socklen_t* addrlen, char** auth_name) 289 { 290 char* s; 291 int port = UNBOUND_DNS_PORT; 292 if((s=strchr(str, '@'))) { 293 char buf[MAX_ADDR_STRLEN]; 294 size_t len = (size_t)(s-str); 295 char* hash = strchr(s+1, '#'); 296 if(hash) { 297 *auth_name = hash+1; 298 } else { 299 *auth_name = NULL; 300 } 301 if(len >= MAX_ADDR_STRLEN) { 302 return 0; 303 } 304 (void)strlcpy(buf, str, sizeof(buf)); 305 buf[len] = 0; 306 port = atoi(s+1); 307 if(port == 0) { 308 if(!hash && strcmp(s+1,"0")!=0) 309 return 0; 310 if(hash && strncmp(s+1,"0#",2)!=0) 311 return 0; 312 } 313 return ipstrtoaddr(buf, port, addr, addrlen); 314 } 315 if((s=strchr(str, '#'))) { 316 char buf[MAX_ADDR_STRLEN]; 317 size_t len = (size_t)(s-str); 318 if(len >= MAX_ADDR_STRLEN) { 319 return 0; 320 } 321 (void)strlcpy(buf, str, sizeof(buf)); 322 buf[len] = 0; 323 port = UNBOUND_DNS_OVER_TLS_PORT; 324 *auth_name = s+1; 325 return ipstrtoaddr(buf, port, addr, addrlen); 326 } 327 *auth_name = NULL; 328 return ipstrtoaddr(str, port, addr, addrlen); 329 } 330 331 /** store port number into sockaddr structure */ 332 void 333 sockaddr_store_port(struct sockaddr_storage* addr, socklen_t addrlen, int port) 334 { 335 if(addr_is_ip6(addr, addrlen)) { 336 struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 337 sa->sin6_port = (in_port_t)htons((uint16_t)port); 338 } else { 339 struct sockaddr_in* sa = (struct sockaddr_in*)addr; 340 sa->sin_port = (in_port_t)htons((uint16_t)port); 341 } 342 } 343 344 void 345 log_nametypeclass(enum verbosity_value v, const char* str, uint8_t* name, 346 uint16_t type, uint16_t dclass) 347 { 348 char buf[LDNS_MAX_DOMAINLEN+1]; 349 char t[12], c[12]; 350 const char *ts, *cs; 351 if(verbosity < v) 352 return; 353 dname_str(name, buf); 354 if(type == LDNS_RR_TYPE_TSIG) ts = "TSIG"; 355 else if(type == LDNS_RR_TYPE_IXFR) ts = "IXFR"; 356 else if(type == LDNS_RR_TYPE_AXFR) ts = "AXFR"; 357 else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; 358 else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; 359 else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; 360 else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name) 361 ts = sldns_rr_descript(type)->_name; 362 else { 363 snprintf(t, sizeof(t), "TYPE%d", (int)type); 364 ts = t; 365 } 366 if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) && 367 sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name) 368 cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name; 369 else { 370 snprintf(c, sizeof(c), "CLASS%d", (int)dclass); 371 cs = c; 372 } 373 log_info("%s %s %s %s", str, buf, ts, cs); 374 } 375 376 void 377 log_query_in(const char* str, uint8_t* name, uint16_t type, uint16_t dclass) 378 { 379 char buf[LDNS_MAX_DOMAINLEN+1]; 380 char t[12], c[12]; 381 const char *ts, *cs; 382 dname_str(name, buf); 383 if(type == LDNS_RR_TYPE_TSIG) ts = "TSIG"; 384 else if(type == LDNS_RR_TYPE_IXFR) ts = "IXFR"; 385 else if(type == LDNS_RR_TYPE_AXFR) ts = "AXFR"; 386 else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; 387 else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; 388 else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; 389 else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name) 390 ts = sldns_rr_descript(type)->_name; 391 else { 392 snprintf(t, sizeof(t), "TYPE%d", (int)type); 393 ts = t; 394 } 395 if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) && 396 sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name) 397 cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name; 398 else { 399 snprintf(c, sizeof(c), "CLASS%d", (int)dclass); 400 cs = c; 401 } 402 if(LOG_TAG_QUERYREPLY) 403 log_query("%s %s %s %s", str, buf, ts, cs); 404 else log_info("%s %s %s %s", str, buf, ts, cs); 405 } 406 407 void log_name_addr(enum verbosity_value v, const char* str, uint8_t* zone, 408 struct sockaddr_storage* addr, socklen_t addrlen) 409 { 410 uint16_t port; 411 const char* family = "unknown_family "; 412 char namebuf[LDNS_MAX_DOMAINLEN+1]; 413 char dest[100]; 414 int af = (int)((struct sockaddr_in*)addr)->sin_family; 415 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 416 if(verbosity < v) 417 return; 418 switch(af) { 419 case AF_INET: family=""; break; 420 case AF_INET6: family=""; 421 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 422 break; 423 case AF_LOCAL: family="local "; break; 424 default: break; 425 } 426 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 427 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 428 } 429 dest[sizeof(dest)-1] = 0; 430 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 431 dname_str(zone, namebuf); 432 if(af != AF_INET && af != AF_INET6) 433 verbose(v, "%s <%s> %s%s#%d (addrlen %d)", 434 str, namebuf, family, dest, (int)port, (int)addrlen); 435 else verbose(v, "%s <%s> %s%s#%d", 436 str, namebuf, family, dest, (int)port); 437 } 438 439 void log_err_addr(const char* str, const char* err, 440 struct sockaddr_storage* addr, socklen_t addrlen) 441 { 442 uint16_t port; 443 char dest[100]; 444 int af = (int)((struct sockaddr_in*)addr)->sin_family; 445 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 446 if(af == AF_INET6) 447 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 448 if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 449 (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 450 } 451 dest[sizeof(dest)-1] = 0; 452 port = ntohs(((struct sockaddr_in*)addr)->sin_port); 453 if(verbosity >= 4) 454 log_err("%s: %s for %s port %d (len %d)", str, err, dest, 455 (int)port, (int)addrlen); 456 else log_err("%s: %s for %s port %d", str, err, dest, (int)port); 457 } 458 459 int 460 sockaddr_cmp(struct sockaddr_storage* addr1, socklen_t len1, 461 struct sockaddr_storage* addr2, socklen_t len2) 462 { 463 struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 464 struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 465 struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 466 struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 467 if(len1 < len2) 468 return -1; 469 if(len1 > len2) 470 return 1; 471 log_assert(len1 == len2); 472 if( p1_in->sin_family < p2_in->sin_family) 473 return -1; 474 if( p1_in->sin_family > p2_in->sin_family) 475 return 1; 476 log_assert( p1_in->sin_family == p2_in->sin_family ); 477 /* compare ip4 */ 478 if( p1_in->sin_family == AF_INET ) { 479 /* just order it, ntohs not required */ 480 if(p1_in->sin_port < p2_in->sin_port) 481 return -1; 482 if(p1_in->sin_port > p2_in->sin_port) 483 return 1; 484 log_assert(p1_in->sin_port == p2_in->sin_port); 485 return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 486 } else if (p1_in6->sin6_family == AF_INET6) { 487 /* just order it, ntohs not required */ 488 if(p1_in6->sin6_port < p2_in6->sin6_port) 489 return -1; 490 if(p1_in6->sin6_port > p2_in6->sin6_port) 491 return 1; 492 log_assert(p1_in6->sin6_port == p2_in6->sin6_port); 493 return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 494 INET6_SIZE); 495 } else { 496 /* eek unknown type, perform this comparison for sanity. */ 497 return memcmp(addr1, addr2, len1); 498 } 499 } 500 501 int 502 sockaddr_cmp_addr(struct sockaddr_storage* addr1, socklen_t len1, 503 struct sockaddr_storage* addr2, socklen_t len2) 504 { 505 struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 506 struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 507 struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 508 struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 509 if(len1 < len2) 510 return -1; 511 if(len1 > len2) 512 return 1; 513 log_assert(len1 == len2); 514 if( p1_in->sin_family < p2_in->sin_family) 515 return -1; 516 if( p1_in->sin_family > p2_in->sin_family) 517 return 1; 518 log_assert( p1_in->sin_family == p2_in->sin_family ); 519 /* compare ip4 */ 520 if( p1_in->sin_family == AF_INET ) { 521 return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 522 } else if (p1_in6->sin6_family == AF_INET6) { 523 return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 524 INET6_SIZE); 525 } else { 526 /* eek unknown type, perform this comparison for sanity. */ 527 return memcmp(addr1, addr2, len1); 528 } 529 } 530 531 int 532 addr_is_ip6(struct sockaddr_storage* addr, socklen_t len) 533 { 534 if(len == (socklen_t)sizeof(struct sockaddr_in6) && 535 ((struct sockaddr_in6*)addr)->sin6_family == AF_INET6) 536 return 1; 537 else return 0; 538 } 539 540 void 541 addr_mask(struct sockaddr_storage* addr, socklen_t len, int net) 542 { 543 uint8_t mask[8] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe}; 544 int i, max; 545 uint8_t* s; 546 if(addr_is_ip6(addr, len)) { 547 s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 548 max = 128; 549 } else { 550 s = (uint8_t*)&((struct sockaddr_in*)addr)->sin_addr; 551 max = 32; 552 } 553 if(net >= max) 554 return; 555 for(i=net/8+1; i<max/8; i++) { 556 s[i] = 0; 557 } 558 s[net/8] &= mask[net&0x7]; 559 } 560 561 int 562 addr_in_common(struct sockaddr_storage* addr1, int net1, 563 struct sockaddr_storage* addr2, int net2, socklen_t addrlen) 564 { 565 int min = (net1<net2)?net1:net2; 566 int i, to; 567 int match = 0; 568 uint8_t* s1, *s2; 569 if(addr_is_ip6(addr1, addrlen)) { 570 s1 = (uint8_t*)&((struct sockaddr_in6*)addr1)->sin6_addr; 571 s2 = (uint8_t*)&((struct sockaddr_in6*)addr2)->sin6_addr; 572 to = 16; 573 } else { 574 s1 = (uint8_t*)&((struct sockaddr_in*)addr1)->sin_addr; 575 s2 = (uint8_t*)&((struct sockaddr_in*)addr2)->sin_addr; 576 to = 4; 577 } 578 /* match = bits_in_common(s1, s2, to); */ 579 for(i=0; i<to; i++) { 580 if(s1[i] == s2[i]) { 581 match += 8; 582 } else { 583 uint8_t z = s1[i]^s2[i]; 584 log_assert(z); 585 while(!(z&0x80)) { 586 match++; 587 z<<=1; 588 } 589 break; 590 } 591 } 592 if(match > min) match = min; 593 return match; 594 } 595 596 void 597 addr_to_str(struct sockaddr_storage* addr, socklen_t addrlen, 598 char* buf, size_t len) 599 { 600 int af = (int)((struct sockaddr_in*)addr)->sin_family; 601 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 602 if(addr_is_ip6(addr, addrlen)) 603 sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 604 if(inet_ntop(af, sinaddr, buf, (socklen_t)len) == 0) { 605 snprintf(buf, len, "(inet_ntop_error)"); 606 } 607 } 608 609 int 610 addr_is_ip4mapped(struct sockaddr_storage* addr, socklen_t addrlen) 611 { 612 /* prefix for ipv4 into ipv6 mapping is ::ffff:x.x.x.x */ 613 const uint8_t map_prefix[16] = 614 {0,0,0,0, 0,0,0,0, 0,0,0xff,0xff, 0,0,0,0}; 615 uint8_t* s; 616 if(!addr_is_ip6(addr, addrlen)) 617 return 0; 618 /* s is 16 octet ipv6 address string */ 619 s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 620 return (memcmp(s, map_prefix, 12) == 0); 621 } 622 623 int addr_is_broadcast(struct sockaddr_storage* addr, socklen_t addrlen) 624 { 625 int af = (int)((struct sockaddr_in*)addr)->sin_family; 626 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 627 return af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 628 && memcmp(sinaddr, "\377\377\377\377", 4) == 0; 629 } 630 631 int addr_is_any(struct sockaddr_storage* addr, socklen_t addrlen) 632 { 633 int af = (int)((struct sockaddr_in*)addr)->sin_family; 634 void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 635 void* sin6addr = &((struct sockaddr_in6*)addr)->sin6_addr; 636 if(af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 637 && memcmp(sinaddr, "\000\000\000\000", 4) == 0) 638 return 1; 639 else if(af==AF_INET6 && addrlen>=(socklen_t)sizeof(struct sockaddr_in6) 640 && memcmp(sin6addr, "\000\000\000\000\000\000\000\000" 641 "\000\000\000\000\000\000\000\000", 16) == 0) 642 return 1; 643 return 0; 644 } 645 646 void sock_list_insert(struct sock_list** list, struct sockaddr_storage* addr, 647 socklen_t len, struct regional* region) 648 { 649 struct sock_list* add = (struct sock_list*)regional_alloc(region, 650 sizeof(*add) - sizeof(add->addr) + (size_t)len); 651 if(!add) { 652 log_err("out of memory in socketlist insert"); 653 return; 654 } 655 log_assert(list); 656 add->next = *list; 657 add->len = len; 658 *list = add; 659 if(len) memmove(&add->addr, addr, len); 660 } 661 662 void sock_list_prepend(struct sock_list** list, struct sock_list* add) 663 { 664 struct sock_list* last = add; 665 if(!last) 666 return; 667 while(last->next) 668 last = last->next; 669 last->next = *list; 670 *list = add; 671 } 672 673 int sock_list_find(struct sock_list* list, struct sockaddr_storage* addr, 674 socklen_t len) 675 { 676 while(list) { 677 if(len == list->len) { 678 if(len == 0 || sockaddr_cmp_addr(addr, len, 679 &list->addr, list->len) == 0) 680 return 1; 681 } 682 list = list->next; 683 } 684 return 0; 685 } 686 687 void sock_list_merge(struct sock_list** list, struct regional* region, 688 struct sock_list* add) 689 { 690 struct sock_list* p; 691 for(p=add; p; p=p->next) { 692 if(!sock_list_find(*list, &p->addr, p->len)) 693 sock_list_insert(list, &p->addr, p->len, region); 694 } 695 } 696 697 void 698 log_crypto_err(const char* str) 699 { 700 #ifdef HAVE_SSL 701 /* error:[error code]:[library name]:[function name]:[reason string] */ 702 char buf[128]; 703 unsigned long e; 704 ERR_error_string_n(ERR_get_error(), buf, sizeof(buf)); 705 log_err("%s crypto %s", str, buf); 706 while( (e=ERR_get_error()) ) { 707 ERR_error_string_n(e, buf, sizeof(buf)); 708 log_err("and additionally crypto %s", buf); 709 } 710 #else 711 (void)str; 712 #endif /* HAVE_SSL */ 713 } 714 715 int 716 listen_sslctx_setup(void* ctxt) 717 { 718 #ifdef HAVE_SSL 719 SSL_CTX* ctx = (SSL_CTX*)ctxt; 720 /* no SSLv2, SSLv3 because has defects */ 721 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 722 != SSL_OP_NO_SSLv2){ 723 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 724 return 0; 725 } 726 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 727 != SSL_OP_NO_SSLv3){ 728 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 729 return 0; 730 } 731 #if defined(SSL_OP_NO_TLSv1) && defined(SSL_OP_NO_TLSv1_1) 732 /* if we have tls 1.1 disable 1.0 */ 733 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1) & SSL_OP_NO_TLSv1) 734 != SSL_OP_NO_TLSv1){ 735 log_crypto_err("could not set SSL_OP_NO_TLSv1"); 736 return 0; 737 } 738 #endif 739 #if defined(SSL_OP_NO_TLSv1_1) && defined(SSL_OP_NO_TLSv1_2) 740 /* if we have tls 1.2 disable 1.1 */ 741 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1_1) & SSL_OP_NO_TLSv1_1) 742 != SSL_OP_NO_TLSv1_1){ 743 log_crypto_err("could not set SSL_OP_NO_TLSv1_1"); 744 return 0; 745 } 746 #endif 747 #if defined(SHA256_DIGEST_LENGTH) && defined(USE_ECDSA) 748 /* if we have sha256, set the cipher list to have no known vulns */ 749 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")) 750 log_crypto_err("could not set cipher list with SSL_CTX_set_cipher_list"); 751 #endif 752 753 if((SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE) & 754 SSL_OP_CIPHER_SERVER_PREFERENCE) != 755 SSL_OP_CIPHER_SERVER_PREFERENCE) { 756 log_crypto_err("could not set SSL_OP_CIPHER_SERVER_PREFERENCE"); 757 return 0; 758 } 759 760 #ifdef HAVE_SSL_CTX_SET_SECURITY_LEVEL 761 SSL_CTX_set_security_level(ctx, 0); 762 #endif 763 #else 764 (void)ctxt; 765 #endif /* HAVE_SSL */ 766 return 1; 767 } 768 769 void 770 listen_sslctx_setup_2(void* ctxt) 771 { 772 #ifdef HAVE_SSL 773 SSL_CTX* ctx = (SSL_CTX*)ctxt; 774 (void)ctx; 775 #if HAVE_DECL_SSL_CTX_SET_ECDH_AUTO 776 if(!SSL_CTX_set_ecdh_auto(ctx,1)) { 777 log_crypto_err("Error in SSL_CTX_ecdh_auto, not enabling ECDHE"); 778 } 779 #elif defined(USE_ECDSA) 780 if(1) { 781 EC_KEY *ecdh = EC_KEY_new_by_curve_name (NID_X9_62_prime256v1); 782 if (!ecdh) { 783 log_crypto_err("could not find p256, not enabling ECDHE"); 784 } else { 785 if (1 != SSL_CTX_set_tmp_ecdh (ctx, ecdh)) { 786 log_crypto_err("Error in SSL_CTX_set_tmp_ecdh, not enabling ECDHE"); 787 } 788 EC_KEY_free (ecdh); 789 } 790 } 791 #endif 792 #else 793 (void)ctxt; 794 #endif /* HAVE_SSL */ 795 } 796 797 void* listen_sslctx_create(char* key, char* pem, char* verifypem) 798 { 799 #ifdef HAVE_SSL 800 SSL_CTX* ctx = SSL_CTX_new(SSLv23_server_method()); 801 if(!ctx) { 802 log_crypto_err("could not SSL_CTX_new"); 803 return NULL; 804 } 805 if(!listen_sslctx_setup(ctx)) { 806 SSL_CTX_free(ctx); 807 return NULL; 808 } 809 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 810 log_err("error for cert file: %s", pem); 811 log_crypto_err("error in SSL_CTX use_certificate_chain_file"); 812 SSL_CTX_free(ctx); 813 return NULL; 814 } 815 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 816 log_err("error for private key file: %s", key); 817 log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 818 SSL_CTX_free(ctx); 819 return NULL; 820 } 821 if(!SSL_CTX_check_private_key(ctx)) { 822 log_err("error for key file: %s", key); 823 log_crypto_err("Error in SSL_CTX check_private_key"); 824 SSL_CTX_free(ctx); 825 return NULL; 826 } 827 listen_sslctx_setup_2(ctx); 828 if(verifypem && verifypem[0]) { 829 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 830 log_crypto_err("Error in SSL_CTX verify locations"); 831 SSL_CTX_free(ctx); 832 return NULL; 833 } 834 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file( 835 verifypem)); 836 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 837 } 838 return ctx; 839 #else 840 (void)key; (void)pem; (void)verifypem; 841 return NULL; 842 #endif 843 } 844 845 #ifdef USE_WINSOCK 846 /* For windows, the CA trust store is not read by openssl. 847 Add code to open the trust store using wincrypt API and add 848 the root certs into openssl trust store */ 849 static int 850 add_WIN_cacerts_to_openssl_store(SSL_CTX* tls_ctx) 851 { 852 HCERTSTORE hSystemStore; 853 PCCERT_CONTEXT pTargetCert = NULL; 854 X509_STORE* store; 855 856 verbose(VERB_ALGO, "Adding Windows certificates from system root store to CA store"); 857 858 /* load just once per context lifetime for this version 859 TODO: dynamically update CA trust changes as they are available */ 860 if (!tls_ctx) 861 return 0; 862 863 /* Call wincrypt's CertOpenStore to open the CA root store. */ 864 865 if ((hSystemStore = CertOpenStore( 866 CERT_STORE_PROV_SYSTEM, 867 0, 868 0, 869 /* NOTE: mingw does not have this const: replace with 1 << 16 from code 870 CERT_SYSTEM_STORE_CURRENT_USER, */ 871 1 << 16, 872 L"root")) == 0) 873 { 874 return 0; 875 } 876 877 store = SSL_CTX_get_cert_store(tls_ctx); 878 if (!store) 879 return 0; 880 881 /* failure if the CA store is empty or the call fails */ 882 if ((pTargetCert = CertEnumCertificatesInStore( 883 hSystemStore, pTargetCert)) == 0) { 884 verbose(VERB_ALGO, "CA certificate store for Windows is empty."); 885 return 0; 886 } 887 /* iterate over the windows cert store and add to openssl store */ 888 do 889 { 890 X509 *cert1 = d2i_X509(NULL, 891 (const unsigned char **)&pTargetCert->pbCertEncoded, 892 pTargetCert->cbCertEncoded); 893 if (!cert1) { 894 /* return error if a cert fails */ 895 verbose(VERB_ALGO, "%s %d:%s", 896 "Unable to parse certificate in memory", 897 (int)ERR_get_error(), ERR_error_string(ERR_get_error(), NULL)); 898 return 0; 899 } 900 else { 901 /* return error if a cert add to store fails */ 902 if (X509_STORE_add_cert(store, cert1) == 0) { 903 unsigned long error = ERR_peek_last_error(); 904 905 /* Ignore error X509_R_CERT_ALREADY_IN_HASH_TABLE which means the 906 * certificate is already in the store. */ 907 if(ERR_GET_LIB(error) != ERR_LIB_X509 || 908 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) { 909 verbose(VERB_ALGO, "%s %d:%s\n", 910 "Error adding certificate", (int)ERR_get_error(), 911 ERR_error_string(ERR_get_error(), NULL)); 912 X509_free(cert1); 913 return 0; 914 } 915 } 916 X509_free(cert1); 917 } 918 } while ((pTargetCert = CertEnumCertificatesInStore( 919 hSystemStore, pTargetCert)) != 0); 920 921 /* Clean up memory and quit. */ 922 if (pTargetCert) 923 CertFreeCertificateContext(pTargetCert); 924 if (hSystemStore) 925 { 926 if (!CertCloseStore( 927 hSystemStore, 0)) 928 return 0; 929 } 930 verbose(VERB_ALGO, "Completed adding Windows certificates to CA store successfully"); 931 return 1; 932 } 933 #endif /* USE_WINSOCK */ 934 935 void* connect_sslctx_create(char* key, char* pem, char* verifypem, int wincert) 936 { 937 #ifdef HAVE_SSL 938 SSL_CTX* ctx = SSL_CTX_new(SSLv23_client_method()); 939 if(!ctx) { 940 log_crypto_err("could not allocate SSL_CTX pointer"); 941 return NULL; 942 } 943 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 944 != SSL_OP_NO_SSLv2) { 945 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 946 SSL_CTX_free(ctx); 947 return NULL; 948 } 949 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 950 != SSL_OP_NO_SSLv3) { 951 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 952 SSL_CTX_free(ctx); 953 return NULL; 954 } 955 if(key && key[0]) { 956 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 957 log_err("error in client certificate %s", pem); 958 log_crypto_err("error in certificate file"); 959 SSL_CTX_free(ctx); 960 return NULL; 961 } 962 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 963 log_err("error in client private key %s", key); 964 log_crypto_err("error in key file"); 965 SSL_CTX_free(ctx); 966 return NULL; 967 } 968 if(!SSL_CTX_check_private_key(ctx)) { 969 log_err("error in client key %s", key); 970 log_crypto_err("error in SSL_CTX_check_private_key"); 971 SSL_CTX_free(ctx); 972 return NULL; 973 } 974 } 975 if((verifypem && verifypem[0]) || wincert) { 976 if(verifypem && verifypem[0]) { 977 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 978 log_crypto_err("error in SSL_CTX verify"); 979 SSL_CTX_free(ctx); 980 return NULL; 981 } 982 } 983 #ifdef USE_WINSOCK 984 if(wincert) { 985 if(!add_WIN_cacerts_to_openssl_store(ctx)) { 986 log_crypto_err("error in add_WIN_cacerts_to_openssl_store"); 987 SSL_CTX_free(ctx); 988 return NULL; 989 } 990 } 991 #else 992 (void)wincert; 993 #endif 994 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 995 } 996 return ctx; 997 #else 998 (void)key; (void)pem; (void)verifypem; (void)wincert; 999 return NULL; 1000 #endif 1001 } 1002 1003 void* incoming_ssl_fd(void* sslctx, int fd) 1004 { 1005 #ifdef HAVE_SSL 1006 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1007 if(!ssl) { 1008 log_crypto_err("could not SSL_new"); 1009 return NULL; 1010 } 1011 SSL_set_accept_state(ssl); 1012 (void)SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY); 1013 if(!SSL_set_fd(ssl, fd)) { 1014 log_crypto_err("could not SSL_set_fd"); 1015 SSL_free(ssl); 1016 return NULL; 1017 } 1018 return ssl; 1019 #else 1020 (void)sslctx; (void)fd; 1021 return NULL; 1022 #endif 1023 } 1024 1025 void* outgoing_ssl_fd(void* sslctx, int fd) 1026 { 1027 #ifdef HAVE_SSL 1028 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1029 if(!ssl) { 1030 log_crypto_err("could not SSL_new"); 1031 return NULL; 1032 } 1033 SSL_set_connect_state(ssl); 1034 (void)SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY); 1035 if(!SSL_set_fd(ssl, fd)) { 1036 log_crypto_err("could not SSL_set_fd"); 1037 SSL_free(ssl); 1038 return NULL; 1039 } 1040 return ssl; 1041 #else 1042 (void)sslctx; (void)fd; 1043 return NULL; 1044 #endif 1045 } 1046 1047 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1048 /** global lock list for openssl locks */ 1049 static lock_basic_type *ub_openssl_locks = NULL; 1050 1051 /** callback that gets thread id for openssl */ 1052 #ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1053 static void 1054 ub_crypto_id_cb(CRYPTO_THREADID *id) 1055 { 1056 CRYPTO_THREADID_set_numeric(id, (unsigned long)log_thread_get()); 1057 } 1058 #else 1059 static unsigned long 1060 ub_crypto_id_cb(void) 1061 { 1062 return (unsigned long)log_thread_get(); 1063 } 1064 #endif 1065 1066 static void 1067 ub_crypto_lock_cb(int mode, int type, const char *ATTR_UNUSED(file), 1068 int ATTR_UNUSED(line)) 1069 { 1070 if((mode&CRYPTO_LOCK)) { 1071 lock_basic_lock(&ub_openssl_locks[type]); 1072 } else { 1073 lock_basic_unlock(&ub_openssl_locks[type]); 1074 } 1075 } 1076 #endif /* OPENSSL_THREADS */ 1077 1078 int ub_openssl_lock_init(void) 1079 { 1080 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1081 int i; 1082 ub_openssl_locks = (lock_basic_type*)reallocarray( 1083 NULL, (size_t)CRYPTO_num_locks(), sizeof(lock_basic_type)); 1084 if(!ub_openssl_locks) 1085 return 0; 1086 for(i=0; i<CRYPTO_num_locks(); i++) { 1087 lock_basic_init(&ub_openssl_locks[i]); 1088 } 1089 # ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1090 CRYPTO_THREADID_set_callback(&ub_crypto_id_cb); 1091 # else 1092 CRYPTO_set_id_callback(&ub_crypto_id_cb); 1093 # endif 1094 CRYPTO_set_locking_callback(&ub_crypto_lock_cb); 1095 #endif /* OPENSSL_THREADS */ 1096 return 1; 1097 } 1098 1099 void ub_openssl_lock_delete(void) 1100 { 1101 #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1102 int i; 1103 if(!ub_openssl_locks) 1104 return; 1105 # ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1106 CRYPTO_THREADID_set_callback(NULL); 1107 # else 1108 CRYPTO_set_id_callback(NULL); 1109 # endif 1110 CRYPTO_set_locking_callback(NULL); 1111 for(i=0; i<CRYPTO_num_locks(); i++) { 1112 lock_basic_destroy(&ub_openssl_locks[i]); 1113 } 1114 free(ub_openssl_locks); 1115 #endif /* OPENSSL_THREADS */ 1116 } 1117 1118 int listen_sslctx_setup_ticket_keys(void* sslctx, struct config_strlist* tls_session_ticket_keys) { 1119 #ifdef HAVE_SSL 1120 size_t s = 1; 1121 struct config_strlist* p; 1122 struct tls_session_ticket_key *keys; 1123 for(p = tls_session_ticket_keys; p; p = p->next) { 1124 s++; 1125 } 1126 keys = calloc(s, sizeof(struct tls_session_ticket_key)); 1127 memset(keys, 0, s*sizeof(*keys)); 1128 ticket_keys = keys; 1129 1130 for(p = tls_session_ticket_keys; p; p = p->next) { 1131 size_t n; 1132 unsigned char *data = (unsigned char *)malloc(80); 1133 FILE *f = fopen(p->str, "r"); 1134 if(!f) { 1135 log_err("could not read tls-session-ticket-key %s: %s", p->str, strerror(errno)); 1136 free(data); 1137 return 0; 1138 } 1139 n = fread(data, 1, 80, f); 1140 fclose(f); 1141 1142 if(n != 80) { 1143 log_err("tls-session-ticket-key %s is %d bytes, must be 80 bytes", p->str, (int)n); 1144 free(data); 1145 return 0; 1146 } 1147 verbose(VERB_OPS, "read tls-session-ticket-key: %s", p->str); 1148 1149 keys->key_name = data; 1150 keys->aes_key = data + 16; 1151 keys->hmac_key = data + 48; 1152 keys++; 1153 } 1154 /* terminate array with NULL key name entry */ 1155 keys->key_name = NULL; 1156 if(SSL_CTX_set_tlsext_ticket_key_cb(sslctx, tls_session_ticket_key_cb) == 0) { 1157 log_err("no support for TLS session ticket"); 1158 return 0; 1159 } 1160 return 1; 1161 #else 1162 (void)sslctx; 1163 (void)tls_session_ticket_keys; 1164 return 0; 1165 #endif 1166 1167 } 1168 1169 int tls_session_ticket_key_cb(void *ATTR_UNUSED(sslctx), unsigned char* key_name, unsigned char* iv, void *evp_sctx, void *hmac_ctx, int enc) 1170 { 1171 #ifdef HAVE_SSL 1172 const EVP_MD *digest; 1173 const EVP_CIPHER *cipher; 1174 int evp_cipher_length; 1175 digest = EVP_sha256(); 1176 cipher = EVP_aes_256_cbc(); 1177 evp_cipher_length = EVP_CIPHER_iv_length(cipher); 1178 if( enc == 1 ) { 1179 /* encrypt */ 1180 verbose(VERB_CLIENT, "start session encrypt"); 1181 memcpy(key_name, ticket_keys->key_name, 16); 1182 if (RAND_bytes(iv, evp_cipher_length) != 1) { 1183 verbose(VERB_CLIENT, "RAND_bytes failed"); 1184 return -1; 1185 } 1186 if (EVP_EncryptInit_ex(evp_sctx, cipher, NULL, ticket_keys->aes_key, iv) != 1) { 1187 verbose(VERB_CLIENT, "EVP_EncryptInit_ex failed"); 1188 return -1; 1189 } 1190 if (HMAC_Init_ex(hmac_ctx, ticket_keys->hmac_key, 32, digest, NULL) != 1) { 1191 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1192 return -1; 1193 } 1194 return 1; 1195 } else if (enc == 0) { 1196 /* decrypt */ 1197 struct tls_session_ticket_key *key; 1198 verbose(VERB_CLIENT, "start session decrypt"); 1199 for(key = ticket_keys; key->key_name != NULL; key++) { 1200 if (!memcmp(key_name, key->key_name, 16)) { 1201 verbose(VERB_CLIENT, "Found session_key"); 1202 break; 1203 } 1204 } 1205 if(key->key_name == NULL) { 1206 verbose(VERB_CLIENT, "Not found session_key"); 1207 return 0; 1208 } 1209 1210 if (HMAC_Init_ex(hmac_ctx, key->hmac_key, 32, digest, NULL) != 1) { 1211 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1212 return -1; 1213 } 1214 if (EVP_DecryptInit_ex(evp_sctx, cipher, NULL, key->aes_key, iv) != 1) { 1215 log_err("EVP_DecryptInit_ex failed"); 1216 return -1; 1217 } 1218 1219 return (key == ticket_keys) ? 1 : 2; 1220 } 1221 return -1; 1222 #else 1223 (void)key_name; 1224 (void)iv; 1225 (void)evp_sctx; 1226 (void)hmac_ctx; 1227 (void)enc; 1228 return 0; 1229 #endif 1230 } 1231 1232 void 1233 listen_sslctx_delete_ticket_keys(void) 1234 { 1235 struct tls_session_ticket_key *key; 1236 if(!ticket_keys) return; 1237 for(key = ticket_keys; key->key_name != NULL; key++) { 1238 memset(key->key_name, 0xdd, 80); /* wipe key data from memory*/ 1239 free(key->key_name); 1240 } 1241 free(ticket_keys); 1242 ticket_keys = NULL; 1243 } 1244