Linux Crypto Framework (Crypto API)

Linux Crypto Framework(Crypto API)를 커널 암호 연산의 공통 추상화 계층으로 심층 분석합니다. skcipher/aead/hash/rng API 분류와 사용 패턴, synchronous vs asynchronous 요청 경로, 알고리즘 등록과 우선순위 선택, AES-NI·ARM Crypto Extensions·QAT 등 하드웨어 가속 연동, scatterlist 기반 버퍼 처리, dm-crypt/IPsec/tls 등 상위 서브시스템 통합, FIPS 모드 고려사항, 성능 계측과 보안 검증 절차까지 실전 커널 암호화 운영에 필요한 핵심을 다룹니다.

Linux Crypto Framework 개요

Linux 커널의 Crypto Framework (Crypto API)는 암호화 알고리즘을 커널 내에서 사용할 수 있도록 하는 통합 프레임워크입니다. 소프트웨어 구현과 하드웨어 가속(AES-NI, SHA Extensions 등)을 동일한 인터페이스로 제공합니다.

Linux Crypto Framework 아키텍처 원리

Crypto Framework (Crypto API)는 알고리즘 구현과 사용을 분리하는 프레임워크 패턴으로 설계되어 있습니다. 핵심 개념은 세 가지입니다:

• Algorithm (알고리즘 등록): 각 암호화 구현체(SW 또는 HW)가 crypto_register_alg()으로 자신을 등록합니다. 같은 알고리즘의 여러 구현이 공존하며, priority 값으로 우선순위를 매깁니다.
• Transform (tfm): 사용자가 crypto_alloc_skcipher("cbc(aes)", ...)를 호출하면, 커널이 priority가 가장 높은 구현을 선택하여 인스턴스(tfm)를 생성합니다. 키를 설정하면 이 tfm으로 반복 암호화가 가능합니다.
• Request: 실제 데이터 처리 단위. scatterlist(물리 메모리 분산 목록)로 데이터를 전달하여 DMA 친화적인 zero-copy 처리가 가능합니다.

알고리즘 조합 (Template) 원리

Crypto Framework (Crypto API)의 강력한 특성 중 하나는 템플릿 기반 알고리즘 조합입니다. "cbc(aes)"에서 cbc는 운용 모드 템플릿이고 aes는 기본 블록 암호입니다. 커널은 이를 재귀적으로 해석하여:

알고리즘 유형

비대칭 암호와 공개키 연산

커널 Crypto Framework에서 비대칭 연산은 하나의 API로 뭉뚱그리지 않고 암/복호화, 서명/검증, 키 합의를 각각 다른 인터페이스로 분리합니다. 이 구분을 이해하지 못하면 RSA, ECDSA, ECDH를 같은 계층의 대체재처럼 오해하게 됩니다.

중요한 차이: crypto_akcipher는 공개키로 암호화하고 개인키로 복호화하는 경로를 다루며, crypto_sig는 서명과 검증을 위해 별도 API를 사용합니다. crypto_kpp는 암/복호화가 아니라 양측이 동일한 공유 비밀을 계산하는 용도이므로, 의미상 완전히 다른 계층입니다.

RSA AKCIPHER 예제

공개키 암호화 API는 crypto_alloc_akcipher()로 tfm을 얻고, akcipher_request에 입출력 scatterlist를 연결한 뒤 crypto_akcipher_encrypt() 또는 crypto_akcipher_decrypt()를 호출하는 형태입니다. 공개키/개인키는 BER/DER로 인코딩된 형태가 필요하다는 점이 대칭 API와 가장 크게 다릅니다.

#include <crypto/akcipher.h>
#include <linux/scatterlist.h>

static int rsa_encrypt_keyblob(const void *pub_der, unsigned int pub_der_len,
                               const u8 *plain, unsigned int plain_len,
                               u8 *cipher, unsigned int *cipher_len)
{
    struct crypto_akcipher *tfm;
    struct akcipher_request *req;
    struct scatterlist src, dst;
    int ret;

    tfm = crypto_alloc_akcipher("rsa", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    ret = crypto_akcipher_set_pub_key(tfm, pub_der, pub_der_len);
    if (ret)
        goto out_free_tfm;

    req = akcipher_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }

    sg_init_one(&src, plain, plain_len);
    sg_init_one(&dst, cipher, *cipher_len);
    akcipher_request_set_crypt(req, &src, &dst, plain_len, *cipher_len);

    ret = crypto_akcipher_encrypt(req);
    if (!ret)
        *cipher_len = req->dst_len;

    akcipher_request_free(req);
out_free_tfm:
    crypto_free_akcipher(tfm);
    return ret;
}

전자서명 API 예제

서명 API는 request 객체를 쓰지 않고 tfm에 직접 crypto_sig_sign() 또는 crypto_sig_verify()를 호출합니다. 상위 계층이 이미 해시를 계산해 둔 상태에서 digest에 대해 서명/검증을 수행하는 식으로 사용하는 경우가 많습니다.

#include <crypto/sig.h>

static int verify_firmware_digest(const void *pub_der, unsigned int pub_der_len,
                                  const u8 *sig, unsigned int sig_len,
                                  const u8 *digest, unsigned int digest_len)
{
    struct crypto_sig *tfm;
    int ret;

    tfm = crypto_alloc_sig("ecdsa", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    ret = crypto_sig_set_pubkey(tfm, pub_der, pub_der_len);
    if (ret)
        goto out_free_tfm;

    ret = crypto_sig_verify(tfm, sig, sig_len, digest, digest_len);

out_free_tfm:
    crypto_free_sig(tfm);
    return ret;
}

서명 출력 버퍼는 crypto_sig_maxsize()로 산정하고, 검증에 넘기는 digest 길이는 상위 프로토콜이 정한 해시 길이와 정확히 맞춰야 합니다. 특히 ECDSA는 곡선 종류와 DER 인코딩 길이에 따라 서명 길이가 가변적일 수 있으므로, 고정 길이 배열을 가정하면 구현이 깨질 수 있습니다.

KPP ECDH 예제

crypto_kpp는 암호문을 만드는 API가 아니라 공유 비밀을 계산하는 API입니다. ECDH에서는 개인키를 struct ecdh로 표현한 뒤 crypto_ecdh_encode_key()로 패킷 형태로 포장해 crypto_kpp_set_secret()에 넘깁니다.

#include <crypto/kpp.h>
#include <crypto/ecdh.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>

static int ecdh_shared_secret(const u8 *priv, unsigned int priv_len,
                               const u8 *peer_pub, unsigned int peer_pub_len,
                               u8 *secret, unsigned int *secret_len)
{
    struct crypto_kpp *tfm;
    struct kpp_request *req;
    struct ecdh params = {
        .key = (char *)priv,
        .key_size = priv_len,
    };
    struct scatterlist src, dst;
    char *packed = NULL;
    unsigned int packed_len;
    int ret;

    tfm = crypto_alloc_kpp("ecdh", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    packed_len = crypto_ecdh_key_len(&params);
    packed = kmalloc(packed_len, GFP_KERNEL);
    if (!packed) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }

    ret = crypto_ecdh_encode_key(packed, packed_len, &params);
    if (ret)
        goto out_free_key;

    ret = crypto_kpp_set_secret(tfm, packed, packed_len);
    if (ret)
        goto out_free_key;

    req = kpp_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_key;
    }

    sg_init_one(&src, peer_pub, peer_pub_len);
    sg_init_one(&dst, secret, *secret_len);
    kpp_request_set_input(req, &src, peer_pub_len);
    kpp_request_set_output(req, &dst, *secret_len);

    ret = crypto_kpp_compute_shared_secret(req);
    if (!ret)
        *secret_len = req->dst_len;

    kpp_request_free(req);
out_free_key:
    kfree(packed);
out_free_tfm:
    crypto_free_kpp(tfm);
    return ret;
}

해시 사용 예제

#include <crypto/hash.h>
#include <linux/slab.h>

static int calc_sha256(const u8 *data, unsigned int len, u8 *digest)
{
    struct crypto_shash *tfm;
    struct shash_desc *desc;
    int ret;

    tfm = crypto_alloc_shash("sha256", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
    if (!desc) {
        crypto_free_shash(tfm);
        return -ENOMEM;
    }

    desc->tfm = tfm;
    ret = crypto_shash_digest(desc, data, len, digest);
    kfree(desc);
    crypto_free_shash(tfm);
    return ret;
}

/* 스택 할당 대안: SHASH_DESC_ON_STACK 매크로 사용
 * 힙 할당 오버헤드 없이 스택에 shash_desc를 직접 배치합니다.
 * 단, descsize가 크면 스택 사용량 초과 위험이 있으므로
 * CONFIG_FRAME_WARN을 초과하지 않는 작은 알고리즘에 적합합니다. */
static int calc_sha256_stack(const u8 *data, unsigned int len, u8 *digest)
{
    struct crypto_shash *tfm = crypto_alloc_shash("sha256", 0, 0);
    SHASH_DESC_ON_STACK(desc, tfm);  /* 스택에 shash_desc 할당 */
    int ret;

    if (IS_ERR(tfm))
        return PTR_ERR(tfm);
    desc->tfm = tfm;
    ret = crypto_shash_digest(desc, data, len, digest);
    shash_desc_zero(desc);          /* 민감 데이터 스택 소거 */
    crypto_free_shash(tfm);
    return ret;
}

대칭 암호 예제

#include <crypto/skcipher.h>

struct crypto_skcipher *tfm;
struct skcipher_request *req;
struct scatterlist sg;
int err;

tfm = crypto_alloc_skcipher("cbc(aes)", 0, 0);
if (IS_ERR(tfm))
    return PTR_ERR(tfm);

err = crypto_skcipher_setkey(tfm, key, key_len);
if (err)
    goto out_free_tfm;

req = skcipher_request_alloc(tfm, GFP_KERNEL);
if (!req) {
    err = -ENOMEM;
    goto out_free_tfm;
}
sg_init_one(&sg, data, data_len);
skcipher_request_set_crypt(req, &sg, &sg, data_len, iv);

/* 암호화 */
err = crypto_skcipher_encrypt(req);
if (err)
    goto out_free_req;

/* 복호화 */
err = crypto_skcipher_decrypt(req);

out_free_req:
skcipher_request_free(req);
out_free_tfm:
crypto_free_skcipher(tfm);
return err;

하드웨어 가속

커널은 CPU의 암호화 명령어를 자동으로 활용합니다:

• AES-NI (Intel/AMD): AES 연산을 하드웨어에서 수행, 소프트웨어 대비 10배 이상 빠름
• SHA Extensions (Intel/AMD): SHA-1, SHA-256 하드웨어 가속
• CRC32C: SSE4.2 명령으로 CRC 계산 가속 (btrfs, ext4 체크섬)
• ARM CE: ARM Cryptography Extensions

# 사용 가능한 암호화 알고리즘 확인
cat /proc/crypto | grep -E "^name|^driver|^priority"

# AES-NI가 활성화되었는지 확인
grep -o aes /proc/cpuinfo | head -1

비동기 암호화 (Async Crypto)

커널 Crypto Framework (Crypto API)는 비동기 처리를 지원하여 H/W 가속기와 효율적으로 연동합니다:

/* 비동기 대칭 암호 사용 예 */
struct crypto_skcipher *tfm;
struct skcipher_request *req;

tfm = crypto_alloc_skcipher("cbc(aes)", 0, 0);
req = skcipher_request_alloc(tfm, GFP_KERNEL);

/* 비동기 완료 콜백 설정 */
skcipher_request_set_callback(req,
    CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
    my_crypto_done, &result);

/* 키 설정 */
crypto_skcipher_setkey(tfm, key, key_len);

/* scatterlist로 데이터 설정 */
struct scatterlist sg;
sg_init_one(&sg, data, data_len);
skcipher_request_set_crypt(req, &sg, &sg, data_len, iv);

/* 비동기 암호화 수행 */
int err = crypto_skcipher_encrypt(req);
if (err == -EINPROGRESS || err == -EBUSY) {
    /* H/W 가속기에서 비동기 처리 중 → 콜백으로 완료 통보 */
    wait_for_completion(&result.completion);
    err = result.err;
}

AEAD (Authenticated Encryption)

AEAD는 암호화와 인증을 동시에 수행합니다 (예: AES-GCM, ChaCha20-Poly1305):

struct crypto_aead *aead;
struct aead_request *req;
int err;

aead = crypto_alloc_aead("gcm(aes)", 0, 0);
if (IS_ERR(aead))
    return PTR_ERR(aead);

err = crypto_aead_setkey(aead, key, key_len);
if (err)
    goto out_free_aead;
err = crypto_aead_setauthsize(aead, 16);  /* 128-bit 인증 태그 */
if (err)
    goto out_free_aead;

req = aead_request_alloc(aead, GFP_KERNEL);
if (!req) {
    err = -ENOMEM;
    goto out_free_aead;
}
aead_request_set_crypt(req, src_sg, dst_sg, plaintext_len, iv);
aead_request_set_ad(req, aad_len);  /* 추가 인증 데이터 */

err = crypto_aead_encrypt(req);  /* 암호화 + MAC 생성 */
aead_request_free(req);
out_free_aead:
crypto_free_aead(aead);
return err;

커널 난수 생성기

/* 커널 CSPRNG */
#include <linux/random.h>

/* 암호학적으로 안전한 난수 */
get_random_bytes(buf, nbytes);

/* 범위 내 난수 */
u32 val = get_random_u32_below(100);  /* 0~99 */

/* /dev/urandom의 커널 구현 */
/* ChaCha20 기반 DRBG, 하드웨어 엔트로피 소스 자동 수집 */

주요 알고리즘 카탈로그

사용자 공간 인터페이스 (AF_ALG)

/* 사용자 공간에서 커널 Crypto Framework (Crypto API) 사용 */
int sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);

struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type   = "hash",
    .salg_name   = "sha256",
};
bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));

int opfd = accept(sockfd, NULL, NULL);
write(opfd, data, data_len);
read(opfd, digest, 32);  /* SHA-256 결과 */

H/W 가속 상세

# 사용 가능한 암호 알고리즘 확인 (H/W 가속 포함)
cat /proc/crypto | head -40
# name         : __cbc(aes)
# driver       : __cbc-aes-aesni  ← AES-NI 하드웨어 가속
# module       : aesni_intel
# priority     : 400             ← 높은 우선순위 = 자동 선택
# type         : skcipher

# AES-NI 지원 확인
grep aes /proc/cpuinfo | head -1
# flags : ... aes ...

AES-NI 심화

AES-NI(Advanced Encryption Standard New Instructions)는 Intel이 2010년(Westmere)에 도입하고 AMD가 2011년(Bulldozer)부터 지원하는 AES 전용 하드웨어 명령어 세트입니다. 소프트웨어 AES 대비 3~10배 이상 빠른 처리량을 제공하며, 일반적인 테이블 기반 구현 대비 타이밍 기반 부채널 위험을 줄이는 데 유리합니다.

AES-NI 명령어 세트

AES-NI는 6개의 핵심 명령어로 구성됩니다. 모든 명령어는 128-bit XMM 레지스터에서 동작합니다:

AES-NI 키 확장 (Key Expansion)

AES 키 확장은 원본 키(128/192/256비트)로부터 각 라운드에 사용할 라운드 키를 생성합니다. 커널의 aesni-intel_glue.c는 키 설정 시 모든 라운드 키를 미리 확장하여 crypto_aes_ctx에 저장합니다:

; AES-128 키 확장 (arch/x86/crypto/aesni-intel_asm.S 참고)
; 입력: %xmm0 = 원본 128-bit 키
; 출력: key_schedule[0..10] = 11개 라운드 키

_aesni_key_expansion_128:
    movaps  %xmm0, (%rdi)          ; key_schedule[0] = 원본 키

    ; 라운드 1: RCON = 0x01
    aeskeygenassist $0x01, %xmm0, %xmm1
    call    _key_expansion_128
    movaps  %xmm0, 0x10(%rdi)    ; key_schedule[1]

    ; 라운드 2: RCON = 0x02
    aeskeygenassist $0x02, %xmm0, %xmm1
    call    _key_expansion_128
    movaps  %xmm0, 0x20(%rdi)    ; key_schedule[2]
    ; ... 라운드 3~10까지 반복 (RCON: 0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36)

; 키 확장 보조 루틴
_key_expansion_128:
    pshufd  $0xff, %xmm1, %xmm1  ; AESKEYGENASSIST 결과를 broadcast
    shufps  $0x10, %xmm0, %xmm4  ; temp = [0,0,key[0],key[1]]
    pxor    %xmm4, %xmm0          ; key ^= temp
    shufps  $0x8c, %xmm0, %xmm4
    pxor    %xmm4, %xmm0          ; key ^= temp (cascade)
    pxor    %xmm1, %xmm0          ; key ^= RCON 결과
    ret

/* 커널 glue 코드: 키 설정 (arch/x86/crypto/aesni-intel_glue.c) */
static int aesni_set_key(struct crypto_aes_ctx *ctx,
                        const u8 *in_key, unsigned int key_len)
{
    if (!crypto_simd_usable())
        return aes_expandkey(ctx, in_key, key_len);  /* SW fallback */

    kernel_fpu_begin();
    aesni_set_key_common(ctx, in_key, key_len);  /* AES-NI 키 확장 */
    kernel_fpu_end();

    return 0;
}

/* struct crypto_aes_ctx — 확장된 키 스케줄 저장 */
struct crypto_aes_ctx {
    u32 key_enc[AES_MAX_KEYLENGTH_U32];  /* 암호화용 라운드 키 (60 u32) */
    u32 key_dec[AES_MAX_KEYLENGTH_U32];  /* 복호화용 라운드 키 (Inv) */
    u32 key_length;                      /* 16, 24, 또는 32 */
};

운용 모드별 AES-NI 구현

커널의 aesni_intel 모듈은 다양한 운용 모드를 AES-NI로 가속합니다. 각 모드의 병렬화 특성에 따라 성능이 크게 달라집니다:

; AES-CBC 암호화 — 직렬 체인 (arch/x86/crypto/aesni-intel_asm.S 참고)
; 각 블록: C[i] = AES_ENC(P[i] XOR C[i-1])
_aesni_enc_cbc:
    movups  (%r8), %xmm2           ; IV 로드
.Lcbc_enc_loop:
    movups  (%rsi), %xmm3          ; 평문 블록 로드
    pxor    %xmm2, %xmm3           ; P[i] XOR C[i-1] (CBC 체이닝)

    ; 10라운드 AES-128 암호화
    pxor    0x00(%rdi), %xmm3     ; AddRoundKey (라운드 0)
    aesenc  0x10(%rdi), %xmm3     ; 라운드 1
    aesenc  0x20(%rdi), %xmm3     ; 라운드 2
    ; ... 라운드 3~9 ...
    aesenclast 0xa0(%rdi), %xmm3  ; 라운드 10 (마지막)

    movups  %xmm3, (%rdx)          ; 암호문 저장
    movaps  %xmm3, %xmm2           ; C[i] → 다음 블록의 IV
    add     $16, %rsi
    add     $16, %rdx
    dec     %ecx
    jnz     .Lcbc_enc_loop

; AES-CTR 암호화 — 병렬 처리 (4블록 동시)
; C[i] = P[i] XOR AES_ENC(CTR+i)
_aesni_enc_ctr:
    ; 4개 카운터를 병렬로 준비
    movaps  %xmm0, %xmm1           ; CTR+0
    movaps  %xmm0, %xmm2           ; CTR+1 (inc)
    movaps  %xmm0, %xmm3           ; CTR+2 (inc)
    movaps  %xmm0, %xmm4           ; CTR+3 (inc)
    ; ... 각 카운터 증가 ...

    ; 4블록 동시 AES 라운드 (파이프라인 활용)
    pxor    (%rdi), %xmm1
    pxor    (%rdi), %xmm2
    pxor    (%rdi), %xmm3
    pxor    (%rdi), %xmm4
    aesenc  0x10(%rdi), %xmm1
    aesenc  0x10(%rdi), %xmm2
    aesenc  0x10(%rdi), %xmm3
    aesenc  0x10(%rdi), %xmm4
    ; ... 나머지 라운드 인터리빙 ...

AES-GCM과 PCLMULQDQ

AES-GCM(Galois/Counter Mode)은 TLS 1.3, IPsec에서 가장 널리 사용되는 AEAD 모드입니다. GCM은 CTR 모드 암호화와 GHASH 인증을 결합합니다. 커널은 AES-NI와 PCLMULQDQ(Carry-less Multiplication) 명령어를 함께 사용하여 두 연산을 모두 하드웨어로 가속합니다:

/* GHASH에서 GF(2^128) 곱셈 — PCLMULQDQ 하드웨어 가속 */
/* PCLMULQDQ: Carry-less multiplication (XOR 기반 다항식 곱셈) */
/* 소프트웨어로 구현하면 수십 사이클 걸리는 연산을 단일 명령어로 수행 */

/* arch/x86/crypto/ghash-clmulni-intel_asm.S 에서: */
; GHASH 블록 처리:
;   xmm0 = 현재 해시 값 (H_i)
;   xmm1 = 해시 키 (H = AES_ENC(0))
;   XOR → CLMUL → reduction → 새 해시 값
pxor    %xmm2, %xmm0              ; H_i XOR C_i (입력 블록과 XOR)

; Karatsuba 분해를 사용한 128×128 bit carry-less 곱셈
movdqa  %xmm0, %xmm3
pclmulqdq $0x00, %xmm1, %xmm3    ; a0 × b0 (하위 64-bit 곱)
movdqa  %xmm0, %xmm4
pclmulqdq $0x11, %xmm1, %xmm4    ; a1 × b1 (상위 64-bit 곱)
movdqa  %xmm0, %xmm5
pclmulqdq $0x10, %xmm1, %xmm5    ; a0 × b1 (교차 곱)
pclmulqdq $0x01, %xmm1, %xmm0    ; a1 × b0 (교차 곱)
pxor    %xmm5, %xmm0              ; 교차 곱 합산
; → GF(2^128) 환원(reduction): x^128 + x^7 + x^2 + x + 1

aesni_intel 모듈 아키텍처

커널의 AES-NI 지원은 arch/x86/crypto/ 디렉터리에 위치하며, glue 코드와 어셈블리 구현으로 분리됩니다:

/* aesni-intel_glue.c — 주요 알고리즘 등록 구조 */

