use aes_gcm::aead::inout::InOutBuf;
use aes_gcm::aead::{AeadInOut, KeyInit};
use hmac::Mac;
use p256::ecdsa::signature::{Signer, Verifier};
use p256::elliptic_curve::Generate;
use p256::elliptic_curve::sec1::ToSec1Point;
use p256::pkcs8::{DecodePrivateKey, EncodePrivateKey};
use sha2::Digest;
use zeroize::Zeroizing;
use super::{Error, NONCE_LEN, TAG_LEN, pem_body};
pub const LIBRARY: &str = "RustCrypto";
type Gcm = aes_gcm::Aes256Gcm;
type Nonce = aes_gcm::aead::Nonce<Gcm>;
type Tag = aes_gcm::aead::Tag<Gcm>;
pub fn sha256(data: &[u8]) -> [u8; 32] {
sha2::Sha256::digest(data).into()
}
pub fn hmac_sha256(key: &[u8], data: &[u8]) -> [u8; 32] {
let mut mac = <hmac::Hmac<sha2::Sha256> as KeyInit>::new_from_slice(key)
.expect("HMAC takes a key of any length");
mac.update(data);
mac.finalize().into_bytes().into()
}
pub fn hkdf_sha256(salt: &[u8], ikm: &[u8], info: &[u8], out: &mut [u8]) -> Result<(), Error> {
hkdf::Hkdf::<sha2::Sha256>::new(Some(salt), ikm)
.expand(info, out)
.map_err(|_| Error)
}
pub struct Aes256Gcm(Gcm);
impl Aes256Gcm {
pub fn new(key: &[u8]) -> Result<Self, Error> {
if key.len() != 32 {
return Err(Error);
}
Gcm::new_from_slice(key).map(Self).map_err(|_| Error)
}
pub fn open<'a>(
&self,
nonce: [u8; NONCE_LEN],
aad: &[u8],
buf: &'a mut [u8],
) -> Result<&'a mut [u8], Error> {
let Some(len) = buf.len().checked_sub(TAG_LEN) else {
return Err(Error);
};
let (text, tag) = buf.split_at_mut(len);
let tag: [u8; TAG_LEN] = (&*tag).try_into().map_err(|_| Error)?;
self.0
.decrypt_inout_detached(
&Nonce::from(nonce),
aad,
InOutBuf::from(text),
&Tag::from(tag),
)
.map_err(|_| Error)?;
Ok(&mut buf[..len])
}
pub fn seal_random_nonce(&self, plaintext: &[u8]) -> Result<Vec<u8>, Error> {
let mut nonce = [0u8; NONCE_LEN];
fill_random(&mut nonce)?;
let mut out = Vec::with_capacity(NONCE_LEN + plaintext.len() + TAG_LEN);
out.extend_from_slice(&nonce);
out.extend_from_slice(plaintext);
let tag = self
.0
.encrypt_inout_detached(
&Nonce::from(nonce),
&[],
InOutBuf::from(&mut out[NONCE_LEN..]),
)
.map_err(|_| Error)?;
out.extend_from_slice(&tag);
Ok(out)
}
pub fn open_nonce_prefixed(&self, data: &[u8]) -> Result<Vec<u8>, Error> {
if data.len() < NONCE_LEN + TAG_LEN {
return Err(Error);
}
let (nonce, sealed) = data.split_at(NONCE_LEN);
let mut nonce_bytes = [0u8; NONCE_LEN];
nonce_bytes.copy_from_slice(nonce);
let mut buf = sealed.to_vec();
let len = self.open(nonce_bytes, &[], &mut buf)?.len();
buf.truncate(len);
Ok(buf)
}
}
pub fn ecdh_generate() -> Result<(Zeroizing<Vec<u8>>, Vec<u8>), Error> {
let secret = p256::SecretKey::try_generate().map_err(|_| Error)?;
let public = point(&secret.public_key());
let scalar = Zeroizing::new(secret.to_bytes());
Ok((Zeroizing::new(scalar.to_vec()), public))
}
pub fn ecdh_agree<R>(
private_scalar: &[u8],
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<R, Error> {
let secret = p256::SecretKey::from_slice(private_scalar).map_err(|_| Error)?;
let peer = peer_key(peer_public)?;
let shared = p256::ecdh::diffie_hellman(secret.to_nonzero_scalar(), peer.as_affine());
derive(shared.raw_secret_bytes().as_slice())
}
pub fn ecdh_ephemeral<R>(
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<(Vec<u8>, R), Error> {
let (key, public) = EphemeralKey::generate()?;
let derived = key.agree(peer_public, derive)?;
Ok((public, derived))
}
pub struct EphemeralKey(p256::ecdh::EphemeralSecret);
impl EphemeralKey {
pub fn generate() -> Result<(Self, Vec<u8>), Error> {
let secret = p256::ecdh::EphemeralSecret::try_generate().map_err(|_| Error)?;
let public = point(&secret.public_key());
Ok((Self(secret), public))
}
pub fn agree<R>(
self,
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<R, Error> {
let peer = peer_key(peer_public)?;
derive(self.0.diffie_hellman(&peer).raw_secret_bytes().as_slice())
}
}
fn peer_key(public_key: &[u8]) -> Result<p256::PublicKey, Error> {
if public_key.len() != super::P256_PUBLIC_LEN {
return Err(Error);
}
p256::PublicKey::from_sec1_bytes(public_key).map_err(|_| Error)
}
fn point(key: &p256::PublicKey) -> Vec<u8> {
key.to_sec1_point(false).as_bytes().to_vec()
}
pub fn fill_random(out: &mut [u8]) -> Result<(), Error> {
getrandom::fill(out).map_err(|_| Error)
}
pub struct IdentityKey {
key: p256::ecdsa::SigningKey,
public: Vec<u8>,
}
impl IdentityKey {
pub fn from_pkcs8(key: &[u8]) -> Result<Self, Error> {
let pem = pem_body(key);
let der: &[u8] = pem.as_deref().map_or(key, Vec::as_slice);
let key = p256::ecdsa::SigningKey::from_pkcs8_der(der).map_err(|_| Error)?;
let public = key.verifying_key().to_sec1_point(false).as_bytes().to_vec();
Ok(Self { key, public })
}
pub fn public_key(&self) -> &[u8] {
&self.public
}
pub fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
let signature: p256::ecdsa::Signature = self.key.sign(message);
Ok(signature.to_bytes().to_vec())
}
}
pub fn generate_p256_pkcs8() -> Result<Vec<u8>, Error> {
p256::SecretKey::try_generate()
.map_err(|_| Error)?
.to_pkcs8_der()
.map(|der| der.as_bytes().to_vec())
.map_err(|_| Error)
}
pub fn verify_p256(public_key: &[u8], message: &[u8], signature: &[u8]) -> bool {
VerifyingKey::from_sec1(public_key).is_some_and(|key| key.verifies(message, signature))
}
pub struct VerifyingKey(p256::ecdsa::VerifyingKey);
impl VerifyingKey {
pub fn from_sec1(public_key: &[u8]) -> Option<Self> {
if public_key.len() != super::P256_PUBLIC_LEN {
return None;
}
p256::ecdsa::VerifyingKey::from_sec1_bytes(public_key)
.ok()
.map(Self)
}
pub fn verifies(&self, message: &[u8], signature: &[u8]) -> bool {
p256::ecdsa::Signature::from_slice(signature)
.is_ok_and(|signature| self.0.verify(message, &signature).is_ok())
}
}
pub struct CounterSealKey {
key: Gcm,
last: Option<u64>,
}
impl CounterSealKey {
pub fn new(key: &[u8]) -> Result<Self, Error> {
if key.len() != 32 {
return Err(Error);
}
let key = Gcm::new_from_slice(key).map_err(|_| Error)?;
Ok(Self { key, last: None })
}
pub fn seal(
&mut self,
nonce: [u8; NONCE_LEN],
aad: &[u8],
buf: &mut Vec<u8>,
from: usize,
) -> Result<(), Error> {
let mut counter = [0u8; 8];
counter.copy_from_slice(&nonce[4..]);
let counter = u64::from_be_bytes(counter);
if self.last.is_some_and(|last| counter <= last) {
return Err(Error);
}
let tag = self
.key
.encrypt_inout_detached(
&Nonce::from(nonce),
aad,
InOutBuf::from(buf.get_mut(from..).ok_or(Error)?),
)
.map_err(|_| Error)?;
buf.extend_from_slice(&tag);
self.last = Some(counter);
Ok(())
}
}