字段
buffer: []const u8
index: u32
BundleChainVersionAlgorithmAlgorithmCategoryAttributeNamedCurveExtensionIdGeneralNameTagnetParsedParseErrorparseverifycontentsParseBitStringErrorparseBitStringParseTimeErrorparseTimeDateparseTimeDigitsparseYear4parseAlgorithmparseAlgorithmCategoryparseAttributeparseNamedCurveparseExtensionIdParseEnumErrorparseEnumParseVersionErrorparseVersionverifyRsaverify_ecdsaverifyEd25519builtinstdcryptomemCertificatederrsa
std.crypto.Certificate.Algorithm
容器
字段
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
类型函数
pub fn Hash(comptime algorithm: Algorithm) type
参数
algorithm: Algorithm
std.crypto.Certificate.Algorithm.map
常量
std.crypto.Certificate.AlgorithmCategory
容器
字段
rsaEncryption
rsassa_pss
X9_62_id_ecPublicKey
curveEd25519
std.crypto.Certificate.AlgorithmCategory.map
常量
std.crypto.Certificate.Attribute
容器
字段
commonName
serialNumber
countryName
localityName
stateOrProvinceName
streetAddress
organizationName
organizationalUnitName
postalCode
organizationIdentifier
pkcs9_emailAddress
domainComponent
std.crypto.Certificate.Attribute.map
常量
std.crypto.Certificate.builtin
常量
std.crypto.Certificate.Bundle
别名
std.crypto.Certificate.Certificate
别名
std.crypto.Certificate.Chain
类型
std.crypto.Certificate.contents
函数
pub fn contents(cert: Certificate, elem: der.Element) []const u8
参数
cert: Certificate
elem: der.Element
std.crypto.Certificate.crypto
别名
别名目标 std.crypto
std.crypto.Certificate.Date
容器
字段
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
函数
转换为自纪元起经过的秒数。
pub fn toSeconds(date: Date) u64
参数
date: Date
std.crypto.Certificate.der
命名空间
std.crypto.Certificate.der.Class
容器
字段
universal
application
context_specific
private
std.crypto.Certificate.der.Element
容器
字段
identifier: Identifier
slice: Slice
std.crypto.Certificate.der.Element.parse
函数
pub fn parse(bytes: []const u8, index: u32) Element.ParseError!Element
参数
bytes: []const u8
index: u32
错误
- CertificateFieldHasInvalidLength
std.crypto.Certificate.der.Element.ParseError
错误集合
错误
- CertificateFieldHasInvalidLength
std.crypto.Certificate.der.Element.Slice
容器
字段
start: u32
end: u32
std.crypto.Certificate.der.Element.Slice.empty
常量
Slice
std.crypto.Certificate.der.Identifier
容器
字段
std.crypto.Certificate.der.PC
容器
字段
primitive
constructed
std.crypto.Certificate.der.Tag
容器
字段
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
容器
字段
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
常量
std.crypto.Certificate.GeneralNameTag
容器
字段
otherName = 0
rfc822Name = 1
dNSName = 2
x400Address = 3
directoryName = 4
ediPartyName = 5
uniformResourceIdentifier = 6
iPAddress = 7
registeredID = 8
_
std.crypto.Certificate.mem
别名
别名目标 std.mem
std.crypto.Certificate.NamedCurve
容器
字段
secp384r1
secp521r1
X9_62_prime256v1
std.crypto.Certificate.NamedCurve.Curve
类型函数
pub fn Curve(comptime curve: NamedCurve) type
参数
curve: NamedCurve
std.crypto.Certificate.NamedCurve.map
常量
std.crypto.Certificate.net
别名
别名目标 std.Io.net
std.crypto.Certificate.parse
函数
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
函数
pub fn parseAlgorithm(bytes: []const u8, element: der.Element) ParseEnumError!Algorithm
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.parseAlgorithmCategory
函数
pub fn parseAlgorithmCategory(bytes: []const u8, element: der.Element) ParseEnumError!AlgorithmCategory
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.parseAttribute
函数
pub fn parseAttribute(bytes: []const u8, element: der.Element) ParseEnumError!Attribute
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.parseBitString
函数
pub fn parseBitString(cert: Certificate, elem: der.Element) !der.Element.Slice
参数
cert: Certificate
elem: der.Element
std.crypto.Certificate.ParseBitStringError
错误集合
错误
- CertificateFieldHasWrongDataType
- CertificateHasInvalidBitString
std.crypto.Certificate.Parsed
容器
字段
std.crypto.Certificate.Parsed.checkHostName
函数
fn checkHostName(host_name: []const u8, dns_name: []const u8) bool
参数
host_name: []const u8
dns_name: []const u8
std.crypto.Certificate.Parsed.checkIpAddress
函数
fn checkIpAddress(host_name: []const u8, ip_address: []const u8) bool
参数
host_name: []const u8
ip_address: []const u8
std.crypto.Certificate.Parsed.commonName
函数
pub fn commonName(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.issuer
函数
pub fn issuer(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.message
函数
pub fn message(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.pubKey
函数
pub fn pubKey(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.PubKeyAlgo
容器
字段
std.crypto.Certificate.Parsed.signature
函数
pub fn signature(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.slice
函数
pub fn slice(p: Parsed, s: Slice) []const u8
参数
std.crypto.Certificate.Parsed.Slice
别名
std.crypto.Certificate.Parsed.subject
函数
pub fn subject(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.subjectAltName
函数
pub fn subjectAltName(p: Parsed) []const u8
参数
p: Parsed
std.crypto.Certificate.Parsed.Validity
容器
字段
not_before: u64
not_after: u64
std.crypto.Certificate.Parsed.verify
函数
此函数验证:
- 主体的签发者确实为提供的签发者。
- 主体的时间有效性。
- 签名。
pub fn verify(parsed_subject: Parsed, parsed_issuer: Parsed, now_sec: i64) VerifyError!void
参数
错误
- CertificateExpired
- CertificateFieldHasInvalidLength
- CertificateFieldHasWrongDataType
- CertificateIssuerMismatch
- CertificateNotYetValid
- CertificatePublicKeyInvalid
- CertificateSignatureAlgorithmMismatch
- CertificateSignatureAlgorithmUnsupported
- CertificateSignatureInvalid
- CertificateSignatureInvalidLength
- CertificateSignatureNamedCurveUnsupported
- CertificateSignatureUnsupportedBitCount
std.crypto.Certificate.Parsed.VerifyError
错误集合
错误
- CertificateExpired
- CertificateFieldHasInvalidLength
- CertificateFieldHasWrongDataType
- CertificateIssuerMismatch
- CertificateNotYetValid
- CertificatePublicKeyInvalid
- CertificateSignatureAlgorithmMismatch
- CertificateSignatureAlgorithmUnsupported
- CertificateSignatureInvalid
- CertificateSignatureInvalidLength
- CertificateSignatureNamedCurveUnsupported
- CertificateSignatureUnsupportedBitCount
std.crypto.Certificate.Parsed.verifyHostName
函数
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
错误集合
错误
- CertificateFieldHasInvalidLength
- CertificateHostMismatch
std.crypto.Certificate.parseEnum
函数
fn parseEnum(comptime E: type, bytes: []const u8, element: der.Element) ParseEnumError!E
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.ParseEnumError
错误集合
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.ParseError
错误集合
错误
- CertificateFieldHasInvalidLength ParseError
- CertificateFieldHasWrongDataType ParseTimeError
- CertificateHasInvalidBitString ParseBitStringError
- CertificateHasUnrecognizedObjectId ParseEnumError
- CertificateTimeInvalid ParseTimeError
- UnsupportedCertificateVersion ParseVersionError
std.crypto.Certificate.parseExtensionId
函数
pub fn parseExtensionId(bytes: []const u8, element: der.Element) ParseEnumError!ExtensionId
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.parseNamedCurve
函数
pub fn parseNamedCurve(bytes: []const u8, element: der.Element) ParseEnumError!NamedCurve
参数
错误
- CertificateFieldHasWrongDataType
- CertificateHasUnrecognizedObjectId
std.crypto.Certificate.parseTime
函数
返回自纪元开始经过的秒数。
pub fn parseTime(cert: Certificate, elem: der.Element) ParseTimeError!u64
参数
cert: Certificate
elem: der.Element
错误
- CertificateFieldHasWrongDataType
- CertificateTimeInvalid
std.crypto.Certificate.parseTimeDigits
函数
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
错误集合
错误
- CertificateFieldHasWrongDataType
- CertificateTimeInvalid
std.crypto.Certificate.parseVersion
函数
pub fn parseVersion(bytes: []const u8, version_elem: der.Element) ParseVersionError!Version
参数
错误
- CertificateFieldHasInvalidLength
- UnsupportedCertificateVersion
std.crypto.Certificate.ParseVersionError
错误集合
错误
- CertificateFieldHasInvalidLength
- UnsupportedCertificateVersion
std.crypto.Certificate.parseYear4
函数
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
命名空间
std.crypto.Certificate.rsa.encrypt
函数
fn encrypt(comptime modulus_len: usize, msg: *const [modulus_len]u8, public_key: PublicKey) EncryptError![modulus_len]u8
参数
错误
- MessageTooLong
std.crypto.Certificate.rsa.EncryptError
错误集合
错误
- MessageTooLong
std.crypto.Certificate.rsa.Fe
常量
std.crypto.Certificate.rsa.max_modulus_bits
常量
std.crypto.Certificate.rsa.Modulus
类型
std.crypto.Certificate.rsa.PKCS1v1_5Signature
命名空间
RFC 3447 8.2 RSASSA-PKCS1-v1_5
std.crypto.Certificate.rsa.PKCS1v1_5Signature.concatVerify
函数
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
函数
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
函数
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
函数
pub fn verify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void
参数
错误
- InvalidSignature
- MessageTooLong EncryptError
std.crypto.Certificate.rsa.PKCS1v1_5Signature.VerifyError
错误集合
错误
- InvalidSignature
- MessageTooLong EncryptError
std.crypto.Certificate.rsa.PSSSignature
命名空间
RFC 3447 8.1 的 RSASSA-PSS
std.crypto.Certificate.rsa.PSSSignature.concatVerify
函数
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
函数
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
函数
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
函数
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
函数
pub fn verify( comptime modulus_len: usize, sig: *const [modulus_len]u8, msg: []const u8, public_key: PublicKey, comptime Hash: type, ) VerifyError!void
参数
错误
- InvalidSignature
- MessageTooLong EncryptError
std.crypto.Certificate.rsa.PSSSignature.VerifyError
错误集合
错误
- InvalidSignature
- MessageTooLong EncryptError
std.crypto.Certificate.rsa.PublicKey
容器
字段
std.crypto.Certificate.rsa.PublicKey.fromBytes
函数
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
错误集合
错误
- CertificatePublicKeyInvalid
std.crypto.Certificate.rsa.PublicKey.parseDer
函数
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
错误集合
错误
- CertificateFieldHasInvalidLength ParseError
- CertificateFieldHasWrongDataType
std.crypto.Certificate.rsa.Uint
类型
std.crypto.Certificate.std
别名
别名目标 std
std.crypto.Certificate.verify
函数
pub fn verify(subject: Certificate, issuer: Certificate, now_sec: i64) !void
参数
std.crypto.Certificate.verify_ecdsa
函数
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
函数
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
函数
fn verifyRsa( comptime Hash: type, msg: []const u8, sig: []const u8, pub_key_algo: Parsed.PubKeyAlgo, pub_key: []const u8, ) !void
参数
std.crypto.Certificate.Version
容器
字段
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));
}