跳转到内容

std.crypto.aegis

标准库Zig 0.17.0官方原文
源码std/crypto/aegis.zig

第 1 行

AEGIS 是基于 AES 核心函数构建的高速认证加密系统。

AEGIS-128* 变体使用 128 位密钥和 128 位 nonce。 AEGIS-256* 变体使用 256 位密钥和 256 位 nonce。 所有变体都可以计算 128 位和 256 位认证标签。

借助可并行执行 AES 块加密的硬件支持,AEGIS 密码族的性能显著高于 AES-GCM。

在支持 AVX-512 的高端 Intel 处理器上,AEGIS-128X4 和 AEGIS-256X4 最快。 在其他现代服务器、桌面和移动处理器上,AEGIS-128X2 和 AEGIS-256X2 通常最快。 AEGIS-128L 和 AEGIS-256 在包括 WebAssembly 在内的广泛平台上表现良好。

与 AES-GCM 不同,使用 AEGIS-256* 时可安全地随机选取 nonce,且没有实际使用中的数量限制。 使用随机 nonce 时,AEGIS-128* 也允许安全加密更多消息。

除非攻击者能够完全控制关联数据,否则通常认为 AEGIS 具有密钥承诺性,因此当密钥熵较低或可能由攻击者控制时,它比多数其他 AEAD 更安全。

最后,状态泄露不会导致密钥泄露。

https://www.rfc-editor.org/rfc/rfc10032.html

std.crypto.aegis.Aegis128L

类型

第 35 行

带 128 位标签的 AEGIS-128L

std.crypto.aegis.Aegis128L_256

类型

第 49 行

使用 256 位标签的 AEGIS-128L

std.crypto.aegis.Aegis128LMac

类型

第 681 行

Aegis128LMac 消息认证函数输出 256 位标签。 除速度极快之外,其大状态、非线性 和不可逆性还提供以下性质:

  • 128 位安全性,强于 GHash/Polyval/Poly1305。
  • 从状态恢复秘密密钥需要约 2^128 次尝试, 对任何现实攻击者都不可行。
  • 对内部碰撞具有很大的安全裕量。

std.crypto.aegis.Aegis128LMac_128

类型

第 723 行

采用 128 位标签的 AEGIS-128L MAC

std.crypto.aegis.Aegis128X2

类型

第 33 行

使用 128 位标签的 AEGIS-128X2

std.crypto.aegis.Aegis128X2_256

类型

第 47 行

采用 256 位标签的 AEGIS-128X2

std.crypto.aegis.Aegis128X2Mac

类型

第 672 行

Aegis128X2Mac 消息认证函数输出 256 位标签。 除速度极快外,其大状态、非线性 和不可逆性赋予其以下性质:

  • 128 位安全性,强于 GHash、Polyval、Poly1305。
  • 从状态恢复秘密密钥需要约 2^128 次尝试, 对任何实际攻击者都不可行。
  • 对内部碰撞具有较大的安全裕度。

std.crypto.aegis.Aegis128X2Mac_128

类型

第 720 行

采用 128 位标签的 AEGIS-128X2 MAC

std.crypto.aegis.Aegis128X4

类型

第 31 行

带 128 位标签的 AEGIS-128X4

std.crypto.aegis.Aegis128X4_256

类型

第 45 行

使用 256 位标签的 AEGIS-128X4

std.crypto.aegis.Aegis128X4Mac

类型

第 663 行

Aegis128X4Mac 消息认证函数输出 256 位标签。 除速度极快之外,其大状态、非线性 和不可逆性还提供以下性质:

  • 128 位安全性,强于 GHash/Polyval/Poly1305。
  • 从状态恢复秘密密钥需要约 2^128 次尝试, 对任何现实攻击者都不可行。
  • 对内部碰撞具有很大的安全裕量。

std.crypto.aegis.Aegis128X4Mac_128

类型

第 717 行

带 128 位标签的 AEGIS-128X4 消息认证码

std.crypto.aegis.Aegis128XGeneric

类型函数

第 274 行

AEGIS 是基于 AES 核心函数构建的高速认证加密系统。

AEGIS 的 128 位变体具有 128 位密钥和 128 位 nonce。

https://www.rfc-editor.org/rfc/rfc10032.html

fn Aegis128XGeneric(comptime degree: u7, comptime tag_bits: u9) type

参数

degree: u7
tag_bits: u9

std.crypto.aegis.Aegis128XGeneric.alignment

常量

第 286 行

std.crypto.aegis.Aegis128XGeneric.block_length

常量

第 284 行

std.crypto.aegis.Aegis128XGeneric.decrypt

函数

第 330 行

m:消息 c:密文 tag:认证标签 ad:关联数据 npub:公开 nonce k:私钥 断言 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

参数

m: []u8
c: []const u8
tag: [tag_length]u8
ad: []const u8
npub: [nonce_length]u8
key: [key_length]u8

错误

AuthenticationFailed AuthenticationError

std.crypto.aegis.Aegis128XGeneric.encrypt

函数

第 294 行

c:密文,输出缓冲区大小应为 m.len tag:认证标签,输出 MAC m:消息 ad:关联数据 npub:公开 nonce k:私钥

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.aegis.Aegis128XGeneric.key_length

常量

第 283 行

std.crypto.aegis.Aegis128XGeneric.nonce_length

常量

第 282 行

std.crypto.aegis.Aegis128XGeneric.State

类型

第 279 行

std.crypto.aegis.Aegis128XGeneric.tag_length

常量

第 281 行

std.crypto.aegis.Aegis256

类型

第 42 行

采用 128 位标签的 AEGIS-256

std.crypto.aegis.Aegis256_256

类型

第 56 行

使用 256 位标签的 AEGIS-256

std.crypto.aegis.Aegis256Mac

类型

第 714 行

Aegis256Mac 消息认证函数使用 256 位密钥,输出 256 位标签。 密钥大小是它与 Aegis128LMac 在实际使用中的主要区别。 AEGIS 的大状态、非线性和不可逆性提供以下属性:

  • 抵抗伪造的安全强度为 256 位。
  • 从状态恢复秘密密钥约需 2^256 次尝试,对任何实际攻击者都不可行。
  • 对内部碰撞具有较大的安全裕度。

std.crypto.aegis.Aegis256Mac_128

类型

第 732 行

采用 128 位标签的 AEGIS-256 MAC

std.crypto.aegis.Aegis256X2

类型

第 40 行

带 128 位标签的 AEGIS-256X2

std.crypto.aegis.Aegis256X2_256

类型

第 54 行

使用 256 位标签的 AEGIS-256X2

std.crypto.aegis.Aegis256X2Mac

类型

第 703 行

Aegis256X2Mac 消息认证函数使用 256 位密钥, 并输出 256 位标签。 密钥大小是其与 Aegis128X2Mac 的主要实际区别。 AEGIS 的大状态、非线性和不可逆性 赋予其以下性质:

  • 256 位抗伪造安全性。
  • 从状态恢复秘密密钥需要约 2^256 次尝试, 对任何实际攻击者都不可行。
  • 对内部碰撞具有较大的安全裕度。

std.crypto.aegis.Aegis256X2Mac_128

类型

第 729 行

带 128 位标签的 AEGIS-256X2 消息认证码

std.crypto.aegis.Aegis256X4

类型

第 38 行

采用 128 位标签的 AEGIS-256X4

std.crypto.aegis.Aegis256X4_256

类型

第 52 行

带 256 位标签的 AEGIS-256X4

std.crypto.aegis.Aegis256X4Mac

