use alloc::vec::Vec;
use core::fmt;
use elliptic_curve::ff::PrimeField;
use p256::Scalar;
use crate::encoding;
use crate::error::Error;
use crate::protocol;
use crate::unvalidated::UnvalidatedPublicKey;
#[derive(Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Certificate(pub(crate) Vec<u8>);
impl Certificate {
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, Error> {
encoding::decode(&bytes)?;
Ok(Self(bytes))
}
pub fn reconstruct(&self, ca_public: &p256::PublicKey) -> Result<UnvalidatedPublicKey, Error> {
let decoded = encoding::decode(self.as_bytes())?;
let point = protocol::user_public_key(
self.as_bytes(),
&decoded.reconstruction_point,
ca_public.as_affine(),
);
Ok(UnvalidatedPublicKey { point })
}
}
impl fmt::Debug for Certificate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Certificate")
.field("len", &self.0.len())
.finish()
}
}
#[derive(Clone)]
pub struct PrivateReconstructionValue(pub(crate) p256::SecretKey);
impl PrivateReconstructionValue {
pub(crate) fn from_scalar(r: Scalar) -> Result<Self, Error> {
let secret = p256::SecretKey::from_bytes(&r.to_repr()).map_err(|_| Error::InvalidScalar)?;
Ok(Self(secret))
}
pub(crate) fn scalar(&self) -> Scalar {
*self.0.to_nonzero_scalar()
}
pub fn to_bytes(&self) -> [u8; 32] {
let mut out = [0u8; 32];
out.copy_from_slice(self.0.to_bytes().as_slice());
out
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
let arr: [u8; 32] = bytes.try_into().map_err(|_| Error::InvalidScalar)?;
let secret = p256::SecretKey::from_bytes(&arr.into()).map_err(|_| Error::InvalidScalar)?;
Ok(Self(secret))
}
}
impl fmt::Debug for PrivateReconstructionValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("PrivateReconstructionValue(<redacted>)")
}
}
#[derive(Clone, Debug)]
pub struct CertificateIssue {
pub certificate: Certificate,
pub private_reconstruction_value: PrivateReconstructionValue,
}