1 /* 2 * Common and shared functions used by multiple modules in the Mbed TLS 3 * library. 4 * 5 * Copyright The Mbed TLS Contributors 6 * SPDX-License-Identifier: Apache-2.0 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); you may 9 * not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 16 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20 21 /* 22 * Ensure gmtime_r is available even with -std=c99; must be defined before 23 * mbedtls_config.h, which pulls in glibc's features.h. Harmless on other platforms 24 * except OpenBSD, where it stops us accessing explicit_bzero. 25 */ 26 #if !defined(_POSIX_C_SOURCE) && !defined(__OpenBSD__) 27 #define _POSIX_C_SOURCE 200112L 28 #endif 29 30 #if !defined(_GNU_SOURCE) 31 /* Clang requires this to get support for explicit_bzero */ 32 #define _GNU_SOURCE 33 #endif 34 35 #include "common.h" 36 37 #include "mbedtls/platform_util.h" 38 #include "mbedtls/platform.h" 39 #include "mbedtls/threading.h" 40 41 #include <stddef.h> 42 43 #ifndef __STDC_WANT_LIB_EXT1__ 44 #define __STDC_WANT_LIB_EXT1__ 1 /* Ask for the C11 gmtime_s() and memset_s() if available */ 45 #endif 46 #include <string.h> 47 48 #if defined(_WIN32) 49 #include <windows.h> 50 #endif 51 52 // Detect platforms known to support explicit_bzero() 53 #if defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 25) 54 #define MBEDTLS_PLATFORM_HAS_EXPLICIT_BZERO 1 55 #elif (defined(__FreeBSD__) && (__FreeBSD_version >= 1100037)) || defined(__OpenBSD__) 56 #define MBEDTLS_PLATFORM_HAS_EXPLICIT_BZERO 1 57 #endif 58 59 #if !defined(MBEDTLS_PLATFORM_ZEROIZE_ALT) 60 61 #undef HAVE_MEMORY_SANITIZER 62 #if defined(__has_feature) 63 #if __has_feature(memory_sanitizer) 64 #include <sanitizer/msan_interface.h> 65 #define HAVE_MEMORY_SANITIZER 66 #endif 67 #endif 68 69 /* 70 * Where possible, we try to detect the presence of a platform-provided 71 * secure memset, such as explicit_bzero(), that is safe against being optimized 72 * out, and use that. 73 * 74 * For other platforms, we provide an implementation that aims not to be 75 * optimized out by the compiler. 76 * 77 * This implementation for mbedtls_platform_zeroize() was inspired from Colin 78 * Percival's blog article at: 79 * 80 * http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html 81 * 82 * It uses a volatile function pointer to the standard memset(). Because the 83 * pointer is volatile the compiler expects it to change at 84 * any time and will not optimize out the call that could potentially perform 85 * other operations on the input buffer instead of just setting it to 0. 86 * Nevertheless, as pointed out by davidtgoldblatt on Hacker News 87 * (refer to http://www.daemonology.net/blog/2014-09-05-erratum.html for 88 * details), optimizations of the following form are still possible: 89 * 90 * if (memset_func != memset) 91 * memset_func(buf, 0, len); 92 * 93 * Note that it is extremely difficult to guarantee that 94 * the memset() call will not be optimized out by aggressive compilers 95 * in a portable way. For this reason, Mbed TLS also provides the configuration 96 * option MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure 97 * mbedtls_platform_zeroize() to use a suitable implementation for their 98 * platform and needs. 99 */ 100 #if !defined(MBEDTLS_PLATFORM_HAS_EXPLICIT_BZERO) && !defined(__STDC_LIB_EXT1__) \ 101 && !defined(_WIN32) 102 static void *(*const volatile memset_func)(void *, int, size_t) = memset; 103 #endif 104 105 void mbedtls_platform_zeroize(void *buf, size_t len) 106 { 107 MBEDTLS_INTERNAL_VALIDATE(len == 0 || buf != NULL); 108 109 if (len > 0) { 110 #if defined(MBEDTLS_PLATFORM_HAS_EXPLICIT_BZERO) 111 explicit_bzero(buf, len); 112 #if defined(HAVE_MEMORY_SANITIZER) 113 /* You'd think that Msan would recognize explicit_bzero() as 114 * equivalent to bzero(), but it actually doesn't on several 115 * platforms, including Linux (Ubuntu 20.04). 116 * https://github.com/google/sanitizers/issues/1507 117 * https://github.com/openssh/openssh-portable/commit/74433a19bb6f4cef607680fa4d1d7d81ca3826aa 118 */ 119 __msan_unpoison(buf, len); 120 #endif 121 #elif defined(__STDC_LIB_EXT1__) 122 memset_s(buf, len, 0, len); 123 #elif defined(_WIN32) 124 SecureZeroMemory(buf, len); 125 #else 126 memset_func(buf, 0, len); 127 #endif 128 } 129 } 130 #endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */ 131 132 #if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT) 133 #include <time.h> 134 #if !defined(_WIN32) && (defined(unix) || \ 135 defined(__unix) || defined(__unix__) || (defined(__APPLE__) && \ 136 defined(__MACH__))) 137 #include <unistd.h> 138 #endif /* !_WIN32 && (unix || __unix || __unix__ || 139 * (__APPLE__ && __MACH__)) */ 140 141 #if !((defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L) || \ 142 (defined(_POSIX_THREAD_SAFE_FUNCTIONS) && \ 143 _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L)) 144 /* 145 * This is a convenience shorthand macro to avoid checking the long 146 * preprocessor conditions above. Ideally, we could expose this macro in 147 * platform_util.h and simply use it in platform_util.c, threading.c and 148 * threading.h. However, this macro is not part of the Mbed TLS public API, so 149 * we keep it private by only defining it in this file 150 */ 151 #if !(defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)) || \ 152 (defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)) 153 #define PLATFORM_UTIL_USE_GMTIME 154 #endif 155 156 #endif /* !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) || \ 157 ( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) && \ 158 _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L ) ) */ 159 160 struct tm *mbedtls_platform_gmtime_r(const mbedtls_time_t *tt, 161 struct tm *tm_buf) 162 { 163 #if defined(_WIN32) && !defined(PLATFORM_UTIL_USE_GMTIME) 164 #if defined(__STDC_LIB_EXT1__) 165 return (gmtime_s(tt, tm_buf) == 0) ? NULL : tm_buf; 166 #else 167 /* MSVC and mingw64 argument order and return value are inconsistent with the C11 standard */ 168 return (gmtime_s(tm_buf, tt) == 0) ? tm_buf : NULL; 169 #endif 170 #elif !defined(PLATFORM_UTIL_USE_GMTIME) 171 return gmtime_r(tt, tm_buf); 172 #else 173 struct tm *lt; 174 175 #if defined(MBEDTLS_THREADING_C) 176 if (mbedtls_mutex_lock(&mbedtls_threading_gmtime_mutex) != 0) { 177 return NULL; 178 } 179 #endif /* MBEDTLS_THREADING_C */ 180 181 lt = gmtime(tt); 182 183 if (lt != NULL) { 184 memcpy(tm_buf, lt, sizeof(struct tm)); 185 } 186 187 #if defined(MBEDTLS_THREADING_C) 188 if (mbedtls_mutex_unlock(&mbedtls_threading_gmtime_mutex) != 0) { 189 return NULL; 190 } 191 #endif /* MBEDTLS_THREADING_C */ 192 193 return (lt == NULL) ? NULL : tm_buf; 194 #endif /* _WIN32 && !EFIX64 && !EFI32 */ 195 } 196 #endif /* MBEDTLS_HAVE_TIME_DATE && MBEDTLS_PLATFORM_GMTIME_R_ALT */ 197 198 #if defined(MBEDTLS_TEST_HOOKS) 199 void (*mbedtls_test_hook_test_fail)(const char *, int, const char *); 200 #endif /* MBEDTLS_TEST_HOOKS */ 201 202 /* 203 * Provide external definitions of some inline functions so that the compiler 204 * has the option to not inline them 205 */ 206 extern inline void mbedtls_xor(unsigned char *r, 207 const unsigned char *a, 208 const unsigned char *b, 209 size_t n); 210 211 extern inline uint16_t mbedtls_get_unaligned_uint16(const void *p); 212 213 extern inline void mbedtls_put_unaligned_uint16(void *p, uint16_t x); 214 215 extern inline uint32_t mbedtls_get_unaligned_uint32(const void *p); 216 217 extern inline void mbedtls_put_unaligned_uint32(void *p, uint32_t x); 218 219 extern inline uint64_t mbedtls_get_unaligned_uint64(const void *p); 220 221 extern inline void mbedtls_put_unaligned_uint64(void *p, uint64_t x); 222