1 /** 2 * \file common.h 3 * 4 * \brief Utility macros for internal use in the library 5 */ 6 /* 7 * Copyright The Mbed TLS Contributors 8 * SPDX-License-Identifier: Apache-2.0 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); you may 11 * not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 18 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 */ 22 23 #ifndef MBEDTLS_LIBRARY_COMMON_H 24 #define MBEDTLS_LIBRARY_COMMON_H 25 26 #include "mbedtls/build_info.h" 27 28 #include <stdint.h> 29 30 /** Helper to define a function as static except when building invasive tests. 31 * 32 * If a function is only used inside its own source file and should be 33 * declared `static` to allow the compiler to optimize for code size, 34 * but that function has unit tests, define it with 35 * ``` 36 * MBEDTLS_STATIC_TESTABLE int mbedtls_foo(...) { ... } 37 * ``` 38 * and declare it in a header in the `library/` directory with 39 * ``` 40 * #if defined(MBEDTLS_TEST_HOOKS) 41 * int mbedtls_foo(...); 42 * #endif 43 * ``` 44 */ 45 #if defined(MBEDTLS_TEST_HOOKS) 46 #define MBEDTLS_STATIC_TESTABLE 47 #else 48 #define MBEDTLS_STATIC_TESTABLE static 49 #endif 50 51 #if defined(MBEDTLS_TEST_HOOKS) 52 extern void (*mbedtls_test_hook_test_fail)( const char * test, int line, const char * file ); 53 #define MBEDTLS_TEST_HOOK_TEST_ASSERT( TEST ) \ 54 do { \ 55 if( ( ! ( TEST ) ) && ( ( *mbedtls_test_hook_test_fail ) != NULL ) ) \ 56 { \ 57 ( *mbedtls_test_hook_test_fail )( #TEST, __LINE__, __FILE__ ); \ 58 } \ 59 } while( 0 ) 60 #else 61 #define MBEDTLS_TEST_HOOK_TEST_ASSERT( TEST ) 62 #endif /* defined(MBEDTLS_TEST_HOOKS) */ 63 64 /** Allow library to access its structs' private members. 65 * 66 * Although structs defined in header files are publicly available, 67 * their members are private and should not be accessed by the user. 68 */ 69 #define MBEDTLS_ALLOW_PRIVATE_ACCESS 70 71 /** Byte Reading Macros 72 * 73 * Given a multi-byte integer \p x, MBEDTLS_BYTE_n retrieves the n-th 74 * byte from x, where byte 0 is the least significant byte. 75 */ 76 #define MBEDTLS_BYTE_0( x ) ( (uint8_t) ( ( x ) & 0xff ) ) 77 #define MBEDTLS_BYTE_1( x ) ( (uint8_t) ( ( ( x ) >> 8 ) & 0xff ) ) 78 #define MBEDTLS_BYTE_2( x ) ( (uint8_t) ( ( ( x ) >> 16 ) & 0xff ) ) 79 #define MBEDTLS_BYTE_3( x ) ( (uint8_t) ( ( ( x ) >> 24 ) & 0xff ) ) 80 #define MBEDTLS_BYTE_4( x ) ( (uint8_t) ( ( ( x ) >> 32 ) & 0xff ) ) 81 #define MBEDTLS_BYTE_5( x ) ( (uint8_t) ( ( ( x ) >> 40 ) & 0xff ) ) 82 #define MBEDTLS_BYTE_6( x ) ( (uint8_t) ( ( ( x ) >> 48 ) & 0xff ) ) 83 #define MBEDTLS_BYTE_7( x ) ( (uint8_t) ( ( ( x ) >> 56 ) & 0xff ) ) 84 85 /** 86 * Get the unsigned 32 bits integer corresponding to four bytes in 87 * big-endian order (MSB first). 88 * 89 * \param data Base address of the memory to get the four bytes from. 90 * \param offset Offset from \p data of the first and most significant 91 * byte of the four bytes to build the 32 bits unsigned 92 * integer from. 93 */ 94 #ifndef MBEDTLS_GET_UINT32_BE 95 #define MBEDTLS_GET_UINT32_BE( data , offset ) \ 96 ( \ 97 ( (uint32_t) ( data )[( offset ) ] << 24 ) \ 98 | ( (uint32_t) ( data )[( offset ) + 1] << 16 ) \ 99 | ( (uint32_t) ( data )[( offset ) + 2] << 8 ) \ 100 | ( (uint32_t) ( data )[( offset ) + 3] ) \ 101 ) 102 #endif 103 104 /** 105 * Put in memory a 32 bits unsigned integer in big-endian order. 106 * 107 * \param n 32 bits unsigned integer to put in memory. 108 * \param data Base address of the memory where to put the 32 109 * bits unsigned integer in. 110 * \param offset Offset from \p data where to put the most significant 111 * byte of the 32 bits unsigned integer \p n. 112 */ 113 #ifndef MBEDTLS_PUT_UINT32_BE 114 #define MBEDTLS_PUT_UINT32_BE( n, data, offset ) \ 115 { \ 116 ( data )[( offset ) ] = MBEDTLS_BYTE_3( n ); \ 117 ( data )[( offset ) + 1] = MBEDTLS_BYTE_2( n ); \ 118 ( data )[( offset ) + 2] = MBEDTLS_BYTE_1( n ); \ 119 ( data )[( offset ) + 3] = MBEDTLS_BYTE_0( n ); \ 120 } 121 #endif 122 123 /** 124 * Get the unsigned 32 bits integer corresponding to four bytes in 125 * little-endian order (LSB first). 126 * 127 * \param data Base address of the memory to get the four bytes from. 128 * \param offset Offset from \p data of the first and least significant 129 * byte of the four bytes to build the 32 bits unsigned 130 * integer from. 131 */ 132 #ifndef MBEDTLS_GET_UINT32_LE 133 #define MBEDTLS_GET_UINT32_LE( data, offset ) \ 134 ( \ 135 ( (uint32_t) ( data )[( offset ) ] ) \ 136 | ( (uint32_t) ( data )[( offset ) + 1] << 8 ) \ 137 | ( (uint32_t) ( data )[( offset ) + 2] << 16 ) \ 138 | ( (uint32_t) ( data )[( offset ) + 3] << 24 ) \ 139 ) 140 #endif 141 142 /** 143 * Put in memory a 32 bits unsigned integer in little-endian order. 144 * 145 * \param n 32 bits unsigned integer to put in memory. 146 * \param data Base address of the memory where to put the 32 147 * bits unsigned integer in. 148 * \param offset Offset from \p data where to put the least significant 149 * byte of the 32 bits unsigned integer \p n. 150 */ 151 #ifndef MBEDTLS_PUT_UINT32_LE 152 #define MBEDTLS_PUT_UINT32_LE( n, data, offset ) \ 153 { \ 154 ( data )[( offset ) ] = MBEDTLS_BYTE_0( n ); \ 155 ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n ); \ 156 ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n ); \ 157 ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n ); \ 158 } 159 #endif 160 161 /** 162 * Get the unsigned 16 bits integer corresponding to two bytes in 163 * little-endian order (LSB first). 164 * 165 * \param data Base address of the memory to get the two bytes from. 166 * \param offset Offset from \p data of the first and least significant 167 * byte of the two bytes to build the 16 bits unsigned 168 * integer from. 169 */ 170 #ifndef MBEDTLS_GET_UINT16_LE 171 #define MBEDTLS_GET_UINT16_LE( data, offset ) \ 172 ( \ 173 ( (uint16_t) ( data )[( offset ) ] ) \ 174 | ( (uint16_t) ( data )[( offset ) + 1] << 8 ) \ 175 ) 176 #endif 177 178 /** 179 * Put in memory a 16 bits unsigned integer in little-endian order. 180 * 181 * \param n 16 bits unsigned integer to put in memory. 182 * \param data Base address of the memory where to put the 16 183 * bits unsigned integer in. 184 * \param offset Offset from \p data where to put the least significant 185 * byte of the 16 bits unsigned integer \p n. 186 */ 187 #ifndef MBEDTLS_PUT_UINT16_LE 188 #define MBEDTLS_PUT_UINT16_LE( n, data, offset ) \ 189 { \ 190 ( data )[( offset ) ] = MBEDTLS_BYTE_0( n ); \ 191 ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n ); \ 192 } 193 #endif 194 195 /** 196 * Get the unsigned 16 bits integer corresponding to two bytes in 197 * big-endian order (MSB first). 198 * 199 * \param data Base address of the memory to get the two bytes from. 200 * \param offset Offset from \p data of the first and most significant 201 * byte of the two bytes to build the 16 bits unsigned 202 * integer from. 203 */ 204 #ifndef MBEDTLS_GET_UINT16_BE 205 #define MBEDTLS_GET_UINT16_BE( data, offset ) \ 206 ( \ 207 ( (uint16_t) ( data )[( offset ) ] << 8 ) \ 208 | ( (uint16_t) ( data )[( offset ) + 1] ) \ 209 ) 210 #endif 211 212 /** 213 * Put in memory a 16 bits unsigned integer in big-endian order. 214 * 215 * \param n 16 bits unsigned integer to put in memory. 216 * \param data Base address of the memory where to put the 16 217 * bits unsigned integer in. 218 * \param offset Offset from \p data where to put the most significant 219 * byte of the 16 bits unsigned integer \p n. 220 */ 221 #ifndef MBEDTLS_PUT_UINT16_BE 222 #define MBEDTLS_PUT_UINT16_BE( n, data, offset ) \ 223 { \ 224 ( data )[( offset ) ] = MBEDTLS_BYTE_1( n ); \ 225 ( data )[( offset ) + 1] = MBEDTLS_BYTE_0( n ); \ 226 } 227 #endif 228 229 /** 230 * Get the unsigned 24 bits integer corresponding to three bytes in 231 * big-endian order (MSB first). 232 * 233 * \param data Base address of the memory to get the three bytes from. 234 * \param offset Offset from \p data of the first and most significant 235 * byte of the three bytes to build the 24 bits unsigned 236 * integer from. 237 */ 238 #ifndef MBEDTLS_GET_UINT24_BE 239 #define MBEDTLS_GET_UINT24_BE( data , offset ) \ 240 ( \ 241 ( (uint32_t) ( data )[( offset ) ] << 16 ) \ 242 | ( (uint32_t) ( data )[( offset ) + 1] << 8 ) \ 243 | ( (uint32_t) ( data )[( offset ) + 2] ) \ 244 ) 245 #endif 246 247 /** 248 * Put in memory a 24 bits unsigned integer in big-endian order. 249 * 250 * \param n 24 bits unsigned integer to put in memory. 251 * \param data Base address of the memory where to put the 24 252 * bits unsigned integer in. 253 * \param offset Offset from \p data where to put the most significant 254 * byte of the 24 bits unsigned integer \p n. 255 */ 256 #ifndef MBEDTLS_PUT_UINT24_BE 257 #define MBEDTLS_PUT_UINT24_BE( n, data, offset ) \ 258 { \ 259 ( data )[( offset ) ] = MBEDTLS_BYTE_2( n ); \ 260 ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n ); \ 261 ( data )[( offset ) + 2] = MBEDTLS_BYTE_0( n ); \ 262 } 263 #endif 264 265 /** 266 * Get the unsigned 24 bits integer corresponding to three bytes in 267 * little-endian order (LSB first). 268 * 269 * \param data Base address of the memory to get the three bytes from. 270 * \param offset Offset from \p data of the first and least significant 271 * byte of the three bytes to build the 24 bits unsigned 272 * integer from. 273 */ 274 #ifndef MBEDTLS_GET_UINT24_LE 275 #define MBEDTLS_GET_UINT24_LE( data, offset ) \ 276 ( \ 277 ( (uint32_t) ( data )[( offset ) ] ) \ 278 | ( (uint32_t) ( data )[( offset ) + 1] << 8 ) \ 279 | ( (uint32_t) ( data )[( offset ) + 2] << 16 ) \ 280 ) 281 #endif 282 283 /** 284 * Put in memory a 24 bits unsigned integer in little-endian order. 285 * 286 * \param n 24 bits unsigned integer to put in memory. 287 * \param data Base address of the memory where to put the 24 288 * bits unsigned integer in. 289 * \param offset Offset from \p data where to put the least significant 290 * byte of the 24 bits unsigned integer \p n. 291 */ 292 #ifndef MBEDTLS_PUT_UINT24_LE 293 #define MBEDTLS_PUT_UINT24_LE( n, data, offset ) \ 294 { \ 295 ( data )[( offset ) ] = MBEDTLS_BYTE_0( n ); \ 296 ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n ); \ 297 ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n ); \ 298 } 299 #endif 300 301 /** 302 * Get the unsigned 64 bits integer corresponding to eight bytes in 303 * big-endian order (MSB first). 304 * 305 * \param data Base address of the memory to get the eight bytes from. 306 * \param offset Offset from \p data of the first and most significant 307 * byte of the eight bytes to build the 64 bits unsigned 308 * integer from. 309 */ 310 #ifndef MBEDTLS_GET_UINT64_BE 311 #define MBEDTLS_GET_UINT64_BE( data, offset ) \ 312 ( \ 313 ( (uint64_t) ( data )[( offset ) ] << 56 ) \ 314 | ( (uint64_t) ( data )[( offset ) + 1] << 48 ) \ 315 | ( (uint64_t) ( data )[( offset ) + 2] << 40 ) \ 316 | ( (uint64_t) ( data )[( offset ) + 3] << 32 ) \ 317 | ( (uint64_t) ( data )[( offset ) + 4] << 24 ) \ 318 | ( (uint64_t) ( data )[( offset ) + 5] << 16 ) \ 319 | ( (uint64_t) ( data )[( offset ) + 6] << 8 ) \ 320 | ( (uint64_t) ( data )[( offset ) + 7] ) \ 321 ) 322 #endif 323 324 /** 325 * Put in memory a 64 bits unsigned integer in big-endian order. 326 * 327 * \param n 64 bits unsigned integer to put in memory. 328 * \param data Base address of the memory where to put the 64 329 * bits unsigned integer in. 330 * \param offset Offset from \p data where to put the most significant 331 * byte of the 64 bits unsigned integer \p n. 332 */ 333 #ifndef MBEDTLS_PUT_UINT64_BE 334 #define MBEDTLS_PUT_UINT64_BE( n, data, offset ) \ 335 { \ 336 ( data )[( offset ) ] = MBEDTLS_BYTE_7( n ); \ 337 ( data )[( offset ) + 1] = MBEDTLS_BYTE_6( n ); \ 338 ( data )[( offset ) + 2] = MBEDTLS_BYTE_5( n ); \ 339 ( data )[( offset ) + 3] = MBEDTLS_BYTE_4( n ); \ 340 ( data )[( offset ) + 4] = MBEDTLS_BYTE_3( n ); \ 341 ( data )[( offset ) + 5] = MBEDTLS_BYTE_2( n ); \ 342 ( data )[( offset ) + 6] = MBEDTLS_BYTE_1( n ); \ 343 ( data )[( offset ) + 7] = MBEDTLS_BYTE_0( n ); \ 344 } 345 #endif 346 347 /** 348 * Get the unsigned 64 bits integer corresponding to eight bytes in 349 * little-endian order (LSB first). 350 * 351 * \param data Base address of the memory to get the eight bytes from. 352 * \param offset Offset from \p data of the first and least significant 353 * byte of the eight bytes to build the 64 bits unsigned 354 * integer from. 355 */ 356 #ifndef MBEDTLS_GET_UINT64_LE 357 #define MBEDTLS_GET_UINT64_LE( data, offset ) \ 358 ( \ 359 ( (uint64_t) ( data )[( offset ) + 7] << 56 ) \ 360 | ( (uint64_t) ( data )[( offset ) + 6] << 48 ) \ 361 | ( (uint64_t) ( data )[( offset ) + 5] << 40 ) \ 362 | ( (uint64_t) ( data )[( offset ) + 4] << 32 ) \ 363 | ( (uint64_t) ( data )[( offset ) + 3] << 24 ) \ 364 | ( (uint64_t) ( data )[( offset ) + 2] << 16 ) \ 365 | ( (uint64_t) ( data )[( offset ) + 1] << 8 ) \ 366 | ( (uint64_t) ( data )[( offset ) ] ) \ 367 ) 368 #endif 369 370 /** 371 * Put in memory a 64 bits unsigned integer in little-endian order. 372 * 373 * \param n 64 bits unsigned integer to put in memory. 374 * \param data Base address of the memory where to put the 64 375 * bits unsigned integer in. 376 * \param offset Offset from \p data where to put the least significant 377 * byte of the 64 bits unsigned integer \p n. 378 */ 379 #ifndef MBEDTLS_PUT_UINT64_LE 380 #define MBEDTLS_PUT_UINT64_LE( n, data, offset ) \ 381 { \ 382 ( data )[( offset ) ] = MBEDTLS_BYTE_0( n ); \ 383 ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n ); \ 384 ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n ); \ 385 ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n ); \ 386 ( data )[( offset ) + 4] = MBEDTLS_BYTE_4( n ); \ 387 ( data )[( offset ) + 5] = MBEDTLS_BYTE_5( n ); \ 388 ( data )[( offset ) + 6] = MBEDTLS_BYTE_6( n ); \ 389 ( data )[( offset ) + 7] = MBEDTLS_BYTE_7( n ); \ 390 } 391 #endif 392 393 /* Fix MSVC C99 compatible issue 394 * MSVC support __func__ from visual studio 2015( 1900 ) 395 * Use MSVC predefine macro to avoid name check fail. 396 */ 397 #if (defined(_MSC_VER) && ( _MSC_VER <= 1900 )) 398 #define /*no-check-names*/ __func__ __FUNCTION__ 399 #endif 400 401 #endif /* MBEDTLS_LIBRARY_COMMON_H */ 402