aes_gcm: Remove ghash! macro.

The macro wasn't doing much. This minimizes the scope of `unsafe`
and paves the way for some future improvements.

Author: briansmith

src/aead/gcm/clmul.rs

@@ -94,6 +94,17 @@ impl UpdateBlock for Key {
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 impl UpdateBlocks for Key {
     fn update_blocks(&self, xi: &mut Xi, input: AsChunks<u8, { BLOCK_LEN }>) {
-        unsafe { ghash!(gcm_ghash_clmul, xi, &self.h_table, input) }
+        prefixed_extern! {
+            fn gcm_ghash_clmul(
+                xi: &mut Xi,
+                Htable: &HTable,
+                inp: *const u8,
+                len: crate::c::NonZero_size_t,
+            );
+        }
+        let htable = &self.h_table;
+        super::ffi::with_non_dangling_ptr(input, |input, len| unsafe {
+            gcm_ghash_clmul(xi, htable, input, len)
+        })
     }
 }

src/aead/gcm/clmulavxmovbe.rs

@@ -14,8 +14,8 @@
 
 #![cfg(target_arch = "x86_64")]
 
-use super::{HTable, KeyValue, UpdateBlock, UpdateBlocks, Xi, BLOCK_LEN};
-use crate::{cpu::intel, polyfill::slice::AsChunks};
+use super::{ffi, HTable, KeyValue, UpdateBlock, UpdateBlocks, Xi, BLOCK_LEN};
+use crate::{c, cpu::intel, polyfill::slice::AsChunks};
 
 #[derive(Clone)]
 pub struct Key {
@@ -49,6 +49,17 @@ impl UpdateBlock for Key {
 
 impl UpdateBlocks for Key {
     fn update_blocks(&self, xi: &mut Xi, input: AsChunks<u8, BLOCK_LEN>) {
-        unsafe { ghash!(gcm_ghash_avx, xi, self.inner(), input) }
+        prefixed_extern! {
+            fn gcm_ghash_avx(
+                xi: &mut Xi,
+                Htable: &HTable,
+                inp: *const u8,
+                len: c::NonZero_size_t,
+            );
+        }
+        let htable = self.inner();
+        ffi::with_non_dangling_ptr(input, |input, len| unsafe {
+            gcm_ghash_avx(xi, htable, input, len)
+        })
     }
 }

src/aead/gcm/ffi.rs

@@ -21,30 +21,6 @@ pub(in super::super) const BLOCK_LEN: usize = 16;
 pub(in super::super) type Block = [u8; BLOCK_LEN];
 pub(super) const ZERO_BLOCK: Block = [0u8; BLOCK_LEN];
 
-/// SAFETY:
-///  * The function `$name` must meet the contract of the `f` paramweter of
-///    `ghash()`.
-#[cfg(any(
-    all(target_arch = "aarch64", target_endian = "little"),
-    all(target_arch = "arm", target_endian = "little"),
-    target_arch = "x86",
-    target_arch = "x86_64"
-))]
-macro_rules! ghash {
-    ( $name:ident, $xi:expr, $h_table:expr, $input:expr $(,)? ) => {{
-        use crate::aead::gcm::ffi::{HTable, Xi};
-        prefixed_extern! {
-            fn $name(
-                xi: &mut Xi,
-                Htable: &HTable,
-                inp: *const u8,
-                len: crate::c::NonZero_size_t,
-            );
-        }
-        $h_table.ghash($name, $xi, $input)
-    }};
-}
-
 #[repr(transparent)]
 pub(in super::super) struct KeyValue([u64; 2]);
 
@@ -88,36 +64,24 @@ impl HTable {
     ) {
         unsafe { f(xi, self) }
     }
+}
 
