programs/ssl/ssl_test_common_source.c

/*
 *  Common source code for SSL test programs. This file is included by
 *  both ssl_client2.c and ssl_server2.c and is intended for source
 *  code that is textually identical in both programs, but that cannot be
 *  compiled separately because it refers to types or macros that are
 *  different in the two programs, or because it would have an incomplete
 *  type.
 *
 *  This file is meant to be #include'd and cannot be compiled separately.
 *
 *  Copyright The Mbed TLS Contributors
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 *  not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

#if defined(MBEDTLS_SSL_EXPORT_KEYS)
void eap_tls_key_derivation(void *p_expkey,
                            mbedtls_ssl_key_export_type secret_type,
                            const unsigned char *secret,
                            size_t secret_len,
                            const unsigned char client_random[32],
                            const unsigned char server_random[32],
                            mbedtls_tls_prf_types tls_prf_type)
{
    eap_tls_keys *keys = (eap_tls_keys *)p_expkey;

    /* We're only interested in the TLS 1.2 master secret */
    if (secret_type != MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET)
        return;
    if (secret_len != sizeof(keys->master_secret))
        return;

    memcpy(keys->master_secret, secret, sizeof(keys->master_secret));
    memcpy(keys->randbytes, client_random, 32);
    memcpy(keys->randbytes + 32, server_random, 32);
    keys->tls_prf_type = tls_prf_type;
}

void nss_keylog_export(void *p_expkey,
                       mbedtls_ssl_key_export_type secret_type,
                       const unsigned char *secret,
                       size_t secret_len,
                       const unsigned char client_random[32],
                       const unsigned char server_random[32],
                       mbedtls_tls_prf_types tls_prf_type)
{
    char nss_keylog_line[200];
    size_t const client_random_len = 32;
    size_t len = 0;
    size_t j;

    /* We're only interested in the TLS 1.2 master secret */
    if (secret_type != MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET)
        return;

    ((void)p_expkey);
    ((void)server_random);
    ((void)tls_prf_type);

    len += sprintf(nss_keylog_line + len, "%s", "CLIENT_RANDOM ");

    for (j = 0; j < client_random_len; j++) {
        len += sprintf(nss_keylog_line + len, "%02x", client_random[j]);
    }

    len += sprintf(nss_keylog_line + len, " ");

    for (j = 0; j < secret_len; j++) {
        len += sprintf(nss_keylog_line + len, "%02x", secret[j]);
    }

    len += sprintf(nss_keylog_line + len, "\n");
    nss_keylog_line[len] = '\0';

    mbedtls_printf("\n");
    mbedtls_printf("---------------- NSS KEYLOG -----------------\n");
    mbedtls_printf("%s", nss_keylog_line);
    mbedtls_printf("---------------------------------------------\n");

    if (opt.nss_keylog_file != NULL) {
        FILE *f;

        if ((f = fopen(opt.nss_keylog_file, "a")) == NULL) {
            goto exit;
        }

        if (fwrite(nss_keylog_line, 1, len, f) != len) {
            fclose(f);
            goto exit;
        }

        fclose(f);
    }

exit:
    mbedtls_platform_zeroize(nss_keylog_line, sizeof(nss_keylog_line));
}

#    if defined(MBEDTLS_SSL_DTLS_SRTP)
void dtls_srtp_key_derivation(void *p_expkey,
                              mbedtls_ssl_key_export_type secret_type,
                              const unsigned char *secret,
                              size_t secret_len,
                              const unsigned char client_random[32],
                              const unsigned char server_random[32],
                              mbedtls_tls_prf_types tls_prf_type)
{
    dtls_srtp_keys *keys = (dtls_srtp_keys *)p_expkey;

    /* We're only interested in the TLS 1.2 master secret */
    if (secret_type != MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET)
        return;
    if (secret_len != sizeof(keys->master_secret))
        return;

    memcpy(keys->master_secret, secret, sizeof(keys->master_secret));
    memcpy(keys->randbytes, client_random, 32);
    memcpy(keys->randbytes + 32, server_random, 32);
    keys->tls_prf_type = tls_prf_type;
}
#    endif /* MBEDTLS_SSL_DTLS_SRTP */

#endif /* MBEDTLS_SSL_EXPORT_KEYS */

