use core::fmt;
use elliptic_curve::Generate;
use p256::Scalar;
use crate::certificate::{Certificate, CertificateIssue, PrivateReconstructionValue};
use crate::encoding;
use crate::error::Error;
use crate::nonce::derive_nonce;
use crate::protocol;
use crate::request::CertificateRequest;
pub struct CertificateAuthority {
secret: p256::SecretKey,
public: p256::PublicKey,
}
impl CertificateAuthority {
pub fn random<R: rand_core::CryptoRng + ?Sized>(rng: &mut R) -> Self {
let secret = p256::SecretKey::generate_from_rng(rng);
let public = secret.public_key();
Self { secret, public }
}
pub fn from_secret_key(secret: &p256::SecretKey) -> Self {
let public = secret.public_key();
Self {
secret: secret.clone(),
public,
}
}
pub fn public_key(&self) -> p256::PublicKey {
self.public
}
pub fn issue_certificate(
&self,
request: &CertificateRequest,
) -> Result<CertificateIssue, Error> {
let d_ca: Scalar = *self.secret.to_nonzero_scalar();
let k = derive_nonce(&d_ca, &request.request_bytes());
self.issue_with_nonce(request, &k)
}
#[cfg(feature = "test-vectors")]
pub fn issue_certificate_with_nonce(
&self,
request: &CertificateRequest,
k: &Scalar,
) -> Result<CertificateIssue, Error> {
self.issue_with_nonce(request, k)
}
fn issue_with_nonce(
&self,
request: &CertificateRequest,
k: &Scalar,
) -> Result<CertificateIssue, Error> {
let d_ca: Scalar = *self.secret.to_nonzero_scalar();
let p_u = protocol::reconstruction_point(&request.public_affine(), k);
let cert_bytes = encoding::encode(&request.fields(), &p_u);
let r = protocol::issue_private_value(&cert_bytes, k, &d_ca);
Ok(CertificateIssue {
certificate: Certificate(cert_bytes),
private_reconstruction_value: PrivateReconstructionValue::from_scalar(r)?,
})
}
}
impl fmt::Debug for CertificateAuthority {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CertificateAuthority")
.field("public_key", &self.public)
.finish()
}
}