-    pub(super) unsafe fn ghash(
-        &self,
-        f: unsafe extern "C" fn(
-            xi: &mut Xi,
-            Htable: &HTable,
-            inp: *const u8,
-            len: crate::c::NonZero_size_t,
-        ),
-        xi: &mut Xi,
-        input: AsChunks<u8, BLOCK_LEN>,
-    ) {
-        use core::num::NonZeroUsize;
-
-        let input = input.as_flattened();
+pub(super) fn with_non_dangling_ptr(
+    input: AsChunks<u8, BLOCK_LEN>,
+    f: impl FnOnce(*const u8, crate::c::NonZero_size_t),
+) {
+    use core::num::NonZeroUsize;
 
-        let input_len = match NonZeroUsize::new(input.len()) {
-            Some(len) => len,
-            None => {
-                return;
-            }
-        };
+    let input = input.as_flattened();
 
-        // SAFETY:
-        //  * There are `input_len: NonZeroUsize` bytes available at `input` for
-        //    `f` to read.
-        unsafe {
-            f(xi, self, input.as_ptr(), input_len);
+    let input_len = match NonZeroUsize::new(input.len()) {
+        Some(len) => len,
+        None => {
+            return;
         }
-    }
+    };
+
+    f(input.as_ptr(), input_len);
 }
 
 // The alignment is required by some assembly code, such as `ghash-ssse3-*`.

src/aead/gcm/neon.rs

@@ -17,8 +17,8 @@
     all(target_arch = "arm", target_endian = "little")
 ))]
 
-use super::{HTable, KeyValue, UpdateBlock, UpdateBlocks, Xi, BLOCK_LEN};
-use crate::{cpu, polyfill::slice::AsChunks};
+use super::{ffi, HTable, KeyValue, UpdateBlock, UpdateBlocks, Xi, BLOCK_LEN};
+use crate::{c, cpu, polyfill::slice::AsChunks};
 
 #[derive(Clone)]
 pub struct Key {
@@ -59,6 +59,17 @@ impl UpdateBlock for Key {
 
 impl UpdateBlocks for Key {
     fn update_blocks(&self, xi: &mut Xi, input: AsChunks<u8, BLOCK_LEN>) {
-        unsafe { ghash!(gcm_ghash_neon, xi, &self.h_table, input) }
+        prefixed_extern! {
+            fn gcm_ghash_neon(
+                xi: &mut Xi,
+                Htable: &HTable,
+                inp: *const u8,
+                len: c::NonZero_size_t,
+            );
+        }
+        let htable = &self.h_table;
+        ffi::with_non_dangling_ptr(input, |input, len| unsafe {
+            gcm_ghash_neon(xi, htable, input, len)
+        });
     }
 }

src/aead/gcm/vclmulavx2.rs

@@ -14,9 +14,13 @@
 
 #![cfg(target_arch = "x86_64")]
 
-use super::{ffi::KeyValue, HTable, UpdateBlock, Xi};
+use super::{
+    ffi::{self, KeyValue},
+    HTable, UpdateBlock, Xi,
+};
 use crate::{
     aead::gcm::ffi::BLOCK_LEN,
+    c,
     cpu::intel::{Avx2, VAesClmul},
     polyfill::slice::AsChunks,
 };
@@ -43,7 +47,18 @@ impl Key {
 
 impl UpdateBlock for Key {
     fn update_block(&self, xi: &mut Xi, a: [u8; BLOCK_LEN]) {
+        prefixed_extern! {
+            fn gcm_ghash_vpclmulqdq_avx2_16(
+                xi: &mut Xi,
+                Htable: &HTable,
+                inp: *const u8,
+                len: c::NonZero_size_t,
+            );
+        }
         let input: AsChunks<u8, BLOCK_LEN> = (&a).into();
-        unsafe { ghash!(gcm_ghash_vpclmulqdq_avx2_16, xi, &self.h_table, input) }
+        let htable = self.inner();
+        ffi::with_non_dangling_ptr(input, |input, len| unsafe {
+            gcm_ghash_vpclmulqdq_avx2_16(xi, htable, input, len)
+        })
     }
 }