use aws_lc_rs::encoding::AsBigEndian;
use aws_lc_rs::{aead, agreement, digest, hkdf, hmac, rand};
use zeroize::Zeroizing;
use super::{Error, NONCE_LEN, TAG_LEN, pem_body};
pub const LIBRARY: &str = if cfg!(feature = "fips") {
"aws-lc-rs (FIPS)"
} else {
"aws-lc-rs"
};
impl From<aws_lc_rs::error::Unspecified> for Error {
fn from(_: aws_lc_rs::error::Unspecified) -> Self {
Error
}
}
impl From<aws_lc_rs::error::KeyRejected> for Error {
fn from(_: aws_lc_rs::error::KeyRejected) -> Self {
Error
}
}
pub fn sha256(data: &[u8]) -> [u8; 32] {
let mut out = [0u8; 32];
out.copy_from_slice(digest::digest(&digest::SHA256, data).as_ref());
out
}
pub fn hmac_sha256(key: &[u8], data: &[u8]) -> [u8; 32] {
let mut out = [0u8; 32];
out.copy_from_slice(hmac::sign(&hmac::Key::new(hmac::HMAC_SHA256, key), data).as_ref());
out
}
pub fn hkdf_sha256(salt: &[u8], ikm: &[u8], info: &[u8], out: &mut [u8]) -> Result<(), Error> {
struct Len(usize);
impl hkdf::KeyType for Len {
fn len(&self) -> usize {
self.0
}
}
hkdf::Salt::new(hkdf::HKDF_SHA256, salt)
.extract(ikm)
.expand(&[info], Len(out.len()))?
.fill(out)?;
Ok(())
}
pub struct Aes256Gcm {
open: aead::LessSafeKey,
seal: aead::RandomizedNonceKey,
}
impl Aes256Gcm {
pub fn new(key: &[u8]) -> Result<Self, Error> {
if key.len() != 32 {
return Err(Error);
}
let unbound = aead::UnboundKey::new(&aead::AES_256_GCM, key)?;
Ok(Self {
open: aead::LessSafeKey::new(unbound),
seal: aead::RandomizedNonceKey::new(&aead::AES_256_GCM, key)?,
})
}
pub fn open<'a>(
&self,
nonce: [u8; NONCE_LEN],
aad: &[u8],
buf: &'a mut [u8],
) -> Result<&'a mut [u8], Error> {
Ok(self.open.open_in_place(
aead::Nonce::assume_unique_for_key(nonce),
aead::Aad::from(aad),
buf,
)?)
}
pub fn seal_random_nonce(&self, plaintext: &[u8]) -> Result<Vec<u8>, Error> {
let mut body = Vec::with_capacity(plaintext.len() + TAG_LEN);
body.extend_from_slice(plaintext);
let nonce = self
.seal
.seal_in_place_append_tag(aead::Aad::empty(), &mut body)?;
let mut out = Vec::with_capacity(NONCE_LEN + body.len());
out.extend_from_slice(nonce.as_ref());
out.extend_from_slice(&body);
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 private = agreement::PrivateKey::generate(&agreement::ECDH_P256)?;
let public = private.compute_public_key()?;
let scalar: aws_lc_rs::encoding::EcPrivateKeyBin = private.as_be_bytes()?;
Ok((
Zeroizing::new(scalar.as_ref().to_vec()),
public.as_ref().to_vec(),
))
}
pub fn ecdh_agree<R>(
private_scalar: &[u8],
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<R, Error> {
let private = agreement::PrivateKey::from_private_key(&agreement::ECDH_P256, private_scalar)?;
let peer = agreement::UnparsedPublicKey::new(&agreement::ECDH_P256, peer_public);
agreement::agree(&private, peer, Error, derive)
}
pub fn ecdh_ephemeral<R>(
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<(Vec<u8>, R), Error> {
let rng = rand::SystemRandom::new();
let private = agreement::EphemeralPrivateKey::generate(&agreement::ECDH_P256, &rng)?;
let public = private.compute_public_key()?.as_ref().to_vec();
let peer = agreement::UnparsedPublicKey::new(&agreement::ECDH_P256, peer_public);
let derived = agreement::agree_ephemeral(private, peer, Error, derive)?;
Ok((public, derived))
}
pub struct EphemeralKey(agreement::EphemeralPrivateKey);
impl EphemeralKey {
pub fn generate() -> Result<(Self, Vec<u8>), Error> {
let rng = rand::SystemRandom::new();
let private = agreement::EphemeralPrivateKey::generate(&agreement::ECDH_P256, &rng)?;
let public = private.compute_public_key()?.as_ref().to_vec();
Ok((Self(private), public))
}
pub fn agree<R>(
self,
peer_public: &[u8],
derive: impl FnOnce(&[u8]) -> Result<R, Error>,
) -> Result<R, Error> {
let peer = agreement::UnparsedPublicKey::new(&agreement::ECDH_P256, peer_public);
agreement::agree_ephemeral(self.0, peer, Error, derive)
}
}
pub fn fill_random(out: &mut [u8]) -> Result<(), Error> {
use aws_lc_rs::rand::SecureRandom;
Ok(rand::SystemRandom::new().fill(out)?)
}
pub struct IdentityKey(aws_lc_rs::signature::EcdsaKeyPair);
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);
aws_lc_rs::signature::EcdsaKeyPair::from_pkcs8(
&aws_lc_rs::signature::ECDSA_P256_SHA256_FIXED_SIGNING,
der,
)
.map(Self)
.map_err(|_| Error)
}
pub fn public_key(&self) -> &[u8] {
use aws_lc_rs::signature::KeyPair;
self.0.public_key().as_ref()
}
pub fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
let rng = rand::SystemRandom::new();
Ok(self.0.sign(&rng, message)?.as_ref().to_vec())
}
}
pub fn generate_p256_pkcs8() -> Result<Vec<u8>, Error> {
let rng = rand::SystemRandom::new();
let pkcs8 = aws_lc_rs::signature::EcdsaKeyPair::generate_pkcs8(
&aws_lc_rs::signature::ECDSA_P256_SHA256_FIXED_SIGNING,
&rng,
)?;
Ok(pkcs8.as_ref().to_vec())
}
pub fn verify_p256(public_key: &[u8], message: &[u8], signature: &[u8]) -> bool {
aws_lc_rs::signature::UnparsedPublicKey::new(
&aws_lc_rs::signature::ECDSA_P256_SHA256_FIXED,
public_key,
)
.verify(message, signature)
.is_ok()
}
pub struct VerifyingKey(aws_lc_rs::signature::ParsedPublicKey);
impl VerifyingKey {
pub fn from_sec1(public_key: &[u8]) -> Option<Self> {
aws_lc_rs::signature::ParsedPublicKey::new(
&aws_lc_rs::signature::ECDSA_P256_SHA256_FIXED,
public_key,
)
.ok()
.map(Self)
}
pub fn verifies(&self, message: &[u8], signature: &[u8]) -> bool {
self.0.verify_sig(message, signature).is_ok()
}
}
pub struct CounterSealKey(aead::TlsRecordSealingKey);
impl CounterSealKey {
pub fn new(key: &[u8]) -> Result<Self, Error> {
Ok(Self(aead::TlsRecordSealingKey::new(
&aead::AES_256_GCM,
aead::TlsProtocolId::TLS12,
key,
)?))
}
pub fn seal(
&mut self,
nonce: [u8; NONCE_LEN],
aad: &[u8],
buf: &mut Vec<u8>,
from: usize,
) -> Result<(), Error> {
if from > buf.len() {
return Err(Error);
}
Ok(self.0.seal_in_place_append_tag(
aead::Nonce::assume_unique_for_key(nonce),
aead::Aad::from(aad),
&mut Tail { buf, from },
)?)
}
}
struct Tail<'a> {
buf: &'a mut Vec<u8>,
from: usize,
}
impl AsMut<[u8]> for Tail<'_> {
fn as_mut(&mut self) -> &mut [u8] {
&mut self.buf[self.from..]
}
}
impl<'a> Extend<&'a u8> for Tail<'_> {
fn extend<I: IntoIterator<Item = &'a u8>>(&mut self, bytes: I) {
self.buf.extend(bytes);
}
}