contrib/unbound/util/net_help.c

   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 }