use der::{
asn1::{ContextSpecificRef, ObjectIdentifier, OctetString, SetOfVec},
Any, Decode, Encode, Length, Sequence, Tag, TagMode, TagNumber, ValueOrd, Writer,
};
use x509_cert::{
attr::{Attribute, AttributeValue},
Certificate,
};
use crate::error::Result;
use crate::oid;
pub use spki::AlgorithmIdentifierOwned;
#[derive(Debug, Clone, Sequence, ValueOrd)]
pub struct IssuerAndSerialNumber {
pub issuer: x509_cert::name::Name,
pub serial_number: x509_cert::serial_number::SerialNumber,
}
#[derive(Debug, Clone)]
pub struct SignerInfo {
pub version: u8,
pub sid: IssuerAndSerialNumber,
pub digest_algorithm: AlgorithmIdentifierOwned,
pub signed_attrs: Option<Vec<Attribute>>,
pub signature_algorithm: AlgorithmIdentifierOwned,
pub signature: OctetString,
}
impl Encode for SignerInfo {
fn encoded_len(&self) -> der::Result<Length> {
let mut len = Length::ZERO;
len = (len + self.version.encoded_len()?)?;
len = (len + self.sid.encoded_len()?)?;
len = (len + self.digest_algorithm.encoded_len()?)?;
if let Some(attrs) = &self.signed_attrs {
let set = attrs_as_set(attrs)?;
let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Implicit,
value: &set,
};
len = (len + ctx.encoded_len()?)?;
}
len = (len + self.signature_algorithm.encoded_len()?)?;
len = (len + self.signature.encoded_len()?)?;
let header = der::Header::new(Tag::Sequence, len)?;
Ok((header.encoded_len()? + len)?)
}
fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
let body_len = inner_len(self)?;
der::Header::new(Tag::Sequence, body_len)?.encode(writer)?;
self.version.encode(writer)?;
self.sid.encode(writer)?;
self.digest_algorithm.encode(writer)?;
if let Some(attrs) = &self.signed_attrs {
let set = attrs_as_set(attrs)?;
let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Implicit,
value: &set,
};
ctx.encode(writer)?;
}
self.signature_algorithm.encode(writer)?;
self.signature.encode(writer)?;
Ok(())
}
}
fn inner_len(si: &SignerInfo) -> der::Result<Length> {
let mut len = Length::ZERO;
len = (len + si.version.encoded_len()?)?;
len = (len + si.sid.encoded_len()?)?;
len = (len + si.digest_algorithm.encoded_len()?)?;
if let Some(attrs) = &si.signed_attrs {
let set = attrs_as_set(attrs)?;
let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Implicit,
value: &set,
};
len = (len + ctx.encoded_len()?)?;
}
len = (len + si.signature_algorithm.encoded_len()?)?;
len = (len + si.signature.encoded_len()?)?;
Ok(len)
}
fn attrs_as_set(attrs: &[Attribute]) -> der::Result<SetOfVec<Attribute>> {
let mut set = SetOfVec::new();
for a in attrs {
set.insert(a.clone())?;
}
Ok(set)
}
#[derive(Debug, Clone)]
pub struct EncapsulatedContentInfo {
pub content_type: ObjectIdentifier,
pub content: Option<OctetString>,
}
impl Encode for EncapsulatedContentInfo {
fn encoded_len(&self) -> der::Result<Length> {
let mut inner = self.content_type.encoded_len()?;
if let Some(c) = &self.content {
let ctx = ContextSpecificRef::<OctetString> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Explicit,
value: c,
};
inner = (inner + ctx.encoded_len()?)?;
}
Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
}
fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
let mut inner = self.content_type.encoded_len()?;
if let Some(c) = &self.content {
let ctx = ContextSpecificRef::<OctetString> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Explicit,
value: c,
};
inner = (inner + ctx.encoded_len()?)?;
}
der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
self.content_type.encode(writer)?;
if let Some(c) = &self.content {
let ctx = ContextSpecificRef::<OctetString> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Explicit,
value: c,
};
ctx.encode(writer)?;
}
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct SignedData {
pub version: u8,
pub digest_algorithms: Vec<AlgorithmIdentifierOwned>,
pub encap_content_info: EncapsulatedContentInfo,
pub certificates: Vec<Certificate>,
pub signer_infos: Vec<SignerInfo>,
}
impl Encode for SignedData {
fn encoded_len(&self) -> der::Result<Length> {
let inner = signed_data_inner_len(self)?;
Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
}
fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
let inner = signed_data_inner_len(self)?;
der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
self.version.encode(writer)?;
let mut da_set = SetOfVec::new();
for a in &self.digest_algorithms {
da_set.insert(a.clone())?;
}
da_set.encode(writer)?;
self.encap_content_info.encode(writer)?;
if !self.certificates.is_empty() {
let set: SetOfVec<Certificate> = SetOfVec::try_from(self.certificates.clone())?;
let ctx = ContextSpecificRef::<SetOfVec<Certificate>> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Implicit,
value: &set,
};
ctx.encode(writer)?;
}
let mut si_set: Vec<u8> = Vec::new();
{
let mut inner_len = Length::ZERO;
for si in &self.signer_infos {
inner_len = (inner_len + si.encoded_len()?)?;
}
let mut header_buf = Vec::new();
der::Header::new(Tag::Set, inner_len)?.encode(&mut header_buf)?;
si_set.extend_from_slice(&header_buf);
for si in &self.signer_infos {
let mut tmp = Vec::new();
si.encode(&mut tmp)?;
si_set.extend_from_slice(&tmp);
}
}
writer.write(&si_set)?;
Ok(())
}
}
fn signed_data_inner_len(sd: &SignedData) -> der::Result<Length> {
let mut len = Length::ZERO;
len = (len + sd.version.encoded_len()?)?;
let mut da_set = SetOfVec::new();
for a in &sd.digest_algorithms {
da_set.insert(a.clone())?;
}
len = (len + da_set.encoded_len()?)?;
len = (len + sd.encap_content_info.encoded_len()?)?;
if !sd.certificates.is_empty() {
let set: SetOfVec<Certificate> = SetOfVec::try_from(sd.certificates.clone())?;
let ctx = ContextSpecificRef::<SetOfVec<Certificate>> {
tag_number: TagNumber::new(0),
tag_mode: TagMode::Implicit,
value: &set,
};
len = (len + ctx.encoded_len()?)?;
}
let mut si_inner = Length::ZERO;
for si in &sd.signer_infos {
si_inner = (si_inner + si.encoded_len()?)?;
}
let header = der::Header::new(Tag::Set, si_inner)?;
len = (len + header.encoded_len()? + si_inner)?;
Ok(len)
}
#[derive(Debug, Clone)]
pub struct ContentInfo {
pub content_type: ObjectIdentifier,
pub content: Vec<u8>,
}
impl Encode for ContentInfo {
fn encoded_len(&self) -> der::Result<Length> {
let inner = content_info_inner_len(self)?;
Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
}
fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
let inner = content_info_inner_len(self)?;
der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
self.content_type.encode(writer)?;
let body_len = Length::try_from(self.content.len())?;
let ctx_header = der::Header::new(
Tag::ContextSpecific {
constructed: true,
number: TagNumber::new(0),
},
body_len,
)?;
ctx_header.encode(writer)?;
writer.write(&self.content)?;
Ok(())
}
}
fn content_info_inner_len(ci: &ContentInfo) -> der::Result<Length> {
let mut len = ci.content_type.encoded_len()?;
let body_len = Length::try_from(ci.content.len())?;
let ctx_header = der::Header::new(
Tag::ContextSpecific {
constructed: true,
number: TagNumber::new(0),
},
body_len,
)?;
len = (len + ctx_header.encoded_len()? + body_len)?;
Ok(len)
}
pub fn alg_sha256() -> AlgorithmIdentifierOwned {
AlgorithmIdentifierOwned {
oid: oid::SHA256,
parameters: None,
}
}
pub fn alg_sha256_with_rsa() -> AlgorithmIdentifierOwned {
AlgorithmIdentifierOwned {
oid: oid::SHA256_WITH_RSA,
parameters: None,
}
}
pub fn attr_content_type(oid_val: ObjectIdentifier) -> Result<Attribute> {
use der::asn1::SetOfVec;
let any = Any::from_der(&oid_val.to_der()?)?;
let mut values: SetOfVec<AttributeValue> = SetOfVec::new();
values.insert(any)?;
Ok(Attribute {
oid: oid::CMS_ATTR_CONTENT_TYPE,
values,
})
}
pub fn attr_message_digest(digest: &[u8]) -> Result<Attribute> {
use der::asn1::SetOfVec;
let os = OctetString::new(digest.to_vec())?;
let any = Any::from_der(&os.to_der()?)?;
let mut values: SetOfVec<AttributeValue> = SetOfVec::new();
values.insert(any)?;
Ok(Attribute {
oid: oid::CMS_ATTR_MESSAGE_DIGEST,
values,
})
}