net_help.c revision 356345
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 */ 65uint16_t EDNS_ADVERTISED_SIZE = 4096; 66 67/** minimal responses when positive answer: default is no */ 68int MINIMAL_RESPONSES = 0; 69 70/** rrset order roundrobin: default is no */ 71int RRSET_ROUNDROBIN = 0; 72 73/** log tag queries with name instead of 'info' for filtering */ 74int LOG_TAG_QUERYREPLY = 0; 75 76static 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 */ 83int 84str_is_ip6(const char* str) 85{ 86 if(strchr(str, ':')) 87 return 1; 88 else return 0; 89} 90 91int 92fd_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 115int 116fd_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 140int 141is_pow2(size_t num) 142{ 143 if(num == 0) return 1; 144 return (num & (num-1)) == 0; 145} 146 147void* 148memdup(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 159void 160log_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 194int 195extstrtoaddr(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 217int 218ipstrtoaddr(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 256int 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 287int 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 */ 332void 333sockaddr_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 344void 345log_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 376void 377log_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 407void 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 439void 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 459int 460sockaddr_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 501int 502sockaddr_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 531int 532addr_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 540void 541addr_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 561int 562addr_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 596void 597addr_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 609int 610addr_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 623int 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 631int 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 646void 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 662void 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 673int 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 687void 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 697void 698log_crypto_err(const char* str) 699{ 700#ifdef HAVE_SSL 701 log_crypto_err_code(str, ERR_get_error()); 702#else 703 (void)str; 704#endif /* HAVE_SSL */ 705} 706 707void log_crypto_err_code(const char* str, unsigned long err) 708{ 709#ifdef HAVE_SSL 710 /* error:[error code]:[library name]:[function name]:[reason string] */ 711 char buf[128]; 712 unsigned long e; 713 ERR_error_string_n(err, buf, sizeof(buf)); 714 log_err("%s crypto %s", str, buf); 715 while( (e=ERR_get_error()) ) { 716 ERR_error_string_n(e, buf, sizeof(buf)); 717 log_err("and additionally crypto %s", buf); 718 } 719#else 720 (void)str; 721 (void)err; 722#endif /* HAVE_SSL */ 723} 724 725int 726listen_sslctx_setup(void* ctxt) 727{ 728#ifdef HAVE_SSL 729 SSL_CTX* ctx = (SSL_CTX*)ctxt; 730 /* no SSLv2, SSLv3 because has defects */ 731 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 732 != SSL_OP_NO_SSLv2){ 733 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 734 return 0; 735 } 736 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 737 != SSL_OP_NO_SSLv3){ 738 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 739 return 0; 740 } 741#if defined(SSL_OP_NO_TLSv1) && defined(SSL_OP_NO_TLSv1_1) 742 /* if we have tls 1.1 disable 1.0 */ 743 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1) & SSL_OP_NO_TLSv1) 744 != SSL_OP_NO_TLSv1){ 745 log_crypto_err("could not set SSL_OP_NO_TLSv1"); 746 return 0; 747 } 748#endif 749#if defined(SSL_OP_NO_TLSv1_1) && defined(SSL_OP_NO_TLSv1_2) 750 /* if we have tls 1.2 disable 1.1 */ 751 if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1_1) & SSL_OP_NO_TLSv1_1) 752 != SSL_OP_NO_TLSv1_1){ 753 log_crypto_err("could not set SSL_OP_NO_TLSv1_1"); 754 return 0; 755 } 756#endif 757#if defined(SSL_OP_NO_RENEGOTIATION) 758 /* disable client renegotiation */ 759 if((SSL_CTX_set_options(ctx, SSL_OP_NO_RENEGOTIATION) & 760 SSL_OP_NO_RENEGOTIATION) != SSL_OP_NO_RENEGOTIATION) { 761 log_crypto_err("could not set SSL_OP_NO_RENEGOTIATION"); 762 return 0; 763 } 764#endif 765#if defined(SHA256_DIGEST_LENGTH) && defined(USE_ECDSA) 766 /* if we have sha256, set the cipher list to have no known vulns */ 767 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")) 768 log_crypto_err("could not set cipher list with SSL_CTX_set_cipher_list"); 769#endif 770 771 if((SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE) & 772 SSL_OP_CIPHER_SERVER_PREFERENCE) != 773 SSL_OP_CIPHER_SERVER_PREFERENCE) { 774 log_crypto_err("could not set SSL_OP_CIPHER_SERVER_PREFERENCE"); 775 return 0; 776 } 777 778#ifdef HAVE_SSL_CTX_SET_SECURITY_LEVEL 779 SSL_CTX_set_security_level(ctx, 0); 780#endif 781#else 782 (void)ctxt; 783#endif /* HAVE_SSL */ 784 return 1; 785} 786 787void 788listen_sslctx_setup_2(void* ctxt) 789{ 790#ifdef HAVE_SSL 791 SSL_CTX* ctx = (SSL_CTX*)ctxt; 792 (void)ctx; 793#if HAVE_DECL_SSL_CTX_SET_ECDH_AUTO 794 if(!SSL_CTX_set_ecdh_auto(ctx,1)) { 795 log_crypto_err("Error in SSL_CTX_ecdh_auto, not enabling ECDHE"); 796 } 797#elif defined(USE_ECDSA) 798 if(1) { 799 EC_KEY *ecdh = EC_KEY_new_by_curve_name (NID_X9_62_prime256v1); 800 if (!ecdh) { 801 log_crypto_err("could not find p256, not enabling ECDHE"); 802 } else { 803 if (1 != SSL_CTX_set_tmp_ecdh (ctx, ecdh)) { 804 log_crypto_err("Error in SSL_CTX_set_tmp_ecdh, not enabling ECDHE"); 805 } 806 EC_KEY_free (ecdh); 807 } 808 } 809#endif 810#else 811 (void)ctxt; 812#endif /* HAVE_SSL */ 813} 814 815void* listen_sslctx_create(char* key, char* pem, char* verifypem) 816{ 817#ifdef HAVE_SSL 818 SSL_CTX* ctx = SSL_CTX_new(SSLv23_server_method()); 819 if(!ctx) { 820 log_crypto_err("could not SSL_CTX_new"); 821 return NULL; 822 } 823 if(!key || key[0] == 0) { 824 log_err("error: no tls-service-key file specified"); 825 SSL_CTX_free(ctx); 826 return NULL; 827 } 828 if(!pem || pem[0] == 0) { 829 log_err("error: no tls-service-pem file specified"); 830 SSL_CTX_free(ctx); 831 return NULL; 832 } 833 if(!listen_sslctx_setup(ctx)) { 834 SSL_CTX_free(ctx); 835 return NULL; 836 } 837 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 838 log_err("error for cert file: %s", pem); 839 log_crypto_err("error in SSL_CTX use_certificate_chain_file"); 840 SSL_CTX_free(ctx); 841 return NULL; 842 } 843 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 844 log_err("error for private key file: %s", key); 845 log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 846 SSL_CTX_free(ctx); 847 return NULL; 848 } 849 if(!SSL_CTX_check_private_key(ctx)) { 850 log_err("error for key file: %s", key); 851 log_crypto_err("Error in SSL_CTX check_private_key"); 852 SSL_CTX_free(ctx); 853 return NULL; 854 } 855 listen_sslctx_setup_2(ctx); 856 if(verifypem && verifypem[0]) { 857 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 858 log_crypto_err("Error in SSL_CTX verify locations"); 859 SSL_CTX_free(ctx); 860 return NULL; 861 } 862 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file( 863 verifypem)); 864 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 865 } 866 return ctx; 867#else 868 (void)key; (void)pem; (void)verifypem; 869 return NULL; 870#endif 871} 872 873#ifdef USE_WINSOCK 874/* For windows, the CA trust store is not read by openssl. 875 Add code to open the trust store using wincrypt API and add 876 the root certs into openssl trust store */ 877static int 878add_WIN_cacerts_to_openssl_store(SSL_CTX* tls_ctx) 879{ 880 HCERTSTORE hSystemStore; 881 PCCERT_CONTEXT pTargetCert = NULL; 882 X509_STORE* store; 883 884 verbose(VERB_ALGO, "Adding Windows certificates from system root store to CA store"); 885 886 /* load just once per context lifetime for this version 887 TODO: dynamically update CA trust changes as they are available */ 888 if (!tls_ctx) 889 return 0; 890 891 /* Call wincrypt's CertOpenStore to open the CA root store. */ 892 893 if ((hSystemStore = CertOpenStore( 894 CERT_STORE_PROV_SYSTEM, 895 0, 896 0, 897 /* NOTE: mingw does not have this const: replace with 1 << 16 from code 898 CERT_SYSTEM_STORE_CURRENT_USER, */ 899 1 << 16, 900 L"root")) == 0) 901 { 902 return 0; 903 } 904 905 store = SSL_CTX_get_cert_store(tls_ctx); 906 if (!store) 907 return 0; 908 909 /* failure if the CA store is empty or the call fails */ 910 if ((pTargetCert = CertEnumCertificatesInStore( 911 hSystemStore, pTargetCert)) == 0) { 912 verbose(VERB_ALGO, "CA certificate store for Windows is empty."); 913 return 0; 914 } 915 /* iterate over the windows cert store and add to openssl store */ 916 do 917 { 918 X509 *cert1 = d2i_X509(NULL, 919 (const unsigned char **)&pTargetCert->pbCertEncoded, 920 pTargetCert->cbCertEncoded); 921 if (!cert1) { 922 /* return error if a cert fails */ 923 verbose(VERB_ALGO, "%s %d:%s", 924 "Unable to parse certificate in memory", 925 (int)ERR_get_error(), ERR_error_string(ERR_get_error(), NULL)); 926 return 0; 927 } 928 else { 929 /* return error if a cert add to store fails */ 930 if (X509_STORE_add_cert(store, cert1) == 0) { 931 unsigned long error = ERR_peek_last_error(); 932 933 /* Ignore error X509_R_CERT_ALREADY_IN_HASH_TABLE which means the 934 * certificate is already in the store. */ 935 if(ERR_GET_LIB(error) != ERR_LIB_X509 || 936 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE) { 937 verbose(VERB_ALGO, "%s %d:%s\n", 938 "Error adding certificate", (int)ERR_get_error(), 939 ERR_error_string(ERR_get_error(), NULL)); 940 X509_free(cert1); 941 return 0; 942 } 943 } 944 X509_free(cert1); 945 } 946 } while ((pTargetCert = CertEnumCertificatesInStore( 947 hSystemStore, pTargetCert)) != 0); 948 949 /* Clean up memory and quit. */ 950 if (pTargetCert) 951 CertFreeCertificateContext(pTargetCert); 952 if (hSystemStore) 953 { 954 if (!CertCloseStore( 955 hSystemStore, 0)) 956 return 0; 957 } 958 verbose(VERB_ALGO, "Completed adding Windows certificates to CA store successfully"); 959 return 1; 960} 961#endif /* USE_WINSOCK */ 962 963void* connect_sslctx_create(char* key, char* pem, char* verifypem, int wincert) 964{ 965#ifdef HAVE_SSL 966 SSL_CTX* ctx = SSL_CTX_new(SSLv23_client_method()); 967 if(!ctx) { 968 log_crypto_err("could not allocate SSL_CTX pointer"); 969 return NULL; 970 } 971 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 972 != SSL_OP_NO_SSLv2) { 973 log_crypto_err("could not set SSL_OP_NO_SSLv2"); 974 SSL_CTX_free(ctx); 975 return NULL; 976 } 977 if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 978 != SSL_OP_NO_SSLv3) { 979 log_crypto_err("could not set SSL_OP_NO_SSLv3"); 980 SSL_CTX_free(ctx); 981 return NULL; 982 } 983#if defined(SSL_OP_NO_RENEGOTIATION) 984 /* disable client renegotiation */ 985 if((SSL_CTX_set_options(ctx, SSL_OP_NO_RENEGOTIATION) & 986 SSL_OP_NO_RENEGOTIATION) != SSL_OP_NO_RENEGOTIATION) { 987 log_crypto_err("could not set SSL_OP_NO_RENEGOTIATION"); 988 return 0; 989 } 990#endif 991 if(key && key[0]) { 992 if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 993 log_err("error in client certificate %s", pem); 994 log_crypto_err("error in certificate file"); 995 SSL_CTX_free(ctx); 996 return NULL; 997 } 998 if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 999 log_err("error in client private key %s", key); 1000 log_crypto_err("error in key file"); 1001 SSL_CTX_free(ctx); 1002 return NULL; 1003 } 1004 if(!SSL_CTX_check_private_key(ctx)) { 1005 log_err("error in client key %s", key); 1006 log_crypto_err("error in SSL_CTX_check_private_key"); 1007 SSL_CTX_free(ctx); 1008 return NULL; 1009 } 1010 } 1011 if((verifypem && verifypem[0]) || wincert) { 1012 if(verifypem && verifypem[0]) { 1013 if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 1014 log_crypto_err("error in SSL_CTX verify"); 1015 SSL_CTX_free(ctx); 1016 return NULL; 1017 } 1018 } 1019#ifdef USE_WINSOCK 1020 if(wincert) { 1021 if(!add_WIN_cacerts_to_openssl_store(ctx)) { 1022 log_crypto_err("error in add_WIN_cacerts_to_openssl_store"); 1023 SSL_CTX_free(ctx); 1024 return NULL; 1025 } 1026 } 1027#else 1028 (void)wincert; 1029#endif 1030 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 1031 } 1032 return ctx; 1033#else 1034 (void)key; (void)pem; (void)verifypem; (void)wincert; 1035 return NULL; 1036#endif 1037} 1038 1039void* incoming_ssl_fd(void* sslctx, int fd) 1040{ 1041#ifdef HAVE_SSL 1042 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1043 if(!ssl) { 1044 log_crypto_err("could not SSL_new"); 1045 return NULL; 1046 } 1047 SSL_set_accept_state(ssl); 1048 (void)SSL_set_mode(ssl, (long)SSL_MODE_AUTO_RETRY); 1049 if(!SSL_set_fd(ssl, fd)) { 1050 log_crypto_err("could not SSL_set_fd"); 1051 SSL_free(ssl); 1052 return NULL; 1053 } 1054 return ssl; 1055#else 1056 (void)sslctx; (void)fd; 1057 return NULL; 1058#endif 1059} 1060 1061void* outgoing_ssl_fd(void* sslctx, int fd) 1062{ 1063#ifdef HAVE_SSL 1064 SSL* ssl = SSL_new((SSL_CTX*)sslctx); 1065 if(!ssl) { 1066 log_crypto_err("could not SSL_new"); 1067 return NULL; 1068 } 1069 SSL_set_connect_state(ssl); 1070 (void)SSL_set_mode(ssl, (long)SSL_MODE_AUTO_RETRY); 1071 if(!SSL_set_fd(ssl, fd)) { 1072 log_crypto_err("could not SSL_set_fd"); 1073 SSL_free(ssl); 1074 return NULL; 1075 } 1076 return ssl; 1077#else 1078 (void)sslctx; (void)fd; 1079 return NULL; 1080#endif 1081} 1082 1083#if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1084/** global lock list for openssl locks */ 1085static lock_basic_type *ub_openssl_locks = NULL; 1086 1087/** callback that gets thread id for openssl */ 1088#ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1089static void 1090ub_crypto_id_cb(CRYPTO_THREADID *id) 1091{ 1092 CRYPTO_THREADID_set_numeric(id, (unsigned long)log_thread_get()); 1093} 1094#else 1095static unsigned long 1096ub_crypto_id_cb(void) 1097{ 1098 return (unsigned long)log_thread_get(); 1099} 1100#endif 1101 1102static void 1103ub_crypto_lock_cb(int mode, int type, const char *ATTR_UNUSED(file), 1104 int ATTR_UNUSED(line)) 1105{ 1106 if((mode&CRYPTO_LOCK)) { 1107 lock_basic_lock(&ub_openssl_locks[type]); 1108 } else { 1109 lock_basic_unlock(&ub_openssl_locks[type]); 1110 } 1111} 1112#endif /* OPENSSL_THREADS */ 1113 1114int ub_openssl_lock_init(void) 1115{ 1116#if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1117 int i; 1118 ub_openssl_locks = (lock_basic_type*)reallocarray( 1119 NULL, (size_t)CRYPTO_num_locks(), sizeof(lock_basic_type)); 1120 if(!ub_openssl_locks) 1121 return 0; 1122 for(i=0; i<CRYPTO_num_locks(); i++) { 1123 lock_basic_init(&ub_openssl_locks[i]); 1124 } 1125# ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1126 CRYPTO_THREADID_set_callback(&ub_crypto_id_cb); 1127# else 1128 CRYPTO_set_id_callback(&ub_crypto_id_cb); 1129# endif 1130 CRYPTO_set_locking_callback(&ub_crypto_lock_cb); 1131#endif /* OPENSSL_THREADS */ 1132 return 1; 1133} 1134 1135void ub_openssl_lock_delete(void) 1136{ 1137#if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 1138 int i; 1139 if(!ub_openssl_locks) 1140 return; 1141# ifdef HAVE_CRYPTO_THREADID_SET_CALLBACK 1142 CRYPTO_THREADID_set_callback(NULL); 1143# else 1144 CRYPTO_set_id_callback(NULL); 1145# endif 1146 CRYPTO_set_locking_callback(NULL); 1147 for(i=0; i<CRYPTO_num_locks(); i++) { 1148 lock_basic_destroy(&ub_openssl_locks[i]); 1149 } 1150 free(ub_openssl_locks); 1151#endif /* OPENSSL_THREADS */ 1152} 1153 1154int listen_sslctx_setup_ticket_keys(void* sslctx, struct config_strlist* tls_session_ticket_keys) { 1155#ifdef HAVE_SSL 1156 size_t s = 1; 1157 struct config_strlist* p; 1158 struct tls_session_ticket_key *keys; 1159 for(p = tls_session_ticket_keys; p; p = p->next) { 1160 s++; 1161 } 1162 keys = calloc(s, sizeof(struct tls_session_ticket_key)); 1163 memset(keys, 0, s*sizeof(*keys)); 1164 ticket_keys = keys; 1165 1166 for(p = tls_session_ticket_keys; p; p = p->next) { 1167 size_t n; 1168 unsigned char *data = (unsigned char *)malloc(80); 1169 FILE *f = fopen(p->str, "r"); 1170 if(!f) { 1171 log_err("could not read tls-session-ticket-key %s: %s", p->str, strerror(errno)); 1172 free(data); 1173 return 0; 1174 } 1175 n = fread(data, 1, 80, f); 1176 fclose(f); 1177 1178 if(n != 80) { 1179 log_err("tls-session-ticket-key %s is %d bytes, must be 80 bytes", p->str, (int)n); 1180 free(data); 1181 return 0; 1182 } 1183 verbose(VERB_OPS, "read tls-session-ticket-key: %s", p->str); 1184 1185 keys->key_name = data; 1186 keys->aes_key = data + 16; 1187 keys->hmac_key = data + 48; 1188 keys++; 1189 } 1190 /* terminate array with NULL key name entry */ 1191 keys->key_name = NULL; 1192 if(SSL_CTX_set_tlsext_ticket_key_cb(sslctx, tls_session_ticket_key_cb) == 0) { 1193 log_err("no support for TLS session ticket"); 1194 return 0; 1195 } 1196 return 1; 1197#else 1198 (void)sslctx; 1199 (void)tls_session_ticket_keys; 1200 return 0; 1201#endif 1202 1203} 1204 1205int tls_session_ticket_key_cb(void *ATTR_UNUSED(sslctx), unsigned char* key_name, unsigned char* iv, void *evp_sctx, void *hmac_ctx, int enc) 1206{ 1207#ifdef HAVE_SSL 1208 const EVP_MD *digest; 1209 const EVP_CIPHER *cipher; 1210 int evp_cipher_length; 1211 digest = EVP_sha256(); 1212 cipher = EVP_aes_256_cbc(); 1213 evp_cipher_length = EVP_CIPHER_iv_length(cipher); 1214 if( enc == 1 ) { 1215 /* encrypt */ 1216 verbose(VERB_CLIENT, "start session encrypt"); 1217 memcpy(key_name, ticket_keys->key_name, 16); 1218 if (RAND_bytes(iv, evp_cipher_length) != 1) { 1219 verbose(VERB_CLIENT, "RAND_bytes failed"); 1220 return -1; 1221 } 1222 if (EVP_EncryptInit_ex(evp_sctx, cipher, NULL, ticket_keys->aes_key, iv) != 1) { 1223 verbose(VERB_CLIENT, "EVP_EncryptInit_ex failed"); 1224 return -1; 1225 } 1226#ifndef HMAC_INIT_EX_RETURNS_VOID 1227 if (HMAC_Init_ex(hmac_ctx, ticket_keys->hmac_key, 32, digest, NULL) != 1) { 1228 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1229 return -1; 1230 } 1231#else 1232 HMAC_Init_ex(hmac_ctx, ticket_keys->hmac_key, 32, digest, NULL); 1233#endif 1234 return 1; 1235 } else if (enc == 0) { 1236 /* decrypt */ 1237 struct tls_session_ticket_key *key; 1238 verbose(VERB_CLIENT, "start session decrypt"); 1239 for(key = ticket_keys; key->key_name != NULL; key++) { 1240 if (!memcmp(key_name, key->key_name, 16)) { 1241 verbose(VERB_CLIENT, "Found session_key"); 1242 break; 1243 } 1244 } 1245 if(key->key_name == NULL) { 1246 verbose(VERB_CLIENT, "Not found session_key"); 1247 return 0; 1248 } 1249 1250#ifndef HMAC_INIT_EX_RETURNS_VOID 1251 if (HMAC_Init_ex(hmac_ctx, key->hmac_key, 32, digest, NULL) != 1) { 1252 verbose(VERB_CLIENT, "HMAC_Init_ex failed"); 1253 return -1; 1254 } 1255#else 1256 HMAC_Init_ex(hmac_ctx, key->hmac_key, 32, digest, NULL); 1257#endif 1258 if (EVP_DecryptInit_ex(evp_sctx, cipher, NULL, key->aes_key, iv) != 1) { 1259 log_err("EVP_DecryptInit_ex failed"); 1260 return -1; 1261 } 1262 1263 return (key == ticket_keys) ? 1 : 2; 1264 } 1265 return -1; 1266#else 1267 (void)key_name; 1268 (void)iv; 1269 (void)evp_sctx; 1270 (void)hmac_ctx; 1271 (void)enc; 1272 return 0; 1273#endif 1274} 1275 1276void 1277listen_sslctx_delete_ticket_keys(void) 1278{ 1279 struct tls_session_ticket_key *key; 1280 if(!ticket_keys) return; 1281 for(key = ticket_keys; key->key_name != NULL; key++) { 1282 /* wipe key data from memory*/ 1283#ifdef HAVE_EXPLICIT_BZERO 1284 explicit_bzero(key->key_name, 80); 1285#else 1286 memset(key->key_name, 0xdd, 80); 1287#endif 1288 free(key->key_name); 1289 } 1290 free(ticket_keys); 1291 ticket_keys = NULL; 1292} 1293