mcuxCsslFlowProtection_SecureCounter_Common.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/* Copyright 2020-2023 NXP                                                  */
/*                                                                          */
/* NXP Proprietary. This software is owned or controlled by NXP and may     */
/* only be used strictly in accordance with the applicable license terms.   */
/* By expressly accepting such terms or by downloading, installing,         */
/* activating and/or otherwise using the software, you are agreeing that    */
/* you have read, and that you agree to comply with and are bound by, such  */
/* license terms.  If you do not agree to be bound by the applicable        */
/* license terms, then you may not retain, install, activate or otherwise   */
/* use the software.                                                        */
/*--------------------------------------------------------------------------*/
 
#ifndef MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_COMMON_H_
#define MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_COMMON_H_
 
/* Include the CSSL C pre-processor support functionality. */
#include <mcuxCsslCPreProcessor.h>
#include <mcuxCsslAnalysis.h>
 
/* Include the CSSL secure counter mechanism as basic building block. */
#include <mcuxCsslSecureCounter.h>
 
/* Include the C99 standard integer types. */
#include <stdint.h>
 
#define MCUX_CSSL_FP_DECL_NAME(type, id) \
  MCUX_CSSL_CPP_CAT4(mcuxCsslFlowProtection_, type, _, id)
 
#define MCUX_CSSL_FP_DECL_IMPL(type, id) \
  MCUX_CSSL_SC_VALUE_TYPE MCUX_CSSL_FP_DECL_NAME(type, id) = \
    MCUX_CSSL_CPP_CAT3(MCUX_CSSL_FP_, type, _ID)(id)
 
#define MCUX_CSSL_FP_ID_IMPL() \
  MCUX_CSSL_CPP_CAT(__LINE__, u)
 
 
 
#define MCUX_CSSL_FP_EXPECTATIONS(...) \
  ((uint32_t) 0u + (MCUX_CSSL_CPP_MAP(MCUX_CSSL_CPP_ADD, __VA_ARGS__)))
 
#define MCUX_CSSL_FP_COUNTER_STMT_IMPL(statement) \
  MCUX_CSSL_ANALYSIS_START_PATTERN_SC_INTEGER_OVERFLOW() \
  statement \
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_SC_INTEGER_OVERFLOW()
 
#define MCUX_CSSL_FP_CONDITIONAL_IMPL(condition, ...) \
  (MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) & ((condition) ? ((uint32_t) UINT32_MAX) : ((uint32_t) 0)))
 
#define MCUX_CSSL_FP_VOID_EXPECTATION_IMPL() \
  (0u)
 
#define MCUX_CSSL_FP_EXPECT_IMPL(...) \
  MCUX_CSSL_SC_SUB( \
    MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
  )
 
 
 
#define MCUX_CSSL_FP_FUNCTION_ID(id) \
  MCUX_CSSL_CPP_CAT(MCUX_CSSL_FP_FUNCID_, id)
 
#define MCUX_CSSL_FP_FUNCTION_ID_ENTRY_MASK \
  (0x5A5A5A5Au)
 
#define MCUX_CSSL_FP_FUNCTION_ID_ENTRY_PART(id) \
  (MCUX_CSSL_FP_FUNCTION_VALUE(id) & MCUX_CSSL_FP_FUNCTION_ID_ENTRY_MASK)
 
#define MCUX_CSSL_FP_FUNCTION_ID_EXIT_PART(id) \
  (MCUX_CSSL_FP_FUNCTION_VALUE(id) - MCUX_CSSL_FP_FUNCTION_ID_ENTRY_PART(id))
 
#define MCUX_CSSL_FP_FUNCTION_DECL_IMPL(...) \
  /* Intentionally empty */
 
#define MCUX_CSSL_FP_FUNCTION_VALUE(id) \
  ((uint32_t) MCUX_CSSL_FP_FUNCTION_ID(id))
 
#define MCUX_CSSL_FP_FUNCTION_DEF_IMPL(...) \
  /* Intentionally empty. */
 