类型

第 692 行

Aegis256X4Mac 消息认证函数的密钥大小为 256 位, 输出 256 位标签。 密钥大小是它与 Aegis128X4Mac 在实践中的主要区别。 AEGIS 的大状态、非线性和不可逆性提供 以下性质:

  • 抵御伪造的安全强度为 256 位。
  • 从状态恢复秘密密钥需要约 2^256 次尝试, 对任何现实攻击者都不可行。
  • 对内部碰撞具有很大的安全裕量。

std.crypto.aegis.Aegis256X4Mac_128

类型

第 726 行

采用 128 位标签的 AEGIS-256X4 MAC

std.crypto.aegis.Aegis256XGeneric

类型函数

第 569 行

AEGIS 是基于 AES 核心函数构建的高速认证加密系统。

AEGIS 的 256 位变体使用 256 位密钥和 256 位 nonce。

https://www.rfc-editor.org/rfc/rfc10032.html

fn Aegis256XGeneric(comptime degree: u7, comptime tag_bits: u9) type

参数

degree: u7
tag_bits: u9

std.crypto.aegis.Aegis256XGeneric.alignment

常量

第 581 行

std.crypto.aegis.Aegis256XGeneric.block_length

常量

第 579 行

std.crypto.aegis.Aegis256XGeneric.decrypt

函数

第 625 行

m:消息 c:密文 tag:认证标签 ad:关联数据 npub:公开 nonce k:私钥 断言 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

参数

m: []u8
c: []const u8
tag: [tag_length]u8
ad: []const u8
npub: [nonce_length]u8
key: [key_length]u8

错误

AuthenticationFailed AuthenticationError

std.crypto.aegis.Aegis256XGeneric.encrypt

函数

第 589 行

c:密文,输出缓冲区大小应为 m.len tag:认证标签,输出 MAC m:消息 ad:关联数据 npub:公开 nonce k:私钥

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.aegis.Aegis256XGeneric.key_length

常量

第 578 行

std.crypto.aegis.Aegis256XGeneric.nonce_length

常量

第 577 行

std.crypto.aegis.Aegis256XGeneric.State

类型

第 574 行

std.crypto.aegis.Aegis256XGeneric.tag_length

常量

第 576 行

std.crypto.aegis.AegisMac

类型函数

第 734 行

fn AegisMac(comptime T: type) type

参数

T: type

字段

state: T.State
buf: [block_length]u8 = undefined
off: usize = 0
msg_len: usize = 0

std.crypto.aegis.AegisMac.block_length

常量

第 741 行

std.crypto.aegis.AegisMac.create

函数

第 811 行

返回消息和密钥的认证标签

pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void

参数

out: *[mac_length]u8
msg: []const u8
key: *const [key_length]u8

std.crypto.aegis.AegisMac.createWithNonce

函数

第 804 行

为给定消息、密钥和 nonce 返回认证标签

pub fn createWithNonce(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8, nonce: *const [nonce_length]u8) void

参数

out: *[mac_length]u8
msg: []const u8
key: *const [key_length]u8
nonce: *const [nonce_length]u8

std.crypto.aegis.AegisMac.final

函数

第 788 行

返回当前状态的认证标签

pub fn final(self: *Mac, out: *[mac_length]u8) void

参数

self: *Mac
out: *[mac_length]u8

std.crypto.aegis.AegisMac.finalResult

函数

第 797 行

pub fn finalResult(d: *Mac) [mac_length]u8

参数

d: *Mac

std.crypto.aegis.AegisMac.init

函数

第 756 行

使用默认 nonce 初始化 MAC 函数的状态

pub fn init(key: *const [key_length]u8) Mac

参数

key: *const [key_length]u8

std.crypto.aegis.AegisMac.initWithNonce

函数

第 749 行

使用密钥和 nonce 初始化 MAC 函数状态

pub fn initWithNonce(key: *const [key_length]u8, nonce: *const [nonce_length]u8) Mac

参数

key: *const [key_length]u8
nonce: *const [nonce_length]u8

std.crypto.aegis.AegisMac.key_length

常量

第 739 行

std.crypto.aegis.AegisMac.Mac

别名

第 736 行

别名目标 std.crypto.aegis.AegisMac

std.crypto.aegis.AegisMac.mac_length

常量

第 738 行

std.crypto.aegis.AegisMac.nonce_length

常量

第 740 行

std.crypto.aegis.AegisMac.update

函数

第 761 行

将数据添加到状态

pub fn update(self: *Mac, b: []const u8) void

参数

self: *Mac
b: []const u8

std.crypto.aegis.assert

别名

第 27 行

别名目标 std.debug.assert

std.crypto.aegis.AuthenticationError

别名

第 28 行

别名目标 std.crypto.errors.AuthenticationError

std.crypto.aegis.crypto

别名

第 25 行

别名目标 std.crypto

std.crypto.aegis.htest

常量

第 819 行

std.crypto.aegis.mem

别名

第 26 行

别名目标 std.mem

std.crypto.aegis.repeat16u8

函数

第 60 行

使用 inline 避免泛型实例化造成无谓的二进制膨胀,因为参数通常在编译期已知,且此函数是简单叶函数。

inline fn repeat16u8(comptime count: usize, part: [16]u8) [16 * count]u8

参数

count: usize
part: [16]u8

std.crypto.aegis.State128X

类型函数

第 66 行

fn State128X(comptime degree: u7) type

参数

degree: u7

字段

blocks: [8]AesBlockVec

std.crypto.aegis.State128X.absorb

函数

第 127 行

fn absorb(state: *State, src: *const [rate]u8) void

参数

state: *State
src: *const [rate]u8

std.crypto.aegis.State128X.aes_block_length

常量

第 73 行

std.crypto.aegis.State128X.AesBlockVec

常量

第 68 行

std.crypto.aegis.State128X.alignment

常量

第 75 行

std.crypto.aegis.State128X.dec

函数

第 146 行

fn dec(state: *State, dst: *[rate]u8, src: *const [rate]u8) void

参数

state: *State
dst: *[rate]u8
src: *const [rate]u8

std.crypto.aegis.State128X.decLast

函数

第 157 行

fn decLast(state: *State, dst: []u8, src: []const u8) void

参数

state: *State
dst: []u8
src: []const u8

std.crypto.aegis.State128X.enc

函数

第 133 行

fn enc(state: *State, dst: *[rate]u8, src: *const [rate]u8) void

参数

state: *State
dst: *[rate]u8
src: *const [rate]u8

std.crypto.aegis.State128X.finalize

函数

第 172 行

