跳转到内容

std.crypto.25519.ed25519

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

第 1 行

std.crypto.25519.ed25519.crypto

别名

第 2 行

别名目标 std.crypto

std.crypto.25519.ed25519.debug

别名

第 3 行

别名目标 std.debug

std.crypto.25519.ed25519.Ed25519

命名空间

第 17 行

Ed25519(EdDSA)签名。

std.crypto.25519.ed25519.Ed25519.BatchElement

容器

第 431 行

用于批量验证的 (signature, message, public_key) 元组。

字段

sig: Signature
msg: []const u8
public_key: PublicKey

std.crypto.25519.ed25519.Ed25519.CompressedScalar

别名

第 24 行

别名目标 std.crypto.25519.scalar.CompressedScalar

std.crypto.25519.ed25519.Ed25519.Curve

别名

第 19 行

底层椭圆曲线。

别名目标 std.crypto.ecc.Edwards25519

std.crypto.25519.ed25519.Ed25519.key_blinding

命名空间

第 498 行

采用密钥盲化的 Ed25519 签名。

std.crypto.25519.ed25519.Ed25519.key_blinding.blind_seed_length

常量

第 500 行

盲化种子的长度(字节)。

std.crypto.25519.ed25519.Ed25519.key_blinding.blindCtx

函数

第 571 行

根据盲化种子及上下文计算盲化上下文。

fn blindCtx(blind_seed: [blind_seed_length]u8, ctx: []const u8) [Sha512.digest_length]u8

参数

blind_seed: [blind_seed_length]u8
ctx: []const u8

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindKeyPair

容器

第 524 行

盲化密钥对。

字段

blind_public_key: BlindPublicKey
blind_secret_key: BlindSecretKey

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindKeyPair.init

函数

第 529 行

根据现有密钥对、盲化种子和上下文创建盲化密钥对。

pub fn init(key_pair: Ed25519.KeyPair, blind_seed: [blind_seed_length]u8, ctx: []const u8) (NonCanonicalError || IdentityElementError)!BlindKeyPair

参数

key_pair: Ed25519.KeyPair
blind_seed: [blind_seed_length]u8
ctx: []const u8

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindKeyPair.sign

函数

第 561 行

使用盲化密钥对和可选随机噪声对消息签名。 加入噪声会生成不符合标准且非确定性的签名, 但已证明可增强对故障攻击的抵抗力。

