LCOV - code coverage report
Current view: top level - src - tls_openssl.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 123 543 22.7 %
Date: 2024-02-24 14:12:49 Functions: 13 38 34.2 %

          Line data    Source code
       1             : /* SPDX-License-Identifier: MIT OR GPL-3.0-only */
       2             : /* tls_openssl.c
       3             : ** strophe XMPP client library -- TLS abstraction openssl impl.
       4             : **
       5             : ** Copyright (C) 2005-008 Collecta, Inc.
       6             : **
       7             : **  This software is provided AS-IS with no warranty, either express
       8             : **  or implied.
       9             : **
      10             : **  This program is dual licensed under the MIT or GPLv3 licenses.
      11             : */
      12             : 
      13             : /** @file
      14             :  *  TLS implementation with OpenSSL.
      15             :  */
      16             : 
      17             : #include <errno.h> /* EINTR */
      18             : #include <string.h>
      19             : 
      20             : #ifndef _WIN32
      21             : #include <sys/select.h>
      22             : #else
      23             : #include <winsock2.h>
      24             : #endif
      25             : 
      26             : #include <openssl/ssl.h>
      27             : #include <openssl/err.h>
      28             : #include <openssl/opensslv.h>
      29             : #include <openssl/x509v3.h>
      30             : #include <openssl/pkcs12.h>
      31             : 
      32             : #include "common.h"
      33             : #include "tls.h"
      34             : #include "sock.h"
      35             : 
      36             : /*
      37             :  * Redefine OPENSSL_VERSION_NUMBER for LibreSSL.
      38             :  * LibreSSL and OpenSSL use different and incompatible version schemes. Solve
      39             :  * this issue in the way how nginx project did.
      40             :  */
      41             : #if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
      42             : #undef OPENSSL_VERSION_NUMBER
      43             : #if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
      44             : #define OPENSSL_VERSION_NUMBER 0x1010000fL
      45             : #elif (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
      46             : #define OPENSSL_VERSION_NUMBER 0x1000200fL
      47             : #else
      48             : #define OPENSSL_VERSION_NUMBER 0x1000107fL
      49             : #endif
      50             : #endif
      51             : 
      52             : #if OPENSSL_VERSION_NUMBER < 0x30000000L
      53             : #define STROPHE_ERR_func_error_string(e) ERR_func_error_string(e)
      54             : #else
      55             : #define STROPHE_ERR_func_error_string(e) ""
      56             : #endif
      57             : 
      58             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
      59             : static const unsigned char *ASN1_STRING_get0_data(ASN1_STRING *asn1)
      60             : {
      61             :     return ASN1_STRING_data(asn1);
      62             : }
      63             : #endif
      64             : 
      65             : #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined LIBRESSL_VERSION_NUMBER
      66             : static int SSL_CTX_use_cert_and_key(SSL_CTX *ctx,
      67             :                                     X509 *x509,
      68             :                                     EVP_PKEY *privatekey,
      69             :                                     STACK_OF(X509) * chain,
      70             :                                     int override)
      71             : {
      72             :     UNUSED(override);
      73             :     if (!ctx)
      74             :         return 0;
      75             :     if (x509 && !SSL_CTX_use_certificate(ctx, x509))
      76             :         return 0;
      77             :     if (privatekey && !SSL_CTX_use_PrivateKey(ctx, privatekey))
      78             :         return 0;
      79             : #ifdef SSL_CTX_set1_chain
      80             :     if (chain && !SSL_CTX_set1_chain(ctx, chain))
      81             :         return 0;
      82             : #else
      83             :     UNUSED(chain);
      84             : #endif
      85             :     return 1;
      86             : }
      87             : #endif
      88             : 
      89             : #if OPENSSL_VERSION_NUMBER < 0x10000000L
      90             : static int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
      91             :                                        ASN1_OBJECT **poid,
      92             :                                        ASN1_TYPE **pvalue)
      93             : {
      94             :     if (gen->type != GEN_OTHERNAME)
      95             :         return 0;
      96             :     if (poid)
      97             :         *poid = gen->d.otherName->type_id;
      98             :     if (pvalue)
      99             :         *pvalue = gen->d.otherName->value;
     100             :     return 1;
     101             : }
     102             : #endif
     103             : 
     104             : struct _tls {
     105             :     xmpp_ctx_t *ctx;
     106             :     sock_t sock;
     107             :     SSL_CTX *ssl_ctx;
     108             :     SSL *ssl;
     109             :     X509 *client_cert;
     110             :     void *channel_binding_data;
     111             :     size_t channel_binding_size;
     112             :     int lasterror;
     113             : };
     114             : 
     115             : enum {
     116             :     TLS_SHUTDOWN_MAX_RETRIES = 10,
     117             :     TLS_TIMEOUT_SEC = 0,
     118             :     TLS_TIMEOUT_USEC = 100000,
     119             : };
     120             : 
     121             : static void _tls_sock_wait(tls_t *tls, int error);
     122             : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size);
     123             : static void _tls_set_error(tls_t *tls, int error);
     124             : static void _tls_log_error(xmpp_ctx_t *ctx);
     125             : static void _tls_dump_cert_info(tls_t *tls);
     126             : static X509 *_tls_cert_read(xmpp_conn_t *conn);
     127             : static X509 *
     128             : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca);
     129             : static int _tls_xaddr_nid(void);
     130             : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res);
     131             : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res);
     132             : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn);
     133             : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert);
     134             : 
     135             : #define TLS_ERROR_STR(error, table) \
     136             :     _tls_error_str(error, table, ARRAY_SIZE(table))
     137             : 
     138             : #define TLS_ERROR_FIELD(x) [x] = #x
     139             : const char *tls_errors[] = {
     140             :     TLS_ERROR_FIELD(SSL_ERROR_NONE),
     141             :     TLS_ERROR_FIELD(SSL_ERROR_SSL),
     142             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_READ),
     143             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_WRITE),
     144             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_X509_LOOKUP),
     145             :     TLS_ERROR_FIELD(SSL_ERROR_SYSCALL),
     146             :     TLS_ERROR_FIELD(SSL_ERROR_ZERO_RETURN),
     147             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_CONNECT),
     148             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ACCEPT),
     149             : #ifndef LIBRESSL_VERSION_NUMBER
     150             : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
     151             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC),
     152             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC_JOB),
     153             : #endif
     154             : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     155             :     TLS_ERROR_FIELD(SSL_ERROR_WANT_CLIENT_HELLO_CB),
     156             : #endif
     157             : #endif /* !LIBRESSL_VERSION_NUMBER */
     158             : };
     159             : const char *cert_errors[] = {
     160             :     TLS_ERROR_FIELD(X509_V_OK),
     161             : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     162             :     TLS_ERROR_FIELD(X509_V_ERR_UNSPECIFIED),
     163             : #endif
     164             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT),
     165             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL),
     166             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE),
     167             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE),
     168             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY),
     169             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_SIGNATURE_FAILURE),
     170             :     TLS_ERROR_FIELD(X509_V_ERR_CRL_SIGNATURE_FAILURE),
     171             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_NOT_YET_VALID),
     172             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_HAS_EXPIRED),
     173             :     TLS_ERROR_FIELD(X509_V_ERR_CRL_NOT_YET_VALID),
     174             :     TLS_ERROR_FIELD(X509_V_ERR_CRL_HAS_EXPIRED),
     175             :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD),
     176             :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD),
     177             :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD),
     178             :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD),
     179             :     TLS_ERROR_FIELD(X509_V_ERR_OUT_OF_MEM),
     180             :     TLS_ERROR_FIELD(X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT),
     181             :     TLS_ERROR_FIELD(X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN),
     182             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY),
     183             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE),
     184             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_CHAIN_TOO_LONG),
     185             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_REVOKED),
     186             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_CA),
     187             :     TLS_ERROR_FIELD(X509_V_ERR_PATH_LENGTH_EXCEEDED),
     188             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_PURPOSE),
     189             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_UNTRUSTED),
     190             :     TLS_ERROR_FIELD(X509_V_ERR_CERT_REJECTED),
     191             :     TLS_ERROR_FIELD(X509_V_ERR_SUBJECT_ISSUER_MISMATCH),
     192             :     TLS_ERROR_FIELD(X509_V_ERR_AKID_SKID_MISMATCH),
     193             :     TLS_ERROR_FIELD(X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH),
     194             :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CERTSIGN),
     195             :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER),
     196             :     TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION),
     197             :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CRL_SIGN),
     198             :     TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION),
     199             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_NON_CA),
     200             :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED),
     201             :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE),
     202             :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED),
     203             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_EXTENSION),
     204             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_POLICY_EXTENSION),
     205             :     TLS_ERROR_FIELD(X509_V_ERR_NO_EXPLICIT_POLICY),
     206             :     TLS_ERROR_FIELD(X509_V_ERR_APPLICATION_VERIFICATION),
     207             : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     208             :     TLS_ERROR_FIELD(X509_V_ERR_DIFFERENT_CRL_SCOPE),
     209             :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE),
     210             :     TLS_ERROR_FIELD(X509_V_ERR_UNNESTED_RESOURCE),
     211             :     TLS_ERROR_FIELD(X509_V_ERR_PERMITTED_VIOLATION),
     212             :     TLS_ERROR_FIELD(X509_V_ERR_EXCLUDED_VIOLATION),
     213             :     TLS_ERROR_FIELD(X509_V_ERR_SUBTREE_MINMAX),
     214             :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE),
     215             :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX),
     216             :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_NAME_SYNTAX),
     217             :     TLS_ERROR_FIELD(X509_V_ERR_CRL_PATH_VALIDATION_ERROR),
     218             : #ifndef LIBRESSL_VERSION_NUMBER
     219             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_VERSION),
     220             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_ALGORITHM),
     221             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_CURVE),
     222             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM),
     223             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED),
     224             :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256),
     225             : #endif /* !LIBRESSL_VERSION_NUMBER */
     226             :     TLS_ERROR_FIELD(X509_V_ERR_HOSTNAME_MISMATCH),
     227             :     TLS_ERROR_FIELD(X509_V_ERR_EMAIL_MISMATCH),
     228             :     TLS_ERROR_FIELD(X509_V_ERR_IP_ADDRESS_MISMATCH),
     229             : #endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
     230             : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
     231             :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_CALL),
     232             :     TLS_ERROR_FIELD(X509_V_ERR_STORE_LOOKUP),
     233             : #ifndef LIBRESSL_VERSION_NUMBER
     234             :     TLS_ERROR_FIELD(X509_V_ERR_PATH_LOOP),
     235             :     TLS_ERROR_FIELD(X509_V_ERR_DANE_NO_MATCH),
     236             :     TLS_ERROR_FIELD(X509_V_ERR_EE_KEY_TOO_SMALL),
     237             :     TLS_ERROR_FIELD(X509_V_ERR_CA_KEY_TOO_SMALL),
     238             :     TLS_ERROR_FIELD(X509_V_ERR_CA_MD_TOO_WEAK),
     239             :     TLS_ERROR_FIELD(X509_V_ERR_NO_VALID_SCTS),
     240             :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION),
     241             : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     242             :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_NEEDED),
     243             :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_FAILED),
     244             :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_CERT_UNKNOWN),
     245             : #endif /* OPENSSL_VERSION_NUMBER >= 0x10101000L */
     246             : #endif /* !LIBRESSL_VERSION_NUMBER */
     247             : #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
     248             : };
     249             : #undef TLS_ERROR_FIELD
     250             : 
     251           2 : void tls_initialize(void)
     252             : {
     253             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     254             :     SSL_library_init();
     255             :     SSL_load_error_strings();
     256             : #else
     257           2 :     OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL);
     258             : #endif
     259             :     /* init xmppAddr OID */
     260           2 :     _tls_xaddr_nid();
     261           2 : }
     262             : 
     263           2 : void tls_shutdown(void)
     264             : {
     265             :     /*
     266             :      * FIXME: Don't free global tables, program or other libraries may use
     267             :      * openssl after libstrophe finalization. Maybe better leak some fixed
     268             :      * memory rather than cause random crashes of the main program.
     269             :      */
     270             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     271             :     OBJ_cleanup();
     272             :     ERR_free_strings();
     273             :     EVP_cleanup();
     274             :     CRYPTO_cleanup_all_ex_data();
     275             : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     276             :     SSL_COMP_free_compression_methods();
     277             : #endif
     278             : #if OPENSSL_VERSION_NUMBER < 0x10000000L
     279             :     ERR_remove_state(0);
     280             : #else
     281             :     ERR_remove_thread_state(NULL);
     282             : #endif
     283             : #endif
     284           2 : }
     285             : 
     286           0 : int tls_error(struct conn_interface *intf)
     287             : {
     288           0 :     return intf->conn->tls->lasterror;
     289             : }
     290             : 
     291             : /** Search through the SubjectAlternativeNames and return the next
     292             :  *  id-on-xmppAddr element starting from `n`.
     293             :  */
     294          24 : char *tls_id_on_xmppaddr(xmpp_conn_t *conn, unsigned int n)
     295             : {
     296          24 :     char *ret = NULL;
     297          24 :     int i, j;
     298          24 :     GENERAL_NAMES *names = _tls_conn_get_names(conn);
     299          24 :     if (!names) {
     300           0 :         _tls_log_error(conn->ctx);
     301           0 :         return NULL;
     302             :     }
     303          24 :     int num_names = sk_GENERAL_NAME_num(names);
     304          80 :     for (i = j = 0; i < num_names; ++i) {
     305          72 :         char *res;
     306          72 :         GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
     307          72 :         if (name == NULL)
     308             :             break;
     309          72 :         if (_tls_xmppaddr_to_string(name, &res))
     310          32 :             continue;
     311          40 :         if (j == (int)n) {
     312          16 :             strophe_debug(conn->ctx, "tls",
     313             :                           "extracted jid %s from id-on-xmppAddr", res);
     314          16 :             ret = strophe_strdup(conn->ctx, res);
     315          16 :             OPENSSL_free(res);
     316             :             break;
     317             :         }
     318          24 :         j++;
     319          24 :         OPENSSL_free(res);
     320             :     }
     321          24 :     GENERAL_NAMES_free(names);
     322          24 :     return ret;
     323             : }
     324             : 
     325           8 : unsigned int tls_id_on_xmppaddr_num(xmpp_conn_t *conn)
     326             : {
     327           8 :     unsigned int ret = 0;
     328           8 :     GENERAL_NAMES *names = _tls_conn_get_names(conn);
     329           8 :     if (!names) {
     330           0 :         _tls_log_error(conn->ctx);
     331           0 :         return 0;
     332             :     }
     333           8 :     int j, num_names = sk_GENERAL_NAME_num(names);
     334          40 :     for (j = 0; j < num_names; ++j) {
     335          32 :         GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
     336          32 :         if (_tls_xmppaddr_to_string(name, NULL))
     337             :             continue;
     338          16 :         ret++;
     339             :     }
     340           8 :     GENERAL_NAMES_free(names);
     341           8 :     return ret;
     342             : }
     343             : 
     344           0 : static int _convert_ASN1TIME(ASN1_TIME *ansi_time, char *buf, size_t len)
     345             : {
     346           0 :     BIO *bio = BIO_new(BIO_s_mem());
     347           0 :     int rc = ASN1_TIME_print(bio, ansi_time);
     348           0 :     if (rc <= 0) {
     349           0 :         BIO_free(bio);
     350           0 :         return 0;
     351             :     }
     352           0 :     rc = BIO_gets(bio, buf, len);
     353           0 :     if (rc <= 0) {
     354           0 :         BIO_free(bio);
     355           0 :         return 0;
     356             :     }
     357           0 :     BIO_free(bio);
     358           0 :     return 1;
     359             : }
     360             : 
     361           0 : static char *_asn1_time_to_str(const xmpp_ctx_t *ctx, ASN1_TIME *t)
     362             : {
     363           0 :     char buf[128];
     364           0 :     int res = _convert_ASN1TIME(t, buf, sizeof(buf));
     365           0 :     if (res) {
     366           0 :         return strophe_strdup(ctx, buf);
     367             :     }
     368             :     return NULL;
     369             : }
     370             : 
     371             : static char *
     372           0 : _get_fingerprint(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
     373             : {
     374           0 :     unsigned char buf[EVP_MAX_MD_SIZE];
     375           0 :     unsigned int len;
     376           0 :     const EVP_MD *digest;
     377           0 :     switch (el) {
     378           0 :     case XMPP_CERT_FINGERPRINT_SHA1:
     379           0 :         digest = EVP_sha1();
     380             :         break;
     381           0 :     case XMPP_CERT_FINGERPRINT_SHA256:
     382           0 :         digest = EVP_sha256();
     383             :         break;
     384             :     default:
     385           0 :         return NULL;
     386             :     }
     387           0 :     if (X509_digest(err_cert, digest, buf, &len) != 0) {
     388           0 :         char fingerprint[4 * EVP_MAX_MD_SIZE];
     389           0 :         hex_encode(fingerprint, buf, len);
     390           0 :         return strophe_strdup(ctx, fingerprint);
     391             :     }
     392             :     return NULL;
     393             : }
     394             : 
     395             : static char *
     396           0 : _get_alg(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
     397             : {
     398           0 :     int alg_nid = NID_undef;
     399             : 
     400           0 :     switch (el) {
     401           0 :     case XMPP_CERT_KEYALG: {
     402             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     403             :         alg_nid = OBJ_obj2nid(err_cert->cert_info->key->algor->algorithm);
     404             : #else
     405           0 :         X509_PUBKEY *pubkey = X509_get_X509_PUBKEY(err_cert);
     406           0 :         ASN1_OBJECT *ppkalg = NULL;
     407           0 :         if (X509_PUBKEY_get0_param(&ppkalg, NULL, NULL, NULL, pubkey)) {
     408           0 :             alg_nid = OBJ_obj2nid(ppkalg);
     409             :         }
     410             : #endif
     411           0 :     } break;
     412           0 :     case XMPP_CERT_SIGALG: {
     413             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     414             :         alg_nid = OBJ_obj2nid(err_cert->sig_alg->algorithm);
     415             : #else
     416           0 :         const X509_ALGOR *palg;
     417           0 :         const ASN1_OBJECT *obj;
     418           0 :         X509_get0_signature(NULL, &palg, err_cert);
     419           0 :         X509_ALGOR_get0(&obj, NULL, NULL, palg);
     420           0 :         alg_nid = OBJ_obj2nid(obj);
     421             : #endif
     422           0 :     } break;
     423             :     default:
     424             :         break;
     425             :     }
     426           0 :     if (alg_nid != NID_undef) {
     427           0 :         const char *alg = OBJ_nid2ln(alg_nid);
     428           0 :         if (alg) {
     429           0 :             return strophe_strdup(ctx, alg);
     430             :         }
     431             :     }
     432             :     return NULL;
     433             : }
     434             : 
     435           0 : static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, X509 *cert)
     436             : {
     437           0 :     char *subject, *issuer, buf[32];
     438           0 :     xmpp_tlscert_t *tlscert = tlscert_new(ctx);
     439           0 :     if (!tlscert)
     440           0 :         return NULL;
     441             : 
     442           0 :     BIO *b = BIO_new(BIO_s_mem());
     443           0 :     if (!b)
     444             :         goto error_out;
     445           0 :     PEM_write_bio_X509(b, cert);
     446           0 :     BUF_MEM *bptr;
     447           0 :     BIO_get_mem_ptr(b, &bptr);
     448           0 :     tlscert->pem = strophe_alloc(ctx, bptr->length + 1);
     449           0 :     if (!tlscert->pem)
     450             :         goto error_out;
     451           0 :     memcpy(tlscert->pem, bptr->data, bptr->length);
     452           0 :     tlscert->pem[bptr->length] = '\0';
     453           0 :     BIO_free(b);
     454             : 
     455           0 :     subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
     456           0 :     if (!subject)
     457             :         goto error_out;
     458           0 :     tlscert->elements[XMPP_CERT_SUBJECT] = strophe_strdup(ctx, subject);
     459           0 :     OPENSSL_free(subject);
     460           0 :     issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
     461           0 :     if (!issuer)
     462             :         goto error_out;
     463           0 :     tlscert->elements[XMPP_CERT_ISSUER] = strophe_strdup(ctx, issuer);
     464           0 :     OPENSSL_free(issuer);
     465             : 
     466           0 :     tlscert->elements[XMPP_CERT_NOTBEFORE] =
     467           0 :         _asn1_time_to_str(ctx, X509_get_notBefore(cert));
     468           0 :     tlscert->elements[XMPP_CERT_NOTAFTER] =
     469           0 :         _asn1_time_to_str(ctx, X509_get_notAfter(cert));
     470             : 
     471           0 :     tlscert->elements[XMPP_CERT_FINGERPRINT_SHA1] =
     472           0 :         _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA1);
     473           0 :     tlscert->elements[XMPP_CERT_FINGERPRINT_SHA256] =
     474           0 :         _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA256);
     475             : 
     476           0 :     strophe_snprintf(buf, sizeof(buf), "%ld", X509_get_version(cert) + 1);
     477           0 :     tlscert->elements[XMPP_CERT_VERSION] = strophe_strdup(ctx, buf);
     478             : 
     479           0 :     tlscert->elements[XMPP_CERT_KEYALG] = _get_alg(ctx, cert, XMPP_CERT_KEYALG);
     480           0 :     tlscert->elements[XMPP_CERT_SIGALG] = _get_alg(ctx, cert, XMPP_CERT_SIGALG);
     481             : 
     482           0 :     ASN1_INTEGER *serial = X509_get_serialNumber(cert);
     483           0 :     BIGNUM *bn = ASN1_INTEGER_to_BN(serial, NULL);
     484           0 :     if (bn) {
     485           0 :         char *serialnumber = BN_bn2hex(bn);
     486           0 :         if (serialnumber) {
     487           0 :             tlscert->elements[XMPP_CERT_SERIALNUMBER] =
     488           0 :                 strophe_strdup(ctx, serialnumber);
     489           0 :             OPENSSL_free(serialnumber);
     490             :         }
     491           0 :         BN_free(bn);
     492             :     }
     493             : 
     494           0 :     GENERAL_NAMES *names = _tls_cert_get_names(cert);
     495           0 :     if (names) {
     496           0 :         int j, num_names = sk_GENERAL_NAME_num(names);
     497             :         size_t n = 0;
     498           0 :         for (j = 0; j < num_names; ++j) {
     499           0 :             char *res;
     500           0 :             GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
     501           0 :             if (_tls_dnsname_to_string(name, &res))
     502           0 :                 continue;
     503           0 :             if (tlscert_add_dnsname(tlscert, res))
     504           0 :                 strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n,
     505             :                               res);
     506           0 :             n++;
     507           0 :             OPENSSL_free(res);
     508             :         }
     509           0 :         GENERAL_NAMES_free(names);
     510             :     }
     511             : 
     512             :     return tlscert;
     513           0 : error_out:
     514           0 :     xmpp_tlscert_free(tlscert);
     515             :     return NULL;
     516             : }
     517             : 
     518           0 : static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
     519             : {
     520           0 :     if (preverify_ok == 1)
     521             :         return 1;
     522             : 
     523           0 :     SSL *ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
     524             :                                           SSL_get_ex_data_X509_STORE_CTX_idx());
     525           0 :     xmpp_conn_t *conn = SSL_get_app_data(ssl);
     526             : 
     527           0 :     if (!conn->certfail_handler) {
     528           0 :         strophe_error(conn->ctx, "tls",
     529             :                       "No certfail handler set, canceling connection attempt");
     530           0 :         return 0;
     531             :     }
     532             : 
     533           0 :     X509 *err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
     534             : 
     535           0 :     xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, err_cert);
     536             : 
     537           0 :     if (!tlscert)
     538             :         return 0;
     539             : 
     540           0 :     strophe_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
     541             :                   preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
     542             :                   tlscert->elements[XMPP_CERT_ISSUER]);
     543             : 
     544           0 :     int ret = conn->certfail_handler(
     545             :         tlscert,
     546           0 :         X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx)));
     547             : 
     548           0 :     xmpp_tlscert_free(tlscert);
     549             : 
     550           0 :     return ret;
     551             : }
     552             : 
     553           8 : static int _tls_password_callback(char *buf, int size, int rwflag, void *u)
     554             : {
     555           8 :     UNUSED(rwflag);
     556           8 :     return tls_caching_password_callback(buf, size, u);
     557             : }
     558             : 
     559           0 : tls_t *tls_new(xmpp_conn_t *conn)
     560             : {
     561           0 :     tls_t *tls = strophe_alloc(conn->ctx, sizeof(*tls));
     562             : 
     563           0 :     if (tls) {
     564           0 :         int ret;
     565             : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     566             :         /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
     567           0 :         X509_VERIFY_PARAM *param;
     568             : #endif
     569           0 :         memset(tls, 0, sizeof(*tls));
     570             : 
     571           0 :         tls->ctx = conn->ctx;
     572           0 :         tls->sock = conn->sock;
     573             : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     574             :         tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
     575             : #else
     576           0 :         tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
     577             : #endif
     578           0 :         if (tls->ssl_ctx == NULL)
     579             :             goto err;
     580             : 
     581             :         /* Enable bug workarounds. */
     582           0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
     583             : 
     584             :         /* Disable insecure SSL/TLS versions. */
     585           0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv2); /* DROWN */
     586           0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv3); /* POODLE */
     587           0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_TLSv1); /* BEAST */
     588             : 
     589           0 :         if (conn->password_callback) {
     590           0 :             SSL_CTX_set_default_passwd_cb(tls->ssl_ctx, _tls_password_callback);
     591           0 :             SSL_CTX_set_default_passwd_cb_userdata(tls->ssl_ctx, conn);
     592             :         }
     593             : 
     594           0 :         if (conn->tls_client_cert && conn->tls_client_key) {
     595           0 :             unsigned int retries = 0;
     596           0 :             tls->client_cert = _tls_cert_read(conn);
     597           0 :             if (!tls->client_cert) {
     598           0 :                 strophe_error(tls->ctx, "tls",
     599             :                               "could not read client certificate");
     600           0 :                 goto err_free_ctx;
     601             :             }
     602             : 
     603           0 :             SSL_CTX_use_certificate_file(tls->ssl_ctx, conn->tls_client_cert,
     604             :                                          SSL_FILETYPE_PEM);
     605           0 :             while (retries++ < conn->password_retries) {
     606           0 :                 if (SSL_CTX_use_PrivateKey_file(
     607           0 :                         tls->ssl_ctx, conn->tls_client_key, SSL_FILETYPE_PEM)) {
     608             :                     break;
     609             :                 }
     610           0 :                 tls_clear_password_cache(conn);
     611           0 :                 unsigned long err = ERR_peek_error();
     612           0 :                 if ((ERR_GET_LIB(err) == ERR_LIB_EVP &&
     613           0 :                      ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) ||
     614           0 :                     (ERR_GET_LIB(err) == ERR_LIB_PEM &&
     615           0 :                      ERR_GET_REASON(err) == PEM_R_BAD_DECRYPT)) {
     616           0 :                     strophe_debug(tls->ctx, "tls", "wrong password?");
     617           0 :                     continue;
     618             :                 }
     619           0 :                 strophe_error(tls->ctx, "tls",
     620             :                               "could not use private key %d %d",
     621           0 :                               ERR_GET_LIB(err), ERR_GET_REASON(err));
     622           0 :                 goto err_free_ctx;
     623             :             }
     624           0 :         } else if (conn->tls_client_cert) {
     625           0 :             EVP_PKEY *pkey = NULL;
     626           0 :             STACK_OF(X509) *ca = NULL;
     627           0 :             X509 *cert = _tls_cert_read_p12(conn, &pkey, &ca);
     628           0 :             if (!cert) {
     629           0 :                 goto err_free_ctx;
     630             :             }
     631             : 
     632           0 :             SSL_CTX_use_cert_and_key(tls->ssl_ctx, cert, pkey, ca, 1);
     633             : 
     634           0 :             if (pkey)
     635           0 :                 EVP_PKEY_free(pkey);
     636           0 :             if (ca)
     637           0 :                 sk_X509_pop_free(ca, X509_free);
     638           0 :             tls->client_cert = cert;
     639             :         } else {
     640             :             /* If the server asks for a client certificate, don't send one. */
     641           0 :             SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
     642             :         }
     643             : 
     644           0 :         SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
     645             : 
     646           0 :         ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
     647           0 :         if (ret == 0 && !conn->tls_trust) {
     648             :             /*
     649             :              * Returns 1 on success and 0 on failure. A missing default
     650             :              * location is still treated as a success.
     651             :              * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
     652             :              */
     653           0 :             strophe_error(tls->ctx, "tls",
     654             :                           "SSL_CTX_set_default_verify_paths() failed");
     655           0 :             goto err_free_cert;
     656             :         }
     657             : 
     658           0 :         if (conn->tls_cafile || conn->tls_capath) {
     659           0 :             if (SSL_CTX_load_verify_locations(tls->ssl_ctx, conn->tls_cafile,
     660           0 :                                               conn->tls_capath) == 0) {
     661           0 :                 strophe_error(tls->ctx, "tls",
     662             :                               "SSL_CTX_load_verify_locations() failed");
     663           0 :                 goto err_free_cert;
     664             :             }
     665             :         }
     666             : 
     667           0 :         tls->ssl = SSL_new(tls->ssl_ctx);
     668           0 :         if (tls->ssl == NULL)
     669             :             goto err_free_cert;
     670             : 
     671             : #if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
     672             :         /* Enable SNI. */
     673           0 :         SSL_set_tlsext_host_name(tls->ssl, conn->domain);
     674             : #endif
     675             : 
     676             :         /* Trust server's certificate when user sets the flag explicitly.
     677             :          * Otherwise call the verification callback */
     678           0 :         if (conn->tls_trust)
     679           0 :             SSL_set_verify(tls->ssl, SSL_VERIFY_NONE, NULL);
     680             :         else
     681           0 :             SSL_set_verify(tls->ssl, SSL_VERIFY_PEER, _tls_verify);
     682           0 :         SSL_set_app_data(tls->ssl, conn);
     683             : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     684             :         /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
     685           0 :         param = SSL_get0_param(tls->ssl);
     686             : 
     687             :         /*
     688             :          * Allow only complete wildcards.  RFC 6125 discourages wildcard usage
     689             :          * completely, and lists internationalized domain names as a reason
     690             :          * against partial wildcards.
     691             :          * See https://tools.ietf.org/html/rfc6125#section-7.2 for more
     692             :          * information.
     693             :          */
     694           0 :         X509_VERIFY_PARAM_set_hostflags(param,
     695             :                                         X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
     696           0 :         X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
     697             : #endif
     698             : 
     699           0 :         ret = SSL_set_fd(tls->ssl, conn->sock);
     700           0 :         if (ret <= 0)
     701           0 :             goto err_free_ssl;
     702             :     }
     703             : 
     704             :     return tls;
     705             : 
     706           0 : err_free_ssl:
     707           0 :     SSL_free(tls->ssl);
     708           0 : err_free_cert:
     709           0 :     X509_free(tls->client_cert);
     710           0 : err_free_ctx:
     711           0 :     SSL_CTX_free(tls->ssl_ctx);
     712           0 : err:
     713           0 :     strophe_free(conn->ctx, tls);
     714           0 :     _tls_log_error(conn->ctx);
     715           0 :     return NULL;
     716             : }
     717             : 
     718           0 : void tls_free(tls_t *tls)
     719             : {
     720           0 :     strophe_free(tls->ctx, tls->channel_binding_data);
     721           0 :     SSL_free(tls->ssl);
     722           0 :     X509_free(tls->client_cert);
     723           0 :     SSL_CTX_free(tls->ssl_ctx);
     724           0 :     strophe_free(tls->ctx, tls);
     725           0 : }
     726             : 
     727           0 : xmpp_tlscert_t *tls_peer_cert(xmpp_conn_t *conn)
     728             : {
     729           0 :     if (conn && conn->tls && conn->tls->ssl) {
     730           0 :         X509 *cert = SSL_get_peer_certificate(conn->tls->ssl);
     731           0 :         if (cert) {
     732           0 :             xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, cert);
     733           0 :             X509_free(cert);
     734           0 :             return tlscert;
     735             :         }
     736             :     }
     737             :     return NULL;
     738             : }
     739             : 
     740           0 : int tls_set_credentials(tls_t *tls, const char *cafilename)
     741             : {
     742           0 :     UNUSED(tls);
     743           0 :     UNUSED(cafilename);
     744           0 :     return -1;
     745             : }
     746             : 
     747           0 : int tls_init_channel_binding(tls_t *tls,
     748             :                              const char **binding_prefix,
     749             :                              size_t *binding_prefix_len)
     750             : {
     751           0 :     const char *label = NULL;
     752           0 :     size_t labellen = 0;
     753           0 :     int ssl_version = SSL_version(tls->ssl);
     754             : 
     755           0 :     switch (ssl_version) {
     756           0 :     case SSL3_VERSION:
     757           0 :         *binding_prefix = "tls-unique";
     758           0 :         *binding_prefix_len = strlen("tls-unique");
     759           0 :         tls->channel_binding_size = 36;
     760           0 :         break;
     761           0 :     case TLS1_VERSION:
     762             :     case TLS1_1_VERSION:
     763             :     case TLS1_2_VERSION:
     764           0 :         *binding_prefix = "tls-unique";
     765           0 :         *binding_prefix_len = strlen("tls-unique");
     766           0 :         tls->channel_binding_size = 12;
     767           0 :         break;
     768             : #ifdef TLS1_3_VERSION
     769           0 :     case TLS1_3_VERSION:
     770           0 :         label = "EXPORTER-Channel-Binding";
     771           0 :         labellen = 24;
     772           0 :         *binding_prefix = "tls-exporter";
     773           0 :         *binding_prefix_len = strlen("tls-exporter");
     774           0 :         tls->channel_binding_size = 32;
     775           0 :         break;
     776             : #endif
     777           0 :     default:
     778           0 :         strophe_error(tls->ctx, "tls", "Unsupported TLS/SSL Version: %s",
     779           0 :                       SSL_get_version(tls->ssl));
     780           0 :         return -1;
     781             :     }
     782             : 
     783           0 :     strophe_free_and_null(tls->ctx, tls->channel_binding_data);
     784           0 :     tls->channel_binding_data =
     785           0 :         strophe_alloc(tls->ctx, tls->channel_binding_size);
     786           0 :     if (!tls->channel_binding_data)
     787             :         return -1;
     788             : 
     789           0 :     if (ssl_version <= TLS1_2_VERSION) {
     790           0 :         size_t len;
     791           0 :         if (SSL_session_reused(tls->ssl)) {
     792           0 :             len = SSL_get_peer_finished(tls->ssl, tls->channel_binding_data,
     793             :                                         tls->channel_binding_size);
     794             :         } else {
     795           0 :             len = SSL_get_finished(tls->ssl, tls->channel_binding_data,
     796             :                                    tls->channel_binding_size);
     797             :         }
     798           0 :         if (len != tls->channel_binding_size) {
     799           0 :             strophe_error(tls->ctx, "tls",
     800             :                           "Got channel binding data of wrong size %zu", len);
     801           0 :             return -1;
     802             :         }
     803             :     } else {
     804           0 :         if (SSL_export_keying_material(tls->ssl, tls->channel_binding_data,
     805             :                                        tls->channel_binding_size, label,
     806             :                                        labellen, NULL, 0, 0) != 1) {
     807           0 :             strophe_error(tls->ctx, "tls",
     808             :                           "Could not get channel binding data");
     809           0 :             return -1;
     810             :         }
     811             :     }
     812             :     return 0;
     813             : }
     814             : 
     815           0 : const void *tls_get_channel_binding_data(tls_t *tls, size_t *size)
     816             : {
     817           0 :     if (!tls->channel_binding_data || !tls->channel_binding_size) {
     818           0 :         strophe_error(tls->ctx, "tls", "No channel binding data available");
     819             :     }
     820           0 :     *size = tls->channel_binding_size;
     821           0 :     return tls->channel_binding_data;
     822             : }
     823             : 
     824           0 : int tls_start(tls_t *tls)
     825             : {
     826           0 :     int error;
     827           0 :     int ret;
     828           0 :     long x509_res;
     829             : 
     830             :     /* Since we're non-blocking, loop the connect call until it
     831             :        succeeds or fails */
     832           0 :     while (1) {
     833           0 :         ret = SSL_connect(tls->ssl);
     834           0 :         error = ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0;
     835             : 
     836           0 :         if (ret == -1 && tls_is_recoverable(NULL, error)) {
     837             :             /* wait for something to happen on the sock before looping back */
     838           0 :             _tls_sock_wait(tls, error);
     839           0 :             continue;
     840             :         }
     841             : 
     842             :         /* success or fatal error */
     843           0 :         break;
     844             :     }
     845             : 
     846           0 :     x509_res = SSL_get_verify_result(tls->ssl);
     847           0 :     if (x509_res == X509_V_OK) {
     848           0 :         strophe_debug(tls->ctx, "tls", "Certificate verification passed");
     849             :     } else {
     850           0 :         strophe_debug(tls->ctx, "tls",
     851             :                       "Certificate verification FAILED, result=%s(%ld)",
     852             :                       TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
     853           0 :         if (ret > 0)
     854           0 :             strophe_debug(tls->ctx, "tls", "User decided to connect anyways");
     855             :     }
     856           0 :     _tls_dump_cert_info(tls);
     857             : 
     858           0 :     _tls_set_error(tls, error);
     859           0 :     return ret <= 0 ? 0 : 1;
     860             : }
     861             : 
     862           0 : int tls_stop(tls_t *tls)
     863             : {
     864           0 :     int retries = 0;
     865           0 :     int error;
     866           0 :     int ret;
     867             : 
     868             :     /* According to OpenSSL.org, we must not call SSL_shutdown(3)
     869             :        if a previous fatal error has occurred on a connection. */
     870           0 :     if (tls->lasterror == SSL_ERROR_SYSCALL || tls->lasterror == SSL_ERROR_SSL)
     871             :         return 1;
     872             : 
     873           0 :     while (1) {
     874           0 :         ++retries;
     875           0 :         ret = SSL_shutdown(tls->ssl);
     876           0 :         error = ret < 0 ? SSL_get_error(tls->ssl, ret) : 0;
     877           0 :         if (ret == 1 || !tls_is_recoverable(NULL, error) ||
     878             :             retries >= TLS_SHUTDOWN_MAX_RETRIES) {
     879             :             break;
     880             :         }
     881           0 :         _tls_sock_wait(tls, error);
     882             :     }
     883           0 :     if (error == SSL_ERROR_SYSCALL && errno == 0) {
     884             :         /*
     885             :          * Handle special case when peer closes connection instead of
     886             :          * proper shutdown.
     887             :          */
     888           0 :         error = 0;
     889           0 :         ret = 1;
     890             :     }
     891           0 :     _tls_set_error(tls, error);
     892             : 
     893           0 :     return ret <= 0 ? 0 : 1;
     894             : }
     895             : 
     896           0 : int tls_is_recoverable(struct conn_interface *intf, int error)
     897             : {
     898           0 :     UNUSED(intf);
     899           0 :     return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
     900           0 :             error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
     901             :             error == SSL_ERROR_WANT_ACCEPT);
     902             : }
     903             : 
     904           0 : int tls_pending(struct conn_interface *intf)
     905             : {
     906           0 :     return SSL_pending(intf->conn->tls->ssl);
     907             : }
     908             : 
     909           0 : int tls_read(struct conn_interface *intf, void *buff, size_t len)
     910             : {
     911           0 :     int ret;
     912           0 :     tls_t *tls = intf->conn->tls;
     913             : 
     914           0 :     ret = SSL_read(tls->ssl, buff, len);
     915           0 :     _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
     916             : 
     917           0 :     return ret;
     918             : }
     919             : 
     920           0 : int tls_write(struct conn_interface *intf, const void *buff, size_t len)
     921             : {
     922           0 :     int ret;
     923           0 :     tls_t *tls = intf->conn->tls;
     924             : 
     925           0 :     ret = SSL_write(tls->ssl, buff, len);
     926           0 :     _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
     927             : 
     928           0 :     return ret;
     929             : }
     930             : 
     931           0 : int tls_clear_pending_write(struct conn_interface *intf)
     932             : {
     933           0 :     UNUSED(intf);
     934           0 :     return 0;
     935             : }
     936             : 
     937           0 : static void _tls_sock_wait(tls_t *tls, int error)
     938             : {
     939           0 :     struct timeval tv;
     940           0 :     fd_set rfds;
     941           0 :     fd_set wfds;
     942           0 :     int nfds;
     943           0 :     int ret;
     944             : 
     945           0 :     if (error == SSL_ERROR_NONE)
     946           0 :         return;
     947             : 
     948           0 :     FD_ZERO(&rfds);
     949           0 :     FD_ZERO(&wfds);
     950           0 :     if (error == SSL_ERROR_WANT_READ)
     951           0 :         FD_SET(tls->sock, &rfds);
     952           0 :     if (error == SSL_ERROR_WANT_WRITE)
     953           0 :         FD_SET(tls->sock, &wfds);
     954           0 :     nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
     955           0 :                ? tls->sock + 1
     956           0 :                : 0;
     957           0 :     do {
     958           0 :         tv.tv_sec = TLS_TIMEOUT_SEC;
     959           0 :         tv.tv_usec = TLS_TIMEOUT_USEC;
     960           0 :         ret = select(nfds, &rfds, &wfds, NULL, &tv);
     961           0 :     } while (ret == -1 && errno == EINTR);
     962             : }
     963             : 
     964             : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
     965             : {
     966           0 :     return (error >= 0 && (size_t)error < tbl_size) ? tbl[error] : "UNKNOWN";
     967             : }
     968             : 
     969           0 : static void _tls_set_error(tls_t *tls, int error)
     970             : {
     971           0 :     if (error != 0 && !tls_is_recoverable(NULL, error)) {
     972           0 :         strophe_debug(tls->ctx, "tls", "error=%s(%d) errno=%d lasterror=%d",
     973           0 :                       TLS_ERROR_STR(error, tls_errors), error, errno,
     974             :                       tls->lasterror);
     975           0 :         _tls_log_error(tls->ctx);
     976           0 :     } else if (tls->lasterror && tls->lasterror != error) {
     977           0 :         strophe_debug_verbose(1, tls->ctx, "tls", "overwrite lasterror=%d",
     978             :                               tls->lasterror);
     979             :     }
     980           0 :     tls->lasterror = error;
     981           0 : }
     982             : 
     983           0 : static void _tls_log_error(xmpp_ctx_t *ctx)
     984             : {
     985           0 :     unsigned long e;
     986             : 
     987           0 :     do {
     988           0 :         e = ERR_get_error();
     989           0 :         if (e != 0) {
     990           0 :             strophe_debug(
     991             :                 ctx, "tls", "error:%08X:%s:%s:%s", e, ERR_lib_error_string(e),
     992             :                 STROPHE_ERR_func_error_string(e), ERR_reason_error_string(e));
     993             :         }
     994           0 :     } while (e != 0);
     995           0 : }
     996             : 
     997           0 : static void _tls_dump_cert_info(tls_t *tls)
     998             : {
     999           0 :     X509 *cert;
    1000           0 :     char *name;
    1001             : 
    1002           0 :     cert = SSL_get_peer_certificate(tls->ssl);
    1003           0 :     if (cert == NULL)
    1004           0 :         strophe_debug(tls->ctx, "tls", "Certificate was not presented by peer");
    1005             :     else {
    1006           0 :         name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
    1007           0 :         if (name != NULL) {
    1008           0 :             strophe_debug(tls->ctx, "tls", "Subject=%s", name);
    1009           0 :             OPENSSL_free(name);
    1010             :         }
    1011           0 :         name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
    1012           0 :         if (name != NULL) {
    1013           0 :             strophe_debug(tls->ctx, "tls", "Issuer=%s", name);
    1014           0 :             OPENSSL_free(name);
    1015             :         }
    1016           0 :         X509_free(cert);
    1017             :     }
    1018           0 : }
    1019             : 
    1020           8 : static X509 *_tls_cert_read_x509(xmpp_conn_t *conn)
    1021             : {
    1022           8 :     if (conn->tls && conn->tls->client_cert)
    1023             :         return conn->tls->client_cert;
    1024           8 :     BIO *f = BIO_new_file(conn->tls_client_cert, "r");
    1025           8 :     if (!f) {
    1026           0 :         strophe_debug(conn->ctx, "tls", "f == NULL");
    1027           0 :         return NULL;
    1028             :     }
    1029           8 :     X509 *c = PEM_read_bio_X509(f, NULL, NULL, NULL);
    1030           8 :     BIO_free(f);
    1031           8 :     if (!c) {
    1032           0 :         _tls_log_error(conn->ctx);
    1033             :     }
    1034             :     return c;
    1035             : }
    1036             : 
    1037          32 : static int _tls_parse_p12(PKCS12 *p12,
    1038             :                           const char *pass,
    1039             :                           EVP_PKEY **pkey,
    1040             :                           X509 **cert,
    1041             :                           STACK_OF(X509) * *ca)
    1042             : {
    1043             :     /* For some reason `PKCS12_parse()` fails without a `EVP_PKEY`
    1044             :      * so if the user doesn't want it, use a local one and free it
    1045             :      * again directly after parsing.
    1046             :      */
    1047          32 :     EVP_PKEY *pkey_;
    1048          32 :     if (!pkey)
    1049          32 :         pkey = &pkey_;
    1050          32 :     int parse_ok = PKCS12_parse(p12, pass, pkey, cert, ca);
    1051          32 :     if (pkey == &pkey_ && pkey_)
    1052          24 :         EVP_PKEY_free(pkey_);
    1053          32 :     return parse_ok;
    1054             : }
    1055             : 
    1056             : static X509 *
    1057          24 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca)
    1058             : {
    1059          24 :     if (conn->tls && conn->tls->client_cert && !pkey && !ca)
    1060          24 :         return conn->tls->client_cert;
    1061          24 :     X509 *cert = NULL;
    1062          24 :     PKCS12 *p12 = NULL;
    1063          24 :     BIO *f = BIO_new_file(conn->tls_client_cert, "rb");
    1064          24 :     if (!f) {
    1065           0 :         strophe_debug(conn->ctx, "tls", "f == NULL");
    1066           0 :         goto error_out;
    1067             :     }
    1068          24 :     p12 = d2i_PKCS12_bio(f, NULL);
    1069          24 :     BIO_free(f);
    1070          24 :     if (!p12) {
    1071           0 :         strophe_debug(conn->ctx, "tls", "Could not read p12 file");
    1072           0 :         goto error_out;
    1073             :     }
    1074             : 
    1075             :     /* First try to open file w/o a pass */
    1076          24 :     if (_tls_parse_p12(p12, NULL, pkey, &cert, ca)) {
    1077             :         goto success;
    1078             :     }
    1079           8 :     cert = NULL;
    1080             : 
    1081           8 :     unsigned int retries = 0;
    1082             : 
    1083           8 :     pem_password_cb *cb = PEM_def_callback;
    1084           8 :     void *userdata = NULL;
    1085           8 :     if (conn->password_callback) {
    1086           8 :         cb = _tls_password_callback;
    1087           8 :         userdata = conn;
    1088             :     }
    1089             : 
    1090           8 :     while (retries++ < conn->password_retries) {
    1091           8 :         char pass[PEM_BUFSIZE + 1];
    1092           8 :         int passlen = cb(pass, PEM_BUFSIZE, 0, userdata);
    1093           8 :         if (passlen < 0 || passlen > PEM_BUFSIZE)
    1094           0 :             goto error_out;
    1095           8 :         int parse_ok = _tls_parse_p12(p12, pass, pkey, &cert, ca);
    1096           8 :         if (parse_ok) {
    1097           8 :             goto success;
    1098             :         }
    1099           0 :         cert = NULL;
    1100           0 :         tls_clear_password_cache(conn);
    1101           0 :         int err = ERR_peek_last_error();
    1102           0 :         if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
    1103           0 :             ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
    1104           0 :             strophe_debug(conn->ctx, "tls",
    1105             :                           "Entered password is most likely wrong!");
    1106           0 :             continue;
    1107             :         }
    1108           0 :         strophe_debug(conn->ctx, "tls", "Could not parse PKCS#12");
    1109           0 :         goto error_out;
    1110             :     }
    1111           0 : error_out:
    1112           0 :     _tls_log_error(conn->ctx);
    1113          24 : success:
    1114          24 :     if (p12)
    1115          24 :         PKCS12_free(p12);
    1116          24 :     return cert;
    1117             : }
    1118             : 
    1119          32 : static X509 *_tls_cert_read(xmpp_conn_t *conn)
    1120             : {
    1121          32 :     if (conn->tls && conn->tls->client_cert)
    1122             :         return conn->tls->client_cert;
    1123          32 :     if (conn->tls_client_cert && !conn->tls_client_key) {
    1124          24 :         return _tls_cert_read_p12(conn, NULL, NULL);
    1125             :     }
    1126           8 :     return _tls_cert_read_x509(conn);
    1127             : }
    1128             : 
    1129          58 : static int _tls_xaddr_nid(void)
    1130             : {
    1131          58 :     static int xaddr_nid = NID_undef;
    1132          58 :     if (xaddr_nid == NID_undef) {
    1133           2 :         xaddr_nid = OBJ_sn2nid("id-on-xmppAddr");
    1134             :     }
    1135          58 :     if (xaddr_nid == NID_undef) {
    1136           2 :         xaddr_nid = OBJ_create("1.3.6.1.5.5.7.8.5", "id-on-xmppAddr",
    1137             :                                "XmppAddr Identifier");
    1138             :     }
    1139          58 :     return xaddr_nid;
    1140             : }
    1141             : 
    1142          32 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn)
    1143             : {
    1144          32 :     X509 *client_cert;
    1145          32 :     GENERAL_NAMES *names = NULL;
    1146          32 :     client_cert = _tls_cert_read(conn);
    1147          32 :     if (!client_cert)
    1148             :         return NULL;
    1149          32 :     names = _tls_cert_get_names(client_cert);
    1150          32 :     if (!conn->tls || !conn->tls->client_cert)
    1151          32 :         X509_free(client_cert);
    1152             :     return names;
    1153             : }
    1154             : 
    1155          32 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert)
    1156             : {
    1157          32 :     int san = X509_get_ext_by_NID(client_cert, NID_subject_alt_name, 0);
    1158          32 :     X509_EXTENSION *san_ext = X509_get_ext(client_cert, san);
    1159          32 :     if (!san_ext)
    1160          32 :         return NULL;
    1161          32 :     ASN1_OCTET_STRING *data = X509_EXTENSION_get_data(san_ext);
    1162          32 :     if (!data)
    1163             :         return NULL;
    1164          32 :     const unsigned char *d = ASN1_STRING_get0_data(data);
    1165          32 :     if (!d)
    1166             :         return NULL;
    1167          32 :     return d2i_GENERAL_NAMES(NULL, &d, ASN1_STRING_length(data));
    1168             : }
    1169             : 
    1170             : /** Convert GENERAL_NAME* to a string
    1171             :  *
    1172             :  *  This checks whether the GENERAL_NAME* that is given has the
    1173             :  *  correct id-on-xmppAddr set and then optionally converts this
    1174             :  *  form ASN.1 to a string/char*.
    1175             :  *
    1176             :  *  When `res` pointer is set to NULL this method doesn't allocate
    1177             :  *  the result but only checks whether it is in the correct format.
    1178             :  *
    1179             :  *  @param name Pointer to the GENERAL_NAME that shall be converted
    1180             :  *  @param res Result-pointer (optional, can be NULL)
    1181             :  *
    1182             :  *  @return classic Unix style - 0=success, 1=error
    1183             :  */
    1184         104 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res)
    1185             : {
    1186         104 :     ASN1_OBJECT *oid;
    1187         104 :     ASN1_TYPE *val;
    1188         104 :     if (!name || name->type != GEN_OTHERNAME)
    1189         104 :         return 1;
    1190          56 :     if (GENERAL_NAME_get0_otherName(name, &oid, &val) == 0)
    1191             :         return 1;
    1192          56 :     if (OBJ_obj2nid(oid) != _tls_xaddr_nid() || !val)
    1193             :         return 1;
    1194          56 :     if (!res)
    1195             :         return 0;
    1196          40 :     if (ASN1_STRING_to_UTF8((unsigned char **)res, val->value.asn1_string) < 0)
    1197           0 :         return 1;
    1198             :     return 0;
    1199             : }
    1200             : 
    1201           0 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res)
    1202             : {
    1203           0 :     ASN1_STRING *str;
    1204           0 :     if (!name || name->type != GEN_DNS)
    1205             :         return 1;
    1206           0 :     str = GENERAL_NAME_get0_value(name, NULL);
    1207           0 :     if (str == NULL)
    1208             :         return 1;
    1209           0 :     if (!res)
    1210             :         return 0;
    1211           0 :     if (ASN1_STRING_to_UTF8((unsigned char **)res, str) < 0)
    1212           0 :         return 1;
    1213             :     return 0;
    1214             : }

Generated by: LCOV version 1.14