use super::super::{
Ed25519PubKey, MlDsa44PubKey, MlDsa65PubKey, MlDsa87PubKey, RsaPubKey, RsaPubKeyErr,
UncompressedP256PubKey, UncompressedP384PubKey, UncompressedPubKey,
};
use core::fmt::{self, Display, Formatter};
use p256::{
NistP256,
elliptic_curve::{Curve, common::typenum::type_operators::ToInt as _},
};
use p384::NistP384;
const INTEGER: u8 = 2;
const BITSTRING: u8 = 3;
const NULL: u8 = 5;
const OID: u8 = 6;
const SEQUENCE: u8 = 16;
const CONSTRUCTED_SEQUENCE: u8 = SEQUENCE | 0b0010_0000;
const MLDSA87_HEADER_LEN: usize = 22;
const MLDSA87_LEN: usize = MLDSA87_HEADER_LEN + 2592;
const MLDSA65_HEADER_LEN: usize = 22;
const MLDSA65_LEN: usize = MLDSA65_HEADER_LEN + 1952;
const MLDSA44_HEADER_LEN: usize = 22;
const MLDSA44_LEN: usize = MLDSA44_HEADER_LEN + 1312;
const ED25519_HEADER_LEN: usize = 12;
const ED25519_LEN: usize = ED25519_HEADER_LEN + ed25519_dalek::PUBLIC_KEY_LENGTH;
#[expect(
clippy::as_conversions,
clippy::cast_possible_truncation,
reason = "comments above justify their correctness"
)]
const ED25519_LEN_U8: u8 = ED25519_LEN as u8;
const P256_HEADER_LEN: usize = 27;
const P256_X_LEN: usize = <NistP256 as Curve>::FieldBytesSize::INT;
const P256_Y_LEN: usize = <NistP256 as Curve>::FieldBytesSize::INT;
const P256_COORD_LEN: usize = P256_X_LEN + P256_Y_LEN;
const P256_LEN: usize = P256_HEADER_LEN + P256_COORD_LEN;
#[expect(
clippy::as_conversions,
clippy::cast_possible_truncation,
reason = "comments above justify their correctness"
)]
const P256_LEN_U8: u8 = P256_LEN as u8;
const P384_HEADER_LEN: usize = 24;
const P384_X_LEN: usize = <NistP384 as Curve>::FieldBytesSize::INT;
const P384_Y_LEN: usize = <NistP384 as Curve>::FieldBytesSize::INT;
const P384_COORD_LEN: usize = P384_X_LEN + P384_Y_LEN;
const P384_LEN: usize = P384_HEADER_LEN + P384_COORD_LEN;
#[expect(
clippy::as_conversions,
clippy::cast_possible_truncation,
reason = "comments above justify their correctness"
)]
const P384_LEN_U8: u8 = P384_LEN as u8;
pub(super) enum SubjectPublicKeyInfoErr {
MlDsa87Len,
MlDsa87Header,
MlDsa65Len,
MlDsa65Header,
MlDsa44Len,
MlDsa44Header,
Ed25519Len,
Ed25519Header,
P256Len,
P256Header,
P384Len,
P384Header,
RsaLen,
RsaEncoding,
RsaExponentTooLarge,
RsaPubKey(RsaPubKeyErr),
}
impl Display for SubjectPublicKeyInfoErr {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match *self {
Self::MlDsa87Len => f.write_str("length of the DER-encoded ML-DSA-87 key was invalid"),
Self::MlDsa87Header => {
f.write_str("header of the DER-encoded ML-DSA-87 key was invalid")
}
Self::MlDsa65Len => f.write_str("length of the DER-encoded ML-DSA-65 key was invalid"),
Self::MlDsa65Header => {
f.write_str("header of the DER-encoded ML-DSA-65 key was invalid")
}
Self::MlDsa44Len => f.write_str("length of the DER-encoded ML-DSA-44 key was invalid"),
Self::MlDsa44Header => {
f.write_str("header of the DER-encoded ML-DSA-44 key was invalid")
}
Self::Ed25519Len => f.write_str("length of the DER-encoded Ed25519 key was invalid"),
Self::Ed25519Header => f.write_str("header of the DER-encoded Ed25519 key was invalid"),
Self::P256Len => f.write_str("length of the DER-encoded P-256 key was invalid"),
Self::P256Header => f.write_str("header of the DER-encoded P-256 key was invalid"),
Self::P384Len => f.write_str("length of the DER-encoded P-384 key was invalid"),
Self::P384Header => f.write_str("header of the DER-encoded P-384 key was invalid"),
Self::RsaLen => f.write_str("length of the DER-encoded RSA key was invalid"),
Self::RsaEncoding => f.write_str("the DER-encoding of the RSA public key was invalid"),
Self::RsaExponentTooLarge => {
f.write_str("the DER-encoded RSA public key had an exponent that was too large")
}
Self::RsaPubKey(err) => {
write!(f, "the DER-encoded RSA public was not valid: {err}")
}
}
}
}
pub(super) trait SubjectPublicKeyInfo<'a>: Sized {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr>;
}
impl<'a> SubjectPublicKeyInfo<'a> for MlDsa87PubKey<&'a [u8]> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; MLDSA87_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
130,
10,
50,
CONSTRUCTED_SEQUENCE,
9 + 2,
OID,
9,
96,
134,
72,
1,
101,
3,
4,
3,
19,
BITSTRING,
130,
10,
33,
0,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::MlDsa87Len)
.and_then(|(header, rem)| {
if header == HEADER {
if rem.len() == 2592 {
Ok(Self(rem))
} else {
Err(SubjectPublicKeyInfoErr::MlDsa87Len)
}
} else {
Err(SubjectPublicKeyInfoErr::MlDsa87Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for MlDsa65PubKey<&'a [u8]> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; MLDSA65_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
130,
7,
178,
CONSTRUCTED_SEQUENCE,
9 + 2,
OID,
9,
96,
134,
72,
1,
101,
3,
4,
3,
18,
BITSTRING,
130,
7,
161,
0,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::MlDsa65Len)
.and_then(|(header, rem)| {
if header == HEADER {
if rem.len() == 1952 {
Ok(Self(rem))
} else {
Err(SubjectPublicKeyInfoErr::MlDsa65Len)
}
} else {
Err(SubjectPublicKeyInfoErr::MlDsa65Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for MlDsa44PubKey<&'a [u8]> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; MLDSA44_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
130,
5,
50,
CONSTRUCTED_SEQUENCE,
9 + 2,
OID,
9,
96,
134,
72,
1,
101,
3,
4,
3,
17,
BITSTRING,
130,
5,
33,
0,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::MlDsa44Len)
.and_then(|(header, rem)| {
if header == HEADER {
if rem.len() == 1312 {
Ok(Self(rem))
} else {
Err(SubjectPublicKeyInfoErr::MlDsa44Len)
}
} else {
Err(SubjectPublicKeyInfoErr::MlDsa44Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for Ed25519PubKey<&'a [u8]> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; ED25519_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
ED25519_LEN_U8 - 2,
CONSTRUCTED_SEQUENCE,
3 + 2,
OID,
3,
43,
101,
112,
BITSTRING,
ED25519_LEN_U8 - 11,
0,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::Ed25519Len)
.and_then(|(header, rem)| {
if header == HEADER {
if rem.len() == ed25519_dalek::PUBLIC_KEY_LENGTH {
Ok(Self(rem))
} else {
Err(SubjectPublicKeyInfoErr::Ed25519Len)
}
} else {
Err(SubjectPublicKeyInfoErr::Ed25519Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for UncompressedP256PubKey<'a> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; P256_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
P256_LEN_U8 - 2,
CONSTRUCTED_SEQUENCE,
7 + 2 + 8 + 2,
OID,
7,
42,
134,
72,
206,
61,
2,
1,
OID,
8,
42,
134,
72,
206,
61,
3,
1,
7,
BITSTRING,
P256_LEN_U8 - 25,
0,
4,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::P256Len)
.and_then(|(header, header_rem)| {
if header == HEADER {
header_rem
.split_at_checked(P256_X_LEN)
.ok_or(SubjectPublicKeyInfoErr::P256Len)
.and_then(|(x, y)| {
if y.len() == P256_Y_LEN {
Ok(Self(x, y))
} else {
Err(SubjectPublicKeyInfoErr::P256Len)
}
})
} else {
Err(SubjectPublicKeyInfoErr::P256Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for UncompressedP384PubKey<'a> {
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const HEADER: [u8; P384_HEADER_LEN] = [
CONSTRUCTED_SEQUENCE,
P384_LEN_U8 - 2,
CONSTRUCTED_SEQUENCE,
7 + 2 + 5 + 2,
OID,
7,
42,
134,
72,
206,
61,
2,
1,
OID,
5,
43,
129,
4,
0,
34,
BITSTRING,
P384_LEN_U8 - 22,
0,
4,
];
der.split_at_checked(HEADER.len())
.ok_or(SubjectPublicKeyInfoErr::P384Len)
.and_then(|(header, header_rem)| {
if header == HEADER {
header_rem
.split_at_checked(P384_X_LEN)
.ok_or(SubjectPublicKeyInfoErr::P384Len)
.and_then(|(x, y)| {
if y.len() == P384_Y_LEN {
Ok(Self(x, y))
} else {
Err(SubjectPublicKeyInfoErr::P384Len)
}
})
} else {
Err(SubjectPublicKeyInfoErr::P384Header)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for RsaPubKey<&'a [u8]> {
#[expect(
clippy::arithmetic_side_effects,
clippy::big_endian_bytes,
clippy::indexing_slicing,
clippy::missing_asserts_for_indexing,
reason = "comments justify their correctness"
)]
#[expect(
clippy::too_many_lines,
reason = "rsa keys are the only type that would benefit from a modular SubjectPublicKeyInfo (similar to FromCbor). if more types benefit in the future, then this will be done."
)]
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const ALG_OID_HEADER: [u8; 17] = [
CONSTRUCTED_SEQUENCE,
9 + 2 + 2,
OID,
9,
42,
134,
72,
134,
247,
13,
1,
1,
1,
NULL,
0,
BITSTRING,
130,
];
const SEQ_LONG: [u8; 2] = [CONSTRUCTED_SEQUENCE, 130];
const INT_LONG: [u8; 2] = [INTEGER, 130];
der.split_at_checked(SEQ_LONG.len())
.ok_or(SubjectPublicKeyInfoErr::RsaLen)
.and_then(|(seq, seq_rem)| {
if seq == SEQ_LONG {
seq_rem
.split_at_checked(2)
.ok_or(SubjectPublicKeyInfoErr::RsaLen)
.and_then(|(seq_len, seq_len_rem)| {
let mut len = [0; 2];
len.copy_from_slice(seq_len);
let rem_len = usize::from(u16::from_be_bytes(len));
if rem_len == seq_len_rem.len() {
if rem_len > 255 {
let (a_oid, a_oid_rem) = seq_len_rem.split_at(ALG_OID_HEADER.len());
if a_oid == ALG_OID_HEADER {
let (bit_str_len_enc, bit_str_val) = a_oid_rem.split_at(2);
let mut bit_string_len = [0; 2];
bit_string_len.copy_from_slice(bit_str_len_enc);
let bit_str_val_len = usize::from(u16::from_be_bytes(bit_string_len));
if bit_str_val_len == bit_str_val.len() {
if bit_str_val_len > 255 {
let (unused_bits, bits_rem) = bit_str_val.split_at(1);
if unused_bits == [0] {
let (rsa_seq, rsa_seq_rem) = bits_rem.split_at(SEQ_LONG.len());
if rsa_seq == SEQ_LONG {
let (rsa_seq_len_enc, rsa_seq_len_enc_rem) = rsa_seq_rem.split_at(2);
let mut rsa_seq_len = [0; 2];
rsa_seq_len.copy_from_slice(rsa_seq_len_enc);
let rsa_key_info_len = usize::from(u16::from_be_bytes(rsa_seq_len));
if rsa_key_info_len == rsa_seq_len_enc_rem.len() {
if rsa_key_info_len > 255 {
let (n_meta, n_meta_rem) = rsa_seq_len_enc_rem.split_at(INT_LONG.len());
if n_meta == INT_LONG {
let (n_len_enc, n_len_enc_rem) = n_meta_rem.split_at(2);
let mut n_len = [0; 2];
n_len.copy_from_slice(n_len_enc);
let mod_len = usize::from(u16::from_be_bytes(n_len));
if mod_len > 255 {
n_len_enc_rem.split_at_checked(mod_len).ok_or(SubjectPublicKeyInfoErr::RsaLen).and_then(|(mut n, n_rem)| {
let n_first = n[0];
if n_first < 128 && (n_first != 0 || n[1] > 127) {
if n_first == 0 {
n = &n[1..];
}
n_rem.split_first().ok_or(SubjectPublicKeyInfoErr::RsaLen).and_then(|(e_type, e_type_rem)| {
if *e_type == INTEGER {
e_type_rem.split_first().ok_or(SubjectPublicKeyInfoErr::RsaLen).and_then(|(e_len, e_len_rem)| {
let e_len_usize = usize::from(*e_len);
if e_len_usize == e_len_rem.len() {
e_len_rem.first().ok_or(SubjectPublicKeyInfoErr::RsaLen).and_then(|&e_first| {
if e_first < 128 {
match e_len_usize {
1 => Ok(u32::from(e_first)),
2..=5 => if e_first == 0 {
if e_len_rem[1] > 127 {
let mut e = [0; 4];
if e_len_usize == 5 {
e.copy_from_slice(&e_len_rem[1..]);
} else {
e[4 - e_len_usize..].copy_from_slice(e_len_rem);
}
Ok(u32::from_be_bytes(e))
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else if e_len_usize == 5 {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
} else {
let mut e = [0; 4];
e[4 - e_len_usize..].copy_from_slice(e_len_rem);
Ok(u32::from_be_bytes(e))
},
_ => Err(SubjectPublicKeyInfoErr::RsaExponentTooLarge),
}.and_then(|e| Self::try_from((n, e)).map_err(SubjectPublicKeyInfoErr::RsaPubKey))
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
})
} else {
Err(SubjectPublicKeyInfoErr::RsaLen)
}
})
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
})
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
})
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaLen)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaLen)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
} else {
Err(SubjectPublicKeyInfoErr::RsaLen)
}
})
} else {
Err(SubjectPublicKeyInfoErr::RsaEncoding)
}
})
}
}
impl<'a> SubjectPublicKeyInfo<'a> for UncompressedPubKey<'a> {
#[expect(clippy::indexing_slicing, reason = "comments justify correctness")]
fn from_der<'b: 'a>(der: &'b [u8]) -> Result<Self, SubjectPublicKeyInfoErr> {
const ML_DSA_OID_LEN_IDX: usize = 5;
const ML_DSA_OID_LEN: u8 = 11;
match der.len() {
ED25519_LEN => Ed25519PubKey::from_der(der).map(Self::Ed25519),
P256_LEN => UncompressedP256PubKey::from_der(der).map(Self::P256),
P384_LEN => UncompressedP384PubKey::from_der(der).map(Self::P384),
MLDSA44_LEN => {
if der[ML_DSA_OID_LEN_IDX] == ML_DSA_OID_LEN {
MlDsa44PubKey::from_der(der).map(Self::MlDsa44)
} else {
RsaPubKey::from_der(der).map(Self::Rsa)
}
}
MLDSA65_LEN => {
if der[ML_DSA_OID_LEN_IDX] == ML_DSA_OID_LEN {
MlDsa65PubKey::from_der(der).map(Self::MlDsa65)
} else {
RsaPubKey::from_der(der).map(Self::Rsa)
}
}
MLDSA87_LEN => MlDsa87PubKey::from_der(der).map(Self::MlDsa87),
_ => RsaPubKey::from_der(der).map(Self::Rsa),
}
}
}