MCUX CLNS
MCUX Crypto Library Normal Secure
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. */
23 #include <mcuxCsslCPreProcessor.h>
24 
25 /* Include the CSSL secure counter mechanism as basic building block. */
26 #include <mcuxCsslSecureCounter.h>
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 
333 #define MCUX_CSSL_FP_FUNCTION_CALL_IMPL(result, call) \
334  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
335  MCUX_CSSL_SC_ADD_ON_CALL( \
336  MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
337  const uint32_t result = MCUX_CSSL_FP_RESULT( \
338  MCUX_CSSL_CPP_CAT(result, _protected))
339 
350 #define MCUX_CSSL_FP_FUNCTION_CALL_VOID_IMPL(call) \
351  { \
352  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
353  MCUX_CSSL_SC_ADD_ON_CALL( \
354  MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
355  }
356 
368 #define MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call) \
369  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
370  const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
371  MCUX_CSSL_CPP_CAT(result, _protected)); \
372  const uint32_t result = MCUX_CSSL_FP_RESULT( \
373  MCUX_CSSL_CPP_CAT(result, _protected))
374 
385 #define MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call) \
386  const uint64_t MCUX_CSSL_CPP_CAT(token, _protected) = (call); \
387  const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
388  MCUX_CSSL_CPP_CAT(token, _protected));
389 
402 #define MCUX_CSSL_FP_FUNCTION_CALL_BEGIN_IMPL(result, token, call) \
403 do \
404 { \
405  MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call)
406 
413 #define MCUX_CSSL_FP_FUNCTION_CALL_END_IMPL() \
414 } while (false)
415 
427 #define MCUX_CSSL_FP_FUNCTION_CALL_VOID_BEGIN_IMPL(token, call) \
428 do \
429 { \
430  MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call)
431 
438 #define MCUX_CSSL_FP_FUNCTION_CALL_VOID_END_IMPL() \
439 } while (false)
440 
461 #define MCUX_CSSL_FP_ASSERT_IMPL(...) \
462  if (MCUX_CSSL_SC_CHECK_PASSED != \
463  MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
464  { \
465  MCUX_CSSL_FP_ASSERT_CALLBACK(); \
466  } \
467  else if (MCUX_CSSL_SC_CHECK_PASSED != \
468  MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
469  { \
470  MCUX_CSSL_FP_ASSERT_CALLBACK(); \
471  } \
472  else {/*empty*/}
473 
474 #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.