跳转到内容

std.crypto.Certificate

标准库Zig 0.17.1官方原文
源码std/crypto/Certificate.zig

第 1 行

字段

buffer: []const u8
index: u32

std.crypto.Certificate.Algorithm

容器

第 12 行

字段

sha1WithRSAEncryption
sha224WithRSAEncryption
sha256WithRSAEncryption
sha384WithRSAEncryption
sha512WithRSAEncryption
ecdsa_with_SHA224
ecdsa_with_SHA256
ecdsa_with_SHA384
ecdsa_with_SHA512
md2WithRSAEncryption
md5WithRSAEncryption
curveEd25519

std.crypto.Certificate.Algorithm.Hash

类型函数

第 41 行

pub fn Hash(comptime algorithm: Algorithm) type

参数

algorithm: Algorithm

std.crypto.Certificate.Algorithm.map

常量

第 26 行

std.crypto.Certificate.AlgorithmCategory

容器

第 54 行

字段

rsaEncryption
rsassa_pss
X9_62_id_ecPublicKey
curveEd25519

std.crypto.Certificate.AlgorithmCategory.map

常量

第 60 行

std.crypto.Certificate.Attribute

容器

第 68 行

字段

commonName
serialNumber
countryName
localityName
stateOrProvinceName
streetAddress
organizationName
organizationalUnitName
postalCode
organizationIdentifier
pkcs9_emailAddress
domainComponent

std.crypto.Certificate.Attribute.map

常量

第 82 行

std.crypto.Certificate.builtin

常量

第 919 行

std.crypto.Certificate.Bundle

别名

第 4 行

别名目标 std.crypto.Certificate.Bundle

std.crypto.Certificate.Certificate

别名

第 923 行

别名目标 std.crypto.Certificate

std.crypto.Certificate.Chain

类型

第 5 行

std.crypto.Certificate.contents

函数

第 613 行

pub fn contents(cert: Certificate, elem: der.Element) []const u8

参数

cert: Certificate
elem: der.Element

std.crypto.Certificate.crypto

别名

第 921 行

别名目标 std.crypto

std.crypto.Certificate.Date

容器

第 670 行

字段

year: u16

示例:1999

month: u8

范围:1 至 12

day: u8

范围:1 到 31

hour: u8

范围:0 至 59

minute: u8

范围:0 至 59

second: u8

范围:0 至 59

std.crypto.Certificate.Date.toSeconds

函数

第 685 行

转换为自纪元起经过的秒数。

pub fn toSeconds(date: Date) u64

参数

date: Date

std.crypto.Certificate.der

命名空间

第 925 行

std.crypto.Certificate.der.Class

容器

第 926 行

字段

universal
application
context_specific
private

std.crypto.Certificate.der.Element

容器

第 958 行

字段

identifier: Identifier
slice: Slice

std.crypto.Certificate.der.Element.parse

函数

第 971 行

pub fn parse(bytes: []const u8, index: u32) Element.ParseError!Element

参数

bytes: []const u8
index: u32

错误

CertificateFieldHasInvalidLength

std.crypto.Certificate.der.Element.ParseError

错误集合

第 969 行

错误

CertificateFieldHasInvalidLength

std.crypto.Certificate.der.Element.Slice

容器

第 962 行

字段

start: u32
end: u32

std.crypto.Certificate.der.Element.Slice.empty

常量

第 966 行

Slice

std.crypto.Certificate.der.Identifier

容器

第 938 行

字段

tag: Tag
pc: PC
class: Class

std.crypto.Certificate.der.PC

容器

第 933 行

字段

primitive
constructed

std.crypto.Certificate.der.Tag

容器

第 944 行

字段

boolean = 1
integer = 2
bitstring = 3
octetstring = 4
null = 5
object_identifier = 6
sequence = 16
set = 17
utc_time = 23
generalized_time = 24
_

std.crypto.Certificate.ExtensionId

容器

第 118 行

字段

subject_key_identifier
key_usage
private_key_usage_period
subject_alt_name
issuer_alt_name
basic_constraints
crl_number
certificate_policies
authority_key_identifier
msCertsrvCAVersion
commonName
ext_key_usage
crl_distribution_points
info_access
entrustVersInfo
enroll_certtype
pe_logotype
netscape_cert_type
netscape_comment

std.crypto.Certificate.ExtensionId.map

常量

第 139 行

std.crypto.Certificate.GeneralNameTag

容器

第 165 行

字段

otherName = 0
rfc822Name = 1
dNSName = 2
x400Address = 3
directoryName = 4
ediPartyName = 5
uniformResourceIdentifier = 6
iPAddress = 7
registeredID = 8
_

std.crypto.Certificate.mem

别名

第 922 行

别名目标 std.mem

std.crypto.Certificate.NamedCurve

容器

第 98 行

字段

secp384r1
secp521r1
X9_62_prime256v1

std.crypto.Certificate.NamedCurve.Curve

类型函数

第 109 行

pub fn Curve(comptime curve: NamedCurve) type

参数

curve: NamedCurve

std.crypto.Certificate.NamedCurve.map

常量

第 103 行

std.crypto.Certificate.net

别名

第 178 行

别名目标 std.Io.net

std.crypto.Certificate.parse

函数

第 478 行

pub fn parse(cert: Certificate) ParseError!Parsed

参数

cert: Certificate

错误

CertificateFieldHasInvalidLength ParseError
CertificateFieldHasWrongDataType ParseTimeError
CertificateHasInvalidBitString ParseBitStringError
CertificateHasUnrecognizedObjectId ParseEnumError
CertificateTimeInvalid ParseTimeError
UnsupportedCertificateVersion ParseVersionError

std.crypto.Certificate.parseAlgorithm

函数

第 783 行

pub fn parseAlgorithm(bytes: []const u8, element: der.Element) ParseEnumError!Algorithm

参数

bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.parseAlgorithmCategory

函数

第 787 行

pub fn parseAlgorithmCategory(bytes: []const u8, element: der.Element) ParseEnumError!AlgorithmCategory

参数

bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.parseAttribute

函数

第 791 行

pub fn parseAttribute(bytes: []const u8, element: der.Element) ParseEnumError!Attribute

参数

bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.parseBitString

函数

第 619 行

pub fn parseBitString(cert: Certificate, elem: der.Element) !der.Element.Slice

参数

cert: Certificate
elem: der.Element

std.crypto.Certificate.ParseBitStringError

错误集合

第 617 行

错误

CertificateFieldHasWrongDataType
CertificateHasInvalidBitString

std.crypto.Certificate.Parsed

容器

第 180 行

字段

certificate: Certificate
issuer_slice: Slice
subject_slice: Slice
common_name_slice: Slice
signature_slice: Slice
signature_algorithm: Algorithm
pub_key_algo: PubKeyAlgo
pub_key_slice: Slice
message_slice: Slice
subject_alt_name_slice: Slice
validity: Validity
version: Version

std.crypto.Certificate.Parsed.checkHostName

函数

第 357 行

fn checkHostName(host_name: []const u8, dns_name: []const u8) bool

参数

host_name: []const u8
dns_name: []const u8

std.crypto.Certificate.Parsed.checkIpAddress

函数

第 388 行

fn checkIpAddress(host_name: []const u8, ip_address: []const u8) bool

参数

host_name: []const u8
ip_address: []const u8

std.crypto.Certificate.Parsed.commonName

函数

第 220 行

