Merge pull request #18 from sekey/dev

Merge version 0.2.1 onto master

Author: ntrippar

Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "ssh-agent"
 description = "Library for implementing an SSH agent"
-version = "0.2.0"
+version = "0.2.1"
 license = "MIT"
 authors = [
     "Nicolas Trippar <ntrippar@gmail.com>",
     "Federico Pomar <fmpomar@users.noreply.github.com>"
 ]
+repository = "https://github.com/sekey/ssh-agent.rs"
 readme = "README.md"
 edition = "2018"
 
@@ -16,10 +17,7 @@ codecov = { repository = "sekey/ssh-agent.rs" }
 
 [dependencies]
 byteorder = "1.2.7"
-num-derive = "0.2"
-num-traits = "0.2"
-serde = "1.0.87"
-serde_derive = "1.0.87"
+serde = {version = "1.0.87", features = ["derive"]}
 bytes = "0.4.11"
 tokio = "0.1.15"
 tokio-uds = "0.2.5"

examples/key_storage.rs

@@ -1,7 +1,4 @@
-#[macro_use]
-extern crate log;
-extern crate env_logger;
-extern crate openssl;
+use log::info;
 
 use ssh_agent::proto::{from_bytes, to_bytes};
 use ssh_agent::proto::message::{self, Message, SignRequest};

src/agent.rs

@@ -1,24 +1,22 @@
-use tokio_uds::UnixListener;
+use byteorder::{BigEndian, ReadBytesExt};
+use bytes::{BytesMut, BufMut};
+use futures::future::FutureResult;
+use log::{error, info};
+use tokio::codec::{Framed, Encoder, Decoder};
 use tokio::net::TcpListener;
-use std::net::SocketAddr;
 use tokio::prelude::*;
+use tokio_uds::UnixListener;
 
-use std::mem::size_of;
 use std::error::Error;
-use std::sync::Arc;
 use std::fmt::Debug;
+use std::mem::size_of;
+use std::net::SocketAddr;
+use std::path::Path;
+use std::sync::Arc;
 
-use super::proto::{from_bytes, to_bytes};
-use super::proto::message::Message;
 use super::error::AgentError;
-
-use bytes::{BytesMut, BufMut};
-
-use byteorder::{BigEndian, ReadBytesExt};
-
-use tokio::codec::{Framed, Encoder, Decoder};
-
-use futures::future::FutureResult;
+use super::proto::message::Message;
+use super::proto::{from_bytes, to_bytes};
 
 struct MessageCodec;
 
@@ -89,7 +87,7 @@ pub trait Agent: 'static + Sync + Send + Sized {
         Box::new(FutureResult::from(self.handle(message)))
     }
 
-    fn run_unix(self, path: &str) -> Result<(), Box<Error>> {
+    fn run_unix(self, path: impl AsRef<Path>) -> Result<(), Box<Error>> {
         let socket = UnixListener::bind(path)?;
         Ok(tokio::run(handle_clients!(self, socket)))
     }

src/lib.rs

@@ -1,16 +1,5 @@
 #![deny(missing_debug_implementations)]
 
-extern crate byteorder;
-extern crate num_traits;
-
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-extern crate serde_derive;
-extern crate serde;
-extern crate bytes;
-
 pub mod proto;
 pub mod agent;
 pub mod error;

src/proto/message.rs

@@ -1,3 +1,5 @@
+use serde::{Deserialize, Serialize};
+
 use super::private_key::PrivateKey;
 
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]

src/proto/private_key.rs

@@ -1,11 +1,12 @@
-use serde::de::{Deserialize, Deserializer, Error};
-use serde::ser::{Serialize, Serializer, SerializeTuple};
+use serde::{Deserialize, Serialize};
+use serde::de::{Deserializer, Error};
+use serde::ser::{Serializer, SerializeTuple};
 use super::error::ProtoError;
 use super::key_type::{KeyType, KeyTypeEnum};
 
 pub type MpInt = Vec<u8>;
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DssPrivateKey {
     pub p: MpInt,
     pub q: MpInt,
@@ -14,13 +15,13 @@ pub struct DssPrivateKey {
     pub x: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct Ed25519PrivateKey {
     pub enc_a: Vec<u8>,
     pub k_enc_a: Vec<u8>
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct RsaPrivateKey {
     pub n: MpInt,
     pub e: MpInt,
@@ -30,14 +31,14 @@ pub struct RsaPrivateKey {
     pub q: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EcDsaPrivateKey {
     pub identifier: String,
     pub q: MpInt,
     pub d: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum PrivateKey {
     Dss(DssPrivateKey),
     Ed25519(Ed25519PrivateKey),

src/proto/public_key.rs

@@ -1,37 +1,38 @@
-use serde::de::{Deserialize, Deserializer, Error};
-use serde::ser::{Serialize, Serializer, SerializeTuple};
+use serde::{Deserialize, Serialize};
+use serde::de::{Deserializer, Error};
+use serde::ser::{Serializer, SerializeTuple};
 use super::error::ProtoError;
 use super::private_key::*;
 use super::key_type::{KeyType, KeyTypeEnum};
 
 pub type MpInt = Vec<u8>;
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct RsaPublicKey {
     pub e: MpInt,
     pub n: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DssPublicKey {
     pub p: MpInt,
     pub q: MpInt,
     pub g: MpInt,
     pub y: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EcDsaPublicKey {
     pub identifier: String,
     pub q: MpInt
 }
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct Ed25519PublicKey {
     pub enc_a: Vec<u8>
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum PublicKey {
     Dss(DssPublicKey),
     Ed25519(Ed25519PublicKey),

src/proto/ser.rs

@@ -315,10 +315,8 @@ impl<'a, W: io::Write> ser::SerializeStructVariant for &'a mut Serializer<W> {
 
 
 pub fn to_bytes<T: Serialize>(value: &T) -> ProtoResult<Vec<u8>> {
-    use bytes::BufMut;
-    let writer = vec![].writer();
-    let mut serializer = Serializer::from_writer(writer);
+    let mut serializer = Serializer::from_writer(Vec::new());
     value.serialize(&mut serializer)?;
-    Ok(serializer.writer.into_inner())
+    Ok(serializer.writer)
 }
 

src/proto/signature.rs

@@ -1,8 +1,37 @@
+use serde::{Deserialize, Serialize};
+
+use super::private_key::*;
+use super::key_type::{KeyType};
+use super::to_bytes;
+
+pub type MpInt = Vec<u8>;
+
 pub const RSA_SHA2_256: u32 = 0x02;
 pub const RSA_SHA2_512: u32 = 0x04;
 
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Signature {
     pub algorithm: String,
     pub blob: Vec<u8>
-}
+}
+
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+pub struct EcDsaSignature {
+    pub identifier: String,
+    pub data: EcDsaSignatureData
+}
+
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+pub struct EcDsaSignatureData {
+    pub r: Vec<u8>,
+    pub s: Vec<u8>
+}
+
+impl From<EcDsaSignature> for Signature {
+    fn from(signature: EcDsaSignature) -> Signature {
+        Signature {
+            algorithm: format!("{}-{}", EcDsaPrivateKey::KEY_TYPE, signature.identifier),
+            blob: to_bytes(&signature.data).unwrap()
+        }
+    }
+}