Add protocol dumper example

Signed-off-by: Wiktor Kwapisiewicz <[email protected]>

Author: wiktor-k

examples/proto-dumper.rs

@@ -0,0 +1,98 @@
+//! This example illustrates a couple of features: First, it
+//! implements a forwarder, exposing an SSH agent socket and
+//! forwarding to a different one. Secondly it shows how to work with
+//! low-level handling of messages instead of parsed high-level
+//! structures.
+//!
+//! Run with
+//! RUST_LOG=info cargo run --example proto-dumper -- --target unix://$SSH_AUTH_SOCK -H unix:///tmp/test.sock
+
+use clap::Parser;
+use service_binding::Binding;
+use ssh_agent_lib::{
+    agent::Agent,
+    agent::Session,
+    async_trait,
+    client::connect,
+    error::AgentError,
+    proto::{Request, Response},
+};
+use ssh_encoding::Encode;
+
+struct DumpAndForward {
+    target: Box<dyn Session>,
+    session: u64,
+    id: u64,
+}
+
+#[async_trait]
+impl Session for DumpAndForward {
+    async fn handle(&mut self, message: Request) -> Result<Response, AgentError> {
+        use std::io::Write;
+
+        self.id += 1;
+        let req_file = format!("req-{}-{}.bin", self.session, self.id);
+        log::info!("Writing request {message:?} to {req_file}");
+
+        let mut req = std::fs::File::create(req_file)?;
+        let mut buf = vec![];
+        message.encode(&mut buf).map_err(AgentError::other)?;
+        req.write_all(&buf)?;
+        drop(req);
+
+        let response = self.target.handle(message).await?;
+
+        let resp_file = format!("resp-{}-{}.bin", self.session, self.id);
+        log::info!("Writing response {response:?} to {resp_file}");
+        let mut resp = std::fs::File::create(resp_file)?;
+        let mut buf = vec![];
+        response.encode(&mut buf).map_err(AgentError::other)?;
+        resp.write_all(&buf)?;
+        drop(resp);
+
+        Ok(response)
+    }
+}
+
+struct Forwarder {
+    target: Binding,
+    id: u64,
+}
+
+impl Agent for Forwarder {
+    fn new_session(&mut self) -> impl Session {
+        self.id += 1;
+        DumpAndForward {
+            target: connect(self.target.clone().try_into().unwrap()).unwrap(),
+            session: self.id,
+            id: 0,
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+struct Args {
+    /// Target SSH agent to which we will proxy all requests.
+    #[clap(long)]
+    target: Binding,
+
+    /// Source that we will bind to.
+    #[clap(long, short = 'H')]
+    host: Binding,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    env_logger::init();
+
+    let args = Args::parse();
+
+    Forwarder {
+        target: args.target,
+        id: 0,
+    }
+    .bind(args.host.try_into()?)
+    .await?;
+
+    Ok(())
+}

examples/ssh-agent-client.rs

@@ -5,11 +5,11 @@ use ssh_agent_lib::client::connect;
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[cfg(unix)]
     let mut client =
-        connect(Binding::FilePath(std::env::var("SSH_AUTH_SOCK")?.into()).try_into()?).await?;
+        connect(Binding::FilePath(std::env::var("SSH_AUTH_SOCK")?.into()).try_into()?)?;
 
     #[cfg(windows)]
     let mut client =
-        connect(Binding::NamedPipe(std::env::var("SSH_AUTH_SOCK")?.into()).try_into()?).await?;
+        connect(Binding::NamedPipe(std::env::var("SSH_AUTH_SOCK")?.into()).try_into()?)?;
 
     eprintln!(
         "Identities that this agent knows of: {:#?}",

src/client.rs

@@ -37,18 +37,18 @@ where
 }
 
 /// Wrap a stream into an SSH agent client.
-pub async fn connect(
+pub fn connect(
     stream: service_binding::Stream,
-) -> Result<std::pin::Pin<Box<dyn crate::agent::Session>>, Box<dyn std::error::Error>> {
+) -> Result<Box<dyn crate::agent::Session>, Box<dyn std::error::Error>> {
     match stream {
         #[cfg(unix)]
         service_binding::Stream::Unix(stream) => {
             let stream = tokio::net::UnixStream::from_std(stream)?;
-            Ok(Box::pin(Client::new(stream)))
+            Ok(Box::new(Client::new(stream)))
         }
         service_binding::Stream::Tcp(stream) => {
             let stream = tokio::net::TcpStream::from_std(stream)?;
-            Ok(Box::pin(Client::new(stream)))
+            Ok(Box::new(Client::new(stream)))
         }
         #[cfg(windows)]
         service_binding::Stream::NamedPipe(pipe) => {
@@ -65,9 +65,9 @@ pub async fn connect(
                     Err(e) => Err(e)?,
                 }
 
-                tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+                std::thread::sleep(std::time::Duration::from_millis(50));
             };
-            Ok(Box::pin(Client::new(stream)))
+            Ok(Box::new(Client::new(stream)))
         }
         #[cfg(not(windows))]
         service_binding::Stream::NamedPipe(_) => Err(ProtoError::IO(std::io::Error::other(