pub fn commonName(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.issuer

函数

第 212 行

pub fn issuer(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.message

函数

第 232 行

pub fn message(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.pubKey

函数

第 228 行

pub fn pubKey(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.PubKeyAlgo

容器

第 194 行

字段

rsaEncryption: void
rsassa_pss: void
X9_62_id_ecPublicKey: NamedCurve
curveEd25519: void

std.crypto.Certificate.Parsed.signature

函数

第 224 行

pub fn signature(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.slice

函数

第 208 行

pub fn slice(p: Parsed, s: Slice) []const u8

参数

p: Parsed
s: Slice

std.crypto.Certificate.Parsed.Slice

别名

第 206 行

别名目标 std.crypto.Certificate.der.Element.Slice

std.crypto.Certificate.Parsed.subject

函数

第 216 行

pub fn subject(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.subjectAltName

函数

第 236 行

pub fn subjectAltName(p: Parsed) []const u8

参数

p: Parsed

std.crypto.Certificate.Parsed.Validity

容器

第 201 行

字段

not_before: u64
not_after: u64

std.crypto.Certificate.Parsed.verify

函数

第 259 行

此函数验证:

  • 主体的签发者确实为提供的签发者。
  • 主体的时间有效性。
  • 签名。
pub fn verify(parsed_subject: Parsed, parsed_issuer: Parsed, now_sec: i64) VerifyError!void

参数

parsed_subject: Parsed
parsed_issuer: Parsed
now_sec: i64

错误

CertificateExpired
CertificateFieldHasInvalidLength
CertificateFieldHasWrongDataType
CertificateIssuerMismatch
CertificateNotYetValid
CertificatePublicKeyInvalid
CertificateSignatureAlgorithmMismatch
CertificateSignatureAlgorithmUnsupported
CertificateSignatureInvalid
CertificateSignatureInvalidLength
CertificateSignatureNamedCurveUnsupported
CertificateSignatureUnsupportedBitCount

std.crypto.Certificate.Parsed.VerifyError

错误集合

第 240 行

错误

CertificateExpired
CertificateFieldHasInvalidLength
CertificateFieldHasWrongDataType
CertificateIssuerMismatch
CertificateNotYetValid
CertificatePublicKeyInvalid
CertificateSignatureAlgorithmMismatch
CertificateSignatureAlgorithmUnsupported
CertificateSignatureInvalid
CertificateSignatureInvalidLength
CertificateSignatureNamedCurveUnsupported
CertificateSignatureUnsupportedBitCount

std.crypto.Certificate.Parsed.verifyHostName

函数

第 315 行

pub fn verifyHostName(parsed_subject: Parsed, host_name: []const u8) VerifyHostNameError!void

参数

parsed_subject: Parsed
host_name: []const u8

错误

CertificateFieldHasInvalidLength
CertificateHostMismatch

std.crypto.Certificate.Parsed.VerifyHostNameError

错误集合

第 310 行

错误

CertificateFieldHasInvalidLength
CertificateHostMismatch

std.crypto.Certificate.parseEnum

函数

第 805 行

fn parseEnum(comptime E: type, bytes: []const u8, element: der.Element) ParseEnumError!E

参数

E: type
bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.ParseEnumError

错误集合

第 803 行

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.ParseError

错误集合

第 476 行

错误

CertificateFieldHasInvalidLength ParseError
CertificateFieldHasWrongDataType ParseTimeError
CertificateHasInvalidBitString ParseBitStringError
CertificateHasUnrecognizedObjectId ParseEnumError
CertificateTimeInvalid ParseTimeError
UnsupportedCertificateVersion ParseVersionError

std.crypto.Certificate.parseExtensionId

函数

第 799 行

pub fn parseExtensionId(bytes: []const u8, element: der.Element) ParseEnumError!ExtensionId

参数

bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.parseNamedCurve

函数

第 795 行

pub fn parseNamedCurve(bytes: []const u8, element: der.Element) ParseEnumError!NamedCurve

参数

bytes: []const u8
element: der.Element

错误

CertificateFieldHasWrongDataType
CertificateHasUnrecognizedObjectId

std.crypto.Certificate.parseTime

函数

第 628 行

返回自纪元开始经过的秒数。

pub fn parseTime(cert: Certificate, elem: der.Element) ParseTimeError!u64

参数

cert: Certificate
elem: der.Element

错误

CertificateFieldHasWrongDataType
CertificateTimeInvalid

std.crypto.Certificate.parseTimeDigits

函数

第 716 行

pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8

参数

text: *const [2]u8
min: u8
max: u8

用法示例

test parseTimeDigits {
    const expectEqual = std.testing.expectEqual;
    try expectEqual(@as(u8, 0), try parseTimeDigits("00", 0, 99));
    try expectEqual(@as(u8, 99), try parseTimeDigits("99", 0, 99));
    try expectEqual(@as(u8, 42), try parseTimeDigits("42", 0, 99));

    const expectError = std.testing.expectError;
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("13", 1, 12));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("00", 1, 12));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("Di", 0, 99));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("0:", 1, 31));
}

std.crypto.Certificate.ParseTimeError

错误集合

第 625 行

错误

CertificateFieldHasWrongDataType
CertificateTimeInvalid

std.crypto.Certificate.parseVersion

函数

第 814 行

pub fn parseVersion(bytes: []const u8, version_elem: der.Element) ParseVersionError!Version

参数

bytes: []const u8
version_elem: der.Element

错误

CertificateFieldHasInvalidLength
UnsupportedCertificateVersion

std.crypto.Certificate.ParseVersionError

错误集合

第 812 行

错误

CertificateFieldHasInvalidLength
UnsupportedCertificateVersion

std.crypto.Certificate.parseYear4

函数

第 754 行

pub fn parseYear4(text: *const [4]u8) !u16

参数

text: *const [4]u8

用法示例

test parseYear4 {
    const expectEqual = std.testing.expectEqual;
    try expectEqual(@as(u16, 0), try parseYear4("0000"));
    try expectEqual(@as(u16, 9999), try parseYear4("9999"));
    try expectEqual(@as(u16, 1988), try parseYear4("1988"));

    const expectError = std.testing.expectError;
    try expectError(error.CertificateTimeInvalid, parseYear4("999b"));
    try expectError(error.CertificateTimeInvalid, parseYear4("crap"));
    try expectError(error.CertificateTimeInvalid, parseYear4("r:bQ"));
    try expectError(error.CertificateTimeInvalid, parseYear4("000:"));
    try expectError(error.CertificateTimeInvalid, parseYear4("0???"));
    try expectError(error.CertificateTimeInvalid, parseYear4("*zig"));
}

std.crypto.Certificate.rsa

命名空间

第 1013 行

std.crypto.Certificate.rsa.encrypt

函数

第 1366 行

fn encrypt(comptime modulus_len: usize, msg: *const [modulus_len]u8, public_key: PublicKey) EncryptError![modulus_len]u8

参数

modulus_len: usize
msg: *const [modulus_len]u8
public_key: PublicKey

错误

MessageTooLong

std.crypto.Certificate.rsa.EncryptError

错误集合

第 1364 行

错误

MessageTooLong

std.crypto.Certificate.rsa.Fe

常量

第 1017 行

std.crypto.Certificate.rsa.max_modulus_bits

常量

第 1014 行

std.crypto.Certificate.rsa.Modulus

类型

第 1016 行

std.crypto.Certificate.rsa.PKCS1v1_5Signature

命名空间

第 1183 行

RFC 3447 8.2 RSASSA-PKCS1-v1_5

std.crypto.Certificate.rsa.PKCS1v1_5Signature.concatVerify

函数

第 1203 行

pub fn concatVerify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void

参数

modulus_len: usize
sig: *const [modulus_len]u8
msg: []const []const u8
public_key: PublicKey
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PKCS1v1_5Signature.EMSA_PKCS1_V1_5_ENCODE

函数

第 1215 行

fn EMSA_PKCS1_V1_5_ENCODE(msg: []const []const u8, comptime emLen: usize, comptime Hash: type) VerifyError![emLen]u8

参数

msg: []const []const u8
emLen: usize
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PKCS1v1_5Signature.fromBytes

函数

第 1184 行

pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8

参数

modulus_len: usize
msg: []const u8

std.crypto.Certificate.rsa.PKCS1v1_5Signature.verify

函数

第 1193 行

pub fn verify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void

参数

modulus_len: usize
sig: *const [modulus_len]u8
msg: []const u8
public_key: PublicKey
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PKCS1v1_5Signature.VerifyError

错误集合

第 1191 行

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PSSSignature

命名空间

第 1020 行

RFC 3447 8.1 的 RSASSA-PSS

std.crypto.Certificate.rsa.PSSSignature.concatVerify

函数

第 1040 行

pub fn concatVerify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void

参数

modulus_len: usize
sig: *const [modulus_len]u8
msg: []const []const u8
public_key: PublicKey
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PSSSignature.EMSA_PSS_VERIFY

函数

第 1053 行

fn EMSA_PSS_VERIFY(msg: []const []const u8, em: []const u8, emBit: usize, sLen: usize, comptime Hash: type) VerifyError!void

参数

msg: []const []const u8
em: []const u8
emBit: usize
sLen: usize
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PSSSignature.fromBytes

函数

第 1021 行

pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8

参数

modulus_len: usize
msg: []const u8

std.crypto.Certificate.rsa.PSSSignature.MGF1

函数

第 1166 行

fn MGF1(comptime Hash: type, out: []u8, seed: *const [Hash.digest_length]u8, len: usize) ![]u8

参数

Hash: type
out: []u8
seed: *const [Hash.digest_length]u8
len: usize

std.crypto.Certificate.rsa.PSSSignature.verify

函数

第 1030 行

pub fn verify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void

参数

modulus_len: usize
sig: *const [modulus_len]u8
msg: []const u8
public_key: PublicKey
Hash: type

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PSSSignature.VerifyError

错误集合

第 1028 行

错误

InvalidSignature
MessageTooLong EncryptError

std.crypto.Certificate.rsa.PublicKey

容器

第 1312 行

字段

n: Modulus
e: Fe

std.crypto.Certificate.rsa.PublicKey.fromBytes

函数

第 1318 行

pub fn fromBytes(pub_bytes: []const u8, modulus_bytes: []const u8) FromBytesError!PublicKey

参数

pub_bytes: []const u8
modulus_bytes: []const u8

错误

CertificatePublicKeyInvalid

std.crypto.Certificate.rsa.PublicKey.FromBytesError

错误集合

第 1316 行

错误

CertificatePublicKeyInvalid

std.crypto.Certificate.rsa.PublicKey.parseDer

函数

第 1345 行

pub fn parseDer(pub_key: []const u8) ParseDerError!struct { modulus: []const u8, exponent: []const u8 }

参数

pub_key: []const u8

错误

CertificateFieldHasInvalidLength ParseError
CertificateFieldHasWrongDataType

std.crypto.Certificate.rsa.PublicKey.ParseDerError

错误集合

第 1343 行

错误

CertificateFieldHasInvalidLength ParseError
CertificateFieldHasWrongDataType

std.crypto.Certificate.rsa.Uint

类型

第 1015 行

std.crypto.Certificate.std

别名

第 920 行

别名目标 std

std.crypto.Certificate.verify

函数

第 607 行

pub fn verify(subject: Certificate, issuer: Certificate, now_sec: i64) !void

参数

subject: Certificate
issuer: Certificate
now_sec: i64

std.crypto.Certificate.verify_ecdsa

函数

第 859 行

fn verify_ecdsa( comptime Hash: type, message: []const u8, encoded_sig: []const u8, pub_key_algo: Parsed.PubKeyAlgo, sec1_pub_key: []const u8, ) !void

参数

Hash: type
message: []const u8
encoded_sig: []const u8
pub_key_algo: Parsed.PubKeyAlgo
sec1_pub_key: []const u8

std.crypto.Certificate.verifyEd25519

函数

第 896 行

fn verifyEd25519( message: []const u8, encoded_sig: []const u8, pub_key_algo: Parsed.PubKeyAlgo, encoded_pub_key: []const u8, ) !void

参数

message: []const u8
encoded_sig: []const u8
pub_key_algo: Parsed.PubKeyAlgo
encoded_pub_key: []const u8

std.crypto.Certificate.verifyRsa

函数

第 834 行

fn verifyRsa( comptime Hash: type, msg: []const u8, sig: []const u8, pub_key_algo: Parsed.PubKeyAlgo, pub_key: []const u8, ) !void

参数

Hash: type
msg: []const u8
sig: []const u8
pub_key_algo: Parsed.PubKeyAlgo
pub_key: []const u8

std.crypto.Certificate.Version

容器

第 10 行

字段

v1
v2
v3
源码

std/crypto/Certificate.zig

buffer: []const u8,
index: u32,

pub const Bundle = @import("Certificate/Bundle.zig");
pub const Chain = switch (builtin.os.tag) {
    else => void, // 并非兼容垫片,以便同时避免开销较大的调用方逻辑。
    .windows => @import("Certificate/Chain.zig"),
};

pub const Version = enum { v1, v2, v3 };

pub const Algorithm = enum {
    sha1WithRSAEncryption,
    sha224WithRSAEncryption,
    sha256WithRSAEncryption,
    sha384WithRSAEncryption,
    sha512WithRSAEncryption,
    ecdsa_with_SHA224,
    ecdsa_with_SHA256,
    ecdsa_with_SHA384,
    ecdsa_with_SHA512,
    md2WithRSAEncryption,
    md5WithRSAEncryption,
    curveEd25519,

    pub const map = std.StaticStringMap(Algorithm).initComptime(.{
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05 }, .sha1WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B }, .sha256WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0C }, .sha384WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0D }, .sha512WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0E }, .sha224WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01 }, .ecdsa_with_SHA224 },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 }, .ecdsa_with_SHA256 },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03 }, .ecdsa_with_SHA384 },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04 }, .ecdsa_with_SHA512 },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x02 }, .md2WithRSAEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x04 }, .md5WithRSAEncryption },
        .{ &.{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
    });

    pub fn Hash(comptime algorithm: Algorithm) type {
        return switch (algorithm) {
            .sha1WithRSAEncryption => crypto.hash.Sha1,
            .ecdsa_with_SHA224, .sha224WithRSAEncryption => crypto.hash.sha2.Sha224,
            .ecdsa_with_SHA256, .sha256WithRSAEncryption => crypto.hash.sha2.Sha256,
            .ecdsa_with_SHA384, .sha384WithRSAEncryption => crypto.hash.sha2.Sha384,
            .ecdsa_with_SHA512, .sha512WithRSAEncryption, .curveEd25519 => crypto.hash.sha2.Sha512,
            .md2WithRSAEncryption => @compileError("unimplemented"),
            .md5WithRSAEncryption => crypto.hash.Md5,
        };
    }
};

