MCUX CLNS
MCUX Crypto Library Normal Secure
 
Loading...
Searching...
No Matches
mcuxCsslFlowProtection_SecureCounter_Local.h
Go to the documentation of this file.
1/*--------------------------------------------------------------------------*/
2/* Copyright 2020-2023 NXP */
3/* */
4/* NXP Confidential. This software is owned or controlled by NXP and may */
5/* only be used strictly in accordance with the applicable license terms. */
6/* By expressly accepting such terms or by downloading, installing, */
7/* activating and/or otherwise using the software, you are agreeing that */
8/* you have read, and that you agree to comply with and are bound by, such */
9/* license terms. If you do not agree to be bound by the applicable license */
10/* terms, then you may not retain, install, activate or otherwise use the */
11/* software. */
12/*--------------------------------------------------------------------------*/
13
19#ifndef MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_LOCAL_H_
20#define MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_LOCAL_H_
21
22/* Include the CSSL C pre-processor support functionality. */
24
25/* Include the CSSL secure counter mechanism as basic building block. */
27
28/* Include the C99 standard integer types. */
29#include <stdint.h>
30
31/* Include standard boolean types */
32#include <stdbool.h>
33
34
45#define MCUX_CSSL_FP_PROTECTED_TYPE_IMPL(resultType) \
46 uint64_t
47
62#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPLn(function, ...) \
63 MCUX_CSSL_SC_INIT( \
64 MCUX_CSSL_FP_FUNCTION_ID_ENTRY_PART(function) \
65 - (MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__)) \
66 )
67
80#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL1(function) \
81 MCUX_CSSL_FP_FUNCTION_ENTRY_IMPLn(function, 0u)
82
100#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL(...) \
101 MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL, __VA_ARGS__)
102
103
122#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, result, ...) \
123 MCUX_CSSL_SC_ADD( \
124 MCUX_CSSL_FP_FUNCTION_ID_EXIT_PART(id) \
125 - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
126 ); \
127 return (MCUX_CSSL_FP_RESULT_VALUE(result) \
128 | MCUX_CSSL_FP_PROTECTION_TOKEN_VALUE(MCUX_CSSL_FP_COUNTER_COMPRESSED()))
129
144#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL1(id) \
145 MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, 0u, 0u)
146
163#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL2(id, result) \
164 MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, result, 0u)
165
188#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(...) \
189 MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_FUNCTION_EXIT_IMPL, __VA_ARGS__)
190
216#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPLn(id, pass, fail, ...) \
217 MCUX_CSSL_SC_ADD( \
218 MCUX_CSSL_FP_FUNCTION_ID_EXIT_PART(id) \
219 - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
220 ); \
221 return (MCUX_CSSL_FP_RESULT_VALUE( \
222 (MCUX_CSSL_SC_CHECK_PASSED == \
223 MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_FUNCTION_VALUE(id))) \
224 ? pass : fail) \
225 | MCUX_CSSL_FP_PROTECTION_TOKEN_VALUE(MCUX_CSSL_FP_COUNTER_COMPRESSED()))
226
248#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL3(id, pass, fail) \
249 MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPLn(id, pass, fail, 0u)
250
278#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL(...) \
279 MCUX_CSSL_CPP_OVERLOADED3(MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL, __VA_ARGS__)
280
290#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL1(id) \
291 MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(id, 0U)
292
304#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPLn(id, ...) \
305 MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(id, 0U, __VA_ARGS__)
306
318#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL(...) \
319 MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL, __VA_ARGS__)
320
330#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL3(type, result, call) \
331 const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
332 MCUX_CSSL_SC_ADD_ON_CALL( \
333 MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
334 type const result = MCUX_CSSL_FP_RESULT(type, \
335 MCUX_CSSL_CPP_CAT(result, _protected))
336
345#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL2(result, call) \
346 MCUX_CSSL_FP_FUNCTION_CALL_IMPL3(uint32_t, result, call)
347
360#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL(...) \
361 MCUX_CSSL_CPP_OVERLOADED3(MCUX_CSSL_FP_FUNCTION_CALL_IMPL, __VA_ARGS__)
362
373#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_IMPL(call) \
374 { \
375 const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
376 MCUX_CSSL_SC_ADD_ON_CALL( \
377 MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
378 }
379
391#define MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call) \
392 const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
393 const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
394 MCUX_CSSL_CPP_CAT(result, _protected)); \
395 const uint32_t result = MCUX_CSSL_FP_RESULT( \
396 MCUX_CSSL_CPP_CAT(result, _protected))
397
408#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call) \
409 const uint64_t MCUX_CSSL_CPP_CAT(token, _protected) = (call); \
410 const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
411 MCUX_CSSL_CPP_CAT(token, _protected));
412
425#define MCUX_CSSL_FP_FUNCTION_CALL_BEGIN_IMPL(result, token, call) \
426do \
427{ \
428 MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call)
429
436#define MCUX_CSSL_FP_FUNCTION_CALL_END_IMPL() \
437} while (false)
438
450#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_BEGIN_IMPL(token, call) \
451do \
452{ \
453 MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call)
454
461#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_END_IMPL() \
462} while (false)
463
484#define MCUX_CSSL_FP_ASSERT_IMPL(...) \
485 if (MCUX_CSSL_SC_CHECK_PASSED != \
486 MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
487 { \
488 MCUX_CSSL_FP_ASSERT_CALLBACK(); \
489 } \
490 else if (MCUX_CSSL_SC_CHECK_PASSED != \
491 MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
492 { \
493 MCUX_CSSL_FP_ASSERT_CALLBACK(); \
494 } \
495 else {/*empty*/}
496
497#endif /* MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_LOCAL_H_ */
The default implementation is based on standard C preprocessor functionality.
Provides the API for the CSSL secure counter mechanism.