tls.c File Reference

Go to the source code of this file.

Functions
asciichat_error_t	quic_tls_server_create (const char *alpn, const char *certificate_file, const char *private_key_file, quic_tls_t **out)
asciichat_error_t	quic_tls_client_create (const char *alpn, const char *ca_file, quic_tls_t **out)
asciichat_error_t	quic_tls_client_configure (quic_tls_t *tls, SSL *ssl, const char *server_name)
asciichat_error_t	quic_tls_session_create (quic_tls_t *tls, const char *server_name, ngtcp2_crypto_conn_ref *connection, SSL **out)
asciichat_error_t	quic_tls_verify_ready (quic_tls_t *tls, SSL *ssl)
void	quic_tls_session_destroy (SSL **ssl)
void	quic_tls_destroy (quic_tls_t **tls)

Function Documentation

quic_tls_client_configure()

asciichat_error_t quic_tls_client_configure	(	quic_tls_t *	tls,
		SSL *	ssl,
		const char *	server_name )

Configure certificate identity verification, SNI and ALPN on a client SSL.

Definition at line 112 of file tls.c.

                                                                                                {
  if (!tls || tls->server || !ssl || SSL_get_SSL_CTX(ssl) != tls->ssl_ctx || !server_name || !*server_name)
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC client requires the expected server identity");
  ERR_clear_error();
  X509_VERIFY_PARAM *verify = SSL_get0_param(ssl);
  X509_VERIFY_PARAM_set_hostflags(verify, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
  if (SSL_set_alpn_protos(ssl, tls->alpn, tls->alpn_length) != 0 ||
      (is_valid_ip(server_name)
           ? X509_VERIFY_PARAM_set1_ip_asc(verify, server_name) != 1
           : (SSL_set_tlsext_host_name(ssl, server_name) != 1 || SSL_set1_host(ssl, server_name) != 1)))
    return tls_error("Cannot configure QUIC server identity");
  return ASCIICHAT_OK;
}

References quic_tls_t::alpn, quic_tls_t::alpn_length, ASCIICHAT_OK, ERROR_INVALID_PARAM, is_valid_ip(), quic_tls_t::server, SET_ERRNO, and quic_tls_t::ssl_ctx.

Referenced by quic_tls_session_create().

quic_tls_client_create()

asciichat_error_t quic_tls_client_create	(	const char *	alpn,
		const char *	ca_file,
		quic_tls_t **	out )

Create a TLS 1.3 client context. NULL ca_file selects the system trust store.

Definition at line 90 of file tls.c.

                                                                                                  {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC client trust configuration");
  *out = NULL;
  if (ca_file && !*ca_file)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC client trust configuration");
  quic_tls_t *tls = NULL;
  asciichat_error_t result = create_context(false, alpn, &tls);
  if (result != ASCIICHAT_OK)
    return result;
  ERR_clear_error();
  int loaded = ca_file ? SSL_CTX_load_verify_locations(tls->ssl_ctx, ca_file, NULL)
                       : SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
  if (loaded != 1) {
    result = tls_error("Cannot load QUIC client trust roots");
    quic_tls_destroy(&tls);
    return result;
  }
  *out = tls;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, out, quic_tls_destroy(), SET_ERRNO, and quic_tls_t::ssl_ctx.

Referenced by quic_endpoint_open().

quic_tls_destroy()

void quic_tls_destroy

(

quic_tls_t **

tls

)

Definition at line 202 of file tls.c.

                                        {
  if (tls && *tls) {
    SSL_CTX_free((*tls)->ssl_ctx);
    SAFE_FREE(*tls);
  }
}

References SAFE_FREE.

Referenced by quic_endpoint_destroy(), quic_endpoint_open(), quic_tls_client_create(), and quic_tls_server_create().

quic_tls_server_create()

asciichat_error_t quic_tls_server_create	(	const char *	alpn,
		const char *	certificate_file,
		const char *	private_key_file,
		quic_tls_t **	out )

Create a TLS 1.3 server context. Certificate and key are copied by OpenSSL.

Definition at line 67 of file tls.c.

                                                           {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC server requires a certificate and private key");
  *out = NULL;
  if (!certificate_file || !*certificate_file || !private_key_file || !*private_key_file)
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC server requires a certificate and private key");
  quic_tls_t *tls = NULL;
  asciichat_error_t result = create_context(true, alpn, &tls);
  if (result != ASCIICHAT_OK)
    return result;
  ERR_clear_error();
  if (SSL_CTX_use_certificate_chain_file(tls->ssl_ctx, certificate_file) != 1 ||
      SSL_CTX_use_PrivateKey_file(tls->ssl_ctx, private_key_file, SSL_FILETYPE_PEM) != 1 ||
      SSL_CTX_check_private_key(tls->ssl_ctx) != 1) {
    result = tls_error("Cannot load QUIC server certificate or private key");
    quic_tls_destroy(&tls);
    return result;
  }
  *out = tls;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, out, quic_tls_destroy(), SET_ERRNO, and quic_tls_t::ssl_ctx.

Referenced by quic_endpoint_open().

quic_tls_session_create()

asciichat_error_t quic_tls_session_create	(	quic_tls_t *	tls,
		const char *	server_name,
		ngtcp2_crypto_conn_ref *	connection,
		SSL **	out )

The connection reference is borrowed and must remain valid while SSL uses it. The caller owns the SSL and must clear its app data before freeing it if the ngtcp2 connection or reference can have been destroyed first.

Definition at line 126 of file tls.c.

                                                     {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC TLS session arguments");
  *out = NULL;
  if (!tls || !tls->ssl_ctx || !connection || !connection->get_conn || (tls->server && server_name))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC TLS session arguments");
  ERR_clear_error();
  SSL *ssl = SSL_new(tls->ssl_ctx);
  if (!ssl)
    return tls_error("Cannot create QUIC TLS session");
  if (SSL_set_app_data(ssl, connection) != 1) {
    asciichat_error_t result = tls_error("Cannot attach QUIC connection to TLS session");
    SSL_free(ssl);
    return result;
  }
  asciichat_error_t result = ASCIICHAT_OK;
  if (tls->server) {
    SSL_set_accept_state(ssl);
    if (ngtcp2_crypto_ossl_configure_server_session(ssl) != 0)
      result = tls_error("Cannot configure server QUIC TLS callbacks");
  } else {
    SSL_set_connect_state(ssl);
    result = quic_tls_client_configure(tls, ssl, server_name);
    if (result == ASCIICHAT_OK && ngtcp2_crypto_ossl_configure_client_session(ssl) != 0)
      result = tls_error("Cannot configure client QUIC TLS callbacks");
  }
  if (result != ASCIICHAT_OK) {
    quic_tls_session_destroy(&ssl);
    return result;
  }
  *out = ssl;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, out, quic_tls_client_configure(), quic_tls_session_destroy(), quic_tls_t::server, SET_ERRNO, and quic_tls_t::ssl_ctx.

quic_tls_session_destroy()

void quic_tls_session_destroy

(

SSL **

ssl

)

Definition at line 194 of file tls.c.

                                         {
  if (ssl && *ssl) {
    SSL_set_app_data(*ssl, NULL);
    SSL_free(*ssl);
    *ssl = NULL;
  }
}

Referenced by quic_connection_destroy(), and quic_tls_session_create().

quic_tls_verify_ready()

asciichat_error_t quic_tls_verify_ready	(	quic_tls_t *	tls,
		SSL *	ssl )

Call after the TLS handshake and before exposing the connection as ready. Requires the configured ALPN; a client also requires a verified peer cert.

Definition at line 161 of file tls.c.

                                                                   {
  if (!tls || !ssl || SSL_get_SSL_CTX(ssl) != tls->ssl_ctx || !SSL_is_init_finished(ssl))
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC TLS handshake is not complete");
  const unsigned char *selected = NULL;
  unsigned int length = 0;
  SSL_get0_alpn_selected(ssl, &selected, &length);
  bool negotiated = false;
  for (size_t offset = 0; offset < tls->alpn_length;) {
    size_t protocol_length = tls->alpn[offset++];
    if (protocol_length > tls->alpn_length - offset)
      break;
    if (selected && protocol_length == (size_t)length && !memcmp(selected, tls->alpn + offset, protocol_length))
      negotiated = true;
    offset += protocol_length;
  }
  if (!negotiated)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "QUIC TLS ALPN was not negotiated");
  if (!tls->server) {
    X509_VERIFY_PARAM *verify = SSL_get0_param(ssl);
    const char *host = X509_VERIFY_PARAM_get0_host(verify, 0);
    char *ip = X509_VERIFY_PARAM_get1_ip_asc(verify);
    X509 *peer = SSL_get0_peer_certificate(ssl);
    bool identity_matches =
        peer && (host || ip) &&
        (!host || X509_check_host(peer, host, 0, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS, NULL) == 1) &&
        (!ip || X509_check_ip_asc(peer, ip, 0) == 1);
    OPENSSL_free(ip);
    if (!identity_matches || !(SSL_get_verify_mode(ssl) & SSL_VERIFY_PEER) || SSL_get_verify_result(ssl) != X509_V_OK)
      return SET_ERRNO(ERROR_CRYPTO, "QUIC TLS peer certificate or identity was not verified");
  }
  return ASCIICHAT_OK;
}

References quic_tls_t::alpn, quic_tls_t::alpn_length, ASCIICHAT_OK, ERROR_CRYPTO, ERROR_INVALID_STATE, ERROR_NETWORK_PROTOCOL, quic_tls_t::server, SET_ERRNO, and quic_tls_t::ssl_ctx.