minimac.cpp 파일 참조

Mini-MAC 프로토콜 구현 (EEPROM 상태 관리, HMAC-MD5 기반 MAC 생성/검증) 더 자세히 ...

#include "minimac.h"

minimac.cpp에 대한 include 의존 그래프

이 파일의 소스 코드 페이지로 가기

함수
static void	debug_print_hex (const uint8_t *buf, uint16_t len)
	디버깅용: 바이트 배열을 16진수로 출력
static void	print_u64 (uint64_t v)
	디버깅용: 64비트 부호 없는 정수를 10진수 문자열로 변환해 출력
static void	compute_digest (const uint8_t *data, uint8_t len, unsigned char digest[16])
	Mini-MAC용 HMAC-MD5 다이제스트 계산
static bool	load_state (void)
	EEPROM에서 Mini-MAC 상태 불러오기
static void	save_state (void)
	Mini-MAC 상태를 EEPROM에 저장
void	minimac_init (uint16_t can_id, const uint8_t *key)
	Mini-MAC 초기화 및 EEPROM 동기화
uint8_t	minimac_sign (uint8_t *data, uint8_t payload_len)
	송신할 메시지에 Mini-MAC 태그 생성 및 내부 상태 갱신
bool	minimac_verify (const uint8_t *data, uint8_t payload_len, const uint8_t *tag)
	수신된 메시지의 Mini-MAC 태그 검증 및 상태 동기화

변수
static const int	SIG_ADDR = 0
	EEPROM 레이아웃: 시그니처 및 데이터 저장 시작 주소
static const uint32_t	SIGVAL = 0xAA55AA55
static const int	DATA_ADDR = SIG_ADDR + sizeof(SIGVAL)
static uint16_t	mm_id
	보호할 CAN ID, 그룹 키, 카운터, 메시지 히스토리
static uint8_t	mm_key [16]
	공유 그룹 키
static uint64_t	mm_counter
	64비트 메시지 카운터
static MiniMacHist	mm_hist [5]
	최근 λ개 메시지 히스토리
static uint8_t	mm_hist_cnt
	히스토리 항목 수 (≤ λ)

상세한 설명

Mini-MAC 프로토콜 구현 (EEPROM 상태 관리, HMAC-MD5 기반 MAC 생성/검증)

minimac.cpp 파일에서 정의되었습니다.

함수 문서화

compute_digest()

static void compute_digest ( const uint8_t * data, uint8_t len, unsigned char digest[16] )

static

Mini-MAC용 HMAC-MD5 다이제스트 계산

매개변수

data	서명할 페이로드 데이터 버퍼
len	페이로드 길이(Byte)
digest	결과 다이제스트 저장 버퍼(16바이트)

메시지 카운터(mm_counter), CAN ID(mm_id), 최근 메시지 히스토리(mm_hist), 그리고 현재 페이로드(data)를 하나의 연속 버퍼에 결합한 후, HMAC-MD5를 수행하여 16바이트 다이제스트를 생성한다. 각 단계별 내부 상태는 Serial 디버그 출력으로 확인 가능하다.

minimac.cpp 파일의 66 번째 라인에서 정의되었습니다.

