chore: Use naming scheme without rosenpass- for crates

sodium/src/aead/chacha20poly1305_ietf.rs

@@ -0,0 +1,63 @@
+use libsodium_sys as libsodium;
+use std::ffi::c_ulonglong;
+use std::ptr::{null, null_mut};
+
+pub const KEY_LEN: usize = libsodium::crypto_aead_chacha20poly1305_IETF_KEYBYTES as usize;
+pub const TAG_LEN: usize = libsodium::crypto_aead_chacha20poly1305_IETF_ABYTES as usize;
+pub const NONCE_LEN: usize = libsodium::crypto_aead_chacha20poly1305_IETF_NPUBBYTES as usize;
+
+#[inline]
+pub fn encrypt(
+    ciphertext: &mut [u8],
+    key: &[u8],
+    nonce: &[u8],
+    ad: &[u8],
+    plaintext: &[u8],
+) -> anyhow::Result<()> {
+    assert!(ciphertext.len() == plaintext.len() + TAG_LEN);
+    assert!(key.len() == KEY_LEN);
+    assert!(nonce.len() == NONCE_LEN);
+    let mut clen: u64 = 0;
+    sodium_call!(
+        crypto_aead_chacha20poly1305_ietf_encrypt,
+        ciphertext.as_mut_ptr(),
+        &mut clen,
+        plaintext.as_ptr(),
+        plaintext.len() as c_ulonglong,
+        ad.as_ptr(),
+        ad.len() as c_ulonglong,
+        null(), // nsec is not used
+        nonce.as_ptr(),
+        key.as_ptr()
+    )?;
+    assert!(clen as usize == ciphertext.len());
+    Ok(())
+}
+
+#[inline]
+pub fn decrypt(
+    plaintext: &mut [u8],
+    key: &[u8],
+    nonce: &[u8],
+    ad: &[u8],
+    ciphertext: &[u8],
+) -> anyhow::Result<()> {
+    assert!(ciphertext.len() == plaintext.len() + TAG_LEN);
+    assert!(key.len() == KEY_LEN);
+    assert!(nonce.len() == NONCE_LEN);
+    let mut mlen: u64 = 0;
+    sodium_call!(
+        crypto_aead_chacha20poly1305_ietf_decrypt,
+        plaintext.as_mut_ptr(),
+        &mut mlen as *mut c_ulonglong,
+        null_mut(), // nsec is not used
+        ciphertext.as_ptr(),
+        ciphertext.len() as c_ulonglong,
+        ad.as_ptr(),
+        ad.len() as c_ulonglong,
+        nonce.as_ptr(),
+        key.as_ptr()
+    )?;
+    assert!(mlen as usize == plaintext.len());
+    Ok(())
+}

sodium/src/aead/mod.rs

@@ -0,0 +1,2 @@
+pub mod chacha20poly1305_ietf;
+pub mod xchacha20poly1305_ietf;

sodium/src/aead/xchacha20poly1305_ietf.rs

