암호화 프레임워크 (Crypto API)

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

Linux Crypto Framework 개요

Linux 커널의 Crypto Framework(Crypto API)는 암호화 알고리즘을 커널 내에서 사용할 수 있도록 하는 통합 프레임워크입니다. 소프트웨어 구현과 하드웨어 가속(AES-NI, ARM CE, QAT, CAAM, CPT 등)을 동일한 인터페이스로 제공하여, 알고리즘 사용자(IPsec, dm-crypt, kTLS 등)가 구현 방식을 신경 쓰지 않아도 됩니다.

어디에서 사용되는가

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(물리 메모리(Physical Memory) 분산 목록)로 데이터를 전달하여 DMA 친화적인 zero-copy 처리가 가능합니다.

알고리즘 조합 (Template) 원리

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

알고리즘 유형

Crypto API는 8가지 알고리즘 유형을 지원하며, 각각 전용 API와 전용 request 구조체를 가집니다. 목적에 맞는 유형을 선택하는 것이 첫 번째 설계 결정입니다:

비대칭 암호와 공개키 연산

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

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

RSA AKCIPHER 예제

공개키 암호화 API는 crypto_alloc_akcipher()로 tfm을 얻고, akcipher_request에 입출력(I/O) 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()로 패킷(Packet) 형태로 포장해 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;
}

커널에서 지원하는 비대칭 알고리즘 전체 목록

TLS 핸드셰이크에서 비대칭 연산의 역할

비대칭 암호의 핵심 사용처는 대칭 세션 키를 안전하게 합의하는 것입니다. TLS 1.3 핸드셰이크를 예로 들면, ECDH(키 합의) → ECDSA(서명 검증) → HKDF(키 파생) → AES-GCM(대칭 암호화) 순서로 비대칭·대칭 연산이 결합됩니다:

커널 모듈 서명 검증 파이프라인

커널 모듈 서명(CONFIG_MODULE_SIG)은 비대칭 암호의 대표적 커널 내 사용처입니다. 빌드 시 개인키로 모듈을 서명하고, 로드 시 내장 공개키로 검증합니다:

키 형식과 DER 인코딩

커널 Crypto API의 비대칭 연산은 키를 DER(Distinguished Encoding Rules) 형식으로 요구합니다. PEM(Base64) 형식이 아닌 바이너리 ASN.1/DER 형태이며, 알고리즘에 따라 구조가 다릅니다:

# ━━━ 키 형식 변환과 커널 호환성 ━━━

# RSA 공개키: PEM → DER 변환
openssl rsa -in rsa_priv.pem -pubout -outform DER -out rsa_pub.der
# → SubjectPublicKeyInfo(SPKI) 형태, crypto_akcipher_set_pub_key()에 직접 전달

# RSA 개인키: PEM → DER 변환 (PKCS#8)
openssl pkcs8 -in rsa_priv.pem -topk8 -nocrypt -outform DER -out rsa_priv.der
# → PKCS#8 형태, crypto_akcipher_set_priv_key()에 전달

# ECDSA P-256 키쌍 생성
openssl ecparam -name prime256v1 -genkey -noout -outform DER -out ec_priv.der
openssl ec -in ec_priv.der -inform DER -pubout -outform DER -out ec_pub.der
# → crypto_sig_set_pubkey()에 DER 형태 직접 전달

# 커널 모듈 서명용 키 생성 (커널 빌드 자동)
# certs/signing_key.pem — 빌드 시 자동 생성
# → .builtin_trusted_keys 키링에 X.509 인증서로 내장

# DER 키 구조 확인
openssl asn1parse -in rsa_pub.der -inform DER
#   0:d=0 hl=4 l=290 cons: SEQUENCE
#   4:d=1 hl=2 l=  13 cons:  SEQUENCE        ← AlgorithmIdentifier
#  19:d=1 hl=4 l=271 prim:  BIT STRING       ← 공개키 데이터