pub const AlgorithmCategory = enum {
    rsaEncryption,
    rsassa_pss,
    X9_62_id_ecPublicKey,
    curveEd25519,

    pub const map = std.StaticStringMap(AlgorithmCategory).initComptime(.{
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 }, .rsaEncryption },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0A }, .rsassa_pss },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01 }, .X9_62_id_ecPublicKey },
        .{ &.{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
    });
};

pub const Attribute = enum {
    commonName,
    serialNumber,
    countryName,
    localityName,
    stateOrProvinceName,
    streetAddress,
    organizationName,
    organizationalUnitName,
    postalCode,
    organizationIdentifier,
    pkcs9_emailAddress,
    domainComponent,

    pub const map = std.StaticStringMap(Attribute).initComptime(.{
        .{ &.{ 0x55, 0x04, 0x03 }, .commonName },
        .{ &.{ 0x55, 0x04, 0x05 }, .serialNumber },
        .{ &.{ 0x55, 0x04, 0x06 }, .countryName },
        .{ &.{ 0x55, 0x04, 0x07 }, .localityName },
        .{ &.{ 0x55, 0x04, 0x08 }, .stateOrProvinceName },
        .{ &.{ 0x55, 0x04, 0x09 }, .streetAddress },
        .{ &.{ 0x55, 0x04, 0x0A }, .organizationName },
        .{ &.{ 0x55, 0x04, 0x0B }, .organizationalUnitName },
        .{ &.{ 0x55, 0x04, 0x11 }, .postalCode },
        .{ &.{ 0x55, 0x04, 0x61 }, .organizationIdentifier },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x01 }, .pkcs9_emailAddress },
        .{ &.{ 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x19 }, .domainComponent },
    });
};

pub const NamedCurve = enum {
    secp384r1,
    secp521r1,
    X9_62_prime256v1,

    pub const map = std.StaticStringMap(NamedCurve).initComptime(.{
        .{ &.{ 0x2B, 0x81, 0x04, 0x00, 0x22 }, .secp384r1 },
        .{ &.{ 0x2B, 0x81, 0x04, 0x00, 0x23 }, .secp521r1 },
        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 }, .X9_62_prime256v1 },
    });

    pub fn Curve(comptime curve: NamedCurve) type {
        return switch (curve) {
            .X9_62_prime256v1 => crypto.ecc.P256,
            .secp384r1 => crypto.ecc.P384,
            .secp521r1 => @compileError("unimplemented"),
        };
    }
};

pub const ExtensionId = enum {
    subject_key_identifier,
    key_usage,
    private_key_usage_period,
    subject_alt_name,
    issuer_alt_name,
    basic_constraints,
    crl_number,
    certificate_policies,
    authority_key_identifier,
    msCertsrvCAVersion,
    commonName,
    ext_key_usage,
    crl_distribution_points,
    info_access,
    entrustVersInfo,
    enroll_certtype,
    pe_logotype,
    netscape_cert_type,
    netscape_comment,

    pub const map = std.StaticStringMap(ExtensionId).initComptime(.{
        .{ &.{ 0x55, 0x04, 0x03 }, .commonName },
        .{ &.{ 0x55, 0x1D, 0x01 }, .authority_key_identifier },
        .{ &.{ 0x55, 0x1D, 0x07 }, .subject_alt_name },
        .{ &.{ 0x55, 0x1D, 0x0E }, .subject_key_identifier },
        .{ &.{ 0x55, 0x1D, 0x0F }, .key_usage },
        .{ &.{ 0x55, 0x1D, 0x0A }, .basic_constraints },
        .{ &.{ 0x55, 0x1D, 0x10 }, .private_key_usage_period },
        .{ &.{ 0x55, 0x1D, 0x11 }, .subject_alt_name },
        .{ &.{ 0x55, 0x1D, 0x12 }, .issuer_alt_name },
        .{ &.{ 0x55, 0x1D, 0x13 }, .basic_constraints },
        .{ &.{ 0x55, 0x1D, 0x14 }, .crl_number },
        .{ &.{ 0x55, 0x1D, 0x1F }, .crl_distribution_points },
        .{ &.{ 0x55, 0x1D, 0x20 }, .certificate_policies },
        .{ &.{ 0x55, 0x1D, 0x23 }, .authority_key_identifier },
        .{ &.{ 0x55, 0x1D, 0x25 }, .ext_key_usage },
        .{ &.{ 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x15, 0x01 }, .msCertsrvCAVersion },
        .{ &.{ 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01 }, .info_access },
        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF6, 0x7D, 0x07, 0x41, 0x00 }, .entrustVersInfo },
        .{ &.{ 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14, 0x02 }, .enroll_certtype },
        .{ &.{ 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x0c }, .pe_logotype },
        .{ &.{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x01 }, .netscape_cert_type },
        .{ &.{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d }, .netscape_comment },
    });
};

pub const GeneralNameTag = enum(u5) {
    otherName = 0,
    rfc822Name = 1,
    dNSName = 2,
    x400Address = 3,
    directoryName = 4,
    ediPartyName = 5,
    uniformResourceIdentifier = 6,
    iPAddress = 7,
    registeredID = 8,
    _,
};

const net = @import("../Io/net.zig");

