1 /* 2 * Copyright 2015-2025 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include <string.h> 11 #include <openssl/types.h> 12 #include "testutil.h" 13 #include "internal/numbers.h" 14 #include "internal/time.h" 15 16 #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L 17 # include <signal.h> 18 #endif 19 20 static int test_sanity_null_zero(void) 21 { 22 char *p; 23 char bytes[sizeof(p)]; 24 25 /* Is NULL equivalent to all-bytes-zero? */ 26 p = NULL; 27 memset(bytes, 0, sizeof(bytes)); 28 return TEST_mem_eq(&p, sizeof(p), bytes, sizeof(bytes)); 29 } 30 31 static int test_sanity_enum_size(void) 32 { 33 enum smallchoices { sa, sb, sc }; 34 enum medchoices { ma, mb, mc, md, me, mf, mg, mh, mi, mj, mk, ml }; 35 enum largechoices { 36 a01, b01, c01, d01, e01, f01, g01, h01, i01, j01, 37 a02, b02, c02, d02, e02, f02, g02, h02, i02, j02, 38 a03, b03, c03, d03, e03, f03, g03, h03, i03, j03, 39 a04, b04, c04, d04, e04, f04, g04, h04, i04, j04, 40 a05, b05, c05, d05, e05, f05, g05, h05, i05, j05, 41 a06, b06, c06, d06, e06, f06, g06, h06, i06, j06, 42 a07, b07, c07, d07, e07, f07, g07, h07, i07, j07, 43 a08, b08, c08, d08, e08, f08, g08, h08, i08, j08, 44 a09, b09, c09, d09, e09, f09, g09, h09, i09, j09, 45 a10, b10, c10, d10, e10, f10, g10, h10, i10, j10, 46 xxx }; 47 48 /* Enum size */ 49 if (!TEST_size_t_eq(sizeof(enum smallchoices), sizeof(int)) 50 || !TEST_size_t_eq(sizeof(enum medchoices), sizeof(int)) 51 || !TEST_size_t_eq(sizeof(enum largechoices), sizeof(int))) 52 return 0; 53 return 1; 54 } 55 56 static int test_sanity_twos_complement(void) 57 { 58 /* Basic two's complement checks. */ 59 if (!TEST_int_eq(~(-1), 0) 60 || !TEST_long_eq(~(-1L), 0L)) 61 return 0; 62 return 1; 63 } 64 65 static int test_sanity_sign(void) 66 { 67 /* Check that values with sign bit 1 and value bits 0 are valid */ 68 if (!TEST_int_eq(-(INT_MIN + 1), INT_MAX) 69 || !TEST_long_eq(-(LONG_MIN + 1), LONG_MAX)) 70 return 0; 71 return 1; 72 } 73 74 static int test_sanity_unsigned_conversion(void) 75 { 76 /* Check that unsigned-to-signed conversions preserve bit patterns */ 77 if (!TEST_int_eq((int)((unsigned int)INT_MAX + 1), INT_MIN) 78 || !TEST_long_eq((long)((unsigned long)LONG_MAX + 1), LONG_MIN)) 79 return 0; 80 return 1; 81 } 82 83 static int test_sanity_range(void) 84 { 85 /* Verify some types are the correct size */ 86 if (!TEST_size_t_eq(sizeof(int8_t), 1) 87 || !TEST_size_t_eq(sizeof(uint8_t), 1) 88 || !TEST_size_t_eq(sizeof(int16_t), 2) 89 || !TEST_size_t_eq(sizeof(uint16_t), 2) 90 || !TEST_size_t_eq(sizeof(int32_t), 4) 91 || !TEST_size_t_eq(sizeof(uint32_t), 4) 92 || !TEST_size_t_eq(sizeof(int64_t), 8) 93 || !TEST_size_t_eq(sizeof(uint64_t), 8) 94 #ifdef UINT128_MAX 95 || !TEST_size_t_eq(sizeof(int128_t), 16) 96 || !TEST_size_t_eq(sizeof(uint128_t), 16) 97 #endif 98 || !TEST_size_t_eq(sizeof(char), 1) 99 || !TEST_size_t_eq(sizeof(unsigned char), 1)) 100 return 0; 101 102 /* We want our long longs to be at least 64 bits */ 103 if (!TEST_size_t_ge(sizeof(long long int), 8) 104 || !TEST_size_t_ge(sizeof(unsigned long long int), 8)) 105 return 0; 106 107 /* 108 * Verify intmax_t. 109 * Some platforms defined intmax_t to be 64 bits but still support 110 * an int128_t, so this check is for at least 64 bits. 111 */ 112 if (!TEST_size_t_ge(sizeof(ossl_intmax_t), 8) 113 || !TEST_size_t_ge(sizeof(ossl_uintmax_t), 8) 114 || !TEST_size_t_ge(sizeof(ossl_uintmax_t), sizeof(size_t))) 115 return 0; 116 117 /* This isn't possible to check using the framework functions */ 118 if (SIZE_MAX < INT_MAX) { 119 TEST_error("int must not be wider than size_t"); 120 return 0; 121 } 122 123 /* SIZE_MAX is always greater than 2*INT_MAX */ 124 if (SIZE_MAX - INT_MAX <= INT_MAX) { 125 TEST_error("SIZE_MAX must exceed 2*INT_MAX"); 126 return 0; 127 } 128 129 return 1; 130 } 131 132 static int test_sanity_memcmp(void) 133 { 134 return CRYPTO_memcmp("ab", "cd", 2); 135 } 136 137 static const struct sleep_test_vector { 138 uint64_t val; 139 } sleep_test_vectors[] = { { 0 }, { 1 }, { 999 }, { 1000 } }; 140 141 #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L 142 static void 143 alrm_handler(int sig) 144 { 145 } 146 #endif /* defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L */ 147 148 static int test_sanity_sleep(int i) 149 { 150 const struct sleep_test_vector * const td = sleep_test_vectors + i; 151 OSSL_TIME start = ossl_time_now(); 152 uint64_t ms; 153 154 #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L 155 /* 156 * Set up an interrupt timer to check that OSSL_sleep doesn't return early 157 * due to interrupts. 158 */ 159 do { 160 static const struct itimerval it = { { 0, 111111 } }; 161 struct sigaction sa; 162 sigset_t mask; 163 164 memset(&sa, 0, sizeof(sa)); 165 sa.sa_handler = alrm_handler; 166 167 if (sigaction(SIGALRM, &sa, NULL)) { 168 TEST_perror("test_sanity_sleep: sigaction"); 169 break; 170 } 171 172 sigemptyset(&mask); 173 sigaddset(&mask, SIGALRM); 174 if (sigprocmask(SIG_UNBLOCK, &mask, NULL)) { 175 TEST_perror("test_sanity_sleep: sigprocmask"); 176 break; 177 } 178 179 if (setitimer(ITIMER_REAL, &it, NULL)) { 180 TEST_perror("test_sanity_sleep: arm setitimer"); 181 break; 182 } 183 } while (0); 184 #endif /* defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L */ 185 186 /* 187 * On any reasonable system this must sleep at least the specified time 188 * but not more than 20 seconds more than that. 189 */ 190 OSSL_sleep(td->val); 191 192 #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L 193 /* disarm the timer */ 194 do { 195 static const struct itimerval it; 196 197 if (setitimer(ITIMER_REAL, &it, NULL)) { 198 TEST_perror("test_sanity_sleep: disarm setitimer"); 199 break; 200 } 201 } while (0); 202 #endif /* defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L */ 203 204 ms = ossl_time2ms(ossl_time_subtract(ossl_time_now(), start)); 205 206 if (!TEST_uint64_t_ge(ms, td->val) + !TEST_uint64_t_le(ms, td->val + 20000)) 207 return 0; 208 return 1; 209 } 210 211 int setup_tests(void) 212 { 213 ADD_TEST(test_sanity_null_zero); 214 ADD_TEST(test_sanity_enum_size); 215 ADD_TEST(test_sanity_twos_complement); 216 ADD_TEST(test_sanity_sign); 217 ADD_TEST(test_sanity_unsigned_conversion); 218 ADD_TEST(test_sanity_range); 219 ADD_TEST(test_sanity_memcmp); 220 ADD_ALL_TESTS(test_sanity_sleep, OSSL_NELEM(sleep_test_vectors)); 221 return 1; 222 } 223