mcuxCsslFlowProtection_SecureCounter_Local.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/* Copyright 2020-2023, 2025 NXP                                            */
/*                                                                          */
/* NXP Confidential and 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_LOCAL_H_
#define MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_LOCAL_H_
 
/* Include the CSSL C pre-processor support functionality. */
#include <mcuxCsslCPreProcessor.h>
 
/* Include the CSSL secure counter mechanism as basic building block. */
#include <mcuxCsslSecureCounter.h>
 
/* Include Core macros for return type class checks */
#include <mcuxClCore_Macros.h>
 
/* Include the C99 standard integer types. */
#include <stdint.h>
 
/* Include standard boolean types */
#include <stdbool.h>
 
/***********************************************************************/
/* Helper Macros specific to the SC Local backend.                     */
/* Since the security counter is encoded in return values, these       */
/* act as getter and setter for the counter and result within the      */
/* encoded return code.                                                */
/***********************************************************************/

#define MCUX_CSSL_FP_RESULT_OFFSET \
  (0u)

#define MCUX_CSSL_FP_RESULT_MASK \
  (0xFFFFFFFFuLL)

#define MCUX_CSSL_FP_RESULT_VALUE(result) \
  (((uint64_t)((uint32_t)(result) & MCUX_CSSL_FP_RESULT_MASK) << MCUX_CSSL_FP_RESULT_OFFSET))

#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_COUNTER_COMPRESSED() \
  MCUX_CSSL_SC_VALUE()
 
/***********************************************************************/
/* SC Local backend implementations of top-level FP macros.            */
/***********************************************************************/

#define MCUX_CSSL_FP_PROTECTED_TYPE_IMPL(resultType) \
  uint64_t

#define MCUX_CSSL_FP_RESULT_IMPL2(type, return) \
  MCUX_CSSL_ANALYSIS_START_SUPPRESS_CAST_MAY_RESULT_IN_MISINTERPRETED_DATA("Loss of precision intended") \
  MCUX_CSSL_ANALYSIS_START_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES() \
  MCUX_CSSL_ANALYSIS_START_SUPPRESS_TYPECAST_BETWEEN_INTEGER_AND_POINTER("Proper alignment is ensured during type cast") \
  ((type)((uint32_t)(((return) >> MCUX_CSSL_FP_RESULT_OFFSET) & MCUX_CSSL_FP_RESULT_MASK))) \
  MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_TYPECAST_BETWEEN_INTEGER_AND_POINTER() \
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES() \
  MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_CAST_MAY_RESULT_IN_MISINTERPRETED_DATA()

#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_TOKEN_IMPL(return) \
  (uint32_t)(((return) >> MCUX_CSSL_FP_PROTECTION_OFFSET) & MCUX_CSSL_FP_PROTECTION_MASK)

#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPLn(function, ...) \
  MCUX_CSSL_SC_INIT( \
    MCUX_CSSL_FP_FUNCTION_ID_ENTRY_PART(function) \
    - (MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__)) \
  )

#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL1(function) \
  MCUX_CSSL_FP_FUNCTION_ENTRY_IMPLn(function, 0u)

#define MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_FUNCTION_ENTRY_IMPL, __VA_ARGS__)
 

#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, result, ...) \
  MCUX_CSSL_SC_ADD( \
    MCUX_CSSL_FP_FUNCTION_ID_EXIT_PART(id) \
    - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__) \
  ); \
  return (MCUX_CSSL_FP_RESULT_VALUE(result) \
    | MCUX_CSSL_FP_PROTECTION_TOKEN_VALUE(MCUX_CSSL_FP_COUNTER_COMPRESSED()))

#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL1(id) \
  MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, 0u, 0u)

#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL2(id, result) \
  MCUX_CSSL_FP_FUNCTION_EXIT_IMPLn(id, result, 0u)

#define MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED2(MCUX_CSSL_FP_FUNCTION_EXIT_IMPL, __VA_ARGS__)

#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPLn(id, pass, fail, ...) \
  MCUX_CSSL_SC_ADD(MCUX_CSSL_FP_FUNCTION_ID_EXIT_PART(id) - MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__)); \
  return (MCUX_CSSL_FP_RESULT_VALUE((MCUX_CSSL_SC_CHECK_PASSED == MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_FUNCTION_VALUE(id))) \
                                     ? pass \
                                     : fail) | \
          MCUX_CSSL_FP_PROTECTION_TOKEN_VALUE(MCUX_CSSL_FP_COUNTER_COMPRESSED()));

