Merge pull request #3 from microsoft/fips

add flags for openssl-only crypto

.gitignore

@@ -4,3 +4,4 @@
 target
 Cargo.lock
 .cargo-ok
+/.devcontainer

russh-keys/Cargo.toml

@@ -29,25 +29,25 @@ repository = "https://nest.pijul.com/pijul/russh"
 version = "0.22.0-beta.7"
 
 [dependencies]
-aes = "0.8"
+aes = { version = "0.8", optional = true }
 bcrypt-pbkdf = "0.6"
 bit-vec = "0.6"
-cbc = "0.1"
-ctr = "0.9"
-block-padding = { version = "0.3", features = ["std"] }
+cbc = { version = "0.1", optional = true }
+ctr = { version = "0.9", optional = true }
+block-padding = { version = "0.3", features = ["std"], optional = true }
 byteorder = "1.4"
 data-encoding = "2.3"
 dirs = "3.0"
-ed25519-dalek = "1.0"
+ed25519-dalek = { version = "1.0", optional = true }
 futures = "0.3"
-hmac = "0.12"
+hmac = { version = "0.12", optional = true }
 inout = { version = "0.1", features = ["std"] }
 log = "0.4"
 md5 = "0.7"
 num-bigint = "0.4"
 num-integer = "0.1"
-openssl = { version = "0.10", optional = true }
-pbkdf2 = "0.11"
+openssl = { version = "^0.10.40", optional = true }
+pbkdf2 = { version = "0.11", optional = true }
 rand = "0.7"
 rand_core = { version = "0.5", features = ["std"] }
 russh-cryptovec = { version = "0.7.0-beta.1", path = "../cryptovec" }
@@ -65,7 +65,17 @@ tokio-stream = { version = "0.1", features = ["net"] }
 yasna = { version = "0.4.0", features = ["bit-vec", "num-bigint"] }
 
 [features]
+default = ["rs-crypto"]
 vendored-openssl = ["openssl", "openssl/vendored"]
+rs-crypto = [
+ "dep:aes",
+ "dep:cbc",
+ "dep:ctr",
+ "dep:block-padding",
+ "dep:hmac",
+ "dep:pbkdf2",
+ "dep:ed25519-dalek",
+]
 
 [dev-dependencies]
 env_logger = "0.8"

russh-keys/src/agent/client.rs

@@ -99,6 +99,7 @@ impl<S: AsyncRead + AsyncWrite + Unpin> AgentClient<S> {
  self.buf.push(msg::ADD_ID_CONSTRAINED)
  }
  match *key {
+ #[cfg(feature = "rs-crypto")]
  key::KeyPair::Ed25519(ref pair) => {
  self.buf.extend_ssh_string(b"ssh-ed25519");
  self.buf.extend_ssh_string(pair.public.as_bytes());
@@ -261,6 +262,7 @@ impl<S: AsyncRead + AsyncWrite + Unpin> AgentClient<S> {
  hash: SignatureHash::SHA2_512,
  })
  }
+ #[cfg(feature = "rs-crypto")]
  b"ssh-ed25519" => keys.push(PublicKey::Ed25519(
  ed25519_dalek::PublicKey::from_bytes(r.read_string()?)?,
  )),
@@ -510,6 +512,7 @@ fn key_blob(public: &key::PublicKey, buf: &mut CryptoVec) -> Result<(), Error> {
  #[allow(clippy::indexing_slicing)] // length is known
  BigEndian::write_u32(&mut buf[5..], (len1 - len0) as u32);
  }