pub const Parsed = struct {
    certificate: Certificate,
    issuer_slice: Slice,
    subject_slice: Slice,
    common_name_slice: Slice,
    signature_slice: Slice,
    signature_algorithm: Algorithm,
    pub_key_algo: PubKeyAlgo,
    pub_key_slice: Slice,
    message_slice: Slice,
    subject_alt_name_slice: Slice,
    validity: Validity,
    version: Version,

    pub const PubKeyAlgo = union(AlgorithmCategory) {
        rsaEncryption: void,
        rsassa_pss: void,
        X9_62_id_ecPublicKey: NamedCurve,
        curveEd25519: void,
    };

    pub const Validity = struct {
        not_before: u64,
        not_after: u64,
    };

    pub const Slice = der.Element.Slice;

    pub fn slice(p: Parsed, s: Slice) []const u8 {
        return p.certificate.buffer[s.start..s.end];
    }

    pub fn issuer(p: Parsed) []const u8 {
        return p.slice(p.issuer_slice);
    }

    pub fn subject(p: Parsed) []const u8 {
        return p.slice(p.subject_slice);
    }

    pub fn commonName(p: Parsed) []const u8 {
        return p.slice(p.common_name_slice);
    }

    pub fn signature(p: Parsed) []const u8 {
        return p.slice(p.signature_slice);
    }

    pub fn pubKey(p: Parsed) []const u8 {
        return p.slice(p.pub_key_slice);
    }

    pub fn message(p: Parsed) []const u8 {
        return p.slice(p.message_slice);
    }

    pub fn subjectAltName(p: Parsed) []const u8 {
        return p.slice(p.subject_alt_name_slice);
    }

    pub const VerifyError = error{
        CertificateIssuerMismatch,
        CertificateNotYetValid,
        CertificateExpired,
        CertificateSignatureAlgorithmUnsupported,
        CertificateSignatureAlgorithmMismatch,
        CertificateFieldHasInvalidLength,
        CertificateFieldHasWrongDataType,
        CertificatePublicKeyInvalid,
        CertificateSignatureInvalidLength,
        CertificateSignatureInvalid,
        CertificateSignatureUnsupportedBitCount,
        CertificateSignatureNamedCurveUnsupported,
    };

    /// 此函数验证:
    ///  * 主体的签发者确实为提供的签发者。
    ///  * 主体的时间有效性。
    ///  * 签名。
    pub fn verify(parsed_subject: Parsed, parsed_issuer: Parsed, now_sec: i64) VerifyError!void {
        // 检查主体的签发者名称是否与签发者的主体名称匹配。
        //
        if (!mem.eql(u8, parsed_subject.issuer(), parsed_issuer.subject())) {
            return error.CertificateIssuerMismatch;
        }

        if (now_sec < parsed_subject.validity.not_before)
            return error.CertificateNotYetValid;
        if (now_sec > parsed_subject.validity.not_after)
            return error.CertificateExpired;

        switch (parsed_subject.signature_algorithm) {
            inline .sha1WithRSAEncryption,
            .sha224WithRSAEncryption,
            .sha256WithRSAEncryption,
            .sha384WithRSAEncryption,
            .sha512WithRSAEncryption,
            => |algorithm| return verifyRsa(
                algorithm.Hash(),
                parsed_subject.message(),
                parsed_subject.signature(),
                parsed_issuer.pub_key_algo,
                parsed_issuer.pubKey(),
            ),

            inline .ecdsa_with_SHA224,
            .ecdsa_with_SHA256,
            .ecdsa_with_SHA384,
            .ecdsa_with_SHA512,
            => |algorithm| return verify_ecdsa(
                algorithm.Hash(),
                parsed_subject.message(),
                parsed_subject.signature(),
                parsed_issuer.pub_key_algo,
                parsed_issuer.pubKey(),
            ),

            .md2WithRSAEncryption, .md5WithRSAEncryption => {
                return error.CertificateSignatureAlgorithmUnsupported;
            },

            .curveEd25519 => return verifyEd25519(
                parsed_subject.message(),
                parsed_subject.signature(),
                parsed_issuer.pub_key_algo,
                parsed_issuer.pubKey(),
            ),
        }
    }

    pub const VerifyHostNameError = error{
        CertificateHostMismatch,
        CertificateFieldHasInvalidLength,
    };

    pub fn verifyHostName(parsed_subject: Parsed, host_name: []const u8) VerifyHostNameError!void {
        // 若存在主体备用名称扩展,则检查该扩展。
        // 否则,仅检查通用名称。
        const subject_alt_name = parsed_subject.subjectAltName();
        if (subject_alt_name.len == 0) {
            // 注意:有意省略 checkIpAddress,因为通用名称字段本就不允许它。
            if (checkHostName(host_name, parsed_subject.commonName())) {
                return;
            } else {
                return error.CertificateHostMismatch;
            }
        }

        const general_names = try der.Element.parse(subject_alt_name, 0);
        var name_i = general_names.slice.start;
        while (name_i < general_names.slice.end) {
            const general_name = try der.Element.parse(subject_alt_name, name_i);
            name_i = general_name.slice.end;
            switch (@as(GeneralNameTag, @fromBackingInt(@intCast(@backingInt(general_name.identifier.tag))))) {
                .dNSName => {
                    const dns_name = subject_alt_name[general_name.slice.start..general_name.slice.end];
                    if (checkHostName(host_name, dns_name)) return;
                },
                .iPAddress => {
                    const ip_address = subject_alt_name[general_name.slice.start..general_name.slice.end];
                    if (checkIpAddress(host_name, ip_address)) return;
                },
                else => {},
            }
        }

        return error.CertificateHostMismatch;
    }

    // 按 RFC2818 规范检查主机名:
    //
    // 如果证书中存在给定类型的多个身份,
    // 例如多个 DNSName 名称,则只要其中任意一个
    // 匹配即可接受。名称可以包含通配符
    // *,它匹配任意单个域名
    // 分量。例如,*.a.com 匹配 foo.a.com,但不匹配 bar.foo.a.com。
    // 不支持 f*.com 这样的部分通配符。
    fn checkHostName(host_name: []const u8, dns_name: []const u8) bool {
        // 空字符串不应匹配
        if (host_name.len == 0 or dns_name.len == 0) return false;

        // RFC 6125 第 6.4.1 节:精确匹配(不区分大小写)
        if (std.ascii.eqlIgnoreCase(dns_name, host_name)) {
            return true; // 精确匹配
        }

        // RFC 6125 第 6.4.3 节:通配符证书。
        // 通配符必须是最左侧的标签,形式为 "*.rest.of.domain"。
        if (dns_name.len >= 3 and mem.startsWith(u8, dns_name, "*.")) {
            const wildcard_suffix = dns_name[2..];

            // 后缀中不允许有额外通配符
            if (mem.find(u8, wildcard_suffix, "*") != null) return false;

            // 查找主机名中的第一个点,将首个标签与其余部分分开。
            const dot_pos = mem.find(u8, host_name, ".") orelse return false;

            // 通配符恰好匹配一个标签,因此比较其余部分
            const host_suffix = host_name[dot_pos + 1 ..];

            // 匹配后缀(按 RFC 6125,不区分大小写)
            return std.ascii.eqlIgnoreCase(wildcard_suffix, host_suffix);
        }

        return false;
    }

    // 依照 RFC 5280 第 4.2.1.6 节检查 IP 地址。
    fn checkIpAddress(host_name: []const u8, ip_address: []const u8) bool {
        switch (ip_address.len) {
            4 => {
                // 端口与 SAN 匹配无关,因此使用 0 作为无害的占位值。
                const address = net.Ip4Address.parse(host_name, 0) catch return false;
                return mem.eql(u8, &address.bytes, ip_address);
            },
            16 => {
                const address = net.Ip6Address.parse(host_name, 0) catch return false;
                return mem.eql(u8, &address.bytes, ip_address);
            },
            else => return false, // 格式错误的证书,既非 4 个也非 16 个八位字节
        }
    }
};

test "Parsed.checkHostName RFC 6125 compliance" {
    const expectEqual = std.testing.expectEqual;

    // 精确匹配测试
    try expectEqual(true, Parsed.checkHostName("ziglang.org", "ziglang.org"));
    try expectEqual(true, Parsed.checkHostName("ziglang.org", "Ziglang.org")); // 不区分大小写
    try expectEqual(true, Parsed.checkHostName("ZIGLANG.ORG", "ziglang.org")); // 不区分大小写

    // 有效的通配符匹配
    try expectEqual(true, Parsed.checkHostName("bar.ziglang.org", "*.ziglang.org"));
    try expectEqual(true, Parsed.checkHostName("BAR.ziglang.org", "*.Ziglang.ORG")); // 不区分大小写

    // RFC 6125:通配符恰好匹配一个标签
    try expectEqual(false, Parsed.checkHostName("foo.bar.ziglang.org", "*.ziglang.org"));
    try expectEqual(false, Parsed.checkHostName("ziglang.org", "*.ziglang.org")); // 无空匹配

    // RFC 6125:不允许部分通配符
    try expectEqual(false, Parsed.checkHostName("ziglang.org", "zig*.org"));
    try expectEqual(false, Parsed.checkHostName("ziglang.org", "*lang.org"));
    try expectEqual(false, Parsed.checkHostName("ziglang.org", "zi*ng.org"));

    // RFC 6125:不允许多个通配符
    try expectEqual(false, Parsed.checkHostName("foo.bar.org", "*.*.org"));

    // RFC 6125:通配符必须位于最左侧标签中
    try expectEqual(false, Parsed.checkHostName("foo.bar.org", "foo.*.org"));

    // 仅含一个标签的主机名不应匹配通配符
    try expectEqual(false, Parsed.checkHostName("localhost", "*.local"));
    try expectEqual(false, Parsed.checkHostName("localhost", "*.localhost"));

    // 边界情况
    try expectEqual(false, Parsed.checkHostName("", ""));
    try expectEqual(false, Parsed.checkHostName("example.com", ""));
    try expectEqual(false, Parsed.checkHostName("", "*.example.com"));
    try expectEqual(false, Parsed.checkHostName("example.com", "*"));
    try expectEqual(false, Parsed.checkHostName("example.com", "*."));
}

test "Parsed.checkIpAddress RFC 5280 4.2.1.6 compliance" {
    const expectEqual = std.testing.expectEqual;

    // 精确匹配的正向测试
    try expectEqual(true, Parsed.checkIpAddress("127.0.0.1", &[4]u8{ 127, 0, 0, 1 }));
    try expectEqual(true, Parsed.checkIpAddress("0:0:0:0:0:0:0:1", &[16]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }));

    // 不应让不匹配通过
    try expectEqual(false, Parsed.checkIpAddress("1.2.3.4", &[4]u8{ 5, 6, 7, 8 }));
    try expectEqual(false, Parsed.checkIpAddress("0:0:0:0:0:0:0:1", &[16]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 }));

    // IPv6:主机名可能采用缩写形式,应与 SAN 中指定的 16 个八位字节精确匹配
    try expectEqual(true, Parsed.checkIpAddress("::1", &[16]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }));

    // IPv6:使用 DNS64/NAT64,即 64:ff9b::/96 时,不进行匹配。
    // RFC 要求八位组精确匹配,因此这一行为可能出人意料且有误。此处出于高度谨慎而采用安全失败策略。
    // 测试断言并非要固化此行为,而是表明已考虑此使用场景。
    // 将来如果找到有效场景,此检查可能放宽。
    try expectEqual(false, Parsed.checkIpAddress("64:ff9b::192.0.2.10", &[4]u8{ 192, 0, 2, 10 }));
    try expectEqual(false, Parsed.checkIpAddress("::ffff:127.0.0.1", &[4]u8{ 127, 0, 0, 1 }));

    // 格式错误的 SAN 长度(不是 4 或 16 字节)永不匹配。
    try expectEqual(false, Parsed.checkIpAddress("127.0.0", &[_]u8{ 127, 0, 0 }));
    try expectEqual(false, Parsed.checkIpAddress("127.0.0.1.0", &[_]u8{ 127, 0, 0, 1, 0 }));

    // 不可解析的 host_name 永不匹配。
    try expectEqual(false, Parsed.checkIpAddress("not-an-ip", &[4]u8{ 127, 0, 0, 1 }));

    // 边界情况 - 空字符串
    try expectEqual(false, Parsed.checkIpAddress("", ""));
    try expectEqual(false, Parsed.checkIpAddress("127.0.0.1", ""));
}