#define MCUX_CSSL_FP_FUNCTION_POINTER_IMPL(type, definition) \
  definition
 
#define MCUX_CSSL_FP_RESULT_OFFSET \
  (0u)
 
#define MCUX_CSSL_FP_RESULT_MASK \
  (0xFFFFFFFFuLL)
 
#define MCUX_CSSL_FP_RESULT_VALUE(result) \
  (((uint64_t)(result) & MCUX_CSSL_FP_RESULT_MASK) << MCUX_CSSL_FP_RESULT_OFFSET)
 
#define MCUX_CSSL_FP_RESULT_IMPL2(type, return) \
  ((type)(((return) >> MCUX_CSSL_FP_RESULT_OFFSET) & MCUX_CSSL_FP_RESULT_MASK))
 
#define MCUX_CSSL_FP_RESULT_IMPL1(return) \
  MCUX_CSSL_FP_RESULT_IMPL2(uint32_t,return)
 
#define MCUX_CSSL_FP_RESULT_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_RESULT_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_PROTECTION_OFFSET \
  (32u)
 
#define MCUX_CSSL_FP_PROTECTION_MASK \
  ((uint64_t) 0xFFFFFFFFuLL)
 
#define MCUX_CSSL_FP_PROTECTION_TOKEN_VALUE(token) \
  ((((uint64_t)(token) & MCUX_CSSL_FP_PROTECTION_MASK)) << MCUX_CSSL_FP_PROTECTION_OFFSET)
 
#define MCUX_CSSL_FP_PROTECTION_TOKEN_IMPL(return) \
  (uint32_t)(((return) >> MCUX_CSSL_FP_PROTECTION_OFFSET) & MCUX_CSSL_FP_PROTECTION_MASK)
 
#define MCUX_CSSL_FP_COUNTER_COMPRESSED() \
  MCUX_CSSL_SC_VALUE()
 
 
#define MCUX_CSSL_FP_FUNCTION_CALLED_IMPL(id) \
  MCUX_CSSL_FP_FUNCTION_VALUE(id)
 
 
#define MCUX_CSSL_FP_FUNCTION_ENTERED_IMPL(id) \
  MCUX_CSSL_FP_FUNCTION_ID_ENTRY_PART(id)
 
 
#define MCUX_CSSL_FP_LOOP_ID(id) \
  MCUX_CSSL_FP_ID_IMPL()
 
#define MCUX_CSSL_FP_LOOP_DECL_IMPL(id) \
  MCUX_CSSL_FP_DECL_IMPL(LOOP, id)
 
#define MCUX_CSSL_FP_LOOP_VALUE(id) \
  MCUX_CSSL_FP_DECL_NAME(LOOP, id)
 
#define MCUX_CSSL_FP_LOOP_ITERATION_IMPLn(id, ...) \
  MCUX_CSSL_SC_ADD( \
    MCUX_CSSL_FP_LOOP_VALUE(id) \
    - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
  )
 
#define MCUX_CSSL_FP_LOOP_ITERATION_IMPL1(id) \
  MCUX_CSSL_FP_LOOP_ITERATION_IMPLn(id, 0u)
 
#define MCUX_CSSL_FP_LOOP_ITERATION_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_LOOP_ITERATION_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_LOOP_ITERATIONS_IMPL(id, count) \
  MCUX_CSSL_ANALYSIS_START_PATTERN_SC_INTEGER_OVERFLOW() \
  ((count) * MCUX_CSSL_FP_LOOP_VALUE(id)) \
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_SC_INTEGER_OVERFLOW()
 
 
 
#define MCUX_CSSL_FP_BRANCH_ID(id) \
  MCUX_CSSL_FP_ID_IMPL()
 
#define MCUX_CSSL_FP_BRANCH_DECL_IMPL(id) \
  MCUX_CSSL_FP_DECL_IMPL(BRANCH, id)
 
#define MCUX_CSSL_FP_BRANCH_VALUE(id) \
  MCUX_CSSL_FP_DECL_NAME(BRANCH, id)
 
