use core::ptr::{self, NonNull};
use crate::error::{Error, Site, status};
use crate::module::{Module, check};
use crate::secret::{
DrbgSeed, HkdfPrk, MlDsa87KeySeed, MlDsa87SecretKey, MlKem1024DecapsulationKey,
MlKem1024EncapsSeed, MlKem1024KeySeedD, MlKem1024KeySeedZ, Okm, SharedSecret, seed_bytes_mut,
wipe, zeroed_seed,
};
use crate::sys;
use crate::{
AES256_GCM_NONCE_LEN, AES256_GCM_TAG_LEN, AES256_KEY_LEN, HKDF_SHA384_MAX_OKM_LEN,
HMAC_DRBG_MAX_REQUEST_LEN, MlDsa87PublicKey, MlDsa87Signature, MlKem1024Ciphertext,
MlKem1024EncapsulationKey, SHA384_LEN,
};
fn status_or_wipe(code: core::ffi::c_int, site: Site, out: &mut [u8]) -> Result<(), Error> {
let result = status(code, site);
if result.is_err() {
wipe(out);
}
result
}
const GCM_MAX_PAYLOAD_LEN: u64 = (1 << 36) - 32;
const GCM_MAX_AAD_LEN: u64 = (1 << 61) - 1;
pub(crate) fn gcm_lengths(payload: usize, aad: usize) -> Result<(), Error> {
if u64::try_from(payload).map_or(true, |n| n > GCM_MAX_PAYLOAD_LEN) {
return Err(Error::InvalidPayloadLength);
}
if u64::try_from(aad).map_or(true, |n| n > GCM_MAX_AAD_LEN) {
return Err(Error::InvalidAadLength);
}
Ok(())
}
fn input(bytes: &[u8]) -> *const u8 {
if bytes.is_empty() {
ptr::null()
} else {
bytes.as_ptr()
}
}
impl Module {
pub fn sha384(self, data: &[u8]) -> Result<[u8; SHA384_LEN], Error> {
let mut out = [0u8; SHA384_LEN];
let code = unsafe { sys::oxi_sha384(input(data), data.len(), out.as_mut_ptr()) };
check(code)?;
Ok(out)
}
pub fn hkdf_sha384_extract(self, salt: Option<&[u8]>, ikm: &[u8]) -> Result<HkdfPrk, Error> {
let salt = salt.unwrap_or(&[]);
let mut prk = HkdfPrk::zeroed();
let code = unsafe {
sys::oxi_hkdf_sha384_extract(
input(salt),
salt.len(),
input(ikm),
ikm.len(),
prk.bytes.as_mut_ptr(),
)
};
check(code)?;
Ok(prk)
}
pub fn hkdf_sha384_expand(self, prk: &HkdfPrk, info: &[u8], len: usize) -> Result<Okm, Error> {
if len > HKDF_SHA384_MAX_OKM_LEN {
return Err(Error::OutputTooLong);
}
let mut okm = Okm::zeroed(len);
let code = unsafe {
sys::oxi_hkdf_sha384_expand(
prk.bytes.as_ptr(),
input(info),
info.len(),
okm.bytes.as_mut_ptr(),
okm.bytes.len(),
)
};
check(code)?;
Ok(okm)
}
pub fn aes256_key(self, key: &[u8; AES256_KEY_LEN]) -> Result<Aes256Key, Error> {
let mut handle: *mut sys::OxiAes256Key = ptr::null_mut();
let code = unsafe { sys::oxi_aes256_new(&raw mut handle, key.as_ptr()) };
check(code)?;
NonNull::new(handle)
.map(|ptr| Aes256Key { ptr })
.ok_or(Error::NullPointer)
}
pub fn aes256_gcm_encrypt(
self,
key: &Aes256Key,
nonce: &[u8; AES256_GCM_NONCE_LEN],
aad: &[u8],
plaintext: &[u8],
ciphertext_out: &mut [u8],
) -> Result<[u8; AES256_GCM_TAG_LEN], Error> {
if let Err(e) = gcm_lengths(plaintext.len(), aad.len()) {
wipe(ciphertext_out);
return Err(e);
}
if ciphertext_out.len() != plaintext.len() {
wipe(ciphertext_out);
return Err(Error::LengthMismatch);
}
let mut tag = [0u8; AES256_GCM_TAG_LEN];
let code = unsafe {
sys::oxi_aes256_gcm_encrypt(
key.ptr.as_ptr(),
nonce.as_ptr(),
input(aad),
aad.len(),
input(plaintext),
plaintext.len(),
ciphertext_out.as_mut_ptr(),
tag.as_mut_ptr(),
)
};
status_or_wipe(code, Site::Other, ciphertext_out)?;
Ok(tag)
}
pub fn aes256_gcm_decrypt(
self,
key: &Aes256Key,
nonce: &[u8; AES256_GCM_NONCE_LEN],
aad: &[u8],
ciphertext: &[u8],
plaintext_out: &mut [u8],
tag: &[u8; AES256_GCM_TAG_LEN],
) -> Result<(), Error> {
if let Err(e) = gcm_lengths(ciphertext.len(), aad.len()) {
wipe(plaintext_out);
return Err(e);
}
if plaintext_out.len() != ciphertext.len() {
wipe(plaintext_out);
return Err(Error::LengthMismatch);
}
let code = unsafe {
sys::oxi_aes256_gcm_decrypt(
key.ptr.as_ptr(),
nonce.as_ptr(),
input(aad),
aad.len(),
input(ciphertext),
ciphertext.len(),
plaintext_out.as_mut_ptr(),
tag.as_ptr(),
)
};
status_or_wipe(code, Site::AeadDecrypt, plaintext_out)
}
pub fn aes256_gcm_encrypt_vec(
self,
key: &Aes256Key,
nonce: &[u8; AES256_GCM_NONCE_LEN],
aad: &[u8],
plaintext: &[u8],
) -> Result<(Vec<u8>, [u8; AES256_GCM_TAG_LEN]), Error> {
gcm_lengths(plaintext.len(), aad.len())?;
let mut ciphertext = vec![0u8; plaintext.len()];
let tag = self.aes256_gcm_encrypt(key, nonce, aad, plaintext, &mut ciphertext)?;
Ok((ciphertext, tag))
}
pub fn aes256_gcm_decrypt_vec(
self,
key: &Aes256Key,
nonce: &[u8; AES256_GCM_NONCE_LEN],
aad: &[u8],
ciphertext: &[u8],
tag: &[u8; AES256_GCM_TAG_LEN],
) -> Result<Vec<u8>, Error> {
gcm_lengths(ciphertext.len(), aad.len())?;
let mut plaintext = vec![0u8; ciphertext.len()];
self.aes256_gcm_decrypt(key, nonce, aad, ciphertext, &mut plaintext, tag)?;
Ok(plaintext)
}
pub fn hmac_drbg_sha256(self) -> Result<HmacDrbgSha256, Error> {
let mut handle: *mut sys::OxiHmacDrbgSha256 = ptr::null_mut();
let code = unsafe { sys::oxi_hmac_drbg_sha256_new(&raw mut handle) };
check(code)?;
NonNull::new(handle)
.map(|ptr| HmacDrbgSha256 { ptr })
.ok_or(Error::NullPointer)
}
pub fn ml_dsa_87_keygen(
self,
seed: MlDsa87KeySeed,
) -> Result<(MlDsa87PublicKey, MlDsa87SecretKey), Error> {
let mut pk = [0u8; crate::ML_DSA_87_PUBLIC_KEY_LEN];
let mut sk = MlDsa87SecretKey::zeroed();
let code = unsafe {
sys::oxi_ml_dsa_87_keygen(seed.bytes.as_ptr(), pk.as_mut_ptr(), sk.bytes.as_mut_ptr())
};
drop(seed);
check(code)?;
Ok((pk, sk))
}
pub fn ml_dsa_87_sign(
self,
sk: &MlDsa87SecretKey,
msg: &[u8],
ctx: &[u8],
) -> Result<MlDsa87Signature, Error> {
let mut sig = [0u8; crate::ML_DSA_87_SIGNATURE_LEN];
let code = unsafe {
sys::oxi_ml_dsa_87_sign(
sk.bytes.as_ptr(),
input(msg),
msg.len(),
input(ctx),
ctx.len(),
sig.as_mut_ptr(),
)
};
check(code)?;
Ok(sig)
}
pub fn ml_dsa_87_verify(
self,
pk: &MlDsa87PublicKey,
msg: &[u8],
ctx: &[u8],
sig: &MlDsa87Signature,
) -> Result<(), Error> {
let code = unsafe {
sys::oxi_ml_dsa_87_verify(
pk.as_ptr(),
input(msg),
msg.len(),
input(ctx),
ctx.len(),
sig.as_ptr(),
)
};
status(code, Site::SignatureVerify)
}
pub fn ml_kem_1024_keygen(
self,
d: MlKem1024KeySeedD,
z: MlKem1024KeySeedZ,
) -> Result<(MlKem1024EncapsulationKey, MlKem1024DecapsulationKey), Error> {
let mut ek = [0u8; crate::ML_KEM_1024_ENCAPSULATION_KEY_LEN];
let mut dk = MlKem1024DecapsulationKey::zeroed();
let code = unsafe {
sys::oxi_ml_kem_1024_keygen(
d.bytes.as_ptr(),
z.bytes.as_ptr(),
ek.as_mut_ptr(),
dk.bytes.as_mut_ptr(),
)
};
drop((d, z));
check(code)?;
Ok((ek, dk))
}
pub fn ml_kem_1024_encapsulate(
self,
ek: &MlKem1024EncapsulationKey,
m: MlKem1024EncapsSeed,
) -> Result<(SharedSecret, MlKem1024Ciphertext), Error> {
let mut ss = SharedSecret::zeroed();
let mut ct = [0u8; crate::ML_KEM_1024_CIPHERTEXT_LEN];
let code = unsafe {
sys::oxi_ml_kem_1024_encapsulate(
ek.as_ptr(),
m.bytes.as_ptr(),
ss.bytes.as_mut_ptr(),
ct.as_mut_ptr(),
)
};
drop(m);
check(code)?;
Ok((ss, ct))
}
pub fn ml_kem_1024_decapsulate(
self,
dk: &MlKem1024DecapsulationKey,
ct: &MlKem1024Ciphertext,
) -> Result<SharedSecret, Error> {
let mut ss = SharedSecret::zeroed();
let code = unsafe {
sys::oxi_ml_kem_1024_decapsulate(dk.bytes.as_ptr(), ct.as_ptr(), ss.bytes.as_mut_ptr())
};
check(code)?;
Ok(ss)
}
}
pub struct Aes256Key {
ptr: NonNull<sys::OxiAes256Key>,
}
unsafe impl Send for Aes256Key {}
unsafe impl Sync for Aes256Key {}
impl Drop for Aes256Key {
fn drop(&mut self) {
unsafe { sys::oxi_aes256_free(self.ptr.as_ptr()) };
}
}
impl core::fmt::Debug for Aes256Key {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("Aes256Key")
}
}
pub struct HmacDrbgSha256 {
ptr: NonNull<sys::OxiHmacDrbgSha256>,
}
unsafe impl Send for HmacDrbgSha256 {}
impl HmacDrbgSha256 {
pub fn instantiate(
&mut self,
entropy: &[u8],
nonce: &[u8],
personalization: &[u8],
) -> Result<(), Error> {
let code = unsafe {
sys::oxi_hmac_drbg_sha256_instantiate(
self.ptr.as_ptr(),
input(entropy),
entropy.len(),
input(nonce),
nonce.len(),
input(personalization),
personalization.len(),
)
};
check(code)
}
pub fn reseed(&mut self, entropy: &[u8], additional: &[u8]) -> Result<(), Error> {
let code = unsafe {
sys::oxi_hmac_drbg_sha256_reseed(
self.ptr.as_ptr(),
input(entropy),
entropy.len(),
input(additional),
additional.len(),
)
};
check(code)
}
pub fn generate(&mut self, additional: &[u8], out: &mut [u8]) -> Result<(), Error> {
if out.len() > HMAC_DRBG_MAX_REQUEST_LEN {
wipe(out);
return Err(Error::OutputTooLong);
}
let code = unsafe {
sys::oxi_hmac_drbg_sha256_generate(
self.ptr.as_ptr(),
input(additional),
additional.len(),
out.as_mut_ptr(),
out.len(),
)
};
status_or_wipe(code, Site::Other, out)
}
pub fn seed<S: DrbgSeed>(&mut self) -> Result<S, Error> {
let mut seed: S = zeroed_seed();
self.generate(&[], seed_bytes_mut(&mut seed))?;
Ok(seed)
}
}
impl Drop for HmacDrbgSha256 {
fn drop(&mut self) {
unsafe { sys::oxi_hmac_drbg_sha256_free(self.ptr.as_ptr()) };
}
}
impl core::fmt::Debug for HmacDrbgSha256 {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("HmacDrbgSha256")
}
}