pub const ParseError = der.Element.ParseError || ParseVersionError || ParseTimeError || ParseEnumError || ParseBitStringError;

pub fn parse(cert: Certificate) ParseError!Parsed {
    const cert_bytes = cert.buffer;
    const certificate = try der.Element.parse(cert_bytes, cert.index);
    const tbs_certificate = try der.Element.parse(cert_bytes, certificate.slice.start);
    const version_elem = try der.Element.parse(cert_bytes, tbs_certificate.slice.start);
    const version = try parseVersion(cert_bytes, version_elem);
    const serial_number = if (@as(u8, @bitCast(version_elem.identifier)) == 0xa0)
        try der.Element.parse(cert_bytes, version_elem.slice.end)
    else
        version_elem;
    // RFC 5280,第 4.1.2.3 节:
    // "此字段必须包含与 Certificate 序列中的
    // signatureAlgorithm 字段相同的算法标识符。"
    const tbs_signature = try der.Element.parse(cert_bytes, serial_number.slice.end);
    const issuer = try der.Element.parse(cert_bytes, tbs_signature.slice.end);
    const validity = try der.Element.parse(cert_bytes, issuer.slice.end);
    const not_before = try der.Element.parse(cert_bytes, validity.slice.start);
    const not_before_utc = try parseTime(cert, not_before);
    const not_after = try der.Element.parse(cert_bytes, not_before.slice.end);
    const not_after_utc = try parseTime(cert, not_after);
    const subject = try der.Element.parse(cert_bytes, validity.slice.end);

    const pub_key_info = try der.Element.parse(cert_bytes, subject.slice.end);
    const pub_key_signature_algorithm = try der.Element.parse(cert_bytes, pub_key_info.slice.start);
    const pub_key_algo_elem = try der.Element.parse(cert_bytes, pub_key_signature_algorithm.slice.start);
    const pub_key_algo: Parsed.PubKeyAlgo = switch (try parseAlgorithmCategory(cert_bytes, pub_key_algo_elem)) {
        inline else => |tag| @unionInit(Parsed.PubKeyAlgo, @tagName(tag), {}),
        .X9_62_id_ecPublicKey => pub_key_algo: {
            // RFC 5480 第 2.1.1.1 节,命名曲线。
            // ECParameters ::= CHOICE {
            //   namedCurve         OBJECT IDENTIFIER
            //   -- implicitCurve   NULL
            //   -- specifiedCurve  SpecifiedECDomain
            // }
            const params_elem = try der.Element.parse(cert_bytes, pub_key_algo_elem.slice.end);
            const named_curve = try parseNamedCurve(cert_bytes, params_elem);
            break :pub_key_algo .{ .X9_62_id_ecPublicKey = named_curve };
        },
    };
    const pub_key_elem = try der.Element.parse(cert_bytes, pub_key_signature_algorithm.slice.end);
    const pub_key = try parseBitString(cert, pub_key_elem);

    var common_name = der.Element.Slice.empty;
    var name_i = subject.slice.start;
    while (name_i < subject.slice.end) {
        const rdn = try der.Element.parse(cert_bytes, name_i);
        var rdn_i = rdn.slice.start;
        while (rdn_i < rdn.slice.end) {
            const atav = try der.Element.parse(cert_bytes, rdn_i);
            var atav_i = atav.slice.start;
            while (atav_i < atav.slice.end) {
                const ty_elem = try der.Element.parse(cert_bytes, atav_i);
                const val = try der.Element.parse(cert_bytes, ty_elem.slice.end);
                atav_i = val.slice.end;
                const ty = parseAttribute(cert_bytes, ty_elem) catch |err| switch (err) {
                    error.CertificateHasUnrecognizedObjectId => continue,
                    else => |e| return e,
                };
                switch (ty) {
                    .commonName => common_name = val.slice,
                    else => {},
                }
            }
            rdn_i = atav.slice.end;
        }
        name_i = rdn.slice.end;
    }

    const sig_algo = try der.Element.parse(cert_bytes, tbs_certificate.slice.end);
    const algo_elem = try der.Element.parse(cert_bytes, sig_algo.slice.start);
    const signature_algorithm = try parseAlgorithm(cert_bytes, algo_elem);
    const sig_elem = try der.Element.parse(cert_bytes, sig_algo.slice.end);
    const signature = try parseBitString(cert, sig_elem);

    // 扩展
    var subject_alt_name_slice = der.Element.Slice.empty;
    ext: {
        if (version == .v1)
            break :ext;

        if (pub_key_info.slice.end >= tbs_certificate.slice.end)
            break :ext;

        const outer_extensions = try der.Element.parse(cert_bytes, pub_key_info.slice.end);
        if (outer_extensions.identifier.tag != .bitstring)
            break :ext;

        const extensions = try der.Element.parse(cert_bytes, outer_extensions.slice.start);

        var ext_i = extensions.slice.start;
        while (ext_i < extensions.slice.end) {
            const extension = try der.Element.parse(cert_bytes, ext_i);
            ext_i = extension.slice.end;
            const oid_elem = try der.Element.parse(cert_bytes, extension.slice.start);
            const ext_id = parseExtensionId(cert_bytes, oid_elem) catch |err| switch (err) {
                error.CertificateHasUnrecognizedObjectId => continue,
                else => |e| return e,
            };
            const critical_elem = try der.Element.parse(cert_bytes, oid_elem.slice.end);
            const ext_bytes_elem = if (critical_elem.identifier.tag != .boolean)
                critical_elem
            else
                try der.Element.parse(cert_bytes, critical_elem.slice.end);
            switch (ext_id) {
                .subject_alt_name => subject_alt_name_slice = ext_bytes_elem.slice,
                else => continue,
            }
        }
    }

    return .{
        .certificate = cert,
        .common_name_slice = common_name,
        .issuer_slice = issuer.slice,
        .subject_slice = subject.slice,
        .signature_slice = signature,
        .signature_algorithm = signature_algorithm,
        .message_slice = .{ .start = certificate.slice.start, .end = tbs_certificate.slice.end },
        .pub_key_algo = pub_key_algo,
        .pub_key_slice = pub_key,
        .validity = .{
            .not_before = not_before_utc,
            .not_after = not_after_utc,
        },
        .subject_alt_name_slice = subject_alt_name_slice,
        .version = version,
    };
}

pub fn verify(subject: Certificate, issuer: Certificate, now_sec: i64) !void {
    const parsed_subject = try subject.parse();
    const parsed_issuer = try issuer.parse();
    return parsed_subject.verify(parsed_issuer, now_sec);
}

pub fn contents(cert: Certificate, elem: der.Element) []const u8 {
    return cert.buffer[elem.slice.start..elem.slice.end];
}

pub const ParseBitStringError = error{ CertificateFieldHasWrongDataType, CertificateHasInvalidBitString };

pub fn parseBitString(cert: Certificate, elem: der.Element) !der.Element.Slice {
    if (elem.identifier.tag != .bitstring) return error.CertificateFieldHasWrongDataType;
    if (cert.buffer[elem.slice.start] != 0) return error.CertificateHasInvalidBitString;
    return .{ .start = elem.slice.start + 1, .end = elem.slice.end };
}

pub const ParseTimeError = error{ CertificateTimeInvalid, CertificateFieldHasWrongDataType };

/// 返回自纪元开始经过的秒数。
pub fn parseTime(cert: Certificate, elem: der.Element) ParseTimeError!u64 {
    const bytes = cert.contents(elem);
    switch (elem.identifier.tag) {
        .utc_time => {
            // 示例:"YYMMDD000000Z"
            if (bytes.len != 13)
                return error.CertificateTimeInvalid;
            if (bytes[12] != 'Z')
                return error.CertificateTimeInvalid;

            return Date.toSeconds(.{
                .year = blk: {
                    const year = try parseTimeDigits(bytes[0..2], 0, 99);
                    break :blk if (year < 50) @as(u16, 2000) + year else @as(u16, 1900) + year;
                },
                .month = try parseTimeDigits(bytes[2..4], 1, 12),
                .day = try parseTimeDigits(bytes[4..6], 1, 31),
                .hour = try parseTimeDigits(bytes[6..8], 0, 23),
                .minute = try parseTimeDigits(bytes[8..10], 0, 59),
                .second = try parseTimeDigits(bytes[10..12], 0, 59),
            });
        },
        .generalized_time => {
            // 示例:
            // "19920521000000Z"
            // "19920622123421Z"
            // "19920722132100.3Z"
            if (bytes.len < 15)
                return error.CertificateTimeInvalid;
            return Date.toSeconds(.{
                .year = try parseYear4(bytes[0..4]),
                .month = try parseTimeDigits(bytes[4..6], 1, 12),
                .day = try parseTimeDigits(bytes[6..8], 1, 31),
                .hour = try parseTimeDigits(bytes[8..10], 0, 23),
                .minute = try parseTimeDigits(bytes[10..12], 0, 59),
                .second = try parseTimeDigits(bytes[12..14], 0, 59),
            });
        },
        else => return error.CertificateFieldHasWrongDataType,
    }
}

