AES-CCM,即计数器模式与 CBC-MAC 组合的认证加密。 AES-CCM* 扩展 CCM,支持仅加密模式,tag_len=0。
参考:
- NIST SP 800-38C:https://csrc.nist.gov/publications/detail/sp/800-38c/final
- RFC 3610:https://datatracker.ietf.org/doc/html/rfc3610
std.crypto.aes_ccm.Aes128Ccm0
类型
不带认证的 AES-128-CCM*(仅加密,13 字节 nonce)。
std.crypto.aes_ccm.Aes128Ccm16
类型
AES-128-CCM,使用 16 字节认证标签和 13 字节 nonce。
std.crypto.aes_ccm.Aes128Ccm8
类型
AES-128-CCM,使用 8 字节认证标签及 13 字节 nonce。
std.crypto.aes_ccm.Aes256Ccm0
类型
不带认证的 AES-256-CCM*(仅加密,13 字节 nonce)。
std.crypto.aes_ccm.Aes256Ccm16
类型
AES-256-CCM,使用 16 字节认证标签及 13 字节 nonce。
std.crypto.aes_ccm.Aes256Ccm8
类型
AES-256-CCM,使用 8 字节认证标签和 13 字节 nonce。
std.crypto.aes_ccm.AesCcm
类型函数
AES-CCM 认证加密,见 NIST SP 800-38C、RFC 3610。 CCM* 模式扩展 CCM,支持 tag_len=0 时仅加密。
BlockCipher:分组密码类型,分组必须为 16 字节。
tag_len:认证标签的字节长度,可以为 0、4、6、8、10、12、14 或 16。
tag_len=0 时,CCM* 仅提供加密,不提供认证。
nonce_len:Nonce 的字节长度,为 7 至 13。
fn AesCcm(comptime BlockCipher: type, comptime tag_len: usize, comptime nonce_len: usize) type
参数
BlockCipher: type
tag_len: usize
nonce_len: usize
std.crypto.aes_ccm.AesCcm.computeCbcMac
函数
对消息和关联数据计算 CBC-MAC。 CCM 使用普通 CBC-MAC,而非 CMAC(RFC 3610)。
fn computeCbcMac(mac: *[block_length]u8, key: *const [key_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8) void
参数
mac: *[block_length]u8
key: *const [key_length]u8
m: []const u8
ad: []const u8
npub: [nonce_length]u8
std.crypto.aes_ccm.AesCcm.decrypt
函数
m:明文输出缓冲区,长度必须与 c 相同。
c:待解密密文。
tag:待验证的认证标签。
ad:关联数据,必须与加密时一致。
npub:公开 nonce,必须与加密时一致。
key:私钥。
断言 c.len == m.len。
如果返回错误,m 的内容未定义。
pub fn decrypt( m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8, ) AuthenticationError!void
参数
错误
- AuthenticationFailed AuthenticationError
std.crypto.aes_ccm.AesCcm.encodeAdLength
函数
按 CCM 规范编码关联数据的长度。 返回写入的字节数。
fn encodeAdLength(buf: *[10]u8, ad_len: usize) usize
参数
buf: *[10]u8
ad_len: usize
std.crypto.aes_ccm.AesCcm.encrypt
函数
c:密文输出缓冲区,长度必须与 m 相同。
tag:认证标签输出。
m:待加密明文消息。
ad:待认证关联数据。
npub:公开 nonce,同一密钥下每条消息必须唯一。
key:加密密钥。
pub fn encrypt( c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8, ) void
参数
c: []u8
tag: *[tag_length]u8
m: []const u8
ad: []const u8
npub: [nonce_length]u8
key: [key_length]u8
std.crypto.aes_ccm.AesCcm.formatB0Block
函数
为 CBC-MAC 格式化 B_0 块。 B_0 格式:[flags | nonce | message_length] flags = 64Adata + 8M' + L' 其中:Adata = (ad.len > 0),M>0 时 M' = (tag_length - 2)/2,否则为 0;L' = L - 1。 CCM*:tag_length=0 时,M' 编码为 0。
fn formatB0Block(block: *[block_length]u8, msg_len: usize, ad_len: usize, npub: [nonce_length]u8) void
参数
std.crypto.aes_ccm.AesCcm.formatCtrBlock
函数
格式化 CTR 模式的计数器块。 计数器块格式:[flags | nonce | counter] flags = L - 1
fn formatCtrBlock(block: *[block_length]u8, npub: [nonce_length]u8, counter: u64) void
参数
std.crypto.aes_ccm.AesCcm.key_length
常量
std.crypto.aes_ccm.AesCcm.nonce_length
常量
std.crypto.aes_ccm.AesCcm.tag_length
常量
std.crypto.aes_ccm.assert
别名
别名目标 std.debug.assert
std.crypto.aes_ccm.AuthenticationError
别名
std.crypto.aes_ccm.cbc_mac
别名
别名目标 std.crypto.cbc_mac
std.crypto.aes_ccm.crypto
别名
别名目标 std.crypto
std.crypto.aes_ccm.fmt
别名
别名目标 std.fmt
std.crypto.aes_ccm.hexToBytes
别名
别名目标 std.fmt.hexToBytes
std.crypto.aes_ccm.mem
别名
别名目标 std.mem
std.crypto.aes_ccm.modes
别名
std.crypto.aes_ccm.std
别名
别名目标 std
std.crypto.aes_ccm.testing
别名
别名目标 std.testing
源码
std/crypto/aes_ccm.zig
//! AES-CCM,即计数器模式与 CBC-MAC 组合的认证加密。
//! AES-CCM* 扩展 CCM,支持仅加密模式,tag_len=0。
//!
//! 参考:
//! - NIST SP 800-38C:https://csrc.nist.gov/publications/detail/sp/800-38c/final
//! - RFC 3610:https://datatracker.ietf.org/doc/html/rfc3610
const std = @import("std");
const assert = std.debug.assert;
const crypto = std.crypto;
const mem = std.mem;
const modes = crypto.core.modes;
const AuthenticationError = crypto.errors.AuthenticationError;
const cbc_mac = @import("cbc_mac.zig");
/// 不带认证的 AES-128-CCM*(仅加密,13 字节 nonce)。
pub const Aes128Ccm0 = AesCcm(crypto.core.aes.Aes128, 0, 13);
/// AES-128-CCM,使用 8 字节认证标签及 13 字节 nonce。
pub const Aes128Ccm8 = AesCcm(crypto.core.aes.Aes128, 8, 13);
/// AES-128-CCM,使用 16 字节认证标签和 13 字节 nonce。
pub const Aes128Ccm16 = AesCcm(crypto.core.aes.Aes128, 16, 13);
/// 不带认证的 AES-256-CCM*(仅加密,13 字节 nonce)。
pub const Aes256Ccm0 = AesCcm(crypto.core.aes.Aes256, 0, 13);
/// AES-256-CCM,使用 8 字节认证标签和 13 字节 nonce。
pub const Aes256Ccm8 = AesCcm(crypto.core.aes.Aes256, 8, 13);
/// AES-256-CCM,使用 16 字节认证标签及 13 字节 nonce。
pub const Aes256Ccm16 = AesCcm(crypto.core.aes.Aes256, 16, 13);
/// AES-CCM 认证加密,见 NIST SP 800-38C、RFC 3610。
/// CCM* 模式扩展 CCM,支持 tag_len=0 时仅加密。
///
/// `BlockCipher`:分组密码类型,分组必须为 16 字节。
/// `tag_len`:认证标签的字节长度,可以为 0、4、6、8、10、12、14 或 16。
/// tag_len=0 时,CCM* 仅提供加密,不提供认证。
/// `nonce_len`:Nonce 的字节长度,为 7 至 13。
fn AesCcm(comptime BlockCipher: type, comptime tag_len: usize, comptime nonce_len: usize) type {
const block_length = BlockCipher.block.block_length;
comptime {
assert(block_length == 16); // CCM 要求 16 字节数据块
if (tag_len != 0 and (tag_len < 4 or tag_len > 16 or tag_len % 2 != 0)) {
@compileError("CCM tag_length must be 0, 4, 6, 8, 10, 12, 14, or 16 bytes");
}
if (nonce_len < 7 or nonce_len > 13) {
@compileError("CCM nonce_length must be between 7 and 13 bytes");
}
}
const L = 15 - nonce_len; // 计数器大小,单位为字节(2 到 8)
return struct {
pub const key_length = BlockCipher.key_bits / 8;
pub const tag_length = tag_len;
pub const nonce_length = nonce_len;
/// `c`:密文输出缓冲区,长度必须与 m 相同。
/// `tag`:认证标签输出。
/// `m`:待加密明文消息。
/// `ad`:待认证关联数据。
/// `npub`:公开 nonce,同一密钥下每条消息必须唯一。
/// `key`:加密密钥。
pub fn encrypt(
c: []u8,
tag: *[tag_length]u8,
m: []const u8,
ad: []const u8,
npub: [nonce_length]u8,
key: [key_length]u8,
) void {
assert(c.len == m.len);
// 验证消息长度可由 L 字节表示
const max_msg_len: u64 = if (L >= 8) std.math.maxInt(u64) else (@as(u64, 1) << @as(u6, @intCast(L * 8))) - 1;
assert(m.len <= max_msg_len);
const cipher_ctx = BlockCipher.initEnc(key);
// CCM*:tag_length 为 0 时跳过认证(仅加密模式)。
if (tag_length > 0) {
// 使用可复用 CBC-MAC 模块计算 CBC-MAC。
var mac_result: [block_length]u8 = undefined;
computeCbcMac(&mac_result, &key, m, ad, npub);
// 构造用于标签加密的计数器块(counter = 0)
var ctr_block: [block_length]u8 = undefined;
formatCtrBlock(&ctr_block, npub, 0);
// 加密 MAC 标签
var s0: [block_length]u8 = undefined;
cipher_ctx.encrypt(&s0, &ctr_block);
for (tag, mac_result[0..tag_length], s0[0..tag_length]) |*t, mac_byte, s_byte| {
t.* = mac_byte ^ s_byte;
}
crypto.secureZero(u8, &mac_result);
crypto.secureZero(u8, &s0);
}
// 使用 CTR 模式加密明文(从 counter = 1 开始)
var ctr_block: [block_length]u8 = undefined;
formatCtrBlock(&ctr_block, npub, 1);
// CCM 计数器位于块的最后 L 个字节中
modes.ctrSlice(@TypeOf(cipher_ctx), cipher_ctx, c, m, ctr_block, .big, 1 + nonce_len, L);
}
/// `m`:明文输出缓冲区,长度必须与 c 相同。
/// `c`:待解密密文。
/// `tag`:待验证的认证标签。
/// `ad`:关联数据,必须与加密时一致。
/// `npub`:公开 nonce,必须与加密时一致。
/// `key`:私钥。
///
/// 断言 `c.len == m.len`。
/// 如果返回错误,`m` 的内容未定义。
pub fn decrypt(
m: []u8,
c: []const u8,
tag: [tag_length]u8,
ad: []const u8,
npub: [nonce_length]u8,
key: [key_length]u8,
) AuthenticationError!void {
assert(m.len == c.len);
const max_msg_len: u64 = if (L >= 8) std.math.maxInt(u64) else (@as(u64, 1) << @as(u6, @intCast(L * 8))) - 1;
if (c.len > max_msg_len) return error.AuthenticationFailed;
const cipher_ctx = BlockCipher.initEnc(key);
// 使用 CTR 模式解密密文(从 counter = 1 开始)
var ctr_block: [block_length]u8 = undefined;
formatCtrBlock(&ctr_block, npub, 1);
// CCM 计数器位于块的最后 L 个字节中
modes.ctrSlice(@TypeOf(cipher_ctx), cipher_ctx, m, c, ctr_block, .big, 1 + nonce_len, L);
// CCM*:tag_length 为 0 时跳过认证(仅加密模式)。
if (tag_length > 0) {
// 对解密后的明文计算 CBC-MAC
var mac_result: [block_length]u8 = undefined;
computeCbcMac(&mac_result, &key, m, ad, npub);
// 解密收到的标签
formatCtrBlock(&ctr_block, npub, 0);
var s0: [block_length]u8 = undefined;
cipher_ctx.encrypt(&s0, &ctr_block);
// 重建预期的 MAC
var expected_mac: [tag_length]u8 = undefined;
for (&expected_mac, mac_result[0..tag_length], s0[0..tag_length]) |*e, mac_byte, s_byte| {
e.* = mac_byte ^ s_byte;
}
// 常量时间标签比较
const valid = crypto.timing_safe.eql([tag_length]u8, expected_mac, tag);
if (!valid) {
crypto.secureZero(u8, &expected_mac);
crypto.secureZero(u8, &mac_result);
crypto.secureZero(u8, &s0);
crypto.secureZero(u8, m);
return error.AuthenticationFailed;
}
crypto.secureZero(u8, &expected_mac);
crypto.secureZero(u8, &mac_result);
crypto.secureZero(u8, &s0);
}
}
/// 格式化 CTR 模式的计数器块。
/// 计数器块格式:[flags | nonce | counter]
/// flags = L - 1
fn formatCtrBlock(block: *[block_length]u8, npub: [nonce_length]u8, counter: u64) void {
@memset(block, 0);
block[0] = L - 1; // 标志
@memcpy(block[1..][0..nonce_length], &npub);
// 计数器位于最后 L 个字节中
const CounterInt = @Int(.unsigned, L * 8);
mem.writeInt(CounterInt, block[1 + nonce_length ..][0..L], @as(CounterInt, @intCast(counter)), .big);
}
/// 对消息和关联数据计算 CBC-MAC。
/// CCM 使用普通 CBC-MAC,而非 CMAC(RFC 3610)。
fn computeCbcMac(mac: *[block_length]u8, key: *const [key_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8) void {
const CbcMac = cbc_mac.CbcMac(BlockCipher);
var ctx = CbcMac.init(key);
// 处理 B_0 数据块
var b0: [block_length]u8 = undefined;
formatB0Block(&b0, m.len, ad.len, npub);
ctx.update(&b0);
// 如果存在关联数据,则进行处理。
// RFC 3610:AD 为填充到块边界的 (encoded_length || ad)。
if (ad.len > 0) {
// 编码并添加关联数据长度
var ad_len_encoding: [10]u8 = undefined;
const ad_len_size = encodeAdLength(&ad_len_encoding, ad.len);
// 处理附加数据,并填充到分组边界
ctx.update(ad_len_encoding[0..ad_len_size]);
ctx.update(ad);
// 添加零填充以到达块边界
const total_ad_size = ad_len_size + ad.len;
const remainder = total_ad_size % block_length;
if (remainder > 0) {
const padding: [block_length]u8 = @splat(0);
ctx.update(padding[0 .. block_length - remainder]);
}
}
// 处理明文消息
ctx.update(m);
// 完成 MAC 计算
ctx.final(mac);
}
/// 为 CBC-MAC 格式化 B_0 块。
/// B_0 格式:[flags | nonce | message_length]
/// flags = 64*Adata + 8*M' + L'
/// 其中:Adata = (ad.len > 0),M>0 时 M' = (tag_length - 2)/2,否则为 0;L' = L - 1。
/// CCM*:tag_length=0 时,M' 编码为 0。
fn formatB0Block(block: *[block_length]u8, msg_len: usize, ad_len: usize, npub: [nonce_length]u8) void {
@memset(block, 0);
const Adata: u8 = if (ad_len > 0) 1 else 0;
const M_prime: u8 = if (tag_length > 0) @intCast((tag_length - 2) / 2) else 0;
const L_prime: u8 = L - 1;
block[0] = (Adata << 6) | (M_prime << 3) | L_prime;
@memcpy(block[1..][0..nonce_length], &npub);
// 将消息长度编码在最后 L 个字节中
const LengthInt = @Int(.unsigned, L * 8);
mem.writeInt(LengthInt, block[1 + nonce_length ..][0..L], @as(LengthInt, @intCast(msg_len)), .big);
}
/// 按 CCM 规范编码关联数据的长度。
/// 返回写入的字节数。
fn encodeAdLength(buf: *[10]u8, ad_len: usize) usize {
if (ad_len < 65280) { // 2^16 - 2^8
// 编码为 2 字节
mem.writeInt(u16, buf[0..2], @as(u16, @intCast(ad_len)), .big);
return 2;
} else if (ad_len <= std.math.maxInt(u32)) {
// 编码为 0xff || 0xfe || 4 字节
buf[0] = 0xff;
buf[1] = 0xfe;
mem.writeInt(u32, buf[2..6], @as(u32, @intCast(ad_len)), .big);
return 6;
} else {
// 编码为 0xff || 0xff || 8 字节
buf[0] = 0xff;
buf[1] = 0xff;
mem.writeInt(u64, buf[2..10], @as(u64, @intCast(ad_len)), .big);
return 10;
}
}
};
}
// 测试
const testing = std.testing;
const fmt = std.fmt;
const hexToBytes = fmt.hexToBytes;
test "Aes256Ccm8 - Encrypt decrypt round-trip" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "Hello, World! This is a test message.";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, "", nonce, key);
try Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
test "Aes256Ccm8 - Associated data" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "secret message";
const ad = "additional authenticated data";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, ad, nonce, key);
try Aes256Ccm8.decrypt(&m2, &c, tag, ad, nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
var m3: [m.len]u8 = undefined;
const wrong_adata = "wrong data";
const result = Aes256Ccm8.decrypt(&m3, &c, tag, wrong_adata, nonce, key);
try testing.expectError(error.AuthenticationFailed, result);
}
test "Aes256Ccm8 - Wrong key" {
const key: [32]u8 = @splat(0x42);
const wrong_key: [32]u8 = @splat(0x43);
const nonce: [13]u8 = @splat(0x11);
const m = "secret";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, "", nonce, key);
const result = Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, wrong_key);
try testing.expectError(error.AuthenticationFailed, result);
}
test "Aes256Ccm8 - Corrupted ciphertext" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "secret message";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, "", nonce, key);
c[5] ^= 0xFF;
const result = Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectError(error.AuthenticationFailed, result);
}
test "Aes256Ccm8 - Empty plaintext" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, "", nonce, key);
try Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqual(@as(usize, 0), m2.len);
}
test "Aes128Ccm8 - Basic functionality" {
const key: [16]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "Test AES-128-CCM";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes128Ccm8.tag_length]u8 = undefined;
Aes128Ccm8.encrypt(&c, &tag, m, "", nonce, key);
try Aes128Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
test "Aes256Ccm16 - 16-byte tag" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "Test 16-byte tag";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm16.tag_length]u8 = undefined;
Aes256Ccm16.encrypt(&c, &tag, m, "", nonce, key);
try testing.expectEqual(@as(usize, 16), tag.len);
try Aes256Ccm16.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
test "Aes256Ccm8 - Edge case short nonce" {
const Aes256Ccm8_7 = AesCcm(crypto.core.aes.Aes256, 8, 7);
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6");
var nonce: [7]u8 = undefined;
_ = try hexToBytes(&nonce, "a544218dadd3c1");
var m: [1]u8 = undefined;
_ = try hexToBytes(&m, "00");
var c: [m.len]u8 = undefined;
var tag: [Aes256Ccm8_7.tag_length]u8 = undefined;
Aes256Ccm8_7.encrypt(&c, &tag, &m, "", nonce, key);
var m2: [c.len]u8 = undefined;
try Aes256Ccm8_7.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, &m, &m2);
}
test "Aes256Ccm8 - Edge case long nonce" {
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "a544218dadd3c10583db49cf39");
var m: [1]u8 = undefined;
_ = try hexToBytes(&m, "00");
var c: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, &m, "", nonce, key);
var m2: [c.len]u8 = undefined;
try Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, &m, &m2);
}
test "Aes256Ccm8 - With AAD and wrong AAD detection" {
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "a544218dadd3c10583db49cf39");
var m: [1]u8 = undefined;
_ = try hexToBytes(&m, "00");
var ad: [32]u8 = undefined;
_ = try hexToBytes(&ad, "3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907");
var c: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, &m, &ad, nonce, key);
var m2: [c.len]u8 = undefined;
try Aes256Ccm8.decrypt(&m2, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &m, &m2);
var wrong_ad: [32]u8 = undefined;
_ = try hexToBytes(&wrong_ad, "0000000000000000000000000000000000000000000000000000000000000000");
var m3: [c.len]u8 = undefined;
const result = Aes256Ccm8.decrypt(&m3, &c, tag, &wrong_ad, nonce, key);
try testing.expectError(error.AuthenticationFailed, result);
}
test "Aes256Ccm8 - Multi-block payload" {
const Aes256Ccm8_12 = AesCcm(crypto.core.aes.Aes256, 8, 12);
// 使用 32 字节载荷测试(2 个 AES 块)
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569");
var nonce: [12]u8 = undefined;
_ = try hexToBytes(&nonce, "a544218dadd3c10583db49cf");
var m: [32]u8 = undefined;
_ = try hexToBytes(&m, "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff");
// 加密
var c: [32]u8 = undefined;
var tag: [Aes256Ccm8_12.tag_length]u8 = undefined;
Aes256Ccm8_12.encrypt(&c, &tag, &m, "", nonce, key);
// 解密并验证
var m2: [32]u8 = undefined;
try Aes256Ccm8_12.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, &m, &m2);
}
test "Aes256Ccm8 - Multi-block with AAD" {
const Aes256Ccm8_12 = AesCcm(crypto.core.aes.Aes256, 8, 12);
// 使用多块载荷(3 个 AES 块)及 AAD 测试。
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453");
var nonce: [12]u8 = undefined;
_ = try hexToBytes(&nonce, "5b8e40746f6b98e00f1d13ff");
// 48 字节有效负载(3 个 AES 分组)
var m: [48]u8 = undefined;
_ = try hexToBytes(&m, "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f");
// 16 字节 AAD
var ad: [16]u8 = undefined;
_ = try hexToBytes(&ad, "000102030405060708090a0b0c0d0e0f");
// 加密
var c: [48]u8 = undefined;
var tag: [Aes256Ccm8_12.tag_length]u8 = undefined;
Aes256Ccm8_12.encrypt(&c, &tag, &m, &ad, nonce, key);
// 解密并验证
var m2: [48]u8 = undefined;
try Aes256Ccm8_12.decrypt(&m2, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &m, &m2);
}
test "Aes256Ccm8 - Minimum nonce length" {
const Aes256Ccm8_7 = AesCcm(crypto.core.aes.Aes256, 8, 7);
// 使用 7 字节 nonce 测试(CCM 规范允许的最小长度)
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f");
var nonce: [7]u8 = undefined;
_ = try hexToBytes(&nonce, "10111213141516");
const m = "Test message with minimum nonce length";
// 加密
var c: [m.len]u8 = undefined;
var tag: [Aes256Ccm8_7.tag_length]u8 = undefined;
Aes256Ccm8_7.encrypt(&c, &tag, m, "", nonce, key);
// 解密并验证
var m2: [m.len]u8 = undefined;
try Aes256Ccm8_7.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
test "Aes256Ccm8 - Maximum nonce length" {
// 使用 13 字节 nonce 测试(CCM 规范允许的最大长度)
var key: [32]u8 = undefined;
_ = try hexToBytes(&key, "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "101112131415161718191a1b1c");
const m = "Test message with maximum nonce length";
// 加密
var c: [m.len]u8 = undefined;
var tag: [Aes256Ccm8.tag_length]u8 = undefined;
Aes256Ccm8.encrypt(&c, &tag, m, "", nonce, key);
// 解密并验证
var m2: [m.len]u8 = undefined;
try Aes256Ccm8.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
// RFC 3610 测试向量
test "Aes128Ccm8 - RFC 3610 Packet Vector #1" {
const Aes128Ccm8_13 = AesCcm(crypto.core.aes.Aes128, 8, 13);
// RFC 3610 附录 A,数据包向量 #1
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "00000003020100A0A1A2A3A4A5");
var ad: [8]u8 = undefined;
_ = try hexToBytes(&ad, "0001020304050607");
var plaintext: [23]u8 = undefined;
_ = try hexToBytes(&plaintext, "08090A0B0C0D0E0F101112131415161718191A1B1C1D1E");
// RFC 给出的预期密文和标签
var expected_ciphertext: [23]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "588C979A61C663D2F066D0C2C0F989806D5F6B61DAC384");
var expected_tag: [8]u8 = undefined;
_ = try hexToBytes(&expected_tag, "17E8D12CFDF926E0");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm8_13.tag_length]u8 = undefined;
Aes128Ccm8_13.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文与 RFC 的预期输出匹配
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 RFC 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm8_13.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm8 - RFC 3610 Packet Vector #2" {
const Aes128Ccm8_13 = AesCcm(crypto.core.aes.Aes128, 8, 13);
// RFC 3610 附录 A,数据包向量 #2(8 字节标签,M=8)
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "00000004030201A0A1A2A3A4A5");
var ad: [8]u8 = undefined;
_ = try hexToBytes(&ad, "0001020304050607");
var plaintext: [24]u8 = undefined;
_ = try hexToBytes(&plaintext, "08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F");
// RFC 中的预期密文及认证标签(取自完整数据包:头部 + 密文 + 标签)。
var expected_ciphertext: [24]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "72C91A36E135F8CF291CA894085C87E3CC15C439C9E43A3B");
var expected_tag: [8]u8 = undefined;
_ = try hexToBytes(&expected_tag, "A091D56E10400916");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm8_13.tag_length]u8 = undefined;
Aes128Ccm8_13.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文与 RFC 的预期输出匹配
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 RFC 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm8_13.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm8 - RFC 3610 Packet Vector #3" {
const Aes128Ccm8_13 = AesCcm(crypto.core.aes.Aes128, 8, 13);
// RFC 3610 附录 A,数据包向量 #3(8 字节标签,25 字节载荷)
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "00000005040302A0A1A2A3A4A5");
var ad: [8]u8 = undefined;
_ = try hexToBytes(&ad, "0001020304050607");
var plaintext: [25]u8 = undefined;
_ = try hexToBytes(&plaintext, "08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20");
// RFC 给出的预期密文和标签
var expected_ciphertext: [25]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "51B1E5F44A197D1DA46B0F8E2D282AE871E838BB64DA859657");
var expected_tag: [8]u8 = undefined;
_ = try hexToBytes(&expected_tag, "4ADAA76FBD9FB0C5");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm8_13.tag_length]u8 = undefined;
Aes128Ccm8_13.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文与 RFC 的预期输出匹配
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 RFC 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm8_13.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
// NIST SP 800-38C 测试向量
test "Aes128Ccm4 - NIST SP 800-38C Example 1" {
const Aes128Ccm4_7 = AesCcm(crypto.core.aes.Aes128, 4, 7);
// 示例 1(C.1):Klen=128, Tlen=32, Nlen=56, Alen=64, Plen=32
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "404142434445464748494a4b4c4d4e4f");
var nonce: [7]u8 = undefined;
_ = try hexToBytes(&nonce, "10111213141516");
var ad: [8]u8 = undefined;
_ = try hexToBytes(&ad, "0001020304050607");
var plaintext: [4]u8 = undefined;
_ = try hexToBytes(&plaintext, "20212223");
// NIST 给出的预期密文和标签
var expected_ciphertext: [4]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "7162015b");
var expected_tag: [4]u8 = undefined;
_ = try hexToBytes(&expected_tag, "4dac255d");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm4_7.tag_length]u8 = undefined;
Aes128Ccm4_7.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文是否匹配 NIST 预期输出
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 NIST 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm4_7.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm6 - NIST SP 800-38C Example 2" {
const Aes128Ccm6_8 = AesCcm(crypto.core.aes.Aes128, 6, 8);
// 示例 2(C.2):Klen=128, Tlen=48, Nlen=64, Alen=128, Plen=128
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "404142434445464748494a4b4c4d4e4f");
var nonce: [8]u8 = undefined;
_ = try hexToBytes(&nonce, "1011121314151617");
var ad: [16]u8 = undefined;
_ = try hexToBytes(&ad, "000102030405060708090a0b0c0d0e0f");
var plaintext: [16]u8 = undefined;
_ = try hexToBytes(&plaintext, "202122232425262728292a2b2c2d2e2f");
// NIST 给出的预期密文和标签
var expected_ciphertext: [16]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "d2a1f0e051ea5f62081a7792073d593d");
var expected_tag: [6]u8 = undefined;
_ = try hexToBytes(&expected_tag, "1fc64fbfaccd");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm6_8.tag_length]u8 = undefined;
Aes128Ccm6_8.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文是否匹配 NIST 预期输出
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 NIST 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm6_8.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm8 - NIST SP 800-38C Example 3" {
const Aes128Ccm8_12 = AesCcm(crypto.core.aes.Aes128, 8, 12);
// 示例 3(C.3):Klen=128, Tlen=64, Nlen=96, Alen=160, Plen=192
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "404142434445464748494a4b4c4d4e4f");
var nonce: [12]u8 = undefined;
_ = try hexToBytes(&nonce, "101112131415161718191a1b");
var ad: [20]u8 = undefined;
_ = try hexToBytes(&ad, "000102030405060708090a0b0c0d0e0f10111213");
var plaintext: [24]u8 = undefined;
_ = try hexToBytes(&plaintext, "202122232425262728292a2b2c2d2e2f3031323334353637");
// NIST 给出的预期密文和标签
var expected_ciphertext: [24]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "e3b201a9f5b71a7a9b1ceaeccd97e70b6176aad9a4428aa5");
var expected_tag: [8]u8 = undefined;
_ = try hexToBytes(&expected_tag, "484392fbc1b09951");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm8_12.tag_length]u8 = undefined;
Aes128Ccm8_12.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文是否匹配 NIST 预期输出
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 NIST 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm8_12.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm14 - NIST SP 800-38C Example 4" {
const Aes128Ccm14_13 = AesCcm(crypto.core.aes.Aes128, 14, 13);
// 示例 4(C.4):Klen=128, Tlen=112, Nlen=104, Alen=524288, Plen=256
// 注:关联数据为 65536 字节(256 字节的模式重复 256 次)
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "404142434445464748494a4b4c4d4e4f");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "101112131415161718191a1b1c");
var plaintext: [32]u8 = undefined;
_ = try hexToBytes(&plaintext, "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
// 生成 65536 字节的关联数据(256 字节模式重复 256 次)。
var pattern: [256]u8 = undefined;
_ = try hexToBytes(&pattern, "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
var ad: [65536]u8 = undefined;
for (0..256) |i| {
@memcpy(ad[i * 256 .. (i + 1) * 256], &pattern);
}
// NIST 给出的预期密文和标签
var expected_ciphertext: [32]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "69915dad1e84c6376a68c2967e4dab615ae0fd1faec44cc484828529463ccf72");
var expected_tag: [14]u8 = undefined;
_ = try hexToBytes(&expected_tag, "b4ac6bec93e8598e7f0dadbcea5b");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm14_13.tag_length]u8 = undefined;
Aes128Ccm14_13.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文是否匹配 NIST 预期输出
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 验证标签与 NIST 预期输出一致
try testing.expectEqualSlices(u8, &expected_tag, &tag);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm14_13.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
// CCM* 测试向量(M=0 的仅加密模式)
test "Aes128Ccm0 - IEEE 802.15.4 Data Frame (Encryption-only)" {
// IEEE 802.15.4 第 2.7 节的测试向量。
// 安全级别 0x04(ENC,仅加密,不认证)。
var key: [16]u8 = undefined;
_ = try hexToBytes(&key, "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF");
var nonce: [13]u8 = undefined;
_ = try hexToBytes(&nonce, "ACDE48000000000100000005" ++ "04");
var plaintext: [4]u8 = undefined;
_ = try hexToBytes(&plaintext, "61626364");
var ad: [26]u8 = undefined;
_ = try hexToBytes(&ad, "69DC842143020000000048DEAC010000000048DEAC0405000000");
// IEEE 规范中的预期密文
var expected_ciphertext: [4]u8 = undefined;
_ = try hexToBytes(&expected_ciphertext, "D43E022B");
// 加密
var c: [plaintext.len]u8 = undefined;
var tag: [Aes128Ccm0.tag_length]u8 = undefined;
Aes128Ccm0.encrypt(&c, &tag, &plaintext, &ad, nonce, key);
// 验证密文与 IEEE 预期输出一致。
try testing.expectEqualSlices(u8, &expected_ciphertext, &c);
// 解密并校验往返一致性
var m: [plaintext.len]u8 = undefined;
try Aes128Ccm0.decrypt(&m, &c, tag, &ad, nonce, key);
try testing.expectEqualSlices(u8, &plaintext, &m);
}
test "Aes128Ccm0 - Zero-length plaintext with encryption-only" {
const key: [16]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "";
const ad = "some associated data";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes128Ccm0.tag_length]u8 = undefined;
Aes128Ccm0.encrypt(&c, &tag, m, ad, nonce, key);
try Aes128Ccm0.decrypt(&m2, &c, tag, ad, nonce, key);
try testing.expectEqual(@as(usize, 0), m2.len);
}
test "Aes256Ccm0 - Basic encryption-only round-trip" {
const key: [32]u8 = @splat(0x42);
const nonce: [13]u8 = @splat(0x11);
const m = "Hello, CCM* encryption-only mode!";
var c: [m.len]u8 = undefined;
var m2: [m.len]u8 = undefined;
var tag: [Aes256Ccm0.tag_length]u8 = undefined;
Aes256Ccm0.encrypt(&c, &tag, m, "", nonce, key);
try Aes256Ccm0.decrypt(&m2, &c, tag, "", nonce, key);
try testing.expectEqualSlices(u8, m[0..], m2[0..]);
}
test "Aes256Ccm decryption of oversized ciphertext" {
const key: [32]u8 = @splat(0);
const nonce: [13]u8 = @splat(0);
const tag: [Aes256Ccm16.tag_length]u8 = @splat(0);
var buf: [65536]u8 = @splat(0);
try testing.expectError(error.AuthenticationFailed, Aes256Ccm16.decrypt(&buf, &buf, tag, "", nonce, key));
}