SecurityAccess - Seed & Key Exchange

/* UDS 0x27: SecurityAccess — 4-step seed-key protocol */
/* Level 1: workshop access (sub-functions 0x01/0x02) */
/* Level 2: reprogramming access (sub-functions 0x03/0x04) */

#include 
#include "Rng.h"
#include "Hsm.h"

typedef struct {
    uint32_t seed;          /* last generated seed */
    uint8_t  fail_count;    /* consecutive wrong-key count */
    uint32_t lockout_timer; /* ticks remaining in lockout */
    boolean  seed_valid;    /* seed was generated and not yet used */
} SecurityState_t;

static SecurityState_t g_sec_state[2];  /* index 0=Level1, index 1=Level2 */

Std_ReturnType SA_RequestSeed(uint8_t level_idx, uint8_t *seed_out, uint16_t *seed_len)
{
    SecurityState_t *state = &g_sec_state[level_idx];

    /* Check: not in lockout */
    if (state->lockout_timer > 0u) {
        return E_NOT_OK;  /* NRC 0x37: requiredTimeDelayNotExpired */
    }

    /* Already unlocked at this level? Return all zeros (seed = 0 means already unlocked) */
    if (Dcm_GetSecurityLevel() >= (level_idx + 1u)) {
        seed_out[0]=0; seed_out[1]=0; seed_out[2]=0; seed_out[3]=0;
        *seed_len = 4u;
        return E_OK;
    }

    /* Generate random seed via TRNG (hardware random number generator) */
    state->seed = Rng_GetRandom32();
    state->seed_valid = TRUE;

    seed_out[0] = (uint8_t)(state->seed >> 24u);
    seed_out[1] = (uint8_t)(state->seed >> 16u);
    seed_out[2] = (uint8_t)(state->seed >>  8u);
    seed_out[3] = (uint8_t)(state->seed);
    *seed_len = 4u;
    return E_OK;
}

Std_ReturnType SA_VerifyKey(uint8_t level_idx, const uint8_t *key_in, uint16_t key_len)
{
    SecurityState_t *state = &g_sec_state[level_idx];

    if (!state->seed_valid || key_len != 4u) {
        return E_NOT_OK;  /* NRC 0x24: requestSequenceError */
    }
    state->seed_valid = FALSE;

    /* Compute expected key from seed */
    uint32_t expected_key = SA_ComputeKey(state->seed, level_idx);
    uint32_t received_key = ((uint32_t)key_in[0] << 24u) | ((uint32_t)key_in[1] << 16u)
                           | ((uint32_t)key_in[2] <<  8u) |  (uint32_t)key_in[3];

    if (received_key != expected_key) {
        state->fail_count++;
        if (state->fail_count >= 5u) {
            state->lockout_timer = LOCKOUT_10MIN_TICKS;  /* NRC 0x37 for 10 min */
            state->fail_count = 0u;
        }
        return E_NOT_OK;  /* NRC 0x35: invalidKey */
    }

    state->fail_count = 0u;
    Dcm_SetSecurityLevel(level_idx + 1u);
    return E_OK;
}

/* Production key algorithm: HMAC-SHA256 with HSM-stored secret */
/* NEVER use XOR or simple arithmetic in production — trivially reverse-engineered */

#include "Hsm.h"

/* Key derivation: HMAC-SHA256(secret_key, seed || ECU_serial || session_level) */
/* secret_key stored in HSM OTP — never accessible to software */

uint32_t SA_ComputeKey(uint32_t seed, uint8_t level)
{
    uint8_t input[9];
    input[0] = (uint8_t)(seed >> 24u);
    input[1] = (uint8_t)(seed >> 16u);
    input[2] = (uint8_t)(seed >>  8u);
    input[3] = (uint8_t) seed;
    input[4] = (uint8_t)(ECU_SERIAL >> 24u);
    input[5] = (uint8_t)(ECU_SERIAL >> 16u);
    input[6] = (uint8_t)(ECU_SERIAL >>  8u);
    input[7] = (uint8_t) ECU_SERIAL;
    input[8] = level;

    uint8_t hmac[32];  /* 256-bit HMAC output */
    Hsm_ComputeHmacSha256(HSM_KEY_SLOT_SA_LEVEL1 + level,
                           input, sizeof(input),
                           hmac);

    /* Truncate to 4 bytes (32 bits) for wire format */
    return ((uint32_t)hmac[0] << 24u) | ((uint32_t)hmac[1] << 16u)
           | ((uint32_t)hmac[2] <<  8u) |  (uint32_t)hmac[3];
}

/* Development alternative (NEVER production): simple XOR for lab testing */
uint32_t SA_ComputeKey_Dev(uint32_t seed, uint8_t level)
{
    (void)level;
    return seed ^ 0xDEADC0DEu;  /* trivially broken — for lab only */
}

/* Workshop tester: runs same HMAC algorithm on PC */
/* OEM distributes key DLL/library to authorised workshop tools */
/* Seed → key computation happens on tester side, not shared as algorithm