Merge Environment variable passing support

From Github #35

Author: mkj

Cargo.toml

@@ -76,7 +76,6 @@ mlkem = ["dep:ml-kem"]
 openssh-key = ["ssh-key"]
 # implements embedded_io::Error for sunset::Error
 embedded-io = ["dep:embedded-io"]
-
 # Arbitrary for fuzzing. std is required for derive(Arbitrary)
 arbitrary = ["dep:arbitrary", "std"]
 

demo/common/src/config.rs

@@ -178,7 +178,7 @@ where
         let ad = Ipv4Address::from_bits(ad);
         let prefix = SSHDecode::dec(s)?;
         if prefix > 32 {
-            // emabassy panics, so test it here
+            // embassy panics, so test it here
             return Err(WireError::PacketWrong);
         }
         let gw: Option<u32> = dec_option(s)?;

demo/common/src/server.rs

@@ -118,6 +118,7 @@ impl DemoCommon {
             ServEvent::PubkeyAuth(a) => self.handle_pubkey(a),
             ServEvent::OpenSession(a) => self.open_session(a),
             ServEvent::SessionPty(a) => a.succeed(),
+            ServEvent::SessionEnv(a) => a.succeed(),
             ServEvent::SessionSubsystem(a) => {
                 info!("Ignored request for subsystem '{}'", a.command()?);
                 Ok(())

src/channel.rs

@@ -569,6 +569,27 @@ impl Channels {
             _ => Err(Error::bug()),
         }
     }
+
+    pub fn fetch_env_name<'p>(&self, p: &Packet<'p>) -> Result<TextString<'p>> {
+        match p {
+            Packet::ChannelRequest(ChannelRequest {
+                req: ChannelReqType::Environment(packets::Environment { name, .. }),
+                ..
+            }) => Ok(name.clone()),
+            _ => Err(Error::bug()),
+        }
+    }
+
+    pub fn fetch_env_value<'p>(&self, p: &Packet<'p>) -> Result<TextString<'p>> {
+        match p {
+            Packet::ChannelRequest(ChannelRequest {
+                req:
+                    ChannelReqType::Environment(packets::Environment { name: _, value }),
+                ..
+            }) => Ok(value.clone()),
+            _ => Err(Error::bug()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -900,6 +921,9 @@ impl Channel {
             ChannelReqType::Pty(_) => {
                 Ok(DispatchEvent::ServEvent(ServEventId::SessionPty { num }))
             }
+            ChannelReqType::Environment(_) => {
+                Ok(DispatchEvent::ServEvent(ServEventId::Environment { num }))
+            }
             _ => {
                 if let ChannelReqType::Unknown(u) = &p.req {
                     warn!("Unknown channel req type \"{}\"", u)

src/event.rs

@@ -301,6 +301,9 @@ pub enum ServEvent<'g, 'a> {
     ///
     /// TODO details
     SessionPty(ServPtyRequest<'g, 'a>),
+    /// Server has received one environment variable.
+    /// Note: input strings are not sanitised.
+    SessionEnv(ServEnvironmentRequest<'g, 'a>),
 
     /// The SSH session is no longer running
     #[allow(unused)]
@@ -326,6 +329,7 @@ impl Debug for ServEvent<'_, '_> {
             Self::SessionExec(_) => "SessionExec",
             Self::SessionSubsystem(_) => "SessionSubsystem",
             Self::SessionPty(_) => "SessionPty",
+            Self::SessionEnv(_) => "Environment",
             Self::Defunct => "Defunct",
             Self::PollAgain => "PollAgain",
         };
@@ -745,7 +749,7 @@ impl<'g, 'a> ServExecRequest<'g, 'a> {
         self.raw_command()?.as_str()
     }
 
-    pub fn raw_command(&self) -> Result<TextString<'_>> {
+    fn raw_command(&self) -> Result<TextString<'_>> {
         self.runner.fetch_servcommand()
     }
 
@@ -847,6 +851,69 @@ impl Drop for ServPtyRequest<'_, '_> {
     }
 }
 
+/// An environment variable request
+///
+pub struct ServEnvironmentRequest<'g, 'a> {
+    runner: &'g mut Runner<'a, Server>,
+    num: ChanNum,
+    done: bool,
+}
+
+impl<'g, 'a> ServEnvironmentRequest<'g, 'a> {
+    fn new(runner: &'g mut Runner<'a, Server>, num: ChanNum) -> Self {
+        Self { runner, num, done: false }
+    }
+
+    /// Indicate that the request succeeded.
+    ///
+    /// Note that if the peer didn't request a reply, this call
+    /// will not do anything.
+    pub fn succeed(mut self) -> Result<()> {
+        self.done = true;
+        self.runner.resume_chanreq(true)
+    }
+
+    /// Indicate that the request failed.
+    ///
+    /// Note that if the peer didn't request a reply, this call
+    /// will not do anything.
+    /// Does not need to be called explicitly, also occurs on drop without `accept()`
+    pub fn fail(mut self) -> Result<()> {
+        self.done = true;
+        self.runner.resume_chanreq(false)
+    }
+
+    /// Return the associated channel number.
+    ///
+    /// This will correspond to a `ChanHandle::num()`
+    /// from a previous [`ServOpenSession`] event.
+    pub fn channel(&self) -> ChanNum {
+        self.num
+    }
+
+    /// Retrieve the name of the environment variable (from NAME=VALUE pair).
+    pub fn name(&self) -> Result<&str> {
+        self.raw_name()?.as_str()
+    }
+
+    /// Retrieve the raw name of the environment variable.
+    fn raw_name(&self) -> Result<TextString<'_>> {
+        self.runner.fetch_env_name()
+    }
+
+    /// Retrieve the value of the environment variable (from NAME=VALUE pair).
+    pub fn value(&self) -> Result<&str> {
+        self.raw_value()?.as_str()
+    }
+
+    /// Retrieve the raw value of the environment variable.
+    fn raw_value(&self) -> Result<TextString<'_>> {
+        self.runner.fetch_env_value()
+    }
+
+    // TODO: does the app care about wantreply?
+}
+
 // Only small values should be stored inline.
 // Larger state is retrieved from the current packet via Runner::fetch_*()
 #[derive(Debug, Clone)]
@@ -872,6 +939,9 @@ pub(crate) enum ServEventId {
     SessionPty {
         num: ChanNum,
     },
+    Environment {
+        num: ChanNum,
+    },
     #[allow(unused)]
     Defunct,
     // TODO:
@@ -925,6 +995,10 @@ impl ServEventId {
                 debug_assert!(matches!(p, Some(Packet::ChannelRequest(_))));
                 Ok(ServEvent::SessionPty(ServPtyRequest::new(runner, num)))
             }
+            Self::Environment { num } => {
+                debug_assert!(matches!(p, Some(Packet::ChannelRequest(_))));
+                Ok(ServEvent::SessionEnv(ServEnvironmentRequest::new(runner, num)))
+            }
             Self::Defunct => Ok(ServEvent::Defunct),
         }
     }
@@ -942,6 +1016,7 @@ impl ServEventId {
             | Self::SessionShell { .. }
             | Self::SessionExec { .. }
             | Self::SessionSubsystem { .. }
+            | Self::Environment { .. }
             | Self::SessionPty { .. } => true,
         }
     }