/* 1. 기본 블록 암호 (AES 단일 블록, 128-bit) */
static struct crypto_alg aesni_cipher_alg = {
    .cra_name           = "aes",
    .cra_driver_name    = "aes-aesni",
    .cra_priority       = 300,
    .cra_flags          = CRYPTO_ALG_TYPE_CIPHER,
    .cra_blocksize      = AES_BLOCK_SIZE,       /* 16 */
    .cra_u.cipher = {
        .cia_min_keysize = AES_MIN_KEY_SIZE,    /* 16 */
        .cia_max_keysize = AES_MAX_KEY_SIZE,    /* 32 */
        .cia_setkey      = aes_set_key,
        .cia_encrypt     = aesni_encrypt,
        .cia_decrypt     = aesni_decrypt,
    },
};

/* 2. skcipher 알고리즘들 (CBC, CTR, XTS, ECB) */
static struct skcipher_alg aesni_skciphers[] = {
    {   /* ECB — 병렬 처리, priority 400 */
        .base.cra_name          = "__ecb(aes)",
        .base.cra_driver_name   = "__ecb-aes-aesni",
        .base.cra_priority      = 400,
        .base.cra_flags         = CRYPTO_ALG_INTERNAL,
        .setkey                 = aesni_skcipher_setkey,
        .encrypt                = ecb_encrypt,
        .decrypt                = ecb_decrypt,
    },
    {   /* CBC */
        .base.cra_name          = "__cbc(aes)",
        .base.cra_driver_name   = "__cbc-aes-aesni",
        .base.cra_priority      = 400,
        .base.cra_flags         = CRYPTO_ALG_INTERNAL,
        .setkey                 = aesni_skcipher_setkey,
        .encrypt                = cbc_encrypt,
        .decrypt                = cbc_decrypt,
    },
    {   /* CTR */
        .base.cra_name          = "__ctr(aes)",
        .base.cra_driver_name   = "__ctr-aes-aesni",
        .base.cra_priority      = 400,
        .base.cra_flags         = CRYPTO_ALG_INTERNAL,
        .setkey                 = aesni_skcipher_setkey,
        .encrypt                = ctr_crypt,
        .decrypt                = ctr_crypt,    /* CTR 모드: enc == dec */
    },
    {   /* XTS — 디스크 암호화 (dm-crypt) */
        .base.cra_name          = "__xts(aes)",
        .base.cra_driver_name   = "__xts-aes-aesni",
        .base.cra_priority      = 401,
        .setkey                 = xts_aesni_setkey,
        .encrypt                = xts_encrypt,
        .decrypt                = xts_decrypt,
    },
};

/* 3. AEAD (GCM) */
static struct aead_alg aesni_aeads[] = {
    {
        .base.cra_name          = "__gcm(aes)",
        .base.cra_driver_name   = "__generic-gcm-aesni",
        .base.cra_priority      = 400,
        .base.cra_flags         = CRYPTO_ALG_INTERNAL,
        .setkey                 = gcm_setkey,
        .setauthsize            = gcm_setauthsize,
        .encrypt                = gcm_encrypt,
        .decrypt                = gcm_decrypt,
        .ivsize                 = GCM_AES_IV_SIZE,    /* 12 */
        .maxauthsize            = 16,
    },
};

aesni_intel 모듈 초기화 흐름

/* aesni-intel_glue.c — 모듈 초기화 */
static int __init aesni_init(void)
{
    int err;

    /* 1. CPU가 AES-NI를 지원하는지 확인 */
    if (!boot_cpu_has(X86_FEATURE_AES))
        return -ENODEV;       /* AES-NI 미지원 → 모듈 로드 실패 → generic 사용 */

    /* 2. PCLMULQDQ 지원 여부 확인 (GCM GHASH에 필요) */
    if (!boot_cpu_has(X86_FEATURE_PCLMULQDQ))
        pr_info("PCLMULQDQ not available, GCM acceleration disabled\\n");

    /* 3. 기본 AES 블록 암호 등록 */
    err = crypto_register_alg(&aesni_cipher_alg);
    if (err)
        return err;

    /* 4. skcipher 알고리즘 등록 (INTERNAL 버전) */
    err = crypto_register_skciphers(aesni_skciphers,
                                    ARRAY_SIZE(aesni_skciphers));

    /* 5. SIMD 래퍼 등록 (외부 공개 버전)
     * __ecb-aes-aesni → ecb-aes-aesni
     * __cbc-aes-aesni → cbc-aes-aesni
     * ... */
    err = simd_register_skciphers_compat(aesni_skciphers,
                                         ARRAY_SIZE(aesni_skciphers),
                                         aesni_simd_skciphers);

    /* 6. AEAD (GCM) 등록 */
    if (boot_cpu_has(X86_FEATURE_PCLMULQDQ)) {
        err = crypto_register_aeads(aesni_aeads,
                                    ARRAY_SIZE(aesni_aeads));
        err = simd_register_aeads_compat(aesni_aeads,
                                         ARRAY_SIZE(aesni_aeads),
                                         aesni_simd_aeads);
    }

    return 0;
}

VAES: AVX-512 벡터 AES

VAES(Vector AES)는 Intel Ice Lake(2019)부터 도입된 확장으로, AES-NI를 AVX-512 레지스터(512-bit)에서 동작하게 합니다. 128-bit XMM 대신 512-bit ZMM 레지스터를 사용하여 한 명령어로 4개 AES 블록을 동시에 처리합니다:

; VAES 예시: 512-bit ZMM 레지스터로 4블록 동시 AES 라운드
; 기존 AES-NI: aesenc %xmm_key, %xmm_data  → 1블록 (128-bit)
; VAES:       vaesenc %zmm_key, %zmm_data, %zmm_out → 4블록 (512-bit)

vaesenc %zmm1, %zmm0, %zmm0     ; 4블록 × 라운드 1
vaesenc %zmm2, %zmm0, %zmm0     ; 4블록 × 라운드 2
vaesenc %zmm3, %zmm0, %zmm0     ; 4블록 × 라운드 3
; ... 라운드 4~9 ...
vaesenclast %zmm11, %zmm0, %zmm0 ; 4블록 × 라운드 10 (마지막)

; 2개 ZMM을 인터리빙하면 8블록(1024-bit) 동시 처리:
vaesenc %zmm1, %zmm10, %zmm10   ; 블록 0~3
vaesenc %zmm1, %zmm11, %zmm11   ; 블록 4~7 (파이프라인 활용)

# VAES 지원 확인
grep vaes /proc/cpuinfo | head -1
# flags : ... vaes avx512f avx512bw ...

# 커널에서 VAES 가속 드라이버 확인
grep -E "aes.*(vaes|avx512)" /proc/crypto
# driver : xts-aes-vaes-avx512
# driver : gcm-aes-vaes-avx512

AES-NI를 활용하는 주요 커널 서브시스템

# dm-crypt에서 AES-NI 가속 확인 (LUKS 디스크)
cryptsetup luksDump /dev/sda2 | grep cipher
# cipher: aes-xts-plain64

# IPsec GCM 설정 예시 (strongSwan)
# ike=aes256gcm16-sha384-ecp384
# esp=aes256gcm16

# 현재 사용 중인 AES 구현 확인
cat /proc/crypto | grep -A4 "name.*: xts(aes)"
# name         : xts(aes)
# driver       : xts-aes-aesni
# module       : aesni_intel
# priority     : 401

# dm-crypt I/O 중 AES-NI CPU 사용 확인
perf top -e cycles -g -- -p $(pgrep -f kcryptd)
# aesni_xts_encrypt  ← AES-NI가 사용되고 있음

AES-NI 성능 특성

# tcrypt 모듈로 AES-NI 벤치마크
modprobe tcrypt mode=500 sec=2
# mode=500대: skcipher 계열 벤치마크 (예: CBC/CTR/XTS)
# mode 번호는 커널 버전에 따라 세부 매핑이 달라질 수 있음

dmesg | tail -30
# 참고 결과 예시 (Xeon, AES-NI):
# testing speed of async cbc(aes) (cbc-aes-aesni) encryption
# test  0 (128 bit key, 16 byte blocks):  18742341 operations in 2 seconds (299877456 bytes)
# test  1 (128 bit key, 64 byte blocks):  12952847 operations in 2 seconds (828982208 bytes)
# test  2 (128 bit key, 256 byte blocks):  7348142 operations in 2 seconds (1881124352 bytes)
# test  3 (128 bit key, 1024 byte blocks): 3128904 operations in 2 seconds (3203997696 bytes)
# test  4 (128 bit key, 1472 byte blocks): 2352961 operations in 2 seconds (3463558592 bytes)
# test  5 (128 bit key, 8192 byte blocks):  537420 operations in 2 seconds (4402585600 bytes)
#                                                          → ~2.2 GB/s (CBC, 단일 코어)

AES-NI 보안 이점: 부채널 공격 방어

소프트웨어 AES 구현은 S-Box 테이블 룩업을 사용하는데, 이는 cache-timing 부채널 공격에 취약합니다. 공격자는 AES 연산 중 캐시 접근 패턴을 관측하여 키를 추출할 수 있습니다:

/* 소프트웨어 AES — cache-timing 취약점 */
/* crypto/aes_generic.c 의 S-Box 테이블 룩업 */
static const u32 Te0[256] = { ... };  /* 1KB 룩업 테이블 */
static const u32 Te1[256] = { ... };
static const u32 Te2[256] = { ... };
static const u32 Te3[256] = { ... };

/* 키에 의존하는 인덱스로 테이블 접근 → 캐시 라인 접근 패턴 노출 */
s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ ...;
/* ↑ 공격자가 cache-line hit/miss 패턴으로 t0, t1 값을 추론 가능 */

/* AES-NI — 하드웨어 경로로 cache-timing 노출면을 축소 */
/* AESENC 명령어는 CPU 내부 회로에서 S-Box를 수행하므로
 * 소프트웨어 테이블 룩업 대비 메모리 접근 패턴 노출이 줄어듦
 * 전체 부채널 안전성은 마이크로아키텍처/플랫폼 조건을 함께 검토해야 함 */
aesenc %xmm_key, %xmm_state   /* 실제 사이클 특성은 구현 경로와 환경에 따라 달라질 수 있음 */

Intel® QuickAssist Technology (Intel® QAT)

Intel QAT는 암호화(Cipher), 해싱(Hash), 압축/해제(Compression)를 하드웨어로 가속하는 기술입니다. 커널 Crypto Framework (Crypto API)에 통합되어 IPsec, TLS(kTLS), dm-crypt, 스토리지 압축 등에서 CPU 오프로드를 제공합니다.

QAT 아키텍처

QAT 커널 드라이버 설정

# QAT 디바이스 확인
lspci -d :4940   # QAT 4xxx (Sapphire Rapids)
lspci -d :37c8   # QAT C62x

# QAT 드라이버 로드
modprobe qat_4xxx       # 또는 qat_c62x, qat_dh895xcc
modprobe intel_qat       # 공통 프레임워크

# QAT 서비스 구성 (crypto, compression, 또는 둘 다)
# /etc/4xxx_dev0.conf 설정 파일
# ServicesEnabled = cy;dc  (cy=crypto, dc=data compression)

# QAT 인스턴스 확인
cat /sys/kernel/debug/qat_4xxx_0000:6b:00.0/fw_counters

# QAT가 crypto API에 등록된 알고리즘 확인
cat /proc/crypto | grep -A5 qat
# driver: qat_aes_cbc
# priority: 4001  ← S/W(aesni=400)보다 높음 → 자동 선택

# SRIOV VF 생성 (VM에 QAT 인스턴스 직접 할당)
echo 16 > /sys/bus/pci/devices/0000:6b:00.0/sriov_numvfs

QAT + IPsec 연동

# QAT IPsec offload — ESP 암호화/복호화를 QAT로 오프로드
# strongSwan 또는 Libreswan에서 자동 감지

# IPsec SA에서 QAT 사용 확인
ip xfrm state | grep -A2 enc
# enc aes-cbc ... offload dev qat_4xxx

# 성능 비교 (예시: AES-128-CBC + SHA-256)
# SW (AES-NI):     ~10 Gbps (CPU 100%)
# QAT offload:     ~40 Gbps (CPU ~20%)

# kTLS + QAT (커널 TLS 오프로드)
# KTLS_TX: 송신 데이터를 QAT가 AES-GCM 암호화
# 커널 5.3+ kTLS + QAT crypto 드라이버 자동 연동

QAT 사용 시 주의사항

알고리즘 구현 가이드

커널 Crypto Framework (Crypto API)에 새로운 알고리즘을 추가하려면 알고리즘 구조체 정의 → 콜백 구현 → 등록 → 테스트 벡터 추가의 과정을 거칩니다. 이 섹션에서는 각 단계를 상세히 다룹니다.

드라이버 작성자가 먼저 결정할 것: 어떤 인터페이스를 구현할 것인가

Crypto driver 작성에서 가장 먼저 해야 할 일은 "이 하드웨어가 AES를 지원한다"가 아니라 어떤 추상 인터페이스를 커널에 노출할지를 정하는 것입니다. 같은 AES 엔진이라도 단일 블록만 처리하는지, 모드(CBC/CTR/XTS/GCM)까지 자체 처리하는지, AAD와 tag를 함께 계산하는지, DMA로 긴 SG를 직접 읽는지에 따라 등록해야 하는 타입이 달라집니다.

struct crypto_alg — 알고리즘 등록의 핵심

모든 암호화 알고리즘은 struct crypto_alg을 기반으로 등록됩니다. 이 구조체는 알고리즘의 메타데이터와 구현 콜백을 담는 컨테이너입니다:

/* include/linux/crypto.h */
struct crypto_alg {
    struct list_head     cra_list;        /* 내부 연결 리스트 */
    struct list_head     cra_users;       /* 이 알고리즘을 사용하는 tfm 목록 */

    u32                  cra_flags;       /* 알고리즘 속성 플래그 */
    unsigned int         cra_blocksize;   /* 블록 크기 (해시: 입력 블록, 암호: 블록 크기) */
    unsigned int         cra_ctxsize;     /* tfm 컨텍스트 크기 (키 상태 등) */
    unsigned int         cra_alignmask;   /* 데이터 정렬 요구사항 (0 = 1바이트 정렬) */

    int                  cra_priority;    /* 우선순위: 높을수록 먼저 선택 */
    unsigned int         cra_refcnt;      /* 참조 카운터 */

    char                 cra_name[128];       /* 알고리즘 정규 이름 ("sha256") */
    char                 cra_driver_name[128]; /* 드라이버 고유 이름 ("sha256-avx2") */

    const struct crypto_type *cra_type;    /* 알고리즘 유형 (skcipher, shash 등) */

    union {
        struct cipher_alg cipher;         /* 단일 블록 암호 (raw block cipher) */
    } cra_u;

    int (*cra_init)(struct crypto_tfm *tfm);    /* tfm 생성 시 초기화 */
    void (*cra_exit)(struct crypto_tfm *tfm);   /* tfm 해제 시 정리 */
    void (*cra_destroy)(struct crypto_alg *alg); /* 알고리즘 등록 해제 시 */

    struct module        *cra_module;     /* 소속 커널 모듈 */
};

주요 필드 상세

cra_flags 주요 플래그

이름, 우선순위, 모듈 alias를 어떻게 설계할 것인가

실제 driver author 입장에서 가장 먼저 엉키는 지점은 연산 코드가 아니라 이름 체계와 노출 정책입니다. cra_name은 커널 전체가 공유하는 공개 계약이고, cra_driver_name은 특정 구현체를 식별하는 내부 이름입니다. 이 둘을 섞어 쓰면 autoload, fallback, testmgr, 우선순위 선택이 전부 헷갈립니다.

#include <crypto/internal/skcipher.h>

static struct skcipher_alg my_ctr_algs[] = {
    {
        .setkey    = my_ctr_setkey,
        .encrypt   = my_ctr_encrypt_internal,
        .decrypt   = my_ctr_decrypt_internal,
        .init      = my_ctr_init_tfm,
        .exit      = my_ctr_exit_tfm,
        .min_keysize = 16,
        .max_keysize = 32,
        .ivsize      = 16,
        .chunksize   = 16,
        .walksize    = 16,
        .base = {
            .cra_name        = "__ctr(aes)",
            .cra_driver_name = "__ctr-aes-myhw",
            .cra_priority    = 400,
            .cra_flags       = CRYPTO_ALG_ASYNC |
                               CRYPTO_ALG_INTERNAL |
                               CRYPTO_ALG_KERN_DRIVER_ONLY,
            .cra_blocksize   = 1,
            .cra_ctxsize     = sizeof(struct my_ctr_ctx),
            .cra_module      = THIS_MODULE,
        },
    }, {
        .setkey    = my_ctr_setkey,
        .encrypt   = my_ctr_encrypt,
        .decrypt   = my_ctr_decrypt,
        .init      = my_ctr_init_tfm,
        .exit      = my_ctr_exit_tfm,
        .min_keysize = 16,
        .max_keysize = 32,
        .ivsize      = 16,
        .chunksize   = 16,
        .walksize    = 16,
        .base = {
            .cra_name        = "ctr(aes)",
            .cra_driver_name = "ctr-aes-myhw",
            .cra_priority    = 401,
            .cra_flags       = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
            .cra_blocksize   = 1,
            .cra_ctxsize     = sizeof(struct my_ctr_ctx),
            .cra_module      = THIS_MODULE,
        },
    },
};

MODULE_ALIAS_CRYPTO("ctr(aes)");
MODULE_ALIAS_CRYPTO("ctr-aes-myhw");

shash 알고리즘 구현 (동기 해시)

가장 단순한 구현 유형인 shash (synchronous hash)로 시작합니다. 커널 소스의 crypto/sha256_generic.c를 참고한 전체 구현 예제입니다:

#include <crypto/internal/hash.h>
#include <linux/module.h>

#define MY_HASH_DIGEST_SIZE  32   /* 출력 해시 크기 (바이트) */
#define MY_HASH_BLOCK_SIZE   64   /* 내부 처리 블록 크기 */

/* tfm당 할당되는 컨텍스트 (키, 상태 등) */
struct my_hash_tfm_ctx {
    u8 key[32];
    bool has_key;
};

/* 요청(desc)당 할당되는 상태 (중간 해시 상태 등) */
struct my_hash_desc_ctx {
    u64 state[4];
    u8  buf[MY_HASH_BLOCK_SIZE];
    unsigned int buflen;
    u64 count;        /* 처리한 총 바이트 수 */
};

/* ① 해시 초기화: 내부 상태를 초기값으로 설정 */
static int my_hash_init(struct shash_desc *desc)
{
    struct my_hash_desc_ctx *dctx = shash_desc_ctx(desc);

    dctx->state[0] = 0x6a09e667f3bcc908ULL;  /* 초기 해시 값 */
    dctx->state[1] = 0xbb67ae8584caa73bULL;
    dctx->state[2] = 0x3c6ef372fe94f82bULL;
    dctx->state[3] = 0xa54ff53a5f1d36f1ULL;
    dctx->buflen = 0;
    dctx->count = 0;
    return 0;
}

/* ② 데이터 입력: 여러 번 호출될 수 있음 (스트리밍 해시) */
static int my_hash_update(struct shash_desc *desc,
                          const u8 *data, unsigned int len)
{
    struct my_hash_desc_ctx *dctx = shash_desc_ctx(desc);

    dctx->count += len;

    /* 버퍼에 남은 데이터와 새 데이터를 합쳐 블록 단위로 처리 */
    if (dctx->buflen + len < MY_HASH_BLOCK_SIZE) {
        memcpy(dctx->buf + dctx->buflen, data, len);
        dctx->buflen += len;
        return 0;
    }

    /* 블록 단위 처리 (실제 해시 압축 함수 호출) */
    /* my_hash_compress(dctx->state, data_blocks, nblocks); */
    return 0;
}

/* ③ 최종 해시 값 출력 */
static int my_hash_final(struct shash_desc *desc, u8 *out)
{
    struct my_hash_desc_ctx *dctx = shash_desc_ctx(desc);

    /* 패딩 적용 + 마지막 블록 처리 */
    /* my_hash_final_block(dctx); */

    /* 내부 상태를 출력 형식으로 변환 */
    memcpy(out, dctx->state, MY_HASH_DIGEST_SIZE);
    return 0;
}

/* ④ 선택사항: 한 번에 처리 (init+update+final 최적화) */
static int my_hash_digest(struct shash_desc *desc,
                          const u8 *data, unsigned int len,
                          u8 *out)
{
    my_hash_init(desc);
    my_hash_update(desc, data, len);
    return my_hash_final(desc, out);
}

/* ⑤ 선택사항: 키 설정 (HMAC, keyed hash용) */
static int my_hash_setkey(struct crypto_shash *tfm,
                          const u8 *key, unsigned int keylen)
{
    struct my_hash_tfm_ctx *ctx = crypto_shash_ctx(tfm);

    if (keylen > 32)
        return -EINVAL;

    memcpy(ctx->key, key, keylen);
    ctx->has_key = true;
    return 0;
}

/* ⑥ 상태 import/export (중간 상태 저장/복원, 선택사항) */
static int my_hash_export(struct shash_desc *desc, void *out)
{
    struct my_hash_desc_ctx *dctx = shash_desc_ctx(desc);
    memcpy(out, dctx, sizeof(*dctx));
    return 0;
}

static int my_hash_import(struct shash_desc *desc, const void *in)
{
    struct my_hash_desc_ctx *dctx = shash_desc_ctx(desc);
    memcpy(dctx, in, sizeof(*dctx));
    return 0;
}

/* ⑦ shash_alg 구조체 정의 */
static struct shash_alg my_hash_alg = {
    .init        = my_hash_init,
    .update      = my_hash_update,
    .final       = my_hash_final,
    .digest      = my_hash_digest,       /* 선택: 한 번에 처리 */
    .setkey      = my_hash_setkey,       /* 선택: keyed hash */
    .export      = my_hash_export,       /* 선택: 상태 저장 */
    .import      = my_hash_import,       /* 선택: 상태 복원 */
    .descsize    = sizeof(struct my_hash_desc_ctx),
    .statesize   = sizeof(struct my_hash_desc_ctx),
    .digestsize  = MY_HASH_DIGEST_SIZE,
    .base        = {
        .cra_name        = "myhash256",
        .cra_driver_name = "myhash256-generic",
        .cra_priority    = 100,
        .cra_blocksize   = MY_HASH_BLOCK_SIZE,
        .cra_ctxsize     = sizeof(struct my_hash_tfm_ctx),
        .cra_module      = THIS_MODULE,
    }
};