const Date = struct {
    /// 示例:1999
    year: u16,
    /// 范围:1 至 12
    month: u8,
    /// 范围:1 到 31
    day: u8,
    /// 范围:0 至 59
    hour: u8,
    /// 范围:0 至 59
    minute: u8,
    /// 范围:0 至 59
    second: u8,

    /// 转换为自纪元起经过的秒数。
    pub fn toSeconds(date: Date) u64 {
        var sec: u64 = 0;

        {
            var year: u16 = 1970;
            while (year < date.year) : (year += 1) {
                const days: u64 = std.time.epoch.getDaysInYear(year);
                sec += days * std.time.epoch.secs_per_day;
            }
        }

        {
            var month: u4 = 1;
            while (month < date.month) : (month += 1) {
                const days: u64 = std.time.epoch.getDaysInMonth(
                    date.year,
                    @fromBackingInt(@intCast(month)),
                );
                sec += days * std.time.epoch.secs_per_day;
            }
        }

        sec += (date.day - 1) * @as(u64, std.time.epoch.secs_per_day);
        sec += date.hour * @as(u64, 60 * 60);
        sec += date.minute * @as(u64, 60);
        sec += date.second;

        return sec;
    }
};

pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8 {
    const V = @Vector(2, u16);
    const bytes: V = text.*;
    const zero: V = @splat('0');
    const mm: V = .{ 10, 1 };
    const d = bytes -% zero;
    if (@reduce(.Or, d > @as(V, @splat(9)))) {
        @branchHint(.unlikely);
        return error.CertificateTimeInvalid;
    }
    const result = @reduce(.Add, d *% mm);
    if (result < min) return error.CertificateTimeInvalid;
    if (result > max) return error.CertificateTimeInvalid;
    return @intCast(result);
}

test "parseTime UTCTime year mapping per RFC 5280" {
    const utc_time_id: der.Identifier = .{ .tag = .utc_time, .pc = .primitive, .class = .universal };
    const elem = der.Element{ .identifier = utc_time_id, .slice = .{ .start = 0, .end = 13 } };
    const cert49 = Certificate{ .buffer = "490101000000Z", .index = 0 };
    try std.testing.expectEqual(@as(u64, 2493072000), try cert49.parseTime(elem));
    const cert99 = Certificate{ .buffer = "990101000000Z", .index = 0 };
    try std.testing.expectEqual(@as(u64, 915148800), try cert99.parseTime(elem));
}

test parseTimeDigits {
    const expectEqual = std.testing.expectEqual;
    try expectEqual(@as(u8, 0), try parseTimeDigits("00", 0, 99));
    try expectEqual(@as(u8, 99), try parseTimeDigits("99", 0, 99));
    try expectEqual(@as(u8, 42), try parseTimeDigits("42", 0, 99));

    const expectError = std.testing.expectError;
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("13", 1, 12));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("00", 1, 12));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("Di", 0, 99));
    try expectError(error.CertificateTimeInvalid, parseTimeDigits("0:", 1, 31));
}

pub fn parseYear4(text: *const [4]u8) !u16 {
    const V = @Vector(4, u32);
    const bytes: V = text.*;
    const zero: V = @splat('0');
    const mmmm: V = .{ 1000, 100, 10, 1 };
    const d = bytes -% zero;
    if (@reduce(.Or, d > @as(V, @splat(9)))) {
        @branchHint(.unlikely);
        return error.CertificateTimeInvalid;
    }
    const result = @reduce(.Add, d *% mmmm);
    return @intCast(result);
}

test parseYear4 {
    const expectEqual = std.testing.expectEqual;
    try expectEqual(@as(u16, 0), try parseYear4("0000"));
    try expectEqual(@as(u16, 9999), try parseYear4("9999"));
    try expectEqual(@as(u16, 1988), try parseYear4("1988"));

    const expectError = std.testing.expectError;
    try expectError(error.CertificateTimeInvalid, parseYear4("999b"));
    try expectError(error.CertificateTimeInvalid, parseYear4("crap"));
    try expectError(error.CertificateTimeInvalid, parseYear4("r:bQ"));
    try expectError(error.CertificateTimeInvalid, parseYear4("000:"));
    try expectError(error.CertificateTimeInvalid, parseYear4("0???"));
    try expectError(error.CertificateTimeInvalid, parseYear4("*zig"));
}

pub fn parseAlgorithm(bytes: []const u8, element: der.Element) ParseEnumError!Algorithm {
    return parseEnum(Algorithm, bytes, element);
}

pub fn parseAlgorithmCategory(bytes: []const u8, element: der.Element) ParseEnumError!AlgorithmCategory {
    return parseEnum(AlgorithmCategory, bytes, element);
}

pub fn parseAttribute(bytes: []const u8, element: der.Element) ParseEnumError!Attribute {
    return parseEnum(Attribute, bytes, element);
}

pub fn parseNamedCurve(bytes: []const u8, element: der.Element) ParseEnumError!NamedCurve {
    return parseEnum(NamedCurve, bytes, element);
}

pub fn parseExtensionId(bytes: []const u8, element: der.Element) ParseEnumError!ExtensionId {
    return parseEnum(ExtensionId, bytes, element);
}

pub const ParseEnumError = error{ CertificateFieldHasWrongDataType, CertificateHasUnrecognizedObjectId };

fn parseEnum(comptime E: type, bytes: []const u8, element: der.Element) ParseEnumError!E {
    if (element.identifier.tag != .object_identifier)
        return error.CertificateFieldHasWrongDataType;
    const oid_bytes = bytes[element.slice.start..element.slice.end];
    return E.map.get(oid_bytes) orelse return error.CertificateHasUnrecognizedObjectId;
}

pub const ParseVersionError = error{ UnsupportedCertificateVersion, CertificateFieldHasInvalidLength };

pub fn parseVersion(bytes: []const u8, version_elem: der.Element) ParseVersionError!Version {
    if (@as(u8, @bitCast(version_elem.identifier)) != 0xa0)
        return .v1;

    if (version_elem.slice.end - version_elem.slice.start != 3)
        return error.CertificateFieldHasInvalidLength;

    const encoded_version = bytes[version_elem.slice.start..version_elem.slice.end];

    if (mem.eql(u8, encoded_version, "\x02\x01\x02")) {
        return .v3;
    } else if (mem.eql(u8, encoded_version, "\x02\x01\x01")) {
        return .v2;
    } else if (mem.eql(u8, encoded_version, "\x02\x01\x00")) {
        return .v1;
    }

    return error.UnsupportedCertificateVersion;
}

fn verifyRsa(
    comptime Hash: type,
    msg: []const u8,
    sig: []const u8,
    pub_key_algo: Parsed.PubKeyAlgo,
    pub_key: []const u8,
) !void {
    if (pub_key_algo != .rsaEncryption) return error.CertificateSignatureAlgorithmMismatch;
    const pk_components = try rsa.PublicKey.parseDer(pub_key);
    const exponent = pk_components.exponent;
    const modulus = pk_components.modulus;
    if (exponent.len > modulus.len) return error.CertificatePublicKeyInvalid;
    if (sig.len != modulus.len) return error.CertificateSignatureInvalidLength;

    switch (modulus.len) {
        inline 128, 256, 384, 512 => |modulus_len| {
            const public_key = rsa.PublicKey.fromBytes(exponent, modulus) catch
                return error.CertificateSignatureInvalid;
            rsa.PKCS1v1_5Signature.verify(modulus_len, sig[0..modulus_len], msg, public_key, Hash) catch
                return error.CertificateSignatureInvalid;
        },
        else => return error.CertificateSignatureUnsupportedBitCount,
    }
}

fn verify_ecdsa(
    comptime Hash: type,
    message: []const u8,
    encoded_sig: []const u8,
    pub_key_algo: Parsed.PubKeyAlgo,
    sec1_pub_key: []const u8,
) !void {
    const sig_named_curve = switch (pub_key_algo) {
        .X9_62_id_ecPublicKey => |named_curve| named_curve,
        else => return error.CertificateSignatureAlgorithmMismatch,
    };

    switch (sig_named_curve) {
        .secp521r1 => {
            return error.CertificateSignatureNamedCurveUnsupported;
        },
        inline .X9_62_prime256v1,
        .secp384r1,
        => |curve| {
            const Ecdsa = crypto.sign.ecdsa.Ecdsa(curve.Curve(), Hash);
            const sig = Ecdsa.Signature.fromDer(encoded_sig) catch |err| switch (err) {
                error.InvalidEncoding => return error.CertificateSignatureInvalid,
            };
            const pub_key = Ecdsa.PublicKey.fromSec1(sec1_pub_key) catch |err| switch (err) {
                error.InvalidEncoding => return error.CertificateSignatureInvalid,
                error.NonCanonical => return error.CertificateSignatureInvalid,
                error.NotSquare => return error.CertificateSignatureInvalid,
            };
            sig.verify(message, pub_key) catch |err| switch (err) {
                error.IdentityElement => return error.CertificateSignatureInvalid,
                error.NonCanonical => return error.CertificateSignatureInvalid,
                error.SignatureVerificationFailed => return error.CertificateSignatureInvalid,
            };
        },
    }
}