@@ -0,0 +1,63 @@
+use libsodium_sys as libsodium;
+use std::ffi::c_ulonglong;
+use std::ptr::{null, null_mut};
+
+pub const KEY_LEN: usize = libsodium::crypto_aead_xchacha20poly1305_IETF_KEYBYTES as usize;
+pub const TAG_LEN: usize = libsodium::crypto_aead_xchacha20poly1305_ietf_ABYTES as usize;
+pub const NONCE_LEN: usize = libsodium::crypto_aead_xchacha20poly1305_IETF_NPUBBYTES as usize;
+
+#[inline]
+pub fn encrypt(
+    ciphertext: &mut [u8],
+    key: &[u8],
+    nonce: &[u8],
+    ad: &[u8],
+    plaintext: &[u8],
+) -> anyhow::Result<()> {
+    assert!(ciphertext.len() == plaintext.len() + NONCE_LEN + TAG_LEN);
+    assert!(key.len() == libsodium::crypto_aead_xchacha20poly1305_IETF_KEYBYTES as usize);
+    let (n, ct) = ciphertext.split_at_mut(NONCE_LEN);
+    n.copy_from_slice(nonce);
+    let mut clen: u64 = 0;
+    sodium_call!(
+        crypto_aead_xchacha20poly1305_ietf_encrypt,
+        ct.as_mut_ptr(),
+        &mut clen,
+        plaintext.as_ptr(),
+        plaintext.len() as c_ulonglong,
+        ad.as_ptr(),
+        ad.len() as c_ulonglong,
+        null(), // nsec is not used
+        nonce.as_ptr(),
+        key.as_ptr()
+    )?;
+    assert!(clen as usize == ct.len());
+    Ok(())
+}
+
+#[inline]
+pub fn decrypt(
+    plaintext: &mut [u8],
+    key: &[u8],
+    ad: &[u8],
+    ciphertext: &[u8],
+) -> anyhow::Result<()> {
+    assert!(ciphertext.len() == plaintext.len() + NONCE_LEN + TAG_LEN);
+    assert!(key.len() == KEY_LEN);
+    let (n, ct) = ciphertext.split_at(NONCE_LEN);
+    let mut mlen: u64 = 0;
+    sodium_call!(
+        crypto_aead_xchacha20poly1305_ietf_decrypt,
+        plaintext.as_mut_ptr(),
+        &mut mlen as *mut c_ulonglong,
+        null_mut(), // nsec is not used
+        ct.as_ptr(),
+        ct.len() as c_ulonglong,
+        ad.as_ptr(),
+        ad.len() as c_ulonglong,
+        n.as_ptr(),
+        key.as_ptr()
+    )?;
+    assert!(mlen as usize == plaintext.len());
+    Ok(())
+}

sodium/src/helpers.rs

@@ -0,0 +1,52 @@
+use libsodium_sys as libsodium;
+use std::os::raw::c_void;
+
+#[inline]
+pub fn memcmp(a: &[u8], b: &[u8]) -> bool {
+    a.len() == b.len()
+        && unsafe {
+            let r = libsodium::sodium_memcmp(
+                a.as_ptr() as *const c_void,
+                b.as_ptr() as *const c_void,
+                a.len(),
+            );
+            r == 0
+        }
+}
+
+#[inline]
+pub fn compare(a: &[u8], b: &[u8]) -> i32 {
+    assert!(a.len() == b.len());
+    unsafe { libsodium::sodium_compare(a.as_ptr(), b.as_ptr(), a.len()) }
+}
+
+#[inline]
+pub fn increment(v: &mut [u8]) {
+    unsafe {
+        libsodium::sodium_increment(v.as_mut_ptr(), v.len());
+    }
+}
+
+#[inline]
+pub fn randombytes_buf(buf: &mut [u8]) {
+    unsafe { libsodium::randombytes_buf(buf.as_mut_ptr() as *mut c_void, buf.len()) };
+}
+
+#[inline]
+pub fn memzero(buf: &mut [u8]) {
+    unsafe { libsodium::sodium_memzero(buf.as_mut_ptr() as *mut c_void, buf.len()) };
+}
+
+// Choose a fully random u64
+// TODO: Replace with ::rand::random
+pub fn rand_u64() -> u64 {
+    let mut buf = [0u8; 8];
+    randombytes_buf(&mut buf);
+    u64::from_le_bytes(buf)
+}
+
+// Choose a random f64 in [0; 1] inclusive; quick and dirty
+// TODO: Replace with ::rand::random
+pub fn rand_f64() -> f64 {
+    (rand_u64() as f64) / (u64::MAX as f64)
+}

sodium/src/lib.rs

@@ -0,0 +1,19 @@
+use libsodium_sys as libsodium;
+
+macro_rules! sodium_call {
+    ($name:ident, $($args:expr),*) => { ::rosenpass_util::attempt!({
+        anyhow::ensure!(unsafe{libsodium::$name($($args),*)} > -1,
+            "Error in libsodium's {}.", stringify!($name));
+        Ok(())
+    })};
+    ($name:ident) => { sodium_call!($name, ) };
+}
+
+#[inline]
+pub fn init() -> anyhow::Result<()> {
+    log::trace!("initializing libsodium");
+    sodium_call!(sodium_init)
+}
+
+pub mod aead;
+pub mod helpers;