+ #[cfg(feature = "rs-crypto")]
  PublicKey::Ed25519(ref p) => {
  buf.extend(&[0, 0, 0, 0]);
  let len0 = buf.len();

russh-keys/src/agent/server.rs

@@ -233,9 +233,11 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + 'stat
  constrained: bool,
  writebuf: &mut CryptoVec,
  ) -> Result<bool, Error> {
+ #[cfg(feature = "rs-crypto")]
  let pos0 = r.position;
  let t = r.read_string()?;
  let (blob, key) = match t {
+ #[cfg(feature = "rs-crypto")]
  b"ssh-ed25519" => {
  let public_ = r.read_string()?;
  let pos1 = r.position;

russh-keys/src/format/openssh.rs

@@ -1,7 +1,3 @@
-use aes::cipher::block_padding::NoPadding;
-use aes::cipher::{BlockDecryptMut, KeyIvInit, StreamCipher};
-use bcrypt_pbkdf;
-use ctr::Ctr64LE;
 #[cfg(feature = "openssl")]
 use openssl::bn::BigNum;
 
@@ -35,21 +31,24 @@ pub fn decode_openssh(secret: &[u8], password: Option<&str>) -> Result<key::KeyP
  for _ in 0..nkeys {
  // TODO check: never really loops beyong the first key
  let key_type = position.read_string()?;
- if key_type == KEYTYPE_ED25519 {
- let pubkey = position.read_string()?;
- let seckey = position.read_string()?;
- let _comment = position.read_string()?;
- if Some(pubkey) != seckey.get(32..) {
- return Err(Error::KeyIsCorrupt);
+ if key_type == KEYTYPE_ED25519 && cfg!(feature = "rs-crypto") {
+ #[cfg(feature = "rs-crypto")]
+ {
+ let pubkey = position.read_string()?;
+ let seckey = position.read_string()?;
+ let _comment = position.read_string()?;
+ if Some(pubkey) != seckey.get(32..) {
+ return Err(Error::KeyIsCorrupt);
+ }
+ let secret = ed25519_dalek::SecretKey::from_bytes(
+ seckey.get(..32).ok_or(Error::KeyIsCorrupt)?,
+ )?;
+ let public = (&secret).into();
+ return Ok(key::KeyPair::Ed25519(ed25519_dalek::Keypair {
+ secret,
+ public,
+ }));
  }
- let secret = ed25519_dalek::SecretKey::from_bytes(
- seckey.get(..32).ok_or(Error::KeyIsCorrupt)?,
- )?;
- let public = (&secret).into();
- return Ok(key::KeyPair::Ed25519(ed25519_dalek::Keypair {
- secret,
- public,
- }));
  } else if key_type == KEYTYPE_RSA && cfg!(feature = "openssl") {
  #[cfg(feature = "openssl")]
  {
@@ -91,8 +90,6 @@ pub fn decode_openssh(secret: &[u8], password: Option<&str>) -> Result<key::KeyP
  }
 }
 
-use aes::*;
-
 fn decrypt_secret_key(
  ciphername: &[u8],
  kdfname: &[u8],
@@ -130,32 +127,51 @@ fn decrypt_secret_key(
 
  let mut dec = secret_key.to_vec();
  dec.resize(dec.len() + 32, 0u8);
- match ciphername {
- b"aes128-cbc" => {
- #[allow(clippy::unwrap_used)] // parameters are static
- let cipher = cbc::Decryptor::<Aes128>::new_from_slices(key, iv).unwrap();
- let n = cipher.decrypt_padded_mut::<NoPadding>(&mut dec)?.len();
- dec.truncate(n)
- }
- b"aes256-cbc" => {
- #[allow(clippy::unwrap_used)] // parameters are static
- let cipher = cbc::Decryptor::<Aes256>::new_from_slices(key, iv).unwrap();
- let n = cipher.decrypt_padded_mut::<NoPadding>(&mut dec)?.len();
- dec.truncate(n)
- }
- b"aes128-ctr" => {
- #[allow(clippy::unwrap_used)] // parameters are static
- let mut cipher = Ctr64LE::<Aes128>::new_from_slices(key, iv).unwrap();
- cipher.apply_keystream(&mut dec);
- dec.truncate(secret_key.len())
+ #[cfg(feature = "rs-crypto")]
+ {
+ use aes::cipher::block_padding::NoPadding;
+ use aes::cipher::{BlockDecryptMut, KeyIvInit, StreamCipher};
+ use aes::*;
+ use ctr::Ctr64LE;
+
+ match ciphername {
+ b"aes128-cbc" => {
+ #[allow(clippy::unwrap_used)] // parameters are static
+ let cipher = cbc::Decryptor::<Aes128>::new_from_slices(key, iv).unwrap();
+ let n = cipher.decrypt_padded_mut::<NoPadding>(&mut dec)?.len();
+ dec.truncate(n)
+ }
+ b"aes256-cbc" => {
+ #[allow(clippy::unwrap_used)] // parameters are static
+ let cipher = cbc::Decryptor::<Aes256>::new_from_slices(key, iv).unwrap();
+ let n = cipher.decrypt_padded_mut::<NoPadding>(&mut dec)?.len();
+ dec.truncate(n)
+ }
+ b"aes128-ctr" => {
+ #[allow(clippy::unwrap_used)] // parameters are static
+ let mut cipher = Ctr64LE::<Aes128>::new_from_slices(key, iv).unwrap();
+ cipher.apply_keystream(&mut dec);
+ dec.truncate(secret_key.len())
+ }
+ b"aes256-ctr" => {
+ #[allow(clippy::unwrap_used)] // parameters are static
+ let mut cipher = Ctr64LE::<Aes256>::new_from_slices(key, iv).unwrap();
+ cipher.apply_keystream(&mut dec);
+ dec.truncate(secret_key.len())
+ }
+ _ => {}
  }
- b"aes256-ctr" => {
- #[allow(clippy::unwrap_used)] // parameters are static
- let mut cipher = Ctr64LE::<Aes256>::new_from_slices(key, iv).unwrap();
- cipher.apply_keystream(&mut dec);
- dec.truncate(secret_key.len())
+ }
+ #[cfg(all(feature = "openssl", not(feature = "rs-crypto")))]
+ {
+ use openssl::symm::{decrypt, Cipher};
+ dec = match ciphername {
+ b"aes128-cbc" => decrypt(Cipher::aes_128_cbc(), key, Some(iv), &dec)?,
+ b"aes256-cbc" => decrypt(Cipher::aes_256_cbc(), key, Some(iv), &dec)?,
+ b"aes128-ctr" => decrypt(Cipher::aes_128_ctr(), key, Some(iv), &dec)?,
+ b"aes256-ctr" => decrypt(Cipher::aes_256_ctr(), key, Some(iv), &dec)?,
+ _ => dec,
  }
- _ => {}
  }
  Ok(dec)
  } else {

russh-keys/src/format/pkcs5.rs

@@ -1,5 +1,3 @@
-use aes::*;
-
 use super::Encryption;
 use crate::{key, Error};
 
@@ -11,8 +9,7 @@ pub fn decode_pkcs5(
  password: Option<&str>,
  enc: Encryption,
 ) -> Result<key::KeyPair, Error> {
- use aes::cipher::{BlockDecryptMut, KeyIvInit};
- use block_padding::Pkcs7;
+ use openssl::symm::{decrypt, Cipher};
 
  if let Some(pass) = password {
  let sec = match enc {
@@ -23,10 +20,7 @@ pub fn decode_pkcs5(
  let md5 = c.compute();
 
  #[allow(clippy::unwrap_used)] // AES parameters are static
- let c = cbc::Decryptor::<Aes128>::new_from_slices(&md5.0, &iv[..]).unwrap();
- let mut dec = secret.to_vec();
- c.decrypt_padded_mut::<Pkcs7>(&mut dec)?;
- dec
+ decrypt(Cipher::aes_128_cbc(), &md5.0, Some(&iv[..]), secret)?
  }
  Encryption::Aes256Cbc(_) => unimplemented!(),
  };