/* ⑧ 모듈 초기화/해제 */
static int __init my_hash_mod_init(void)
{
    return crypto_register_shash(&my_hash_alg);
}

static void __exit my_hash_mod_exit(void)
{
    crypto_unregister_shash(&my_hash_alg);
}

module_init(my_hash_mod_init);
module_exit(my_hash_mod_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Example hash algorithm");
MODULE_ALIAS_CRYPTO("myhash256");
MODULE_ALIAS_CRYPTO("myhash256-generic");

shash 콜백 호출 흐름

skcipher 알고리즘 구현 (대칭 암호)

대칭 블록/스트림 암호의 구현입니다. struct skcipher_alg을 사용하여 등록합니다:

#include <crypto/internal/skcipher.h>
#include <linux/module.h>

#define MY_CIPHER_BLOCK_SIZE  16
#define MY_CIPHER_KEY_SIZE    32
#define MY_CIPHER_IV_SIZE     16

/* tfm 컨텍스트: 확장된 키 스케줄 등 */
struct my_cipher_ctx {
    u32 enc_key_sched[60];     /* 암호화 키 스케줄 */
    u32 dec_key_sched[60];     /* 복호화 키 스케줄 */
    unsigned int key_length;
};

/* 키 설정: 키 스케줄(라운드 키) 생성 */
static int my_cipher_setkey(struct crypto_skcipher *tfm,
                            const u8 *key, unsigned int keylen)
{
    struct my_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);

    if (keylen != 16 && keylen != 24 && keylen != 32)
        return -EINVAL;

    ctx->key_length = keylen;
    /* 키 스케줄 확장 수행 */
    /* my_expand_key(ctx->enc_key_sched, key, keylen); */
    /* my_expand_key_dec(ctx->dec_key_sched, key, keylen); */
    return 0;
}

/* 암호화: scatterlist 기반 데이터 처리 */
static int my_cipher_encrypt(struct skcipher_request *req)
{
    struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    struct my_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
    struct skcipher_walk walk;
    int err;

    /* skcipher_walk: scatterlist를 선형 버퍼로 순회하는 헬퍼 */
    err = skcipher_walk_virt(&walk, req, false);

    while (walk.nbytes) {
        unsigned int nbytes = walk.nbytes;
        const u8 *src = walk.src.virt.addr;
        u8 *dst = walk.dst.virt.addr;
        u8 *iv = walk.iv;

        /* 블록 단위로 CBC 암호화 수행 */
        while (nbytes >= MY_CIPHER_BLOCK_SIZE) {
            /* XOR plaintext with IV/previous ciphertext (CBC 모드) */
            crypto_xor_cpy(dst, src, iv, MY_CIPHER_BLOCK_SIZE);
            /* 블록 암호화 */
            /* my_encrypt_block(ctx->enc_key_sched, dst, dst); */
            iv = dst;
            src += MY_CIPHER_BLOCK_SIZE;
            dst += MY_CIPHER_BLOCK_SIZE;
            nbytes -= MY_CIPHER_BLOCK_SIZE;
        }

        /* IV 업데이트 (다음 walk 반복을 위해) */
        memcpy(walk.iv, iv, MY_CIPHER_IV_SIZE);
        err = skcipher_walk_done(&walk, nbytes);
    }

    return err;
}

/* 복호화 */
static int my_cipher_decrypt(struct skcipher_request *req)
{
    /* 암호화와 유사하나 역방향 처리 + 복호화 키 스케줄 사용 */
    /* ... */
    return 0;
}

static struct skcipher_alg my_cipher_alg = {
    .setkey      = my_cipher_setkey,
    .encrypt     = my_cipher_encrypt,
    .decrypt     = my_cipher_decrypt,
    .min_keysize = 16,
    .max_keysize = 32,
    .ivsize      = MY_CIPHER_IV_SIZE,
    .chunksize   = MY_CIPHER_BLOCK_SIZE,  /* 최소 처리 단위 */
    .walksize    = MY_CIPHER_BLOCK_SIZE,  /* walk 반복당 최소 크기 */
    .base        = {
        .cra_name        = "cbc(mycipher)",
        .cra_driver_name = "cbc-mycipher-generic",
        .cra_priority    = 100,
        .cra_flags       = CRYPTO_ALG_ASYNC,  /* H/W인 경우 */
        .cra_blocksize   = MY_CIPHER_BLOCK_SIZE,
        .cra_ctxsize     = sizeof(struct my_cipher_ctx),
        .cra_module      = THIS_MODULE,
    }
};

static int __init my_cipher_mod_init(void)
{
    return crypto_register_skcipher(&my_cipher_alg);
}

static void __exit my_cipher_mod_exit(void)
{
    crypto_unregister_skcipher(&my_cipher_alg);
}

module_init(my_cipher_mod_init);
module_exit(my_cipher_mod_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_CRYPTO("cbc(mycipher)");

skcipher_walk 상세

skcipher_walk은 scatterlist 기반의 분산된 데이터를 선형 버퍼처럼 순회하는 핵심 헬퍼입니다:

AEAD 알고리즘 구현

AEAD(Authenticated Encryption with Associated Data)는 암호화와 무결성 검증을 동시에 수행합니다. 구현은 struct aead_alg을 사용합니다:

#include <crypto/internal/aead.h>
#include <crypto/scatterwalk.h>

struct my_aead_ctx {
    struct crypto_skcipher *enc_tfm;  /* 내부 암호화 tfm */
    struct crypto_shash    *mac_tfm;  /* 내부 MAC tfm */
    unsigned int authsize;
};

static int my_aead_setkey(struct crypto_aead *tfm,
                          const u8 *key, unsigned int keylen)
{
    struct my_aead_ctx *ctx = crypto_aead_ctx(tfm);

    /* 키를 암호화용과 MAC용으로 분리 */
    struct crypto_authenc_keys keys;
    if (crypto_authenc_extractkeys(&keys, key, keylen))
        return -EINVAL;

    /* 각 내부 알고리즘에 키 설정 */
    crypto_skcipher_setkey(ctx->enc_tfm, keys.enckey, keys.enckeylen);
    crypto_shash_setkey(ctx->mac_tfm, keys.authkey, keys.authkeylen);

    return 0;
}

static int my_aead_setauthsize(struct crypto_aead *tfm,
                               unsigned int authsize)
{
    struct my_aead_ctx *ctx = crypto_aead_ctx(tfm);

    if (authsize > 16)
        return -EINVAL;

    ctx->authsize = authsize;
    return 0;
}

static int my_aead_encrypt(struct aead_request *req)
{
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_aead_ctx *ctx = crypto_aead_ctx(tfm);

    /* 1단계: 평문을 암호화 (cbc, ctr 등) */
    /* 2단계: AAD + 암호문에 대해 MAC 계산 */
    /* 3단계: 인증 태그를 출력 끝에 추가 */

    /* req->src: [AAD | 평문]
     * req->dst: [AAD | 암호문 | 인증태그]
     * req->assoclen: AAD 길이
     * req->cryptlen: 평문 길이
     */
    return 0;
}

static int my_aead_decrypt(struct aead_request *req)
{
    /* 1단계: AAD + 암호문에 대해 MAC 재계산
     * 2단계: 수신된 인증 태그와 비교
     * 3단계: 일치하면 복호화, 불일치시 -EBADMSG 반환
     *
     * req->src: [AAD | 암호문 | 인증태그]
     * req->cryptlen: 암호문 + 인증태그 길이
     * 실제 암호문 길이 = req->cryptlen - ctx->authsize
     */
    return 0;
}

static int my_aead_init_tfm(struct crypto_aead *tfm)
{
    struct my_aead_ctx *ctx = crypto_aead_ctx(tfm);

    /* 내부 알고리즘 할당 */
    ctx->enc_tfm = crypto_alloc_skcipher("cbc(aes)", 0, 0);
    if (IS_ERR(ctx->enc_tfm))
        return PTR_ERR(ctx->enc_tfm);

    ctx->mac_tfm = crypto_alloc_shash("hmac(sha256)", 0, 0);
    if (IS_ERR(ctx->mac_tfm)) {
        crypto_free_skcipher(ctx->enc_tfm);
        return PTR_ERR(ctx->mac_tfm);
    }

    /* AEAD 요청 크기 설정: 내부 skcipher 요청도 포함 */
    crypto_aead_set_reqsize(tfm,
        sizeof(struct skcipher_request) +
        crypto_skcipher_reqsize(ctx->enc_tfm));

    return 0;
}

static void my_aead_exit_tfm(struct crypto_aead *tfm)
{
    struct my_aead_ctx *ctx = crypto_aead_ctx(tfm);

    crypto_free_skcipher(ctx->enc_tfm);
    crypto_free_shash(ctx->mac_tfm);
}

static struct aead_alg my_aead_alg = {
    .setkey      = my_aead_setkey,
    .setauthsize = my_aead_setauthsize,
    .encrypt     = my_aead_encrypt,
    .decrypt     = my_aead_decrypt,
    .init        = my_aead_init_tfm,
    .exit        = my_aead_exit_tfm,
    .ivsize      = 16,
    .maxauthsize = 16,
    .chunksize   = 16,
    .base        = {
        .cra_name        = "authenc(hmac(sha256),cbc(aes))",
        .cra_driver_name = "my-authenc-hmac-sha256-cbc-aes",
        .cra_priority    = 100,
        .cra_flags       = CRYPTO_ALG_ASYNC,
        .cra_blocksize   = 1,
        .cra_ctxsize     = sizeof(struct my_aead_ctx),
        .cra_module      = THIS_MODULE,
    }
};

AEAD 하드웨어 드라이버 구현: aead_engine_alg 기반 GCM 예시

위 예시는 "기존 암호 + MAC 조합"을 직접 보여 주기 위한 것입니다. 하지만 실제 SoC/PCIe 가속기는 대개 GCM/CCM tag 생성과 검증을 한 번에 처리합니다. 이런 장치를 driver로 올릴 때는 aead_engine_alg와 crypto_transfer_aead_request_to_engine() 패턴이 가장 실용적입니다. 핵심은 요청 레이아웃을 그대로 하드웨어 명령으로 번역하고, 하드웨어가 못 받는 입력만 fallback으로 보내는 것입니다.

#include <crypto/internal/aead.h>
#include <crypto/engine.h>

struct my_gcm_dev {
    struct device *dev;
    struct crypto_engine *engine;
    struct aead_request *active_req;
};

struct my_gcm_tfm_ctx {
    struct my_gcm_dev *dd;
    struct crypto_aead *fallback;
    unsigned int authsize;
    u8 key[32];
    unsigned int keylen;
};

struct my_gcm_reqctx {
    dma_addr_t src_dma;
    dma_addr_t dst_dma;
    u8 iv[16];
    bool decrypt;
    bool mapped;
};

static inline struct aead_request *my_gcm_fallback_req(struct my_gcm_reqctx *rctx)
{
    return PTR_ALIGN(rctx + 1, crypto_tfm_ctx_alignment());
}

static int my_gcm_setkey(struct crypto_aead *tfm,
                         const u8 *key, unsigned int keylen)
{
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);

    if (keylen != 16 && keylen != 24 && keylen != 32)
        return -EINVAL;

    memcpy(ctx->key, key, keylen);
    ctx->keylen = keylen;
    return crypto_aead_setkey(ctx->fallback, key, keylen);
}

static int my_gcm_setauthsize(struct crypto_aead *tfm,
                              unsigned int authsize)
{
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);

    switch (authsize) {
    case 8:
    case 12:
    case 16:
        ctx->authsize = authsize;
        return crypto_aead_setauthsize(ctx->fallback, authsize);
    }

    return -EINVAL;
}

static int my_gcm_init_tfm(struct crypto_aead *tfm)
{
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);

    ctx->fallback = crypto_alloc_aead("gcm(aes-generic)", 0, 0);
    if (IS_ERR(ctx->fallback))
        return PTR_ERR(ctx->fallback);

    ctx->authsize = 16;
    crypto_aead_setauthsize(ctx->fallback, ctx->authsize);
    crypto_aead_set_reqsize_dma(tfm,
        sizeof(struct my_gcm_reqctx) +
        crypto_tfm_ctx_alignment() +
        sizeof(struct aead_request) +
        crypto_aead_reqsize(ctx->fallback));
    return 0;
}

static void my_gcm_exit_tfm(struct crypto_aead *tfm)
{
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);
    crypto_free_aead(ctx->fallback);
}

static int my_gcm_do_fallback(struct aead_request *req, bool decrypt)
{
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);
    struct my_gcm_reqctx *rctx = aead_request_ctx(req);
    struct aead_request *subreq = my_gcm_fallback_req(rctx);

    aead_request_set_tfm(subreq, ctx->fallback);
    aead_request_set_callback(subreq, req->base.flags,
                              req->base.complete, req->base.data);
    aead_request_set_crypt(subreq, req->src, req->dst,
                           req->cryptlen, req->iv);
    aead_request_set_ad(subreq, req->assoclen);

    if (decrypt)
        return crypto_aead_decrypt(subreq);
    return crypto_aead_encrypt(subreq);
}

static int my_gcm_encrypt(struct aead_request *req)
{
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);
    struct my_gcm_reqctx *rctx = aead_request_ctx(req);

    rctx->decrypt = false;
    if (!my_gcm_hw_can_handle(req))
        return my_gcm_do_fallback(req, false);

    return crypto_transfer_aead_request_to_engine(ctx->dd->engine, req);
}

static int my_gcm_decrypt(struct aead_request *req)
{
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);
    struct my_gcm_reqctx *rctx = aead_request_ctx(req);

    rctx->decrypt = true;
    if (!my_gcm_hw_can_handle(req))
        return my_gcm_do_fallback(req, true);

    return crypto_transfer_aead_request_to_engine(ctx->dd->engine, req);
}

static int my_gcm_do_one_request(struct crypto_engine *engine, void *areq)
{
    struct crypto_async_request *base = areq;
    struct aead_request *req = container_of(base, struct aead_request, base);
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_gcm_tfm_ctx *ctx = crypto_aead_ctx(tfm);
    struct my_gcm_reqctx *rctx = aead_request_ctx_dma(req);

    (void)engine;
    ctx->dd->active_req = req;
    memcpy(rctx->iv, req->iv, crypto_aead_ivsize(tfm));

    my_gcm_map_req(ctx->dd, req, rctx);
    my_gcm_program(ctx->dd, req->assoclen, req->cryptlen,
                   crypto_aead_authsize(tfm), rctx->iv, rctx->decrypt);
    my_gcm_kick(ctx->dd);
    return -EINPROGRESS;
}

static irqreturn_t my_gcm_irq(int irq, void *data)
{
    struct my_gcm_dev *dd = data;
    struct aead_request *req = dd->active_req;
    struct crypto_aead *tfm = crypto_aead_reqtfm(req);
    struct my_gcm_reqctx *rctx = aead_request_ctx_dma(req);
    int err = my_gcm_status(dd);

    (void)irq;
    (void)tfm;
    if (!err && rctx->decrypt && !my_gcm_tag_ok(dd))
        err = -EBADMSG;

    if (rctx->mapped)
        my_gcm_unmap_req(dd, req, rctx);

    dd->active_req = NULL;
    crypto_finalize_aead_request(dd->engine, req, err);
    return IRQ_HANDLED;
}

static struct aead_engine_alg my_gcm_alg = {
    .base = {
        .setkey      = my_gcm_setkey,
        .setauthsize = my_gcm_setauthsize,
        .encrypt     = my_gcm_encrypt,
        .decrypt     = my_gcm_decrypt,
        .init        = my_gcm_init_tfm,
        .exit        = my_gcm_exit_tfm,
        .ivsize      = 12,
        .maxauthsize = 16,
        .chunksize   = 1,
        .base = {
            .cra_name        = "gcm(aes)",
            .cra_driver_name = "gcm-aes-myhw",
            .cra_priority    = 450,
            .cra_flags       = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
            .cra_blocksize   = 1,
            .cra_ctxsize     = sizeof(struct my_gcm_tfm_ctx),
            .cra_alignmask   = 0xf,
            .cra_module      = THIS_MODULE,
        },
    },
    .op = {
        .do_one_request = my_gcm_do_one_request,
    },
};

템플릿(Template) 구현

템플릿은 기존 알고리즘을 래핑하여 새로운 알고리즘을 자동 생성하는 메커니즘입니다. 예를 들어 cbc 템플릿은 임의의 블록 암호를 CBC 모드로 래핑합니다:

#include <crypto/internal/skcipher.h>

/* 템플릿 인스턴스의 컨텍스트 */
struct my_tmpl_instance_ctx {
    struct crypto_skcipher_spawn spawn;  /* 내부 알고리즘 참조 */
};

struct my_tmpl_tfm_ctx {
    struct crypto_skcipher *child;      /* 실제 내부 tfm */
};

/* 템플릿 인스턴스 생성: "mymode(aes)" 요청 시 호출 */
static int my_tmpl_create(struct crypto_template *tmpl,
                          struct rtattr **tb)
{
    struct skcipher_instance *inst;
    struct my_tmpl_instance_ctx *ictx;
    struct skcipher_alg_common *alg;
    u32 mask;
    int err;

    /* 내부 알고리즘 이름 추출 (예: "aes" from "mymode(aes)") */
    err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER, &mask);
    if (err)
        return err;

    /* 인스턴스 할당 */
    inst = kzalloc(sizeof(*inst) + sizeof(*ictx), GFP_KERNEL);
    if (!inst)
        return -ENOMEM;

    ictx = skcipher_instance_ctx(inst);

    /* 내부 알고리즘(spawn) 바인딩 */
    err = crypto_grab_skcipher(&ictx->spawn,
                              skcipher_crypto_instance(inst),
                              crypto_attr_alg_name(tb[1]),
                              0, mask);
    if (err)
        goto err_free;

    alg = crypto_spawn_skcipher_alg_common(&ictx->spawn);

    /* 인스턴스 이름 조합: "mymode(inner_alg_name)" */
    err = snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
                   "mymode(%s)", alg->base.cra_name);

    err = snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
                   "mymode(%s)", alg->base.cra_driver_name);

    /* 내부 알고리즘 속성 상속 */
    inst->alg.base.cra_priority = alg->base.cra_priority;
    inst->alg.base.cra_blocksize = alg->base.cra_blocksize;
    inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
    inst->alg.base.cra_ctxsize = sizeof(struct my_tmpl_tfm_ctx);

    inst->alg.ivsize = alg->ivsize;
    inst->alg.min_keysize = alg->min_keysize;
    inst->alg.max_keysize = alg->max_keysize;

    /* 콜백 등록 */
    inst->alg.setkey  = my_tmpl_setkey;
    inst->alg.encrypt = my_tmpl_encrypt;
    inst->alg.decrypt = my_tmpl_decrypt;
    inst->alg.init    = my_tmpl_init_tfm;
    inst->alg.exit    = my_tmpl_exit_tfm;

    inst->free = my_tmpl_free_instance;

    /* 인스턴스 등록 */
    err = skcipher_register_instance(tmpl, inst);
    if (err)
        goto err_free;

    return 0;

err_free:
    kfree(inst);
    return err;
}

/* 템플릿 등록 */
static struct crypto_template my_tmpl = {
    .name   = "mymode",
    .create = my_tmpl_create,
    .module = THIS_MODULE,
};

static int __init my_tmpl_mod_init(void)
{
    return crypto_register_template(&my_tmpl);
}

static void __exit my_tmpl_mod_exit(void)
{
    crypto_unregister_template(&my_tmpl);
}

드라이버 작성자의 핵심 감각: tfm 컨텍스트와 request 컨텍스트를 분리하라

Crypto API 제공자 입장에서 가장 중요한 설계는 무엇이 tfm에 속하고 무엇이 request에 속하는가입니다. 같은 알고리즘 인스턴스를 여러 CPU가 동시에 사용할 수 있으므로, cra_ctxsize로 잡은 tfm 컨텍스트에는 키 스케줄, 디바이스 포인터, fallback tfm, 정적 capability 같은 장수 상태만 두어야 합니다. 반대로 DMA mapping, bounce buffer, SG walk 상태, IRQ 완료용 descriptor는 요청마다 독립적이어야 하므로 reqsize에 들어가야 합니다.

#include <crypto/internal/skcipher.h>
#include <crypto/internal/hash.h>

struct my_dev {
    struct device *dev;
    void __iomem *regs;
    int irq;
};

/* tfm당 한 번만 살아 있는 상태 */
struct my_skcipher_tfm_ctx {
    struct my_dev *dd;
    struct crypto_skcipher *fallback;
    u32 round_keys[60];
    unsigned int keylen;
};

/* 요청마다 새로 필요한 상태 */
struct my_skcipher_reqctx {
    dma_addr_t src_dma;
    dma_addr_t dst_dma;
    u8 iv[16];
    bool mapped;
    bool use_fallback;
};

static int my_skcipher_init_tfm(struct crypto_skcipher *tfm)
{
    struct my_skcipher_tfm_ctx *ctx = crypto_skcipher_ctx(tfm);

    ctx->fallback = crypto_alloc_skcipher("cbc(aes-generic)", 0, 0);
    if (IS_ERR(ctx->fallback))
        return PTR_ERR(ctx->fallback);

    /* DMA 정렬까지 고려한 request private area */
    crypto_skcipher_set_reqsize_dma(tfm, sizeof(struct my_skcipher_reqctx));
    return 0;
}

static void my_skcipher_exit_tfm(struct crypto_skcipher *tfm)
{
    struct my_skcipher_tfm_ctx *ctx = crypto_skcipher_ctx(tfm);
    crypto_free_skcipher(ctx->fallback);
}

static int my_ahash_init_tfm(struct crypto_ahash *tfm)
{
    /* 해시도 동일한 패턴: statesize와 reqsize를 정직하게 설정 */
    crypto_ahash_set_statesize(tfm, 32);
    crypto_ahash_set_reqsize_dma(tfm, 128);
    return 0;
}

드라이버 메타데이터를 대충 정하면 생기는 문제

Crypto driver는 단순히 함수 포인터만 채우는 구조가 아닙니다. blocksize, alignmask, chunksize, walksize, reqsize 같은 메타데이터가 상위 계층의 메모리 배치, bounce buffer 사용, page 경계 처리, zero-copy 가능 여부를 결정합니다.