fn finalize(state: *State, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8

参数

state: *State
tag_bits: u9
adlen: usize
mlen: usize

std.crypto.aegis.State128X.finalizeMac

函数

第 212 行

fn finalizeMac(state: *State, comptime tag_bits: u9, datalen: usize) [tag_bits / 8]u8

参数

state: *State
tag_bits: u9
datalen: usize

std.crypto.aegis.State128X.init

函数

第 77 行

fn init(key: [16]u8, nonce: [16]u8) State

参数

key: [16]u8
nonce: [16]u8

std.crypto.aegis.State128X.rate

常量

第 74 行

std.crypto.aegis.State128X.State

别名

第 69 行

别名目标 std.crypto.aegis.State128X

std.crypto.aegis.State128X.update

函数

第 115 行

fn update(state: *State, d1: AesBlockVec, d2: AesBlockVec) void

参数

state: *State
d1: AesBlockVec
d2: AesBlockVec

std.crypto.aegis.State256X

类型函数

第 361 行

fn State256X(comptime degree: u7) type

参数

degree: u7

字段

blocks: [6]AesBlockVec

std.crypto.aegis.State256X.absorb

函数

第 434 行

fn absorb(state: *State, src: *const [rate]u8) void

参数

state: *State
src: *const [rate]u8

std.crypto.aegis.State256X.aes_block_length

常量

第 368 行

std.crypto.aegis.State256X.AesBlockVec

常量

第 363 行

std.crypto.aegis.State256X.alignment

常量

第 370 行

std.crypto.aegis.State256X.dec

函数

第 448 行

fn dec(state: *State, dst: *[rate]u8, src: *const [rate]u8) void

参数

state: *State
dst: *[rate]u8
src: *const [rate]u8

std.crypto.aegis.State256X.decLast

函数

第 456 行

fn decLast(state: *State, dst: []u8, src: []const u8) void

参数

state: *State
dst: []u8
src: []const u8

std.crypto.aegis.State256X.enc

函数

第 439 行

fn enc(state: *State, dst: *[rate]u8, src: *const [rate]u8) void

参数

state: *State
dst: *[rate]u8
src: *const [rate]u8

std.crypto.aegis.State256X.finalize

函数

第 467 行

fn finalize(state: *State, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8

参数

state: *State
tag_bits: u9
adlen: usize
mlen: usize

std.crypto.aegis.State256X.finalizeMac

函数

第 507 行

fn finalizeMac(state: *State, comptime tag_bits: u9, datalen: usize) [tag_bits / 8]u8

参数

state: *State
tag_bits: u9
datalen: usize

std.crypto.aegis.State256X.init

函数

第 372 行

fn init(key: [32]u8, nonce: [32]u8) State

参数

key: [32]u8
nonce: [32]u8

std.crypto.aegis.State256X.rate

别名

第 369 行

别名目标 std.crypto.aegis.State256X.aes_block_length

std.crypto.aegis.State256X.State

别名

第 364 行

别名目标 std.crypto.aegis.State256X

std.crypto.aegis.State256X.update

函数

第 424 行

fn update(state: *State, d: AesBlockVec) void

参数

state: *State
d: AesBlockVec

std.crypto.aegis.std

别名

第 24 行

别名目标 std

std.crypto.aegis.testing

别名

第 820 行

别名目标 std.testing

源码

std/crypto/aegis.zig

//! AEGIS 是基于 AES 核心函数构建的高速认证加密系统。
//!
//! AEGIS-128* 变体使用 128 位密钥和 128 位 nonce。
//! AEGIS-256* 变体使用 256 位密钥和 256 位 nonce。
//! 所有变体都可以计算 128 位和 256 位认证标签。
//!
//! 借助可并行执行 AES 块加密的硬件支持,AEGIS 密码族的性能显著高于 AES-GCM。
//!
//! 在支持 AVX-512 的高端 Intel 处理器上,AEGIS-128X4 和 AEGIS-256X4 最快。
//! 在其他现代服务器、桌面和移动处理器上,AEGIS-128X2 和 AEGIS-256X2 通常最快。
//! AEGIS-128L 和 AEGIS-256 在包括 WebAssembly 在内的广泛平台上表现良好。
//!
//! 与 AES-GCM 不同,使用 AEGIS-256* 时可安全地随机选取 nonce,且没有实际使用中的数量限制。
//! 使用随机 nonce 时,AEGIS-128* 也允许安全加密更多消息。
//!
//! 除非攻击者能够完全控制关联数据,否则通常认为 AEGIS 具有密钥承诺性,因此当密钥熵较低或可能由攻击者控制时,它比多数其他 AEAD 更安全。
//!
//! 最后,状态泄露不会导致密钥泄露。
//!
//! https://www.rfc-editor.org/rfc/rfc10032.html
//!
//!

const std = @import("std");
const crypto = std.crypto;
const mem = std.mem;
const assert = std.debug.assert;
const AuthenticationError = crypto.errors.AuthenticationError;

/// 带 128 位标签的 AEGIS-128X4
pub const Aegis128X4 = Aegis128XGeneric(4, 128);
/// 使用 128 位标签的 AEGIS-128X2
pub const Aegis128X2 = Aegis128XGeneric(2, 128);
/// 带 128 位标签的 AEGIS-128L
pub const Aegis128L = Aegis128XGeneric(1, 128);

/// 采用 128 位标签的 AEGIS-256X4
pub const Aegis256X4 = Aegis256XGeneric(4, 128);
/// 带 128 位标签的 AEGIS-256X2
pub const Aegis256X2 = Aegis256XGeneric(2, 128);
/// 采用 128 位标签的 AEGIS-256
pub const Aegis256 = Aegis256XGeneric(1, 128);

/// 使用 256 位标签的 AEGIS-128X4
pub const Aegis128X4_256 = Aegis128XGeneric(4, 256);
/// 采用 256 位标签的 AEGIS-128X2
pub const Aegis128X2_256 = Aegis128XGeneric(2, 256);
/// 使用 256 位标签的 AEGIS-128L
pub const Aegis128L_256 = Aegis128XGeneric(1, 256);

/// 带 256 位标签的 AEGIS-256X4
pub const Aegis256X4_256 = Aegis256XGeneric(4, 256);
/// 使用 256 位标签的 AEGIS-256X2
pub const Aegis256X2_256 = Aegis256XGeneric(2, 256);
/// 使用 256 位标签的 AEGIS-256
pub const Aegis256_256 = Aegis256XGeneric(1, 256);

/// 使用 `inline` 避免泛型实例化造成无谓的二进制膨胀,因为参数通常在编译期已知,且此函数是简单叶函数。
///
inline fn repeat16u8(comptime count: usize, part: [16]u8) [16 * count]u8 {
    const buf: [count][part.len]u8 = @splat(part);
    const ptr: *const [16 * count]u8 = @ptrCast(&buf);
    return ptr.*;
}

fn State128X(comptime degree: u7) type {
    return struct {
        const AesBlockVec = crypto.core.aes.BlockVec(degree);
        const State = @This();

        blocks: [8]AesBlockVec,

        const aes_block_length = AesBlockVec.block_length;
        const rate = aes_block_length * 2;
        const alignment = AesBlockVec.native_word_size;

        fn init(key: [16]u8, nonce: [16]u8) State {
            const c1 = AesBlockVec.fromBytes(&repeat16u8(degree, .{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd }));
            const c2 = AesBlockVec.fromBytes(&repeat16u8(degree, .{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 }));
            const key_block = AesBlockVec.fromBytes(&repeat16u8(degree, key));
            const nonce_block = AesBlockVec.fromBytes(&repeat16u8(degree, nonce));
            const blocks = [8]AesBlockVec{
                key_block.xorBlocks(nonce_block),
                c1,
                c2,
                c1,
                key_block.xorBlocks(nonce_block),
                key_block.xorBlocks(c2),
                key_block.xorBlocks(c1),
                key_block.xorBlocks(c2),
            };
            var state = State{ .blocks = blocks };
            if (degree > 1) {
                const context_block = ctx: {
                    var contexts_bytes: [aes_block_length]u8 = @splat(0);
                    for (0..degree) |i| {
                        contexts_bytes[i * 16] = @intCast(i);
                        contexts_bytes[i * 16 + 1] = @intCast(degree - 1);
                    }
                    break :ctx AesBlockVec.fromBytes(&contexts_bytes);
                };
                for (0..10) |_| {
                    state.blocks[3] = state.blocks[3].xorBlocks(context_block);
                    state.blocks[7] = state.blocks[7].xorBlocks(context_block);
                    state.update(nonce_block, key_block);
                }
            } else {
                for (0..10) |_| {
                    state.update(nonce_block, key_block);
                }
            }
            return state;
        }

        fn update(state: *State, d1: AesBlockVec, d2: AesBlockVec) void {
            const blocks = &state.blocks;
            const tmp = blocks[7];
            comptime var i: usize = 7;
            inline while (i > 0) : (i -= 1) {
                blocks[i] = blocks[i - 1].encrypt(blocks[i]);
            }
            blocks[0] = tmp.encrypt(blocks[0]);
            blocks[0] = blocks[0].xorBlocks(d1);
            blocks[4] = blocks[4].xorBlocks(d2);
        }

        fn absorb(state: *State, src: *const [rate]u8) void {
            const msg0 = AesBlockVec.fromBytes(src[0..aes_block_length]);
            const msg1 = AesBlockVec.fromBytes(src[aes_block_length..rate]);
            state.update(msg0, msg1);
        }

        fn enc(state: *State, dst: *[rate]u8, src: *const [rate]u8) void {
            const blocks = &state.blocks;
            const msg0 = AesBlockVec.fromBytes(src[0..aes_block_length]);
            const msg1 = AesBlockVec.fromBytes(src[aes_block_length..rate]);
            var tmp0 = msg0.xorBlocks(blocks[6]).xorBlocks(blocks[1]);
            var tmp1 = msg1.xorBlocks(blocks[2]).xorBlocks(blocks[5]);
            tmp0 = tmp0.xorBlocks(blocks[2].andBlocks(blocks[3]));
            tmp1 = tmp1.xorBlocks(blocks[6].andBlocks(blocks[7]));
            dst[0..aes_block_length].* = tmp0.toBytes();
            dst[aes_block_length..rate].* = tmp1.toBytes();
            state.update(msg0, msg1);
        }

        fn dec(state: *State, dst: *[rate]u8, src: *const [rate]u8) void {
            const blocks = &state.blocks;
            var msg0 = AesBlockVec.fromBytes(src[0..aes_block_length]).xorBlocks(blocks[6]).xorBlocks(blocks[1]);
            var msg1 = AesBlockVec.fromBytes(src[aes_block_length..rate]).xorBlocks(blocks[2]).xorBlocks(blocks[5]);
            msg0 = msg0.xorBlocks(blocks[2].andBlocks(blocks[3]));
            msg1 = msg1.xorBlocks(blocks[6].andBlocks(blocks[7]));
            dst[0..aes_block_length].* = msg0.toBytes();
            dst[aes_block_length..rate].* = msg1.toBytes();
            state.update(msg0, msg1);
        }

        fn decLast(state: *State, dst: []u8, src: []const u8) void {
            const blocks = &state.blocks;
            const z0 = blocks[6].xorBlocks(blocks[1]).xorBlocks(blocks[2].andBlocks(blocks[3]));
            const z1 = blocks[2].xorBlocks(blocks[5]).xorBlocks(blocks[6].andBlocks(blocks[7]));
            var pad: [rate]u8 = @splat(0);
            pad[0..aes_block_length].* = z0.toBytes();
            pad[aes_block_length..].* = z1.toBytes();
            for (pad[0..src.len], src) |*p, x| p.* ^= x;
            @memcpy(dst, pad[0..src.len]);
            @memset(pad[src.len..], 0);
            const msg0 = AesBlockVec.fromBytes(pad[0..aes_block_length]);
            const msg1 = AesBlockVec.fromBytes(pad[aes_block_length..rate]);
            state.update(msg0, msg1);
        }

        fn finalize(state: *State, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8 {
            const blocks = &state.blocks;
            var sizes: [aes_block_length]u8 = undefined;
            mem.writeInt(u64, sizes[0..8], @as(u64, adlen) * 8, .little);
            mem.writeInt(u64, sizes[8..16], @as(u64, mlen) * 8, .little);
            for (1..degree) |i| {
                @memcpy(sizes[i * 16 ..][0..16], sizes[0..16]);
            }
            const tmp = AesBlockVec.fromBytes(&sizes).xorBlocks(blocks[2]);
            for (0..7) |_| {
                state.update(tmp, tmp);
            }
            switch (tag_bits) {
                128 => {
                    var tag_multi = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).xorBlocks(blocks[6]).toBytes();
                    var tag = tag_multi[0..16].*;
                    @memcpy(tag[0..], tag_multi[0..16]);
                    for (1..degree) |d| {
                        for (0..16) |i| {
                            tag[i] ^= tag_multi[d * 16 + i];
                        }
                    }
                    return tag;
                },
                256 => {
                    const tag_multi_1 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).toBytes();
                    const tag_multi_2 = blocks[4].xorBlocks(blocks[5]).xorBlocks(blocks[6]).xorBlocks(blocks[7]).toBytes();
                    var tag = tag_multi_1[0..16].* ++ tag_multi_2[0..16].*;
                    for (1..degree) |d| {
                        for (0..16) |i| {
                            tag[i] ^= tag_multi_1[d * 16 + i];
                            tag[i + 16] ^= tag_multi_2[d * 16 + i];
                        }
                    }
                    return tag;
                },
                else => unreachable,
            }
        }

        fn finalizeMac(state: *State, comptime tag_bits: u9, datalen: usize) [tag_bits / 8]u8 {
            const blocks = &state.blocks;
            var sizes: [aes_block_length]u8 = undefined;
            mem.writeInt(u64, sizes[0..8], @as(u64, datalen) * 8, .little);
            mem.writeInt(u64, sizes[8..16], tag_bits, .little);
            for (1..degree) |i| {
                @memcpy(sizes[i * 16 ..][0..16], sizes[0..16]);
            }
            var t = blocks[2].xorBlocks(AesBlockVec.fromBytes(&sizes));
            for (0..7) |_| {
                state.update(t, t);
            }
            if (degree > 1) {
                var v: [rate]u8 = @splat(0);
                switch (tag_bits) {
                    128 => {
                        const tags = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).xorBlocks(blocks[6]).toBytes();
                        for (0..degree / 2) |d| {
                            v[0..16].* = tags[d * 32 ..][0..16].*;
                            v[rate / 2 ..][0..16].* = tags[d * 32 ..][16..32].*;
                            state.absorb(&v);
                        }
                    },
                    256 => {
                        const tags_0 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).toBytes();
                        const tags_1 = blocks[4].xorBlocks(blocks[5]).xorBlocks(blocks[6]).xorBlocks(blocks[7]).toBytes();
                        for (1..degree) |d| {
                            v[0..16].* = tags_0[d * 16 ..][0..16].*;
                            v[rate / 2 ..][0..16].* = tags_1[d * 16 ..][0..16].*;
                            state.absorb(&v);
                        }
                    },
                    else => unreachable,
                }
                mem.writeInt(u64, sizes[0..8], degree, .little);
                mem.writeInt(u64, sizes[8..16], tag_bits, .little);
                t = blocks[2].xorBlocks(AesBlockVec.fromBytes(&sizes));
                for (0..7) |_| {
                    state.update(t, t);
                }
            }
            switch (tag_bits) {
                128 => {
                    const tags = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).xorBlocks(blocks[6]).toBytes();
                    return tags[0..16].*;
                },
                256 => {
                    const tags_0 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).toBytes();
                    const tags_1 = blocks[4].xorBlocks(blocks[5]).xorBlocks(blocks[6]).xorBlocks(blocks[7]).toBytes();
                    return tags_0[0..16].* ++ tags_1[0..16].*;
                },
                else => unreachable,
            }
        }
    };
}