비대칭 연산 HW 가속

비대칭 연산은 대칭 연산에 비해 수백~수천 배 느리기 때문에, TLS 핸드셰이크가 많은 환경에서 HW 가속의 효과가 큽니다. 커널의 주요 HW 가속기별 지원 현황입니다:

비대칭 연산 성능 특성

해시 사용 예제

해시(Hash)는 임의 길이 데이터를 고정 길이 다이제스트(Digest)로 축약하는 일방향 함수입니다. Crypto API는 shash(동기 해시)와 ahash(비동기 해시) 두 인터페이스를 제공합니다. 대부분의 경우 shash가 간결하고 충분하며, HW DMA 해시 엔진을 사용할 때만 ahash가 필요합니다:

#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;
}

대칭 암호 예제

대칭 암호(skcipher)는 동일한 키로 암호화와 복호화를 수행합니다. crypto_skcipher API는 블록 암호 모드(CBC, CTR, XTS 등)와 스트림 암호(ChaCha20)를 통합 인터페이스로 제공합니다. 4단계 라이프사이클을 따릅니다:

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

/* ━━━ AES-CBC 대칭 암호화 전체 예제 (비동기 지원) ━━━ */
static int aes_cbc_encrypt(const u8 *key, unsigned int key_len,
                           u8 *iv, u8 *data, unsigned int data_len)
{
    struct crypto_skcipher *tfm;
    struct skcipher_request *req;
    struct scatterlist sg;
    u8 iv_local[16];
    int ret;
    DECLARE_CRYPTO_WAIT(wait);

    /* ① tfm 할당 — 커널이 최적 구현을 자동 선택 */
    tfm = crypto_alloc_skcipher("cbc(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 할당 + 콜백 설정 */
    req = skcipher_request_alloc(tfm, GFP_KERNEL);
    if (!req) { ret = -ENOMEM; goto out_free_tfm; }

    skcipher_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
        crypto_req_done, &wait);

    /* ③ scatterlist + IV 설정 (in-place 암호화) */
    sg_init_one(&sg, data, data_len);
    memcpy(iv_local, iv, 16);  /* IV 복사본 — 일부 드라이버가 원본 수정 */
    skcipher_request_set_crypt(req, &sg, &sg, data_len, 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;  /* 0: 성공, 음수: 에러 */
}

하드웨어 가속

Crypto API의 priority 기반 자동 선택 메커니즘을 통해, 사용자 코드 변경 없이 하드웨어 가속이 투명하게 적용됩니다. 동일 알고리즘의 여러 구현이 등록되면 priority가 가장 높은 것이 자동 선택됩니다:

# ━━━ 하드웨어 가속 상태 확인 ━━━

# 등록된 모든 알고리즘과 드라이버·우선순위 확인
grep -E "^name|^driver|^priority|^type" /proc/crypto | head -20
# name         : cbc(aes)
# driver       : cbc-aes-aesni      ← AES-NI 가속
# priority     : 400
# type         : skcipher

# CPU 암호 명령어 지원 확인
grep -oE "aes|sha_ni|pclmulqdq|crc32c" /proc/cpuinfo | sort -u
# aes pclmulqdq sha_ni crc32c

# ARM CE 확인
grep -oE "aes|sha2|pmull|crc32" /proc/cpuinfo | sort -u

# HW 가속기 모듈 로드 확인
lsmod | grep -E "aesni|caam|qat|otx2_cpt|hisi_sec"

비동기 암호화 (Async Crypto)

커널 Crypto API의 비동기(Asynchronous) 처리 모델은 HW 가속기와 CPU를 병렬로 동작시키는 핵심 메커니즘입니다. 동기(synchronous) 알고리즘(AES-NI 등)은 함수가 반환되면 이미 완료되지만, 비동기 알고리즘(QAT, CAAM, CPT 등)은 요청을 큐에 제출한 뒤 즉시 반환하고, HW가 완료되면 콜백(callback)으로 결과를 통지합니다. 이 차이를 이해하지 않으면 데이터 손상, deadlock, use-after-free 등 치명적 버그가 발생합니다.

동기 vs 비동기 처리 모델

Crypto API의 모든 알고리즘은 /proc/crypto의 async 필드로 동기/비동기 여부를 확인할 수 있습니다. 동일한 알고리즘 이름(cbc(aes) 등)에 대해 동기·비동기 구현이 공존하며, priority가 높은 구현이 자동 선택됩니다:

# /proc/crypto에서 동기·비동기 구분 확인
grep -A4 "^name.*cbc(aes)" /proc/crypto
# name         : cbc(aes)
# driver       : cbc-aes-aesni        ← AES-NI (동기)
# priority     : 400
# async        : no                   ← 동기: 즉시 완료
# ---
# name         : cbc(aes)
# driver       : cbc-aes-caam         ← CAAM (비동기)
# priority     : 3000
# async        : yes                  ← 비동기: 콜백으로 완료

# CAAM priority(3000) > AES-NI priority(400)
# → i.MX/Layerscape에서 crypto_alloc_skcipher("cbc(aes)")는 CAAM을 자동 선택

반환값 계약과 완료 통지

Crypto API 비동기 모델에서 가장 중요한 것은 반환값과 콜백의 관계입니다. crypto_skcipher_encrypt(), crypto_aead_encrypt(), crypto_ahash_digest() 등 모든 비동기 API 함수는 동일한 반환값 규약을 따릅니다:

콜백 메커니즘 상세

비동기 콜백은 skcipher_request_set_callback() / aead_request_set_callback() / ahash_request_set_callback()으로 등록합니다. 콜백 함수의 시그니처와 호출 컨텍스트를 이해하는 것이 안전한 비동기 코드 작성의 핵심입니다:

/* ━━━ 비동기 콜백 함수 작성 패턴 ━━━ */

/* 콜백 함수 시그니처 — 모든 비동기 API 공통 */
static void my_crypto_done(void *data, int err)
{
    struct my_async_result *result = data;

    /* 백로그 경로: 1차 콜백은 "큐 진입 알림"일 뿐 */
    if (err == -EINPROGRESS)
        return;  /* 아직 완료 아님, 2차 콜백을 기다림 */

    /* 여기가 진짜 완료 지점 — err=0이면 성공, 음수면 에러 */
    result->err = err;
    complete(&result->completion);
}

/* 콜백 결과를 전달받을 구조체 */
struct my_async_result {
    struct completion completion;
    int err;
};

crypto_wait_req() — 비동기를 동기처럼 사용하기

process context(sleep 가능)에서는 콜백 기반 상태 머신을 직접 구현할 필요 없이 DECLARE_CRYPTO_WAIT와 crypto_wait_req()를 사용하면 동기·비동기 양쪽을 동일한 코드로 처리할 수 있습니다. 이 패턴은 dm-crypt, fscrypt, IKE 등 커널 내 대부분의 Crypto API 소비자가 사용합니다:

/* ━━━ crypto_wait_req() 사용 예 — 가장 간결한 비동기 패턴 ━━━ */

#include <crypto/skcipher.h>

static int encrypt_data(struct crypto_skcipher *tfm,
                       u8 *data, unsigned int len, u8 *iv)
{
    struct skcipher_request *req;
    struct scatterlist sg;
    DECLARE_CRYPTO_WAIT(wait);  /* completion + err 포함 */
    int ret;

    req = skcipher_request_alloc(tfm, GFP_KERNEL);
    if (!req)
        return -ENOMEM;

    sg_init_one(&sg, data, len);
    skcipher_request_set_crypt(req, &sg, &sg, len, iv);
    skcipher_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
        crypto_req_done, &wait);     /* 커널 내장 콜백 */

    /* 한 줄로 동기·비동기 모두 처리 */
    ret = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
    /* ret == 0: 성공 (동기든 비동기든 무관) */
    /* ret < 0: 에러 (암호화 실패) */

    skcipher_request_free(req);
    return ret;
}

