use alloc::vec::Vec;
use core::fmt;
use elliptic_curve::Generate;
#[cfg(feature = "test-vectors")]
use elliptic_curve::ff::Field;
use elliptic_curve::ff::PrimeField;
use elliptic_curve::sec1::ToSec1Point;
use p256::{AffinePoint, Scalar};
use crate::certificate::{Certificate, PrivateReconstructionValue};
use crate::encoding;
use crate::error::Error;
use crate::protocol;
pub struct CertificateRequest {
k_u: p256::SecretKey,
r_u: AffinePoint,
identity: Vec<u8>,
attributes: Vec<u8>,
}
impl CertificateRequest {
pub fn random<R: rand_core::CryptoRng + ?Sized>(
identity: &[u8],
attributes: &[u8],
rng: &mut R,
) -> Self {
let k_u = p256::SecretKey::generate_from_rng(rng);
let r_u = *k_u.public_key().as_affine();
Self {
k_u,
r_u,
identity: identity.to_vec(),
attributes: attributes.to_vec(),
}
}
#[cfg(feature = "test-vectors")]
pub fn from_secret(identity: &[u8], attributes: &[u8], k_u: &Scalar) -> Result<Self, Error> {
if bool::from(k_u.is_zero()) {
return Err(Error::InvalidScalar);
}
let secret =
p256::SecretKey::from_bytes(&k_u.to_repr()).map_err(|_| Error::InvalidScalar)?;
let r_u = *secret.public_key().as_affine();
Ok(Self {
k_u: secret,
r_u,
identity: identity.to_vec(),
attributes: attributes.to_vec(),
})
}
pub fn public_point(&self) -> p256::PublicKey {
p256::PublicKey::from_affine(self.r_u).expect("request point is on the curve")
}
pub fn finalize(
self,
certificate: &Certificate,
r: &PrivateReconstructionValue,
ca_public: &p256::PublicKey,
) -> Result<p256::SecretKey, Error> {
let cert_bytes = certificate.as_bytes();
let decoded = encoding::decode(cert_bytes)?;
let k_u: Scalar = *self.k_u.to_nonzero_scalar();
let r_scalar = r.scalar();
let d_u = protocol::requester_private_key(cert_bytes, &k_u, &r_scalar);
let q_u = protocol::user_public_key(
cert_bytes,
&decoded.reconstruction_point,
ca_public.as_affine(),
);
if protocol::public_from_private(&d_u) != q_u {
return Err(Error::SelfCheckFailed);
}
p256::SecretKey::from_bytes(&d_u.to_repr()).map_err(|_| Error::InvalidScalar)
}
pub(crate) fn fields(&self) -> encoding::CertificateFields {
encoding::CertificateFields::new(self.identity.clone(), self.attributes.clone())
}
pub(crate) fn public_affine(&self) -> AffinePoint {
self.r_u
}
pub(crate) fn request_bytes(&self) -> Vec<u8> {
let mut out = Vec::new();
push_len(&mut out, &self.identity);
push_len(&mut out, &self.attributes);
out.extend_from_slice(self.r_u.to_sec1_point(true).as_bytes());
out
}
}
fn push_len(out: &mut Vec<u8>, field: &[u8]) {
let len = u16::try_from(field.len()).expect("identity or attributes longer than 65535 bytes");
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(field);
}
impl fmt::Debug for CertificateRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CertificateRequest")
.field("k_u", &"<redacted>")
.field("r_u", &self.r_u)
.finish()
}
}