fn verifyEd25519(
    message: []const u8,
    encoded_sig: []const u8,
    pub_key_algo: Parsed.PubKeyAlgo,
    encoded_pub_key: []const u8,
) !void {
    if (pub_key_algo != .curveEd25519) return error.CertificateSignatureAlgorithmMismatch;
    const Ed25519 = crypto.sign.Ed25519;
    if (encoded_sig.len != Ed25519.Signature.encoded_length) return error.CertificateSignatureInvalid;
    const sig = Ed25519.Signature.fromBytes(encoded_sig[0..Ed25519.Signature.encoded_length].*);
    if (encoded_pub_key.len != Ed25519.PublicKey.encoded_length) return error.CertificateSignatureInvalid;
    const pub_key = Ed25519.PublicKey.fromBytes(encoded_pub_key[0..Ed25519.PublicKey.encoded_length].*) catch |err| switch (err) {
        error.NonCanonical => return error.CertificateSignatureInvalid,
    };
    sig.verify(message, pub_key) catch |err| switch (err) {
        error.IdentityElement => return error.CertificateSignatureInvalid,
        error.NonCanonical => return error.CertificateSignatureInvalid,
        error.SignatureVerificationFailed => return error.CertificateSignatureInvalid,
        error.InvalidEncoding => return error.CertificateSignatureInvalid,
        error.WeakPublicKey => return error.CertificateSignatureInvalid,
    };
}

const builtin = @import("builtin");
const std = @import("../std.zig");
const crypto = std.crypto;
const mem = std.mem;
const Certificate = @This();

pub const der = struct {
    pub const Class = enum(u2) {
        universal,
        application,
        context_specific,
        private,
    };

    pub const PC = enum(u1) {
        primitive,
        constructed,
    };

    pub const Identifier = packed struct(u8) {
        tag: Tag,
        pc: PC,
        class: Class,
    };

    pub const Tag = enum(u5) {
        boolean = 1,
        integer = 2,
        bitstring = 3,
        octetstring = 4,
        null = 5,
        object_identifier = 6,
        sequence = 16,
        set = 17,
        utc_time = 23,
        generalized_time = 24,
        _,
    };

    pub const Element = struct {
        identifier: Identifier,
        slice: Slice,

        pub const Slice = struct {
            start: u32,
            end: u32,

            pub const empty: Slice = .{ .start = 0, .end = 0 };
        };

        pub const ParseError = error{CertificateFieldHasInvalidLength};

        pub fn parse(bytes: []const u8, index: u32) Element.ParseError!Element {
            var i = index;
            const identifier: Identifier = @bitCast(bytes[i]);
            i += 1;
            const size_byte = bytes[i];
            i += 1;
            if ((size_byte >> 7) == 0) {
                return .{
                    .identifier = identifier,
                    .slice = .{
                        .start = i,
                        .end = i + size_byte,
                    },
                };
            }

            const len_size: u7 = @truncate(size_byte);
            if (len_size > @sizeOf(u32)) {
                return error.CertificateFieldHasInvalidLength;
            }

            const end_i = i + len_size;
            var long_form_size: u32 = 0;
            while (i < end_i) : (i += 1) {
                long_form_size = (long_form_size << 8) | bytes[i];
            }

            return .{
                .identifier = identifier,
                .slice = .{
                    .start = i,
                    .end = i + long_form_size,
                },
            };
        }
    };
};

test {
    _ = Bundle;
}