/// AEGIS 是基于 AES 核心函数构建的高速认证加密系统。
///
/// AEGIS 的 128 位变体具有 128 位密钥和 128 位 nonce。
///
/// https://www.rfc-editor.org/rfc/rfc10032.html
fn Aegis128XGeneric(comptime degree: u7, comptime tag_bits: u9) type {
    comptime assert(degree > 0); // 次数必须大于 0
    comptime assert(tag_bits == 128 or tag_bits == 256); // 标签必须为 128 位或 256 位

    return struct {
        const State = State128X(degree);

        pub const tag_length = tag_bits / 8;
        pub const nonce_length = 16;
        pub const key_length = 16;
        pub const block_length = State.rate;

        const alignment = State.alignment;

        /// c:密文,输出缓冲区大小应为 m.len
        /// tag:认证标签,输出 MAC
        /// m:消息
        /// ad:关联数据
        /// npub:公开 nonce
        /// k:私钥
        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);
            var state = State.init(key, npub);
            var src: [block_length]u8 align(alignment) = undefined;
            var dst: [block_length]u8 align(alignment) = undefined;
            var i: usize = 0;
            while (i + block_length <= ad.len) : (i += block_length) {
                state.absorb(ad[i..][0..block_length]);
            }
            if (ad.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. ad.len % block_length], ad[i..][0 .. ad.len % block_length]);
                state.absorb(&src);
            }
            i = 0;
            while (i + block_length <= m.len) : (i += block_length) {
                state.enc(c[i..][0..block_length], m[i..][0..block_length]);
            }
            if (m.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. m.len % block_length], m[i..][0 .. m.len % block_length]);
                state.enc(&dst, &src);
                @memcpy(c[i..][0 .. m.len % block_length], dst[0 .. m.len % block_length]);
            }
            tag.* = state.finalize(tag_bits, ad.len, m.len);
        }

        /// `m`:消息
        /// `c`:密文
        /// `tag`:认证标签
        /// `ad`:关联数据
        /// `npub`:公开 nonce
        /// `k`:私钥
        /// 断言 `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(c.len == m.len);
            var state = State.init(key, npub);
            var src: [block_length]u8 align(alignment) = undefined;
            var i: usize = 0;
            while (i + block_length <= ad.len) : (i += block_length) {
                state.absorb(ad[i..][0..block_length]);
            }
            if (ad.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. ad.len % block_length], ad[i..][0 .. ad.len % block_length]);
                state.absorb(&src);
            }
            i = 0;
            while (i + block_length <= m.len) : (i += block_length) {
                state.dec(m[i..][0..block_length], c[i..][0..block_length]);
            }
            if (m.len % block_length != 0) {
                state.decLast(m[i..], c[i..]);
            }
            var computed_tag = state.finalize(tag_bits, ad.len, m.len);
            const verify = crypto.timing_safe.eql([tag_length]u8, computed_tag, tag);
            if (!verify) {
                crypto.secureZero(u8, &computed_tag);
                @memset(m, undefined);
                return error.AuthenticationFailed;
            }
        }
    };
}

