zeloxy 0.5.1

A library for creating lightweight, async, and lag-free proxy connections.
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

use bytes::{BufMut, BytesMut};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

use crate::proxy::ProxyAuth;
use crate::{ErrorKind, ProxyError, ProxyResult};

const PROXY_VERSION: u8 = 0x04;
const CONNECT_COMMAND: u8 = 0x01;

/// Статус ответа SOCKS4 прокси
#[derive(Debug, PartialEq, Eq)]
enum ResponseStatus {
  Success,
  RequestRejected,
  IdentdError,
  AuthError,
  UnknownResponse,
}

impl ResponseStatus {
  pub fn from(id: u8) -> Self {
    match id {
      0x5a => Self::Success,
      0x5b => Self::RequestRejected,
      0x5c => Self::IdentdError,
      0x5d => Self::AuthError,
      _ => Self::UnknownResponse,
    }
  }
}

/// Функция создания подключения с SOCKS4 прокси
pub async fn connect_socks4(stream: &mut TcpStream, target_host: String, target_port: u16, auth: &Option<ProxyAuth>) -> ProxyResult<()> {
  let mut req = BytesMut::with_capacity(512);
  req.put_u8(PROXY_VERSION);
  req.put_u8(CONNECT_COMMAND);
  req.put_u16(target_port);

  let ipv4_addr = target_host.parse::<std::net::Ipv4Addr>();

  if let Ok(ipv4) = ipv4_addr {
    req.put_slice(&ipv4.octets());
  } else {
    req.put_slice(&[0x00, 0x00, 0x00, 0x01]);
  }

  if let Some(a) = auth {
    let user_id = match a {
      ProxyAuth::Ident { user_id } => user_id,
      _ => {
        return Err(ProxyError::new(
          ErrorKind::AuthFailed,
          "specified incorrect authorization method for SOCKS4",
        ));
      }
    };

    req.put_slice(user_id.as_bytes());
  } else {
    req.put_u8(0x00);
  }

  if ipv4_addr.is_err() {
    if target_host.len() > 255 {
      return Err(ProxyError::new(ErrorKind::InvalidData, "target host is too long"));
    }

    req.put_slice(target_host.as_bytes());
    req.put_u8(0x00);
  }

  stream.write_all(&req).await?;

  let mut resp = [0u8; 8];
  stream.read_exact(&mut resp).await?;

  // В SOCKS4 здесь обычно всегда 0x00
  if resp[0] != 0x00 {
    return Err(ProxyError::new(ErrorKind::InvalidData, "invalid proxy response"));
  }

  let response_status = ResponseStatus::from(resp[1]);

  if response_status != ResponseStatus::Success {
    return Err(ProxyError::new(
      ErrorKind::NotConnected,
      format!("unsuccessful proxy response status: {:?}", response_status),
    ));
  }

  Ok(())
}