Gilles Peskine | a3ed34f | 2021-01-05 21:11:16 +0100 | [diff] [blame] | 1 | /* |
Gilles Peskine | 0d980b8 | 2021-01-05 23:34:27 +0100 | [diff] [blame] | 2 | * Common code library for SSL test programs. |
| 3 | * |
| 4 | * In addition to the functions in this file, there is shared source code |
| 5 | * that cannot be compiled separately in "ssl_test_common_source.c". |
Gilles Peskine | a3ed34f | 2021-01-05 21:11:16 +0100 | [diff] [blame] | 6 | * |
| 7 | * Copyright The Mbed TLS Contributors |
Dave Rodgman | 7ff7965 | 2023-11-03 12:04:52 +0000 | [diff] [blame] | 8 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
Gilles Peskine | a3ed34f | 2021-01-05 21:11:16 +0100 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include "ssl_test_lib.h" |
| 12 | |
Gilles Peskine | e374b95 | 2021-02-03 00:05:19 +0100 | [diff] [blame] | 13 | #if defined(MBEDTLS_TEST_HOOKS) |
| 14 | #include "test/helpers.h" |
| 15 | #endif |
| 16 | |
Gilles Peskine | ab7ce96 | 2021-01-05 21:27:53 +0100 | [diff] [blame] | 17 | #if !defined(MBEDTLS_SSL_TEST_IMPOSSIBLE) |
| 18 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 19 | void my_debug(void *ctx, int level, |
| 20 | const char *file, int line, |
| 21 | const char *str) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 22 | { |
| 23 | const char *p, *basename; |
| 24 | |
| 25 | /* Extract basename from file */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 26 | for (p = basename = file; *p != '\0'; p++) { |
| 27 | if (*p == '/' || *p == '\\') { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 28 | basename = p + 1; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 29 | } |
| 30 | } |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 31 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 32 | mbedtls_fprintf((FILE *) ctx, "%s:%04d: |%d| %s", |
| 33 | basename, line, level, str); |
| 34 | fflush((FILE *) ctx); |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 35 | } |
| 36 | |
Raoul Strackx | 2db000f | 2020-06-22 14:08:57 +0200 | [diff] [blame] | 37 | #if defined(MBEDTLS_HAVE_TIME) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 38 | mbedtls_time_t dummy_constant_time(mbedtls_time_t *time) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 39 | { |
| 40 | (void) time; |
| 41 | return 0x5af2a056; |
| 42 | } |
Raoul Strackx | 2db000f | 2020-06-22 14:08:57 +0200 | [diff] [blame] | 43 | #endif |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 44 | |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 45 | #if !defined(MBEDTLS_TEST_USE_PSA_CRYPTO_RNG) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 46 | static int dummy_entropy(void *data, unsigned char *output, size_t len) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 47 | { |
| 48 | size_t i; |
| 49 | int ret; |
| 50 | (void) data; |
| 51 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 52 | ret = mbedtls_entropy_func(data, output, len); |
| 53 | for (i = 0; i < len; i++) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 54 | //replace result with pseudo random |
| 55 | output[i] = (unsigned char) rand(); |
| 56 | } |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 57 | return ret; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 58 | } |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 59 | #endif |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 60 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 61 | void rng_init(rng_context_t *rng) |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 62 | { |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 63 | #if defined(MBEDTLS_TEST_USE_PSA_CRYPTO_RNG) |
| 64 | (void) rng; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 65 | psa_crypto_init(); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 66 | #else /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
| 67 | |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 68 | #if defined(MBEDTLS_CTR_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 69 | mbedtls_ctr_drbg_init(&rng->drbg); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 70 | #elif defined(MBEDTLS_HMAC_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 71 | mbedtls_hmac_drbg_init(&rng->drbg); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 72 | #else |
| 73 | #error "No DRBG available" |
| 74 | #endif |
| 75 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 76 | mbedtls_entropy_init(&rng->entropy); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 77 | #endif /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 78 | } |
| 79 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 80 | int rng_seed(rng_context_t *rng, int reproducible, const char *pers) |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 81 | { |
Gilles Peskine | aaedbdc | 2021-02-03 13:55:22 +0100 | [diff] [blame] | 82 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 83 | if (reproducible) { |
| 84 | mbedtls_fprintf(stderr, |
| 85 | "MBEDTLS_USE_PSA_CRYPTO does not support reproducible mode.\n"); |
| 86 | return -1; |
Gilles Peskine | aaedbdc | 2021-02-03 13:55:22 +0100 | [diff] [blame] | 87 | } |
| 88 | #endif |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 89 | #if defined(MBEDTLS_TEST_USE_PSA_CRYPTO_RNG) |
| 90 | /* The PSA crypto RNG does its own seeding. */ |
| 91 | (void) rng; |
| 92 | (void) pers; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 93 | if (reproducible) { |
| 94 | mbedtls_fprintf(stderr, |
| 95 | "The PSA RNG does not support reproducible mode.\n"); |
| 96 | return -1; |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 97 | } |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 98 | return 0; |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 99 | #else /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 100 | int (*f_entropy)(void *, unsigned char *, size_t) = |
| 101 | (reproducible ? dummy_entropy : mbedtls_entropy_func); |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 102 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 103 | if (reproducible) { |
| 104 | srand(1); |
| 105 | } |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 106 | |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 107 | #if defined(MBEDTLS_CTR_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 108 | int ret = mbedtls_ctr_drbg_seed(&rng->drbg, |
| 109 | f_entropy, &rng->entropy, |
| 110 | (const unsigned char *) pers, |
| 111 | strlen(pers)); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 112 | #elif defined(MBEDTLS_HMAC_DRBG_C) |
| 113 | #if defined(MBEDTLS_SHA256_C) |
| 114 | const mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256; |
| 115 | #elif defined(MBEDTLS_SHA512_C) |
| 116 | const mbedtls_md_type_t md_type = MBEDTLS_MD_SHA512; |
| 117 | #else |
| 118 | #error "No message digest available for HMAC_DRBG" |
| 119 | #endif |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 120 | int ret = mbedtls_hmac_drbg_seed(&rng->drbg, |
| 121 | mbedtls_md_info_from_type(md_type), |
| 122 | f_entropy, &rng->entropy, |
| 123 | (const unsigned char *) pers, |
| 124 | strlen(pers)); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 125 | #else /* !defined(MBEDTLS_CTR_DRBG_C) && !defined(MBEDTLS_HMAC_DRBG_C) */ |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 126 | #error "No DRBG available" |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 127 | #endif /* !defined(MBEDTLS_CTR_DRBG_C) && !defined(MBEDTLS_HMAC_DRBG_C) */ |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 128 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 129 | if (ret != 0) { |
| 130 | mbedtls_printf(" failed\n ! mbedtls_ctr_drbg_seed returned -0x%x\n", |
| 131 | (unsigned int) -ret); |
| 132 | return ret; |
Gilles Peskine | f1cb75f | 2021-01-13 18:46:01 +0100 | [diff] [blame] | 133 | } |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 134 | #endif /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 135 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 136 | return 0; |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 137 | } |
| 138 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 139 | void rng_free(rng_context_t *rng) |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 140 | { |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 141 | #if defined(MBEDTLS_TEST_USE_PSA_CRYPTO_RNG) |
| 142 | (void) rng; |
| 143 | /* Deinitialize the PSA crypto subsystem. This deactivates all PSA APIs. |
| 144 | * This is ok because none of our applications try to do any crypto after |
| 145 | * deinitializing the RNG. */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 146 | mbedtls_psa_crypto_free(); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 147 | #else /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
| 148 | |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 149 | #if defined(MBEDTLS_CTR_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 150 | mbedtls_ctr_drbg_free(&rng->drbg); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 151 | #elif defined(MBEDTLS_HMAC_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 152 | mbedtls_hmac_drbg_free(&rng->drbg); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 153 | #else |
| 154 | #error "No DRBG available" |
| 155 | #endif |
| 156 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 157 | mbedtls_entropy_free(&rng->entropy); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 158 | #endif /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | daa94c4 | 2021-01-13 18:38:27 +0100 | [diff] [blame] | 159 | } |
| 160 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 161 | int rng_get(void *p_rng, unsigned char *output, size_t output_len) |
Gilles Peskine | 535fb37 | 2021-01-13 18:59:46 +0100 | [diff] [blame] | 162 | { |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 163 | #if defined(MBEDTLS_TEST_USE_PSA_CRYPTO_RNG) |
| 164 | (void) p_rng; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 165 | return mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE, |
| 166 | output, output_len); |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 167 | #else /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | 535fb37 | 2021-01-13 18:59:46 +0100 | [diff] [blame] | 168 | rng_context_t *rng = p_rng; |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 169 | |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 170 | #if defined(MBEDTLS_CTR_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 171 | return mbedtls_ctr_drbg_random(&rng->drbg, output, output_len); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 172 | #elif defined(MBEDTLS_HMAC_DRBG_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 173 | return mbedtls_hmac_drbg_random(&rng->drbg, output, output_len); |
Gilles Peskine | ba74904 | 2021-01-13 20:02:03 +0100 | [diff] [blame] | 174 | #else |
| 175 | #error "No DRBG available" |
| 176 | #endif |
Gilles Peskine | 8eb2943 | 2021-02-03 20:07:11 +0100 | [diff] [blame] | 177 | |
| 178 | #endif /* !MBEDTLS_TEST_USE_PSA_CRYPTO_RNG */ |
Gilles Peskine | 535fb37 | 2021-01-13 18:59:46 +0100 | [diff] [blame] | 179 | } |
| 180 | |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 181 | #if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 182 | int ca_callback(void *data, mbedtls_x509_crt const *child, |
| 183 | mbedtls_x509_crt **candidates) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 184 | { |
| 185 | int ret = 0; |
| 186 | mbedtls_x509_crt *ca = (mbedtls_x509_crt *) data; |
| 187 | mbedtls_x509_crt *first; |
| 188 | |
| 189 | /* This is a test-only implementation of the CA callback |
| 190 | * which always returns the entire list of trusted certificates. |
| 191 | * Production implementations managing a large number of CAs |
| 192 | * should use an efficient presentation and lookup for the |
| 193 | * set of trusted certificates (such as a hashtable) and only |
| 194 | * return those trusted certificates which satisfy basic |
| 195 | * parental checks, such as the matching of child `Issuer` |
| 196 | * and parent `Subject` field or matching key identifiers. */ |
| 197 | ((void) child); |
| 198 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 199 | first = mbedtls_calloc(1, sizeof(mbedtls_x509_crt)); |
| 200 | if (first == NULL) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 201 | ret = -1; |
| 202 | goto exit; |
| 203 | } |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 204 | mbedtls_x509_crt_init(first); |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 205 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 206 | if (mbedtls_x509_crt_parse_der(first, ca->raw.p, ca->raw.len) != 0) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 207 | ret = -1; |
| 208 | goto exit; |
| 209 | } |
| 210 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 211 | while (ca->next != NULL) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 212 | ca = ca->next; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 213 | if (mbedtls_x509_crt_parse_der(first, ca->raw.p, ca->raw.len) != 0) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 214 | ret = -1; |
| 215 | goto exit; |
| 216 | } |
| 217 | } |
| 218 | |
| 219 | exit: |
| 220 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 221 | if (ret != 0) { |
| 222 | mbedtls_x509_crt_free(first); |
| 223 | mbedtls_free(first); |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 224 | first = NULL; |
| 225 | } |
| 226 | |
| 227 | *candidates = first; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 228 | return ret; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 229 | } |
| 230 | #endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */ |
| 231 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 232 | int delayed_recv(void *ctx, unsigned char *buf, size_t len) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 233 | { |
| 234 | static int first_try = 1; |
| 235 | int ret; |
| 236 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 237 | if (first_try) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 238 | first_try = 0; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 239 | return MBEDTLS_ERR_SSL_WANT_READ; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 240 | } |
| 241 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 242 | ret = mbedtls_net_recv(ctx, buf, len); |
| 243 | if (ret != MBEDTLS_ERR_SSL_WANT_READ) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 244 | first_try = 1; /* Next call will be a new operation */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 245 | } |
| 246 | return ret; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 247 | } |
| 248 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 249 | int delayed_send(void *ctx, const unsigned char *buf, size_t len) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 250 | { |
| 251 | static int first_try = 1; |
| 252 | int ret; |
| 253 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 254 | if (first_try) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 255 | first_try = 0; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 256 | return MBEDTLS_ERR_SSL_WANT_WRITE; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 257 | } |
| 258 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 259 | ret = mbedtls_net_send(ctx, buf, len); |
| 260 | if (ret != MBEDTLS_ERR_SSL_WANT_WRITE) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 261 | first_try = 1; /* Next call will be a new operation */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 262 | } |
| 263 | return ret; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 264 | } |
| 265 | |
| 266 | #if !defined(MBEDTLS_TIMING_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 267 | int idle(mbedtls_net_context *fd, |
| 268 | int idle_reason) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 269 | #else |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 270 | int idle(mbedtls_net_context *fd, |
| 271 | mbedtls_timing_delay_context *timer, |
| 272 | int idle_reason) |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 273 | #endif |
| 274 | { |
| 275 | int ret; |
| 276 | int poll_type = 0; |
| 277 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 278 | if (idle_reason == MBEDTLS_ERR_SSL_WANT_WRITE) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 279 | poll_type = MBEDTLS_NET_POLL_WRITE; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 280 | } else if (idle_reason == MBEDTLS_ERR_SSL_WANT_READ) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 281 | poll_type = MBEDTLS_NET_POLL_READ; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 282 | } |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 283 | #if !defined(MBEDTLS_TIMING_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 284 | else { |
| 285 | return 0; |
| 286 | } |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 287 | #endif |
| 288 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 289 | while (1) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 290 | /* Check if timer has expired */ |
| 291 | #if defined(MBEDTLS_TIMING_C) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 292 | if (timer != NULL && |
| 293 | mbedtls_timing_get_delay(timer) == 2) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 294 | break; |
| 295 | } |
| 296 | #endif /* MBEDTLS_TIMING_C */ |
| 297 | |
| 298 | /* Check if underlying transport became available */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 299 | if (poll_type != 0) { |
| 300 | ret = mbedtls_net_poll(fd, poll_type, 0); |
| 301 | if (ret < 0) { |
| 302 | return ret; |
| 303 | } |
| 304 | if (ret == poll_type) { |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 305 | break; |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 306 | } |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 307 | } |
| 308 | } |
| 309 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 310 | return 0; |
Gilles Peskine | 504c1a3 | 2021-01-05 23:40:14 +0100 | [diff] [blame] | 311 | } |
| 312 | |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 313 | #if defined(MBEDTLS_TEST_HOOKS) |
| 314 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 315 | void test_hooks_init(void) |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 316 | { |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 317 | mbedtls_test_info_reset(); |
Gilles Peskine | e374b95 | 2021-02-03 00:05:19 +0100 | [diff] [blame] | 318 | |
| 319 | #if defined(MBEDTLS_TEST_MUTEX_USAGE) |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 320 | mbedtls_test_mutex_usage_init(); |
Gilles Peskine | e374b95 | 2021-02-03 00:05:19 +0100 | [diff] [blame] | 321 | #endif |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 322 | } |
| 323 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 324 | int test_hooks_failure_detected(void) |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 325 | { |
Gilles Peskine | e374b95 | 2021-02-03 00:05:19 +0100 | [diff] [blame] | 326 | #if defined(MBEDTLS_TEST_MUTEX_USAGE) |
| 327 | /* Errors are reported via mbedtls_test_info. */ |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 328 | mbedtls_test_mutex_usage_check(); |
Gilles Peskine | e374b95 | 2021-02-03 00:05:19 +0100 | [diff] [blame] | 329 | #endif |
| 330 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 331 | if (mbedtls_test_info.result != MBEDTLS_TEST_RESULT_SUCCESS) { |
| 332 | return 1; |
| 333 | } |
| 334 | return 0; |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 335 | } |
| 336 | |
Gilles Peskine | 1b6c09a | 2023-01-11 14:52:35 +0100 | [diff] [blame] | 337 | void test_hooks_free(void) |
Gilles Peskine | 53dea74 | 2021-02-02 22:55:06 +0100 | [diff] [blame] | 338 | { |
| 339 | } |
| 340 | |
| 341 | #endif /* MBEDTLS_TEST_HOOKS */ |
| 342 | |
Gilles Peskine | ab7ce96 | 2021-01-05 21:27:53 +0100 | [diff] [blame] | 343 | #endif /* !defined(MBEDTLS_SSL_TEST_IMPOSSIBLE) */ |