Hands-On: SecOC Implementation

  SecOcTxPduProcessing_EngTorqueCmd

  
  48

  
  64
  16

  
  TRUE

  
  
    /CryptoConfig/CsmJobs/CsmJob_AES128_CMAC_Generate
  

  
  
    /Com/ComConfig/ComIPdus/EngTorqueCmd_Authentic_PDU
  




  SecOcRxPduProcessing_EngTorqueCmd
  48
  64
  16
  
  10
  
  DROP_NEWEST

/* SecOC FreshnessManagement callout implementation */
/* Two strategies: counter-based (NVM) and time-based (StbM) */

#include "SecOC.h"
#include "NvM.h"
#include "StbM.h"

/* Strategy A: Counter-based FV */
/* FV = TripCounter[16-bit] || MessageCounter[48-bit] */

static uint16 trip_counter;      /* persisted in NVM; incremented on ECU reset */
static uint64 message_counter;   /* RAM only; reset to 0 on ECU reset */

Std_ReturnType SecOC_GetTxFreshness(uint16 freshnessValueId,
                                     uint8* freshnessValue, uint32* freshnessValueLength)
{
    uint64 full_fv;
    message_counter++;  /* increment per transmission */

    /* Build 64-bit FV: [TripCounter 16b][MessageCounter 48b] */
    full_fv = ((uint64)trip_counter << 48) | (message_counter & 0xFFFFFFFFFFFFULL);

    /* Store full FV big-endian */
    for (int i = 7; i >= 0; i--) {
        freshnessValue[i] = (uint8)(full_fv & 0xFF);
        full_fv >>= 8;
    }
    *freshnessValueLength = 8;  /* 64 bits */
    return E_OK;
}

/* Called by ComM before power-off: persist trip counter to NVM */
void SecOC_PreSleep_PersistFV(void)
{
    trip_counter++;  /* increment for next ignition cycle */
    NvM_WriteBlock(NVM_BLOCK_SECOC_TRIP_COUNTER, &trip_counter);
    NvM_WriteBlock(NVM_BLOCK_SECOC_MSG_COUNTER, &message_counter);
}

/* Strategy B: Time-based FV using AUTOSAR StbM (nanosecond timestamp) */
Std_ReturnType SecOC_GetTxFreshness_TimeBased(uint16 freshnessValueId,
                                               uint8* freshnessValue, uint32* freshnessValueLength)
{
    StbM_TimeStampType timestamp;
    StbM_UserDataType  userData;
    StbM_GetCurrentTime(STBM_SYNC_TIME_BASE_ETHERNET, ×tamp, &userData);

    /* Use lower 64 bits of timestamp as FV */
    uint64 fv_time = ((uint64)timestamp.seconds << 32) | timestamp.nanoseconds;
    memcpy(freshnessValue, &fv_time, 8);
    *freshnessValueLength = 8;
    return E_OK;
}

/* CANoe CAPL: SecOC integration test simulation */
/* Inject authentic frames and attack frames, verify ECU response */

variables {
    byte test_key[16] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
                         0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10};
    int authentic_frames_sent = 0;
    int attack_frames_sent    = 0;
    int attack_frames_detected = 0;
}

/* Inject authentic frame with correct CMAC */
void InjectAuthenticFrame(long pdu_id, byte* payload, int len)
{
    byte secured_pdu[64];
    byte fv[2];      /* 16-bit truncated freshness value */
    byte mac[6];     /* 48-bit truncated MAC */

    /* Build secured PDU: payload || FV || MAC */
    memcpy(secured_pdu, payload, len);
    /* FV: current counter value (simplified for test) */
    fv[0] = (authentic_frames_sent >> 8) & 0xFF;
    fv[1] =  authentic_frames_sent & 0xFF;
    memcpy(secured_pdu + len, fv, 2);

    /* Compute AES-128-CMAC using test key (SHE mock in CANoe) */
    ComputeCMAC_AES128(test_key, secured_pdu, len + 2, mac, 6);
    memcpy(secured_pdu + len + 2, mac, 6);

    /* Transmit secured PDU on CAN bus */
    CanOutputPDU(pdu_id, secured_pdu, len + 8);
    authentic_frames_sent++;
}

/* Inject attack frame with random (wrong) MAC */
void InjectAttackFrame(long pdu_id, byte* payload, int len)
{
    byte secured_pdu[64];
    memcpy(secured_pdu, payload, len);
    /* Random FV and MAC — will fail SecOC verification */
    GetRandomBytes(secured_pdu + len, 8);
    CanOutputPDU(pdu_id, secured_pdu, len + 8);
    attack_frames_sent++;
}

/* Monitor DEM events: SecOC verification failure */
on envVar SecOC_VerificationStatus_EngTorqueCmd {
    if (@this == FAILED) {
        attack_frames_detected++;
        write("SecOC ATTACK DETECTED: frame %d — DEM event logged", attack_frames_sent);
    }
}

on start {
    /* Test sequence: 10 authentic, 5 attack, 10 authentic */
    byte eng_payload[8] = {0x01,0x02,0x00,0x00,0x00,0x00,0x00,0x00};
    int i;
    for (i = 0; i < 10; i++) InjectAuthenticFrame(0x100, eng_payload, 8);
    for (i = 0; i <  5; i++) InjectAttackFrame(0x100, eng_payload, 8);
    for (i = 0; i < 10; i++) InjectAuthenticFrame(0x100, eng_payload, 8);
}

on stop {
    write("Test summary: %d authentic / %d attacks / %d detected (must = %d)",
          authentic_frames_sent, attack_frames_sent, attack_frames_detected, attack_frames_sent);
}