fn State256X(comptime degree: u7) type {
    return struct {
        const AesBlockVec = crypto.core.aes.BlockVec(degree);
        const State = @This();

        blocks: [6]AesBlockVec,

        const aes_block_length = AesBlockVec.block_length;
        const rate = aes_block_length;
        const alignment = AesBlockVec.native_word_size;

        fn init(key: [32]u8, nonce: [32]u8) State {
            const c1 = AesBlockVec.fromBytes(&repeat16u8(degree, .{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd }));
            const c2 = AesBlockVec.fromBytes(&repeat16u8(degree, .{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 }));
            const key_block1 = AesBlockVec.fromBytes(&repeat16u8(degree, key[0..16].*));
            const key_block2 = AesBlockVec.fromBytes(&repeat16u8(degree, key[16..32].*));
            const nonce_block1 = AesBlockVec.fromBytes(&repeat16u8(degree, nonce[0..16].*));
            const nonce_block2 = AesBlockVec.fromBytes(&repeat16u8(degree, nonce[16..32].*));
            const kxn1 = key_block1.xorBlocks(nonce_block1);
            const kxn2 = key_block2.xorBlocks(nonce_block2);
            const blocks = [6]AesBlockVec{
                kxn1,
                kxn2,
                c1,
                c2,
                key_block1.xorBlocks(c2),
                key_block2.xorBlocks(c1),
            };
            var state = State{ .blocks = blocks };
            if (degree > 1) {
                const context_block = ctx: {
                    var contexts_bytes: [aes_block_length]u8 = @splat(0);
                    for (0..degree) |i| {
                        contexts_bytes[i * 16] = @intCast(i);
                        contexts_bytes[i * 16 + 1] = @intCast(degree - 1);
                    }
                    break :ctx AesBlockVec.fromBytes(&contexts_bytes);
                };
                for (0..4) |_| {
                    state.blocks[3] = state.blocks[3].xorBlocks(context_block);
                    state.blocks[5] = state.blocks[5].xorBlocks(context_block);
                    state.update(key_block1);
                    state.blocks[3] = state.blocks[3].xorBlocks(context_block);
                    state.blocks[5] = state.blocks[5].xorBlocks(context_block);
                    state.update(key_block2);
                    state.blocks[3] = state.blocks[3].xorBlocks(context_block);
                    state.blocks[5] = state.blocks[5].xorBlocks(context_block);
                    state.update(kxn1);
                    state.blocks[3] = state.blocks[3].xorBlocks(context_block);
                    state.blocks[5] = state.blocks[5].xorBlocks(context_block);
                    state.update(kxn2);
                }
            } else {
                for (0..4) |_| {
                    state.update(key_block1);
                    state.update(key_block2);
                    state.update(kxn1);
                    state.update(kxn2);
                }
            }
            return state;
        }

        fn update(state: *State, d: AesBlockVec) void {
            const blocks = &state.blocks;
            const tmp = blocks[5].encrypt(blocks[0]);
            comptime var i: usize = 5;
            inline while (i > 0) : (i -= 1) {
                blocks[i] = blocks[i - 1].encrypt(blocks[i]);
            }
            blocks[0] = tmp.xorBlocks(d);
        }

        fn absorb(state: *State, src: *const [rate]u8) void {
            const msg = AesBlockVec.fromBytes(src);
            state.update(msg);
        }

        fn enc(state: *State, dst: *[rate]u8, src: *const [rate]u8) void {
            const blocks = &state.blocks;
            const msg = AesBlockVec.fromBytes(src);
            var tmp = msg.xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
            tmp = tmp.xorBlocks(blocks[2].andBlocks(blocks[3]));
            dst.* = tmp.toBytes();
            state.update(msg);
        }

        fn dec(state: *State, dst: *[rate]u8, src: *const [rate]u8) void {
            const blocks = &state.blocks;
            var msg = AesBlockVec.fromBytes(src).xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
            msg = msg.xorBlocks(blocks[2].andBlocks(blocks[3]));
            dst.* = msg.toBytes();
            state.update(msg);
        }

        fn decLast(state: *State, dst: []u8, src: []const u8) void {
            const blocks = &state.blocks;
            const z = blocks[5].xorBlocks(blocks[4]).xorBlocks(blocks[1]).xorBlocks(blocks[2].andBlocks(blocks[3]));
            var pad = z.toBytes();
            for (pad[0..src.len], src) |*p, x| p.* ^= x;
            @memcpy(dst, pad[0..src.len]);
            @memset(pad[src.len..], 0);
            const msg = AesBlockVec.fromBytes(pad[0..]);
            state.update(msg);
        }

        fn finalize(state: *State, comptime tag_bits: u9, adlen: usize, mlen: usize) [tag_bits / 8]u8 {
            const blocks = &state.blocks;
            var sizes: [aes_block_length]u8 = undefined;
            mem.writeInt(u64, sizes[0..8], @as(u64, adlen) * 8, .little);
            mem.writeInt(u64, sizes[8..16], @as(u64, mlen) * 8, .little);
            for (1..degree) |i| {
                @memcpy(sizes[i * 16 ..][0..16], sizes[0..16]);
            }
            const tmp = AesBlockVec.fromBytes(&sizes).xorBlocks(blocks[3]);
            for (0..7) |_| {
                state.update(tmp);
            }
            switch (tag_bits) {
                128 => {
                    var tag_multi = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                    var tag = tag_multi[0..16].*;
                    @memcpy(tag[0..], tag_multi[0..16]);
                    for (1..degree) |d| {
                        for (0..16) |i| {
                            tag[i] ^= tag_multi[d * 16 + i];
                        }
                    }
                    return tag;
                },
                256 => {
                    const tag_multi_1 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).toBytes();
                    const tag_multi_2 = blocks[3].xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                    var tag = tag_multi_1[0..16].* ++ tag_multi_2[0..16].*;
                    for (1..degree) |d| {
                        for (0..16) |i| {
                            tag[i] ^= tag_multi_1[d * 16 + i];
                            tag[i + 16] ^= tag_multi_2[d * 16 + i];
                        }
                    }
                    return tag;
                },
                else => unreachable,
            }
        }

        fn finalizeMac(state: *State, comptime tag_bits: u9, datalen: usize) [tag_bits / 8]u8 {
            const blocks = &state.blocks;
            var sizes: [aes_block_length]u8 = undefined;
            mem.writeInt(u64, sizes[0..8], @as(u64, datalen) * 8, .little);
            mem.writeInt(u64, sizes[8..16], tag_bits, .little);
            for (1..degree) |i| {
                @memcpy(sizes[i * 16 ..][0..16], sizes[0..16]);
            }
            var t = blocks[3].xorBlocks(AesBlockVec.fromBytes(&sizes));
            for (0..7) |_| {
                state.update(t);
            }
            if (degree > 1) {
                var v: [rate]u8 = @splat(0);
                switch (tag_bits) {
                    128 => {
                        const tags = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                        for (1..degree) |d| {
                            v[0..16].* = tags[d * 16 ..][0..16].*;
                            state.absorb(&v);
                        }
                    },
                    256 => {
                        const tags_0 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).toBytes();
                        const tags_1 = blocks[3].xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                        for (1..degree) |d| {
                            v[0..16].* = tags_0[d * 16 ..][0..16].*;
                            state.absorb(&v);
                            v[0..16].* = tags_1[d * 16 ..][0..16].*;
                            state.absorb(&v);
                        }
                    },
                    else => unreachable,
                }
                mem.writeInt(u64, sizes[0..8], degree, .little);
                mem.writeInt(u64, sizes[8..16], tag_bits, .little);
                t = blocks[3].xorBlocks(AesBlockVec.fromBytes(&sizes));
                for (0..7) |_| {
                    state.update(t);
                }
            }
            switch (tag_bits) {
                128 => {
                    const tags = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                    return tags[0..16].*;
                },
                256 => {
                    const tags_0 = blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).toBytes();
                    const tags_1 = blocks[3].xorBlocks(blocks[4]).xorBlocks(blocks[5]).toBytes();
                    return tags_0[0..16].* ++ tags_1[0..16].*;
                },
                else => unreachable,
            }
        }
    };
}

