use alloc::vec;
use alloc::vec::Vec;
use std::time::SystemTime;
use rsa::pkcs8::EncodePrivateKey;
use rsa::rand_core::CryptoRngCore;
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
use crate::keys::cert::{self, CertError};
use crate::keys::AdbKey;
#[derive(Debug)]
#[non_exhaustive]
pub enum TlsIdentityError {
Certificate(CertError),
PrivateKey(rsa::pkcs8::Error),
}
impl core::fmt::Display for TlsIdentityError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Certificate(e) => write!(f, "tls identity certificate: {e}"),
Self::PrivateKey(e) => write!(f, "tls identity private key: {e}"),
}
}
}
impl core::error::Error for TlsIdentityError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Certificate(e) => Some(e),
Self::PrivateKey(e) => Some(e),
}
}
}
pub struct TlsIdentity {
certificate: CertificateDer<'static>,
private_key: PrivatePkcs8KeyDer<'static>,
}
impl TlsIdentity {
pub fn from_key<R: CryptoRngCore>(key: &AdbKey, rng: &mut R) -> Result<Self, TlsIdentityError> {
Self::from_key_at(key, rng, SystemTime::now())
}
pub fn from_key_at<R: CryptoRngCore>(
key: &AdbKey,
rng: &mut R,
not_before: SystemTime,
) -> Result<Self, TlsIdentityError> {
let certificate =
cert::build_at(key, rng, not_before).map_err(TlsIdentityError::Certificate)?;
let pkcs8 = key
.private_key()
.to_pkcs8_der()
.map_err(TlsIdentityError::PrivateKey)?;
Ok(Self {
certificate: CertificateDer::from(certificate),
private_key: PrivatePkcs8KeyDer::from(pkcs8.as_bytes().to_vec()),
})
}
pub fn certificate_der(&self) -> &[u8] {
self.certificate.as_ref()
}
pub(crate) fn rustls_parts(&self) -> (Vec<CertificateDer<'static>>, PrivateKeyDer<'static>) {
(
vec![self.certificate.clone()],
PrivateKeyDer::Pkcs8(self.private_key.clone_key()),
)
}
}
impl core::fmt::Debug for TlsIdentity {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TlsIdentity")
.field("certificate_len", &self.certificate.as_ref().len())
.finish_non_exhaustive()
}
}
impl Drop for TlsIdentity {
fn drop(&mut self) {
zeroize::Zeroize::zeroize(&mut self.private_key);
}
}
impl zeroize::ZeroizeOnDrop for TlsIdentity {}
#[cfg(test)]
mod tests {
#[test]
fn the_identity_is_marked_zeroize_on_drop() {
fn marked<T: zeroize::ZeroizeOnDrop>() {}
marked::<super::TlsIdentity>();
}
}