Standard preamble:
========================================================================
..
.... Set up some character translations and predefined strings. \*(-- will
give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
double quote, and \*(R" will give a right double quote. \*(C+ will
give a nicer C++. Capital omega is used to do unbreakable dashes and
therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
nothing in troff, for use with C<>.
.tr \(*W- . ds -- \(*W- . ds PI pi . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch . ds L" "" . ds R" "" . ds C` "" . ds C' "" 'br\} . ds -- \|\(em\| . ds PI \(*p . ds L" `` . ds R" '' . ds C` . ds C' 'br\}
Escape single quotes in literal strings from groff's Unicode transform.
If the F register is >0, we'll generate index entries on stderr for
titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
entries marked with X<> in POD. Of course, you'll have to process the
output yourself in some meaningful fashion.
Avoid warning from groff about undefined register 'F'.
.. .nr rF 0 . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF
Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
Fear. Run. Save yourself. No user-serviceable parts.
. \" fudge factors for nroff and troff . ds #H 0 . ds #V .8m . ds #F .3m . ds #[ \f1 . ds #] .\} . ds #H ((1u-(\\\\n(.fu%2u))*.13m) . ds #V .6m . ds #F 0 . ds #[ \& . ds #] \& .\} . \" simple accents for nroff and troff . ds ' \& . ds ` \& . ds ^ \& . ds , \& . ds ~ ~ . ds / .\} . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' .\} . \" troff and (daisy-wheel) nroff accents . \" corrections for vroff . \" for low resolution devices (crt and lpr) \{\ . ds : e . ds 8 ss . ds o a . ds d- d\h'-1'\(ga . ds D- D\h'-1'\(hy . ds th \o'bp' . ds Th \o'LP' . ds ae ae . ds Ae AE .\} ========================================================================
Title "SSL_CTX_DANE_ENABLE 3"
way too many mistakes in technical documents.
\fBSSL_CTX_dane_enable() must be called first to initialize the shared state required for \s-1DANE\s0 support. Individual connections associated with the context can then enable per-connection \s-1DANE\s0 support as appropriate. \s-1DANE\s0 authentication is implemented in the X509_verify_cert\|(3) function, and applications that override X509_verify_cert\|(3) via \fBSSL_CTX_set_cert_verify_callback\|(3) are responsible to authenticate the peer chain in whatever manner they see fit.
\fBSSL_CTX_dane_mtype_set() may then be called zero or more times to adjust the supported digest algorithms. This must be done before any \s-1SSL\s0 handles are created for the context.
The mtype argument specifies a \s-1DANE TLSA\s0 matching type and the md argument specifies the associated digest algorithm handle. The ord argument specifies a strength ordinal. Algorithms with a larger strength ordinal are considered more secure. Strength ordinals are used to implement \s-1RFC7671\s0 digest algorithm agility. Specifying a \s-1NULL\s0 digest algorithm for a matching type disables support for that matching type. Matching type Full\|(0) cannot be modified or disabled.
By default, matching type \*(C`SHA2-256(1)\*(C' (see \s-1RFC7218\s0 for definitions of the \s-1DANE TLSA\s0 parameter acronyms) is mapped to \*(C`EVP_sha256()\*(C' with a strength ordinal of 1 and matching type \*(C`SHA2-512(2)\*(C' is mapped to \*(C`EVP_sha512()\*(C' with a strength ordinal of 2.
\fBSSL_dane_enable() must be called before the \s-1SSL\s0 handshake is initiated with \fBSSL_connect\|(3) if (and only if) you want to enable \s-1DANE\s0 for that connection. (The connection must be associated with a DANE-enabled \s-1SSL\s0 context). The basedomain argument specifies the \s-1RFC7671 TLSA\s0 base domain, which will be the primary peer reference identifier for certificate name checks. Additional server names can be specified via SSL_add1_host\|(3). The basedomain is used as the default \s-1SNI\s0 hint if none has yet been specified via SSL_set_tlsext_host_name\|(3).
\fBSSL_dane_tlsa_add() may then be called one or more times, to load each of the \s-1TLSA\s0 records that apply to the remote \s-1TLS\s0 peer. (This too must be done prior to the beginning of the \s-1SSL\s0 handshake). The arguments specify the fields of the \s-1TLSA\s0 record. The data field is provided in binary (wire \s-1RDATA\s0) form, not the hexadecimal \s-1ASCII\s0 presentation form, with an explicit length passed via dlen. The library takes a copy of the data buffer contents and the caller may free the original data buffer when convenient. A return value of 0 indicates that \*(L"unusable\*(R" \s-1TLSA\s0 records (with invalid or unsupported parameters) were provided. A negative return value indicates an internal error in processing the record.
The caller is expected to check the return value of each SSL_dane_tlsa_add() call and take appropriate action if none are usable or an internal error is encountered in processing some records.
If no \s-1TLSA\s0 records are added successfully, \s-1DANE\s0 authentication is not enabled, and authentication will be based on any configured traditional trust-anchors; authentication success in this case does not mean that the peer was DANE-authenticated.
\fBSSL_get0_dane_authority() can be used to get more detailed information about the matched \s-1DANE\s0 trust-anchor after successful connection completion. The return value is negative if \s-1DANE\s0 verification failed (or was not enabled), 0 if an \s-1EE TLSA\s0 record directly matched the leaf certificate, or a positive number indicating the depth at which a \s-1TA\s0 record matched an issuer certificate. The complete verified chain can be retrieved via SSL_get0_verified_chain\|(3). The return value is an index into this verified chain, rather than the list of certificates sent by the peer as returned by SSL_get_peer_cert_chain\|(3).
If the mcert argument is not \s-1NULL\s0 and a \s-1TLSA\s0 record matched a chain certificate, a pointer to the matching certificate is returned via mcert. The returned address is a short-term internal reference to the certificate and must not be freed by the application. Applications that want to retain access to the certificate can call \fBX509_up_ref\|(3) to obtain a long-term reference which must then be freed via \fBX509_free\|(3) once no longer needed.
If no \s-1TLSA\s0 records directly matched any elements of the certificate chain, but a \s-1DANE-TA\s0\|(2) \s-1SPKI\s0\|(1) Full\|(0) record provided the public key that signed an element of the chain, then that key is returned via mspki argument (if not \s-1NULL\s0). In this case the return value is the depth of the top-most element of the validated certificate chain. As with mcert this is a short-term internal reference, and \fBEVP_PKEY_up_ref\|(3) and EVP_PKEY_free\|(3) can be used to acquire and release long-term references respectively.
\fBSSL_get0_dane_tlsa() can be used to retrieve the fields of the \s-1TLSA\s0 record that matched the peer certificate chain. The return value indicates the match depth or failure to match just as with \fBSSL_get0_dane_authority(). When the return value is non-negative, the storage pointed to by the usage, \fBselector, mtype and data parameters is updated to the corresponding \s-1TLSA\s0 record fields. The data field is in binary wire form, and is therefore not NUL-terminated, its length is returned via the dlen parameter. If any of these parameters is \s-1NULL,\s0 the corresponding field is not returned. The data parameter is set to a short-term internal-copy of the associated data field and must not be freed by the application. Applications that need long-term access to this field need to copy the content.
\fBSSL_CTX_dane_set_flags() and SSL_dane_set_flags() can be used to enable optional \s-1DANE\s0 verification features. \fBSSL_CTX_dane_clear_flags() and SSL_dane_clear_flags() can be used to disable the same features. The flags argument is a bitmask of the features to enable or disable. The flags set for an \s-1SSL_CTX\s0 context are copied to each \s-1SSL\s0 handle associated with that context at the time the handle is created. Subsequent changes in the context's flags have no effect on the flags set for the handle.
At present, the only available option is \s-1DANE_FLAG_NO_DANE_EE_NAMECHECKS\s0 which can be used to disable server name checks when authenticating via \s-1DANE-EE\s0\|(3) \s-1TLSA\s0 records. For some applications, primarily web browsers, it is not safe to disable name checks due to \*(L"unknown key share\*(R" attacks, in which a malicious server can convince a client that a connection to a victim server is instead a secure connection to the malicious server. The malicious server may then be able to violate cross-origin scripting restrictions. Thus, despite the text of \s-1RFC7671,\s0 name checks are by default enabled for \s-1DANE-EE\s0\|(3) \s-1TLSA\s0 records, and can be disabled in applications where it is safe to do so. In particular, \s-1SMTP\s0 and \s-1XMPP\s0 clients should set this option as \s-1SRV\s0 and \s-1MX\s0 records already make it possible for a remote domain to redirect client connections to any server of its choice, and in any case \s-1SMTP\s0 and \s-1XMPP\s0 clients do not execute scripts downloaded from remote servers.
The functions SSL_get0_dane_authority() and SSL_get0_dane_tlsa() return a negative value when \s-1DANE\s0 authentication failed or was not enabled, a non-negative value indicates the chain depth at which the \s-1TLSA\s0 record matched a chain certificate, or the depth of the top-most certificate, when the \s-1TLSA\s0 record is a full public key that is its signer.
The functions SSL_CTX_dane_set_flags(), SSL_CTX_dane_clear_flags(), \fBSSL_dane_set_flags() and SSL_dane_clear_flags() return the flags in effect before they were called.
.Vb 7 SSL_CTX *ctx; SSL *ssl; int (*verify_cb)(int ok, X509_STORE_CTX *sctx) = NULL; int num_usable = 0; const char *nexthop_domain = "example.com"; const char *dane_tlsa_domain = "smtp.example.com"; uint8_t usage, selector, mtype; \& if ((ctx = SSL_CTX_new(TLS_client_method())) == NULL) /* error */ if (SSL_CTX_dane_enable(ctx) <= 0) /* error */ if ((ssl = SSL_new(ctx)) == NULL) /* error */ if (SSL_dane_enable(ssl, dane_tlsa_domain) <= 0) /* error */ \& /* * For many applications it is safe to skip DANE-EE(3) namechecks. Do not * disable the checks unless "unknown key share" attacks pose no risk for * your application. */ SSL_dane_set_flags(ssl, DANE_FLAG_NO_DANE_EE_NAMECHECKS); \& if (!SSL_add1_host(ssl, nexthop_domain)) /* error */ SSL_set_hostflags(ssl, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS); \& for (... each TLSA record ...) { unsigned char *data; size_t len; int ret; \& /* set usage, selector, mtype, data, len */ \& /* * Opportunistic DANE TLS clients support only DANE-TA(2) or DANE-EE(3). * They treat all other certificate usages, and in particular PKIX-TA(0) * and PKIX-EE(1), as unusable. */ switch (usage) { default: case 0: /* PKIX-TA(0) */ case 1: /* PKIX-EE(1) */ continue; case 2: /* DANE-TA(2) */ case 3: /* DANE-EE(3) */ break; } \& ret = SSL_dane_tlsa_add(ssl, usage, selector, mtype, data, len); /* free data as appropriate */ \& if (ret < 0) /* handle SSL library internal error */ else if (ret == 0) /* handle unusable TLSA record */ else ++num_usable; } \& /* * At this point, the verification mode is still the default SSL_VERIFY_NONE. * Opportunistic DANE clients use unauthenticated TLS when all TLSA records * are unusable, so continue the handshake even if authentication fails. */ if (num_usable == 0) { /* Log all records unusable? */ \& /* Optionally set verify_cb to a suitable non-NULL callback. */ SSL_set_verify(ssl, SSL_VERIFY_NONE, verify_cb); } else { /* At least one usable record. We expect to verify the peer */ \& /* Optionally set verify_cb to a suitable non-NULL callback. */ \& /* * Below we elect to fail the handshake when peer verification fails. * Alternatively, use the permissive SSL_VERIFY_NONE verification mode, * complete the handshake, check the verification status, and if not * verified disconnect gracefully at the application layer, especially if * application protocol supports informing the server that authentication * failed. */ SSL_set_verify(ssl, SSL_VERIFY_PEER, verify_cb); } \& /* * Load any saved session for resumption, making sure that the previous * session applied the same security and authentication requirements that * would be expected of a fresh connection. */ \& /* Perform SSL_connect() handshake and handle errors here */ \& if (SSL_session_reused(ssl)) { if (SSL_get_verify_result(ssl) == X509_V_OK) { /* * Resumed session was originally verified, this connection is * authenticated. */ } else { /* * Resumed session was not originally verified, this connection is not * authenticated. */ } } else if (SSL_get_verify_result(ssl) == X509_V_OK) { const char *peername = SSL_get0_peername(ssl); EVP_PKEY *mspki = NULL; \& int depth = SSL_get0_dane_authority(ssl, NULL, &mspki); if (depth >= 0) { (void) SSL_get0_dane_tlsa(ssl, &usage, &selector, &mtype, NULL, NULL); printf("DANE TLSA %d %d %d %s at depth %d\en", usage, selector, mtype, (mspki != NULL) ? "TA public key verified certificate" : depth ? "matched TA certificate" : "matched EE certificate", depth); } if (peername != NULL) { /* Name checks were in scope and matched the peername */ printf("Verified peername: %s\en", peername); } } else { /* * Not authenticated, presumably all TLSA rrs unusable, but possibly a * callback suppressed connection termination despite the presence of * usable TLSA RRs none of which matched. Do whatever is appropriate for * fresh unauthenticated connections. */ } .Ve
Such applications should generally treat any \s-1TLSA\s0 records published by the peer with usages \s-1PKIX-TA\s0\|(0) and \s-1PKIX-EE\s0\|(1) as \*(L"unusable\*(R", and should not include them among the \s-1TLSA\s0 records used to authenticate peer connections. In addition, some \s-1TLSA\s0 records with supported usages may be \*(L"unusable\*(R" as a result of invalid or unsupported parameters.
When a peer has \s-1TLSA\s0 records, but none are \*(L"usable\*(R", an opportunistic application must avoid cleartext, but cannot authenticate the peer, and so should generally proceed with an unauthenticated connection. Opportunistic applications need to note the return value of each call to SSL_dane_tlsa_add(), and if all return 0 (due to invalid or unsupported parameters) disable peer authentication by calling \fBSSL_set_verify\|(3) with mode equal to \s-1SSL_VERIFY_NONE\s0.
Licensed under the OpenSSL license (the \*(L"License\*(R"). You may not use this file except in compliance with the License. You can obtain a copy in the file \s-1LICENSE\s0 in the source distribution or at <https://www.openssl.org/source/license.html>.