/// AEGIS 是基于 AES 核心函数构建的高速认证加密系统。
///
/// AEGIS 的 256 位变体使用 256 位密钥和 256 位 nonce。
///
/// https://www.rfc-editor.org/rfc/rfc10032.html
fn Aegis256XGeneric(comptime degree: u7, comptime tag_bits: u9) type {
    comptime assert(degree > 0); // 次数必须大于 0
    comptime assert(tag_bits == 128 or tag_bits == 256); // 标签必须为 128 位或 256 位

    return struct {
        const State = State256X(degree);

        pub const tag_length = tag_bits / 8;
        pub const nonce_length = 32;
        pub const key_length = 32;
        pub const block_length = State.rate;

        const alignment = State.alignment;

        /// c:密文,输出缓冲区大小应为 m.len
        /// tag:认证标签,输出 MAC
        /// m:消息
        /// ad:关联数据
        /// npub:公开 nonce
        /// k:私钥
        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);
            var state = State.init(key, npub);
            var src: [block_length]u8 align(alignment) = undefined;
            var dst: [block_length]u8 align(alignment) = undefined;
            var i: usize = 0;
            while (i + block_length <= ad.len) : (i += block_length) {
                state.absorb(ad[i..][0..block_length]);
            }
            if (ad.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. ad.len % block_length], ad[i..][0 .. ad.len % block_length]);
                state.absorb(&src);
            }
            i = 0;
            while (i + block_length <= m.len) : (i += block_length) {
                state.enc(c[i..][0..block_length], m[i..][0..block_length]);
            }
            if (m.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. m.len % block_length], m[i..][0 .. m.len % block_length]);
                state.enc(&dst, &src);
                @memcpy(c[i..][0 .. m.len % block_length], dst[0 .. m.len % block_length]);
            }
            tag.* = state.finalize(tag_bits, ad.len, m.len);
        }

        /// `m`:消息
        /// `c`:密文
        /// `tag`:认证标签
        /// `ad`:关联数据
        /// `npub`:公开 nonce
        /// `k`:私钥
        /// 断言 `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(c.len == m.len);
            var state = State.init(key, npub);
            var src: [block_length]u8 align(alignment) = undefined;
            var i: usize = 0;
            while (i + block_length <= ad.len) : (i += block_length) {
                state.absorb(ad[i..][0..block_length]);
            }
            if (ad.len % block_length != 0) {
                @memset(src[0..], 0);
                @memcpy(src[0 .. ad.len % block_length], ad[i..][0 .. ad.len % block_length]);
                state.absorb(&src);
            }
            i = 0;
            while (i + block_length <= m.len) : (i += block_length) {
                state.dec(m[i..][0..block_length], c[i..][0..block_length]);
            }
            if (m.len % block_length != 0) {
                state.decLast(m[i..], c[i..]);
            }
            var computed_tag = state.finalize(tag_bits, ad.len, m.len);
            const verify = crypto.timing_safe.eql([tag_length]u8, computed_tag, tag);
            if (!verify) {
                crypto.secureZero(u8, &computed_tag);
                @memset(m, undefined);
                return error.AuthenticationFailed;
            }
        }
    };
}

/// `Aegis128X4Mac` 消息认证函数输出 256 位标签。
/// 除速度极快之外,其大状态、非线性
/// 和不可逆性还提供以下性质:
/// - 128 位安全性,强于 GHash/Polyval/Poly1305。
/// - 从状态恢复秘密密钥需要约 2^128 次尝试,
///   对任何现实攻击者都不可行。
/// - 对内部碰撞具有很大的安全裕量。
pub const Aegis128X4Mac = AegisMac(Aegis128X4_256);