ahash 드라이버 구현: DMA 해시 엔진 + 소프트웨어 fallback

해시 가속기는 실무에서 가장 다양한 제약을 가집니다. 어떤 엔진은 진짜 스트리밍(init/update/final)을 지원하고, 어떤 엔진은 digest one-shot만 빠르며, 어떤 엔진은 finup는 되지만 중간 상태 export/import는 안 됩니다. 따라서 ahash driver는 하드웨어가 지원하는 가장 강한 연산을 기준으로 구현하고, 그보다 풍부한 API 표면은 소프트웨어 fallback으로 메워야 합니다.

#include <crypto/internal/hash.h>
#include <crypto/engine.h>
#include <linux/dma-mapping.h>

struct my_sha_dev {
    struct device *dev;
    struct crypto_engine *engine;
    struct ahash_request *active_req;
};

struct my_sha_tfm_ctx {
    struct my_sha_dev *dd;
    struct crypto_shash *fallback;
};

struct my_sha_reqctx {
    dma_addr_t src_dma;
    dma_addr_t result_dma;
    u8 digest[32];
    bool mapped;
};

static int my_sha_init_tfm(struct crypto_ahash *tfm)
{
    struct my_sha_tfm_ctx *ctx = crypto_ahash_ctx(tfm);

    ctx->fallback = crypto_alloc_shash("sha256-generic", 0, 0);
    if (IS_ERR(ctx->fallback))
        return PTR_ERR(ctx->fallback);

    crypto_ahash_set_statesize(tfm, 32);
    crypto_ahash_set_reqsize_dma(tfm, sizeof(struct my_sha_reqctx));
    return 0;
}

static void my_sha_exit_tfm(struct crypto_ahash *tfm)
{
    struct my_sha_tfm_ctx *ctx = crypto_ahash_ctx(tfm);
    crypto_free_shash(ctx->fallback);
}

static int my_sha_init(struct ahash_request *req)
{
    struct my_sha_reqctx *rctx = ahash_request_ctx(req);
    memset(rctx, 0, sizeof(*rctx));
    return 0;
}

static int my_sha_fallback_digest(struct ahash_request *req)
{
    struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
    struct my_sha_tfm_ctx *ctx = crypto_ahash_ctx(tfm);
    SHASH_DESC_ON_STACK(desc, ctx->fallback);

    desc->tfm = ctx->fallback;
    return shash_ahash_digest(req, desc);
}

static int my_sha_digest(struct ahash_request *req)
{
    struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
    struct my_sha_tfm_ctx *ctx = crypto_ahash_ctx(tfm);

    /* 하드웨어가 요구하는 SG 조건을 만족하지 않으면 fallback */
    if (!my_sha_hw_can_digest(req->src, req->nbytes))
        return my_sha_fallback_digest(req);

    return crypto_transfer_hash_request_to_engine(ctx->dd->engine, req);
}

static int my_sha_update(struct ahash_request *req)
{
    /* 이 예시는 one-shot 하드웨어를 가정하므로 진짜 스트리밍은 fallback 처리 */
    return my_sha_fallback_digest(req);
}

static int my_sha_final(struct ahash_request *req)
{
    return my_sha_fallback_digest(req);
}

static int my_sha_do_one_request(struct crypto_engine *engine, void *areq)
{
    struct crypto_async_request *base = areq;
    struct ahash_request *req = ahash_request_cast(base);
    struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
    struct my_sha_tfm_ctx *ctx = crypto_ahash_ctx(tfm);
    struct my_sha_reqctx *rctx = ahash_request_ctx_dma(req);

    (void)engine;
    ctx->dd->active_req = req;

    rctx->src_dma = dma_map_sgtable(ctx->dd->dev, my_req_to_sgt(req), DMA_TO_DEVICE, 0);
    rctx->result_dma = dma_map_single(ctx->dd->dev, rctx->digest, 32, DMA_FROM_DEVICE);
    rctx->mapped = true;

    /* 레지스터 적재 후 SHA 엔진 시작 */
    my_sha_hw_kick(ctx->dd, req, rctx);
    return -EINPROGRESS;
}

static irqreturn_t my_sha_irq(int irq, void *data)
{
    struct my_sha_dev *dd = data;
    struct ahash_request *req = dd->active_req;
    struct my_sha_reqctx *rctx = ahash_request_ctx_dma(req);
    int err = my_sha_hw_status(dd);

    if (!err)
        memcpy(req->result, rctx->digest, 32);

    if (rctx->mapped)
        my_sha_unmap_req(dd, req, rctx);

    dd->active_req = NULL;
    crypto_finalize_hash_request(dd->engine, req, err);
    return IRQ_HANDLED;
}

static struct ahash_engine_alg my_sha_alg = {
    .base = {
        .init     = my_sha_init,
        .update   = my_sha_update,
        .final    = my_sha_final,
        .digest   = my_sha_digest,
        .init_tfm = my_sha_init_tfm,
        .exit_tfm = my_sha_exit_tfm,
        .reqsize  = sizeof(struct my_sha_reqctx),
        .halg = {
            .digestsize = 32,
            .statesize  = 32,
            .base = {
                .cra_name        = "sha256",
                .cra_driver_name = "sha256-myhw",
                .cra_priority    = 300,
                .cra_flags       = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY,
                .cra_blocksize   = 64,
                .cra_ctxsize     = sizeof(struct my_sha_tfm_ctx),
                .cra_alignmask   = 0,
                .cra_module      = THIS_MODULE,
            },
        },
    },
    .op = {
        .do_one_request = my_sha_do_one_request,
    },
};

RNG 드라이버 구현: TRNG와 DRBG 래퍼를 구분하라

rng_alg는 단순해 보이지만 정책적 의미가 큽니다. 하드웨어 TRNG를 그대로 노출하는지, 내부적으로 DRBG를 돌리는지, 외부에서 seed를 넣어야 하는지에 따라 seed()와 seedsize 의미가 달라집니다. 특히 FIPS 경계 안에서는 "엔트로피를 내는 장치"와 "결정론적으로 바이트를 내는 DRBG"를 혼동하면 안 됩니다.

#include <crypto/rng.h>
#include <crypto/internal/rng.h>

struct my_trng_ctx {
    struct my_dev *dd;
    bool seeded;
    u8 personalization[48];
};

static inline struct my_trng_ctx *my_rng_ctx(struct crypto_rng *tfm)
{
    return crypto_tfm_ctx(crypto_rng_tfm(tfm));
}

static int my_trng_seed(struct crypto_rng *tfm,
                        const u8 *seed, unsigned int slen)
{
    struct my_trng_ctx *ctx = my_rng_ctx(tfm);

    if (slen != 48)
        return -EINVAL;

    memcpy(ctx->personalization, seed, slen);
    ctx->seeded = true;
    return 0;
}

static int my_trng_generate(struct crypto_rng *tfm,
                            const u8 *src, unsigned int slen,
                            u8 *dst, unsigned int dlen)
{
    struct my_trng_ctx *ctx = my_rng_ctx(tfm);

    if (!ctx->seeded)
        return -EINVAL;

    while (dlen) {
        u32 word;

        if (!my_hw_rng_ready(ctx->dd))
            return -EAGAIN;

        word = my_hw_rng_read(ctx->dd);
        memcpy(dst, &word, min(dlen, sizeof(word)));
        dst += min(dlen, sizeof(word));
        dlen -= min(dlen, sizeof(word));
    }

    if (src && slen)
        my_hw_mix_additional_input(ctx->dd, src, slen);

    return 0;
}

static struct rng_alg my_trng_alg = {
    .generate = my_trng_generate,
    .seed     = my_trng_seed,
    .seedsize = 48,
    .base = {
        .cra_name        = "mytrng",
        .cra_driver_name = "mytrng-hw",
        .cra_priority    = 200,
        .cra_ctxsize     = sizeof(struct my_trng_ctx),
        .cra_module      = THIS_MODULE,
    },
};

압축 드라이버 구현: acomp는 engine helper가 없다는 점이 핵심

acomp는 비동기 압축 API이지만, skcipher/aead/ahash처럼 crypto_engine 래퍼가 제공되지는 않습니다. 따라서 비동기 압축 드라이버는 자체 queue/workqueue/IRQ 경로를 직접 관리하는 경우가 많습니다. 이것이 암호 드라이버와 압축 드라이버의 큰 차이점입니다.

#include <crypto/internal/acompress.h>
#include <linux/workqueue.h>

struct my_zip_tfm_ctx {
    struct my_dev *dd;
};

struct my_zip_reqctx {
    struct work_struct work;
    struct acomp_req *req;
    bool allocated_dst;
};

static void my_zip_dst_free(struct scatterlist *dst)
{
    my_sg_free(dst);
}

static void my_zip_do_work(struct work_struct *work)
{
    struct my_zip_reqctx *rctx = container_of(work, struct my_zip_reqctx, work);
    struct acomp_req *req = rctx->req;
    int err;

    err = my_zip_hw_run(req);
    if (!err)
        req->dlen = my_zip_result_len(req);

    acomp_request_complete(req, err);
}

static int my_zip_compress(struct acomp_req *req)
{
    struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
    struct my_zip_tfm_ctx *ctx = acomp_tfm_ctx(tfm);
    struct my_zip_reqctx *rctx = acomp_request_ctx(req);

    memset(rctx, 0, sizeof(*rctx));
    rctx->req = req;

    if (req->flags & CRYPTO_ACOMP_ALLOC_OUTPUT) {
        req->dst = my_zip_alloc_output_sg(req->dlen);
        if (!req->dst)
            return -ENOMEM;
        rctx->allocated_dst = true;
    }

    if (!my_zip_hw_can_handle(ctx->dd, req))
        return -EINVAL;

    INIT_WORK(&rctx->work, my_zip_do_work);
    queue_work(ctx->dd->wq, &rctx->work);
    return -EINPROGRESS;
}

static int my_zip_decompress(struct acomp_req *req)
{
    /* 압축과 동일한 패턴으로 하드웨어 또는 workqueue 경로 사용 */
    return my_zip_compress(req);
}

static int my_zip_init_tfm(struct crypto_acomp *tfm)
{
    struct my_zip_tfm_ctx *ctx = acomp_tfm_ctx(tfm);
    ctx->dd = my_pick_zip_device();
    return 0;
}

static struct acomp_alg my_zip_alg = {
    .compress = my_zip_compress,
    .decompress = my_zip_decompress,
    .dst_free = my_zip_dst_free,
    .init = my_zip_init_tfm,
    .reqsize = sizeof(struct my_zip_reqctx),
    .base = {
        .cra_name        = "deflate",
        .cra_driver_name = "deflate-myzip",
        .cra_priority    = 250,
        .cra_flags       = CRYPTO_ALG_ASYNC,
        .cra_ctxsize     = sizeof(struct my_zip_tfm_ctx),
        .cra_module      = THIS_MODULE,
    },
};

AKCIPHER 드라이버 구현: 길이 계약과 키 파싱이 절반이다

공개키 엔진 드라이버는 수학 연산보다도 키 파싱, 출력 길이 산정, verify 입력 규약을 정확히 맞추는 일이 더 어렵습니다. 특히 akcipher_request는 검증 경로에서 src = signature || digest 형태를 사용하므로, src_len과 dst_len의 의미가 연산마다 달라진다는 점을 기억해야 합니다.

#include <crypto/akcipher.h>
#include <crypto/internal/akcipher.h>

struct my_rsa_tfm_ctx {
    struct my_dev *dd;
    unsigned int modulus_size;
    bool has_pub;
    bool has_priv;
};

struct my_rsa_reqctx {
    dma_addr_t src_dma;
    dma_addr_t dst_dma;
};

static int my_rsa_set_pub_key(struct crypto_akcipher *tfm,
                              const void *key, unsigned int keylen)
{
    struct my_rsa_tfm_ctx *ctx = akcipher_tfm_ctx(tfm);

    /* BER/DER 파싱 후 modulus 길이 계산 */
    ctx->modulus_size = my_parse_rsa_pubkey(key, keylen, ctx);
    if (!ctx->modulus_size)
        return -EINVAL;

    ctx->has_pub = true;
    return 0;
}

static int my_rsa_set_priv_key(struct crypto_akcipher *tfm,
                               const void *key, unsigned int keylen)
{
    struct my_rsa_tfm_ctx *ctx = akcipher_tfm_ctx(tfm);

    ctx->modulus_size = my_parse_rsa_privkey(key, keylen, ctx);
    if (!ctx->modulus_size)
        return -EINVAL;

    ctx->has_priv = true;
    return 0;
}

static unsigned int my_rsa_max_size(struct crypto_akcipher *tfm)
{
    struct my_rsa_tfm_ctx *ctx = akcipher_tfm_ctx(tfm);
    return ctx->modulus_size;
}

static int my_rsa_encrypt(struct akcipher_request *req)
{
    struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
    struct my_rsa_tfm_ctx *ctx = akcipher_tfm_ctx(tfm);

    if (!ctx->has_pub)
        return -EINVAL;

    if (req->dst_len < ctx->modulus_size) {
        req->dst_len = ctx->modulus_size;
        return -EOVERFLOW;
    }

    /* PKCS#1/OAEP padding 검증 후 장치 또는 소프트웨어 경로 수행 */
    req->dst_len = ctx->modulus_size;
    return my_rsa_hw_encrypt(req, ctx);
}

static int my_rsa_verify(struct akcipher_request *req)
{
    struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
    struct my_rsa_tfm_ctx *ctx = akcipher_tfm_ctx(tfm);

    /* verify 입력 규약:
     * req->src     = [signature][digest]
     * req->src_len = signature 길이
     * req->dst_len = digest 길이
     */
    if (req->src_len != ctx->modulus_size)
        return -EINVAL;

    if (!my_rsa_sig_matches_digest(req, ctx))
        return -EBADMSG;

    return 0;
}

static int my_rsa_init_tfm(struct crypto_akcipher *tfm)
{
    akcipher_set_reqsize_dma(tfm, sizeof(struct my_rsa_reqctx));
    return 0;
}

static struct akcipher_alg my_rsa_alg = {
    .encrypt      = my_rsa_encrypt,
    .verify       = my_rsa_verify,
    .set_pub_key  = my_rsa_set_pub_key,
    .set_priv_key = my_rsa_set_priv_key,
    .max_size     = my_rsa_max_size,
    .init         = my_rsa_init_tfm,
    .base = {
        .cra_name        = "rsa",
        .cra_driver_name = "rsa-myhw",
        .cra_priority    = 500,
        .cra_flags       = CRYPTO_ALG_ASYNC,
        .cra_ctxsize     = sizeof(struct my_rsa_tfm_ctx),
        .cra_module      = THIS_MODULE,
    },
};

KPP 드라이버 구현: 공개키 생성과 공유 비밀 계산을 분리하라

KPP 드라이버는 "세션 키 합의"라는 높은 수준 개념 대신, 훨씬 더 낮은 두 primitive만 제공합니다. 하나는 내 공개키 생성, 다른 하나는 상대 공개키를 입력으로 공유 비밀 계산입니다. 소비자(TLS, IPsec, WireGuard 전단 등)는 그 결과를 다시 KDF에 넣어 실제 데이터 키를 만듭니다.

#include <crypto/kpp.h>
#include <crypto/internal/kpp.h>
#include <crypto/ecdh.h>

struct my_ecdh_tfm_ctx {
    struct my_dev *dd;
    u8 priv[80];
    unsigned int priv_len;
    unsigned int pub_len;
    unsigned int secret_len;
};

struct my_ecdh_reqctx {
    dma_addr_t src_dma;
    dma_addr_t dst_dma;
};

static int my_ecdh_set_secret(struct crypto_kpp *tfm,
                               const void *buffer, unsigned int len)
{
    struct my_ecdh_tfm_ctx *ctx = kpp_tfm_ctx(tfm);
    struct ecdh params;
    int ret;

    ret = crypto_ecdh_decode_key(buffer, len, &params);
    if (ret)
        return ret;

    if (params.key_size > sizeof(ctx->priv))
        return -EINVAL;

    memcpy(ctx->priv, params.key, params.key_size);
    ctx->priv_len = params.key_size;
    ctx->pub_len = my_ecdh_public_size(params.key_size);
    ctx->secret_len = my_ecdh_secret_size(params.key_size);
    return 0;
}

static unsigned int my_ecdh_max_size(struct crypto_kpp *tfm)
{
    struct my_ecdh_tfm_ctx *ctx = kpp_tfm_ctx(tfm);
    return max(ctx->pub_len, ctx->secret_len);
}

static int my_ecdh_generate_public_key(struct kpp_request *req)
{
    struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
    struct my_ecdh_tfm_ctx *ctx = kpp_tfm_ctx(tfm);

    if (req->dst_len < ctx->pub_len) {
        req->dst_len = ctx->pub_len;
        return -EOVERFLOW;
    }

    req->dst_len = ctx->pub_len;
    return my_ecdh_hw_make_public(req, ctx);
}

static int my_ecdh_compute_shared_secret(struct kpp_request *req)
{
    struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
    struct my_ecdh_tfm_ctx *ctx = kpp_tfm_ctx(tfm);

    if (req->dst_len < ctx->secret_len) {
        req->dst_len = ctx->secret_len;
        return -EOVERFLOW;
    }

    req->dst_len = ctx->secret_len;
    return my_ecdh_hw_shared_secret(req, ctx);
}

static int my_ecdh_init_tfm(struct crypto_kpp *tfm)
{
    kpp_set_reqsize_dma(tfm, sizeof(struct my_ecdh_reqctx));
    return 0;
}

static struct kpp_alg my_ecdh_alg = {
    .set_secret            = my_ecdh_set_secret,
    .generate_public_key   = my_ecdh_generate_public_key,
    .compute_shared_secret = my_ecdh_compute_shared_secret,
    .max_size              = my_ecdh_max_size,
    .init                  = my_ecdh_init_tfm,
    .base = {
        .cra_name        = "ecdh",
        .cra_driver_name = "ecdh-myhw",
        .cra_priority    = 350,
        .cra_flags       = CRYPTO_ALG_ASYNC,
        .cra_ctxsize     = sizeof(struct my_ecdh_tfm_ctx),
        .cra_module      = THIS_MODULE,
    },
};

하드웨어 드라이버 등록 패턴: crypto_engine을 기준으로 보는 전체 수명

하드웨어 crypto driver의 전형적인 뼈대는 다음 순서입니다. probe에서 engine 생성 → 알고리즘 등록 → tfm init에서 per-transform state 준비 → encrypt/decrypt/digest가 engine queue에 요청 위임 → IRQ에서 finalize 입니다. 이 패턴을 지키면 backlog와 완료 통지가 Crypto API 규약에 맞춰 정리됩니다.

#include <crypto/engine.h>
#include <crypto/internal/skcipher.h>

struct my_accel_dev {
    struct device *dev;
    struct crypto_engine *engine;
};

static int my_hw_encrypt(struct skcipher_request *req)
{
    struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    struct my_skcipher_tfm_ctx *ctx = crypto_skcipher_ctx(tfm);
    return crypto_transfer_skcipher_request_to_engine(ctx->dd->engine, req);
}

static int my_hw_decrypt(struct skcipher_request *req)
{
    return my_hw_encrypt(req);
}

static int my_hw_do_one_request(struct crypto_engine *engine, void *areq)
{
    struct crypto_async_request *base = areq;
    struct skcipher_request *req = container_of(base, struct skcipher_request, base);

    (void)engine;
    my_hw_map_req(req);
    my_hw_start(req);
    return -EINPROGRESS;
}

static struct skcipher_engine_alg my_hw_algs[] = {{
    .base = {
        .setkey      = my_cipher_setkey,
        .encrypt     = my_hw_encrypt,
        .decrypt     = my_hw_decrypt,
        .init        = my_skcipher_init_tfm,
        .exit        = my_skcipher_exit_tfm,
        .min_keysize = 16,
        .max_keysize = 32,
        .ivsize      = 16,
        .chunksize   = 16,
        .walksize    = 16,
        .base = {
            .cra_name        = "cbc(aes)",
            .cra_driver_name = "cbc-aes-myhw",
            .cra_priority    = 400,
            .cra_flags       = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
            .cra_blocksize   = 16,
            .cra_ctxsize     = sizeof(struct my_skcipher_tfm_ctx),
            .cra_alignmask   = 0xf,
            .cra_module      = THIS_MODULE,
        },
    },
    .op = {
        .do_one_request = my_hw_do_one_request,
    },
}};

static int my_probe(struct platform_device *pdev)
{
    struct my_accel_dev *dd;
    int err;

    dd = devm_kzalloc(&pdev->dev, sizeof(*dd), GFP_KERNEL);
    if (!dd)
        return -ENOMEM;

    dd->dev = &pdev->dev;
    dd->engine = crypto_engine_alloc_init(&pdev->dev, true);
    if (!dd->engine)
        return -ENOMEM;

    err = crypto_engine_start(dd->engine);
    if (err)
        goto err_engine_exit;

    err = crypto_engine_register_skciphers(my_hw_algs, ARRAY_SIZE(my_hw_algs));
    if (err)
        goto err_engine_stop;

    return 0;

err_engine_stop:
    crypto_engine_stop(dd->engine);
err_engine_exit:
    crypto_engine_exit(dd->engine);
    return err;
}

static void my_remove(struct platform_device *pdev)
{
    struct my_accel_dev *dd = platform_get_drvdata(pdev);

    crypto_engine_unregister_skciphers(my_hw_algs, ARRAY_SIZE(my_hw_algs));
    crypto_engine_stop(dd->engine);
    crypto_engine_exit(dd->engine);
}

crypto_queue를 직접 쓰는 드라이버: crypto_engine이 맞지 않을 때

crypto_engine은 대부분의 단일 큐 장치에서 최선의 출발점입니다. 하지만 여러 채널을 가진 장치, vendor scheduler가 별도로 있는 장치, 요청을 일괄(batch)로 묶어야 하는 장치에서는 오히려 crypto_queue를 직접 다루는 편이 더 명확할 수 있습니다. 이 경우 핵심은 단 세 가지입니다. (1) enqueue는 락 안에서, (2) backlog 통지는 dequeue 직후, (3) 현재 active request 포인터는 완료 전에만 유효해야 합니다.

#include <crypto/algapi.h>
#include <crypto/internal/hash.h>

