4f90caa4a07647064df1f7b2079169abbc65d8e1
[exim.git] / 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: usage %u sel %u mdname \"%s\"\n",
1166                           usage, selector, mdname);
1167
1168 if(dane_idx < 0 || !(dane = SSL_get_ex_data(ssl, dane_idx)))
1169   {
1170   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_DANE_INIT);
1171   return -1;
1172   }
1173
1174 if(usage > SSL_DANE_USAGE_LAST)
1175   {
1176   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_USAGE);
1177   return 0;
1178   }
1179 if(selector > SSL_DANE_SELECTOR_LAST)
1180   {
1181   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_SELECTOR);
1182   return 0;
1183   }
1184 if(mdname && !(md = EVP_get_digestbyname(mdname)))
1185   {
1186   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_DIGEST);
1187   return 0;
1188   }
1189 if(!data)
1190   {
1191   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_NULL_DATA);
1192   return 0;
1193   }
1194 if(mdname && dlen != EVP_MD_size(md))
1195   {
1196   DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_DATA_LENGTH);
1197   return 0;
1198   }
1199
1200 if(!mdname)
1201   {
1202   X509 *x = 0;
1203   EVP_PKEY *k = 0;
1204   const unsigned char *p = data;
1205
1206 #define xklistinit(lvar, ltype, var, freeFunc) do { \
1207       (lvar) = (ltype) OPENSSL_malloc(sizeof(*(lvar))); \
1208       if (!(lvar)) { \
1209           DANEerr(DANE_F_SSL_DANE_ADD_TLSA, ERR_R_MALLOC_FAILURE); \
1210           freeFunc((var)); \
1211           return 0; \
1212       } \
1213       (lvar)->next = 0; \
1214       lvar->value = var; \
1215   } while (0)
1216 #define xkfreeret(ret) do { \
1217       if (xlist) list_free(xlist, cert_free); \
1218       if (klist) list_free(klist, pkey_free); \
1219       return (ret); \
1220   } while (0)
1221
1222   switch(selector)
1223     {
1224     case SSL_DANE_SELECTOR_CERT:
1225       if(!d2i_X509(&x, &p, dlen) || dlen != p - data)
1226         {
1227         if (x)
1228             X509_free(x);
1229         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_CERT);
1230         return 0;
1231         }
1232       k = X509_get_pubkey(x);
1233       EVP_PKEY_free(k);
1234       if(!k)
1235         {
1236         X509_free(x);
1237         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_CERT_PKEY);
1238         return 0;
1239         }
1240       if(usage == SSL_DANE_USAGE_TRUSTED_CA)
1241         xklistinit(xlist, dane_cert_list, x, X509_free);
1242       break;
1243
1244     case SSL_DANE_SELECTOR_SPKI:
1245       if(!d2i_PUBKEY(&k, &p, dlen) || dlen != p - data)
1246         {
1247         if(k)
1248           EVP_PKEY_free(k);
1249         DANEerr(DANE_F_SSL_DANE_ADD_TLSA, DANE_R_BAD_PKEY);
1250         return 0;
1251         }
1252       if(usage == SSL_DANE_USAGE_TRUSTED_CA)
1253         xklistinit(klist, dane_pkey_list, k, EVP_PKEY_free);
1254       break;
1255     }
1256   }
1257
1258 /* Find insertion point and don't add duplicate elements. */
1259 for(s = dane->selectors[usage]; s; s = s->next)
1260   if(s->value->selector == selector)
1261     for(m = s->value->mtype; m; m = m->next)
1262       if(m->value->md == md)
1263         for(d = m->value->data; d; d = d->next)
1264           if(  d->value->datalen == dlen
1265             && memcmp(d->value->data, data, dlen) == 0)
1266             xkfreeret(1);
1267
1268 if(!(d = (dane_data_list) list_alloc(sizeof(*d->value) + dlen)))
1269   xkfreeret(0);
1270 d->value->datalen = dlen;
1271 memcpy(d->value->data, data, dlen);
1272 if(!m)
1273   {
1274   if(!(m = (dane_mtype_list) list_alloc(sizeof(*m->value))))
1275     {
1276     list_free(d, OPENSSL_freeFunc);
1277     xkfreeret(0);
1278     }
1279   m->value->data = 0;
1280   if((m->value->md = md) != 0)
1281     m->value->mdlen = dlen;
1282   if(!s)
1283     {
1284     if(!(s = (dane_selector_list) list_alloc(sizeof(*s->value))))
1285       {
1286       list_free(m, dane_mtype_free);
1287       xkfreeret(0);
1288       }
1289     s->value->mtype = 0;
1290     s->value->selector = selector;
1291     LINSERT(dane->selectors[usage], s);
1292     }
1293   LINSERT(s->value->mtype, m);
1294   }
1295 LINSERT(m->value->data, d);
1296
1297 if(xlist)
1298   LINSERT(dane->certs, xlist);
1299 else if(klist)
1300   LINSERT(dane->pkeys, klist);
1301 ++dane->count;
1302 return 1;
1303 }
1304
1305
1306
1307
1308 /*
1309 Call this once we have an ssl connection handle but before
1310 making the TLS connection.
1311
1312 => In tls_client_start() after the call to SSL_new()
1313 and before the call to SSL_connect().  Exactly where
1314 probably does not matter.
1315 We probably want to keep our existing SNI handling;
1316 call this with NULL.
1317
1318 Arguments:
1319   ssl           Connection handle
1320   sni_domain    Optional peer server name
1321   hostnames     list of names to chack against peer cert
1322
1323 Return
1324   -1 on fatal error
1325   0  nonfatal error
1326   1  success
1327 */
1328
1329 int
1330 DANESSL_init(SSL *ssl, const char *sni_domain, const char **hostnames)
1331 {
1332 ssl_dane *dane;
1333 int i;
1334 #ifdef OPENSSL_INTERNAL
1335 SSL_CTX *sctx = SSL_get_SSL_CTX(ssl);
1336
1337
1338 if(sctx->app_verify_callback != verify_cert)
1339   {
1340   DANEerr(DANE_F_SSL_DANE_INIT, DANE_R_SCTX_INIT);
1341   return -1;
1342   }
1343 #else
1344 DEBUG(D_tls) debug_printf("Dane ssl-init\n");
1345 if(dane_idx < 0)
1346   {
1347   DANEerr(DANE_F_SSL_DANE_INIT, DANE_R_LIBRARY_INIT);
1348   return -1;
1349   }
1350 #endif
1351
1352 if(sni_domain && !SSL_set_tlsext_host_name(ssl, sni_domain))
1353     return 0;
1354
1355 if(!(dane = (ssl_dane *) OPENSSL_malloc(sizeof(ssl_dane))))
1356   {
1357   DANEerr(DANE_F_SSL_DANE_INIT, ERR_R_MALLOC_FAILURE);
1358   return 0;
1359   }
1360 if(!SSL_set_ex_data(ssl, dane_idx, dane))
1361   {
1362   DANEerr(DANE_F_SSL_DANE_INIT, ERR_R_MALLOC_FAILURE);
1363   OPENSSL_free(dane);
1364   return 0;
1365   }
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 */