restructure crate types

This commit completely redefines the API of the `sio` crate.
The core type is `Algorithm` which now uses associated constants
for the key, nonce and tag length. Using ass. constants the compiler
can guarantee a lot of invariants, like:
 - The key passed to `Algorithm::new` has always the correct length.
   (Therefore we can return `Self` instead of a Result)
 - The nonce passed to `seal_in_place` / `open_in_place` has always
   the correct length.
 - It's actually not possible to implement `Algorithm` for an AEAD
   with a nonce size < 4 and use it with `sio`. Doing so causes the
   compiler to complain that `Nonce::<Algorithm>::SIZE` will overflow
   (usize becomes negative).

Further, it's not possible to pass a wrong key or nonce to an
enc/dec reader/writer.

However, this commit only contains the basic structure. A lot of things
are still missing. In particular:
  - docs and examples!!!
  - the enc/dec reader implementations
  - proper cargo.toml configuration (production/dev builds a.s.o)
  - tests and benchmarks.

Author: Andreas Auernhammer

Cargo.toml

@@ -7,4 +7,8 @@ edition = "2018"
 description = "Secure IO"
 license = "MIT"
 
+[features]
+default = ["ring"]
+
 [dependencies]
+ring = { version = "0.14.6", optional = true }

src/aead.rs

@@ -1,5 +1,105 @@
+use super::error::{Exceeded, Invalid, NotAuthentic};
+use std::marker::PhantomData;
+
 pub trait Algorithm {
-    fn nonce_len(&self) -> usize;
+    const KEY_LEN: usize;
+    const NONCE_LEN: usize;
+    const TAG_LEN: usize;
+
+    fn new(key: &[u8; 32]) -> Self;
+
+    fn seal_in_place<'a>(
+        &self,
+        nonce: &[u8; 12],
+        aad: &[u8],
+        in_out: &'a mut [u8],
+    ) -> Result<&'a [u8], Invalid>;
+
+    fn open_in_place<'a>(
+        &self,
+        nonce: &[u8; 12],
+        aad: &[u8],
+        in_out: &'a mut [u8],
+    ) -> Result<&'a [u8], NotAuthentic>;
+}
+
+pub struct Key<A: Algorithm>([u8; 32], PhantomData<A>);
+
+impl<A: Algorithm> Key<A> {
+    pub const SIZE: usize = A::KEY_LEN;
+
+    pub fn new(bytes: [u8; 32]) -> Self {
+        Key(bytes, PhantomData)
+    }
+}
+
+impl<A: Algorithm> AsRef<[u8; 32]> for Key<A> {
+    fn as_ref(&self) -> &[u8; 32] {
+        &self.0
+    }
+}
+
+pub struct Nonce<A: Algorithm>([u8; 8], PhantomData<A>);
+
+impl<A: Algorithm> Nonce<A> {
+    pub const SIZE: usize = A::NONCE_LEN - 4;
+
+    pub fn new(bytes: [u8; 8]) -> Self {
+        Nonce(bytes, PhantomData)
+    }
+}
+
+impl<A: Algorithm> AsRef<[u8; 8]> for Nonce<A> {
+    fn as_ref(&self) -> &[u8; 8] {
+        &self.0
+    }
+}
+
+#[repr(transparent)]
+pub struct Aad<'a>(&'a [u8]);
+
+impl<'a> Aad<'a> {
+    #[inline]
+    pub const fn from(aad: &'a [u8]) -> Self {
+        Aad(aad)
+    }
+}
+
+impl Aad<'static> {
+    #[inline]
+    pub fn empty() -> Self {
+        Self::from(&[])
+    }
+}
+
+impl<'a> AsRef<[u8]> for Aad<'a> {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+pub(crate) struct Counter<A: Algorithm> {
+    nonce: [u8; 8],
+    seq_num: u32,
+    phantom_data: PhantomData<A>,
+}
+
+impl<A: Algorithm> Counter<A> {
+    pub fn zero(nonce: Nonce<A>) -> Self {
+        Counter {
+            nonce: nonce.0,
+            seq_num: 0,
+            phantom_data: PhantomData,
+        }
+    }
+
+    pub fn next(&mut self) -> Result<[u8; 12], Exceeded> {
+        let seq_num = self.seq_num.checked_add(1).ok_or(Exceeded)?;
 
-    fn tag_len(&self) -> usize;
+        let mut nonce = [0; 12];
+        &nonce[..8].copy_from_slice(self.nonce.as_ref());
+        nonce[8..].copy_from_slice(self.seq_num.to_le_bytes().as_ref());
+        self.seq_num = seq_num;
+        Ok(nonce)
+    }
 }

src/error.rs

@@ -0,0 +1,85 @@
+use std::error::Error;
+use std::{fmt, io};
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct NotAuthentic;
+
+impl NotAuthentic {
+    const fn description() -> &'static str {
+        "not authentic"
+    }
+}
+
+impl Error for NotAuthentic {
+    fn description(&self) -> &str {
+        Self::description()
+    }
+}
+
+impl fmt::Display for NotAuthentic {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", Self::description())
+    }
+}
+
+impl From<NotAuthentic> for io::Error {
+    fn from(_: NotAuthentic) -> Self {
+        io::Error::new(io::ErrorKind::InvalidData, NotAuthentic)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Exceeded;
+
+impl Exceeded {
+    const fn description() -> &'static str {
+        "data limit exceeded"
+    }
+}
+
+impl Error for Exceeded {
+    fn description(&self) -> &str {
+        Self::description()
+    }
+}
+
+impl fmt::Display for Exceeded {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", Self::description())
+    }
+}
+
+impl From<Exceeded> for io::Error {
+    fn from(_: Exceeded) -> Self {
+        io::Error::new(io::ErrorKind::InvalidData, Exceeded)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Invalid {
+    Key,
+    Nonce,
+    BufSize,
+}
+
+impl Error for Invalid {
+    fn description(&self) -> &str {
+        match self {
+            Invalid::Key => "sio::Invalid::Key",
+            Invalid::Nonce => "sio::Invalid::Nonce",
+            Invalid::BufSize => "sio::Invalid::BufSize",
+        }
+    }
+}
+
+impl fmt::Display for Invalid {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.description())
+    }
+}
+
+impl From<Invalid> for io::Error {
+    fn from(e: Invalid) -> Self {
+        io::Error::new(io::ErrorKind::Other, e)
+    }
+}