socks5rs 0.3.1

Minimal, Low-Level and simple socks5 protocol implementation
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use {
    std::net::IpAddr,
    crate::error::{Error, Socks5ErrorKind}
};

/// Byte representation of version field in socks5 request and responses
pub const SOCKS5: u8 = 0x05;

/// Reserved byte
pub const RESERVED: u8 = 0x00;


#[derive(Debug)]
/// Destination address in a socks5 request
pub enum DestAddr {
    /// IP address
    IP(IpAddr),
    /// Fully Qualified Domain Name (requires DNS resolution)
    FQDN(Vec<u8>),
}

#[derive(Debug)]
/// Socks5 request
pub struct Request {
    /// Destination address
    pub dest_addr: DestAddr,
    /// Destination port
    pub dest_port: u16,
}

impl Request {
    pub fn new(dest_addr: DestAddr, dest_port: u16) -> Self {
        Self{ dest_addr, dest_port }
    }
}


/// Socks5 address type byte representation
pub mod addrtype {
    use super::*;

    pub const V4: u8 = 0x01;
    pub const FQDN: u8 = 0x03;
    pub const V6: u8 = 0x04;

    #[repr(u8)]
    #[derive(Debug)]
    pub enum AddrType {
        /// IPv4
        V4 = V4,
        /// Fully Qualified Domain Name
        FQDN = FQDN,
        /// IPv6
        V6 = V6,
    }

    impl TryFrom<u8> for AddrType {
        type Error = Error;

        fn try_from(value: u8) -> Result<Self, Self::Error> {
            match value {
                V4 => Ok(AddrType::V4),
                FQDN => Ok(AddrType::FQDN),
                V6 => Ok(AddrType::V6),
                _ => Err(Error::from(Socks5ErrorKind::AddressTypeNotSupported)),
            }
        }
    }
}

/// Socks5 commands byte representation
pub mod command {
    use super::*;

    pub const CONNECT: u8 = 0x01;
    pub const BIND: u8 = 0x02;
    pub const ASSOCIATE: u8 = 0x03;

    #[repr(u8)]
    #[derive(Debug)]
    /// Socks5 client command kind
    pub enum CommandKind {
        Connect = CONNECT,
        Bind = BIND,
        Associate = ASSOCIATE,
    }

    impl TryFrom<u8> for CommandKind {
        type Error = Error;

        fn try_from(value: u8) -> Result<Self, Self::Error> {
            match value {
                CONNECT => Ok(CommandKind::Connect),
                BIND => Ok(CommandKind::Bind),
                ASSOCIATE => Ok(CommandKind::Associate),
                _ => Err(Error::from(Socks5ErrorKind::CommandNotSupported)),
            }
        }
    }

    #[derive(Debug)]
    pub enum Command {
        Connect(Request),
        Bind(Request),
        Associate(Request),
    }
}

/// Socks5 authentication methods byte representation
pub mod method {
    pub const NO_AUTH: u8 = 0x00;
    pub const GSSAPI: u8 = 0x01;
    pub const USER_PASS: u8 = 0x02;
    pub const NO_ACCEPTABLE_METHODS: u8 = 0xff;

    #[repr(u8)]
    #[derive(Debug)]
    pub enum Method {
        NoAuth = NO_AUTH,
        GSSAPI = GSSAPI,
        UserPass = USER_PASS,
        NoAcceptableMethods = NO_ACCEPTABLE_METHODS,
    }
}

pub const fn check_buffer_length(buffer: &[u8], min_length: usize) -> crate::error::Result<()> {
    if buffer.len() < min_length {
        return Err(crate::error::Error::SHORT_BUFFER_ERROR);
    }
    Ok(())
}