비동기 요청 라이프사이클

비동기 암호 요청은 4단계 라이프사이클을 거칩니다. 각 단계에서 메모리 소유권이 이동하므로 순서를 지키는 것이 중요합니다:

완료 통지 모델 3종 비교

HW 가속기가 암호 연산을 완료한 뒤 결과를 CPU에 통지하는 방식은 3가지입니다. 워크로드 특성에 따라 최적 모델이 달라집니다:

백로그(Backlog) 메커니즘

HW 가속기의 하드웨어 큐는 유한합니다. 큐가 가득 찬 상태에서 새 요청이 들어오면, CRYPTO_TFM_REQ_MAY_BACKLOG 플래그가 설정된 경우 커널은 요청을 소프트웨어 백로그 리스트에 추가하고 -EBUSY를 반환합니다. HW 큐에 빈 슬롯이 생기면 백로그에서 요청을 꺼내 자동으로 재제출합니다:

/* ━━━ 백로그 처리가 포함된 완전한 비동기 패턴 ━━━ */

/* 콜백 — 백로그를 올바르게 처리 */
static void my_crypto_complete(void *data, int err)
{
    struct my_ctx *ctx = data;

    if (err == -EINPROGRESS) {
        /* 백로그 경로 1차 콜백: 큐에 진입했다는 알림
         * → 아직 처리 완료가 아니므로 데이터에 접근하면 안 됨
         * → 필요하면 통계 카운터만 업데이트 */
        atomic_dec(&ctx->backlog_count);
        return;
    }

    /* 진짜 완료 — err=0이면 성공 */
    ctx->err = err;
    complete(&ctx->done);
}