#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL3(id, pass, fail) \
  MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPLn(id, pass, fail, 0u)

#define MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED3(MCUX_CSSL_FP_FUNCTION_EXIT_WITH_CHECK_IMPL, __VA_ARGS__)

#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL1(id) \
  MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(id, 0U)

#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPLn(id, ...) \
  MCUX_CSSL_FP_FUNCTION_EXIT_IMPL(id, 0U, __VA_ARGS__)

#define MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL(...) \
  MCUX_CSSL_CPP_OVERLOADED1(MCUX_CSSL_FP_FUNCTION_EXIT_VOID_IMPL, __VA_ARGS__)

#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL3(type, result, call) \
  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
  MCUX_CSSL_SC_ADD_ON_CALL( \
    MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
  type const result = MCUX_CSSL_FP_RESULT(type, \
    MCUX_CSSL_CPP_CAT(result, _protected))

#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL2(result, call) \
  MCUX_CSSL_FP_FUNCTION_CALL_IMPL3(uint32_t, result, call)

#define MCUX_CSSL_FP_FUNCTION_CALL_IMPL(...) \
  MCUX_CSSL_ANALYSIS_START_SUPPRESS_NULL_POINTER_CONSTANT("False positive, due to macro expansion, any usage of NULL is considered as 0 by Coverity") \
  MCUX_CSSL_CPP_OVERLOADED3(MCUX_CSSL_FP_FUNCTION_CALL_IMPL, __VA_ARGS__) \
  MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_NULL_POINTER_CONSTANT()

#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_IMPL(call) \
  MCUX_CSSL_ANALYSIS_START_SUPPRESS_NULL_POINTER_CONSTANT("False positive, due to macro expansion, any usage of NULL is considered as 0 by Coverity") \
  { \
  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
  MCUX_CSSL_SC_ADD_ON_CALL( \
    MCUX_CSSL_FP_PROTECTION_TOKEN(MCUX_CSSL_CPP_CAT(result, _protected))); \
  } \
  MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_NULL_POINTER_CONSTANT()

#define MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call) \
  const uint64_t MCUX_CSSL_CPP_CAT(result, _protected) = (call); \
  const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
    MCUX_CSSL_CPP_CAT(result, _protected)); \
  const uint32_t result = MCUX_CSSL_FP_RESULT( \
    MCUX_CSSL_CPP_CAT(result, _protected))

#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call) \
  const uint64_t MCUX_CSSL_CPP_CAT(token, _protected) = (call); \
  const uint32_t token = MCUX_CSSL_FP_PROTECTION_TOKEN( \
    MCUX_CSSL_CPP_CAT(token, _protected))

#define MCUX_CSSL_FP_FUNCTION_CALL_BEGIN_IMPL(result, token, call)   \
do                                                                  \
{                                                                   \
    MCUX_CSSL_FP_FUNCTION_CALL_PROTECTED_IMPL(result, token, call)

#define MCUX_CSSL_FP_FUNCTION_CALL_END_IMPL() \
MCUX_CSSL_ANALYSIS_START_SUPPRESS_BOOLEAN_TYPE_FOR_CONDITIONAL_EXPRESSION() \
} while (false) \
MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_BOOLEAN_TYPE_FOR_CONDITIONAL_EXPRESSION()

#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_BEGIN_IMPL(token, call)   \
do                                                               \
{                                                                \
    MCUX_CSSL_FP_FUNCTION_CALL_VOID_PROTECTED_IMPL(token, call)

#define MCUX_CSSL_FP_FUNCTION_CALL_VOID_END_IMPL() \
MCUX_CSSL_ANALYSIS_START_SUPPRESS_BOOLEAN_TYPE_FOR_CONDITIONAL_EXPRESSION() \
} while (false) \
MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_BOOLEAN_TYPE_FOR_CONDITIONAL_EXPRESSION()

#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_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_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_ASSERT_IMPL(...) \
  if (MCUX_CSSL_SC_CHECK_PASSED != \
        MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
  { \
    MCUX_CSSL_FP_ASSERT_CALLBACK(); \
  } \
  else if (MCUX_CSSL_SC_CHECK_PASSED != \
        MCUX_CSSL_SC_CHECK(MCUX_CSSL_FP_EXPECTATIONS(__VA_ARGS__))) \
  { \
    MCUX_CSSL_FP_ASSERT_CALLBACK(); \
  } \
  else {/*empty*/}
 
#endif /* MCUX_CSSL_FLOW_PROTECTION_SECURE_COUNTER_LOCAL_H_ */