int ssl_check_record(mbedtls_ssl_context const *ssl,
                     unsigned char const *buf,
                     size_t len)
{
    int my_ret = 0, ret_cr1, ret_cr2;
    unsigned char *tmp_buf;

    /* Record checking may modify the input buffer,
     * so make a copy. */
    tmp_buf = mbedtls_calloc(1, len);
    if (tmp_buf == NULL)
        return MBEDTLS_ERR_SSL_ALLOC_FAILED;
    memcpy(tmp_buf, buf, len);

    ret_cr1 = mbedtls_ssl_check_record(ssl, tmp_buf, len);
    if (ret_cr1 != MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) {
        /* Test-only: Make sure that mbedtls_ssl_check_record()
         *            doesn't alter state. */
        memcpy(tmp_buf, buf, len); /* Restore buffer */
        ret_cr2 = mbedtls_ssl_check_record(ssl, tmp_buf, len);
        if (ret_cr2 != ret_cr1) {
            mbedtls_printf(
                "mbedtls_ssl_check_record() returned inconsistent results.\n");
            my_ret = -1;
            goto cleanup;
        }

        switch (ret_cr1) {
            case 0:
                break;

            case MBEDTLS_ERR_SSL_INVALID_RECORD:
                if (opt.debug_level > 1)
                    mbedtls_printf(
                        "mbedtls_ssl_check_record() detected invalid record.\n");
                break;

            case MBEDTLS_ERR_SSL_INVALID_MAC:
                if (opt.debug_level > 1)
                    mbedtls_printf(
                        "mbedtls_ssl_check_record() detected unauthentic record.\n");
                break;

            case MBEDTLS_ERR_SSL_UNEXPECTED_RECORD:
                if (opt.debug_level > 1)
                    mbedtls_printf(
                        "mbedtls_ssl_check_record() detected unexpected record.\n");
                break;

            default:
                mbedtls_printf(
                    "mbedtls_ssl_check_record() failed fatally with -%#04x.\n",
                    (unsigned int)-ret_cr1);
                my_ret = -1;
                goto cleanup;
        }

        /* Regardless of the outcome, forward the record to the stack. */
    }

cleanup:
    mbedtls_free(tmp_buf);

    return my_ret;
}

int recv_cb(void *ctx, unsigned char *buf, size_t len)
{
    io_ctx_t *io_ctx = (io_ctx_t *)ctx;
    size_t recv_len;
    int ret;

    if (opt.nbio == 2)
        ret = delayed_recv(io_ctx->net, buf, len);
    else
        ret = mbedtls_net_recv(io_ctx->net, buf, len);
    if (ret < 0)
        return ret;
    recv_len = (size_t)ret;

    if (opt.transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        /* Here's the place to do any datagram/record checking
         * in between receiving the packet from the underlying
         * transport and passing it on to the TLS stack. */
        if (ssl_check_record(io_ctx->ssl, buf, recv_len) != 0)
            return -1;
    }

    return (int)recv_len;
}

int recv_timeout_cb(void *ctx, unsigned char *buf, size_t len, uint32_t timeout)
{
    io_ctx_t *io_ctx = (io_ctx_t *)ctx;
    int ret;
    size_t recv_len;

    ret = mbedtls_net_recv_timeout(io_ctx->net, buf, len, timeout);
    if (ret < 0)
        return ret;
    recv_len = (size_t)ret;

    if (opt.transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        /* Here's the place to do any datagram/record checking
         * in between receiving the packet from the underlying
         * transport and passing it on to the TLS stack. */
        if (ssl_check_record(io_ctx->ssl, buf, recv_len) != 0)
            return -1;
    }

    return (int)recv_len;
}

int send_cb(void *ctx, unsigned char const *buf, size_t len)
{
    io_ctx_t *io_ctx = (io_ctx_t *)ctx;

    if (opt.nbio == 2)
        return delayed_send(io_ctx->net, buf, len);

    return mbedtls_net_send(io_ctx->net, buf, len);
}

#if defined(MBEDTLS_X509_CRT_PARSE_C)
int ssl_sig_hashes_for_test[] = {
#    if defined(MBEDTLS_SHA512_C)
    MBEDTLS_MD_SHA512,
#    endif
#    if defined(MBEDTLS_SHA384_C)
    MBEDTLS_MD_SHA384,
#    endif
#    if defined(MBEDTLS_SHA256_C)
    MBEDTLS_MD_SHA256,
#    endif
#    if defined(MBEDTLS_SHA224_C)
    MBEDTLS_MD_SHA224,
#    endif
#    if defined(MBEDTLS_SHA1_C)
    /* Allow SHA-1 as we use it extensively in tests. */
    MBEDTLS_MD_SHA1,
#    endif
    MBEDTLS_MD_NONE
};
#endif /* MBEDTLS_X509_CRT_PARSE_C */

#if defined(MBEDTLS_X509_CRT_PARSE_C)
/** Functionally equivalent to mbedtls_x509_crt_verify_info, see that function
 *  for more info.
 */
int x509_crt_verify_info(char *buf,
                         size_t size,
                         const char *prefix,
                         uint32_t flags)
{
#    if !defined(MBEDTLS_X509_REMOVE_INFO)
    return mbedtls_x509_crt_verify_info(buf, size, prefix, flags);

#    else /* !MBEDTLS_X509_REMOVE_INFO */
    int ret;
    char *p = buf;
    size_t n = size;

#        define X509_CRT_ERROR_INFO(err, err_str, info)               \
            if ((flags & err) != 0) {                                 \
                ret = mbedtls_snprintf(p, n, "%s%s\n", prefix, info); \
                MBEDTLS_X509_SAFE_SNPRINTF;                           \
                flags ^= err;                                         \
            }

    MBEDTLS_X509_CRT_ERROR_INFO_LIST
#        undef X509_CRT_ERROR_INFO

    if (flags != 0) {
        ret = mbedtls_snprintf(p, n,
                               "%sUnknown reason "
                               "(this should not happen)\n",
                               prefix);
        MBEDTLS_X509_SAFE_SNPRINTF;
    }

    return ((int)(size - n));
#    endif /* MBEDTLS_X509_REMOVE_INFO */
}
#endif /* MBEDTLS_X509_CRT_PARSE_C */