Bump ring to 0.16

.cirrus.yml

@@ -7,18 +7,18 @@ task:
           - rustup component add rustfmt
           - cargo fmt -- --check
        build_script: 
-          - cargo build --verbose --all
+          - cargo build --verbose --all-features
 
      - name: linux (nightly)
        container:
           image: rustlang/rust:nightly
        build_script:
-          - cargo build --verbose --all
-          - cargo bench --verbose --all --no-run
+          - cargo build --verbose --all-features
+          - cargo bench --verbose --all-features --no-run
 
   cargo_cache:
      folder: $CARGO_HOME/registry
   test_script: 
-          - cargo test --all
-          - cargo test --all --features=aesgcm 
+          - cargo test --features=c20p1305
+          - cargo test --features=aesgcm
   before_cache_script: rm -rf $CARGO_HOME/registry/index

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "sio"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Andreas Auernhammer <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Secure IO"
 license = "MIT"
@@ -24,4 +24,4 @@ c20p1305 = ["ring"]
 aesgcm = ["ring"]
 
 [dependencies]
-ring = { version = "0.14.6", optional = true }
+ring = { version = "0.16", optional = true }

benches/writer.rs

@@ -10,19 +10,21 @@ use std::{io, io::Write};
 extern crate test;
 use test::Bencher;
 
+#[allow(clippy::upper_case_acronyms)]
 #[cfg(feature = "aesgcm")]
 type AEAD = AES_256_GCM;
 