struct my_queue_dev {
    struct device *dev;
    spinlock_t lock;
    struct crypto_queue queue;
    struct ahash_request *active_req;
    bool busy;
};

static int my_queue_digest(struct ahash_request *req)
{
    struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
    struct my_queue_tfm_ctx *ctx = crypto_ahash_ctx(tfm);
    struct my_queue_dev *dd = ctx->dd;
    struct crypto_async_request *async_req, *backlog;
    unsigned long flags;
    int ret = 0;

    spin_lock_irqsave(&dd->lock, flags);

    ret = ahash_enqueue_request(&dd->queue, req);
    if (dd->busy) {
        spin_unlock_irqrestore(&dd->lock, flags);
        return ret;
    }

    backlog = crypto_get_backlog(&dd->queue);
    async_req = crypto_dequeue_request(&dd->queue);
    if (async_req) {
        dd->busy = true;
        dd->active_req = ahash_request_cast(async_req);
    }

    spin_unlock_irqrestore(&dd->lock, flags);

    if (!async_req)
        return ret;

    if (backlog)
        crypto_request_complete(backlog, -EINPROGRESS);

    ret = my_queue_start_hash(dd, dd->active_req);
    if (ret != -EINPROGRESS)
        my_queue_finish_one(dd, ret);
    return ret ? ret : -EINPROGRESS;
}

static void my_queue_finish_one(struct my_queue_dev *dd, int err)
{
    struct crypto_async_request *async_req, *backlog;
    struct ahash_request *req;
    unsigned long flags;

    spin_lock_irqsave(&dd->lock, flags);
    req = dd->active_req;
    dd->active_req = NULL;
    dd->busy = false;

    backlog = crypto_get_backlog(&dd->queue);
    async_req = crypto_dequeue_request(&dd->queue);
    if (async_req) {
        dd->busy = true;
        dd->active_req = ahash_request_cast(async_req);
    }
    spin_unlock_irqrestore(&dd->lock, flags);

    if (req)
        ahash_request_complete(req, err);

    if (backlog)
        crypto_request_complete(backlog, -EINPROGRESS);

    if (dd->active_req)
        my_queue_start_hash(dd, dd->active_req);
}

static irqreturn_t my_queue_irq(int irq, void *data)
{
    struct my_queue_dev *dd = data;
    int err = my_queue_hw_status(dd);

    (void)irq;
    my_queue_finish_one(dd, err);
    return IRQ_HANDLED;
}

static int my_queue_probe(struct platform_device *pdev)
{
    struct my_queue_dev *dd = platform_get_drvdata(pdev);

    spin_lock_init(&dd->lock);
    crypto_init_queue(&dd->queue, 64);
    dd->active_req = NULL;
    dd->busy = false;
    return 0;
}

비동기 드라이버의 반환값 계약

Crypto driver에서 가장 치명적인 버그 중 하나는 반환값과 완료 콜백의 의미를 뒤섞는 것입니다. 호출자 입장에서 "이미 끝났는지", "나중에 콜백이 올지", "버퍼 크기만 다시 잡으면 되는지"를 반환값 하나로 판단하기 때문입니다.

테스트 프레임워크

새 알고리즘을 추가하면 반드시 테스트 벡터를 함께 제공해야 합니다. 커널의 Crypto Framework (Crypto API)는 알고리즘 등록 시 자동으로 자가 테스트를 수행합니다.

testmgr — 알고리즘 자동 검증

crypto/testmgr.c는 등록된 모든 알고리즘에 대해 Known Answer Test(KAT)를 수행합니다. 알고리즘이 crypto_register_*()로 등록되면 cryptomgr가 비동기적으로 테스트를 트리거합니다:

/* crypto/testmgr.c — 테스트 벡터 구조체 */

/* 해시 테스트 벡터 */
struct hash_testvec {
    const char *key;          /* HMAC 키 (선택) */
    const char *plaintext;    /* 입력 데이터 */
    const char *digest;       /* 기대 해시 값 */
    unsigned int psize;       /* 입력 길이 */
    unsigned int ksize;       /* 키 길이 */
};

/* 대칭 암호 테스트 벡터 */
struct cipher_testvec {
    const char *key;          /* 암호 키 */
    const char *iv;           /* 초기화 벡터 */
    const char *ptext;        /* 평문 */
    const char *ctext;        /* 기대 암호문 */
    unsigned int klen;        /* 키 길이 */
    unsigned int len;         /* 데이터 길이 */
};

/* AEAD 테스트 벡터 */
struct aead_testvec {
    const char *key;
    const char *iv;
    const char *assoc;        /* AAD (추가 인증 데이터) */
    const char *ptext;        /* 평문 */
    const char *ctext;        /* 암호문 + 인증태그 */
    unsigned int klen;
    unsigned int alen;        /* AAD 길이 */
    unsigned int plen;        /* 평문 길이 */
    unsigned int clen;        /* 암호문+태그 길이 */
};

테스트 벡터 추가 방법

새 알고리즘의 테스트 벡터를 추가하려면 두 파일을 수정합니다:

/* 1단계: crypto/testmgr.h — 테스트 벡터 데이터 정의 */

static const struct hash_testvec myhash256_tv_template[] = {
    {   /* 벡터 #1: 빈 입력 */
        .plaintext = "",
        .psize     = 0,
        .digest    = "\xe3\xb0\xc4\x42...",  /* 기대 해시 값 */
    },
    {   /* 벡터 #2: "abc" */
        .plaintext = "abc",
        .psize     = 3,
        .digest    = "\xba\x78\x16\xbf...",
    },
    {   /* 벡터 #3: 긴 입력 (NIST 표준 벡터 등) */
        .plaintext = "abcdbcdecdefdefg...",
        .psize     = 56,
        .digest    = "\x24\x8d\x6a\x61...",
    },
};

/* 2단계: crypto/testmgr.c — 테스트 벡터를 알고리즘에 연결 */

static const struct alg_test_desc alg_test_descs[] = {
    /* ... 기존 항목들 (알파벳순 정렬!) ... */
    {
        .alg  = "myhash256",
        .test = alg_test_hash,      /* 테스트 함수 유형 */
        .suite = {
            .hash = __VECS(myhash256_tv_template)
        }
    },
    /* ... */
};

tcrypt — 성능 벤치마크

crypto/tcrypt.c는 암호 알고리즘의 성능을 측정하는 커널 모듈입니다:

# tcrypt 모듈 로드 — mode 번호로 테스트 유형 선택
modprobe tcrypt mode=200    # SHA-256 속도 테스트
modprobe tcrypt mode=500    # AES-CBC 속도 테스트
modprobe tcrypt mode=300    # AEAD 계열 속도 테스트

# 결과 확인
dmesg | tail -50
# testing speed of async cbc(aes) encryption
# test 0 (128 bit key, 16 byte blocks): 1 operation in 1234 cycles (16 bytes)
# test 1 (128 bit key, 64 byte blocks): 1 operation in 2345 cycles (64 bytes)

# 모든 알고리즘 셀프 테스트 실행
modprobe tcrypt mode=0      # 전체 알고리즘 테스트

# 특정 알고리즘만 테스트 (sec 파라미터로 벤치마크 시간 조절)
modprobe tcrypt mode=500 sec=5   # 5초간 벤치마크

Kconfig / Makefile 통합

커널 트리에 새 알고리즘을 통합하려면 crypto/ 디렉터리의 Kconfig와 Makefile을 수정합니다:

# crypto/Kconfig — 알고리즘 빌드 옵션 추가

config CRYPTO_MYHASH256
    tristate "My Hash 256 algorithm"
    select CRYPTO_HASH           # 해시 프레임워크 의존성
    help
      This is an example hash algorithm producing a 256-bit digest.

config CRYPTO_MYCIPHER
    tristate "My Block Cipher (CBC mode)"
    select CRYPTO_SKCIPHER       # skcipher 프레임워크 의존성
    select CRYPTO_LIB_AES        # AES 라이브러리 의존성 (필요 시) 
    help
      My custom block cipher with CBC mode support.

# H/W 가속 구현인 경우
config CRYPTO_MYCIPHER_X86_64
    tristate "My Block Cipher (x86_64/AES-NI 가속)"
    depends on X86 && 64BIT
    select CRYPTO_MYCIPHER       # generic 구현 fallback용 
    select CRYPTO_SIMD           # SIMD 헬퍼 */
    help
      x86_64 AES-NI accelerated implementation.

주요 Kconfig select 대상

MODULE_ALIAS_CRYPTO 매크로

/* 모듈 자동 로딩을 위한 alias 등록 */
MODULE_ALIAS_CRYPTO("myhash256");
MODULE_ALIAS_CRYPTO("myhash256-generic");

/* 커널이 "myhash256" 알고리즘을 요청하면:
 * 1. crypto_has_alg("myhash256") → 등록 안 됨
 * 2. request_module("crypto-myhash256") 호출
 * 3. MODULE_ALIAS_CRYPTO 매칭 → myhash256.ko 자동 로드
 * 4. module_init 실행 → crypto_register_shash()
 * 5. 이제 crypto_alloc_shash("myhash256") 성공
 */

cryptomgr와 알고리즘 탐색 메커니즘

cryptomgr(Crypto Manager)는 알고리즘 등록/해제/탐색을 관리하는 커널 서브시스템입니다:

crypto_larval — 알고리즘 대기 객체

/* crypto/api.c — 알고리즘 탐색 핵심 로직 (간략화) */

struct crypto_alg *crypto_alg_mod_lookup(const char *name,
                                         u32 type, u32 mask)
{
    struct crypto_alg *alg;

    /* 1. 이미 등록된 알고리즘 검색 */
    alg = crypto_alg_lookup(name, type, mask);
    if (alg)
        return alg;

    /* 2. 모듈 자동 로드 시도 (MODULE_ALIAS_CRYPTO 매칭) */
    request_module("crypto-%s", name);

    /* 3. larval (대기 객체) 생성 — 비동기 등록 대기 */
    struct crypto_larval *larval = crypto_larval_alloc(name, type, mask);

    /* 4. cryptomgr에 알고리즘 탐색 요청 (kthread) */
    crypto_probing_notify(CRYPTO_MSG_ALG_REQUEST, larval);

    /* 5. 등록 완료 대기 (타임아웃 60초) */
    alg = crypto_larval_wait(larval);

    /* cryptomgr는 템플릿 매칭을 시도:
     * "cbc(aes)" → cbc 템플릿 + aes 알고리즘으로 분해
     * → cbc 템플릿의 create() 호출
     * → cbc(aes) 인스턴스 자동 생성 및 등록
     */

    return alg;
}

FIPS 모드와 자가 테스트

FIPS(Federal Information Processing Standards)는 미국 NIST(National Institute of Standards and Technology)가 발행하는 연방 정보 처리 표준입니다. 암호화 모듈의 보안 요구사항을 정의하며, 미국 연방 정부 기관은 물론 금융, 의료, 방위산업 등 규제 환경에서 필수적으로 요구됩니다. 리눅스 커널은 부트 파라미터를 통해 FIPS 모드를 활성화하여 인증된 암호 알고리즘만 사용하도록 강제할 수 있습니다.

FIPS 140 표준 개요

FIPS 140은 암호화 모듈의 보안 요구사항을 정의하는 NIST 표준으로, 현재 FIPS 140-3(ISO/IEC 19790:2012 기반)이 최신 버전입니다. FIPS 140-2는 2021년 9월 이후 신규 인증이 중단되었으나, 기존 인증은 유효합니다.

주요 FIPS/NIST 암호화 표준

FIPS 모드 활성화

FIPS 140-3 인증이 필요한 환경에서는 커널을 FIPS 모드로 부팅합니다. 이 모드에서는 모든 암호 알고리즘이 반드시 자가 테스트(KAT: Known Answer Test)를 통과해야 사용 가능합니다:

# ─── FIPS 모드 활성화 (부트 파라미터) ───
# GRUB 설정: /etc/default/grub
GRUB_CMDLINE_LINUX="fips=1"
# /boot 파티션이 별도인 경우 boot= 지정 필요
GRUB_CMDLINE_LINUX="fips=1 boot=/dev/sda1"

# GRUB 설정 반영
grub2-mkconfig -o /boot/grub2/grub.cfg

# ─── 현재 FIPS 모드 확인 ───
cat /proc/sys/crypto/fips_enabled
# 1 = FIPS 모드, 0 = 일반 모드

# sysctl로도 확인 가능
sysctl crypto.fips_enabled
# crypto.fips_enabled = 1

# FIPS 모드에서 알고리즘 등록 실패 시 로그
dmesg | grep -i fips
# alg: fips already enabled
# alg: self-tests for myhash256 (myhash256-generic) failed
# (result -2) → 테스트 벡터 불일치

FIPS 모드 커널 내부 구현

커널 내부에서 FIPS 모드는 전역 변수 fips_enabled로 관리됩니다. 이 변수는 부팅 시 설정되며, 암호 서브시스템 전반에서 참조합니다:

/* crypto/fips.c — FIPS 모드 전역 상태 */
#include <linux/kernel.h>
#include <linux/sysctl.h>
#include <linux/export.h>

int fips_enabled;
EXPORT_SYMBOL_GPL(fips_enabled);

/* 부트 파라미터 "fips=1" 처리 */
static int __init fips_enable(char *str)
{
    fips_enabled = 1;
    pr_info("fips mode is enabled\\n");
    return 1;
}
__setup("fips=", fips_enable);

/* /proc/sys/crypto/fips_enabled sysctl 등록 */
static struct ctl_table crypto_sysctl_table[] = {
    {
        .procname   = "fips_enabled",
        .data       = &fips_enabled,
        .maxlen     = sizeof(int),
        .mode       = 0444,            /* 읽기 전용 */
        .proc_handler = proc_dointvec,
    },
};

커널 코드 내에서 FIPS 모드를 확인하는 주요 인터페이스:

/* include/linux/fips.h */
#ifdef CONFIG_CRYPTO_FIPS
extern int fips_enabled;
#else
#define fips_enabled 0
#endif

/* 사용 예: 비승인 알고리즘 차단 */
if (fips_enabled && !(alg->cra_flags & CRYPTO_ALG_FIPS_INTERNAL)) {
    /* FIPS 비승인 알고리즘 → 등록 거부 */
    return -ENOENT;
}

/* CONFIG_CRYPTO_FIPS 커널 설정 옵션 */
/*
 * Kconfig (crypto/Kconfig):
 * config CRYPTO_FIPS
 *     bool "FIPS 200 compliance"
 *     depends on CRYPTO
 *     help
 *       This option enables the FIPS boot option which is
 *       required if you want the system to operate in a
 *       FIPS 200 compliant manner.
 */

자가 테스트(Self-Test) 메커니즘

FIPS 140-3은 암호 모듈이 전원 투입 자가 테스트(Power-On Self-Test, POST)와 조건부 자가 테스트(Conditional Self-Test, CST)를 수행할 것을 요구합니다. 리눅스 커널에서는 crypto/testmgr.c가 이 역할을 담당합니다:

/* crypto/testmgr.c — 알고리즘 자가 테스트 핵심 구조 */

/* KAT(Known Answer Test) 테스트 벡터 구조체 */
struct cipher_testvec {
    const char *key;        /* 입력 키 */
    const char *iv;         /* 초기화 벡터 */
    const char *ptext;      /* 평문 (Known Input) */
    const char *ctext;      /* 암호문 (Known Answer) */
    unsigned int klen;      /* 키 길이 */
    unsigned int len;       /* 데이터 길이 */
    bool fips_skip;         /* FIPS 모드에서 건너뛸지 여부 */
};

/* 해시 테스트 벡터 */
struct hash_testvec {
    const char *key;        /* HMAC 키 (해시는 NULL) */
    const char *plaintext;  /* 입력 데이터 */
    const char *digest;     /* 기대 출력 (Known Answer) */
    unsigned int psize;     /* 평문 길이 */
    unsigned int ksize;     /* 키 길이 */
};

/* 알고리즘별 테스트 정의 — testmgr.c의 핵심 테이블 */
static const struct alg_test_desc alg_test_descs[] = {
    {
        .alg   = "cbc(aes)",
        .test  = alg_test_skcipher,
        .fips_allowed = 1,     /* FIPS 승인 알고리즘 */
        .suite = {
            .cipher = __VECS(aes_cbc_tv_template)
        }
    }, {
        .alg   = "ecb(aes)",
        .test  = alg_test_skcipher,
        .fips_allowed = 1,
        .suite = {
            .cipher = __VECS(aes_tv_template)
        }
    }, {
        .alg   = "sha256",
        .test  = alg_test_hash,
        .fips_allowed = 1,
        .suite = {
            .hash = __VECS(sha256_tv_template)
        }
    }, {
        .alg   = "hmac(sha256)",
        .test  = alg_test_hash,
        .fips_allowed = 1,
        .suite = {
            .hash = __VECS(hmac_sha256_tv_template)
        }
    },
    /* ... 수백 개의 알고리즘 테스트 정의 ... */
};

테스트 실행 흐름 — 알고리즘이 등록될 때 자동으로 호출됩니다:

/* crypto/testmgr.c — 자가 테스트 실행 흐름 */

/* 1. 알고리즘 등록 시 testmgr가 호출됨 */
int alg_test(const char *driver, const char *alg,
             u32 type, u32 mask)
{
    const struct alg_test_desc *test;
    int rc;

    /* alg_test_descs[] 테이블에서 알고리즘 검색 */
    test = find_test(alg);
    if (!test) {
        if (fips_enabled) {
            /* FIPS 모드: 테스트 없으면 → 등록 거부 */
            pr_err("alg: no test for %s (%s)\\n", alg, driver);
            return -EINVAL;
        }
        /* 일반 모드: 테스트 없으면 → 건너뜀 (경고만) */
        return 0;
    }

    /* 2. FIPS 모드에서 비승인 알고리즘 차단 */
    if (fips_enabled && !test->fips_allowed) {
        pr_info("alg: %s not allowed in fips mode\\n", alg);
        return -EINVAL;
    }

    /* 3. KAT(Known Answer Test) 실행 */
    rc = test->test(test, driver, type, mask);
    if (rc) {
        if (fips_enabled)
            panic("alg: self-tests for %s (%s) failed (rc=%d)\\n",
                  alg, driver, rc);
        else
            pr_warn("alg: self-tests for %s (%s) failed (rc=%d)\\n",
                    alg, driver, rc);
    }

    return rc;
}

FIPS 자가 테스트 유형

FIPS 140-3이 요구하는 자가 테스트는 크게 두 가지로 분류됩니다:

/* KAT 실행 예: 대칭 암호(skcipher) 테스트 */
static int test_skcipher_vec(const char *driver,
                              const struct cipher_testvec *vec,
                              struct skcipher_request *req)
{
    /* 1. 키 설정 */
    crypto_skcipher_setkey(tfm, vec->key, vec->klen);

    /* 2. 알려진 평문으로 암호화 수행 */
    sg_init_one(&sg, buf, vec->len);
    memcpy(buf, vec->ptext, vec->len);
    skcipher_request_set_crypt(req, &sg, &sg, vec->len, iv);
    err = crypto_skcipher_encrypt(req);

    /* 3. 결과를 Known Answer와 비교 */
    if (memcmp(buf, vec->ctext, vec->len) != 0) {
        pr_err("encryption test failed for %s\\n", driver);
        return -EINVAL;   /* KAT 실패 */
    }

    /* 4. 역방향(복호화) 테스트 */
    memcpy(buf, vec->ctext, vec->len);
    err = crypto_skcipher_decrypt(req);
    if (memcmp(buf, vec->ptext, vec->len) != 0) {
        pr_err("decryption test failed for %s\\n", driver);
        return -EINVAL;   /* KAT 실패 */
    }

    return 0;  /* 테스트 통과 */
}

/* 조건부 자가 테스트 예: DRBG 연속 출력 비교 */
static int drbg_healthcheck(struct drbg_state *drbg,
                             unsigned char *buf)
{
    /* FIPS 140-3: 난수 생성기 연속 출력 비교 테스트 (CRNGT)
     * 연속된 두 출력 블록이 동일하면 → 난수 생성기 고장 */
    if (memcmp(buf, drbg->prev_output, drbg->len) == 0) {
        pr_err("drbg: continuous test failed\\n");
        if (fips_enabled)
            panic("drbg: continuous random number test failed\\n");
        return -EFAULT;
    }
    memcpy(drbg->prev_output, buf, drbg->len);
    return 0;
}

FIPS 승인/비승인 알고리즘

FIPS 모드에서는 NIST가 승인한 알고리즘만 사용할 수 있습니다. testmgr.c의 fips_allowed 플래그로 구분합니다:

CRYPTO_ALG_FIPS_INTERNAL 플래그

커널은 CRYPTO_ALG_FIPS_INTERNAL 플래그로 FIPS 인증 경계(Boundary) 내의 알고리즘과 내부 도우미 알고리즘을 구분합니다:

/* include/linux/crypto.h */

/* FIPS 내부 전용 알고리즘 표시 — 정확한 비트값은 커널 헤더 기준 */
#define CRYPTO_ALG_FIPS_INTERNAL    /* include/linux/crypto.h 참조 */

/*
 * 이 플래그가 설정된 알고리즘:
 *   - FIPS 모듈 경계 내부에서만 사용 가능
 *   - AF_ALG 소켓을 통한 사용자 공간 접근 차단
 *   - /proc/crypto에서 "internal : yes"로 표시
 *
 * 예: CTR 모드 DRBG의 내부 AES 인스턴스
 *     → 직접 사용자 접근은 차단, DRBG 내부에서만 사용
 */

/* AF_ALG에서 FIPS_INTERNAL 알고리즘 차단 */
static int alg_accept(struct sock *sk)
{
    struct crypto_alg *alg = ...;

    /* FIPS 모드: internal 플래그 알고리즘은 AF_ALG로 사용 불가 */
    if (alg->cra_flags & CRYPTO_ALG_FIPS_INTERNAL) {
        if (fips_enabled)
            return -ENOENT;
    }
    ...
}

/* 템플릿에서 FIPS_INTERNAL 전파 예 */
static int cbc_create(struct crypto_template *tmpl,
                      struct rtattr **tb)
{
    /* 내부 알고리즘(예: ecb(aes))은 FIPS_INTERNAL로 마킹 */
    inst->alg.base.cra_flags |= (alg->cra_flags & CRYPTO_ALG_FIPS_INTERNAL);
    ...
}

HMAC 무결성 검증

