std.crypto.aes.armcrypto.Aes128
命名空间
采用标准密钥扩展的 AES-128。
std.crypto.aes.armcrypto.Aes128.block
别名
std.crypto.aes.armcrypto.Aes128.initDec
函数
创建新的解密上下文。
pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes128)
参数
key: [key_bits / 8]u8
std.crypto.aes.armcrypto.Aes128.initEnc
函数
创建新的加密上下文。
pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes128)
参数
key: [key_bits / 8]u8
std.crypto.aes.armcrypto.Aes128.key_bits
常量
usize
std.crypto.aes.armcrypto.Aes128.rounds
常量
std.crypto.aes.armcrypto.Aes256
命名空间
采用标准密钥编排的 AES-256。
std.crypto.aes.armcrypto.Aes256.block
别名
std.crypto.aes.armcrypto.Aes256.initDec
函数
创建新的解密上下文。
pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes256)
参数
key: [key_bits / 8]u8
std.crypto.aes.armcrypto.Aes256.initEnc
函数
创建新的加密上下文。
pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes256)
参数
key: [key_bits / 8]u8
std.crypto.aes.armcrypto.Aes256.key_bits
常量
usize
std.crypto.aes.armcrypto.Aes256.rounds
常量
std.crypto.aes.armcrypto.AesDecryptCtx
类型函数
使用标准 AES 密钥调度进行解密的上下文。
pub fn AesDecryptCtx(comptime Aes: type) type
参数
Aes: type
字段
key_schedule: KeySchedule(Aes)
std.crypto.aes.armcrypto.AesDecryptCtx.block
常量
std.crypto.aes.armcrypto.AesDecryptCtx.block_length
常量
std.crypto.aes.armcrypto.AesDecryptCtx.decrypt
函数
解密单个数据块。
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void
参数
std.crypto.aes.armcrypto.AesDecryptCtx.decryptWide
函数
解密多个数据块,可能利用并行处理。
pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void
参数
std.crypto.aes.armcrypto.AesDecryptCtx.init
函数
使用给定密钥创建新的解密上下文。
pub fn init(key: [Aes.key_bits / 8]u8) Self
参数
key: [Aes.key_bits / 8]u8
std.crypto.aes.armcrypto.AesDecryptCtx.initFromEnc
函数
从现有加密上下文创建解密上下文。
pub fn initFromEnc(ctx: AesEncryptCtx(Aes)) Self
参数
ctx: AesEncryptCtx(Aes)
std.crypto.aes.armcrypto.AesDecryptCtx.Self
别名
std.crypto.aes.armcrypto.AesEncryptCtx
类型函数
使用标准 AES 密钥扩展进行加密的上下文。
pub fn AesEncryptCtx(comptime Aes: type) type
参数
Aes: type
字段
key_schedule: KeySchedule(Aes)
std.crypto.aes.armcrypto.AesEncryptCtx.block
常量
std.crypto.aes.armcrypto.AesEncryptCtx.block_length
常量
std.crypto.aes.armcrypto.AesEncryptCtx.encrypt
函数
加密单个数据块。
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void
参数
std.crypto.aes.armcrypto.AesEncryptCtx.encryptWide
函数
加密多个块,可能利用并行处理。
pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void
参数
std.crypto.aes.armcrypto.AesEncryptCtx.init
函数
使用给定密钥创建新的加密上下文。
pub fn init(key: [Aes.key_bits / 8]u8) Self
参数
key: [Aes.key_bits / 8]u8
std.crypto.aes.armcrypto.AesEncryptCtx.Self
别名
std.crypto.aes.armcrypto.AesEncryptCtx.xor
函数
对单个块执行加密和异或。
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void
参数
std.crypto.aes.armcrypto.AesEncryptCtx.xorWide
函数
对多个块执行加密及异或,可能利用并行处理。
pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void
参数
std.crypto.aes.armcrypto.Block
容器
单个 AES 数据块。
字段
repr: Repr数据分组的内部表示。
std.crypto.aes.armcrypto.Block.andBlocks
函数
对两个块的内容应用按位与操作。
pub fn andBlocks(block1: Block, block2: Block) Block
参数
std.crypto.aes.armcrypto.Block.block_length
常量
usize
std.crypto.aes.armcrypto.Block.decrypt
函数
用轮密钥解密一个块。
pub fn decrypt(block: Block, inv_round_key: Block) Block
参数
std.crypto.aes.armcrypto.Block.decryptLast
函数
使用最后一轮密钥解密一个块。
pub fn decryptLast(block: Block, inv_round_key: Block) Block
参数
std.crypto.aes.armcrypto.Block.encrypt
函数
使用轮密钥加密一个块。
pub fn encrypt(block: Block, round_key: Block) Block
参数
std.crypto.aes.armcrypto.Block.encryptLast
函数
使用最后一轮的轮密钥加密一个分组。
pub fn encryptLast(block: Block, round_key: Block) Block
参数
std.crypto.aes.armcrypto.Block.fromBytes
函数
将字节序列转换为内部表示。
pub fn fromBytes(bytes: *const [16]u8) Block
参数
bytes: *const [16]u8
std.crypto.aes.armcrypto.Block.invMixColumns
函数
对一个块应用逆 MixColumns 运算。
pub fn invMixColumns(block: Block) Block
参数
block: Block
std.crypto.aes.armcrypto.Block.orBlocks
函数
对两个块的内容执行按位或操作。
pub fn orBlocks(block1: Block, block2: Block) Block
参数
std.crypto.aes.armcrypto.Block.parallel
命名空间
并行处理多个块。
std.crypto.aes.armcrypto.Block.parallel.decryptLastWide
函数
使用同一个末轮密钥并行解密多个数据块。
pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.decryptParallel
函数
并行解密多个数据块,各自使用自己的轮密钥。
pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.decryptWide
函数
使用同一轮密钥并行解密多个块。
pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.encryptLastWide
函数
使用相同的最后一轮密钥并行加密多个块。
pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.encryptParallel
函数
并行加密多个块,每个块使用各自的轮密钥。
pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.encryptWide
函数
使用同一个轮密钥并行加密多个数据块。
pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block
参数
std.crypto.aes.armcrypto.Block.parallel.optimal_parallel_blocks
常量
对所选实现,建议并行执行的 AES 加密/解密次数。
std.crypto.aes.armcrypto.Block.Repr
常量
std.crypto.aes.armcrypto.Block.toBytes
函数
将数据块的内部表示转换为字节序列。
pub fn toBytes(block: Block) [16]u8
参数
block: Block
std.crypto.aes.armcrypto.Block.xorBlocks
函数
对两个数据块的内容应用按位异或操作。
pub fn xorBlocks(block1: Block, block2: Block) Block
参数
std.crypto.aes.armcrypto.Block.xorBytes
函数
将该块与字节序列异或。
pub fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8
参数
block: Block
bytes: *const [16]u8
std.crypto.aes.armcrypto.Block.zero
常量
std.crypto.aes.armcrypto.BlockVec
类型函数
固定大小的 AES 块向量。 所有操作均并行执行,在可用时使用 SIMD 指令。
pub fn BlockVec(comptime blocks_count: comptime_int) type
参数
blocks_count: comptime_int
字段
repr: [native_words]Block分组向量的内部表示。
std.crypto.aes.armcrypto.BlockVec.andBlocks
函数
对两个块向量的内容执行按位与。
pub fn andBlocks(block_vec1: Self, block_vec2: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.block_length
常量
分组向量的长度,单位为字节。
usize
std.crypto.aes.armcrypto.BlockVec.decrypt
函数
使用轮密钥向量,对块向量执行逆 AES 操作。
pub fn decrypt(block_vec: Self, inv_round_key_vec: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.decryptLast
函数
使用末轮密钥向量,对块向量应用逆 AES 操作。
pub fn decryptLast(block_vec: Self, inv_round_key_vec: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.encrypt
函数
使用轮密钥向量,对块向量应用正向 AES 运算。
pub fn encrypt(block_vec: Self, round_key_vec: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.encryptLast
函数
使用最后一轮密钥向量,对块向量执行正向 AES 操作。
pub fn encryptLast(block_vec: Self, round_key_vec: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.fromBytes
函数
将字节序列转换为内部表示。
pub fn fromBytes(bytes: *const [blocks_count * 16]u8) Self
参数
bytes: *const [blocks_count * 16]u8
std.crypto.aes.armcrypto.BlockVec.invMixColumns
函数
对向量中的每个块应用逆 MixColumns 运算。
pub fn invMixColumns(block_vec: Self) Self
参数
block_vec: Self
std.crypto.aes.armcrypto.BlockVec.native_vector_size
常量
目标架构可通过单条指令处理的 AES 块数量。
std.crypto.aes.armcrypto.BlockVec.native_word_size
常量
目标架构可用单条指令处理的 AES 块向量大小,以字节为单位。
std.crypto.aes.armcrypto.BlockVec.native_words
常量
std.crypto.aes.armcrypto.BlockVec.orBlocks
函数
对两个块向量的内容应用按位或操作。
pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.Self
别名
std.crypto.aes.armcrypto.BlockVec.toBytes
函数
将块向量的内部表示转换为字节序列。
pub fn toBytes(block_vec: Self) [blocks_count * 16]u8
参数
block_vec: Self
std.crypto.aes.armcrypto.BlockVec.xorBlocks
函数
对两个块向量的内容应用按位异或操作。
pub fn xorBlocks(block_vec1: Self, block_vec2: Self) Self
参数
std.crypto.aes.armcrypto.BlockVec.xorBytes
函数
将块向量与字节序列异或。
pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8
参数
block_vec: Self
bytes: *const [blocks_count * 16]u8
std.crypto.aes.armcrypto.debug
别名
别名目标 std.debug
std.crypto.aes.armcrypto.KeySchedule
类型函数
fn KeySchedule(comptime Aes: type) type
参数
Aes: type
字段
round_keys: [rounds + 1]Block
std.crypto.aes.armcrypto.KeySchedule.drc128
函数
fn drc128(comptime rc: u8, t: Repr) Repr
参数
rc: u8
t: Repr
std.crypto.aes.armcrypto.KeySchedule.drc256
函数
fn drc256(comptime second: bool, comptime rc: u8, t: Repr, tx: Repr) Repr
参数
std.crypto.aes.armcrypto.KeySchedule.expand128
函数
fn expand128(t1: *Block) Self
参数
t1: *Block
std.crypto.aes.armcrypto.KeySchedule.expand256
函数
fn expand256(t1: *Block, t2: *Block) Self
参数
std.crypto.aes.armcrypto.KeySchedule.invert
函数
反转密钥编排。
pub fn invert(key_schedule: Self) Self
参数
key_schedule: Self
std.crypto.aes.armcrypto.KeySchedule.mask1
常量
std.crypto.aes.armcrypto.KeySchedule.mask2
常量
std.crypto.aes.armcrypto.KeySchedule.Repr
常量
std.crypto.aes.armcrypto.KeySchedule.Self
别名
std.crypto.aes.armcrypto.KeySchedule.zero
常量
std.crypto.aes.armcrypto.mem
别名
别名目标 std.mem
std.crypto.aes.armcrypto.std
别名
别名目标 std
源码
std/crypto/aes/armcrypto.zig
const std = @import("../../std.zig");
const mem = std.mem;
const debug = std.debug;
/// 单个 AES 数据块。
pub const Block = struct {
const Repr = @Vector(2, u64);
pub const block_length: usize = 16;
/// 数据分组的内部表示。
repr: Repr,
/// 将字节序列转换为内部表示。
pub fn fromBytes(bytes: *const [16]u8) Block {
const repr = mem.bytesToValue(Repr, bytes);
return Block{ .repr = repr };
}
/// 将数据块的内部表示转换为字节序列。
pub fn toBytes(block: Block) [16]u8 {
return mem.toBytes(block.repr);
}
/// 将该块与字节序列异或。
pub fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
const x = block.repr ^ fromBytes(bytes).repr;
return mem.toBytes(x);
}
const zero = @Vector(2, u64){ 0, 0 };
/// 使用轮密钥加密一个块。
pub fn encrypt(block: Block, round_key: Block) Block {
return Block{
.repr = (asm (
\\ mov %[out].16b, %[in].16b
\\ aese %[out].16b, %[zero].16b
\\ aesmc %[out].16b, %[out].16b
: [out] "=&x" (-> Repr),
: [in] "x" (block.repr),
[zero] "x" (zero),
)) ^ round_key.repr,
};
}
/// 使用最后一轮的轮密钥加密一个分组。
pub fn encryptLast(block: Block, round_key: Block) Block {
return Block{
.repr = (asm (
\\ mov %[out].16b, %[in].16b
\\ aese %[out].16b, %[zero].16b
: [out] "=&x" (-> Repr),
: [in] "x" (block.repr),
[zero] "x" (zero),
)) ^ round_key.repr,
};
}
/// 用轮密钥解密一个块。
pub fn decrypt(block: Block, inv_round_key: Block) Block {
return Block{
.repr = (asm (
\\ mov %[out].16b, %[in].16b
\\ aesd %[out].16b, %[zero].16b
\\ aesimc %[out].16b, %[out].16b
: [out] "=&x" (-> Repr),
: [in] "x" (block.repr),
[zero] "x" (zero),
)) ^ inv_round_key.repr,
};
}
/// 使用最后一轮密钥解密一个块。
pub fn decryptLast(block: Block, inv_round_key: Block) Block {
return Block{
.repr = (asm (
\\ mov %[out].16b, %[in].16b
\\ aesd %[out].16b, %[zero].16b
: [out] "=&x" (-> Repr),
: [in] "x" (block.repr),
[zero] "x" (zero),
)) ^ inv_round_key.repr,
};
}
/// 对两个数据块的内容应用按位异或操作。
pub fn xorBlocks(block1: Block, block2: Block) Block {
return Block{ .repr = block1.repr ^ block2.repr };
}
/// 对两个块的内容应用按位与操作。
pub fn andBlocks(block1: Block, block2: Block) Block {
return Block{ .repr = block1.repr & block2.repr };
}
/// 对两个块的内容执行按位或操作。
pub fn orBlocks(block1: Block, block2: Block) Block {
return Block{ .repr = block1.repr | block2.repr };
}
/// 对一个块应用逆 MixColumns 运算。
pub fn invMixColumns(block: Block) Block {
return Block{
.repr = asm (
\\ aesimc %[out].16b, %[in].16b
: [out] "=x" (-> Repr),
: [in] "x" (block.repr),
),
};
}
/// 并行处理多个块。
pub const parallel = struct {
/// 对所选实现,建议并行执行的 AES 加密/解密次数。
pub const optimal_parallel_blocks = 6;
/// 并行加密多个块,每个块使用各自的轮密钥。
pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encrypt(round_keys[i]);
}
return out;
}
/// 并行解密多个数据块,各自使用自己的轮密钥。
pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decrypt(round_keys[i]);
}
return out;
}
/// 使用同一个轮密钥并行加密多个数据块。
pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encrypt(round_key);
}
return out;
}
/// 使用同一轮密钥并行解密多个块。
pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decrypt(round_key);
}
return out;
}
/// 使用相同的最后一轮密钥并行加密多个块。
pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encryptLast(round_key);
}
return out;
}
/// 使用同一个末轮密钥并行解密多个数据块。
pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decryptLast(round_key);
}
return out;
}
};
};
/// 固定大小的 AES 块向量。
/// 所有操作均并行执行,在可用时使用 SIMD 指令。
pub fn BlockVec(comptime blocks_count: comptime_int) type {
return struct {
const Self = @This();
/// 目标架构可通过单条指令处理的 AES 块数量。
pub const native_vector_size = 1;
/// 目标架构可用单条指令处理的 AES 块向量大小,以字节为单位。
pub const native_word_size = native_vector_size * 16;
const native_words = blocks_count;
/// 分组向量的内部表示。
repr: [native_words]Block,
/// 分组向量的长度,单位为字节。
pub const block_length: usize = blocks_count * 16;
/// 将字节序列转换为内部表示。
pub fn fromBytes(bytes: *const [blocks_count * 16]u8) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = Block.fromBytes(bytes[i * native_word_size ..][0..native_word_size]);
}
return out;
}
/// 将块向量的内部表示转换为字节序列。
pub fn toBytes(block_vec: Self) [blocks_count * 16]u8 {
var out: [blocks_count * 16]u8 = undefined;
inline for (0..native_words) |i| {
out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].toBytes();
}
return out;
}
/// 将块向量与字节序列异或。
pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8 {
var out: [blocks_count * 16]u8 = undefined;
inline for (0..native_words) |i| {
out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
}
return out;
}
/// 使用轮密钥向量,对块向量应用正向 AES 运算。
pub fn encrypt(block_vec: Self, round_key_vec: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec.repr[i].encrypt(round_key_vec.repr[i]);
}
return out;
}
/// 使用最后一轮密钥向量,对块向量执行正向 AES 操作。
pub fn encryptLast(block_vec: Self, round_key_vec: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec.repr[i].encryptLast(round_key_vec.repr[i]);
}
return out;
}
/// 使用轮密钥向量,对块向量执行逆 AES 操作。
pub fn decrypt(block_vec: Self, inv_round_key_vec: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec.repr[i].decrypt(inv_round_key_vec.repr[i]);
}
return out;
}
/// 使用末轮密钥向量,对块向量应用逆 AES 操作。
pub fn decryptLast(block_vec: Self, inv_round_key_vec: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec.repr[i].decryptLast(inv_round_key_vec.repr[i]);
}
return out;
}
/// 对两个块向量的内容应用按位异或操作。
pub fn xorBlocks(block_vec1: Self, block_vec2: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec1.repr[i].xorBlocks(block_vec2.repr[i]);
}
return out;
}
/// 对两个块向量的内容执行按位与。
pub fn andBlocks(block_vec1: Self, block_vec2: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec1.repr[i].andBlocks(block_vec2.repr[i]);
}
return out;
}
/// 对两个块向量的内容应用按位或操作。
pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec1.repr[i].orBlocks(block_vec2.repr[i]);
}
return out;
}
/// 对向量中的每个块应用逆 MixColumns 运算。
pub fn invMixColumns(block_vec: Self) Self {
var out: Self = undefined;
inline for (0..native_words) |i| {
out.repr[i] = block_vec.repr[i].invMixColumns();
}
return out;
}
};
}
fn KeySchedule(comptime Aes: type) type {
std.debug.assert(Aes.rounds == 10 or Aes.rounds == 14);
const rounds = Aes.rounds;
return struct {
const Self = @This();
const Repr = Aes.block.Repr;
const zero = @Vector(2, u64){ 0, 0 };
const mask1 = @Vector(16, u8){ 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12 };
const mask2 = @Vector(16, u8){ 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15 };
round_keys: [rounds + 1]Block,
fn drc128(comptime rc: u8, t: Repr) Repr {
var v1: Repr = undefined;
var v2: Repr = undefined;
var v3: Repr = undefined;
var v4: Repr = undefined;
return asm (
\\ movi %[v2].4s, %[rc]
\\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
\\ ext %[r].16b, %[zero].16b, %[t].16b, #12
\\ aese %[v4].16b, %[zero].16b
\\ eor %[v2].16b, %[r].16b, %[v2].16b
\\ ext %[r].16b, %[zero].16b, %[r].16b, #12
\\ eor %[v1].16b, %[v2].16b, %[t].16b
\\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
\\ eor %[v1].16b, %[v1].16b, %[r].16b
\\ eor %[r].16b, %[v1].16b, %[v3].16b
\\ eor %[r].16b, %[r].16b, %[v4].16b
: [r] "=&x" (-> Repr),
[v1] "=&x" (v1),
[v2] "=&x" (v2),
[v3] "=&x" (v3),
[v4] "=&x" (v4),
: [rc] "N" (rc),
[t] "x" (t),
[zero] "x" (zero),
[mask] "x" (mask1),
);
}
fn drc256(comptime second: bool, comptime rc: u8, t: Repr, tx: Repr) Repr {
var v1: Repr = undefined;
var v2: Repr = undefined;
var v3: Repr = undefined;
var v4: Repr = undefined;
return asm (
\\ movi %[v2].4s, %[rc]
\\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
\\ ext %[r].16b, %[zero].16b, %[tx].16b, #12
\\ aese %[v4].16b, %[zero].16b
\\ eor %[v1].16b, %[tx].16b, %[r].16b
\\ ext %[r].16b, %[zero].16b, %[r].16b, #12
\\ eor %[v1].16b, %[v1].16b, %[r].16b
\\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
\\ eor %[v1].16b, %[v1].16b, %[v2].16b
\\ eor %[v1].16b, %[v1].16b, %[v3].16b
\\ eor %[r].16b, %[v1].16b, %[v4].16b
: [r] "=&x" (-> Repr),
[v1] "=&x" (v1),
[v2] "=&x" (v2),
[v3] "=&x" (v3),
[v4] "=&x" (v4),
: [rc] "N" (if (second) @as(u8, 0) else rc),
[t] "x" (t),
[tx] "x" (tx),
[zero] "x" (zero),
[mask] "x" (if (second) mask2 else mask1),
);
}
fn expand128(t1: *Block) Self {
var round_keys: [11]Block = undefined;
const rcs = [_]u8{ 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 };
inline for (rcs, 0..) |rc, round| {
round_keys[round] = t1.*;
t1.repr = drc128(rc, t1.repr);
}
round_keys[rcs.len] = t1.*;
return Self{ .round_keys = round_keys };
}
fn expand256(t1: *Block, t2: *Block) Self {
var round_keys: [15]Block = undefined;
const rcs = [_]u8{ 1, 2, 4, 8, 16, 32 };
round_keys[0] = t1.*;
inline for (rcs, 0..) |rc, round| {
round_keys[round * 2 + 1] = t2.*;
t1.repr = drc256(false, rc, t2.repr, t1.repr);
round_keys[round * 2 + 2] = t1.*;
t2.repr = drc256(true, rc, t1.repr, t2.repr);
}
round_keys[rcs.len * 2 + 1] = t2.*;
t1.repr = drc256(false, 64, t2.repr, t1.repr);
round_keys[rcs.len * 2 + 2] = t1.*;
return Self{ .round_keys = round_keys };
}
/// 反转密钥编排。
pub fn invert(key_schedule: Self) Self {
const round_keys = &key_schedule.round_keys;
var inv_round_keys: [rounds + 1]Block = undefined;
inv_round_keys[0] = round_keys[rounds];
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
inv_round_keys[i] = Block{
.repr = asm (
\\ aesimc %[inv_rk].16b, %[rk].16b
: [inv_rk] "=x" (-> Repr),
: [rk] "x" (round_keys[rounds - i].repr),
),
};
}
inv_round_keys[rounds] = round_keys[0];
return Self{ .round_keys = inv_round_keys };
}
};
}
/// 使用标准 AES 密钥扩展进行加密的上下文。
pub fn AesEncryptCtx(comptime Aes: type) type {
std.debug.assert(Aes.key_bits == 128 or Aes.key_bits == 256);
const rounds = Aes.rounds;
return struct {
const Self = @This();
pub const block = Aes.block;
pub const block_length = block.block_length;
key_schedule: KeySchedule(Aes),
/// 使用给定密钥创建新的加密上下文。
pub fn init(key: [Aes.key_bits / 8]u8) Self {
var t1 = Block.fromBytes(key[0..16]);
const key_schedule = if (Aes.key_bits == 128) ks: {
break :ks KeySchedule(Aes).expand128(&t1);
} else ks: {
var t2 = Block.fromBytes(key[16..32]);
break :ks KeySchedule(Aes).expand256(&t1, &t2);
};
return Self{
.key_schedule = key_schedule,
};
}
/// 加密单个数据块。
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
}
t = t.encryptLast(round_keys[rounds]);
dst.* = t.toBytes();
}
/// 对单个块执行加密和异或。
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
}
t = t.encryptLast(round_keys[rounds]);
dst.* = t.xorBytes(src);
}
/// 加密多个块,可能利用并行处理。
pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
}
ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
}
}
/// 对多个块执行加密及异或,可能利用并行处理。
pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
}
ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].xorBytes(src[16 * j .. 16 * j + 16]);
}
}
};
}
/// 使用标准 AES 密钥调度进行解密的上下文。
pub fn AesDecryptCtx(comptime Aes: type) type {
std.debug.assert(Aes.key_bits == 128 or Aes.key_bits == 256);
const rounds = Aes.rounds;
return struct {
const Self = @This();
pub const block = Aes.block;
pub const block_length = block.block_length;
key_schedule: KeySchedule(Aes),
/// 从现有加密上下文创建解密上下文。
pub fn initFromEnc(ctx: AesEncryptCtx(Aes)) Self {
return Self{
.key_schedule = ctx.key_schedule.invert(),
};
}
/// 使用给定密钥创建新的解密上下文。
pub fn init(key: [Aes.key_bits / 8]u8) Self {
const enc_ctx = AesEncryptCtx(Aes).init(key);
return initFromEnc(enc_ctx);
}
/// 解密单个数据块。
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.decrypt(inv_round_keys[i]);
}
t = t.decryptLast(inv_round_keys[rounds]);
dst.* = t.toBytes();
}
/// 解密多个数据块,可能利用并行处理。
pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
}
ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
}
}
};
}
/// 采用标准密钥扩展的 AES-128。
pub const Aes128 = struct {
pub const key_bits: usize = 128;
pub const rounds = ((key_bits - 64) / 32 + 8);
pub const block = Block;
/// 创建新的加密上下文。
pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes128) {
return AesEncryptCtx(Aes128).init(key);
}
/// 创建新的解密上下文。
pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes128) {
return AesDecryptCtx(Aes128).init(key);
}
};
/// 采用标准密钥编排的 AES-256。
pub const Aes256 = struct {
pub const key_bits: usize = 256;
pub const rounds = ((key_bits - 64) / 32 + 8);
pub const block = Block;
/// 创建新的加密上下文。
pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes256) {
return AesEncryptCtx(Aes256).init(key);
}
/// 创建新的解密上下文。
pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes256) {
return AesDecryptCtx(Aes256).init(key);
}
};