#define MCUX_CSSL_FP_BRANCH_POSITIVE_VALUE 0x5u
 
#define MCUX_CSSL_FP_BRANCH_NEGATIVE_VALUE 0xAu
 
#define MCUX_CSSL_FP_BRANCH_SCENARIO_IMPL(id, scenario, ...) \
  MCUX_CSSL_SC_ADD( \
    (MCUX_CSSL_FP_BRANCH_VALUE(id) * (scenario)) \
    - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
  )
 
#define MCUX_CSSL_FP_BRANCH_POSITIVE_IMPLn(id, ...) \
  MCUX_CSSL_FP_BRANCH_SCENARIO_IMPL(id, MCUX_CSSL_FP_BRANCH_POSITIVE_VALUE, \
    __VA_ARGS__)
 
#define MCUX_CSSL_FP_BRANCH_POSITIVE_IMPL1(id) \
  MCUX_CSSL_FP_BRANCH_SCENARIO_IMPL(id, MCUX_CSSL_FP_BRANCH_POSITIVE_VALUE, 0u)
 
#define MCUX_CSSL_FP_BRANCH_POSITIVE_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_BRANCH_POSITIVE_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_BRANCH_NEGATIVE_IMPLn(id, ...) \
  MCUX_CSSL_FP_BRANCH_SCENARIO_IMPL(id, MCUX_CSSL_FP_BRANCH_NEGATIVE_VALUE, \
    __VA_ARGS__)
 
#define MCUX_CSSL_FP_BRANCH_NEGATIVE_IMPL1(id) \
  MCUX_CSSL_FP_BRANCH_SCENARIO_IMPL(id, MCUX_CSSL_FP_BRANCH_NEGATIVE_VALUE, 0u)
 
#define MCUX_CSSL_FP_BRANCH_NEGATIVE_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_BRANCH_NEGATIVE_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_IMPL(id, scenario, condition) \
  MCUX_CSSL_ANALYSIS_START_PATTERN_SC_INTEGER_OVERFLOW() \
  MCUX_CSSL_FP_CONDITIONAL_IMPL(condition, \
    MCUX_CSSL_FP_BRANCH_VALUE(id) * (scenario)) \
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_SC_INTEGER_OVERFLOW()
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_POSITIVE_IMPL2(id, condition) \
  MCUX_CSSL_FP_BRANCH_TAKEN_IMPL(id, MCUX_CSSL_FP_BRANCH_POSITIVE_VALUE, condition)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_POSITIVE_IMPL1(id) \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8, "The macro does not contain a composite expression.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_DEVIATE(MISRA_C_2012_Rule_14_3, "The usage of an invariant condition here is intended to keep the macro structures more clear.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1, "True is of boolean type.") \
    MCUX_CSSL_FP_BRANCH_TAKEN_IMPL(id, MCUX_CSSL_FP_BRANCH_POSITIVE_VALUE, true) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_DEVIATE(MISRA_C_2012_Rule_14_3) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_POSITIVE_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_BRANCH_TAKEN_POSITIVE_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_NEGATIVE_IMPL2(id, condition) \
  MCUX_CSSL_FP_BRANCH_TAKEN_IMPL(id, MCUX_CSSL_FP_BRANCH_NEGATIVE_VALUE, condition)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_NEGATIVE_IMPL1(id) \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8, "The macro does not contain a composite expression.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_DEVIATE(MISRA_C_2012_Rule_14_3, "The usage of an invariant condition here is intended to keep the macro structures more clear.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1, "True is of boolean type.") \
    MCUX_CSSL_FP_BRANCH_TAKEN_IMPL(id, MCUX_CSSL_FP_BRANCH_NEGATIVE_VALUE, true) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_DEVIATE(MISRA_C_2012_Rule_14_3) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8)
 
#define MCUX_CSSL_FP_BRANCH_TAKEN_NEGATIVE_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_BRANCH_TAKEN_NEGATIVE_IMPL, __VA_ARGS__)
 
 
 