{
    /* (1) 버퍼 크기 계산:
     *     - 메시지 카운터(mm_counter, 8바이트)
     *     - CAN ID(mm_id, 2바이트)
     *     - 과거 메시지 히스토리(mm_hist_cnt개, 각 항목 len 바이트)
     *     - 현재 페이로드(data, len 바이트)
     *   위 항목의 총합(buf_len)을 계산한 뒤, 이를 저장할 버퍼(buf)를 동적 할당.
     *   off 변수는 buf 내 현재 쓰기 위치를 나타냄.
     */
    uint16_t buf_len = 8 + 2;
    for (uint8_t i = 0; i < mm_hist_cnt; i++)
        buf_len += mm_hist[i].len;
    buf_len += len;
 
    uint8_t *buf = (uint8_t *)malloc(buf_len);
    uint16_t off = 0;
 
    /* (2) 카운터 삽입 (big-endian):
     *   - 64비트 카운터를 빅엔디안 순서로 buf[off..off+7]에 저장
     *   - Serial.print로 현재 카운터 값을 10진수 문자열로 출력
     */
    Serial.print("[DBG] counter = ");
    print_u64(mm_counter);
    Serial.println();
 
    uint64_t tmp = mm_counter;
    for (int i = 7; i >= 0; i--) {
        buf[off + i] = tmp & 0xFF;
        tmp >>= 8;
    }
    off += 8;
 
    /* (3) CAN ID 삽입:
     *   - mm_id 상위 바이트(buf[off])와 하위 바이트(buf[off+1])를 저장
     *   - Serial.print로 16진수 형태의 CAN ID 출력
     */
    buf[off++] = mm_id >> 8;
    buf[off++] = mm_id & 0xFF;
    Serial.print("[DBG] CAN ID = 0x");
    Serial.println(mm_id, HEX);
 
    /* (4) 메시지 히스토리 삽입:
     *   - 저장된 히스토리 개수(mm_hist_cnt)만큼 반복
     *   - 각 항목(mm_hist[i].data, length mm_hist[i].len)을 buf에 복사
     *   - debug_print_hex로 각 히스토리 데이터 덤프
     */
    Serial.print("[DBG] history_count = ");
    Serial.println(mm_hist_cnt);
 
    for (uint8_t i = 0; i < mm_hist_cnt; i++) {
        Serial.print("[DBG] hist[");
        Serial.print(i);
        Serial.print("] = ");
        debug_print_hex(mm_hist[i].data, mm_hist[i].len);
 
        memcpy(buf + off, mm_hist[i].data, mm_hist[i].len);
        off += mm_hist[i].len;
    }
 
    /* (5) 현재 페이로드 삽입:
     *   - data[0..len-1]를 buf에 연속 복사
     *   - debug_print_hex로 페이로드 덤프
     */
    Serial.print("[DBG] current_data = ");
    debug_print_hex(data, len);
 
    memcpy(buf + off, data, len);
    off += len;
 
    /* (6) HMAC-MD5 계산:
     *   - MD5.hmac_md5(buf, off, mm_key, MINIMAC_KEY_LEN, digest)를 호출하여
     *     전체 입력(buf, 길이 off)에 대한 HMAC-MD5 다이제스트 생성
     *   - debug_print_hex로 16바이트 raw MD5 덤프
     *   - 동적 할당된 buf 메모리 해제
     */
    MD5 hasher;
    hasher.hmac_md5(buf, off, (void *)mm_key, MINIMAC_KEY_LEN, digest);
 
    Serial.print("[DBG] raw MD5 = ");
    debug_print_hex(digest, 16);
 
    free(buf);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

debug_print_hex()

static void debug_print_hex ( const uint8_t * buf, uint16_t len )

static

디버깅용: 바이트 배열을 16진수로 출력

매개변수

buf	출력할 바이트 배열
len	배열 길이(Byte)

minimac.cpp 파일의 25 번째 라인에서 정의되었습니다.

{
    for (uint16_t i = 0; i < len; i++) {
        if (buf[i] < 0x10) Serial.print('0');
        Serial.print(buf[i], HEX);
        Serial.print(' ');
    }
    Serial.println();
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

load_state()

static bool load_state ( void )

static

EEPROM에서 Mini-MAC 상태 불러오기

EEPROM에 저장된 시그니처(SIGVAL)를 확인한 뒤, 유효하면 mm_counter, mm_hist_cnt 및 메시지 히스토리 배열을 복원한다.

반환값

true EEPROM에 유효한 상태가 있어 복원 성공

false 시그니처 불일치로 초기화가 필요함

minimac.cpp 파일의 160 번째 라인에서 정의되었습니다.

{
    uint32_t sig;
 
    /* (1) 시그니처 확인 */
    EEPROM.get(SIG_ADDR, sig);
    if (sig != SIGVAL)
        return false;
 
    /* (2) 카운터 및 히스토리 개수 복원 */
    EEPROM.get(DATA_ADDR,                     mm_counter);
    EEPROM.get(DATA_ADDR + sizeof(mm_counter), mm_hist_cnt);
 
    /* (3) 히스토리 항목 복원 */
    int addr = DATA_ADDR + sizeof(mm_counter)
                      + sizeof(mm_hist_cnt);
    for (uint8_t i = 0; i < mm_hist_cnt; i++) {
        /* (3a) 각 히스토리 길이 로드 */
        EEPROM.get(addr, mm_hist[i].len);
        addr += sizeof(mm_hist[i].len);
 
        /* (3b) 고정 크기 버퍼에 과거 페이로드 데이터 로드 */
        EEPROM.get(addr, mm_hist[i].data);
        addr += MINIMAC_MAX_DATA;
    }
 
    /* (4) 디버그 출력으로 복원된 상태 확인 */
    Serial.println("[DBG] load_state: loaded from EEPROM");
    Serial.print("  counter = ");
    print_u64(mm_counter);
    Serial.println();
    Serial.print("  history_count = ");
    Serial.println(mm_hist_cnt);
 
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

minimac_init()

void minimac_init	(	uint16_t	can_id,
		const uint8_t *	key )

Mini-MAC 초기화 및 EEPROM 동기화

Mini-MAC 프로토콜 초기화

매개변수

can_id	보호할 CAN 메시지 식별자 (16비트)
key	Mini-MAC HMAC 키 (128비트, 16바이트)

Serial 포트를 115200bps로 초기화하고, mm_id와 mm_key 전역 변수에 인자를 설정한다. EEPROM에서 이전에 저장된 mm_counter와 메시지 히스토리를 불러오되(load_state()), 저장된 시그니처가 없으면 fresh 상태로 간주하여 mm_counter와 mm_hist_cnt를 0으로 초기화한 뒤(save_state()), EEPROM에 초기 상태를 기록한다. 디버그용으로 Serial.print를 통해 초기화 과정을 출력한다.

minimac.cpp 파일의 246 번째 라인에서 정의되었습니다.

{
    /* Serial 초기화: 디버그 출력용 */
    Serial.begin(115200);
    while (!Serial)
        /* 시리얼 포트가 준비될 때까지 대기 */;
    Serial.println("[DBG] minimac_init()");
 
    /* (1) CAN ID 설정: 보호할 그룹 식별자 */
    mm_id = can_id;
 
    /* (2) 그룹 키 복사: 16바이트 비밀키 */
    memcpy(mm_key, key, MINIMAC_KEY_LEN);
 
    /* (3) EEPROM에서 이전 상태 불러오기 */
    if (!load_state()) {
        /* EEPROM에 유효한 시그니처 없음: fresh 초기화 */
        Serial.println("[DBG] minimac_init: no EEPROM state, initialize fresh");
 
        /* (3a) 카운터 초기화 */
        mm_counter   = 0;
 
        /* (3b) 히스토리 개수 초기화 */
        mm_hist_cnt  = 0;
 
        /* (3c) 초기 상태 EEPROM에 저장 */
        save_state();
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

minimac_sign()

uint8_t minimac_sign	(	uint8_t *	data,
		uint8_t	payload_len )

송신할 메시지에 Mini-MAC 태그 생성 및 내부 상태 갱신

송신 전 페이로드에 Mini-MAC 태그 생성 및 붙이기

매개변수

data	서명할 페이로드 버퍼, 호출 후 buf[payload_len..] 위치에 태그가 덧붙여짐
payload_len	페이로드 길이(Byte)

반환값

전체 전송 길이 (payload_len + MINIMAC_TAG_LEN)

전달받은 페이로드(data, payload_len)를 바탕으로 HMAC-MD5 다이제스트를 계산하여 상위 4바이트(tag)를 data 뒤에 덧붙인다. 이후 메시지 히스토리(mm_hist)와 메시지 카운터(mm_counter)를 갱신하고 EEPROM에 저장(save_state)한다.

minimac.cpp 파일의 286 번째 라인에서 정의되었습니다.

{
    /* 디버그: 함수 진입 */
    Serial.println("[DBG] minimac_sign()");
 
    /* (1) HMAC 입력 구성 및 다이제스트 계산 */
    unsigned char digest[16];
    compute_digest(data, payload_len, digest);
 
    /* (2) 디버그: 생성된 다이제스트의 태그 부분 출력 */
    Serial.print("[DBG] sign: tag = ");
    debug_print_hex(digest, MINIMAC_TAG_LEN);
 
    /* (3) 태그(4바이트) 붙이기 */
    memcpy(data + payload_len, digest, MINIMAC_TAG_LEN);
    uint8_t total = payload_len + MINIMAC_TAG_LEN;
 
    /* (4) 메시지 히스토리 순환 버퍼 관리 */
    if (mm_hist_cnt == MINIMAC_HIST_LEN) {
        Serial.println("[DBG] sign: history full, dropping oldest");
        /* 가장 오래된 히스토리 항목 삭제 */
        for (uint8_t i = 1; i < mm_hist_cnt; i++)
            mm_hist[i - 1] = mm_hist[i];
        mm_hist_cnt--;
    }
    /* 새로운 페이로드를 히스토리에 추가 */
    mm_hist[mm_hist_cnt].len = payload_len;
    memcpy(mm_hist[mm_hist_cnt].data, data, payload_len);
    mm_hist_cnt++;
    Serial.print("[DBG] sign: new history_count = ");
    Serial.println(mm_hist_cnt);
 
    /* (5) 카운터 증가 및 디버그 출력 */
    mm_counter++;
    Serial.print("[DBG] sign: new counter = ");
    print_u64(mm_counter);
    Serial.println();
 
    /* (6) EEPROM에 상태 저장 */
    save_state();
 
    return total;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

minimac_verify()

bool minimac_verify	(	const uint8_t *	data,
		uint8_t	payload_len,
		const uint8_t *	tag )

수신된 메시지의 Mini-MAC 태그 검증 및 상태 동기화

수신 후 Mini-MAC 태그 검증 및 내부 상태 갱신

매개변수

data	검증할 페이로드 버퍼
payload_len	페이로드 길이(Byte)
tag	수신된 태그 버퍼 (MINIMAC_TAG_LEN 바이트)

반환값

true 검증 성공 및 내부 상태 갱신

false 검증 실패 (TAG 불일치)

data와 tag를 기반으로 HMAC-MD5 다이제스트를 재계산하여 수신된 tag와 비교한다. 검증 성공 시 메시지 히스토리(mm_hist)와 카운터(mm_counter)를 갱신하고 EEPROM에 저장(save_state)한 뒤 true를 반환한다. 실패 시 false 반환하며 상태는 갱신되지 않음.

minimac.cpp 파일의 343 번째 라인에서 정의되었습니다.

{
    /* 디버그: 함수 진입 */
    Serial.println("[DBG] minimac_verify()");
 
    /* (1) HMAC 입력 구성 및 다이제스트 재계산 */
    unsigned char digest[16];
    compute_digest(data, payload_len, digest);
 
    /* (2) 디버그: 기대 태그(expected) 및 수신 태그(received) 출력 */
    Serial.print("[DBG] verify: expected tag = ");
    debug_print_hex(digest, MINIMAC_TAG_LEN);
    Serial.print("[DBG] verify: recv    tag = ");
    debug_print_hex(tag, MINIMAC_TAG_LEN);
 
    /* (3) 태그 비교: 불일치 시 실패 처리 */
    if (memcmp(digest, tag, MINIMAC_TAG_LEN) != 0) {
        Serial.println("[DBG] verify: FAILED");
        return false;
    }
 
    /* (4) 히스토리 순환 버퍼 관리 (가득 찼다면 가장 오래된 항목 삭제) */
    if (mm_hist_cnt == MINIMAC_HIST_LEN) {
        Serial.println("[DBG] verify: history full, dropping oldest");
        for (uint8_t i = 1; i < mm_hist_cnt; i++)
            mm_hist[i - 1] = mm_hist[i];
        mm_hist_cnt--;
    }
 
    /* (5) 성공 페이로드를 히스토리에 추가 */
    mm_hist[mm_hist_cnt].len = payload_len;
    memcpy(mm_hist[mm_hist_cnt].data, data, payload_len);
    mm_hist_cnt++;
    Serial.print("[DBG] verify: new history_count = ");
    Serial.println(mm_hist_cnt);
 
    /* (6) 카운터 증가 및 디버그 출력 */
    mm_counter++;
    Serial.print("[DBG] verify: new counter = ");
    print_u64(mm_counter);
    Serial.println();
 
    /* (7) EEPROM에 상태 저장 */
    save_state();
 
    Serial.println("[DBG] verify: SUCCESS");
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

print_u64()

static void print_u64 ( uint64_t v )

static

디버깅용: 64비트 부호 없는 정수를 10진수 문자열로 변환해 출력

매개변수

v	변환할 64비트 값

minimac.cpp 파일의 39 번째 라인에서 정의되었습니다.

{
    if (v == 0) {
        Serial.print('0');
        return;
    }
    char buf[21];      // 최대 20자리 숫자 + 널 종료
    buf[20] = '\0';
    int pos = 19;
    while (v > 0 && pos >= 0) {
        buf[pos--] = '0' + (v % 10);
        v /= 10;
    }
    Serial.print(&buf[pos + 1]);
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

save_state()

static void save_state ( void )

static

Mini-MAC 상태를 EEPROM에 저장

현재 mm_counter, mm_hist_cnt 및 메시지 히스토리 배열을 EEPROM에 시그니처와 함께 순차 기록하여 재부팅 시에도 상태 유지.

minimac.cpp 파일의 203 번째 라인에서 정의되었습니다.

{
    /* (1) 시그니처 기록 */
    EEPROM.put(SIG_ADDR, SIGVAL);
 
    /* (2) 카운터 및 히스토리 개수 기록 */
    EEPROM.put(DATA_ADDR,                       mm_counter);
    EEPROM.put(DATA_ADDR + sizeof(mm_counter),  mm_hist_cnt);
 
    /* (3) 히스토리 항목 기록 */
    int addr = DATA_ADDR + sizeof(mm_counter)
                      + sizeof(mm_hist_cnt);
    for (uint8_t i = 0; i < mm_hist_cnt; i++) {
        /* (3a) 각 히스토리 길이 저장 */
        EEPROM.put(addr, mm_hist[i].len);
        addr += sizeof(mm_hist[i].len);
 
        /* (3b) 고정 크기 버퍼에 과거 페이로드 데이터 저장 */
        EEPROM.put(addr, mm_hist[i].data);
        addr += MINIMAC_MAX_DATA;
    }
 
    /* (4) 디버그 출력으로 저장된 상태 확인 */
    Serial.println("[DBG] save_state: saved to EEPROM");
    Serial.print("  counter = ");
    print_u64(mm_counter);
    Serial.println();
    Serial.print("  history_count = ");
    Serial.println(mm_hist_cnt);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

변수 문서화

DATA_ADDR

const int DATA_ADDR = SIG_ADDR + sizeof(SIGVAL)

static

minimac.cpp 파일의 11 번째 라인에서 정의되었습니다.

mm_counter

uint64_t mm_counter

static

64비트 메시지 카운터

minimac.cpp 파일의 16 번째 라인에서 정의되었습니다.

mm_hist

MiniMacHist mm_hist[5]

static

최근 λ개 메시지 히스토리

minimac.cpp 파일의 17 번째 라인에서 정의되었습니다.

mm_hist_cnt

uint8_t mm_hist_cnt

static

히스토리 항목 수 (≤ λ)

minimac.cpp 파일의 18 번째 라인에서 정의되었습니다.

mm_id

uint16_t mm_id

static

보호할 CAN ID, 그룹 키, 카운터, 메시지 히스토리

CAN ID (그룹 식별자)

minimac.cpp 파일의 14 번째 라인에서 정의되었습니다.

mm_key

uint8_t mm_key[16]

static

공유 그룹 키

minimac.cpp 파일의 15 번째 라인에서 정의되었습니다.

SIG_ADDR

const int SIG_ADDR = 0

static

EEPROM 레이아웃: 시그니처 및 데이터 저장 시작 주소

minimac.cpp 파일의 9 번째 라인에서 정의되었습니다.

SIGVAL

const uint32_t SIGVAL = 0xAA55AA55

static

minimac.cpp 파일의 10 번째 라인에서 정의되었습니다.