metalssh 0.0.1

Experimental SSH implementation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use crate::constants::msg::SSH_MSG_NEWKEYS;
use crate::types::Error;
use crate::types::Result;
use crate::wire::SshDecode;
use crate::wire::SshEncode;

/// [`SSH_MSG_NEWKEYS`]
pub struct Newkeys<'b> {
    buffer: &'b [u8],
}

impl<'b> Newkeys<'b> {
    /// Writes this message into a buffer in place.
    pub fn new(mut buffer: &'b mut [u8]) -> Result<Self> {
        buffer.write_byte(SSH_MSG_NEWKEYS, &mut 0)?;
        Ok(Self { buffer })
    }

    /// Interprets an existing byte buffer as this message type.
    pub fn from_bytes(buffer: &'b [u8]) -> Result<Self> {
        let message = Self { buffer };
        match message.message_code()? {
            SSH_MSG_NEWKEYS => Ok(message),
            code => Err(Error::UnexpectedMessage(code)),
        }
    }

    /// Gets the message code for this message.
    pub fn message_code(&self) -> Result<u8> {
        self.buffer.read_byte(&mut 0)
    }
}

#[cfg(test)]
mod tests {
    use rstest::rstest;

    use crate::msg::Newkeys;
    use crate::wire::Packet;

    #[rstest]
    #[case("testdata/none-exec/06-server-newkeys.bin")]
    fn read_works(#[case] packet_file: &str) {
        let bytes = std::fs::read(packet_file).unwrap();
        let packet = Packet::new(&bytes, 0);
        let payload = packet.payload().unwrap();

        let _message = Newkeys::from_bytes(payload).unwrap();
    }
}