/// `Aegis128X2Mac` 消息认证函数输出 256 位标签。
/// 除速度极快外,其大状态、非线性
/// 和不可逆性赋予其以下性质:
/// - 128 位安全性,强于 GHash、Polyval、Poly1305。
/// - 从状态恢复秘密密钥需要约 2^128 次尝试,
///   对任何实际攻击者都不可行。
/// - 对内部碰撞具有较大的安全裕度。
pub const Aegis128X2Mac = AegisMac(Aegis128X2_256);

/// `Aegis128LMac` 消息认证函数输出 256 位标签。
/// 除速度极快之外,其大状态、非线性
/// 和不可逆性还提供以下性质:
/// - 128 位安全性,强于 GHash/Polyval/Poly1305。
/// - 从状态恢复秘密密钥需要约 2^128 次尝试,
///   对任何现实攻击者都不可行。
/// - 对内部碰撞具有很大的安全裕量。
pub const Aegis128LMac = AegisMac(Aegis128L_256);

/// `Aegis256X4Mac` 消息认证函数的密钥大小为 256 位,
/// 输出 256 位标签。
/// 密钥大小是它与 `Aegis128X4Mac` 在实践中的主要区别。
/// AEGIS 的大状态、非线性和不可逆性提供
/// 以下性质:
/// - 抵御伪造的安全强度为 256 位。
/// - 从状态恢复秘密密钥需要约 2^256 次尝试,
///   对任何现实攻击者都不可行。
/// - 对内部碰撞具有很大的安全裕量。
pub const Aegis256X4Mac = AegisMac(Aegis256X4_256);

/// `Aegis256X2Mac` 消息认证函数使用 256 位密钥,
/// 并输出 256 位标签。
/// 密钥大小是其与 `Aegis128X2Mac` 的主要实际区别。
/// AEGIS 的大状态、非线性和不可逆性
/// 赋予其以下性质:
/// - 256 位抗伪造安全性。
/// - 从状态恢复秘密密钥需要约 2^256 次尝试,
///   对任何实际攻击者都不可行。
/// - 对内部碰撞具有较大的安全裕度。
pub const Aegis256X2Mac = AegisMac(Aegis256X2_256);

/// `Aegis256Mac` 消息认证函数使用 256 位密钥,输出 256 位标签。
/// 密钥大小是它与 `Aegis128LMac` 在实际使用中的主要区别。
/// AEGIS 的大状态、非线性和不可逆性提供以下属性:
/// - 抵抗伪造的安全强度为 256 位。
/// - 从状态恢复秘密密钥约需 2^256 次尝试,对任何实际攻击者都不可行。
/// - 对内部碰撞具有较大的安全裕度。
///
///
///
pub const Aegis256Mac = AegisMac(Aegis256_256);

/// 带 128 位标签的 AEGIS-128X4 消息认证码
pub const Aegis128X4Mac_128 = AegisMac(Aegis128X4);

/// 采用 128 位标签的 AEGIS-128X2 MAC
pub const Aegis128X2Mac_128 = AegisMac(Aegis128X2);

/// 采用 128 位标签的 AEGIS-128L MAC
pub const Aegis128LMac_128 = AegisMac(Aegis128L);

/// 采用 128 位标签的 AEGIS-256X4 MAC
pub const Aegis256X4Mac_128 = AegisMac(Aegis256X4);

/// 带 128 位标签的 AEGIS-256X2 消息认证码
pub const Aegis256X2Mac_128 = AegisMac(Aegis256X2);

/// 采用 128 位标签的 AEGIS-256 MAC
pub const Aegis256Mac_128 = AegisMac(Aegis256);

fn AegisMac(comptime T: type) type {
    return struct {
        const Mac = @This();

        pub const mac_length = T.tag_length;
        pub const key_length = T.key_length;
        pub const nonce_length = T.nonce_length;
        pub const block_length = T.block_length;

        state: T.State,
        buf: [block_length]u8 = undefined,
        off: usize = 0,
        msg_len: usize = 0,

        /// 使用密钥和 nonce 初始化 MAC 函数状态
        pub fn initWithNonce(key: *const [key_length]u8, nonce: *const [nonce_length]u8) Mac {
            return Mac{
                .state = T.State.init(key.*, nonce.*),
            };
        }

        /// 使用默认 nonce 初始化 MAC 函数的状态
        pub fn init(key: *const [key_length]u8) Mac {
            return .{ .state = .init(key.*, @splat(0)) };
        }

        /// 将数据添加到状态
        pub fn update(self: *Mac, b: []const u8) void {
            self.msg_len += b.len;

            const len_partial = @min(b.len, block_length - self.off);
            @memcpy(self.buf[self.off..][0..len_partial], b[0..len_partial]);
            self.off += len_partial;
            if (self.off < block_length) {
                return;
            }
            self.state.absorb(&self.buf);

            var i = len_partial;
            self.off = 0;
            while (i + block_length * 2 <= b.len) : (i += block_length * 2) {
                self.state.absorb(b[i..][0..block_length]);
                self.state.absorb(b[i..][block_length .. block_length * 2]);
            }
            while (i + block_length <= b.len) : (i += block_length) {
                self.state.absorb(b[i..][0..block_length]);
            }
            if (i != b.len) {
                self.off = b.len - i;
                @memcpy(self.buf[0..self.off], b[i..]);
            }
        }

        /// 返回当前状态的认证标签
        pub fn final(self: *Mac, out: *[mac_length]u8) void {
            if (self.off > 0) {
                var pad: [block_length]u8 = @splat(0);
                @memcpy(pad[0..self.off], self.buf[0..self.off]);
                self.state.absorb(&pad);
            }
            out.* = self.state.finalizeMac(T.tag_length * 8, self.msg_len);
        }

        pub fn finalResult(d: *Mac) [mac_length]u8 {
            var result: [mac_length]u8 = undefined;
            d.final(&result);
            return result;
        }

        /// 为给定消息、密钥和 nonce 返回认证标签
        pub fn createWithNonce(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8, nonce: *const [nonce_length]u8) void {
            var ctx = Mac.initWithNonce(key, nonce);
            ctx.update(msg);
            ctx.final(out);
        }

        /// 返回消息和密钥的认证标签
        pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {
            var ctx = Mac.init(key);
            ctx.update(msg);
            ctx.final(out);
        }
    };
}

const htest = @import("test.zig");
const testing = std.testing;

test "Aegis128L test vector 1" {
    const key: [Aegis128L.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ @as([14]u8, @splat(0x00));
    const nonce: [Aegis128L.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ @as([13]u8, @splat(0x00));
    const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
    const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis128L.tag_length]u8 = undefined;

    Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c);
    try htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag);

    c[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));
    c[0] -%= 1;
    tag[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));
}

test "Aegis128L test vector 2" {
    const key: [Aegis128L.key_length]u8 = @splat(0x00);
    const nonce: [Aegis128L.nonce_length]u8 = @splat(0x00);
    const ad: [0]u8 = .{};
    const m: [16]u8 = @splat(0x00);
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis128L.tag_length]u8 = undefined;

    Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c);
    try htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag);
}

test "Aegis128L test vector 3" {
    const key: [Aegis128L.key_length]u8 = @splat(0x00);
    const nonce: [Aegis128L.nonce_length]u8 = @splat(0x00);
    const ad = [_]u8{};
    const m = [_]u8{};
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis128L.tag_length]u8 = undefined;

    Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag);
}