#define MCUX_CSSL_FP_SWITCH_ID(id) \
  MCUX_CSSL_FP_ID_IMPL()
 
#define MCUX_CSSL_FP_SWITCH_DECL_IMPL(id) \
    MCUX_CSSL_FP_DECL_IMPL(SWITCH, id)
 
#define MCUX_CSSL_FP_SWITCH_VALUE(id) \
  MCUX_CSSL_FP_DECL_NAME(SWITCH, id)
 
#define MCUX_CSSL_FP_SWITCH_CASE_IMPLn(id, case, ...) \
  MCUX_CSSL_SC_ADD( \
    (MCUX_CSSL_FP_SWITCH_VALUE(id) * (case)) \
    - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
  )
 
#define MCUX_CSSL_FP_SWITCH_CASE_IMPL2(id, case) \
  MCUX_CSSL_FP_SWITCH_CASE_IMPLn(id, case, 0u)
 
#define MCUX_CSSL_FP_SWITCH_CASE_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_SWITCH_CASE_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_SWITCH_DEFAULT_VALUE \
  (0xDEFAu)
 
#define MCUX_CSSL_FP_SWITCH_DEFAULT_IMPLn(id, ...) \
  MCUX_CSSL_FP_SWITCH_CASE_IMPLn( \
    id, MCUX_CSSL_FP_SWITCH_DEFAULT_VALUE, __VA_ARGS__)
 
#define MCUX_CSSL_FP_SWITCH_DEFAULT_IMPL1(id) \
  MCUX_CSSL_FP_SWITCH_DEFAULT_IMPLn(id, 0u) \
 
#define MCUX_CSSL_FP_SWITCH_DEFAULT_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_SWITCH_DEFAULT_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_IMPL3(id, case, condition) \
  MCUX_CSSL_ANALYSIS_START_PATTERN_SC_INTEGER_OVERFLOW() \
  MCUX_CSSL_FP_CONDITIONAL_IMPL(condition, \
    MCUX_CSSL_FP_SWITCH_VALUE(id) * (case)) \
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_SC_INTEGER_OVERFLOW()
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_IMPL2(id, case) \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8, "The macro does not contain a composite expression.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_DEVIATE(MISRA_C_2012_Rule_14_3, "The usage of an invariant condition here is intended to keep the macro structures more clear.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1, "True is of boolean type.") \
    MCUX_CSSL_FP_SWITCH_TAKEN_IMPL3(id, case, true) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_DEVIATE(MISRA_C_2012_Rule_14_3) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8)
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED3(MCUX_CSSL_FP_SWITCH_TAKEN_IMPL, __VA_ARGS__)
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_DEFAULT_IMPL2(id, condition) \
  MCUX_CSSL_FP_SWITCH_TAKEN_IMPL3(id, MCUX_CSSL_FP_SWITCH_DEFAULT_VALUE, condition)
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_DEFAULT_IMPL1(id) \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8, "The macro does not contain a composite expression.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_DEVIATE(MISRA_C_2012_Rule_14_3, "The usage of an invariant condition here is intended to keep the macro structures more clear.") \
  MCUX_CSSL_ANALYSIS_COVERITY_START_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1, "True is of boolean type.") \
    MCUX_CSSL_FP_SWITCH_TAKEN_DEFAULT_IMPL2(id, true) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_1) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_DEVIATE(MISRA_C_2012_Rule_14_3) \
  MCUX_CSSL_ANALYSIS_COVERITY_STOP_FALSE_POSITIVE(MISRA_C_2012_Rule_10_8)
 
#define MCUX_CSSL_FP_SWITCH_TAKEN_DEFAULT_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_SWITCH_TAKEN_DEFAULT_IMPL, __VA_ARGS__)
 
#ifndef MCUX_CSSL_FP_ASSERT_CALLBACK
  #define MCUX_CSSL_FP_ASSERT_CALLBACK() \
    return 1/0 /* Fallback ASSERT callback is used, please provide your own. */
#endif
 
#endif /* MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_COMMON_H_ */