FIPS 140-3은 암호화 모듈의 바이너리 무결성을 부팅 시 검증할 것을 요구합니다. 리눅스에서는 HMAC-SHA256 기반의 무결성 검증을 수행합니다:

# FIPS 무결성 파일 확인 (RHEL/CentOS 예시)
ls -la /boot/.vmlinuz-$(uname -r).hmac
# -r--------. 1 root root 33 Jan 15 12:00 /boot/.vmlinuz-6.x.hmac

# 커널 모듈 HMAC 파일
ls /lib/modules/$(uname -r)/.*.hmac
# .aesni-intel.ko.hmac
# .sha256_ssse3.ko.hmac
# .ghash-clmulni-intel.ko.hmac

# 수동 무결성 검증
sha256hmac /boot/vmlinuz-$(uname -r)
# 출력된 HMAC 값이 .vmlinuz-*.hmac 파일 내용과 일치해야 함

# FIPS 모듈 목록 확인 (dracut 기준)
cat /etc/dracut.conf.d/40-fips.conf
# add_dracutmodules+=" fips "

일반 모드 vs FIPS 모드 상세 비교

FIPS 모드가 영향을 미치는 커널 서브시스템

FIPS 모드 활성화는 Crypto Framework (Crypto API)뿐 아니라 암호화를 사용하는 모든 커널 서브시스템에 영향을 미칩니다:

FIPS 모드 디버깅

# ─── FIPS 모드 상태 종합 확인 ───

# 1. FIPS 모드 활성화 여부
cat /proc/sys/crypto/fips_enabled

# 2. 부팅 시 FIPS 관련 커널 로그
dmesg | grep -i fips
# [    0.000000] command line: ... fips=1
# [    0.123456] fips mode is enabled

# 3. 자가 테스트 결과 확인
dmesg | grep "alg: self-tests"
# alg: self-tests for sha256 (sha256-generic) passed
# alg: self-tests for aes (aes-generic) passed
# alg: self-tests for cbc(aes) (cbc-aes-aesni) passed

# 4. FIPS 승인 알고리즘 목록 확인
grep -A1 "selftest" /proc/crypto | grep -B1 "passed"

# 5. FIPS 모드에서 차단된 알고리즘 확인
dmesg | grep "not allowed in fips"
# alg: md5 not allowed in fips mode

# 6. 무결성 검증 실패 확인
dmesg | grep -i "integrity"
# integrity: HMAC check failed for vmlinuz

# 7. 커널 FIPS 설정 옵션 확인
zgrep CONFIG_CRYPTO_FIPS /proc/config.gz
# CONFIG_CRYPTO_FIPS=y

# 8. 현재 사용 중인 알고리즘의 FIPS 상태
# /proc/crypto에서 fips 관련 필드 확인
awk '/^name/{name=$NF} /^selftest/{print name, $NF}' /proc/crypto

# 9. FIPS 모드에서 OpenSSL 상태 확인 (사용자 공간 연동)
openssl version
openssl list -providers
# fips 프로바이더가 활성화되어 있어야 함

/proc/crypto 상세 해석

/proc/crypto는 현재 등록된 모든 알고리즘의 상세 정보를 보여줍니다:

# /proc/crypto 출력 예시 — AES-NI CBC 구현
name         : cbc(aes)
driver       : cbc-aes-aesni
module       : aesni_intel
priority     : 400
refcnt       : 9
selftest     : passed
internal     : no
type         : skcipher
async        : no
blocksize    : 16
min keysize  : 16
max keysize  : 32
ivsize       : 16
chunksize    : 16
walksize     : 16

# 실용적인 /proc/crypto 분석 명령

# 같은 알고리즘의 모든 구현체와 priority 비교
awk '/^name/{n=$3} /^driver/{d=$3} /^priority/{print n, d, $3}' /proc/crypto \
  | sort | column -t

# 특정 알고리즘의 실제 사용되는 구현 확인 (priority 최고)
awk '/^name/{n=$3} /^driver/{d=$3} /^priority/{p=$3}
     n=="cbc(aes)"{print p, d}' /proc/crypto | sort -rn | head -1

# 자가 테스트 실패한 알고리즘 찾기
awk '/^name/{n=$3} /^selftest/{if($3!="passed") print n, $3}' /proc/crypto

# 비동기(H/W) 알고리즘만 확인
awk '/^name/{n=$3} /^async/{if($3=="yes") print n}' /proc/crypto

SIMD 컨텍스트 관리

SSE/AVX/NEON 명령어를 사용하는 H/W 가속 구현에서는 SIMD 레지스터 컨텍스트 관리가 필수입니다. 커널에서 SIMD 레지스터를 사용하려면 명시적으로 저장/복원해야 합니다:

#include <asm/fpu/api.h>        /* x86 */
#include <crypto/internal/simd.h>

/* 방법 1: 직접 kernel_fpu_begin/end 사용 */
static int my_aesni_encrypt(struct skcipher_request *req)
{
    /* kernel_fpu_begin()은 현재 태스크의 FPU 상태를 저장하고
     * 커널이 SSE/AVX 레지스터를 사용할 수 있게 함
     * 주의: 이 구간에서는 preemption이 비활성화됨 */
    kernel_fpu_begin();

    /* AES-NI 명령어 사용 (인라인 어셈블리 또는 .S 파일) */
    aesni_cbc_enc(ctx->key_sched, dst, src, len, iv);

    kernel_fpu_end();
    return 0;
}

/* 방법 2: crypto_simd 래퍼 사용 (권장) */
/* softirq/hardirq 컨텍스트에서도 안전하게 동작
 * SIMD를 사용할 수 없는 컨텍스트에서는 자동으로
 * cryptd kthread로 작업을 위임 */
static struct simd_skcipher_alg *simd_alg;

static int __init my_simd_init(void)
{
    int err;

    /* 원본 SIMD 알고리즘 등록 (__cbc-aes-aesni, INTERNAL 플래그) */
    err = crypto_register_skcipher(&my_simd_skcipher);
    if (err)
        return err;

    /* SIMD 래퍼 등록 (cbc-aes-aesni, 외부 공개)
     * → process context: 직접 SIMD 실행
     * → softirq context: cryptd kthread로 위임 */
    simd_alg = simd_skcipher_create_compat(
        my_simd_skcipher.base.cra_name,
        my_simd_skcipher.base.cra_driver_name,
        my_simd_skcipher.base.cra_name);

    return PTR_ERR_OR_ZERO(simd_alg);
}

알고리즘 구현 체크리스트

crypto_alg 등록 흐름 심화

알고리즘 등록은 Crypto Framework (Crypto API)의 핵심 진입점입니다. crypto_register_alg() 호출 시 커널 내부에서는 이름 충돌 검사, 우선순위 비교, 테스트 벡터 검증, larval 깨우기, 템플릿 인스턴스화가 순차적으로 수행됩니다. 이 섹션에서는 등록 과정의 내부 흐름을 단계별로 추적합니다.

crypto_register_alg() 내부 흐름

crypto_register_alg()는 crypto/algapi.c에 정의되어 있으며, 호출 시 다음 순서로 동작합니다:

/* crypto/algapi.c — crypto_register_alg() 핵심 로직 (간략화) */

int crypto_register_alg(struct crypto_alg *alg)
{
    struct crypto_alg *q;
    int ret = 0;

    /* 1. 입력 유효성 검사 */
    if (!alg->cra_name[0] || !alg->cra_driver_name[0])
        return -EINVAL;

    /* blocksize가 PAGE_SIZE를 초과하면 거부 */
    if (alg->cra_blocksize > PAGE_SIZE)
        return -EINVAL;

    /* refcnt 초기화 */
    refcount_set(&alg->cra_refcnt, 1);

    /* 2. 전역 알고리즘 리스트 잠금 (write lock) */
    down_write(&crypto_alg_sem);

    /* 3. 같은 driver_name이 이미 등록되어 있는지 확인 */
    list_for_each_entry(q, &crypto_alg_list, cra_list) {
        if (!strcmp(q->cra_driver_name, alg->cra_driver_name)) {
            ret = -EEXIST;
            goto out_unlock;
        }
    }

    /* 4. 알고리즘 리스트에 삽입 */
    list_add(&alg->cra_list, &crypto_alg_list);

    /* 5. 대기 중인 larval 객체 깨우기
     * crypto_alloc_*()에서 대기 중이던 요청에 통보 */
    crypto_alg_finish_registration(alg);

    up_write(&crypto_alg_sem);

    /* 6. 알림 체인: testmgr, cryptomgr에 등록 이벤트 전달
     * → testmgr: 자가 테스트 스케줄링
     * → cryptomgr: 템플릿 인스턴스화 트리거 */
    crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, alg);

    return 0;

out_unlock:
    up_write(&crypto_alg_sem);
    return ret;
}

우선순위 선택과 동적 교체

같은 cra_name에 여러 구현이 등록되면, crypto_alloc_*() 시점에 priority가 가장 높은 구현이 선택됩니다. 나중에 더 높은 priority의 구현이 등록되면 새로운 tfm 할당부터 적용됩니다:

/* crypto/api.c — 알고리즘 선택 로직 (간략화) */

static struct crypto_alg *crypto_find_alg(const char *name,
                                            u32 type, u32 mask)
{
    struct crypto_alg *best = NULL;
    struct crypto_alg *q;

    list_for_each_entry(q, &crypto_alg_list, cra_list) {
        /* cra_name이 요청과 일치하는지 확인 */
        if (strcmp(q->cra_name, name) != 0)
            continue;

        /* type/mask 필터 적용 */
        if ((q->cra_flags ^ type) & mask)
            continue;

        /* priority가 더 높은 구현 선택 */
        if (!best || q->cra_priority > best->cra_priority)
            best = q;
    }

    return best;
}

/* 우선순위 예시:
 * "aes" → aes_generic(100) vs aes-aesni(300) vs qat_aes(4001)
 * → QAT 드라이버 로드 시 qat_aes(4001)가 자동 선택
 * → QAT 드라이버 unload 시 aes-aesni(300)로 자동 전환
 * 기존 tfm은 영향 없음, 새 crypto_alloc_*() 호출부터 적용 */

템플릿 인스턴스화 메커니즘

템플릿은 알고리즘 등록 시 CRYPTO_MSG_ALG_REGISTER 알림을 받아 자동으로 인스턴스를 생성합니다. 이 메커니즘을 통해 새 블록 암호를 추가하면 기존 모든 운용 모드와 자동 조합됩니다:

/* crypto/algboss.c — 템플릿 인스턴스화 트리거 */

static int cryptomgr_notify(struct notifier_block *this,
                            unsigned long msg, void *data)
{
    switch (msg) {
    case CRYPTO_MSG_ALG_REQUEST:
        /* 알고리즘 요청 시: 템플릿 매칭 → 인스턴스 생성 */
        return cryptomgr_schedule_probe(data);

    case CRYPTO_MSG_ALG_REGISTER:
        /* 새 알고리즘 등록 시: 대기 중인 larval과 매칭 */
        return cryptomgr_schedule_test(data);
    }
    return NOTIFY_DONE;
}

/* 인스턴스 생성 과정 (예: "cbc(sm4)" 요청 시) */
/*
 * 1. "cbc(sm4)" 파싱 → 템플릿 이름 "cbc" + 내부 알고리즘 "sm4"
 * 2. crypto_template 목록에서 "cbc" 탐색
 * 3. cbc_tmpl->create() 호출:
 *    a. sm4 알고리즘 참조 (spawn) 획득
 *    b. skcipher_instance 할당
 *    c. 이름/속성 설정: cra_name = "cbc(sm4)"
 *    d. 내부 알고리즘 속성 상속 (blocksize, keysize 등)
 *    e. skcipher_register_instance() 로 등록
 * 4. 등록 완료 → 대기 중인 larval 깨우기
 * 5. testmgr가 자가 테스트 수행
 */

AEAD 상태 머신 심화

AEAD(Authenticated Encryption with Associated Data) 알고리즘은 암호화와 인증을 하나의 원자적 연산으로 결합합니다. 내부적으로 encrypt 경로와 decrypt 경로는 비대칭적이며, 특히 decrypt에서는 인증 태그 검증이 복호화보다 먼저 수행됩니다. 이 섹션에서는 커널의 authenc 구현을 기준으로 AEAD의 상태 전이를 분석합니다.

Encrypt 경로 상태 전이

authenc 내부 구현 분석

커널의 crypto/authenc.c는 가장 기본적인 AEAD 구현으로, Encrypt-then-MAC 방식을 사용합니다. IPsec ESP에서 authenc(hmac(sha256),cbc(aes)) 형태로 주로 사용됩니다:

/* crypto/authenc.c — authenc encrypt 핵심 경로 (간략화) */

static int crypto_authenc_encrypt(struct aead_request *req)
{
    struct crypto_aead *authenc = crypto_aead_reqtfm(req);
    struct authenc_instance_ctx *ictx = aead_instance_ctx(
        aead_alg_instance(authenc));
    struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
    struct crypto_skcipher *enc = ictx->enc;
    int err;

    /* 1단계: skcipher로 평문 암호화 */
    struct skcipher_request *subreq = &areq_ctx->subreq;
    skcipher_request_set_tfm(subreq, enc);
    skcipher_request_set_crypt(subreq, req->src, req->dst,
                              req->cryptlen, req->iv);
    skcipher_request_set_callback(subreq, aead_request_flags(req),
                                 authenc_encrypt_done, req);

    err = crypto_skcipher_encrypt(subreq);
    if (err)
        return err;

    /* 2단계: AAD + 암호문에 대해 HMAC 계산 */
    return crypto_authenc_genicv(req, aead_request_flags(req));
}

/* authenc decrypt: MAC 검증이 먼저! */
static int crypto_authenc_decrypt(struct aead_request *req)
{
    struct crypto_aead *authenc = crypto_aead_reqtfm(req);
    unsigned int authsize = crypto_aead_authsize(authenc);
    int err;

    /* 1단계: AAD + 암호문에 대해 HMAC 재계산 */
    err = crypto_authenc_verify(req);
    if (err)
        return err;  /* -EBADMSG: 태그 불일치 → 복호화 거부 */

    /* 2단계: 태그 일치 확인 후에만 복호화 수행 */
    return crypto_authenc_decrypt_tail(req,
        aead_request_flags(req));
}

/* 태그 비교: 반드시 상수 시간(constant-time) 비교 사용 */
static int crypto_authenc_verify(struct aead_request *req)
{
    /* ... HMAC 계산 ... */

    /* crypto_memneq: 타이밍 부채널 방지 상수 시간 비교
     * memcmp와 달리 첫 불일치에서 조기 종료하지 않음 */
    if (crypto_memneq(computed_tag, received_tag, authsize))
        return -EBADMSG;

    return 0;
}

AEAD scatterlist 메모리 레이아웃

AEAD 요청의 scatterlist 레이아웃은 encrypt와 decrypt에서 비대칭적입니다. 이 차이를 정확히 이해하지 못하면 데이터 손상이나 인증 실패가 발생합니다:

/* AEAD scatterlist 구성 예제 (IPsec ESP 기준) */

struct scatterlist sg[3];
unsigned int authsize = crypto_aead_authsize(aead);

/* === Encrypt 시 === */
/* src: [AAD(assoclen) | 평문(cryptlen)]
 * dst: [AAD(assoclen) | 암호문(cryptlen) | 태그(authsize)] */
sg_init_table(sg, 3);
sg_set_buf(&sg[0], aad, assoclen);
sg_set_buf(&sg[1], plaintext, plaintext_len);
sg_set_buf(&sg[2], tag_space, authsize);  /* 태그 공간 확보 */

aead_request_set_crypt(req, sg, sg, plaintext_len, iv);
aead_request_set_ad(req, assoclen);

/* === Decrypt 시 === */
/* src: [AAD(assoclen) | 암호문+태그(cryptlen)]
 * cryptlen = 암호문 길이 + authsize
 * 실제 평문 길이 = cryptlen - authsize */
aead_request_set_crypt(req, sg, sg,
                      ciphertext_len + authsize,  /* 태그 포함! */
                      iv);
aead_request_set_ad(req, assoclen);

AES-NI 커널 통합 메커니즘

AES-NI 하드웨어 가속의 커널 통합은 단순히 AESENC 명령어를 호출하는 것 이상의 복잡한 시스템 엔지니어링을 포함합니다. kernel_fpu_begin()/end() 기반의 FPU 컨텍스트 관리, SIMD 래퍼를 통한 인터럽트 안전성 보장, S/W fallback 전환 등 핵심 메커니즘을 분석합니다.

kernel_fpu_begin/end 내부 동작

/* arch/x86/kernel/fpu/core.c — kernel_fpu_begin() 내부 */

void kernel_fpu_begin_mask(unsigned int kfpu_mask)
{
    /* 1. preemption 비활성화
     * FPU 상태가 복원되기 전에 다른 태스크로 전환되면
     * FPU 레지스터가 오염되므로 반드시 비활성화 */
    preempt_disable();

    /* 2. 현재 태스크의 FPU 상태를 메모리에 저장
     * XSAVE/XSAVEOPT/FXSAVE 중 CPU가 지원하는 최적 명령어 사용 */
    fpregs_lock();
    fpu__save(current);

    /* 3. 커널 FPU 사용 플래그 설정 */
    current->flags |= PF_KTHREAD_FPU;

    /* 이후 AES-NI 등 SIMD 명령어 사용 가능 */
}

void kernel_fpu_end(void)
{
    /* 1. 태스크의 FPU 상태 복원 (XRSTOR 등) */
    fpregs_unlock();

    /* 2. preemption 재활성화 */
    preempt_enable();
}

/* FPU 사용 가능 여부 확인 */
bool irq_fpu_usable(void)
{
    /* hardirq 또는 softirq 컨텍스트에서는 false
     * 이미 kernel_fpu_begin() 호출 중이면 false (중첩 금지) */
    if (in_irq() || in_softirq())
        return false;
    if (current->flags & PF_KTHREAD_FPU)
        return false;
    return true;
}

SIMD 래퍼와 cryptd 위임

커널의 SIMD 래퍼(crypto/simd.c)는 실행 컨텍스트에 따라 자동으로 처리 경로를 분기합니다:

/* crypto/simd.c — SIMD 래퍼의 encrypt 함수 (간략화) */

static int simd_skcipher_encrypt(struct skcipher_request *req)
{
    struct simd_skcipher_ctx *ctx = ...;

    /* crypto_simd_usable(): irq_fpu_usable()의 래퍼 */
    if (crypto_simd_usable()) {
        /* Process context: 직접 SIMD 알고리즘 호출
         * kernel_fpu_begin/end는 내부 알고리즘이 처리 */
        return crypto_skcipher_encrypt(ctx->internal_req);
    }

    /* Interrupt context: cryptd kthread로 위임
     * → cryptd 워커가 process context에서 실행
     * → 완료 시 콜백으로 결과 통보 */
    return cryptd_skcipher_enqueue(ctx->cryptd_req, req);
}

/* cryptd 워커 스레드 (crypto/cryptd.c) */
/* kcryptd 커널 스레드는 항상 process context에서 실행되므로
 * kernel_fpu_begin() 호출이 안전함 */
static void cryptd_skcipher_encrypt(struct crypto_async_request *base,
                                     int err)
{
    /* process context → kernel_fpu_begin() 가능 */
    err = crypto_skcipher_encrypt(subreq);
    /* 원본 요청의 완료 콜백 호출 */
    req->base.complete(&req->base, err);
}

S/W Fallback 메커니즘

H/W 가속기가 특정 조건(키 크기, 입력 크기, FPU 사용 불가 등)을 처리하지 못할 때 자동으로 S/W 구현으로 전환하는 메커니즘입니다:

/* H/W 가속 알고리즘의 fallback 구현 패턴 */

struct my_hw_ctx {
    struct crypto_skcipher *fallback;  /* S/W fallback tfm */
    /* ... H/W 고유 컨텍스트 ... */
};

static int my_hw_init_tfm(struct crypto_skcipher *tfm)
{
    struct my_hw_ctx *ctx = crypto_skcipher_ctx(tfm);
    const char *name = crypto_skcipher_alg_name(tfm);

    /* CRYPTO_ALG_NEED_FALLBACK으로 S/W 전용 구현을 요청
     * → priority가 낮은 generic 구현이 선택됨 */
    ctx->fallback = crypto_alloc_skcipher(name, 0,
                        CRYPTO_ALG_NEED_FALLBACK);
    if (IS_ERR(ctx->fallback))
        return PTR_ERR(ctx->fallback);

    /* fallback의 reqsize를 반영 */
    crypto_skcipher_set_reqsize(tfm,
        max(crypto_skcipher_reqsize(ctx->fallback),
            sizeof(struct my_hw_subreq)));

    return 0;
}

static int my_hw_encrypt(struct skcipher_request *req)
{
    struct my_hw_ctx *ctx = crypto_skcipher_ctx(
        crypto_skcipher_reqtfm(req));

    /* 조건 확인: SIMD 사용 가능 + H/W 지원 범위 */
    if (!crypto_simd_usable() ||
        req->cryptlen < MY_HW_MIN_SIZE) {
        /* Fallback: S/W 구현으로 전환 */
        skcipher_request_set_tfm(req, ctx->fallback);
        return crypto_skcipher_encrypt(req);
    }

    /* H/W 가속 경로 */
    kernel_fpu_begin();
    /* ... AES-NI 명령어 사용 ... */
    kernel_fpu_end();
    return 0;
}

/* 알고리즘 등록 시 NEED_FALLBACK 플래그 설정 */
static struct skcipher_alg my_hw_alg = {
    .base.cra_name        = "xts(aes)",
    .base.cra_driver_name = "xts-aes-my-hw",
    .base.cra_priority    = 500,
    .base.cra_flags       = CRYPTO_ALG_ASYNC |
                            CRYPTO_ALG_NEED_FALLBACK,
    /* ... */
};

암호화 성능 추적과 벤치마크

커널 암호화 작업의 성능 분석에는 tcrypt 모듈 벤치마크, ftrace 함수 추적, bpftrace 동적 계측의 세 가지 기법이 주로 사용됩니다. 이 섹션에서는 각 도구의 실전 활용법을 다룹니다.

tcrypt 고급 벤치마크

tcrypt 모듈은 커널 내부에서 직접 Crypto Framework (Crypto API)를 호출하여 순수 암호 연산 성능을 측정합니다. I/O 스택 오버헤드 없이 알고리즘 자체의 throughput을 확인할 수 있습니다:

