smb 0.4.0

A Pure Rust SMB Client 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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::io::Cursor;

use super::binrw_util::prelude::*;
use super::{smb1, smb2};
use binrw::io::TakeSeekExt;
use binrw::prelude::*;

#[binrw::binrw]
#[derive(Debug, Default)]
#[brw(big)]
pub struct NetBiosTcpMessage {
    #[bw(calc = NetBiosTcpMessageHeader::default())]
    pub header: NetBiosTcpMessageHeader,
    // use stream_protocol_length to determine the length of the stream_protocol:
    #[br(map_stream = |s| s.take_seek(header.stream_protocol_length.value.into()), parse_with = binrw::helpers::until_eof)]
    #[bw(write_with = PosMarker3Byte::write_and_fill_size, args(&header.stream_protocol_length))]
    pub content: Vec<u8>,
}

#[binrw::binrw]
#[derive(Debug)]
#[brw(big, magic(b"\x00"))]
pub struct NetBiosTcpMessageHeader {
    pub stream_protocol_length: PosMarker3Byte,
}

impl NetBiosTcpMessageHeader {
    /// Size of the header, including the magic number (0x00).
    pub const SIZE: usize = 4;
}

impl Default for NetBiosTcpMessageHeader {
    fn default() -> NetBiosTcpMessageHeader {
        NetBiosTcpMessageHeader {
            stream_protocol_length: PosMarker3Byte::default(),
        }
    }
}

impl NetBiosTcpMessage {
    pub fn parse_content(&self) -> Result<NetBiosMessageContent, binrw::Error> {
        Ok(NetBiosMessageContent::try_from(self.content.as_slice())?)
    }

    pub fn from_content(
        content: &NetBiosMessageContent,
    ) -> Result<NetBiosTcpMessage, binrw::Error> {
        let mut content_writer = Cursor::new(vec![]);
        content.write(&mut content_writer)?;
        Ok(Self::from_content_bytes(content_writer.into_inner()))
    }

    pub fn from_content_bytes(content: Vec<u8>) -> NetBiosTcpMessage {
        NetBiosTcpMessage { content }
    }

    pub fn to_bytes(&self) -> Result<Vec<u8>, binrw::Error> {
        let mut msg_data = Cursor::new(Vec::new());
        self.write(&mut msg_data)?;
        Ok(msg_data.into_inner())
    }
}

#[derive(BinRead, BinWrite, Debug)]
#[brw(big)]
pub enum NetBiosMessageContent {
    SMB2Message(smb2::Message),
    SMB1Message(smb1::SMB1NegotiateMessage),
}

impl TryFrom<&[u8]> for NetBiosMessageContent {
    type Error = binrw::Error;
    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        Ok(NetBiosMessageContent::read(&mut Cursor::new(value))?)
    }
}