+#[allow(clippy::upper_case_acronyms)]
 #[cfg(not(feature = "aesgcm"))]
 type AEAD = CHACHA20_POLY1305;
 
 fn buffer_size() -> usize {
-    const BUFFER_SIZE: &'static str = "SIO_BUF_SIZE";
+    const BUFFER_SIZE: &str = "SIO_BUF_SIZE";
     if let Ok(value) = std::env::var(BUFFER_SIZE) {
         let value: usize = value
             .as_str()
             .parse()
-            .expect(format!("'{}' is not a number", BUFFER_SIZE).as_str());
+            .unwrap_or_else(|_| panic!("'{}' is not a number", BUFFER_SIZE));
         1024 * value
     } else {
         sio::BUF_SIZE
@@ -35,14 +37,15 @@ fn encrypt_write_1k(b: &mut Bencher) -> io::Result<()> {
     let mut writer = EncWriter::with_buffer_size(
         io::sink(),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
     .expect("Failed to create EncWriter");
 
+    #[allow(clippy::identity_op)]
     let buf: &[u8] = &[0; 1 * 1024];
-    b.bytes = 1 * 1024;
+    b.bytes = buf.len() as u64;
     b.iter(|| {
         writer.write_all(buf).expect("encryption failed");
     });
@@ -55,7 +58,7 @@ fn encrypt_write_64k(b: &mut Bencher) -> io::Result<()> {
     let mut writer = EncWriter::with_buffer_size(
         io::sink(),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -75,7 +78,7 @@ fn encrypt_write_512k(b: &mut Bencher) -> io::Result<()> {
     let mut writer = EncWriter::with_buffer_size(
         io::sink(),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -95,7 +98,7 @@ fn encrypt_write_1mb(b: &mut Bencher) -> io::Result<()> {
     let mut writer = EncWriter::with_buffer_size(
         io::sink(),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -116,13 +119,13 @@ fn decrypt_write_1k(b: &mut Bencher) -> io::Result<()> {
         DecWriter::with_buffer_size(
             io::sink(),
             &key,
-            Nonce::new([0; Nonce::<AEAD>::SIZE]),
+            Nonce::new([0; Nonce::SIZE]),
             Aad::empty(),
             buffer_size(),
         )
         .expect("Failed to create DecWriter"),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -143,13 +146,13 @@ fn decrypt_write_64k(b: &mut Bencher) -> io::Result<()> {
         DecWriter::with_buffer_size(
             io::sink(),
             &key,
-            Nonce::new([0; Nonce::<AEAD>::SIZE]),
+            Nonce::new([0; Nonce::SIZE]),
             Aad::empty(),
             buffer_size(),
         )
         .expect("Failed to create DecWriter"),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -170,13 +173,13 @@ fn decrypt_write_512k(b: &mut Bencher) -> io::Result<()> {
         DecWriter::with_buffer_size(
             io::sink(),
             &key,
-            Nonce::new([0; Nonce::<AEAD>::SIZE]),
+            Nonce::new([0; Nonce::SIZE]),
             Aad::empty(),
             buffer_size(),
         )
         .expect("Failed to create DecWriter"),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )
@@ -197,13 +200,13 @@ fn decrypt_write_1mb(b: &mut Bencher) -> io::Result<()> {
         DecWriter::with_buffer_size(
             io::sink(),
             &key,
-            Nonce::new([0; Nonce::<AEAD>::SIZE]),
+            Nonce::new([0; Nonce::SIZE]),
             Aad::empty(),
             buffer_size(),
         )
         .expect("Failed to create DecWriter"),
         &key,
-        Nonce::new([0; Nonce::<AEAD>::SIZE]),
+        Nonce::new([0; Nonce::SIZE]),
         Aad::empty(),
         buffer_size(),
     )

src/aead.rs

@@ -2,26 +2,24 @@
 // Use of this source code is governed by a license that can be
 // found in the LICENSE file.
 
-use crate::error::{Exceeded, Invalid, NotAuthentic};
+use crate::error::{Invalid, NotAuthentic};
 use std::marker::PhantomData;
 
 pub trait Algorithm {
     const KEY_LEN: usize;
     const NONCE_LEN: usize;
     const TAG_LEN: usize;
 
-    fn new(key: &[u8; 32]) -> Self;
+    fn new(key: &[u8; 32], nonce: Nonce) -> Self;
 
     fn seal_in_place<'a>(
-        &self,
-        nonce: &[u8; 12],
+        &mut self,
         aad: &[u8],
-        in_out: &'a mut [u8],
+        in_out: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], Invalid>;
 
     fn open_in_place<'a>(
-        &self,
-        nonce: &[u8; 12],
+        &mut self,
         aad: &[u8],
         in_out: &'a mut [u8],
     ) -> Result<&'a [u8], NotAuthentic>;
@@ -43,17 +41,18 @@ impl<A: Algorithm> AsRef<[u8; 32]> for Key<A> {
     }
 }
 
-pub struct Nonce<A: Algorithm>([u8; 8], PhantomData<A>);
+#[derive(Copy, Clone)]
+pub struct Nonce([u8; 8]);
 
-impl<A: Algorithm> Nonce<A> {
-    pub const SIZE: usize = A::NONCE_LEN - 4;
+impl Nonce {
+    pub const SIZE: usize = ::ring::aead::NONCE_LEN - 4;
 
     pub fn new(bytes: [u8; 8]) -> Self {
-        Nonce(bytes, PhantomData)
+        Nonce(bytes)
     }
 }
 
-impl<A: Algorithm> AsRef<[u8; 8]> for Nonce<A> {
+impl AsRef<[u8; 8]> for Nonce {
     fn as_ref(&self) -> &[u8; 8] {
         &self.0
     }
@@ -81,7 +80,7 @@ impl<'a, A: Algorithm> Clone for Aad<'a, A> {
 impl<'a, A: Algorithm> AsRef<[u8]> for Aad<'a, A> {
     #[inline]
     fn as_ref(&self) -> &[u8] {
-        &self.0
+        self.0
     }
 }
 
@@ -92,29 +91,39 @@ impl<'a, A: Algorithm> From<&'a [u8]> for Aad<'a, A> {
     }
 }
 
-pub(crate) struct Counter<A: Algorithm> {
+pub(crate) struct Counter {
     nonce: [u8; 12],
     pub seq_num: u32,
     exceeded: bool,
-    phantom_data: PhantomData<A>,
 }
 
-impl<A: Algorithm> Counter<A> {
-    pub fn zero(nonce: Nonce<A>) -> Self {
+impl Counter {
+    fn new(nonce: Nonce, seq_num: u32) -> Self {
         let mut value = [0; 12];
-        &mut value[..8].copy_from_slice(&nonce.0);
+        value[..8].copy_from_slice(&nonce.0);
         Counter {
             nonce: value,
-            seq_num: 0,
+            seq_num,
             exceeded: false,
-            phantom_data: PhantomData,
         }
     }
 
     #[inline]
-    pub fn next<'a>(&'a mut self) -> Result<&'a [u8; 12], Exceeded> {
+    pub fn zero(nonce: Nonce) -> Self {
+        Self::new(nonce, 0)
+    }
+
+    #[inline]
+    pub fn one(nonce: Nonce) -> Self {
+        Self::new(nonce, 1)
+    }
+}
+
+impl ::ring::aead::NonceSequence for Counter {
+    #[inline]
+    fn advance(&mut self) -> Result<::ring::aead::Nonce, ::ring::error::Unspecified> {
         if self.exceeded {
-            return Err(Exceeded);
+            return Err(::ring::error::Unspecified);
         }
 
         self.nonce[8..].copy_from_slice(self.seq_num.to_le_bytes().as_ref());
@@ -123,6 +132,6 @@ impl<A: Algorithm> Counter<A> {
         } else {
             self.exceeded = true;
         }
-        Ok(&self.nonce)
+        Ok(::ring::aead::Nonce::assume_unique_for_key(self.nonce))
     }
 }

src/aesgcm.rs

@@ -4,59 +4,55 @@
 
 extern crate ring;
 
-use crate::aead::Algorithm;
+use crate::aead::{Algorithm, Counter};
 use crate::error::{Invalid, NotAuthentic};
-use ring::aead;
+use crate::Nonce;
+use ring::aead::{self, BoundKey};
 
 #[allow(non_camel_case_types)]
 pub struct AES_256_GCM {
-    seal_key: aead::SealingKey,
-    open_key: aead::OpeningKey,
+    seal_key: aead::SealingKey<Counter>,
+    open_key: aead::OpeningKey<Counter>,
 }
 
 impl Algorithm for AES_256_GCM {
     const KEY_LEN: usize = 256 / 8;
     const NONCE_LEN: usize = 96 / 8;
     const TAG_LEN: usize = 128 / 8;
 
-    fn new(key: &[u8; Self::KEY_LEN]) -> Self {
+    fn new(key: &[u8; Self::KEY_LEN], nonce: Nonce) -> Self {
         Self {
-            seal_key: aead::SealingKey::new(&aead::AES_256_GCM, key).unwrap(),
-            open_key: aead::OpeningKey::new(&aead::AES_256_GCM, key).unwrap(),
+            seal_key: aead::SealingKey::new(
+                aead::UnboundKey::new(&aead::AES_256_GCM, key).unwrap(),
+                Counter::zero(nonce),
+            ),
+            open_key: aead::OpeningKey::new(
+                aead::UnboundKey::new(&aead::AES_256_GCM, key).unwrap(),
+                Counter::one(nonce),
+            ),
         }
     }
 
     fn seal_in_place<'a>(
-        &self,
-        nonce: &[u8; Self::NONCE_LEN],
+        &mut self,
         aad: &[u8],
-        in_out: &'a mut [u8],
+        in_out: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], Invalid> {
-        match aead::seal_in_place(
-            &self.seal_key,
-            aead::Nonce::assume_unique_for_key(*nonce),
-            aead::Aad::from(aad),
-            in_out,
-            Self::TAG_LEN,
-        ) {
-            Ok(len) => Ok(&in_out[..len]),
+        match self
+            .seal_key
+            .seal_in_place_append_tag(aead::Aad::from(aad), in_out)
+        {
+            Ok(()) => Ok(in_out.as_slice()),
             Err(_) => Err(Invalid::BufSize),
         }
     }
 
     fn open_in_place<'a>(
-        &self,
-        nonce: &[u8; Self::NONCE_LEN],
+        &mut self,
         aad: &[u8],
         in_out: &'a mut [u8],
     ) -> Result<&'a [u8], NotAuthentic> {
-        match aead::open_in_place(
-            &self.open_key,
-            aead::Nonce::assume_unique_for_key(*nonce),
-            aead::Aad::from(aad),
-            0,
-            in_out,
-        ) {
+        match self.open_key.open_in_place(aead::Aad::from(aad), in_out) {
             Ok(val) => Ok(val),
             Err(_) => Err(NotAuthentic),
         }