src/src/dane-openssl.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdint.h>
   4
   5 #include <openssl/opensslv.h>
   6 #include <openssl/err.h>
   7 #include <openssl/crypto.h>
   8 #include <openssl/safestack.h>
   9 #include <openssl/objects.h>
  10 #include <openssl/x509.h>
  11 #include <openssl/x509v3.h>
  12 #include <openssl/evp.h>
  13
  14 #if OPENSSL_VERSION_NUMBER < 0x1000000fL
  15 # error "OpenSSL 1.0.0 or higher required"
  16 #else   /* remainder of file */
  17
  18 #include "danessl.h"
  19
  20 #define DANE_F_ADD_SKID                 100
  21 #define DANE_F_CHECK_END_ENTITY         101
  22 #define DANE_F_GROW_CHAIN               102
  23 #define DANE_F_LIST_ALLOC               103
  24 #define DANE_F_MATCH                    104
  25 #define DANE_F_PUSH_EXT                 105
  26 #define DANE_F_SET_TRUST_ANCHOR         106
  27 #define DANE_F_SSL_CTX_DANE_INIT        107
  28 #define DANE_F_SSL_DANE_ADD_TLSA        108
  29 #define DANE_F_SSL_DANE_INIT            109
  30 #define DANE_F_SSL_DANE_LIBRARY_INIT    110
  31 #define DANE_F_VERIFY_CERT              111
  32 #define DANE_F_WRAP_CERT                112
  33
  34 #define DANE_R_BAD_CERT                 100
  35 #define DANE_R_BAD_CERT_PKEY            101
  36 #define DANE_R_BAD_DATA_LENGTH          102
  37 #define DANE_R_BAD_DIGEST               103
  38 #define DANE_R_BAD_NULL_DATA            104
  39 #define DANE_R_BAD_PKEY                 105
  40 #define DANE_R_BAD_SELECTOR             106
  41 #define DANE_R_BAD_USAGE                107
  42 #define DANE_R_DANE_INIT                108
  43 #define DANE_R_DANE_SUPPORT             109
  44 #define DANE_R_LIBRARY_INIT             110
  45 #define DANE_R_NOSIGN_KEY               111
  46 #define DANE_R_SCTX_INIT                112
  47
  48 #ifndef OPENSSL_NO_ERR
  49 # define DANE_F_PLACEHOLDER              0               /* FIRST! Value TBD */
  50 static ERR_STRING_DATA dane_str_functs[] =
  51 {
  52     {DANE_F_PLACEHOLDER,                "DANE library"},        /* FIRST!!! */
  53     {DANE_F_ADD_SKID,                   "add_skid"},
  54     {DANE_F_CHECK_END_ENTITY,           "check_end_entity"},
  55     {DANE_F_GROW_CHAIN,                 "grow_chain"},
  56     {DANE_F_LIST_ALLOC,                 "list_alloc"},
  57     {DANE_F_MATCH,                      "match"},
  58     {DANE_F_PUSH_EXT,                   "push_ext"},
  59     {DANE_F_SET_TRUST_ANCHOR,           "set_trust_anchor"},
  60     {DANE_F_SSL_CTX_DANE_INIT,          "SSL_CTX_dane_init"},
  61     {DANE_F_SSL_DANE_ADD_TLSA,          "SSL_dane_add_tlsa"},
  62     {DANE_F_SSL_DANE_INIT,              "SSL_dane_init"},
  63     {DANE_F_SSL_DANE_LIBRARY_INIT,      "SSL_dane_library_init"},
  64     {DANE_F_VERIFY_CERT,                "verify_cert"},
  65     {DANE_F_WRAP_CERT,                  "wrap_cert"},
  66     {0,                                 NULL}
  67 };
  68 static ERR_STRING_DATA dane_str_reasons[] =
  69 {
  70     {DANE_R_BAD_CERT,           "Bad TLSA record certificate"},
  71     {DANE_R_BAD_CERT_PKEY,      "Bad TLSA record certificate public key"},
  72     {DANE_R_BAD_DATA_LENGTH,    "Bad TLSA record digest length"},
  73     {DANE_R_BAD_DIGEST,         "Bad TLSA record digest"},
  74     {DANE_R_BAD_NULL_DATA,      "Bad TLSA record null data"},
  75     {DANE_R_BAD_PKEY,           "Bad TLSA record public key"},
  76     {DANE_R_BAD_SELECTOR,       "Bad TLSA record selector"},
  77     {DANE_R_BAD_USAGE,          "Bad TLSA record usage"},
  78     {DANE_R_DANE_INIT,          "SSL_dane_init() required"},
  79     {DANE_R_DANE_SUPPORT,       "DANE library features not supported"},
  80     {DANE_R_LIBRARY_INIT,       "SSL_dane_library_init() required"},
  81     {DANE_R_SCTX_INIT,          "SSL_CTX_dane_init() required"},
  82     {DANE_R_NOSIGN_KEY,         "Certificate usage 2 requires EC support"},
  83     {0,                         NULL}
  84 };
  85 #endif  /*OPENSSL_NO_ERR*/
  86
  87 #define DANEerr(f, r) ERR_PUT_error(err_lib_dane, (f), (r), __FILE__, __LINE__)
  88
  89 static int err_lib_dane = -1;
  90 static int dane_idx = -1;
  91
  92 #ifdef X509_V_FLAG_PARTIAL_CHAIN       /* OpenSSL >= 1.0.2 */
  93 static int wrap_to_root = 0;
  94 #else
  95 static int wrap_to_root = 1;
  96 #endif
  97
  98 static void (*cert_free)(void *) = (void (*)(void *)) X509_free;
  99 static void (*pkey_free)(void *) = (void (*)(void *)) EVP_PKEY_free;
 100
 101 typedef struct dane_list
 102 {
 103     struct dane_list *next;
 104     void *value;
 105 } *dane_list;
 106
 107 #define LINSERT(h, e) do { (e)->next = (h); (h) = (e); } while (0)
 108
 109 typedef struct dane_host_list
 110 {
 111     struct dane_host_list *next;
 112     char *value;
 113 } *dane_host_list;
 114
 115 typedef struct dane_data
 116 {
 117     size_t datalen;
 118     unsigned char data[0];
 119 } *dane_data;
 120
 121 typedef struct dane_data_list
 122 {
 123     struct dane_data_list *next;
 124     dane_data value;
 125 } *dane_data_list;
 126
 127 typedef struct dane_mtype
 128 {
 129     int mdlen;
 130     const EVP_MD *md;
 131     dane_data_list data;
 132 } *dane_mtype;
 133
 134 typedef struct dane_mtype_list
 135 {
 136     struct dane_mtype_list *next;
 137     dane_mtype value;
 138 } *dane_mtype_list;
 139
 140 typedef struct dane_selector
 141 {
 142     uint8_t selector;
 143     dane_mtype_list mtype;
 144 } *dane_selector;
 145
 146 typedef struct dane_selector_list
 147 {
 148     struct dane_selector_list *next;
 149     dane_selector value;
 150 } *dane_selector_list;
 151
 152 typedef struct dane_pkey_list
 153 {
 154     struct dane_pkey_list *next;
 155     EVP_PKEY *value;
 156 } *dane_pkey_list;
 157
 158 typedef struct dane_cert_list
 159 {
 160     struct dane_cert_list *next;
 161     X509 *value;
 162 } *dane_cert_list;
 163
 164 typedef struct ssl_dane
 165 {
 166     int            (*verify)(X509_STORE_CTX *);
 167     STACK_OF(X509) *roots;
 168     STACK_OF(X509) *chain;
 169     const char     *thost;              /* TLSA base domain */
 170     char           *mhost;              /* Matched, peer name */
 171     dane_pkey_list pkeys;
 172     dane_cert_list certs;
 173     dane_host_list hosts;
 174     dane_selector_list selectors[SSL_DANE_USAGE_LAST + 1];
 175     int            depth;
 176     int            multi;               /* Multi-label wildcards? */
 177     int            count;               /* Number of TLSA records */
 178 } ssl_dane;
 179
 180 #ifndef X509_V_ERR_HOSTNAME_MISMATCH
 181 # define X509_V_ERR_HOSTNAME_MISMATCH X509_V_ERR_APPLICATION_VERIFICATION
 182 #endif
 183
 184 static int
 185 match(dane_selector_list slist, X509 *cert, int depth)
 186 {
 187 int matched;
 188
 189 /*
 190  * Note, set_trust_anchor() needs to know whether the match was for a
 191  * pkey digest or a certificate digest.  We return MATCHED_PKEY or
 192  * MATCHED_CERT accordingly.
 193  */
 194 #define MATCHED_CERT (SSL_DANE_SELECTOR_CERT + 1)
 195 #define MATCHED_PKEY (SSL_DANE_SELECTOR_SPKI + 1)
 196
 197 /*
 198  * Loop over each selector, mtype, and associated data element looking
 199  * for a match.
 200  */
 201 for(matched = 0; !matched && slist; slist = slist->next)
 202   {
 203   dane_mtype_list m;
 204   unsigned char mdbuf[EVP_MAX_MD_SIZE];
 205   unsigned char *buf;
 206   unsigned char *buf2;
 207   unsigned int len;
 208
 209   /*
 210    * Extract ASN.1 DER form of certificate or public key.
 211    */
 212   switch(slist->value->selector)
 213     {
 214     case SSL_DANE_SELECTOR_CERT:
 215       len = i2d_X509(cert, NULL);
 216       buf2 = buf = (unsigned char *) OPENSSL_malloc(len);
 217       if(buf) i2d_X509(cert, &buf2);
 218       break;
 219     case SSL_DANE_SELECTOR_SPKI:
 220       len = i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), NULL);
 221       buf2 = buf = (unsigned char *) OPENSSL_malloc(len);
 222       if(buf) i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), &buf2);
 223       break;
 224     }
 225
 226   if(!buf)
 227     {
 228     DANEerr(DANE_F_MATCH, ERR_R_MALLOC_FAILURE);
 229     return 0;
 230     }
 231   OPENSSL_assert(buf2 - buf == len);
 232
 233   /*
 234    * Loop over each mtype and data element
 235    */
 236   for(m = slist->value->mtype; !matched && m; m = m->next)
 237     {
 238     dane_data_list d;
 239     unsigned char *cmpbuf = buf;
 240     unsigned int cmplen = len;
 241
 242     /*
 243      * If it is a digest, compute the corresponding digest of the
 244      * DER data for comparison, otherwise, use the full object.
 245      */
 246     if(m->value->md)
 247       {
 248       cmpbuf = mdbuf;
 249       if(!EVP_Digest(buf, len, cmpbuf, &cmplen, m->value->md, 0))
 250           matched = -1;
 251       }
 252     for(d = m->value->data; !matched && d; d = d->next)
 253         if(  cmplen == d->value->datalen
 254           && memcmp(cmpbuf, d->value->data, cmplen) == 0)
 255             matched = slist->value->selector + 1;
 256     }
 257
 258   OPENSSL_free(buf);
 259   }
 260
 261 return matched;
 262 }
 263
 264 static int
 265 push_ext(X509 *cert, X509_EXTENSION *ext)
 266 {
 267 X509_EXTENSIONS *exts;
 268
 269 if(ext)
 270   {
 271   if(!(exts = cert->cert_info->extensions))
 272     exts = cert->cert_info->extensions = sk_X509_EXTENSION_new_null();
 273   if (exts && sk_X509_EXTENSION_push(exts, ext))
 274     return 1;
 275   X509_EXTENSION_free(ext);
 276   }
 277 DANEerr(DANE_F_PUSH_EXT, ERR_R_MALLOC_FAILURE);
 278 return 0;
 279 }
 280
 281 static int
 282 add_ext(X509 *issuer, X509 *subject, int ext_nid, char *ext_val)
 283 {
 284 X509V3_CTX v3ctx;
 285
 286 X509V3_set_ctx(&v3ctx, issuer, subject, 0, 0, 0);
 287 return push_ext(subject, X509V3_EXT_conf_nid(0, &v3ctx, ext_nid, ext_val));
 288 }
 289
 290 static int
 291 set_serial(X509 *cert, AUTHORITY_KEYID *akid, X509 *subject)
 292 {
 293 int ret = 0;
 294 BIGNUM *bn;
 295
 296 if(akid && akid->serial)
 297   return (X509_set_serialNumber(cert, akid->serial));
 298
 299 /*
 300  * Add one to subject's serial to avoid collisions between TA serial and
 301  * serial of signing root.
 302  */
 303 if(  (bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(subject), 0)) != 0
 304   && BN_add_word(bn, 1)
 305   && BN_to_ASN1_INTEGER(bn, X509_get_serialNumber(cert)))
 306   ret = 1;
 307
 308 if(bn)
 309   BN_free(bn);
 310 return ret;
 311 }
 312
 313 static int
 314 add_akid(X509 *cert, AUTHORITY_KEYID *akid)
 315 {
 316 int nid = NID_authority_key_identifier;
 317 ASN1_STRING *id;
 318 unsigned char c = 0;
 319 int ret = 0;
 320
 321 /*
 322  * 0 will never be our subject keyid from a SHA-1 hash, but it could be
 323  * our subject keyid if forced from child's akid.  If so, set our
 324  * authority keyid to 1.  This way we are never self-signed, and thus
 325  * exempt from any potential (off by default for now in OpenSSL)
 326  * self-signature checks!
 327  */
 328 id = (ASN1_STRING *) ((akid && akid->keyid) ? akid->keyid : 0);
 329 if(id && M_ASN1_STRING_length(id) == 1 && *M_ASN1_STRING_data(id) == c)
 330   c = 1;
 331
 332 if(  (akid = AUTHORITY_KEYID_new()) != 0
 333   && (akid->keyid = ASN1_OCTET_STRING_new()) != 0
 334   && M_ASN1_OCTET_STRING_set(akid->keyid, (void *) &c, 1)
 335   && X509_add1_ext_i2d(cert, nid, akid, 0, X509V3_ADD_APPEND))
 336   ret = 1;
 337 if(akid)
 338   AUTHORITY_KEYID_free(akid);
 339 return ret;
 340 }
 341
 342 static int
 343 add_skid(X509 *cert, AUTHORITY_KEYID *akid)
 344 {
 345 int nid = NID_subject_key_identifier;
 346
 347 if(!akid || !akid->keyid)
 348   return add_ext(0, cert, nid, "hash");
 349 return X509_add1_ext_i2d(cert, nid, akid->keyid, 0, X509V3_ADD_APPEND) > 0;
 350 }
 351
 352 static X509_NAME *
 353 akid_issuer_name(AUTHORITY_KEYID *akid)
 354 {
 355 if(akid && akid->issuer)
 356   {
 357   int     i;
 358   GENERAL_NAMES *gens = akid->issuer;
 359
 360   for(i = 0; i < sk_GENERAL_NAME_num(gens); ++i)
 361     {
 362     GENERAL_NAME *gn = sk_GENERAL_NAME_value(gens, i);
 363
 364     if(gn->type == GEN_DIRNAME)
 365       return (gn->d.dirn);
 366     }
 367   }
 368 return 0;
 369 }
 370
 371 static int
 372 set_issuer_name(X509 *cert, AUTHORITY_KEYID *akid)
 373 {
 374 X509_NAME *name = akid_issuer_name(akid);
 375
 376 /*
 377  * If subject's akid specifies an authority key identifer issuer name, we
 378  * must use that.
 379  */
 380 return X509_set_issuer_name(cert,
 381                             name ? name : X509_get_subject_name(cert));
 382 }
 383
 384 static int
 385 grow_chain(ssl_dane *dane, int trusted, X509 *cert)
 386 {
 387 STACK_OF(X509) **xs = trusted ? &dane->roots : &dane->chain;
 388 static ASN1_OBJECT *serverAuth = 0;
 389
 390 #define UNTRUSTED 0
 391 #define TRUSTED 1
 392
 393 if(  trusted && !serverAuth
 394   && !(serverAuth = OBJ_nid2obj(NID_server_auth)))
 395   {
 396   DANEerr(DANE_F_GROW_CHAIN, ERR_R_MALLOC_FAILURE);
 397   return 0;
 398   }
 399 if(!*xs && !(*xs = sk_X509_new_null()))
 400   {
 401   DANEerr(DANE_F_GROW_CHAIN, ERR_R_MALLOC_FAILURE);
 402   return 0;
 403   }
 404
 405 if(cert)
 406   {
 407   if(trusted && !X509_add1_trust_object(cert, serverAuth))
 408     return 0;
 409   CRYPTO_add(&cert->references, 1, CRYPTO_LOCK_X509);
 410   if (!sk_X509_push(*xs, cert))
 411     {
 412     X509_free(cert);
 413     DANEerr(DANE_F_GROW_CHAIN, ERR_R_MALLOC_FAILURE);
 414     return 0;
 415     }
 416   }
 417 return 1;
 418 }
 419
 420 static int
 421 wrap_issuer(ssl_dane *dane, EVP_PKEY *key, X509 *subject, int depth, int top)
 422 {
 423 int ret = 1;
 424 X509 *cert = 0;
 425 AUTHORITY_KEYID *akid;
 426 X509_NAME *name = X509_get_issuer_name(subject);
 427 EVP_PKEY *newkey = key ? key : X509_get_pubkey(subject);
 428
 429 #define WRAP_MID 0              /* Ensure intermediate. */
 430 #define WRAP_TOP 1              /* Ensure self-signed. */
 431
 432 if(!name || !newkey || !(cert = X509_new()))
 433   return 0;
 434
 435 /*
 436  * Record the depth of the trust-anchor certificate.
 437  */
 438 if(dane->depth < 0)
 439   dane->depth = depth + 1;
 440
 441 /*
 442  * XXX: Uncaught error condition:
 443  *
 444  * The return value is NULL both when the extension is missing, and when
 445  * OpenSSL rans out of memory while parsing the extension.
 446  */
 447 ERR_clear_error();
 448 akid = X509_get_ext_d2i(subject, NID_authority_key_identifier, 0, 0);
 449 /* XXX: Should we peek at the error stack here??? */
 450
 451 /*
 452  * If top is true generate a self-issued root CA, otherwise an
 453  * intermediate CA and possibly its self-signed issuer.
 454  *
 455  * CA cert valid for +/- 30 days
 456  */
 457 if(  !X509_set_version(cert, 2)
 458   || !set_serial(cert, akid, subject)
 459   || !X509_set_subject_name(cert, name)
 460   || !set_issuer_name(cert, akid)
 461   || !X509_gmtime_adj(X509_get_notBefore(cert), -30 * 86400L)
 462   || !X509_gmtime_adj(X509_get_notAfter(cert), 30 * 86400L)
 463   || !X509_set_pubkey(cert, newkey)
 464   || !add_ext(0, cert, NID_basic_constraints, "CA:TRUE")
 465   || (!top && !add_akid(cert, akid))
 466   || !add_skid(cert, akid)
 467   || (  !top && wrap_to_root
 468      && !wrap_issuer(dane, newkey, cert, depth, WRAP_TOP)))
 469   ret = 0;
 470
 471 if(akid)
 472   AUTHORITY_KEYID_free(akid);
 473 if(!key)
 474   EVP_PKEY_free(newkey);
 475 if(ret)
 476   ret = grow_chain(dane, !top && wrap_to_root ? UNTRUSTED : TRUSTED, cert);
 477 if(cert)
 478   X509_free(cert);
 479 return ret;
 480 }
 481
 482 static int
 483 wrap_cert(ssl_dane *dane, X509 *tacert, int depth)
 484 {
 485 if(dane->depth < 0)
 486   dane->depth = depth + 1;
 487
 488 /*
 489  * If the TA certificate is self-issued, or need not be, use it directly.
 490  * Otherwise, synthesize requisuite ancestors.
 491  */
 492 if(  !wrap_to_root
 493   || X509_check_issued(tacert, tacert) == X509_V_OK)
 494   return grow_chain(dane, TRUSTED, tacert);
 495
 496 if(wrap_issuer(dane, 0, tacert, depth, WRAP_MID))
 497   return grow_chain(dane, UNTRUSTED, tacert);
 498 return 0;
 499 }
 500
 501 static int
 502 ta_signed(ssl_dane *dane, X509 *cert, int depth)
 503 {
 504 dane_cert_list x;
 505 dane_pkey_list k;
 506 EVP_PKEY *pk;
 507 int done = 0;
 508
 509 /*
 510  * First check whether issued and signed by a TA cert, this is cheaper
 511  * than the bare-public key checks below, since we can determine whether
 512  * the candidate TA certificate issued the certificate to be checked
 513  * first (name comparisons), before we bother with signature checks
 514  * (public key operations).
 515  */
 516 for (x = dane->certs; !done && x; x = x->next)
 517   {
 518   if(X509_check_issued(x->value, cert) == X509_V_OK)
 519     {
 520     if(!(pk = X509_get_pubkey(x->value)))
 521       {
 522       /*
 523        * The cert originally contained a valid pkey, which does
 524        * not just vanish, so this is most likely a memory error.
 525        */
 526       done = -1;
 527       break;
 528       }
 529     /* Check signature, since some other TA may work if not this. */
 530     if(X509_verify(cert, pk) > 0)
 531       done = wrap_cert(dane, x->value, depth) ? 1 : -1;
 532     EVP_PKEY_free(pk);
 533     }
 534   }
 535
 536 /*
 537  * With bare TA public keys, we can't check whether the trust chain is
 538  * issued by the key, but we can determine whether it is signed by the
 539  * key, so we go with that.
 540  *
 541  * Ideally, the corresponding certificate was presented in the chain, and we
 542  * matched it by its public key digest one level up.  This code is here
 543  * to handle adverse conditions imposed by sloppy administrators of
 544  * receiving systems with poorly constructed chains.
 545  *
 546  * We'd like to optimize out keys that should not match when the cert's
 547  * authority key id does not match the key id of this key computed via
 548  * the RFC keyid algorithm (SHA-1 digest of public key bit-string sans
 549  * ASN1 tag and length thus also excluding the unused bits field that is
 550  * logically part of the length).  However, some CAs have a non-standard
 551  * authority keyid, so we lose.  Too bad.
 552  *
 553  * This may push errors onto the stack when the certificate signature is
 554  * not of the right type or length, throw these away,
 555  */
 556 for(k = dane->pkeys; !done && k; k = k->next)
 557   if(X509_verify(cert, k->value) > 0)
 558     done = wrap_issuer(dane, k->value, cert, depth, WRAP_MID) ? 1 : -1;
 559   else
 560     ERR_clear_error();
 561
 562 return done;
 563 }
 564
 565 static int
 566 set_trust_anchor(X509_STORE_CTX *ctx, ssl_dane *dane, X509 *cert)
 567 {
 568 int matched = 0;
 569 int n;
 570 int i;
 571 int depth = 0;
 572 EVP_PKEY *takey;
 573 X509 *ca;
 574 STACK_OF(X509) *in = ctx->untrusted;        /* XXX: Accessor? */
 575
 576 if(!grow_chain(dane, UNTRUSTED, 0))
 577   return -1;
 578
 579 /*
 580  * Accept a degenerate case: depth 0 self-signed trust-anchor.
 581  */
 582 if(X509_check_issued(cert, cert) == X509_V_OK)
 583   {
 584   dane->depth = 0;
 585   matched = match(dane->selectors[SSL_DANE_USAGE_TRUSTED_CA], cert, 0);
 586   if(matched > 0 && !grow_chain(dane, TRUSTED, cert))
 587     matched = -1;
 588   return matched;
 589   }
 590
 591 /* Make a shallow copy of the input untrusted chain. */
 592 if(!(in = sk_X509_dup(in)))
 593   {
 594   DANEerr(DANE_F_SET_TRUST_ANCHOR, ERR_R_MALLOC_FAILURE);
 595   return -1;
 596   }
 597
 598 /*
 599  * At each iteration we consume the issuer of the current cert.  This
 600  * reduces the length of the "in" chain by one.  If no issuer is found,
 601  * we are done.  We also stop when a certificate matches a TA in the
 602  * peer's TLSA RRset.
 603  *
 604  * Caller ensures that the initial certificate is not self-signed.
 605  */
 606 for(n = sk_X509_num(in); n > 0; --n, ++depth)
 607   {
 608   for(i = 0; i < n; ++i)
 609     if(X509_check_issued(sk_X509_value(in, i), cert) == X509_V_OK)
 610       break;
 611
 612   /*
 613    * Final untrusted element with no issuer in the peer's chain, it may
 614    * however be signed by a pkey or cert obtained via a TLSA RR.
 615    */
 616   if(i == n)
 617     break;
 618
 619   /* Peer's chain contains an issuer ca. */
 620   ca = sk_X509_delete(in, i);
 621
 622   /* If not a trust anchor, record untrusted ca and continue. */
 623   if((matched = match(dane->selectors[SSL_DANE_USAGE_TRUSTED_CA], ca, depth+1))
 624      == 0)
 625     {
 626     if(grow_chain(dane, UNTRUSTED, ca))
 627       {
 628       if(!X509_check_issued(ca, ca) == X509_V_OK)
 629         {
 630         /* Restart with issuer as subject */
 631         cert = ca;
 632         continue;
 633         }
 634       /* Final self-signed element, skip ta_signed() check. */
 635       cert = 0;
 636       }
 637     else
 638       matched = -1;
 639     }
 640   else if(matched == MATCHED_CERT)
 641     {
 642     if(!wrap_cert(dane, ca, depth))
 643       matched = -1;
 644     }
 645   else if(matched == MATCHED_PKEY)
 646     {
 647     if(  !(takey = X509_get_pubkey(ca))
 648       || !wrap_issuer(dane, takey, cert, depth, WRAP_MID))
 649       {
 650       if(takey)
 651         EVP_PKEY_free(takey);
 652       else
 653         DANEerr(DANE_F_SET_TRUST_ANCHOR, ERR_R_MALLOC_FAILURE);
 654       matched = -1;
 655       }
 656     }
 657   break;
 658   }
 659
 660 /* Shallow free the duplicated input untrusted chain. */
 661 sk_X509_free(in);
 662
 663 /*
 664  * When the loop exits, if "cert" is set, it is not self-signed and has
 665  * no issuer in the chain, we check for a possible signature via a DNS
 666  * obtained TA cert or public key.
 667  */
 668 if(matched == 0 && cert)
 669   matched = ta_signed(dane, cert, depth);
 670
 671 return matched;
 672 }
 673
 674 static int
 675 check_end_entity(X509_STORE_CTX *ctx, ssl_dane *dane, X509 *cert)
 676 {
 677 int matched;
 678
 679 matched = match(dane->selectors[SSL_DANE_USAGE_FIXED_LEAF], cert, 0);
 680 if(matched > 0)
 681   if(!ctx->chain)
 682     if(  (ctx->chain = sk_X509_new_null())
 683       && sk_X509_push(ctx->chain, cert))
 684       CRYPTO_add(&cert->references, 1, CRYPTO_LOCK_X509);
 685     else
 686       {
 687       DANEerr(DANE_F_CHECK_END_ENTITY, ERR_R_MALLOC_FAILURE);
 688       return -1;
 689       }
 690 return matched;
 691 }
 692
 693 static int
 694 match_name(const char *certid, ssl_dane *dane)
 695 {
 696 int multi = dane->multi;
 697 dane_host_list hosts;
 698
 699 for(hosts = dane->hosts; hosts; hosts = hosts->next)
 700   {
 701   int match_subdomain = 0;
 702   const char *domain = hosts->value;
 703   const char *parent;
 704   int idlen;
 705   int domlen;
 706
 707   if(*domain == '.' && domain[1] != '\0')
 708     {
 709     ++domain;
 710     match_subdomain = 1;
 711     }
 712
 713   /*
 714    * Sub-domain match: certid is any sub-domain of hostname.
 715    */
 716   if(match_subdomain)
 717     if(  (idlen = strlen(certid)) > (domlen = strlen(domain)) + 1
 718       && certid[idlen - domlen - 1] == '.'
 719       && !strcasecmp(certid + (idlen - domlen), domain))
 720       return 1;
 721     else
 722       continue;
 723
 724   /*
 725    * Exact match and initial "*" match. The initial "*" in a certid
 726    * matches one (if multi is false) or more hostname components under
 727    * the condition that the certid contains multiple hostname components.
 728    */
 729   if(  !strcasecmp(certid, domain)
 730     || (  certid[0] == '*' && certid[1] == '.' && certid[2] != 0
 731        && (parent = strchr(domain, '.')) != 0
 732        && (idlen = strlen(certid + 1)) <= (domlen = strlen(parent))
 733        && strcasecmp(multi ? parent + domlen - idlen : parent, certid+1) == 0))
 734     return 1;
 735   }
 736 return 0;
 737 }
 738
 739 static char *
 740 check_name(char *name, int len)
 741 {
 742 char *cp = name + len;
 743
 744 while(len > 0 && !*--cp)
 745   --len;                          /* Ignore trailing NULs */
 746 if(len <= 0)
 747   return 0;
 748 for(cp = name; *cp; cp++)
 749   {
 750   char c = *cp;
 751   if (!((c >= 'a' && c <= 'z') ||
 752         (c >= '0' && c <= '9') ||
 753         (c >= 'A' && c <= 'Z') ||
 754         (c == '.' || c == '-') ||
 755         (c == '*')))
 756     return 0;                   /* Only LDH, '.' and '*' */
 757   }
 758 if(cp - name != len)               /* Guard against internal NULs */
 759   return 0;
 760 return name;
 761 }
 762
 763 static char *
 764 parse_dns_name(const GENERAL_NAME *gn)
 765 {
 766 if(gn->type != GEN_DNS)
 767   return 0;
 768 if(ASN1_STRING_type(gn->d.ia5) != V_ASN1_IA5STRING)
 769   return 0;
 770 return check_name((char *) ASN1_STRING_data(gn->d.ia5),
 771                   ASN1_STRING_length(gn->d.ia5));
 772 }
 773
 774 static char *
 775 parse_subject_name(X509 *cert)
 776 {
 777 X509_NAME *name = X509_get_subject_name(cert);
 778 X509_NAME_ENTRY *entry;
 779 ASN1_STRING *entry_str;
 780 unsigned char *namebuf;
 781 int nid = NID_commonName;
 782 int len;
 783 int i;
 784
 785 if(!name || (i = X509_NAME_get_index_by_NID(name, nid, -1)) < 0)
 786   return 0;
 787 if(!(entry = X509_NAME_get_entry(name, i)))
 788   return 0;
 789 if(!(entry_str = X509_NAME_ENTRY_get_data(entry)))
 790   return 0;
 791
 792 if((len = ASN1_STRING_to_UTF8(&namebuf, entry_str)) < 0)
 793   return 0;
 794 if(len <= 0 || check_name((char *) namebuf, len) == 0)
 795   {
 796   OPENSSL_free(namebuf);
 797   return 0;
 798   }
 799 return (char *) namebuf;
 800 }
 801
 802 static int
 803 name_check(ssl_dane *dane, X509 *cert)
 804 {
 805 int matched = 0;
 806 BOOL got_altname = FALSE;
 807 GENERAL_NAMES *gens;
 808
 809 gens = X509_get_ext_d2i(cert, NID_subject_alt_name, 0, 0);
 810 if(gens)
 811   {
 812   int n = sk_GENERAL_NAME_num(gens);
 813   int i;
 814
 815   for(i = 0; i < n; ++i)
 816     {
 817     const GENERAL_NAME *gn = sk_GENERAL_NAME_value(gens, i);
 818     const char *certid;
 819
 820     if(gn->type != GEN_DNS)
 821         continue;
 822     got_altname = TRUE;
 823     certid = parse_dns_name(gn);
 824     if(certid && *certid)
 825       {
 826       if((matched = match_name(certid, dane)) == 0)
 827         continue;
 828       if(!(dane->mhost = OPENSSL_strdup(certid)))
 829         matched = -1;
 830       break;
 831       }
 832     }
 833   GENERAL_NAMES_free(gens);
 834   }
 835
 836 /*
 837  * XXX: Should the subjectName be skipped when *any* altnames are present,
 838  * or only when DNS altnames are present?
 839  */
 840 if(got_altname)
 841   {
 842   char *certid = parse_subject_name(cert);
 843   if(certid != 0 && *certid && (matched = match_name(certid, dane)) != 0)
 844     dane->mhost = certid;       /* Already a copy */
 845   }
 846 return matched;
 847 }
 848
 849 static int
 850 verify_chain(X509_STORE_CTX *ctx)
 851 {
 852 dane_selector_list issuer_rrs;
 853 dane_selector_list leaf_rrs;
 854 int (*cb)(int, X509_STORE_CTX *) = ctx->verify_cb;
 855 int ssl_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
 856 SSL *ssl = X509_STORE_CTX_get_ex_data(ctx, ssl_idx);
 857 ssl_dane *dane = SSL_get_ex_data(ssl, dane_idx);
 858 X509 *cert = ctx->cert;             /* XXX: accessor? */
 859 int matched = 0;
 860 int chain_length = sk_X509_num(ctx->chain);
 861
 862 DEBUG(D_tls) debug_printf("Dane library verify_chain fn called\n");
 863
 864 issuer_rrs = dane->selectors[SSL_DANE_USAGE_LIMIT_ISSUER];
 865 leaf_rrs = dane->selectors[SSL_DANE_USAGE_LIMIT_LEAF];
 866 ctx->verify = dane->verify;
 867
 868 if((matched = name_check(dane, cert)) < 0)
 869   {
 870   X509_STORE_CTX_set_error(ctx, X509_V_ERR_OUT_OF_MEM);
 871   return 0;
 872   }
 873
 874 if(!matched)
 875   {
 876   ctx->error_depth = 0;
 877   ctx->current_cert = cert;
 878   X509_STORE_CTX_set_error(ctx, X509_V_ERR_HOSTNAME_MISMATCH);
 879   if(!cb(0, ctx))
 880     return 0;
 881   }
 882 matched = 0;
 883
 884 /*
 885  * Satisfy at least one usage 0 or 1 constraint, unless we've already
 886  * matched a usage 2 trust anchor.
 887  *
 888  * XXX: internal_verify() doesn't callback with top certs that are not
 889  * self-issued.  This should be fixed in a future OpenSSL.
 890  */
 891 if(dane->roots && sk_X509_num(dane->roots))
 892   {
 893 #ifndef NO_CALLBACK_WORKAROUND
 894   X509 *top = sk_X509_value(ctx->chain, dane->depth);
 895
 896   if(X509_check_issued(top, top) != X509_V_OK)
 897     {
 898     ctx->error_depth = dane->depth;
 899     ctx->current_cert = top;
 900     if(!cb(1, ctx))
 901       return 0;
 902     }
 903 #endif
 904   /* Pop synthetic trust-anchor ancestors off the chain! */
 905   while (--chain_length > dane->depth)
 906       X509_free(sk_X509_pop(ctx->chain));
 907   }
 908 else if(issuer_rrs || leaf_rrs)
 909   {
 910   int n = chain_length;
 911
 912   /*
 913    * Check for an EE match, then a CA match at depths > 0, and
 914    * finally, if the EE cert is self-issued, for a depth 0 CA match.
 915    */
 916   if(leaf_rrs)
 917     matched = match(leaf_rrs, cert, 0);
 918   while(!matched && issuer_rrs && --n >= 0)
 919     {
 920     X509 *xn = sk_X509_value(ctx->chain, n);
 921
 922     if(n > 0 || X509_check_issued(xn, xn) == X509_V_OK)
 923       matched = match(issuer_rrs, xn, n);
 924     }
 925
 926   if(matched < 0)
 927     {
 928     X509_STORE_CTX_set_error(ctx, X509_V_ERR_OUT_OF_MEM);
 929     return 0;
 930     }
 931
 932   if(!matched)
 933     {
 934     ctx->current_cert = cert;
 935     ctx->error_depth = 0;
 936     X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_UNTRUSTED);
 937     if(!cb(0, ctx))
 938       return 0;
 939     }
 940   }
 941
 942 return ctx->verify(ctx);
 943 }
 944
 945 static int
 946 verify_cert(X509_STORE_CTX *ctx, void *unused_ctx)
 947 {
 948 static int ssl_idx = -1;
 949 SSL *ssl;
 950 ssl_dane *dane;
 951 int (*cb)(int, X509_STORE_CTX *) = ctx->verify_cb;
 952 int matched;
 953 X509 *cert = ctx->cert;             /* XXX: accessor? */
 954
 955 DEBUG(D_tls) debug_printf("Dane library verify_cert fn called\n");
 956
 957 if(ssl_idx < 0)
 958   ssl_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
 959 if(dane_idx < 0)
 960   {
 961   DANEerr(DANE_F_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
 962   return -1;
 963   }
 964
 965 ssl = X509_STORE_CTX_get_ex_data(ctx, ssl_idx);
 966 if(!(dane = SSL_get_ex_data(ssl, dane_idx)) || !cert)
 967   return X509_verify_cert(ctx);
 968
 969 if(dane->selectors[SSL_DANE_USAGE_FIXED_LEAF])
 970   {
 971   if((matched = check_end_entity(ctx, dane, cert)) > 0)
 972     {
 973     ctx->error_depth = 0;
 974     ctx->current_cert = cert;
 975     return cb(1, ctx);
 976     }
 977   if(matched < 0)
 978     {
 979     X509_STORE_CTX_set_error(ctx, X509_V_ERR_OUT_OF_MEM);
 980     return -1;
 981     }
 982   }
 983
 984 if(dane->selectors[SSL_DANE_USAGE_TRUSTED_CA])
 985   {
 986   if((matched = set_trust_anchor(ctx, dane, cert)) < 0)
 987     {
 988     X509_STORE_CTX_set_error(ctx, X509_V_ERR_OUT_OF_MEM);
 989     return -1;
 990     }
 991   if(matched)
 992     {
 993     /*
 994      * Check that setting the untrusted chain updates the expected
 995      * structure member at the expected offset.
 996      */
 997     X509_STORE_CTX_trusted_stack(ctx, dane->roots);
 998     X509_STORE_CTX_set_chain(ctx, dane->chain);
 999     OPENSSL_assert(ctx->untrusted == dane->chain);
1000     }
1001   }
1002
1003 /*
1004  * Name checks and usage 0/1 constraint enforcement are delayed until
1005  * X509_verify_cert() builds the full chain and calls our verify_chain()
1006  * wrapper.
1007  */
1008 dane->verify = ctx->verify;
1009 ctx->verify = verify_chain;
1010
1011 return X509_verify_cert(ctx);
1012 }
1013
1014 static dane_list
1015 list_alloc(size_t vsize)
1016 {
1017 void *value = (void *) OPENSSL_malloc(vsize);
1018 dane_list l;
1019
1020 if(!value)
1021   {
1022   DANEerr(DANE_F_LIST_ALLOC, ERR_R_MALLOC_FAILURE);
1023   return 0;
1024   }
1025 if(!(l = (dane_list) OPENSSL_malloc(sizeof(*l))))
1026   {
1027   OPENSSL_free(value);
1028   DANEerr(DANE_F_LIST_ALLOC, ERR_R_MALLOC_FAILURE);
1029   return 0;
1030   }
1031 l->next = 0;
1032 l->value = value;
1033 return l;
1034 }
1035
1036 static void
1037 list_free(void *list, void (*f)(void *))
1038 {
1039 dane_list head;
1040 dane_list next;
1041
1042 for(head = (dane_list) list; head; head = next)
1043   {
1044   next = head->next;
1045   if (f && head->value)
1046       f(head->value);
1047   OPENSSL_free(head);
1048   }
1049 }
1050
1051 static void
1052 dane_mtype_free(void *p)
1053 {
1054 list_free(((dane_mtype) p)->data, OPENSSL_freeFunc);
1055 OPENSSL_free(p);
1056 }
1057
1058 static void
1059 dane_selector_free(void *p)
1060 {
1061 list_free(((dane_selector) p)->mtype, dane_mtype_free);
1062 OPENSSL_free(p);
1063 }
1064
1065
1066
1067 /*
1068
1069 Tidy up once the connection is finished with.
1070
1071 Arguments
1072   ssl           The ssl connection handle
1073
1074 => Before calling SSL_free()
1075 tls_close() and tls_getc() [the error path] are the obvious places.
1076 Could we do it earlier - right after verification?  In tls_client_start()
1077 right after SSL_connect() returns, in that case.
1078
1079 */
1080
1081 void
1082 DANESSL_cleanup(SSL *ssl)
1083 {
1084 ssl_dane *dane;
1085 int u;
1086
1087 DEBUG(D_tls) debug_printf("Dane library cleanup fn called\n");
1088
1089 if(dane_idx < 0 || !(dane = SSL_get_ex_data(ssl, dane_idx)))
1090   return;
1091 (void) SSL_set_ex_data(ssl, dane_idx, 0);
1092
1093 if(dane->hosts)
1094   list_free(dane->hosts, OPENSSL_freeFunc);
1095 if(dane->mhost)
1096   OPENSSL_free(dane->mhost);
1097 for(u = 0; u <= SSL_DANE_USAGE_LAST; ++u)
1098   if(dane->selectors[u])
1099     list_free(dane->selectors[u], dane_selector_free);
1100 if(dane->pkeys)
1101   list_free(dane->pkeys, pkey_free);
1102 if(dane->certs)
1103   list_free(dane->certs, cert_free);
1104 if(dane->roots)
1105   sk_X509_pop_free(dane->roots, X509_free);
1106 if(dane->chain)
1107   sk_X509_pop_free(dane->chain, X509_free);
1108 OPENSSL_free(dane);
1109 DEBUG(D_tls) debug_printf("Dane library cleanup fn return\n");
1110 }
1111
1112 static dane_host_list
1113 host_list_init(const char **src)
1114 {
1115 dane_host_list head = NULL;
1116
1117 while(*src)
1118   {
1119   dane_host_list elem = (dane_host_list) OPENSSL_malloc(sizeof(*elem));
1120   if(!elem)
1121     {
1122     list_free(head, OPENSSL_freeFunc);
1123     return 0;
1124     }
1125   elem->value = OPENSSL_strdup(*src++);
1126   LINSERT(head, elem);
1127   }
1128 return head;
1129 }
1130
1131
1132
1133
1134 /*
1135
1136 Call this for each TLSA record found for the target, after the
1137 DANE setup has been done on the ssl connection handle.
1138
1139 Arguments:
1140   ssl           Connection handle
1141   usage         TLSA record field
1142   selector      TLSA record field
1143   mdname        ??? message digest name?
1144   data          ??? TLSA record megalump?
1145   dlen          length of data
1146
1147 Return
1148   -1 on error
1149   0  action not taken
1150   1  record accepted
1151 */
1152
1153 int
1154 DANESSL_add_tlsa(SSL *ssl, uint8_t usage, uint8_t selector, const char *mdname,
1155         unsigned const char *data, size_t dlen)
1156 {
1157 ssl_dane *dane;
1158 dane_selector_list s = 0;
1159 dane_mtype_list m = 0;
1160 dane_data_list d = 0;
1161 dane_cert_list xlist = 0;
1162 dane_pkey_list klist = 0;
1163 const EVP_MD *md = 0;
1164
1165 DEBUG(D_tls) debug_printf("Dane add_tlsa\n");
1166
1167 if(dane_idx < 0 || !(dane = SSL_get_ex_data(ssl, dane_idx)))
1168   {
1169   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_DANE_INIT);
1170   return -1;
1171   }
1172
1173 if(usage > SSL_DANE_USAGE_LAST)
1174   {
1175   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_USAGE);
1176   return 0;
1177   }
1178 if(selector > SSL_DANE_SELECTOR_LAST)
1179   {
1180   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_SELECTOR);
1181   return 0;
1182   }
1183 if(mdname && !(md = EVP_get_digestbyname(mdname)))
1184   {
1185   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_DIGEST);
1186   return 0;
1187   }
1188 if(!data)
1189   {
1190   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_NULL_DATA);
1191   return 0;
1192   }
1193 if(mdname && dlen != EVP_MD_size(md))
1194   {
1195   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_DATA_LENGTH);
1196   return 0;
1197   }
1198
1199 if(!mdname)
1200   {
1201   X509 *x = 0;
1202   EVP_PKEY *k = 0;
1203   const unsigned char *p = data;
1204
1205 #define xklistinit(lvar, ltype, var, freeFunc) do { \
1206       (lvar) = (ltype) OPENSSL_malloc(sizeof(*(lvar))); \
1207       if (!(lvar)) { \
1208           DANEerr(DANE_F_SSL_DANE_ADD_TLSA, ERR_R_MALLOC_FAILURE); \
1209           freeFunc((var)); \
1210           return 0; \
1211       } \
1212       (lvar)->next = 0; \
1213       lvar->value = var; \
1214   } while (0)
1215 #define xkfreeret(ret) do { \
1216       if (xlist) list_free(xlist, cert_free); \
1217       if (klist) list_free(klist, pkey_free); \
1218       return (ret); \
1219   } while (0)
1220
1221   switch(selector)
1222     {
1223     case SSL_DANE_SELECTOR_CERT:
1224       if(!d2i_X509(&x, &p, dlen) || dlen != p - data)
1225         {
1226         if (x)
1227             X509_free(x);
1228         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_CERT);
1229         return 0;
1230         }
1231       k = X509_get_pubkey(x);
1232       EVP_PKEY_free(k);
1233       if(!k)
1234         {
1235         X509_free(x);
1236         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_CERT_PKEY);
1237         return 0;
1238         }
1239       if(usage == SSL_DANE_USAGE_TRUSTED_CA)
1240         xklistinit(xlist, dane_cert_list, x, X509_free);
1241       break;
1242
1243     case SSL_DANE_SELECTOR_SPKI:
1244       if(!d2i_PUBKEY(&k, &p, dlen) || dlen != p - data)
1245         {
1246         if(k)
1247           EVP_PKEY_free(k);
1248         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_PKEY);
1249         return 0;
1250         }
1251       if(usage == SSL_DANE_USAGE_TRUSTED_CA)
1252         xklistinit(klist, dane_pkey_list, k, EVP_PKEY_free);
1253       break;
1254     }
1255   }
1256
1257 /* Find insertion point and don't add duplicate elements. */
1258 for(s = dane->selectors[usage]; s; s = s->next)
1259   if(s->value->selector == selector)
1260     for(m = s->value->mtype; m; m = m->next)
1261       if(m->value->md == md)
1262         for(d = m->value->data; d; d = d->next)
1263           if(  d->value->datalen == dlen
1264             && memcmp(d->value->data, data, dlen) == 0)
1265             xkfreeret(1);
1266
1267 if(!(d = (dane_data_list) list_alloc(sizeof(*d->value) + dlen)))
1268   xkfreeret(0);
1269 d->value->datalen = dlen;
1270 memcpy(d->value->data, data, dlen);
1271 if(!m)
1272   {
1273   if(!(m = (dane_mtype_list) list_alloc(sizeof(*m->value))))
1274     {
1275     list_free(d, OPENSSL_freeFunc);
1276     xkfreeret(0);
1277     }
1278   m->value->data = 0;
1279   if((m->value->md = md) != 0)
1280     m->value->mdlen = dlen;
1281   if(!s)
1282     {
1283     if(!(s = (dane_selector_list) list_alloc(sizeof(*s->value))))
1284       {
1285       list_free(m, dane_mtype_free);
1286       xkfreeret(0);
1287       }
1288     s->value->mtype = 0;
1289     s->value->selector = selector;
1290     LINSERT(dane->selectors[usage], s);
1291     }
1292   LINSERT(s->value->mtype, m);
1293   }
1294 LINSERT(m->value->data, d);
1295
1296 if(xlist)
1297   LINSERT(dane->certs, xlist);
1298 else if(klist)
1299   LINSERT(dane->pkeys, klist);
1300 ++dane->count;
1301 return 1;
1302 }
1303
1304
1305
1306
1307 /*
1308 Call this once we have an ssl connection handle but before
1309 making the TLS connection.
1310
1311 => In tls_client_start() after the call to SSL_new()
1312 and before the call to SSL_connect().  Exactly where
1313 probably does not matter.
1314 We probably want to keep our existing SNI handling;
1315 call this with NULL.
1316
1317 Arguments:
1318   ssl           Connection handle
1319   sni_domain    Optional peer server name
1320   hostnames     list of names to chack against peer cert
1321
1322 Return
1323   -1 on fatal error
1324   0  nonfatal error
1325   1  success
1326 */
1327
1328 int
1329 DANESSL_init(SSL *ssl, const char *sni_domain, const char **hostnames)
1330 {
1331 ssl_dane *dane;
1332 int i;
1333 #ifdef OPENSSL_INTERNAL
1334 SSL_CTX *sctx = SSL_get_SSL_CTX(ssl);
1335
1336
1337 if(sctx->app_verify_callback != verify_cert)
1338   {
1339   DANEerr(DANE_F_SSL_DANE_INIT, DANE_R_SCTX_INIT);
1340   return -1;
1341   }
1342 #else
1343 DEBUG(D_tls) debug_printf("Dane ssl_init\n");
1344 if(dane_idx < 0)
1345   {
1346   DANEerr(DANE_F_SSL_DANE_INIT, DANE_R_LIBRARY_INIT);
1347   return -1;
1348   }
1349 #endif
1350
1351 if(sni_domain && !SSL_set_tlsext_host_name(ssl, sni_domain))
1352     return 0;
1353
1354 if(!(dane = (ssl_dane *) OPENSSL_malloc(sizeof(ssl_dane))))
1355   {
1356   DANEerr(DANE_F_SSL_DANE_INIT, ERR_R_MALLOC_FAILURE);
1357   return 0;
1358   }
1359 if(!SSL_set_ex_data(ssl, dane_idx, dane))
1360   {
1361   DANEerr(DANE_F_SSL_DANE_INIT, ERR_R_MALLOC_FAILURE);
1362   OPENSSL_free(dane);
1363   return 0;
1364   }
1365 DEBUG(D_tls) debug_printf("Dane ssl-init: new dane struct: %p\n", dane);
1366
1367 dane->verify = 0;
1368 dane->hosts = 0;
1369 dane->thost = 0;
1370 dane->pkeys = 0;
1371 dane->certs = 0;
1372 dane->chain = 0;
1373 dane->roots = 0;
1374 dane->depth = -1;
1375 dane->mhost = 0;                    /* Future SSL control interface */
1376 dane->multi = 0;                    /* Future SSL control interface */
1377 dane->count = 0;
1378
1379 for(i = 0; i <= SSL_DANE_USAGE_LAST; ++i)
1380     dane->selectors[i] = 0;
1381
1382 if(hostnames && !(dane->hosts = host_list_init(hostnames)))
1383   {
1384   DANEerr(DANE_F_SSL_DANE_INIT, ERR_R_MALLOC_FAILURE);
1385   DANESSL_cleanup(ssl);
1386   return 0;
1387   }
1388
1389 return 1;
1390 }
1391
1392
1393 /*
1394
1395 Call this once we have a context to work with, but
1396 before DANESSL_init()
1397
1398 => in tls_client_start(), after tls_init() call gives us the ctx,
1399 if we decide we want to (policy) and can (TLSA records available)
1400 replacing (? what about fallback) everything from testing tls_verify_hosts
1401 down to just before calling SSL_new() for the conn handle.
1402
1403 Arguments
1404   ctx           SSL context
1405
1406 Return
1407   -1    Error
1408   1     Success
1409 */
1410
1411 int
1412 DANESSL_CTX_init(SSL_CTX *ctx)
1413 {
1414 DEBUG(D_tls) debug_printf("Dane ctx-init\n");
1415 if(dane_idx >= 0)
1416   {
1417   SSL_CTX_set_cert_verify_callback(ctx, verify_cert, 0);
1418   return 1;
1419   }
1420 DANEerr(DANE_F_SSL_CTX_DANE_INIT, DANE_R_LIBRARY_INIT);
1421 return -1;
1422 }
1423
1424 static int
1425 init_once(volatile int *value, int (*init)(void), void (*postinit)(void))
1426 {
1427 int wlock = 0;
1428
1429 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
1430 if(*value < 0)
1431   {
1432   CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
1433   CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
1434   wlock = 1;
1435   if(*value < 0)
1436     {
1437     *value = init();
1438     if(postinit)
1439       postinit();
1440     }
1441   }
1442 if (wlock)
1443     CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
1444 else
1445     CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
1446 return *value;
1447 }
1448
1449 static void
1450 dane_init(void)
1451 {
1452 /*
1453  * Store library id in zeroth function slot, used to locate the library
1454  * name.  This must be done before we load the error strings.
1455  */
1456 #ifndef OPENSSL_NO_ERR
1457 dane_str_functs[0].error |= ERR_PACK(err_lib_dane, 0, 0);
1458 ERR_load_strings(err_lib_dane, dane_str_functs);
1459 ERR_load_strings(err_lib_dane, dane_str_reasons);
1460 #endif
1461
1462 /*
1463  * Register SHA-2 digests, if implemented and not already registered.
1464  */
1465 #if defined(LN_sha256) && defined(NID_sha256) && !defined(OPENSSL_NO_SHA256)
1466 if(!EVP_get_digestbyname(LN_sha224)) EVP_add_digest(EVP_sha224());
1467 if(!EVP_get_digestbyname(LN_sha256)) EVP_add_digest(EVP_sha256());
1468 #endif
1469 #if defined(LN_sha512) && defined(NID_sha512) && !defined(OPENSSL_NO_SHA512)
1470 if(!EVP_get_digestbyname(LN_sha384)) EVP_add_digest(EVP_sha384());
1471 if(!EVP_get_digestbyname(LN_sha512)) EVP_add_digest(EVP_sha512());
1472 #endif
1473
1474 /*
1475  * Register an SSL index for the connection-specific ssl_dane structure.
1476  * Using a separate index makes it possible to add DANE support to
1477  * existing OpenSSL releases that don't have a suitable pointer in the
1478  * SSL structure.
1479  */
1480 dane_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
1481 }
1482
1483
1484
1485 /*
1486
1487 Call this once.  Probably early in startup will do; may need
1488 to be after SSL library init.
1489
1490 => put after call to tls_init() for now
1491
1492 Return
1493   1     Success
1494   0     Fail
1495 */
1496
1497 int
1498 DANESSL_library_init(void)
1499 {
1500 DEBUG(D_tls) debug_printf("Dane lib-init\n");
1501 if(err_lib_dane < 0)
1502   init_once(&err_lib_dane, ERR_get_next_error_library, dane_init);
1503
1504 #if defined(LN_sha256)
1505 /* No DANE without SHA256 support */
1506 if(dane_idx >= 0 && EVP_get_digestbyname(LN_sha256) != 0)
1507   return 1;
1508 #endif
1509
1510 DANEerr(DANE_F_SSL_DANE_LIBRARY_INIT, DANE_R_DANE_SUPPORT);
1511 return 0;
1512 }
1513
1514
1515 #endif /* OPENSSL_VERSION_NUMBER */
1516 /* vi: aw ai sw=2
1517 */