initial work towards server-side support

sasl/src/common/mod.rs

@@ -0,0 +1,201 @@
+use std::collections::HashMap;
+
+use std::convert::From;
+
+use std::string::FromUtf8Error;
+
+pub mod scram;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Identity {
+    None,
+    Username(String),
+}
+
+impl From<String> for Identity {
+    fn from(s: String) -> Identity {
+        Identity::Username(s)
+    }
+}
+
+impl<'a> From<&'a str> for Identity {
+    fn from(s: &'a str) -> Identity {
+        Identity::Username(s.to_owned())
+    }
+}
+
+/// A struct containing SASL credentials.
+#[derive(Clone, Debug)]
+pub struct Credentials {
+    /// The requested identity.
+    pub identity: Identity,
+    /// The secret used to authenticate.
+    pub secret: Secret,
+    /// Channel binding data, for *-PLUS mechanisms.
+    pub channel_binding: ChannelBinding,
+}
+
+impl Default for Credentials {
+    fn default() -> Credentials {
+        Credentials {
+            identity: Identity::None,
+            secret: Secret::None,
+            channel_binding: ChannelBinding::Unsupported,
+        }
+    }
+}
+
+impl Credentials {
+    /// Creates a new Credentials with the specified username.
+    pub fn with_username<N: Into<String>>(mut self, username: N) -> Credentials {
+        self.identity = Identity::Username(username.into());
+        self
+    }
+
+    /// Creates a new Credentials with the specified plaintext password.
+    pub fn with_password<P: Into<String>>(mut self, password: P) -> Credentials {
+        self.secret = Secret::password_plain(password);
+        self
+    }
+
+    /// Creates a new Credentials with the specified chanel binding.
+    pub fn with_channel_binding(mut self, channel_binding: ChannelBinding) -> Credentials {
+        self.channel_binding = channel_binding;
+        self
+    }
+}
+
+/// Represents a SASL secret, like a password.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Secret {
+    /// No extra data needed.
+    None,
+    /// Password required.
+    Password(Password),
+}
+
+impl Secret {
+    pub fn password_plain<S: Into<String>>(password: S) -> Secret {
+        Secret::Password(Password::Plain(password.into()))
+    }
+
+    pub fn password_pbkdf2<S: Into<String>>(
+        method: S,
+        salt: Vec<u8>,
+        iterations: usize,
+        data: Vec<u8>,
+    ) -> Secret {
+        Secret::Password(Password::Pbkdf2 {
+            method: method.into(),
+            salt: salt,
+            iterations: iterations,
+            data: data,
+        })
+    }
+}
+
+/// Represents a password.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Password {
+    /// A plaintext password.
+    Plain(String),
+    /// A password digest derived using PBKDF2.
+    Pbkdf2 {
+        method: String,
+        salt: Vec<u8>,
+        iterations: usize,
+        data: Vec<u8>,
+    },
+}
+
+impl From<String> for Password {
+    fn from(s: String) -> Password {
+        Password::Plain(s)
+    }
+}
+
+impl<'a> From<&'a str> for Password {
+    fn from(s: &'a str) -> Password {
+        Password::Plain(s.to_owned())
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn xor_works() {
+    assert_eq!(
+        xor(
+            &[135, 94, 53, 134, 73, 233, 140, 221, 150, 12, 96, 111, 54, 66, 11, 76],
+            &[163, 9, 122, 180, 107, 44, 22, 252, 248, 134, 112, 82, 84, 122, 56, 209]
+        ),
+        &[36, 87, 79, 50, 34, 197, 154, 33, 110, 138, 16, 61, 98, 56, 51, 157]
+    );
+}
+
+#[doc(hidden)]
+pub fn xor(a: &[u8], b: &[u8]) -> Vec<u8> {
+    assert_eq!(a.len(), b.len());
+    let mut ret = Vec::with_capacity(a.len());
+    for (a, b) in a.into_iter().zip(b) {
+        ret.push(a ^ b);
+    }
+    ret
+}
+
+#[doc(hidden)]
+pub fn parse_frame(frame: &[u8]) -> Result<HashMap<String, String>, FromUtf8Error> {
+    let inner = String::from_utf8(frame.to_owned())?;
+    let mut ret = HashMap::new();
+    for s in inner.split(',') {
+        let mut tmp = s.splitn(2, '=');
+        let key = tmp.next();
+        let val = tmp.next();
+        match (key, val) {
+            (Some(k), Some(v)) => {
+                ret.insert(k.to_owned(), v.to_owned());
+            }
+            _ => (),
+        }
+    }
+    Ok(ret)
+}
+
+/// Channel binding configuration.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ChannelBinding {
+    /// No channel binding data.
+    None,
+    /// Advertise that the client does not think the server supports channel binding.
+    Unsupported,
+    /// p=tls-unique channel binding data.
+    TlsUnique(Vec<u8>),
+}
+
+impl ChannelBinding {
+    /// Return the gs2 header for this channel binding mechanism.
+    pub fn header(&self) -> &[u8] {
+        match *self {
+            ChannelBinding::None => b"n,,",
+            ChannelBinding::Unsupported => b"y,,",
+            ChannelBinding::TlsUnique(_) => b"p=tls-unique,,",
+        }
+    }
+
+    /// Return the channel binding data for this channel binding mechanism.
+    pub fn data(&self) -> &[u8] {
+        match *self {
+            ChannelBinding::None => &[],
+            ChannelBinding::Unsupported => &[],
+            ChannelBinding::TlsUnique(ref data) => data,
+        }
+    }
+
+    /// Checks whether this channel binding mechanism is supported.
+    pub fn supports(&self, mechanism: &str) -> bool {
+        match *self {
+            ChannelBinding::None => false,
+            ChannelBinding::Unsupported => false,
+            ChannelBinding::TlsUnique(_) => mechanism == "tls-unique",
+        }
+    }
+}

sasl/src/common/scram.rs

@@ -0,0 +1,155 @@
+use openssl::error::ErrorStack;
+use openssl::hash::hash;
+use openssl::hash::MessageDigest;
+use openssl::pkcs5::pbkdf2_hmac;
+use openssl::pkey::PKey;
+use openssl::rand::rand_bytes;
+use openssl::sign::Signer;
+
+use common::Password;
+
+use base64;
+
+/// Generate a nonce for SCRAM authentication.
+pub fn generate_nonce() -> Result<String, ErrorStack> {
+    let mut data = vec![0; 32];
+    rand_bytes(&mut data)?;
+    Ok(base64::encode(&data))
+}
+
+/// A trait which defines the needed methods for SCRAM.
+pub trait ScramProvider {
+    /// The name of the hash function.
+    fn name() -> &'static str;
+
+    /// A function which hashes the data using the hash function.
+    fn hash(data: &[u8]) -> Vec<u8>;
+
+    /// A function which performs an HMAC using the hash function.
+    fn hmac(data: &[u8], key: &[u8]) -> Vec<u8>;
+
+    /// A function which does PBKDF2 key derivation using the hash function.
+    fn derive(data: &Password, salt: &[u8], iterations: usize) -> Result<Vec<u8>, String>;
+}
+
+/// A `ScramProvider` which provides SCRAM-SHA-1 and SCRAM-SHA-1-PLUS
+pub struct Sha1;
+
+impl ScramProvider for Sha1 {
+    // TODO: look at all these unwraps
+    fn name() -> &'static str {
+        "SHA-1"
+    }
+
+    fn hash(data: &[u8]) -> Vec<u8> {
+        hash(MessageDigest::sha1(), data).unwrap()
+    }
+
+    fn hmac(data: &[u8], key: &[u8]) -> Vec<u8> {
+        let pkey = PKey::hmac(key).unwrap();
+        let mut signer = Signer::new(MessageDigest::sha1(), &pkey).unwrap();
+        signer.update(data).unwrap();
+        signer.finish().unwrap()
+    }
+
+    fn derive(password: &Password, salt: &[u8], iterations: usize) -> Result<Vec<u8>, String> {
+        match *password {
+            Password::Plain(ref plain) => {
+                let mut result = vec![0; 20];
+                pbkdf2_hmac(
+                    plain.as_bytes(),
+                    salt,
+                    iterations,
+                    MessageDigest::sha1(),
+                    &mut result,
+                )
+                .unwrap();
+                Ok(result)
+            }
+            Password::Pbkdf2 {
+                ref method,
+                salt: ref my_salt,
+                iterations: my_iterations,
+                ref data,
+            } => {
+                if method != Self::name() {
+                    Err(format!(
+                        "incompatible hashing method, {} is not {}",
+                        method,
+                        Self::name()
+                    ))
+                } else if my_salt == &salt {
+                    Err(format!("incorrect salt"))
+                } else if my_iterations == iterations {
+                    Err(format!(
+                        "incompatible iteration count, {} is not {}",
+                        my_iterations, iterations
+                    ))
+                } else {
+                    Ok(data.to_vec())
+                }
+            }
+        }
+    }
+}
+
+/// A `ScramProvider` which provides SCRAM-SHA-256 and SCRAM-SHA-256-PLUS
+pub struct Sha256;
+
+impl ScramProvider for Sha256 {
+    // TODO: look at all these unwraps
+    fn name() -> &'static str {
+        "SHA-256"
+    }
+
+    fn hash(data: &[u8]) -> Vec<u8> {
+        hash(MessageDigest::sha256(), data).unwrap()
+    }
+
+    fn hmac(data: &[u8], key: &[u8]) -> Vec<u8> {
+        let pkey = PKey::hmac(key).unwrap();
+        let mut signer = Signer::new(MessageDigest::sha256(), &pkey).unwrap();
+        signer.update(data).unwrap();
+        signer.finish().unwrap()
+    }
+
+    fn derive(password: &Password, salt: &[u8], iterations: usize) -> Result<Vec<u8>, String> {
+        match *password {
+            Password::Plain(ref plain) => {
+                let mut result = vec![0; 32];
+                pbkdf2_hmac(
+                    plain.as_bytes(),
+                    salt,
+                    iterations,
+                    MessageDigest::sha256(),
+                    &mut result,
+                )
+                .unwrap();
+                Ok(result)
+            }
+            Password::Pbkdf2 {
+                ref method,
+                salt: ref my_salt,
+                iterations: my_iterations,
+                ref data,
+            } => {
+                if method != Self::name() {
+                    Err(format!(
+                        "incompatible hashing method, {} is not {}",
+                        method,
+                        Self::name()
+                    ))
+                } else if my_salt == &salt {
+                    Err(format!("incorrect salt"))
+                } else if my_iterations == iterations {
+                    Err(format!(
+                        "incompatible iteration count, {} is not {}",
+                        my_iterations, iterations
+                    ))
+                } else {
+                    Ok(data.to_vec())
+                }
+            }
+        }
+    }
+}