pub const rsa = struct {
    const max_modulus_bits = 4096;
    const Uint = std.crypto.ff.Uint(max_modulus_bits);
    const Modulus = std.crypto.ff.Modulus(max_modulus_bits);
    const Fe = Modulus.Fe;

    /// RFC 3447 8.1 的 RSASSA-PSS
    pub const PSSSignature = struct {
        pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8 {
            var result: [modulus_len]u8 = undefined;
            @memcpy(result[0..msg.len], msg);
            @memset(result[msg.len..], 0);
            return result;
        }

        pub const VerifyError = EncryptError || error{InvalidSignature};

        pub fn verify(
            comptime modulus_len: usize,
            sig: *const [modulus_len]u8,
            msg: []const u8,
            public_key: PublicKey,
            comptime Hash: type,
        ) VerifyError!void {
            try concatVerify(modulus_len, sig, &.{msg}, public_key, Hash);
        }

        pub fn concatVerify(
            comptime modulus_len: usize,
            sig: *const [modulus_len]u8,
            msg: []const []const u8,
            public_key: PublicKey,
            comptime Hash: type,
        ) VerifyError!void {
            const mod_bits = public_key.n.bits();
            const em_dec = try encrypt(modulus_len, sig, public_key);

            try EMSA_PSS_VERIFY(msg, &em_dec, mod_bits - 1, Hash.digest_length, Hash);
        }

        fn EMSA_PSS_VERIFY(msg: []const []const u8, em: []const u8, emBit: usize, sLen: usize, comptime Hash: type) VerifyError!void {
            // 1.   如果 M 的长度大于哈希函数的输入限制,
            //      对 SHA-1 即 2^61 - 1 个八位组,则输出
            //      "inconsistent" 并停止。
            // 标准库中的所有密码学哈希函数的上限均 >= 2^61 - 1。
            // 即便如此,此检查也只是出于过度谨慎。在 TLS 证书上下文中,emBit 不可能超过 4096。
            if (emBit >= 1 << 61) return error.InvalidSignature;

            // emLen = \ceil(emBits/8)
            const emLen = ((emBit - 1) / 8) + 1;
            std.debug.assert(emLen == em.len);

            // 2. 令 mHash = Hash(M),它是长度为 hLen 的八位字节串。
            var mHash: [Hash.digest_length]u8 = undefined;
            {
                var hasher: Hash = .init(.{});
                for (msg) |part| hasher.update(part);
                hasher.final(&mHash);
            }

            // 3. 若 emLen < hLen + sLen + 2,输出 "inconsistent" 并停止。
            if (emLen < Hash.digest_length + sLen + 2) {
                return error.InvalidSignature;
            }

            // 4.   如果 EM 最右侧八位组的十六进制值
            //      不是 0xbc,则输出 "inconsistent" 并停止。
            if (em[em.len - 1] != 0xbc) {
                return error.InvalidSignature;
            }

            // 5.   令 maskedDB 为 EM 最左侧的 emLen - hLen - 1 个八位字节,
            //      H 为随后的 hLen 个八位字节。
            const maskedDB = em[0..(emLen - Hash.digest_length - 1)];
            const h = em[(emLen - Hash.digest_length - 1)..(emLen - 1)][0..Hash.digest_length];

            // 6. 若 maskedDB 最左侧八位字节中,最左侧 8emLen - emBits 位
            //    并非全部为零,则输出“inconsistent”
            //    并停止。
            const zero_bits = emLen * 8 - emBit;
            var mask: u8 = maskedDB[0];
            var i: usize = 0;
            while (i < 8 - zero_bits) : (i += 1) {
                mask = mask >> 1;
            }
            if (mask != 0) {
                return error.InvalidSignature;
            }

            // 7. 令 dbMask = MGF(H, emLen - hLen - 1)。
            const mgf_len = emLen - Hash.digest_length - 1;
            var mgf_out_buf: [512]u8 = undefined;
            if (mgf_len > mgf_out_buf.len) { // 模数 > 4096 位
                return error.InvalidSignature;
            }
            const mgf_out = mgf_out_buf[0 .. ((mgf_len - 1) / Hash.digest_length + 1) * Hash.digest_length];
            var dbMask = try MGF1(Hash, mgf_out, h, mgf_len);

            // 8. 令 DB = maskedDB \xor dbMask。
            i = 0;
            while (i < dbMask.len) : (i += 1) {
                dbMask[i] = maskedDB[i] ^ dbMask[i];
            }

            // 9.   将 DB 最左侧八位字节中最左边的
            //      8emLen - emBits 位设为零。
            i = 0;
            mask = 0;
            while (i < 8 - zero_bits) : (i += 1) {
                mask = mask << 1;
                mask += 1;
            }
            dbMask[0] = dbMask[0] & mask;

            // 10. 如果 DB 中最左侧的 emLen - hLen - sLen - 2 个八位组不为
            //      零,或者位置 emLen - hLen - sLen - 1 处的八位组(
            //      最左位置为“位置 1”)的十六进制
            //      值不为 0x01,则输出“inconsistent”并停止。
            if (dbMask[mgf_len - sLen - 2] != 0x00) {
                return error.InvalidSignature;
            }

            if (dbMask[mgf_len - sLen - 1] != 0x01) {
                return error.InvalidSignature;
            }

            // 11. 令 salt 为 DB 的最后 sLen 个八位字节。
            const salt = dbMask[(mgf_len - sLen)..];

            // 12. 令
            //         M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt ;
            //      M' 是长度为 8 + hLen + sLen 的八位组字符串,
            //      开头有八个零八位组。
            if (sLen > Hash.digest_length) { // 大于哈希长度的种子没有作用
                return error.InvalidSignature;
            }
            var m_p_buf: [8 + Hash.digest_length + Hash.digest_length]u8 = undefined;
            var m_p = m_p_buf[0 .. 8 + Hash.digest_length + sLen];
            @memmove(m_p[0..8], @as(*const [8]u8, &@splat(0)));
            @memmove(m_p[8..][0..Hash.digest_length], &mHash);
            @memmove(m_p[(8 + Hash.digest_length)..], salt);

            // 13.  令 H' = Hash(M'),它是长度为 hLen 的八位字节串。
            var h_p: [Hash.digest_length]u8 = undefined;
            Hash.hash(m_p, &h_p, .{});

            // 14. 如果 H = H',则输出 "consistent";
            //     否则输出 "inconsistent"。
            if (!std.mem.eql(u8, h, &h_p)) {
                return error.InvalidSignature;
            }
        }

        fn MGF1(comptime Hash: type, out: []u8, seed: *const [Hash.digest_length]u8, len: usize) ![]u8 {
            var counter: u32 = 0;
            var idx: usize = 0;
            var hash = seed.* ++ @as([4]u8, undefined);

            while (idx < len) {
                std.mem.writeInt(u32, hash[seed.len..][0..4], counter, .big);
                Hash.hash(&hash, out[idx..][0..Hash.digest_length], .{});
                idx += Hash.digest_length;
                counter += 1;
            }

            return out[0..len];
        }
    };

    /// RFC 3447 8.2 RSASSA-PKCS1-v1_5
    pub const PKCS1v1_5Signature = struct {
        pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8 {
            var result: [modulus_len]u8 = undefined;
            @memcpy(result[0..msg.len], msg);
            @memset(result[msg.len..], 0);
            return result;
        }

        pub const VerifyError = EncryptError || error{InvalidSignature};

        pub fn verify(
            comptime modulus_len: usize,
            sig: *const [modulus_len]u8,
            msg: []const u8,
            public_key: PublicKey,
            comptime Hash: type,
        ) VerifyError!void {
            try concatVerify(modulus_len, sig, &.{msg}, public_key, Hash);
        }

        pub fn concatVerify(
            comptime modulus_len: usize,
            sig: *const [modulus_len]u8,
            msg: []const []const u8,
            public_key: PublicKey,
            comptime Hash: type,
        ) VerifyError!void {
            const em_dec = try encrypt(modulus_len, sig, public_key);
            const em = try EMSA_PKCS1_V1_5_ENCODE(msg, modulus_len, Hash);
            if (!std.mem.eql(u8, &em_dec, &em)) return error.InvalidSignature;
        }

        fn EMSA_PKCS1_V1_5_ENCODE(msg: []const []const u8, comptime emLen: usize, comptime Hash: type) VerifyError![emLen]u8 {
            comptime var em_index = emLen;
            var em: [emLen]u8 = undefined;

            // 1. 对消息 M 应用哈希函数,生成哈希值
            //    H:
            //
            //       H = Hash(M).
            //
            //    若哈希函数输出 "message too long,",则输出 "message
            //    too long" 并停止。
            var hasher: Hash = .init(.{});
            for (msg) |part| hasher.update(part);
            em_index -= Hash.digest_length;
            hasher.final(em[em_index..]);

            // 2. 使用可辨别编码规则 DER,将哈希函数的算法标识及哈希值编码为 DigestInfo 类型的 ASN.1 值,参见附录 A.2.4。DigestInfo 类型的语法如下:
            //
            //    DigestInfo ::= SEQUENCE {
            //        digestAlgorithm AlgorithmIdentifier,
            //        digest OCTET STRING
            //    }
            //
            //    第一个字段标识哈希函数,第二个字段包含哈希值。令 T 为 DigestInfo 值的 DER 编码,参见下文注释;tLen 为 T 的字节长度。
            //
            //
            //
            //
            //
            //
            const hash_der: []const u8 = &switch (Hash) {
                crypto.hash.Md5 => .{
                    0x30, 0x20, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86,
                    0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05, 0x05, 0x00,
                    0x04, 0x10,
                },
                crypto.hash.Sha1 => .{
                    0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e,
                    0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14,
                },
                crypto.hash.sha2.Sha224 => .{
                    0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05,
                    0x00, 0x04, 0x1c,
                },
                crypto.hash.sha2.Sha256 => .{
                    0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
                    0x00, 0x04, 0x20,
                },
                crypto.hash.sha2.Sha384 => .{
                    0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
                    0x00, 0x04, 0x30,
                },
                crypto.hash.sha2.Sha512 => .{
                    0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
                    0x00, 0x04, 0x40,
                },
                crypto.hash.sha3.Sha3_256 => .{
                    0x30, 0x31, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x08, 0x05,
                    0x00, 0x04, 0x20,
                },
                crypto.hash.sha3.Sha3_512 => .{
                    0x30, 0x51, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86,
                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x0a, 0x05,
                    0x00, 0x04, 0x40,
                },
                else => comptime unreachable,
            };
            em_index -= hash_der.len;
            @memcpy(em[em_index..][0..hash_der.len], hash_der);

            // 3. 如果 emLen < tLen + 11,则输出 "intended encoded message length too short"
            //    并停止。

            // 4. 生成由 emLen - tLen - 3 个八位字节组成的字符串 PS,
            //    每字节的十六进制值为 0xff。PS 的长度至少为
            //    8 个八位字节。
            em_index -= 1;
            @memset(em[2..em_index], 0xff);

            // 5. 连接 PS、DER 编码 T 和其他填充,形成
            //    编码消息 EM:
            //
            //       EM = 0x00 || 0x01 || PS || 0x00 || T。
            em[em_index] = 0x00;
            em[1] = 0x01;
            em[0] = 0x00;

            // 6. 输出 EM。
            return em;
        }
    };

    pub const PublicKey = struct {
        n: Modulus,
        e: Fe,

        pub const FromBytesError = error{CertificatePublicKeyInvalid};

        pub fn fromBytes(pub_bytes: []const u8, modulus_bytes: []const u8) FromBytesError!PublicKey {
            // 拒绝小于 512 位的模数。
            // 512 位 RSA 已在 1999 年被分解,因此此限制几乎没有意义;但先确立一个限制,以便在能力范围内逐步提高。
            //
            const _n = Modulus.fromBytes(modulus_bytes, .big) catch return error.CertificatePublicKeyInvalid;
            if (_n.bits() < 512) return error.CertificatePublicKeyInvalid;

            // 指数必须是大于 2 的奇数。
            // 此外,为缓解拒绝服务攻击,必须小于 2^32。
            // Windows CryptoAPI 不支持超过 32 位的值[1],因此
            // Windows 常见操作不太可能
            // 使用超过 32 位的指数。
            // [1] https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/ns-wincrypt-rsapubkey
            if (pub_bytes.len > 4) return error.CertificatePublicKeyInvalid;
            const _e = Fe.fromBytes(_n, pub_bytes, .big) catch return error.CertificatePublicKeyInvalid;
            if (!_e.isOdd()) return error.CertificatePublicKeyInvalid;
            const e_v = _e.toPrimitive(u32) catch return error.CertificatePublicKeyInvalid;
            if (e_v < 2) return error.CertificatePublicKeyInvalid;

            return .{
                .n = _n,
                .e = _e,
            };
        }

        pub const ParseDerError = der.Element.ParseError || error{CertificateFieldHasWrongDataType};

        pub fn parseDer(pub_key: []const u8) ParseDerError!struct { modulus: []const u8, exponent: []const u8 } {
            const pub_key_seq = try der.Element.parse(pub_key, 0);
            if (pub_key_seq.identifier.tag != .sequence) return error.CertificateFieldHasWrongDataType;
            const modulus_elem = try der.Element.parse(pub_key, pub_key_seq.slice.start);
            if (modulus_elem.identifier.tag != .integer) return error.CertificateFieldHasWrongDataType;
            const exponent_elem = try der.Element.parse(pub_key, modulus_elem.slice.end);
            if (exponent_elem.identifier.tag != .integer) return error.CertificateFieldHasWrongDataType;
            // 跳过模数中无意义的零。
            const modulus_raw = pub_key[modulus_elem.slice.start..modulus_elem.slice.end];
            const modulus_offset = for (modulus_raw, 0..) |byte, i| {
                if (byte != 0) break i;
            } else modulus_raw.len;
            return .{
                .modulus = modulus_raw[modulus_offset..],
                .exponent = pub_key[exponent_elem.slice.start..exponent_elem.slice.end],
            };
        }
    };

    const EncryptError = error{MessageTooLong};

    fn encrypt(comptime modulus_len: usize, msg: *const [modulus_len]u8, public_key: PublicKey) EncryptError![modulus_len]u8 {
        const m = Fe.fromBytes(public_key.n, msg, .big) catch return error.MessageTooLong;
        const e = public_key.n.powPublic(m, public_key.e) catch unreachable;
        var res: [modulus_len]u8 = undefined;
        e.toBytes(&res, .big) catch unreachable;
        return res;
    }
};

test "RSA-PSS verify wrapper" {
    const modulus_hex = "a1757161bd6ddb93e4a96329dfed3cf5bd729156686893b74e36cabfc929781316ab7a2ecab1d5a0e3fe1d2ab4b14f34dbb02d3a7c879fded3b2ba26d41f554a183f906b3b32a7c11be8194d25f7a26fef17020373fea72906ba2db5259a4ab4ba91937f078bcb57f9f82b06ca6dac17a2e0b673c721b1f7d0600b208fef0d43";
    const signature_hex = "32079b2b70f8828e4c70331abc9f08d2ccb805b29b7330c80f4ed17ddaa8c72b544faed138e9e7d41ca55e5770f408cb13d1149da7f1c13034dc5ce0da35dfc8417a2a8bfee1056b81e73954aae23acf6113c8db5b57b4a9242fd943c59c6b693d3d5d2dc40146dd75fc631507d1e43c6ce4f5a44b243804018107ae8bcacc86";
    var modulus: [modulus_hex.len / 2]u8 = undefined;
    _ = try std.fmt.hexToBytes(&modulus, modulus_hex);
    var signature: [signature_hex.len / 2]u8 = undefined;
    _ = try std.fmt.hexToBytes(&signature, signature_hex);
    const key = try rsa.PublicKey.fromBytes(&.{ 1, 0, 1 }, &modulus);
    const message = "Zig RSA-PSS wrapper regression";

    try rsa.PSSSignature.verify(signature.len, &signature, message, key, std.crypto.hash.sha2.Sha256);
    try std.testing.expectError(error.InvalidSignature, rsa.PSSSignature.verify(signature.len, &signature, "wrong message", key, std.crypto.hash.sha2.Sha256));
    signature[signature.len - 1] ^= 1;
    try std.testing.expectError(error.InvalidSignature, rsa.PSSSignature.verify(signature.len, &signature, message, key, std.crypto.hash.sha2.Sha256));
}