/* 제출 측 */
int ret = crypto_skcipher_encrypt(req);

switch (ret) {
case 0:
    /* 즉시 완료 — 결과 사용 가능 */
    process_result(req);
    break;
case -EINPROGRESS:
    /* HW에서 처리 중 — 콜백으로 완료 통지 */
    break;
case -EBUSY:
    /* 큐 포화 → 백로그 진입 — 결국 콜백으로 완료 */
    atomic_inc(&ctx->backlog_count);
    break;
default:
    /* 에러 (콜백 없음) — 직접 에러 처리 */
    handle_error(ret);
    break;
}

crypto_engine — HW 드라이버의 비동기 큐 관리

crypto_engine은 커널이 HW 가속기 드라이버를 위해 제공하는 비동기 큐 관리 프레임워크입니다. 드라이버가 직접 큐잉·백로그·완료 통지를 구현하는 대신, crypto_engine에 위임하면 Crypto API 규약에 맞는 비동기 처리가 자동으로 이루어집니다:

AEAD (Authenticated Encryption with Associated Data)

AEAD(Authenticated Encryption with Associated Data)는 암호화(기밀성)와 인증(무결성·진본성)을 단일 원자적 연산으로 결합하는 암호 프리미티브입니다. 전통적인 "encrypt-then-MAC" 조합과 달리 키 관리가 단순하고, 암호화·인증 순서 실수로 인한 취약점(Padding Oracle 등)이 구조적으로 불가능합니다. 커널에서 IPsec ESP, kTLS, WireGuard, dm-integrity+dm-crypt 등 거의 모든 현대 암호 프로토콜이 AEAD를 사용합니다.

AEAD 동작 원리

AEAD 알고리즘은 4개의 입력을 받아 암호문과 인증 태그(Authentication Tag)를 생성합니다:

커널에서 지원하는 주요 AEAD 알고리즘

scatterlist 메모리 레이아웃

AEAD 요청에서 가장 실수가 많은 부분이 scatterlist 레이아웃입니다. encrypt와 decrypt에서 src/dst의 구성이 비대칭적이며, cryptlen의 의미도 다릅니다:

AEAD API 사용 패턴

/* ━━━ AEAD (AES-GCM) 암호화/복호화 전체 예제 ━━━ */

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

#define GCM_IV_SIZE   12   /* AES-GCM 표준 IV */
#define GCM_TAG_SIZE  16   /* 128-bit 인증 태그 */

/* ── 암호화 ── */
static int aead_encrypt_example(const u8 *key, unsigned int key_len,
                               const u8 *iv, const u8 *aad, unsigned int aad_len,
                               const u8 *plaintext, unsigned int pt_len,
                               u8 *output)  /* output 크기 = aad_len + pt_len + GCM_TAG_SIZE */
{
    struct crypto_aead *tfm;
    struct aead_request *req;
    struct scatterlist src_sg[2], dst_sg[3];
    u8 iv_local[GCM_IV_SIZE];
    int ret;
    DECLARE_CRYPTO_WAIT(wait);

    /* 1. tfm 할당 + 키·태그 크기 설정 */
    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, GCM_TAG_SIZE);
    if (ret) goto out_free_tfm;

    /* 2. request 할당 + 콜백 설정 */
    req = aead_request_alloc(tfm, GFP_KERNEL);
    if (!req) { ret = -ENOMEM; goto out_free_tfm; }

    aead_request_set_callback(req,
        CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
        crypto_req_done, &wait);

    /* 3. scatterlist 구성 */
    /* src: [AAD | Plaintext] */
    sg_init_table(src_sg, 2);
    sg_set_buf(&src_sg[0], aad, aad_len);
    sg_set_buf(&src_sg[1], plaintext, pt_len);

    /* dst: [AAD | Ciphertext | Tag] */
    sg_init_table(dst_sg, 3);
    sg_set_buf(&dst_sg[0], output, aad_len);               /* AAD 복사 영역 */
    sg_set_buf(&dst_sg[1], output + aad_len, pt_len);      /* 암호문 */
    sg_set_buf(&dst_sg[2], output + aad_len + pt_len, GCM_TAG_SIZE); /* 태그 */

    /* 4. 요청 파라미터 설정 */
    memcpy(iv_local, iv, GCM_IV_SIZE);
    aead_request_set_crypt(req, src_sg, dst_sg, pt_len, iv_local);
    /*                                         ^^^^^^ Encrypt: 평문 길이 */
    aead_request_set_ad(req, aad_len);

    /* 5. 암호화 수행 (비동기 지원) */
    ret = crypto_wait_req(crypto_aead_encrypt(req), &wait);

    aead_request_free(req);
out_free_tfm:
    crypto_free_aead(tfm);
    return ret;
}

/* ── 복호화 ── */
static int aead_decrypt_example(const u8 *key, unsigned int key_len,
                               const u8 *iv, const u8 *aad, unsigned int aad_len,
                               const u8 *ct_and_tag, unsigned int ct_len,
                               u8 *output)  /* output 크기 = aad_len + ct_len */
{
    /* ... tfm/req 할당 동일 ... */

    /* src: [AAD | Ciphertext | Tag] */
    aead_request_set_crypt(req, src_sg, dst_sg,
        ct_len + GCM_TAG_SIZE, iv_local);
    /* ^^^^^^^^^^^^^^^^^^^^^^^^ Decrypt: 암호문 + 태그 길이! */
    aead_request_set_ad(req, aad_len);

    ret = crypto_wait_req(crypto_aead_decrypt(req), &wait);
    /* ret == -EBADMSG: 인증 태그 불일치 → 데이터 위변조 감지 */
    /* ret == 0: 복호화 성공, output에 평문 기록됨 */
}

프로토콜별 AEAD 적용 구조

커널의 주요 네트워크·스토리지 프로토콜은 각각 다른 방식으로 AEAD를 적용합니다. 아래 다이어그램은 각 프로토콜이 AAD, 평문, 태그를 어떻게 배치하는지 보여줍니다:

AES-GCM 내부 동작

AES-GCM은 커널에서 가장 많이 사용되는 AEAD 알고리즘입니다. 내부적으로 AES-CTR(Counter Mode)로 암호화하고, GHASH(Galois Hash)로 인증 태그를 생성합니다. AES-NI와 PCLMULQDQ(캐리 없는 곱셈) 명령어를 사용하면 두 연산을 파이프라인으로 병렬 처리할 수 있습니다:

authenc(HMAC,CBC) vs 네이티브 AEAD 비교

커널의 authenc 템플릿은 기존 블록 암호(CBC)와 MAC(HMAC)을 조합하여 AEAD 인터페이스를 제공하는 호환 레이어입니다. 네이티브 AEAD(GCM, ChaCha20-Poly1305)와의 핵심 차이를 이해하면 적절한 알고리즘을 선택할 수 있습니다:

커널 난수 생성기

암호화 시스템의 안전성은 키·IV·Nonce의 예측 불가능성에 달려 있으며, 이를 제공하는 것이 난수 생성기(Random Number Generator)입니다. 리눅스 커널은 다계층 난수 아키텍처를 사용합니다: 하드웨어 엔트로피 소스(TRNG/hwrng)가 물리적 무작위성을 수집하고, 커널 엔트로피 풀이 이를 축적한 뒤, ChaCha20 기반 CRNG(Cryptographically Secure PRNG)가 고속으로 난수를 생성합니다. Crypto API의 crypto_rng 인터페이스는 NIST SP 800-90A DRBG를 FIPS 호환 방식으로 제공합니다.

커널 난수 아키텍처

난수 API 비교 — 언제 무엇을 쓸 것인가

커널 공간 난수 API 사용 예제

#include <linux/random.h>

/* ━━━ 범용 암호학적 난수 (가장 일반적) ━━━ */

u8 aes_key[32];
get_random_bytes(aes_key, sizeof(aes_key));  /* 256-bit AES 키 */

u8 iv[16];
get_random_bytes(iv, sizeof(iv));             /* CBC IV */

u8 nonce[12];
get_random_bytes(nonce, sizeof(nonce));       /* GCM Nonce */

/* ━━━ 정수 난수 ━━━ */

u32 hash_seed = get_random_u32();             /* 해시 테이블 시드 */
u64 cookie = get_random_u64();                /* TCP SYN 쿠키 */
u32 idx = get_random_u32_below(100);          /* 0~99 범위 */

/* ━━━ 초기 부팅 시 주의사항 ━━━ */
/* 부팅 초기에는 엔트로피 풀이 충분히 채워지지 않을 수 있음.
 * get_random_bytes()는 CRNG가 초기화된 후에만 완전한 품질을 보장.
 * wait_for_random_bytes()로 초기화 완료를 기다릴 수 있음 */
ret = wait_for_random_bytes();  /* CRNG 준비될 때까지 대기 */
if (ret)
    pr_warn("CRNG not ready, random may be weak\n");

Crypto API DRBG — FIPS 호환 난수 생성

Crypto API의 crypto_rng 인터페이스는 NIST SP 800-90A 규격의 DRBG(Deterministic Random Bit Generator)를 제공합니다. 일반 용도에서는 get_random_bytes()가 충분하지만, FIPS 인증 환경이나 테스트 벡터 재현이 필요한 경우 DRBG를 직접 사용합니다:

#include <crypto/rng.h>