pub fn sign(key_pair: BlindKeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signature

参数

key_pair: BlindKeyPair
msg: []const u8
noise: ?[noise_length]u8

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindPublicKey

容器

第 510 行

盲化公钥。

字段

key: PublicKey

对应公钥,可用于签名验证。

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindPublicKey.unblind

函数

第 515 行

从盲化公钥恢复原公钥。

pub fn unblind(blind_public_key: BlindPublicKey, blind_seed: [blind_seed_length]u8, ctx: []const u8) (IdentityElementError || NonCanonicalError || EncodingError || WeakPublicKeyError)!PublicKey

参数

blind_public_key: BlindPublicKey
blind_seed: [blind_seed_length]u8
ctx: []const u8

std.crypto.25519.ed25519.Ed25519.key_blinding.BlindSecretKey

容器

第 503 行

盲化私钥。

字段

prefix: [64]u8
blind_scalar: CompressedScalar
blind_public_key: BlindPublicKey

std.crypto.25519.ed25519.Ed25519.KeyPair

容器

第 300 行

Ed25519 密钥对。

字段

public_key: PublicKey

公开部分。

secret_key: SecretKey

秘密标量。

std.crypto.25519.ed25519.Ed25519.KeyPair.fromSecretKey

函数

第 354 行

从已有私钥创建密钥对。

注意,对于 EdDSA,建议存储种子并从中 恢复密钥对,而非存储整个私钥。 已有密钥对的种子可通过 key_pair.secret_key.seed() 取得,之后可使用 SecretKey.generateDeterministic() 重新计算私钥。

pub fn fromSecretKey(secret_key: SecretKey) (NonCanonicalError || EncodingError || IdentityElementError)!KeyPair

参数

secret_key: SecretKey

std.crypto.25519.ed25519.Ed25519.KeyPair.generate

函数

第 336 行

生成新的随机密钥对。

pub fn generate(io: std.Io) KeyPair

参数

io: std.Io

std.crypto.25519.ed25519.Ed25519.KeyPair.generateDeterministic

函数

第 319 行

从密码学安全的秘密种子确定性派生密钥对。

要创建新密钥,应用程序通常应调用 generate(),而非此函数。

按 RFC 8032,生成 Ed25519 公钥时,先使用 SHA-512 函数对私钥进行哈希,再将输出的低半部分 经位交换及钳位处理后解释为秘密标量。

因此,EdDSA 私钥通常被称为种子, 实际秘密值由它派生。

pub fn generateDeterministic(seed: [seed_length]u8) IdentityElementError!KeyPair

参数

seed: [seed_length]u8

错误

IdentityElement IdentityElementError

std.crypto.25519.ed25519.Ed25519.KeyPair.seed_length

别名

第 302 行

创建密钥对所需种子的长度(字节)。

别名目标 std.crypto.25519.ed25519.Ed25519.noise_length

std.crypto.25519.ed25519.Ed25519.KeyPair.sign

函数

第 375 行

使用密钥对签署消息。 noise 可以为 null,以创建确定性签名。 若不要求确定性签名,则应改用随机生成的 noise。 这样有助于抵御故障攻击。

pub fn sign(key_pair: KeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature

参数

key_pair: KeyPair
msg: []const u8
noise: ?[noise_length]u8

std.crypto.25519.ed25519.Ed25519.KeyPair.signer

函数

第 417 行

创建一个可用于增量签名的 Signer。 注意,签名并非确定性的。

pub fn signer( key_pair: KeyPair, noise: ?[noise_length]u8, io: std.Io, ) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer

参数

key_pair: KeyPair
noise: ?[noise_length]u8

如果设置,应为每条消息使用唯一值, 例如随机 nonce 或计数器。

io: std.Io

std.crypto.25519.ed25519.Ed25519.KeyPair.signerWithBaseNonce

函数

第 392 行

使用自定义基础 nonce 创建可增量签名的签名器。 base_nonce 对每条已签名消息必须唯一,否则攻击者 可以轻易恢复私钥。 可使用密码学安全的随机数生成器生成它。

pub fn signerWithBaseNonce( key_pair: KeyPair, base_nonce: [32]u8, noise: ?[noise_length]u8, ) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer

参数

key_pair: KeyPair
base_nonce: [32]u8
noise: ?[noise_length]u8

若设置,每条消息都应使用不同的值,例如计数器。

std.crypto.25519.ed25519.Ed25519.noise_length

常量

第 22 行

用于非确定性签名的可选随机字节长度(单位为字节)。

std.crypto.25519.ed25519.Ed25519.PublicKey

容器

第 107 行

Ed25519 公钥。

字段

bytes: [encoded_length]u8

std.crypto.25519.ed25519.Ed25519.PublicKey.computeNonceAndSign

函数

第 130 行

fn computeNonceAndSign(public_key: PublicKey, msg: []const u8, noise: ?[noise_length]u8, scalar: CompressedScalar, prefix: []const u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature

参数

public_key: PublicKey
msg: []const u8
noise: ?[noise_length]u8
scalar: CompressedScalar
prefix: []const u8

std.crypto.25519.ed25519.Ed25519.PublicKey.encoded_length

常量

第 109 行

原始公钥的长度(字节)。

std.crypto.25519.ed25519.Ed25519.PublicKey.fromBytes

函数

第 114 行

从原始字节创建公钥。

pub fn fromBytes(bytes: [encoded_length]u8) NonCanonicalError!PublicKey

参数

bytes: [encoded_length]u8

错误

NonCanonical NonCanonicalError

std.crypto.25519.ed25519.Ed25519.PublicKey.signWithNonce

函数

第 124 行

fn signWithNonce(public_key: PublicKey, msg: []const u8, scalar: CompressedScalar, nonce: CompressedScalar) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature

参数

public_key: PublicKey
msg: []const u8
scalar: CompressedScalar
nonce: CompressedScalar

std.crypto.25519.ed25519.Ed25519.PublicKey.toBytes

函数

第 120 行

将公钥转换为原始字节。

pub fn toBytes(pk: PublicKey) [encoded_length]u8

参数

pk: PublicKey

std.crypto.25519.ed25519.Ed25519.Scalar

别名

第 25 行

别名目标 std.crypto.25519.scalar.Scalar

std.crypto.25519.ed25519.Ed25519.SecretKey

容器

第 28 行

Ed25519 私钥。

字段

bytes: [encoded_length]u8

std.crypto.25519.ed25519.Ed25519.SecretKey.encoded_length

常量

第 30 行

原始私钥的长度,单位为字节。

std.crypto.25519.ed25519.Ed25519.SecretKey.fromBytes

函数

第 45 行

从原始字节创建秘密密钥。

pub fn fromBytes(bytes: [encoded_length]u8) !SecretKey

参数

bytes: [encoded_length]u8

std.crypto.25519.ed25519.Ed25519.SecretKey.publicKeyBytes

函数

第 40 行

返回与此私钥对应的原始公钥字节。

pub fn publicKeyBytes(self: SecretKey) [PublicKey.encoded_length]u8

参数

self: SecretKey

std.crypto.25519.ed25519.Ed25519.SecretKey.scalarAndPrefix

类型函数

第 55 行

fn scalarAndPrefix(self: SecretKey) struct { scalar: CompressedScalar, prefix: [32]u8 }

参数

self: SecretKey

std.crypto.25519.ed25519.Ed25519.SecretKey.seed

函数

第 35 行

返回用于生成此私钥的种子。

pub fn seed(self: SecretKey) [KeyPair.seed_length]u8

参数

self: SecretKey

std.crypto.25519.ed25519.Ed25519.SecretKey.toBytes

函数

第 50 行

以原始字节形式返回私钥。

pub fn toBytes(sk: SecretKey) [encoded_length]u8

参数

sk: SecretKey

std.crypto.25519.ed25519.Ed25519.Signature

容器

第 235 行

Ed25519 签名。

字段

r: [Curve.encoded_length]u8

EdDSA 签名的 R 分量。

s: CompressedScalar

EdDSA 签名的 S 分量。

std.crypto.25519.ed25519.Ed25519.Signature.encoded_length

常量

第 237 行

原始签名的长度(字节)。

std.crypto.25519.ed25519.Ed25519.Signature.fromBytes

函数

第 254 行

从 (r, s) 的原始编码创建签名。 EdDSA 始终假定为小端序。

pub fn fromBytes(bytes: [encoded_length]u8) Signature

参数

bytes: [encoded_length]u8

std.crypto.25519.ed25519.Ed25519.Signature.toBytes

函数

第 245 行

返回小端格式的原始签名 (r, s)。

pub fn toBytes(sig: Signature) [encoded_length]u8

参数

sig: Signature

std.crypto.25519.ed25519.Ed25519.Signature.verifier

函数

第 262 行

创建用于增量验证签名的 Verifier。

pub fn verifier(sig: Signature, public_key: PublicKey) Verifier.InitError!Verifier

参数

sig: Signature
public_key: PublicKey

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError

std.crypto.25519.ed25519.Ed25519.Signature.verify

函数

第 275 行

根据消息和公钥验证签名。

此函数采用带余因子的验证,以获得广泛互操作性。 使单签名验证与常见批量验证方法保持一致。

若公钥或签名不在预期范围内,返回 IdentityElement 或 NonCanonical; 若签名对给定消息和密钥无效,返回 SignatureVerificationError。

pub fn verify(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void

参数

sig: Signature
msg: []const u8
public_key: PublicKey

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.Signature.VerifyError

错误集合

第 266 行

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.Signature.verifyStrict

函数

第 292 行

使用无余因子验证,根据消息和公钥验证签名。

执行不乘以余因子的严格验证, 检查确切等式:[s]B = R + [H(R,A,m)]A。

这比标准 verify() 方法更严格,可能拒绝 某些经过特意构造、但带余因子验证会接受的签名。 不过,绝不会拒绝使用 sign() 方法创建的有效签名。

如果公钥或签名不在预期范围内,则返回 IdentityElement 或 NonCanonical; 如果签名对于给定消息和密钥无效,则返回 SignatureVerificationError。

pub fn verifyStrict(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void

参数

sig: Signature
msg: []const u8
public_key: PublicKey

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.Signer

容器

第 70 行

Signer 用于增量计算签名。 可通过 KeyPair 的 signer() 函数获取。

字段

std.crypto.25519.ed25519.Ed25519.Signer.finalize

函数

第 95 行

计算整个消息的签名。

pub fn finalize(self: *Signer) Signature

参数

self: *Signer

std.crypto.25519.ed25519.Ed25519.Signer.init

函数

第 76 行

fn init(scalar: CompressedScalar, nonce: CompressedScalar, public_key: PublicKey) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer

参数

scalar: CompressedScalar
nonce: CompressedScalar
public_key: PublicKey

std.crypto.25519.ed25519.Ed25519.Signer.update

函数

第 90 行

向正在签名的消息加入新数据。

pub fn update(self: *Signer, data: []const u8) void

参数

self: *Signer
data: []const u8

std.crypto.25519.ed25519.Ed25519.Verifier

容器

第 148 行

Verifier 用于增量验证签名。 可通过 Signature 的 verifier() 函数获取。

字段

h: Sha512
s: CompressedScalar
a: Curve
expected_r: Curve

std.crypto.25519.ed25519.Ed25519.Verifier.init

函数

第 156 行

fn init(sig: Signature, public_key: PublicKey) InitError!Verifier

参数

sig: Signature
public_key: PublicKey

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError

std.crypto.25519.ed25519.Ed25519.Verifier.InitError

错误集合

第 154 行

错误

IdentityElement IdentityElementError
InvalidEncoding EncodingError
NonCanonical NonCanonicalError

std.crypto.25519.ed25519.Ed25519.Verifier.isIdentity

函数

第 178 行

fn isIdentity(p: Curve) bool

参数

p: Curve

std.crypto.25519.ed25519.Ed25519.Verifier.update

函数

第 174 行

向待验证消息添加新内容。

pub fn update(self: *Verifier, msg: []const u8) void

参数

self: *Verifier
msg: []const u8

std.crypto.25519.ed25519.Ed25519.Verifier.verify

函数

第 192 行

验证签名对完整消息是否有效。

此函数使用带余因子的验证,以获得广泛的互操作性。 它使单签名验证与常见批量验证方法保持一致。

如果公钥或签名不在预期范围内,则返回 IdentityElement 或 NonCanonical; 如果签名对于给定消息和密钥无效,则返回 SignatureVerificationError。

pub fn verify(self: *Verifier) VerifyError!void

参数

self: *Verifier

错误

IdentityElement IdentityElementError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.Verifier.VerifyError

错误集合

第 182 行

错误

IdentityElement IdentityElementError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.Verifier.verifyStrict

函数

第 218 行

通过不乘余因子的验证,检查签名对完整消息是否有效。

此函数执行不含余因子乘法的严格验证,检查精确等式:[s]B = R + [H(R,A,m)]A

这比带余因子的 verify() 方法更严格,可能拒绝某些精心构造、但带余因子验证会接受的签名。不过,绝不会拒绝使用 sign() 方法生成的有效签名。

若公钥或签名不在预期范围内,返回 IdentityElement 或 NonCanonical;若签名对给定消息和密钥无效,返回 SignatureVerificationError。

pub fn verifyStrict(self: *Verifier) VerifyError!void

参数

self: *Verifier

错误

IdentityElement IdentityElementError
SignatureVerificationFailed SignatureVerificationError
WeakPublicKey WeakPublicKeyError

std.crypto.25519.ed25519.Ed25519.verifyBatch

函数

第 438 行

在单次操作中验证多个签名,比逐个验证签名快得多。

pub fn verifyBatch(io: std.Io, comptime count: usize, signature_batch: [count]BatchElement) (SignatureVerificationError || IdentityElementError || WeakPublicKeyError || EncodingError || NonCanonicalError)!void

参数

io: std.Io
count: usize
signature_batch: [count]BatchElement

std.crypto.25519.ed25519.EncodingError

别名

第 9 行

别名目标 std.crypto.errors.EncodingError

std.crypto.25519.ed25519.fmt

别名

第 4 行

别名目标 std.fmt

std.crypto.25519.ed25519.IdentityElementError

别名

第 10 行

别名目标 std.crypto.errors.IdentityElementError

std.crypto.25519.ed25519.KeyMismatchError

别名

第 13 行

别名目标 std.crypto.errors.KeyMismatchError

std.crypto.25519.ed25519.mem

别名

第 5 行

别名目标 std.mem

std.crypto.25519.ed25519.NonCanonicalError

别名

第 11 行

别名目标 std.crypto.errors.NonCanonicalError

std.crypto.25519.ed25519.Sha512

别名

第 7 行

别名目标 std.crypto.sha2.Sha512

std.crypto.25519.ed25519.SignatureVerificationError

别名

第 12 行

别名目标 std.crypto.errors.SignatureVerificationError

std.crypto.25519.ed25519.std

别名

第 1 行

别名目标 std

std.crypto.25519.ed25519.WeakPublicKeyError

别名

第 14 行

别名目标 std.crypto.errors.WeakPublicKeyError

源码

std/crypto/25519/ed25519.zig

const std = @import("std");
const crypto = std.crypto;
const debug = std.debug;
const fmt = std.fmt;
const mem = std.mem;

const Sha512 = crypto.hash.sha2.Sha512;

const EncodingError = crypto.errors.EncodingError;
const IdentityElementError = crypto.errors.IdentityElementError;
const NonCanonicalError = crypto.errors.NonCanonicalError;
const SignatureVerificationError = crypto.errors.SignatureVerificationError;
const KeyMismatchError = crypto.errors.KeyMismatchError;
const WeakPublicKeyError = crypto.errors.WeakPublicKeyError;

/// Ed25519(EdDSA)签名。
pub const Ed25519 = struct {
    /// 底层椭圆曲线。
    pub const Curve = std.crypto.ecc.Edwards25519;

    /// 用于非确定性签名的可选随机字节长度(单位为字节)。
    pub const noise_length = 32;

    const CompressedScalar = Curve.scalar.CompressedScalar;
    const Scalar = Curve.scalar.Scalar;

    /// Ed25519 私钥。
    pub const SecretKey = struct {
        /// 原始私钥的长度,单位为字节。
        pub const encoded_length = 64;

        bytes: [encoded_length]u8,

        /// 返回用于生成此私钥的种子。
        pub fn seed(self: SecretKey) [KeyPair.seed_length]u8 {
            return self.bytes[0..KeyPair.seed_length].*;
        }

        /// 返回与此私钥对应的原始公钥字节。
        pub fn publicKeyBytes(self: SecretKey) [PublicKey.encoded_length]u8 {
            return self.bytes[KeyPair.seed_length..].*;
        }

        /// 从原始字节创建秘密密钥。
        pub fn fromBytes(bytes: [encoded_length]u8) !SecretKey {
            return SecretKey{ .bytes = bytes };
        }

        /// 以原始字节形式返回私钥。
        pub fn toBytes(sk: SecretKey) [encoded_length]u8 {
            return sk.bytes;
        }

        // 返回此私钥经过钳制的秘密标量和前缀
        fn scalarAndPrefix(self: SecretKey) struct { scalar: CompressedScalar, prefix: [32]u8 } {
            var az: [Sha512.digest_length]u8 = undefined;
            var h = Sha512.init(.{});
            h.update(&self.seed());
            h.final(&az);

            var s = az[0..32].*;
            Curve.scalar.clamp(&s);

            return .{ .scalar = s, .prefix = az[32..].* };
        }
    };

    /// Signer 用于增量计算签名。
    /// 可通过 `KeyPair` 的 `signer()` 函数获取。
    pub const Signer = struct {
        h: Sha512,
        scalar: CompressedScalar,
        nonce: CompressedScalar,
        r_bytes: [Curve.encoded_length]u8,

        fn init(scalar: CompressedScalar, nonce: CompressedScalar, public_key: PublicKey) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer {
            const r = try Curve.basePoint.mul(nonce);
            const r_bytes = r.toBytes();

            var t: [64]u8 = undefined;
            t[0..32].* = r_bytes;
            t[32..].* = public_key.bytes;
            var h = Sha512.init(.{});
            h.update(&t);

            return Signer{ .h = h, .scalar = scalar, .nonce = nonce, .r_bytes = r_bytes };
        }

        /// 向正在签名的消息加入新数据。
        pub fn update(self: *Signer, data: []const u8) void {
            self.h.update(data);
        }

        /// 计算整个消息的签名。
        pub fn finalize(self: *Signer) Signature {
            var hram64: [Sha512.digest_length]u8 = undefined;
            self.h.final(&hram64);
            const hram = Curve.scalar.reduce64(hram64);

            const s = Curve.scalar.mulAdd(hram, self.scalar, self.nonce);

            return Signature{ .r = self.r_bytes, .s = s };
        }
    };

    /// Ed25519 公钥。
    pub const PublicKey = struct {
        /// 原始公钥的长度(字节)。
        pub const encoded_length = 32;

        bytes: [encoded_length]u8,

        /// 从原始字节创建公钥。
        pub fn fromBytes(bytes: [encoded_length]u8) NonCanonicalError!PublicKey {
            try Curve.rejectNonCanonical(bytes);
            return PublicKey{ .bytes = bytes };
        }

        /// 将公钥转换为原始字节。
        pub fn toBytes(pk: PublicKey) [encoded_length]u8 {
            return pk.bytes;
        }

        fn signWithNonce(public_key: PublicKey, msg: []const u8, scalar: CompressedScalar, nonce: CompressedScalar) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
            var st = try Signer.init(scalar, nonce, public_key);
            st.update(msg);
            return st.finalize();
        }

        fn computeNonceAndSign(public_key: PublicKey, msg: []const u8, noise: ?[noise_length]u8, scalar: CompressedScalar, prefix: []const u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
            var h = Sha512.init(.{});
            if (noise) |*z| {
                h.update(z);
            }
            h.update(prefix);
            h.update(msg);
            var nonce64: [64]u8 = undefined;
            h.final(&nonce64);

            const nonce = Curve.scalar.reduce64(nonce64);

            return public_key.signWithNonce(msg, scalar, nonce);
        }
    };

    /// Verifier 用于增量验证签名。
    /// 可通过 `Signature` 的 `verifier()` 函数获取。
    pub const Verifier = struct {
        h: Sha512,
        s: CompressedScalar,
        a: Curve,
        expected_r: Curve,

        pub const InitError = NonCanonicalError || EncodingError || IdentityElementError;

        fn init(sig: Signature, public_key: PublicKey) InitError!Verifier {
            const r = sig.r;
            const s = sig.s;
            try Curve.scalar.rejectNonCanonical(s);
            const a = try Curve.fromBytes(public_key.bytes);
            try a.rejectIdentity();
            try Curve.rejectNonCanonical(r);
            const expected_r = try Curve.fromBytes(r);
            try expected_r.rejectIdentity();

            var h = Sha512.init(.{});
            h.update(&r);
            h.update(&public_key.bytes);

            return Verifier{ .h = h, .s = s, .a = a, .expected_r = expected_r };
        }

        /// 向待验证消息添加新内容。
        pub fn update(self: *Verifier, msg: []const u8) void {
            self.h.update(msg);
        }

        fn isIdentity(p: Curve) bool {
            return p.x.isZero() and p.y.equivalent(p.z);
        }

        pub const VerifyError = WeakPublicKeyError || IdentityElementError ||
            SignatureVerificationError;

        /// 验证签名对完整消息是否有效。
        ///
        /// 此函数使用带余因子的验证,以获得广泛的互操作性。
        /// 它使单签名验证与常见批量验证方法保持一致。
        ///
        /// 如果公钥或签名不在预期范围内,则返回 IdentityElement 或 NonCanonical;
        /// 如果签名对于给定消息和密钥无效,则返回 SignatureVerificationError。
        pub fn verify(self: *Verifier) VerifyError!void {
            var hram64: [Sha512.digest_length]u8 = undefined;
            self.h.final(&hram64);
            const hram = Curve.scalar.reduce64(hram64);
            const sb_ah = (try Curve.basePoint.mulDoubleBasePublic(
                Curve.scalar.mul8(self.s),
                self.a.clearCofactor().neg(),
                hram,
            ));
            const check = sb_ah.sub(self.expected_r.clearCofactor());
            if (!isIdentity(check)) {
                return error.SignatureVerificationFailed;
            }
        }

        /// 通过不乘余因子的验证,检查签名对完整消息是否有效。
        ///
        /// 此函数执行不含余因子乘法的严格验证,检查精确等式:[s]B = R + [H(R,A,m)]A
        ///
        /// 这比带余因子的 `verify()` 方法更严格,可能拒绝某些精心构造、但带余因子验证会接受的签名。不过,绝不会拒绝使用 `sign()` 方法生成的有效签名。
        ///
        /// 若公钥或签名不在预期范围内,返回 IdentityElement 或 NonCanonical;若签名对给定消息和密钥无效,返回 SignatureVerificationError。
        ///
        ///
        ///
        ///
        pub fn verifyStrict(self: *Verifier) VerifyError!void {
            var hram64: [Sha512.digest_length]u8 = undefined;
            self.h.final(&hram64);
            const hram = Curve.scalar.reduce64(hram64);
            const sb_ah = (try Curve.basePoint.mulDoubleBasePublic(
                self.s,
                self.a.neg(),
                hram,
            ));
            const check = sb_ah.sub(self.expected_r);
            if (!isIdentity(check)) {
                return error.SignatureVerificationFailed;
            }
        }
    };

    /// Ed25519 签名。
    pub const Signature = struct {
        /// 原始签名的长度(字节)。
        pub const encoded_length = Curve.encoded_length + @sizeOf(CompressedScalar);

        /// EdDSA 签名的 R 分量。
        r: [Curve.encoded_length]u8,
        /// EdDSA 签名的 S 分量。
        s: CompressedScalar,

        /// 返回小端格式的原始签名 (r, s)。
        pub fn toBytes(sig: Signature) [encoded_length]u8 {
            var bytes: [encoded_length]u8 = undefined;
            bytes[0..Curve.encoded_length].* = sig.r;
            bytes[Curve.encoded_length..].* = sig.s;
            return bytes;
        }

        /// 从 (r, s) 的原始编码创建签名。
        /// EdDSA 始终假定为小端序。
        pub fn fromBytes(bytes: [encoded_length]u8) Signature {
            return Signature{
                .r = bytes[0..Curve.encoded_length].*,
                .s = bytes[Curve.encoded_length..].*,
            };
        }

        /// 创建用于增量验证签名的 Verifier。
        pub fn verifier(sig: Signature, public_key: PublicKey) Verifier.InitError!Verifier {
            return Verifier.init(sig, public_key);
        }

        pub const VerifyError = Verifier.InitError || Verifier.VerifyError;

        /// 根据消息和公钥验证签名。
        ///
        /// 此函数采用带余因子的验证,以获得广泛互操作性。
        /// 使单签名验证与常见批量验证方法保持一致。
        ///
        /// 若公钥或签名不在预期范围内,返回 IdentityElement 或 NonCanonical;
        /// 若签名对给定消息和密钥无效,返回 SignatureVerificationError。
        pub fn verify(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void {
            var st = try sig.verifier(public_key);
            st.update(msg);
            try st.verify();
        }

        /// 使用无余因子验证,根据消息和公钥验证签名。
        ///
        /// 执行不乘以余因子的严格验证,
        /// 检查确切等式:[s]B = R + [H(R,A,m)]A。
        ///
        /// 这比标准 `verify()` 方法更严格,可能拒绝
        /// 某些经过特意构造、但带余因子验证会接受的签名。
        /// 不过,绝不会拒绝使用 `sign()` 方法创建的有效签名。
        ///
        /// 如果公钥或签名不在预期范围内,则返回 IdentityElement 或 NonCanonical;
        /// 如果签名对于给定消息和密钥无效,则返回 SignatureVerificationError。
        pub fn verifyStrict(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void {
            var st = try sig.verifier(public_key);
            st.update(msg);
            try st.verifyStrict();
        }
    };

    /// Ed25519 密钥对。
    pub const KeyPair = struct {
        /// 创建密钥对所需种子的长度(字节)。
        pub const seed_length = noise_length;

        /// 公开部分。
        public_key: PublicKey,
        /// 秘密标量。
        secret_key: SecretKey,

        /// 从密码学安全的秘密种子确定性派生密钥对。
        ///
        /// 要创建新密钥,应用程序通常应调用 `generate()`,而非此函数。
        ///
        /// 按 RFC 8032,生成 Ed25519 公钥时,先使用 SHA-512
        /// 函数对私钥进行哈希,再将输出的低半部分
        /// 经位交换及钳位处理后解释为秘密标量。
        ///
        /// 因此,EdDSA 私钥通常被称为种子,
        /// 实际秘密值由它派生。
        pub fn generateDeterministic(seed: [seed_length]u8) IdentityElementError!KeyPair {
            var az: [Sha512.digest_length]u8 = undefined;
            var h = Sha512.init(.{});
            h.update(&seed);
            h.final(&az);
            const pk_p = Curve.basePoint.clampedMul(az[0..32].*) catch return error.IdentityElement;
            const pk_bytes = pk_p.toBytes();
            var sk_bytes: [SecretKey.encoded_length]u8 = undefined;
            sk_bytes[0..seed_length].* = seed;
            sk_bytes[seed_length..].* = pk_bytes;
            return KeyPair{
                .public_key = PublicKey.fromBytes(pk_bytes) catch unreachable,
                .secret_key = try SecretKey.fromBytes(sk_bytes),
            };
        }

        /// 生成新的随机密钥对。
        pub fn generate(io: std.Io) KeyPair {
            var random_seed: [seed_length]u8 = undefined;
            while (true) {
                io.random(&random_seed);
                return generateDeterministic(random_seed) catch {
                    @branchHint(.unlikely);
                    continue;
                };
            }
        }

        /// 从已有私钥创建密钥对。
        ///
        /// 注意,对于 EdDSA,建议存储种子并从中
        /// 恢复密钥对,而非存储整个私钥。
        /// 已有密钥对的种子可通过
        /// `key_pair.secret_key.seed()` 取得,之后可使用
        /// `SecretKey.generateDeterministic()` 重新计算私钥。
        pub fn fromSecretKey(secret_key: SecretKey) (NonCanonicalError || EncodingError || IdentityElementError)!KeyPair {
            // 对 EdDSA 而言,使用正确的公钥至关重要。
            // 为强制满足这一要求,SecretKey 隐式包含公钥副本。
            // 启用运行时安全检查时,仍可承担验证公钥是否正确的开销。
            if (std.debug.runtime_safety) {
                const pk_p = try Curve.fromBytes(secret_key.publicKeyBytes());
                const recomputed_kp = try generateDeterministic(secret_key.seed());
                if (!mem.eql(u8, &recomputed_kp.public_key.toBytes(), &pk_p.toBytes())) {
                    return error.NonCanonical;
                }
            }
            return KeyPair{
                .public_key = try PublicKey.fromBytes(secret_key.publicKeyBytes()),
                .secret_key = secret_key,
            };
        }

        /// 使用密钥对签署消息。
        /// noise 可以为 null,以创建确定性签名。
        /// 若不要求确定性签名,则应改用随机生成的 noise。
        /// 这样有助于抵御故障攻击。
        pub fn sign(key_pair: KeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
            if (!mem.eql(u8, &key_pair.secret_key.publicKeyBytes(), &key_pair.public_key.toBytes())) {
                return error.KeyMismatch;
            }
            const scalar_and_prefix = key_pair.secret_key.scalarAndPrefix();
            return key_pair.public_key.computeNonceAndSign(
                msg,
                noise,
                scalar_and_prefix.scalar,
                &scalar_and_prefix.prefix,
            );
        }

        /// 使用自定义基础 nonce 创建可增量签名的签名器。
        /// `base_nonce` 对每条已签名消息必须唯一,否则攻击者
        /// 可以轻易恢复私钥。
        /// 可使用密码学安全的随机数生成器生成它。
        pub fn signerWithBaseNonce(
            key_pair: KeyPair,
            base_nonce: [32]u8,
            /// 若设置,每条消息都应使用不同的值,例如计数器。
            noise: ?[noise_length]u8,
        ) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer {
            if (!mem.eql(u8, &key_pair.secret_key.publicKeyBytes(), &key_pair.public_key.toBytes())) {
                return error.KeyMismatch;
            }
            const scalar_and_prefix = key_pair.secret_key.scalarAndPrefix();
            var h = Sha512.init(.{});
            h.update(&scalar_and_prefix.prefix);
            h.update(&base_nonce);
            if (noise) |*z| {
                h.update(z);
            }
            var nonce64: [64]u8 = undefined;
            h.final(&nonce64);
            const nonce = Curve.scalar.reduce64(nonce64);

            return Signer.init(scalar_and_prefix.scalar, nonce, key_pair.public_key);
        }

        /// 创建一个可用于增量签名的 Signer。
        /// 注意,签名并非确定性的。
        pub fn signer(
            key_pair: KeyPair,
            /// 如果设置,应为每条消息使用唯一值,
            /// 例如随机 nonce 或计数器。
            noise: ?[noise_length]u8,
            io: std.Io,
        ) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer {
            var base_nonce: [32]u8 = undefined;
            io.random(&base_nonce);
            return key_pair.signerWithBaseNonce(base_nonce, noise);
        }
    };

    /// 用于批量验证的 (signature, message, public_key) 元组。
    pub const BatchElement = struct {
        sig: Signature,
        msg: []const u8,
        public_key: PublicKey,
    };

    /// 在单次操作中验证多个签名,比逐个验证签名快得多。
    pub fn verifyBatch(io: std.Io, comptime count: usize, signature_batch: [count]BatchElement) (SignatureVerificationError || IdentityElementError || WeakPublicKeyError || EncodingError || NonCanonicalError)!void {
        var r_batch: [count]CompressedScalar = undefined;
        var s_batch: [count]CompressedScalar = undefined;
        var a_batch: [count]Curve = undefined;
        var expected_r_batch: [count]Curve = undefined;

        for (signature_batch, 0..) |signature, i| {
            const r = signature.sig.r;
            const s = signature.sig.s;
            try Curve.scalar.rejectNonCanonical(s);
            const a = try Curve.fromBytes(signature.public_key.bytes);
            try a.rejectIdentity();
            try Curve.rejectNonCanonical(r);
            const expected_r = try Curve.fromBytes(r);
            try expected_r.rejectIdentity();
            expected_r_batch[i] = expected_r;
            r_batch[i] = r;
            s_batch[i] = s;
            a_batch[i] = a;
        }

        var hram_batch: [count]Curve.scalar.CompressedScalar = undefined;
        for (signature_batch, 0..) |signature, i| {
            var h = Sha512.init(.{});
            h.update(&r_batch[i]);
            h.update(&signature.public_key.bytes);
            h.update(signature.msg);
            var hram64: [Sha512.digest_length]u8 = undefined;
            h.final(&hram64);
            hram_batch[i] = Curve.scalar.reduce64(hram64);
        }

        var z_batch: [count]Curve.scalar.CompressedScalar = undefined;
        for (&z_batch) |*z| {
            io.random(z[0..16]);
            @memset(z[16..], 0);
        }

        var zs_sum = Curve.scalar.zero;
        for (z_batch, 0..) |z, i| {
            const zs = Curve.scalar.mul(z, s_batch[i]);
            zs_sum = Curve.scalar.add(zs_sum, zs);
        }
        zs_sum = Curve.scalar.mul8(zs_sum);

        var zhs: [count]Curve.scalar.CompressedScalar = undefined;
        for (z_batch, 0..) |z, i| {
            zhs[i] = Curve.scalar.mul(z, hram_batch[i]);
        }

        const zr = (try Curve.mulMulti(count, expected_r_batch, z_batch)).clearCofactor();
        const zah = (try Curve.mulMulti(count, a_batch, zhs)).clearCofactor();

        const zsb = try Curve.basePoint.mulPublic(zs_sum);
        if (zr.add(zah).sub(zsb).rejectIdentity()) |_| {
            return error.SignatureVerificationFailed;
        } else |_| {}
    }

    /// 采用密钥盲化的 Ed25519 签名。
    pub const key_blinding = struct {
        /// 盲化种子的长度(字节)。
        pub const blind_seed_length = 32;

        /// 盲化私钥。
        pub const BlindSecretKey = struct {
            prefix: [64]u8,
            blind_scalar: CompressedScalar,
            blind_public_key: BlindPublicKey,
        };

        /// 盲化公钥。
        pub const BlindPublicKey = struct {
            /// 对应公钥,可用于签名验证。
            key: PublicKey,

            /// 从盲化公钥恢复原公钥。
            pub fn unblind(blind_public_key: BlindPublicKey, blind_seed: [blind_seed_length]u8, ctx: []const u8) (IdentityElementError || NonCanonicalError || EncodingError || WeakPublicKeyError)!PublicKey {
                const blind_h = blindCtx(blind_seed, ctx);
                const inv_blind_factor = Scalar.fromBytes(blind_h[0..32].*).invert().toBytes();
                const pk_p = try (try Curve.fromBytes(blind_public_key.key.bytes)).mul(inv_blind_factor);
                return PublicKey.fromBytes(pk_p.toBytes());
            }
        };

        /// 盲化密钥对。
        pub const BlindKeyPair = struct {
            blind_public_key: BlindPublicKey,
            blind_secret_key: BlindSecretKey,

            /// 根据现有密钥对、盲化种子和上下文创建盲化密钥对。
            pub fn init(key_pair: Ed25519.KeyPair, blind_seed: [blind_seed_length]u8, ctx: []const u8) (NonCanonicalError || IdentityElementError)!BlindKeyPair {
                var h: [Sha512.digest_length]u8 = undefined;
                Sha512.hash(&key_pair.secret_key.seed(), &h, .{});
                Curve.scalar.clamp(h[0..32]);
                const scalar = Curve.scalar.reduce(h[0..32].*);

                const blind_h = blindCtx(blind_seed, ctx);
                const blind_factor = Curve.scalar.reduce(blind_h[0..32].*);

                const blind_scalar = Curve.scalar.mul(scalar, blind_factor);
                const blind_public_key = BlindPublicKey{
                    .key = try PublicKey.fromBytes((Curve.basePoint.mul(blind_scalar) catch return error.IdentityElement).toBytes()),
                };

                var prefix: [64]u8 = undefined;
                prefix[0..32].* = h[32..64].*;
                prefix[32..64].* = blind_h[32..64].*;

                const blind_secret_key = BlindSecretKey{
                    .prefix = prefix,
                    .blind_scalar = blind_scalar,
                    .blind_public_key = blind_public_key,
                };
                return BlindKeyPair{
                    .blind_public_key = blind_public_key,
                    .blind_secret_key = blind_secret_key,
                };
            }

            /// 使用盲化密钥对和可选随机噪声对消息签名。
            /// 加入噪声会生成不符合标准且非确定性的签名,
            /// 但已证明可增强对故障攻击的抵抗力。
            pub fn sign(key_pair: BlindKeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signature {
                const scalar = key_pair.blind_secret_key.blind_scalar;
                const prefix = key_pair.blind_secret_key.prefix;

                return (try PublicKey.fromBytes(key_pair.blind_public_key.key.bytes))
                    .computeNonceAndSign(msg, noise, scalar, &prefix);
            }
        };

        /// 根据盲化种子及上下文计算盲化上下文。
        fn blindCtx(blind_seed: [blind_seed_length]u8, ctx: []const u8) [Sha512.digest_length]u8 {
            var blind_h: [Sha512.digest_length]u8 = undefined;
            var hx = Sha512.init(.{});
            hx.update(&blind_seed);
            hx.update(&[1]u8{0});
            hx.update(ctx);
            hx.final(&blind_h);
            return blind_h;
        }
    };
};

test "key pair creation" {
    var seed: [32]u8 = undefined;
    _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
    const key_pair = try Ed25519.KeyPair.generateDeterministic(seed);
    var buf: [256]u8 = undefined;
    try std.testing.expectEqualStrings(try std.mem.print(&buf, "{X}", .{&key_pair.secret_key.toBytes()}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
    try std.testing.expectEqualStrings(try std.mem.print(&buf, "{X}", .{&key_pair.public_key.toBytes()}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
}

test "signature" {
    var seed: [32]u8 = undefined;
    _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
    const key_pair = try Ed25519.KeyPair.generateDeterministic(seed);

    const sig = try key_pair.sign("test", null);
    var buf: [128]u8 = undefined;
    try std.testing.expectEqualStrings(try std.mem.print(&buf, "{X}", .{&sig.toBytes()}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808");
    try sig.verify("test", key_pair.public_key);
    try std.testing.expectError(error.SignatureVerificationFailed, sig.verify("TEST", key_pair.public_key));
}

test "batch verification" {
    const io = std.testing.io;

    for (0..16) |_| {
        const key_pair = Ed25519.KeyPair.generate(io);
        var msg1: [32]u8 = undefined;
        var msg2: [32]u8 = undefined;
        io.random(&msg1);
        io.random(&msg2);
        const sig1 = try key_pair.sign(&msg1, null);
        const sig2 = try key_pair.sign(&msg2, null);
        var signature_batch = [_]Ed25519.BatchElement{
            Ed25519.BatchElement{
                .sig = sig1,
                .msg = &msg1,
                .public_key = key_pair.public_key,
            },
            Ed25519.BatchElement{
                .sig = sig2,
                .msg = &msg2,
                .public_key = key_pair.public_key,
            },
        };
        try Ed25519.verifyBatch(io, 2, signature_batch);

        signature_batch[1].sig = sig1;
        try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(io, signature_batch.len, signature_batch));
    }
}

test "test vectors" {
    const Vec = struct {
        msg_hex: []const u8,
        public_key_hex: *const [64:0]u8,
        sig_hex: *const [128:0]u8,
        expected: ?anyerror,
    };

    const entries = [_]Vec{
        Vec{
            .msg_hex = "8c93255d71dcab10e8f379c26200f3c7bd5f09d9bc3068d3ef4edeb4853022b6",
            .public_key_hex = "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa",
            .sig_hex = "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a0000000000000000000000000000000000000000000000000000000000000000",
            .expected = error.WeakPublicKey, // 0
        },
        Vec{
            .msg_hex = "9bd9f44f4dcc75bd531b56b2cd280b0bb38fc1cd6d1230e14861d861de092e79",
            .public_key_hex = "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa",
            .sig_hex = "f7badec5b8abeaf699583992219b7b223f1df3fbbea919844e3f7c554a43dd43a5bb704786be79fc476f91d3f3f89b03984d8068dcf1bb7dfc6637b45450ac04",
            .expected = error.WeakPublicKey, // 1
        },
        Vec{
            .msg_hex = "aebf3f2601a0c8c5d39cc7d8911642f740b78168218da8471772b35f9d35b9ab",
            .public_key_hex = "f7badec5b8abeaf699583992219b7b223f1df3fbbea919844e3f7c554a43dd43",
            .sig_hex = "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa8c4bd45aecaca5b24fb97bc10ac27ac8751a7dfe1baff8b953ec9f5833ca260e",
            .expected = null, // 2 - 允许小阶 R
        },
        Vec{
            .msg_hex = "9bd9f44f4dcc75bd531b56b2cd280b0bb38fc1cd6d1230e14861d861de092e79",
            .public_key_hex = "cdb267ce40c5cd45306fa5d2f29731459387dbf9eb933b7bd5aed9a765b88d4d",
            .sig_hex = "9046a64750444938de19f227bb80485e92b83fdb4b6506c160484c016cc1852f87909e14428a7a1d62e9f22f3d3ad7802db02eb2e688b6c52fcd6648a98bd009",
            .expected = null, // 3——混合阶
        },
        Vec{
            .msg_hex = "e47d62c63f830dc7a6851a0b1f33ae4bb2f507fb6cffec4011eaccd55b53f56c",
            .public_key_hex = "cdb267ce40c5cd45306fa5d2f29731459387dbf9eb933b7bd5aed9a765b88d4d",
            .sig_hex = "160a1cb0dc9c0258cd0a7d23e94d8fa878bcb1925f2c64246b2dee1796bed5125ec6bc982a269b723e0668e540911a9a6a58921d6925e434ab10aa7940551a09",
            .expected = null, // 4 - 带余因子的验证
        },
        Vec{
            .msg_hex = "e47d62c63f830dc7a6851a0b1f33ae4bb2f507fb6cffec4011eaccd55b53f56c",
            .public_key_hex = "cdb267ce40c5cd45306fa5d2f29731459387dbf9eb933b7bd5aed9a765b88d4d",
            .sig_hex = "21122a84e0b5fca4052f5b1235c80a537878b38f3142356b2c2384ebad4668b7e40bc836dac0f71076f9abe3a53f9c03c1ceeeddb658d0030494ace586687405",
            .expected = null, // 5——含余因子处理的验证
        },
        Vec{
            .msg_hex = "85e241a07d148b41e47d62c63f830dc7a6851a0b1f33ae4bb2f507fb6cffec40",
            .public_key_hex = "442aad9f089ad9e14647b1ef9099a1ff4798d78589e66f28eca69c11f582a623",
            .sig_hex = "e96f66be976d82e60150baecff9906684aebb1ef181f67a7189ac78ea23b6c0e547f7690a0e2ddcd04d87dbc3490dc19b3b3052f7ff0538cb68afb369ba3a514",
            .expected = error.NonCanonical, // 6 - S > L
        },
        Vec{
            .msg_hex = "85e241a07d148b41e47d62c63f830dc7a6851a0b1f33ae4bb2f507fb6cffec40",
            .public_key_hex = "442aad9f089ad9e14647b1ef9099a1ff4798d78589e66f28eca69c11f582a623",
            .sig_hex = "8ce5b96c8f26d0ab6c47958c9e68b937104cd36e13c33566acd2fe8d38aa19427e71f98a473474f2f13f06f97c20d58cc3f54b8bd0d272f42b695dd7e89a8c22",
            .expected = error.NonCanonical, // 7 - S >> L
        },
        Vec{
            .msg_hex = "9bedc267423725d473888631ebf45988bad3db83851ee85c85e241a07d148b41",
            .public_key_hex = "f7badec5b8abeaf699583992219b7b223f1df3fbbea919844e3f7c554a43dd43",
            .sig_hex = "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03be9678ac102edcd92b0210bb34d7428d12ffc5df5f37e359941266a4e35f0f",
            .expected = error.InvalidEncoding, // 8——非规范的 R
        },
        Vec{
            .msg_hex = "9bedc267423725d473888631ebf45988bad3db83851ee85c85e241a07d148b41",
            .public_key_hex = "f7badec5b8abeaf699583992219b7b223f1df3fbbea919844e3f7c554a43dd43",
            .sig_hex = "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffca8c5b64cd208982aa38d4936621a4775aa233aa0505711d8fdcfdaa943d4908",
            .expected = error.InvalidEncoding, // 9 - 非规范 R
        },
        Vec{
            .msg_hex = "e96b7021eb39c1a163b6da4e3093dcd3f21387da4cc4572be588fafae23c155b",
            .public_key_hex = "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
            .sig_hex = "a9d55260f765261eb9b84e106f665e00b867287a761990d7135963ee0a7d59dca5bb704786be79fc476f91d3f3f89b03984d8068dcf1bb7dfc6637b45450ac04",
            .expected = error.InvalidEncoding, // 10 - 小阶 A
        },
        Vec{
            .msg_hex = "39a591f5321bbe07fd5a23dc2f39d025d74526615746727ceefd6e82ae65c06f",
            .public_key_hex = "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
            .sig_hex = "a9d55260f765261eb9b84e106f665e00b867287a761990d7135963ee0a7d59dca5bb704786be79fc476f91d3f3f89b03984d8068dcf1bb7dfc6637b45450ac04",
            .expected = error.InvalidEncoding, // 11——小阶 A
        },
    };
    for (entries) |entry| {
        var msg: [64 / 2]u8 = undefined;
        const msg_len = entry.msg_hex.len / 2;
        _ = try fmt.hexToBytes(msg[0..msg_len], entry.msg_hex);
        var public_key_bytes: [32]u8 = undefined;
        _ = try fmt.hexToBytes(&public_key_bytes, entry.public_key_hex);
        const public_key = Ed25519.PublicKey.fromBytes(public_key_bytes) catch |err| {
            try std.testing.expectEqual(entry.expected.?, err);
            continue;
        };
        var sig_bytes: [64]u8 = undefined;
        _ = try fmt.hexToBytes(&sig_bytes, entry.sig_hex);
        const sig = Ed25519.Signature.fromBytes(sig_bytes);
        if (entry.expected) |error_type| {
            try std.testing.expectError(error_type, sig.verify(msg[0..msg_len], public_key));
        } else {
            try sig.verify(msg[0..msg_len], public_key);
        }
    }
}

test "with blind keys" {
    const io = std.testing.io;
    const BlindKeyPair = Ed25519.key_blinding.BlindKeyPair;

    // 创建标准 Ed25519 密钥对
    const kp = Ed25519.KeyPair.generate(io);

    // 创建随机盲化种子
    var blind: [32]u8 = undefined;
    io.random(&blind);

    // 盲化密钥对
    const blind_kp = try BlindKeyPair.init(kp, blind, "ctx");

    // 对消息签名,并检查是否可使用盲化公钥验证
    const msg = "test";
    const sig = try blind_kp.sign(msg, null);
    try sig.verify(msg, blind_kp.blind_public_key.key);

    // 解除公钥盲化
    const pk = try blind_kp.blind_public_key.unblind(blind, "ctx");
    try std.testing.expectEqualSlices(u8, &pk.toBytes(), &kp.public_key.toBytes());
}

test "signatures with streaming" {
    const io = std.testing.io;
    const kp = Ed25519.KeyPair.generate(io);

    var signer = try kp.signer(null, io);
    signer.update("mes");
    signer.update("sage");
    const sig = signer.finalize();

    try sig.verify("message", kp.public_key);

    var verifier = try sig.verifier(kp.public_key);
    verifier.update("mess");
    verifier.update("age");
    try verifier.verify();
}

test "key pair from secret key" {
    const io = std.testing.io;
    const kp = Ed25519.KeyPair.generate(io);
    const kp2 = try Ed25519.KeyPair.fromSecretKey(kp.secret_key);
    try std.testing.expectEqualSlices(u8, &kp.secret_key.toBytes(), &kp2.secret_key.toBytes());
    try std.testing.expectEqualSlices(u8, &kp.public_key.toBytes(), &kp2.public_key.toBytes());
}

test "cofactored vs cofactorless verification" {
    const msg_hex = "65643235353139766563746f72732033";
    const public_key_hex = "86e72f5c2a7215151059aa151c0ee6f8e2155d301402f35d7498f078629a8f79";
    const sig_hex = "fa9dde274f4820efb19a890f8ba2d8791710a4303ceef4aedf9dddc4e81a1f11701a598b9a02ae60505dd0c2938a1a0c2d6ffd4676cfb49125b19e9cb358da06";

    var msg: [16]u8 = undefined;
    _ = try fmt.hexToBytes(&msg, msg_hex);

    var pk_bytes: [32]u8 = undefined;
    _ = try fmt.hexToBytes(&pk_bytes, public_key_hex);
    const pk = try Ed25519.PublicKey.fromBytes(pk_bytes);

    var sig_bytes: [64]u8 = undefined;
    _ = try fmt.hexToBytes(&sig_bytes, sig_hex);
    const sig = Ed25519.Signature.fromBytes(sig_bytes);

    try sig.verify(&msg, pk);

    try std.testing.expectError(
        error.SignatureVerificationFailed,
        sig.verifyStrict(&msg, pk),
    );
}

test "regular signature verifies with both verify and verifyStrict" {
    const io = std.testing.io;
    const kp = Ed25519.KeyPair.generate(io);
    const msg = "test message";
    const sig = try kp.sign(msg, null);
    try sig.verify(msg, kp.public_key);
    try sig.verifyStrict(msg, kp.public_key);
}