# ═══ tcrypt 벤치마크 실전 활용 ═══

# skcipher 벤치마크 (AES-CBC, AES-CTR, AES-XTS)
modprobe tcrypt mode=500 sec=3   # 3초간 측정
modprobe tcrypt mode=501 sec=3   # AES-CTR
modprobe tcrypt mode=502 sec=3   # AES-XTS

# AEAD 벤치마크 (AES-GCM, ChaCha20-Poly1305)
modprobe tcrypt mode=211 sec=3   # AES-GCM

# 해시 벤치마크
modprobe tcrypt mode=403 sec=3   # SHA-256
modprobe tcrypt mode=404 sec=3   # SHA-512

# 결과 파싱: ops/sec와 throughput 추출
dmesg | grep "testing speed" -A 20 | tail -25
# testing speed of async cbc(aes) (cbc-aes-aesni) encryption
# test 5 (256 bit key, 8192 byte blocks): 495230 ops in 3 sec
#   → 495230 × 8192 / 3 = ~1.35 GB/s

# S/W vs H/W 비교: aes_generic 강제 사용
# 1. aesni_intel 모듈 일시 언로드
modprobe -r aesni_intel 2>/dev/null
modprobe tcrypt mode=500 sec=3   # aes_generic으로 테스트
# 2. aesni_intel 재로드
modprobe aesni_intel
modprobe tcrypt mode=500 sec=3   # AES-NI로 테스트
# → throughput 비교로 가속 비율 확인

ftrace를 이용한 암호화 함수 추적

ftrace는 커널 내장 추적기로, 암호화 함수의 호출 빈도와 지연 시간을 분석할 수 있습니다:

# ═══ ftrace로 crypto 함수 추적 ═══

# 1. 추적 가능한 crypto 함수 목록 확인
grep crypto /sys/kernel/debug/tracing/available_filter_functions | head -20
# crypto_skcipher_encrypt
# crypto_skcipher_decrypt
# crypto_aead_encrypt
# crypto_shash_digest
# crypto_alloc_tfm

# 2. function_graph 추적기로 호출 흐름 확인
cd /sys/kernel/debug/tracing
echo function_graph > current_tracer
echo crypto_skcipher_encrypt > set_graph_function
echo 1 > tracing_on

# dm-crypt I/O 발생 (다른 터미널에서)
dd if=/dev/urandom of=/dev/mapper/my-crypt bs=4K count=100

echo 0 > tracing_on
cat trace | head -40
# kcryptd/0-1234 |   0.456 us  | crypto_skcipher_encrypt();
#               |              |   cbc_encrypt();
#               |              |     kernel_fpu_begin();
#               |   0.312 us  |     aesni_cbc_enc();
#               |              |     kernel_fpu_end();

# 3. 함수 호출 히스토그램 (지연 시간 분포)
echo 0 > tracing_on
echo nop > current_tracer
echo crypto_skcipher_encrypt > set_ftrace_filter
echo 1 > function_profile_enabled
echo 1 > tracing_on

# 워크로드 실행 후
cat trace_stat/function0 | grep crypto
#   Function              Hit    Time          Avg
#   --------              ---    ----          ---
#   crypto_skcipher_encrypt  152847  45.230 ms   0.296 us

# 4. 추적 해제
echo 0 > tracing_on
echo 0 > function_profile_enabled
echo nop > current_tracer
echo > set_ftrace_filter

bpftrace를 이용한 동적 계측

bpftrace는 eBPF 기반의 고급 추적 도구로, 커널 암호화 작업의 세부 통계를 실시간으로 수집할 수 있습니다:

# ═══ bpftrace로 crypto 연산 계측 ═══

# 1. 암호화 함수 호출 빈도 (10초간 수집)
bpftrace -e '
kprobe:crypto_skcipher_encrypt,
kprobe:crypto_skcipher_decrypt,
kprobe:crypto_aead_encrypt,
kprobe:crypto_aead_decrypt,
kprobe:crypto_shash_digest {
    @calls[probe] = count();
}
interval:s:10 { exit(); }
'
# @calls[kprobe:crypto_skcipher_encrypt]: 284713
# @calls[kprobe:crypto_aead_encrypt]: 15234
# @calls[kprobe:crypto_shash_digest]: 42891

# 2. 암호화 함수별 지연 시간 히스토그램
bpftrace -e '
kprobe:crypto_skcipher_encrypt { @start[tid] = nsecs; }
kretprobe:crypto_skcipher_encrypt /@start[tid]/ {
    @latency_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}
interval:s:10 { exit(); }
'
# @latency_ns:
# [128, 256)       12834 |@@@@@@@@@@@@@@@@@@@@|
# [256, 512)       85219 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
# [512, 1K)        42103 |@@@@@@@@@@@@@@@@@@@|
# [1K, 2K)          5847 |@@|
# [2K, 4K)           312 |

# 3. 프로세스별 crypto 사용량 추적
bpftrace -e '
kprobe:crypto_skcipher_encrypt {
    @by_comm[comm] = count();
}
interval:s:10 { exit(); }
'
# @by_comm[kcryptd/0]: 198234
# @by_comm[ksoftirqd/2]: 45123
# @by_comm[openvpn]: 12345

# 4. kernel_fpu_begin/end 구간 측정 (FPU 점유 시간)
bpftrace -e '
kprobe:kernel_fpu_begin_mask { @fpu_start[tid] = nsecs; }
kprobe:kernel_fpu_end /@fpu_start[tid]/ {
    @fpu_hold_ns = hist(nsecs - @fpu_start[tid]);
    delete(@fpu_start[tid]);
}
interval:s:5 { exit(); }
'
# → FPU 점유 시간이 너무 길면 preemption latency 문제 가능

perf를 이용한 crypto 프로파일링

# ═══ perf로 crypto 핫스팟 분석 ═══

# 1. dm-crypt I/O 중 CPU 프로파일
perf record -g -p $(pgrep -f kcryptd) -- sleep 10
perf report --no-children

# 주요 확인 포인트:
#   aesni_xts_encrypt    → AES-NI 사용 확인
#   aes_encrypt          → S/W fallback 사용 (성능 문제)
#   kernel_fpu_begin     → FPU 컨텍스트 스위칭 비용
#   scatterwalk_*        → scatterlist 순회 오버헤드

# 2. 특정 crypto 함수의 캐시 미스 분석
perf stat -e cache-misses,cache-references,instructions \
  -p $(pgrep -f kcryptd) -- sleep 5

# 3. IPsec crypto 성능 분석
perf top -e cycles -g --no-children \
  --call-graph dwarf -- -p $(pgrep -f "pluto\|charon")

# 4. CPU 명령어별 통계 (AES-NI 파이프라인 효율)
perf stat -e cycles,instructions,r01b1,r02b1 \
  -- modprobe tcrypt mode=500 sec=2
# r01b1: UOPS_EXECUTED.THREAD (마이크로-ops 실행 수)
# → IPC(Instructions Per Cycle)로 파이프라인 효율 확인

ARM 암호화 가속

ARMv8-A 아키텍처는 Crypto Extensions(CE)를 통해 AES, SHA, 다항식 곱셈 등의 암호 연산을 하드웨어에서 직접 수행합니다. x86의 AES-NI에 대응하는 기능으로, 모바일 SoC부터 서버용 ARM 프로세서까지 널리 지원됩니다. 커널 Crypto API는 CE 명령어를 자동 감지하여 소프트웨어 구현보다 높은 우선순위로 등록합니다.

ARMv8-A Crypto Extensions 명령어

ARM CE는 AES, SHA-1, SHA-256, 다항식 곱셈(GCM용)을 위한 전용 명령어를 제공합니다:

커널 암호 모듈

ARM64 커널은 CE, NEON, 제네릭 세 가지 계층의 암호 모듈을 제공합니다:

모듈 등록과 priority 선택

ARM CE 모듈은 module_cpu_feature_match() 매크로를 사용하여 CPU가 해당 기능을 지원할 때만 자동 로드됩니다:

/* arch/arm64/crypto/aes-ce-core.S + aes-glue.c 패턴 */

/* CE 모듈: priority 300 — CPU에 CE 기능이 있으면 자동 선택 */
static struct skcipher_alg aes_algs[] = {{
    .base.cra_name        = "cbc(aes)",
    .base.cra_driver_name = "cbc-aes-ce",
    .base.cra_priority    = 300,
    .setkey               = ce_aes_setkey,
    .encrypt              = ce_aes_cbc_encrypt,
    .decrypt              = ce_aes_cbc_decrypt,
}};

/* 모듈 로드 조건: ARM64_HAS_AES feature bit 확인 */
module_cpu_feature_match(AES, aes_ce_mod_init);

/* NEON 모듈: priority 200 — CE 없는 ARMv8에서 사용 */
static struct skcipher_alg aes_neon_algs[] = {{
    .base.cra_name        = "cbc(aes)",
    .base.cra_driver_name = "cbc-aes-neon",
    .base.cra_priority    = 200,
}};

/* 제네릭 모듈: priority 100 — 항상 사용 가능한 최후의 수단 */
/* crypto/aes_generic.c */

# ARM64에서 Crypto Extensions 지원 확인
cat /proc/cpuinfo | grep -i features
# Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics ...
#            ^^^ ^^^^^ ^^^^ ^^^^         — CE 관련 플래그

# 등록된 AES 드라이버와 priority 확인
grep -A4 'cbc(aes)' /proc/crypto
# name         : cbc(aes)
# driver       : cbc-aes-ce        ← CE 모듈 (priority 300)
# priority     : 300

NEON 기반 AES (bit-slicing)

CE가 없는 ARMv7이나 초기 ARMv8 프로세서에서는 NEON(ASIMD) SIMD 레지스터를 활용한 bit-slicing 기법으로 AES를 가속합니다. S-Box 테이블 룩업 대신 비트 연산으로 AES 라운드를 구현하여, 타이밍 부채널을 방지하면서 제네릭 구현보다 2~4배 빠른 성능을 제공합니다:

/* arch/arm64/crypto/aes-neonbs-glue.c — bit-sliced AES */
/* 8블록을 병렬로 처리하여 NEON 128-bit 레지스터 활용 극대화 */
static int aesbs_cbc_encrypt(struct skcipher_request *req)
{
    /* NEON 레지스터 사용을 위해 커널 FPSIMD 컨텍스트 획득 */
    kernel_neon_begin();
    /* bit-slicing: 8개 AES 블록을 8개 NEON 레지스터에 전치하여
     * 각 비트 위치별로 병렬 S-Box 연산 수행 */
    aesbs_cbc_encrypt_neon(walk.dst.virt.addr,
                           walk.src.virt.addr, ctx->rk, nbytes, walk.iv);
    kernel_neon_end();
}

SVE2 암호화 확장

ARMv9의 SVE2(Scalable Vector Extension 2)는 가변 길이 벡터 레지스터(128~2048비트)에서 동작하는 암호화 명령어를 추가합니다:

ARM CE 성능 비교

Cortex-A76 (ARMv8.2) 기준 tcrypt 벤치마크 결과:

x86 추가 암호화 명령어

AES-NI 외에도 x86 아키텍처는 SHA, CRC32, SM3/SM4 등의 전용 명령어를 세대별로 추가해왔습니다. 커널은 각 명령어 세트에 대응하는 최적화 모듈을 제공하며, CPUID 플래그 기반으로 자동 선택합니다.

SHA-NI (SHA Extensions)

SHA-NI는 SHA-1과 SHA-256 라운드 함수를 하드웨어에서 수행하는 명령어 세트입니다:

# SHA-NI 지원 확인
grep sha_ni /proc/cpuinfo
# flags : ... sha_ni ...

# SHA-256 드라이버 확인: sha256-ni가 가장 높은 priority
grep -A3 'sha256' /proc/crypto | grep -E 'name|driver|priority'
# name         : sha256
# driver       : sha256-ni         ← SHA-NI 하드웨어 가속
# priority     : 300

# tcrypt 벤치마크: SHA-256
modprobe tcrypt mode=403 sec=3
# SHA-NI: ~2.5 GB/s (8K blocks) vs SW: ~300 MB/s → 약 8배 가속

AVX/AVX2 최적화 해시

SHA-NI가 없는 CPU에서는 AVX/AVX2 SIMD 명령어를 활용한 최적화 해시 구현을 사용합니다. Multi-buffer 기법은 여러 독립적인 해시 연산을 SIMD 레인에 배치하여 병렬 처리합니다:

/* arch/x86/crypto/sha256_avx2_asm.S 개념 — multi-buffer 기법 */
/* 4개의 독립적인 SHA-256 연산을 YMM 레지스터에서 병렬 처리 */
/*
 * YMM0 = [msg_A[0:31] | msg_B[0:31] | msg_C[0:31] | msg_D[0:31]]
 * 각 64바이트 레인에서 독립적인 SHA-256 라운드 수행
 * → 단일 스트림 대비 2~3배 처리량 향상
 */

/* 커널 등록 예시 */
static struct shash_alg sha256_avx2_alg = {
    .digestsize   = SHA256_DIGEST_SIZE,
    .init         = sha256_base_init,
    .update       = sha256_avx2_update,
    .final        = sha256_avx2_final,
    .base = {
        .cra_name        = "sha256",
        .cra_driver_name = "sha256-avx2",
        .cra_priority    = 170,
    },
};

SM3/SM4 명령어 (Sapphire Rapids)

Intel Sapphire Rapids(4세대 Xeon)부터 중국 국가 표준 암호 알고리즘인 SM3(해시)과 SM4(블록 암호)의 전용 명령어를 지원합니다. 커널 모듈 sm4-aesni-avx2와 sm3-avx가 이를 활용합니다. SM4는 국제 표준 ISO/IEC 18033-3:2010에도 등록되어 있으며, 중국 시장 제품에서 AES 대신 필수적으로 사용됩니다.

CRC32C SSE4.2 가속

SSE4.2의 CRC32 명령어는 Castagnoli CRC(CRC32C)를 하드웨어에서 수행합니다. ext4, btrfs, iSCSI 등 커널 전반에서 데이터 무결성 검증에 사용됩니다:

# CRC32C 가속 모듈 확인
grep crc32 /proc/crypto
# name         : crc32c
# driver       : crc32c-intel       ← SSE4.2 하드웨어 가속
# priority     : 200

# ext4 파일시스템에서 CRC32C 사용 확인
dmesg | grep crc32c
# ext4: using crc32c-intel for CRC32C checksums

# 성능: crc32c-intel ~20 GB/s vs crc32c-generic ~800 MB/s
# → SSE4.2 CRC32 명령어는 클럭당 8바이트 처리 가능

네트워크 암호화 오프로드

네트워크 암호화를 NIC 하드웨어에 오프로드하면 CPU 부하를 대폭 줄이고 와이어 속도에 가까운 암호화 처리량을 달성할 수 있습니다. 커널은 IPsec, kTLS, MACsec 세 가지 프로토콜에서 NIC 암호화 오프로드를 지원하며, 각각 다른 오프로드 레벨과 드라이버 콜백을 제공합니다.

IPsec 인라인 오프로드

IPsec 오프로드는 xfrm_dev_offload 구조체를 통해 두 가지 모드를 지원합니다:

NIC 드라이버는 xfrmdev_ops 콜백을 구현하여 SA(Security Association)를 하드웨어에 설치합니다:

/* include/linux/netdevice.h — IPsec 오프로드 콜백 */
struct xfrmdev_ops {
    int  (*xdo_dev_state_add)(struct xfrm_state *x,
                              struct netlink_ext_ack *extack);
    void (*xdo_dev_state_delete)(struct xfrm_state *x);
    void (*xdo_dev_state_free)(struct xfrm_state *x);
    bool (*xdo_dev_offload_ok)(struct sk_buff *skb,
                               struct xfrm_state *x);
    int  (*xdo_dev_policy_add)(struct xfrm_policy *xp,
                               struct netlink_ext_ack *extack);
    void (*xdo_dev_policy_delete)(struct xfrm_policy *xp);
};

/* 지원 NIC 예시: Mellanox ConnectX-6 Dx+ (mlx5), Intel E810 (ice) */

kTLS 암호화 오프로드

kTLS(Kernel TLS)는 TLS 레코드 계층의 암복호화를 NIC에 오프로드할 수 있습니다. 사용자 공간에서 TLS 핸드셰이크를 완료한 후 setsockopt(TCP_ULP, "tls")로 커널에 키를 전달하면, 지원 NIC이 자동으로 오프로드합니다:

MACsec 오프로드

MACsec(IEEE 802.1AE)은 이더넷 프레임 레벨에서 AES-GCM-128/256 암호화를 수행합니다. 일부 NIC(Mellanox ConnectX-6 Dx, Intel E810, Marvell Prestera)에서 MACsec 오프로드를 지원하며, macsec_ops 콜백으로 SA를 하드웨어에 설치합니다. MACsec의 상세 아키텍처와 설정은 이더넷 MACsec을 참고하세요.

오프로드 확인 및 설정

# ━━━ 네트워크 암호화 오프로드 확인/설정 ━━━

# IPsec offload 기능 확인
ethtool -k eth0 | grep esp
# esp-hw-offload: on        ← IPsec crypto offload 가능
# esp-tx-csum-hw-offload: on

# IPsec SA에 오프로드 설정
ip xfrm state add src 10.0.0.1 dst 10.0.0.2 proto esp spi 0x100 \
    mode transport aead 'rfc4106(gcm(aes))' 0x... 128 \
    offload dev eth0 dir out     # ← offload 키워드

# 오프로드 상태 확인
ip xfrm state list | grep -A2 offload
#   offload dev eth0 dir out type crypto

# kTLS offload 확인
ethtool -k eth0 | grep tls
# tls-hw-tx-offload: on
# tls-hw-rx-offload: on

# MACsec offload 확인
ethtool -k eth0 | grep macsec
# macsec-hw-offload: on

스토리지 인라인 암호화

스토리지 인라인 암호화(Inline Encryption)는 데이터가 저장장치에 기록/읽기될 때 전용 하드웨어 엔진(ICE, Inline Crypto Engine)이 와이어 속도로 실시간 암복호화를 수행하는 기술입니다. CPU 개입이 전혀 없으므로 dm-crypt 대비 성능 오버헤드가 없고, 모바일 기기의 파일 기반 암호화(FBE)에서 핵심 역할을 합니다.

blk-crypto 프레임워크

Linux 커널의 blk-crypto 프레임워크는 블록 레이어에서 인라인 암호화를 추상화합니다. 상위 계층(fscrypt, dm-crypt)이 blk_crypto_key를 설정하면, 하드웨어 지원 여부에 따라 ICE 또는 소프트웨어 폴백으로 자동 전환합니다:

/* include/linux/blk-crypto.h — 핵심 구조체 */
struct blk_crypto_key {
    struct blk_crypto_config crypto_cfg;  /* 암호 설정 */
    unsigned int data_unit_size;           /* 암호화 단위 (보통 4096) */
    unsigned int size;                      /* 키 크기 */
    u8 raw[BLK_CRYPTO_MAX_KEY_SIZE];        /* 원시 키 데이터 */
};

enum blk_crypto_mode_num {
    BLK_ENCRYPTION_MODE_INVALID,
    BLK_ENCRYPTION_MODE_AES_256_XTS,      /* FBE 기본 */
    BLK_ENCRYPTION_MODE_AES_128_CBC_ESSIV, /* 레거시 FDE */
    BLK_ENCRYPTION_MODE_ADIANTUM,          /* CE 없는 저가형 */
    BLK_ENCRYPTION_MODE_SM4_XTS,           /* 중국 표준 */
};

/* blk_crypto_profile: 스토리지 디바이스의 ICE 능력 기술 */
struct blk_crypto_profile {
    struct blk_crypto_ll_ops ll_ops;   /* keyslot 관리 콜백 */
    unsigned int max_dun_bytes_supported; /* DUN 크기 */
    unsigned int num_slots;               /* 하드웨어 keyslot 수 */
    unsigned int modes_supported[BLK_ENCRYPTION_MODE_MAX];
};

인라인 암호화 엔진

주요 스토리지 인터페이스별 인라인 암호화 엔진:

소프트웨어 폴백

CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK이 활성화되면, ICE가 없는 디바이스에서도 blk-crypto 인터페이스를 사용할 수 있습니다. 폴백 모듈은 내부적으로 Crypto API의 crypto_skcipher를 사용하여 소프트웨어로 암복호화를 수행합니다:

/* block/blk-crypto-fallback.c — 소프트웨어 폴백 개요 */
static int blk_crypto_fallback_encrypt_bio(struct bio **bio_ptr)
{
    struct bio_crypt_ctx *bc = (*bio_ptr)->bi_crypt_context;
    struct crypto_skcipher *tfm;

    /* blk_crypto_mode → Crypto API 알고리즘 이름 매핑 */
    /* AES_256_XTS → "xts(aes)" */
    tfm = crypto_alloc_skcipher(
        blk_crypto_modes[bc->bc_key->crypto_cfg.crypto_mode].name,
        0, 0);

    /* Crypto API를 통한 소프트웨어 암호화 수행 */
    /* AES-NI/ARM CE가 있으면 HW 가속으로 폴백됨 */
    crypto_skcipher_encrypt(req);
}

fscrypt + blk-crypto 연동

fscrypt(파일시스템 암호화)는 blk-crypto를 통해 ICE를 활용합니다. 각 파일(또는 디렉토리)마다 고유한 키를 생성하고, blk-crypto에 키를 등록하여 I/O 요청에 첨부합니다:

# ━━━ fscrypt + inline encryption 설정 ━━━

# 1. 디바이스의 inline encryption 지원 확인
cat /sys/block/sda/queue/crypto/max_dun_bytes
# 8    ← DUN(Data Unit Number) 크기, 0이면 미지원

cat /sys/block/sda/queue/crypto/modes/AES-256-XTS
# 4096  ← data_unit_size, 0이면 미지원

# 2. fscrypt에서 inline encryption 사용 (Android FBE)
# /data 파티션 마운트 시 inlinecrypt 옵션 추가
mount -o inlinecrypt /dev/block/sda13 /data

# 3. 키 해제 (파일 잠금)
# fscrypt lock /data → blk_crypto_evict_key()로 HW keyslot 제거
fscrypt lock /data
# → ICE keyslot이 안전하게 소거됨

암호화 가속기 디바이스