/* ━━━ Crypto API DRBG 사용 예제 ━━━ */
static int generate_fips_random(u8 *out, unsigned int len)
{
    struct crypto_rng *drbg;
    u8 seed[64];
    int ret;

    /* 1. DRBG 인스턴스 할당 */
    drbg = crypto_alloc_rng("drbg_nopr_hmac_sha256", 0, 0);
    if (IS_ERR(drbg))
        return PTR_ERR(drbg);

    /* 2. 엔트로피 시드 준비 → DRBG에 주입 */
    get_random_bytes(seed, crypto_rng_seedsize(drbg));
    ret = crypto_rng_reset(drbg, seed, crypto_rng_seedsize(drbg));
    if (ret)
        goto out;

    /* 3. DRBG에서 난수 생성 */
    ret = crypto_rng_get_bytes(drbg, out, len);
    /* ret == 0: 성공, -EINVAL: 파라미터 오류 */

out:
    memzero_explicit(seed, sizeof(seed));
    crypto_free_rng(drbg);
    return ret;
}

엔트로피 소스와 HW RNG

커널이 수집하는 엔트로피 소스와 각각의 특성입니다. 다중 소스를 혼합(mixing)하여 단일 소스의 결함이 전체 시스템을 위협하지 않도록 합니다:

ChaCha20 CRNG 내부 구조

리눅스 6.x의 핵심 CRNG는 ChaCha20 스트림 암호 기반입니다. CPU별(per-CPU) 독립 상태를 유지하여 lock-free 고속 생성이 가능합니다:

/* drivers/char/random.c — ChaCha20 CRNG 핵심 구조 (간소화) */

struct crng_state {
    u32 state[16];     /* ChaCha20 상태 (512비트) */
    unsigned long birth; /* 마지막 reseed 시각 */
};

/* per-CPU CRNG — 각 CPU가 독립 상태를 보유 */
static DEFINE_PER_CPU(struct crng_state, crngs);

/* get_random_bytes() 내부 동작 (간소화) */
void get_random_bytes(void *buf, size_t len)
{
    struct crng_state *crng = this_cpu_ptr(&crngs);

    /* 1. reseed 필요 여부 확인 (5분 또는 256B 출력마다) */
    if (crng_needs_reseed(crng))
        crng_reseed(crng);  /* 엔트로피 풀에서 256비트 시드 추출 → 키 갱신 */

    /* 2. ChaCha20 블록 생성 → buf에 복사 */
    chacha20_block(crng->state, buf);

    /* 3. backtrack 방지: 키 부분을 출력에서 즉시 갱신 */
    crng_fast_key_erasure(crng->state);
    /* → 과거 출력에서 키를 역추적하는 것이 불가능 */
}

주요 알고리즘 카탈로그

사용자 공간(User Space) 인터페이스 (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배 이상 빠른 처리량(Throughput)을 제공하며, 일반적인 테이블 기반 구현 대비 타이밍 기반 부채널 위험을 줄이는 데 유리합니다.

AES-NI 명령어 세트

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

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 연산 중 캐시(Cache) 접근 패턴을 관측하여 키를 추출할 수 있습니다:

/* 소프트웨어 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)에 새로운 알고리즘을 추가하려면 알고리즘 구조체(Struct) 정의 → 콜백 구현 → 등록 → 테스트 벡터 추가의 과정을 거칩니다. 이 섹션에서는 각 단계를 상세히 다룹니다.

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

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

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

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

/* 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,
    },
};

하드웨어 드라이버 등록(Driver Registration) 패턴: 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는 암호 알고리즘의 성능을 측정하는 커널 모듈(Kernel Module)입니다:

# 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 매크로(Macro)

/* 모듈 자동 로딩을 위한 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 모드 디버깅(Debugging)

# ─── 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)의 핵심 진입점(Entry Point)입니다. crypto_register_alg() 호출 시 커널 내부에서는 이름 충돌 검사, 우선순위 비교, 테스트 벡터 검증, larval 깨우기(Wakeup), 템플릿 인스턴스화가 순차적으로 수행됩니다. 이 섹션에서는 등록 과정의 내부 흐름을 단계별로 추적합니다.

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) 알고리즘은 암호화와 인증을 하나의 원자적 연산(Atomic Operation)으로 결합합니다. 내부적으로 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);