src/packets.rs

@@ -2,7 +2,7 @@
 //!
 //! A [`Packet`] can be encoded/decoded to the
 //! SSH Binary Packet Protocol using [`sshwire`].
-//! SSH packet format is described in [RFC4253](https://tools.ietf.org/html/rfc5643) SSH Transport
+//! SSH packet format is described in [RFC4253](https://tools.ietf.org/html/rfc4253#section-6) SSH Transport
 
 #[allow(unused_imports)]
 use {
@@ -722,6 +722,8 @@ pub enum ChannelReqType<'a> {
     Subsystem(Subsystem<'a>),
     #[sshwire(variant = "window-change")]
     WinChange(WinChange),
+    #[sshwire(variant = "env")]
+    Environment(Environment<'a>),
     #[sshwire(variant = "signal")]
     Signal(Signal<'a>),
     #[sshwire(variant = "exit-status")]
@@ -736,7 +738,6 @@ pub enum ChannelReqType<'a> {
     // Other requests that aren't implemented at present:
     // [email protected]
     // x11-req
-    // env
     // xon-xoff
     #[sshwire(unknown)]
     Unknown(Unknown<'a>),
@@ -777,6 +778,14 @@ pub struct WinChange {
     pub height: u32,
 }
 
+/// An environment variable
+#[derive(Debug, SSHEncode, SSHDecode)]
+#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
+pub struct Environment<'a> {
+    pub name: TextString<'a>,
+    pub value: TextString<'a>,
+}
+
 /// A unix signal channel request
 #[derive(Debug, SSHEncode, SSHDecode)]
 #[cfg_attr(feature = "arbitrary", derive(Arbitrary))]

src/runner.rs

@@ -778,6 +778,7 @@ impl<'a, CS: CliServ> Runner<'a, CS> {
                 | DispatchEvent::ServEvent(ServEventId::SessionExec { .. })
                 | DispatchEvent::ServEvent(ServEventId::SessionSubsystem { .. })
                 | DispatchEvent::ServEvent(ServEventId::SessionPty { .. })
+                | DispatchEvent::ServEvent(ServEventId::Environment { .. })
         ));
     }
 
@@ -800,6 +801,20 @@ impl<'a, CS: CliServ> Runner<'a, CS> {
         let p = self.conn.packet(payload)?;
         self.conn.channels.fetch_servcommand(&p)
     }
+
+    pub(crate) fn fetch_env_name(&self) -> Result<TextString<'_>> {
+        Self::check_chanreq(&self.resume_event);
+        let (payload, _seq) = self.traf_in.payload().trap()?;
+        let p = self.conn.packet(payload)?;
+        self.conn.channels.fetch_env_name(&p)
+    }
+
+    pub(crate) fn fetch_env_value(&self) -> Result<TextString<'_>> {
+        Self::check_chanreq(&self.resume_event);
+        let (payload, _seq) = self.traf_in.payload().trap()?;
+        let p = self.conn.packet(payload)?;
+        self.conn.channels.fetch_env_value(&p)
+    }
 }
 
 /// Sets a waker, waking any existing waker