CPU 내장 명령어(AES-NI, ARM CE) 외에도 PCI 가속기, SoC 임베디드 엔진, 가상 디바이스 등 다양한 형태의 암호화 가속기가 커널 Crypto API에 등록됩니다. 이들은 CPU와 독립적으로 동작하므로 대량의 암호 연산을 CPU 부하 없이 처리할 수 있습니다.

AMD CCP / PSP

AMD CCP(Cryptographic Co-Processor)는 AMD EPYC/Ryzen 프로세서에 내장된 보안 전용 코프로세서입니다. PSP(Platform Security Processor)는 CCP를 포함하는 상위 개념으로, SEV/SEV-SNP 기밀 컴퓨팅의 기반이 됩니다:

# ━━━ AMD CCP 드라이버 설정 ━━━

# Kconfig 옵션
# CONFIG_CRYPTO_DEV_CCP=m
# CONFIG_CRYPTO_DEV_CCP_CRYPTO=m  ← Crypto API 연동
# CONFIG_CRYPTO_DEV_SP_PSP=y       ← PSP/SEV 지원

# CCP 디바이스 확인
lspci | grep -i ccp
# 09:00.2 Encryption controller: AMD CCP/PSP

# 드라이버 로드 확인
dmesg | grep ccp
# ccp 0000:09:00.2: enabling device
# ccp 0000:09:00.2: ccp enabled
# ccp 0000:09:00.2: SEV API:1.55 build:21

# CCP가 등록한 Crypto API 알고리즘
grep ccp /proc/crypto | head -5
# driver       : ccp-aes-cbc
# driver       : ccp-aes-gcm
# driver       : ccp-sha256

HiSilicon SEC / SEC2

HiSilicon SEC2는 Kunpeng 920(ARM 서버 SoC)에 내장된 고속 암호화 가속기입니다. hisi_sec2 드라이버를 통해 Crypto API에 등록되며, UACCE(Unified/User-space Accelerator Framework)를 통해 사용자 공간에서도 직접 접근할 수 있습니다:

Marvell / Cavium OcteonTX CPT

Marvell(Cavium) OcteonTX CPT는 네트워크 프로세서에 내장된 암호화 가속기입니다. IPsec 고속 처리에 최적화되어 있으며, cpt(OcteonTX) 및 otx2_cpt(OcteonTX2) 드라이버를 통해 Crypto API에 등록됩니다. OcteonTX2는 최대 100 Gbps IPsec 처리를 지원합니다.

Samsung Exynos S5P SSS

Samsung S5P SSS(Security SubSystem)는 Exynos SoC에 내장된 암호 엔진입니다. s5p-sss 드라이버가 AES(ECB/CBC/CTR), SHA-1/256, PRNG를 Crypto API에 등록합니다. 주로 Android 기기에서 dm-crypt 가속에 활용됩니다.

SoC 임베디드 암호 엔진 종합

virtio-crypto 가상 디바이스

virtio-crypto는 가상 머신에서 호스트의 암호화 가속기를 활용할 수 있는 준가상화(paravirtual) 디바이스입니다. QEMU/KVM 환경에서 게스트 커널이 virtio_crypto 드라이버를 통해 호스트의 Crypto API(또는 하드웨어 가속기)에 접근합니다:

# ━━━ QEMU에서 virtio-crypto 디바이스 추가 ━━━

# 방법 1: 내장 백엔드
qemu-system-x86_64 \
    -device virtio-crypto-pci,cryptodev=crypto0 \
    -object cryptodev-backend-builtin,id=crypto0

# 방법 2: vhost-user 백엔드 (DPDK cryptodev 연동)
qemu-system-x86_64 \
    -chardev socket,id=chardev0,path=/tmp/vhost-crypto.sock \
    -object cryptodev-vhost-user,id=crypto0,chardev=chardev0 \
    -device virtio-crypto-pci,cryptodev=crypto0

/* virtio_crypto 서비스 유형 */
#define VIRTIO_CRYPTO_SERVICE_CIPHER  0  /* 대칭 암호 */
#define VIRTIO_CRYPTO_SERVICE_HASH    1  /* 해시 */
#define VIRTIO_CRYPTO_SERVICE_MAC     2  /* MAC */
#define VIRTIO_CRYPTO_SERVICE_AEAD    3  /* AEAD */
#define VIRTIO_CRYPTO_SERVICE_AKCIPHER 4  /* 비대칭 암호 (RSA) */

/* 게스트 커널의 /proc/crypto에서 확인 */
/* driver: virtio-crypto-xxx */

AF_ALG 사용자 공간 인터페이스 심화

AF_ALG은 사용자 공간에서 커널 Crypto API를 직접 사용할 수 있는 소켓 인터페이스입니다. 별도의 암호 라이브러리 없이 커널에 등록된 모든 암호화 가속기(AES-NI, QAT 등)를 활용할 수 있으며, splice()를 통한 zero-copy 전송도 지원합니다.

AF_ALG 아키텍처

AF_ALG 소켓은 4단계 라이프사이클을 따릅니다:

/* AF_ALG 기본 패턴 */
int sockfd, connfd;
struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type   = "skcipher",  /* "hash", "aead", "rng" */
    .salg_name   = "cbc(aes)",  /* 알고리즘 이름 */
};

/* 1. 소켓 생성 + 알고리즘 바인드 */
sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));

/* 2. 키 설정 (skcipher/aead만) */
setsockopt(sockfd, SOL_ALG, ALG_SET_KEY, key, key_len);

/* 3. 연결 소켓 생성 (세션) */
connfd = accept(sockfd, NULL, 0);

/* 4. 데이터 송수신 (IV/AAD는 cmsg로 전달) */
sendmsg(connfd, &msg, 0);   /* 평문 + cmsg(IV, op) */
read(connfd, out, out_len); /* 암호문 수신 */

close(connfd);
close(sockfd);

해시 예제 (SHA-256)

#include <linux/if_alg.h>
#include <sys/socket.h>

int sha256_af_alg(const void *data, size_t len,
                  unsigned char digest[32])
{
    struct sockaddr_alg sa = {
        .salg_family = AF_ALG,
        .salg_type   = "hash",
        .salg_name   = "sha256",
    };
    int sockfd, connfd;

    sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));
    connfd = accept(sockfd, NULL, 0);

    /* 데이터 전송 — 커널이 sha256-ni(또는 최적 드라이버)로 처리 */
    write(connfd, data, len);

    /* 다이제스트 수신 */
    read(connfd, digest, 32);

    close(connfd);
    close(sockfd);
    return 0;
}

/* splice() zero-copy: 파일 해시를 커널 공간에서 직접 처리 */
int sha256_file_splice(int fd, unsigned char digest[32])
{
    /* ... socket/bind/accept 동일 ... */
    int pipefd[2];
    pipe(pipefd);

    /* 파일 → 파이프 → AF_ALG: 사용자 공간 복사 없음 */
    splice(fd, NULL, pipefd[1], NULL, file_size, 0);
    splice(pipefd[0], NULL, connfd, NULL, file_size, 0);

    read(connfd, digest, 32);
    /* ... */
}

대칭 암호 예제 (AES-CBC)

int aes_cbc_encrypt_af_alg(const void *key, int keylen,
    const void *iv, const void *pt, void *ct, int len)
{
    struct sockaddr_alg sa = {
        .salg_family = AF_ALG,
        .salg_type   = "skcipher",
        .salg_name   = "cbc(aes)",
    };
    int sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));
    setsockopt(sockfd, SOL_ALG, ALG_SET_KEY, key, keylen);

    int connfd = accept(sockfd, NULL, 0);

    /* cmsg로 IV와 operation(encrypt/decrypt) 전달 */
    struct msghdr msg = {};
    struct cmsghdr *cmsg;
    char cbuf[CMSG_SPACE(4) + CMSG_SPACE(16)];
    struct iovec iov = { .iov_base = (void *)pt, .iov_len = len };

    msg.msg_control = cbuf;
    msg.msg_controllen = sizeof(cbuf);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    /* cmsg 1: operation = ALG_OP_ENCRYPT */
    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_ALG;
    cmsg->cmsg_type  = ALG_SET_OP;
    cmsg->cmsg_len   = CMSG_LEN(4);
    *(__u32 *)CMSG_DATA(cmsg) = ALG_OP_ENCRYPT;

    /* cmsg 2: IV */
    cmsg = CMSG_NXTHDR(&msg, cmsg);
    cmsg->cmsg_level = SOL_ALG;
    cmsg->cmsg_type  = ALG_SET_IV;
    cmsg->cmsg_len   = CMSG_LEN(20);  /* 4(ivlen) + 16(iv) */
    struct af_alg_iv *aiv = (void *)CMSG_DATA(cmsg);
    aiv->ivlen = 16;
    memcpy(aiv->iv, iv, 16);

    sendmsg(connfd, &msg, 0);
    read(connfd, ct, len);

    close(connfd);
    close(sockfd);
    return 0;
}

AEAD 예제 (AES-GCM)

/* AF_ALG AEAD: AES-256-GCM 암호화 */
struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type   = "aead",
    .salg_name   = "gcm(aes)",
};
int sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));
setsockopt(sockfd, SOL_ALG, ALG_SET_KEY, key, 32);

/* 인증 태그 크기 설정 (16바이트) */
setsockopt(sockfd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 16);

int connfd = accept(sockfd, NULL, 0);

/* cmsg에 ALG_SET_OP, ALG_SET_IV, ALG_SET_AEAD_ASSOCLEN 설정 */
/* sendmsg: [AAD (assoclen bytes)] + [plaintext] */
/* read:    [AAD (assoclen bytes)] + [ciphertext] + [tag (16 bytes)] */

/* cmsg 3: AAD 길이 */
cmsg->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
cmsg->cmsg_len  = CMSG_LEN(4);
*(__u32 *)CMSG_DATA(cmsg) = aad_len;

/* iov[0] = AAD, iov[1] = plaintext */
sendmsg(connfd, &msg, 0);
/* 수신: AAD + ciphertext + 16바이트 GCM 태그 */
read(connfd, outbuf, aad_len + pt_len + 16);

AF_ALG 성능 비교

/proc/crypto와 드라이버 선택

# ━━━ /proc/crypto 활용법 ━━━

# 특정 알고리즘의 모든 구현 확인
awk '/^name.*cbc\(aes\)/,/^$/' /proc/crypto
# name         : cbc(aes)
# driver       : cbc-aes-aesni       priority: 400
# name         : cbc(aes)
# driver       : cbc-aes-generic     priority: 100

# AF_ALG에서 특정 드라이버 강제 지정
# salg_name에 드라이버 이름을 직접 사용
struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type   = "skcipher",
    .salg_name   = "cbc-aes-aesni",  /* 드라이버 이름 직접 지정 */
};

# 전체 알고리즘 유형별 개수
grep '^type' /proc/crypto | sort | uniq -c | sort -rn
#  45 type         : skcipher
#  32 type         : shash
#  18 type         : aead
#   8 type         : ahash
#   5 type         : rng

암호화 오프로드 결정 가이드

다양한 암호화 오프로드 옵션 중 워크로드 특성에 맞는 방식을 선택하는 것이 중요합니다. CPU ISA 가속으로 충분한 경우 별도 가속기를 도입할 필요가 없고, 반대로 대규모 암호 처리에서는 전용 가속기가 CPU 자원을 확보해줍니다.

오프로드 유형별 선택 기준

패킷 크기 임계값과 CPU 사용률

오프로드 효율은 데이터 크기에 크게 의존합니다. 소량 데이터에서는 오프로드 설정(DMA 맵핑, 디스크립터 전송)의 고정 비용이 암호화 자체보다 클 수 있습니다:

종합 비교

실전 구현 패턴과 다양한 예시

앞 절에서는 Crypto API의 각 계층과 가속 메커니즘을 나누어 보았지만, 실제 커널 코드는 거의 항상 여러 층을 동시에 건드립니다. 같은 AES라도 어떤 경로는 sleep 가능한 process context에서 동작하고, 어떤 경로는 softirq에서 바로 들어오며, 어떤 경로는 DMA 가능한 scatterlist와 함께 hardware queue에 실려 나갑니다. 따라서 실전 구현에서는 알고리즘 이름보다도 문맥 제약, 객체 수명, 입출력 버퍼 레이아웃, fallback 경로, 에러 전파를 먼저 설계해야 합니다.

아래 예시들은 단순히 "이 함수는 이렇게 호출한다"를 넘어서, 실제 서브시스템 코드가 어떤 틀로 조립되는지 보여 주는 데 초점을 둡니다. 특히 기존 문서의 개별 API 예시를 보완하기 위해, 이번 섹션은 소비자 관점에서 자주 필요한 패턴을 묶어서 설명합니다.

비동기 구현을 동기처럼 다루는 skcipher 패턴

Crypto API의 많은 구현체는 내부적으로 비동기입니다. 하지만 상위 계층이 sleep 가능한 process context라면 굳이 콜백 기반 상태 머신으로 코드를 찢지 않고, DECLARE_CRYPTO_WAIT와 crypto_wait_req()로 "동기처럼" 다룰 수 있습니다. 이 패턴은 하드웨어 엔진이 있으면 비동기로 돌고, 없으면 generic 구현으로 즉시 끝나는 두 경우를 같은 코드로 수용한다는 점이 강점입니다.

#include <crypto/skcipher.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>

static int encrypt_ctr_two_segments(const u8 *key, unsigned int key_len,
                                    const u8 iv[16],
                                    const u8 *head, unsigned int head_len,
                                    const u8 *body, unsigned int body_len,
                                    u8 *out_head, u8 *out_body)
{
    struct crypto_skcipher *tfm;
    struct skcipher_request *req;
    struct scatterlist src[2], dst[2];
    u8 iv_local[16];
    unsigned int total = head_len + body_len;
    int ret;
    DECLARE_CRYPTO_WAIT(wait);

    tfm = crypto_alloc_skcipher("ctr(aes)", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    ret = crypto_skcipher_setkey(tfm, key, key_len);
    if (ret)
        goto out_free_tfm;

    req = skcipher_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }

    sg_init_table(src, 2);
    sg_set_buf(&src[0], head, head_len);
    sg_set_buf(&src[1], body, body_len);

    sg_init_table(dst, 2);
    sg_set_buf(&dst[0], out_head, head_len);
    sg_set_buf(&dst[1], out_body, body_len);

    memcpy(iv_local, iv, 16);
    skcipher_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_SLEEP | CRYPTO_TFM_REQ_MAY_BACKLOG,
        crypto_req_done, &wait);
    skcipher_request_set_crypt(req, src, dst, total, iv_local);

    ret = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);

    memzero_explicit(iv_local, sizeof(iv_local));
    skcipher_request_free(req);
out_free_tfm:
    crypto_free_skcipher(tfm);
    return ret;
}

ahash와 멀티 세그먼트 scatterlist

shash는 작은 연속 버퍼에 가장 단순하지만, 실제 커널 데이터는 헤더와 payload, trailer가 제각각 다른 메모리 조각에 놓여 있는 경우가 많습니다. 이때 crypto_ahash는 scatterlist를 직접 받아 복사 없이 해시를 계산할 수 있고, DMA 기반 해시 엔진과도 자연스럽게 연결됩니다.

#include <crypto/hash.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>

static int calc_sha256_ahash_three_buffers(const u8 *hdr, unsigned int hdr_len,
                                          const u8 *payload, unsigned int payload_len,
                                          const u8 *tail, unsigned int tail_len,
                                          u8 digest[32])
{
    struct crypto_ahash *tfm;
    struct ahash_request *req;
    struct scatterlist sg[3];
    unsigned int total = hdr_len + payload_len + tail_len;
    int ret;
    DECLARE_CRYPTO_WAIT(wait);

    tfm = crypto_alloc_ahash("sha256", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    req = ahash_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }

    sg_init_table(sg, 3);
    sg_set_buf(&sg[0], hdr, hdr_len);
    sg_set_buf(&sg[1], payload, payload_len);
    sg_set_buf(&sg[2], tail, tail_len);

    ahash_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_SLEEP | CRYPTO_TFM_REQ_MAY_BACKLOG,
        crypto_req_done, &wait);
    ahash_request_set_crypt(req, sg, digest, total);

    ret = crypto_wait_req(crypto_ahash_digest(req), &wait);

    ahash_request_free(req);
out_free_tfm:
    crypto_free_ahash(tfm);
    return ret;
}

이 예시는 digest 단일 호출만 보여 주지만, 실전에서는 init/update/final 또는 finup 계열로 더 긴 스트림을 처리하기도 합니다. 예를 들어, 대형 펌웨어 이미지를 페이지 단위로 읽어 오면서 해시하려면 crypto_ahash_init() 후 페이지마다 crypto_ahash_update()를 호출하고, 마지막 조각에서 crypto_ahash_final()을 수행하는 식이 더 적합합니다.

AEAD 레코드 처리: AAD, 암호문, 태그 배치

AEAD는 Crypto API에서 가장 자주 길이 계산을 틀리는 인터페이스입니다. 이유는 AAD 길이와 cryptlen이 서로 다른 의미를 갖기 때문입니다. aead_request_set_ad()는 AAD 길이를 별도로 주고, aead_request_set_crypt()의 cryptlen은 "암호화/복호화 대상 본문 길이"를 뜻합니다. 복호화 시에는 인증 태그까지 포함한 길이를 넘겨야 한다는 점도 실수 포인트입니다.

#include <crypto/aead.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>

static int gcm_encrypt_record_inplace(const u8 *key, unsigned int key_len,
                                      const u8 *iv, unsigned int iv_len,
                                      u8 *record, unsigned int aad_len,
                                      unsigned int plaintext_len)
{
    struct crypto_aead *tfm;
    struct aead_request *req;
    struct scatterlist sg;
    u8 iv_local[16];
    int ret;
    DECLARE_CRYPTO_WAIT(wait);

    tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    ret = crypto_aead_setkey(tfm, key, key_len);
    if (ret)
        goto out_free_tfm;

    ret = crypto_aead_setauthsize(tfm, 16);
    if (ret)
        goto out_free_tfm;

    req = aead_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }

    if (iv_len != crypto_aead_ivsize(tfm)) {
        ret = -EINVAL;
        goto out_free_req;
    }

    memcpy(iv_local, iv, iv_len);

    /* record 레이아웃: [AAD][plaintext][tag용 여유 16바이트] */
    sg_init_one(&sg, record, aad_len + plaintext_len + 16);
    aead_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_SLEEP | CRYPTO_TFM_REQ_MAY_BACKLOG,
        crypto_req_done, &wait);
    aead_request_set_ad(req, aad_len);
    aead_request_set_crypt(req, &sg, &sg, plaintext_len, iv_local);

    ret = crypto_wait_req(crypto_aead_encrypt(req), &wait);

    memzero_explicit(iv_local, sizeof(iv_local));
out_free_req:
    aead_request_free(req);
out_free_tfm:
    crypto_free_aead(tfm);
    return ret;
}

kTLS, IPsec ESP, 일부 저장 포맷이 모두 이 레이아웃 감각 위에 서 있습니다. "왜 내 tag 검증이 항상 실패하지?"라는 문제는 대개 assoclen, cryptlen, tag 길이 중 하나를 잘못 넣었을 때 발생합니다. 특히 복호화에서 ciphertext_len만 넣고 tag 길이를 빼먹는 실수가 매우 흔합니다.

HMAC과 키 파생: 공유 비밀을 바로 쓰지 않는 이유

커널 안에서 암호를 다루다 보면 "공유 비밀이 나왔으니 바로 AES 키로 써도 되는가?"라는 질문이 자주 나옵니다. 보통은 그렇지 않습니다. ECDH 결과나 장치 고유 비밀은 길이, 분포, 방향 분리 문제 때문에 곧바로 데이터 키로 쓰지 않고, HMAC 기반 KDF를 한 번 더 거칩니다. 아래 예시는 hmac(sha256) 하나만으로 HKDF와 비슷한 구조를 구현해 TX/RX 키를 분리하는 패턴입니다.

#include <crypto/hash.h>
#include <linux/slab.h>
#include <linux/string.h>

static int hmac_sha256_once(const u8 *key, unsigned int key_len,
                            const u8 *msg, unsigned int msg_len,
                            u8 out[32])
{
    struct crypto_shash *tfm;
    struct shash_desc *desc;
    unsigned int dlen;
    int ret;

    tfm = crypto_alloc_shash("hmac(sha256)", 0, 0);
    if (IS_ERR(tfm))
        return PTR_ERR(tfm);

    dlen = sizeof(*desc) + crypto_shash_descsize(tfm);
    desc = kmalloc(dlen, GFP_KERNEL);
    if (!desc) {
        crypto_free_shash(tfm);
        return -ENOMEM;
    }

    desc->tfm = tfm;
    ret = crypto_shash_setkey(tfm, key, key_len);
    if (!ret)
        ret = crypto_shash_digest(desc, msg, msg_len, out);

    memzero_explicit(desc, dlen);
    kfree(desc);
    crypto_free_shash(tfm);
    return ret;
}

static int derive_tx_rx_keys_from_secret(const u8 *salt, unsigned int salt_len,
                                         const u8 *shared, unsigned int shared_len,
                                         const u8 *info, unsigned int info_len,
                                         u8 tx_key[32], u8 rx_key[32])
{
    u8 prk[32];
    u8 t[32];
    u8 *block;
    int ret;

    block = kmalloc(32 + info_len + 1, GFP_KERNEL);
    if (!block)
        return -ENOMEM;

    /* Extract: PRK = HMAC(salt, shared_secret) */
    ret = hmac_sha256_once(salt, salt_len, shared, shared_len, prk);
    if (ret)
        goto out;

    /* Expand block 1: T1 = HMAC(PRK, info || 0x01) */
    memcpy(block, info, info_len);
    block[info_len] = 1;
    ret = hmac_sha256_once(prk, sizeof(prk), block, info_len + 1, t);
    if (ret)
        goto out;
    memcpy(tx_key, t, 32);

    /* Expand block 2: T2 = HMAC(PRK, T1 || info || 0x02) */
    memcpy(block, t, 32);
    memcpy(block + 32, info, info_len);
    block[32 + info_len] = 2;
    ret = hmac_sha256_once(prk, sizeof(prk),
                            block, 32 + info_len + 1, rx_key);
out:
    memzero_explicit(prk, sizeof(prk));
    memzero_explicit(t, sizeof(t));
    memzero_explicit(block, 32 + info_len + 1);
    kfree(block);
    return ret;
}