test "Aegis128X2 test vector 1" {
    const key: [Aegis128X2.key_length]u8 = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
    const nonce: [Aegis128X2.nonce_length]u8 = [_]u8{ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
    var empty = [_]u8{};
    var tag: [Aegis128X2.tag_length]u8 = undefined;
    var tag256: [Aegis128X2_256.tag_length]u8 = undefined;

    Aegis128X2.encrypt(&empty, &tag, &empty, &empty, nonce, key);
    Aegis128X2_256.encrypt(&empty, &tag256, &empty, &empty, nonce, key);
    try htest.assertEqual("63117dc57756e402819a82e13eca8379", &tag);
    try htest.assertEqual("b92c71fdbd358b8a4de70b27631ace90cffd9b9cfba82028412bac41b4f53759", &tag256);
    tag[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis128X2.decrypt(&empty, &empty, tag, &empty, nonce, key));
    tag256[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis128X2_256.decrypt(&empty, &empty, tag256, &empty, nonce, key));
}

test "Aegis256 test vector 1" {
    const key: [Aegis256.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ @as([30]u8, @splat(0x00));
    const nonce: [Aegis256.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ @as([29]u8, @splat(0x00));
    const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
    const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis256.tag_length]u8 = undefined;

    Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c);
    try htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag);

    c[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));
    c[0] -%= 1;
    tag[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));
}

test "Aegis256 test vector 2" {
    const key: [Aegis256.key_length]u8 = @splat(0x00);
    const nonce: [Aegis256.nonce_length]u8 = @splat(0x00);
    const ad = [_]u8{};
    const m: [16]u8 = @splat(0x00);
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis256.tag_length]u8 = undefined;

    Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c);
    try htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag);
}

test "Aegis256 test vector 3" {
    const key: [Aegis256.key_length]u8 = @splat(0x00);
    const nonce: [Aegis256.nonce_length]u8 = @splat(0x00);
    const ad = [_]u8{};
    const m = [_]u8{};
    var c: [m.len]u8 = undefined;
    var m2: [m.len]u8 = undefined;
    var tag: [Aegis256.tag_length]u8 = undefined;

    Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
    try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
    try testing.expectEqualSlices(u8, &m, &m2);

    try htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag);
}

test "Aegis256X4 test vector 1" {
    const key: [Aegis256X4.key_length]u8 = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
    const nonce: [Aegis256X4.nonce_length]u8 = [_]u8{ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f };
    var empty = [_]u8{};
    var tag: [Aegis256X4.tag_length]u8 = undefined;
    var tag256: [Aegis256X4_256.tag_length]u8 = undefined;

    Aegis256X4.encrypt(&empty, &tag, &empty, &empty, nonce, key);
    Aegis256X4_256.encrypt(&empty, &tag256, &empty, &empty, nonce, key);
    try htest.assertEqual("3b7fee6cee7bf17888ad11ed2397beb4", &tag);
    try htest.assertEqual("6093a1a8aab20ec635dc1ca71745b01b5bec4fc444c9ffbebd710d4a34d20eaf", &tag256);
    tag[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis256X4.decrypt(&empty, &empty, tag, &empty, nonce, key));
    tag256[0] +%= 1;
    try testing.expectError(error.AuthenticationFailed, Aegis256X4_256.decrypt(&empty, &empty, tag256, &empty, nonce, key));
}

test "Aegis MAC" {
    const key: [Aegis128LMac.key_length]u8 = @splat(0x00);
    var msg: [64]u8 = undefined;
    for (&msg, 0..) |*m, i| {
        m.* = @as(u8, @truncate(i));
    }
    const st_init = Aegis128LMac.init(&key);
    var st = st_init;
    var tag: [Aegis128LMac.mac_length]u8 = undefined;

    st.update(msg[0..32]);
    st.update(msg[32..]);
    st.final(&tag);
    try htest.assertEqual("f5eb88d90b7d31c9a679eb94ed1374cd14816b19cdb77930d1a5158f8595983b", &tag);

    st = st_init;
    st.update(msg[0..31]);
    st.update(msg[31..]);
    st.final(&tag);
    try htest.assertEqual("f5eb88d90b7d31c9a679eb94ed1374cd14816b19cdb77930d1a5158f8595983b", &tag);

    st = st_init;
    st.update(msg[0..14]);
    st.update(msg[14..30]);
    st.update(msg[30..]);
    st.final(&tag);
    try htest.assertEqual("f5eb88d90b7d31c9a679eb94ed1374cd14816b19cdb77930d1a5158f8595983b", &tag);

    // 大小不是数据块大小整数倍的更新。
    st = st_init;
    st.update(msg[0..33]);
    st.final(&tag);
    try htest.assertEqual("07b3ba5ad9ceee5ef1906e3396f0fa540fbcd2f33833ef97c35bdc2ae9ae0535", &tag);
}

test "AEGISMAC-128* test vectors" {
    const key = [_]u8{ 0x10, 0x01 } ++ @as([16 - 2]u8, @splat(0x00));
    const nonce = [_]u8{ 0x10, 0x00, 0x02 } ++ @as([16 - 3]u8, @splat(0x00));
    var msg: [35]u8 = undefined;
    for (&msg, 0..) |*byte, i| byte.* = @truncate(i);
    var mac128: [16]u8 = undefined;
    var mac256: [32]u8 = undefined;

    Aegis128LMac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis128LMac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("d3f09b2842ad301687d6902c921d7818", &mac128);
    try htest.assertEqual("9490e7c89d420c9f37417fa625eb38e8cad53c5cbec55285e8499ea48377f2a3", &mac256);

    Aegis128X2Mac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis128X2Mac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("6873ee34e6b5c59143b6d35c5e4f2c6e", &mac128);
    try htest.assertEqual("afcba3fc2d63c8d6c7f2d63f3ec8fbbbaf022e15ac120e78ffa7755abccd959c", &mac256);

    Aegis128X4Mac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis128X4Mac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("c45a98fd9ab8956ce616eb008cfe4e53", &mac128);
    try htest.assertEqual("26fdc76f41b1da7aec7779f6e964beae8904e662f05aca8345ae3befb357412a", &mac256);
}

test "AEGISMAC-256* test vectors" {
    const key = [_]u8{ 0x10, 0x01 } ++ @as([32 - 2]u8, @splat(0x00));
    const nonce = [_]u8{ 0x10, 0x00, 0x02 } ++ @as([32 - 3]u8, @splat(0x00));
    var msg: [35]u8 = undefined;
    for (&msg, 0..) |*byte, i| byte.* = @truncate(i);
    var mac128: [16]u8 = undefined;
    var mac256: [32]u8 = undefined;

    Aegis256Mac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis256Mac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("c08e20cfc56f27195a46c9cef5c162d4", &mac128);
    try htest.assertEqual("a5c906ede3d69545c11e20afa360b221f936e946ed2dba3d7c75ad6dc2784126", &mac256);

    Aegis256X2Mac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis256X2Mac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("fb319cb6dd728a764606fb14d37f2a5e", &mac128);
    try htest.assertEqual("0844b20ed5147ceae89c7a160263afd4b1382d6b154ecf560ce8a342cb6a8fd1", &mac256);

    Aegis256X4Mac.createWithNonce(&mac256, &msg, &key, &nonce);
    Aegis256X4Mac_128.createWithNonce(&mac128, &msg, &key, &nonce);
    try htest.assertEqual("a51f9bc5beae60cce77f0dbc60761edd", &mac128);
    try htest.assertEqual("b36a16ef07c36d75a91f437502f24f545b8dfa88648ed116943c29fead3bf10c", &mac256);
}