nineap/netrunner-proxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

buf sizes changes and socks5 remove to rawcast

Browse Source
This commit is contained in:
Kirill
2026-03-26 15:50:41 +07:00
parent c51c086fbc
commit b0dc3fc0a4
13 changed files with 641 additions and 945 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/src/net/connection/connection.rs
+140 -141
View File
@@ -1,18 +1,14 @@
use crate::{
net::{
connection::{
bridge::run_tcp_bridge, engine::TunnelEngine, handler::StreamHandler, muxer::Muxer,
},
connection::{engine::TunnelEngine, handler::StreamHandler, muxer::Muxer},
network::NetworkConfig,
},
nrxp::{
Codec, ErrorAction, FrameType, {SocksReply, SocksRequest},
},
parser::Parser,
nrxp::{Codec, ErrorAction, FrameType},
rawcast::{LocalProtocol, RawCastEvent, RawCastFrame},
tlseng::BrowserProfile,
};
use bytes::BytesMut;
use netrunner_logger::{info, warn};
use bytes::{Bytes, BytesMut};
use netrunner_logger::{error, info, warn};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::{
@@ -21,7 +17,6 @@ use tokio::{
},
sync::mpsc,
};
use tokio_util::sync::CancellationToken;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ConnectionRole {
@@ -60,53 +55,34 @@ impl Connection {
codec: Codec::new(false),
}
}
pub async fn read_socks_request(&mut self) -> Result<SocksRequest, String> {
loop {
match SocksRequest::parse(&mut self.read_buf) {
Ok(Some(req)) => return Ok(req),
Ok(None) => {}
Err(e) => return Err(format!("Socks parse error: {}", e)),
}
let n = self
.inbound
.read_buf(&mut self.read_buf)
.await
.map_err(|e| e.to_string())?;
if n == 0 {
return Err("Client closed connection".into());
}
}
}
pub async fn send_socks_reply(&mut self, reply: SocksReply) -> Result<(), String> {
let mut buf = BytesMut::with_capacity(24);
reply.write_to(&mut buf);
self.outbound
.write_all(&buf)
.await
.map_err(|e| e.to_string())
}
}
pub struct ClientHandler {
pub(crate) conn: Connection,
pub(crate) muxer: Muxer,
}
pub struct ClientHandler;
impl ClientHandler {
pub async fn connect(remote_proxy_addr: &str) -> Result<Muxer, String> {
/// Вспомогательная функция: устанавливает одно физическое TLS-соединение
/// и возвращает готовый Muxer для работы с ним.
async fn establish_leg(remote_proxy_addr: &str, leg_name: &str) -> Result<Muxer, String> {
info!(
"Establishing dedicated {} tunnel to {}...",
leg_name, remote_proxy_addr
);
let stream = TcpStream::connect(remote_proxy_addr)
.await
.map_err(|e| e.to_string())?;
let (inbound, outbound) = stream.into_split();
.map_err(|e| format!("Failed to connect: {}", e))?;
if let Err(e) = stream.set_nodelay(true) {
warn!("Failed to set TCP_NODELAY on {} leg: {}", leg_name, e);
}
let (inbound, outbound) = stream.into_split();
let mut conn = Connection::new_raw(inbound, outbound);
let ch = conn
.codec
.make_client_handshake(&BrowserProfile::CHROME_131, "ubuntu.com")
.map_err(|e| format!("{:?}", e))?;
.map_err(|e| format!("Handshake generation failed: {:?}", e))?;
conn.outbound
.write_all(&ch)
.await
@@ -122,18 +98,19 @@ impl ClientHandler {
.await
.map_err(|e| e.to_string())?;
if n == 0 {
return Err("EOF during handshake".into());
return Err(format!("EOF during handshake on {} leg", leg_name));
}
}
Err(e) => return Err(format!("TLS error: {:?}", e)),
Err(e) => return Err(format!("TLS error on {} leg: {:?}", leg_name, e)),
}
}
let (control_tx, control_rx) = mpsc::channel(NetworkConfig::global().channel_capacity);
let (data_tx, data_rx) = mpsc::channel(NetworkConfig::global().channel_capacity);
info!("{} TLS Handshake complete. Starting Engine.", leg_name);
let (control_tx, control_rx) = mpsc::channel(NetworkConfig::global().muxer_capacity);
let (data_tx, data_rx) = mpsc::channel(NetworkConfig::global().muxer_capacity);
let muxer = Muxer::new(control_tx, data_tx, true);
let handler =
std::sync::Arc::new(StreamHandler::new(muxer.clone(), ConnectionRole::Client));
@@ -152,102 +129,125 @@ impl ClientHandler {
Ok(muxer)
}
async fn handle_udp_associate(&mut self) -> Result<(), String> {
let reply = SocksReply::ConnectResult {
reply_code: 0x00,
atyp: 0x01,
addr: [0, 0, 0, 0],
port: 0,
};
self.conn.send_socks_reply(reply).await?;
/// Главная функция запуска клиента
pub async fn connect(
remote_proxy_addr: &str,
mut rx_from_engine: mpsc::Receiver<RawCastFrame>,
tx_to_engine: mpsc::Sender<RawCastFrame>,
) -> Result<(), String> {
// 1. Устанавливаем ДВА независимых соединения
// Мы можем сделать это параллельно через tokio::try_join! для скорости
let (tcp_muxer, udp_muxer) = tokio::try_join!(
Self::establish_leg(remote_proxy_addr, "TCP"),
Self::establish_leg(remote_proxy_addr, "UDP"),
)?;
let mut buf = [0u8; 1024];
loop {
if self
.conn
.inbound
.read(&mut buf)
.await
.map_err(|e| e.to_string())?
== 0
{
break;
info!("Dual-tunnel architecture established successfully!");
// 2. ЗАПУСКАЕМ МОСТ-РОУТЕР
tokio::spawn(async move {
while let Some(raw_frame) = rx_from_engine.recv().await {
let stream_id = raw_frame.socket_id as u32;
let is_udp = raw_frame.protocol == LocalProtocol::Udp;
// РОУТИНГ: Выбираем нужный физический канал
let muxer = if is_udp {
udp_muxer.clone()
} else {
tcp_muxer.clone()
};
match raw_frame.event {
RawCastEvent::Connect => {
let (v_tx, mut v_rx) =
mpsc::channel(NetworkConfig::global().tcp_buffer_size);
muxer.register_stream(stream_id, v_tx);
// Читаем домен, который мы прокинули в предыдущем шаге
let target = if !raw_frame.payload.is_empty() {
String::from_utf8_lossy(&raw_frame.payload).to_string()
} else {
format!("{}:{}", raw_frame.dst_ip, raw_frame.dst_port)
};
let frame_type = if is_udp {
FrameType::UdpConnect
} else {
FrameType::Connect
};
if let Err(e) = muxer
.send_control(stream_id, frame_type, Bytes::from(target))
.await
{
error!("Failed to send connect control frame: {}", e);
continue;
}
let tx_engine_clone = tx_to_engine.clone();
let mut muxer_clone = muxer.clone();
let dst_ip = raw_frame.dst_ip;
let dst_port = raw_frame.dst_port;
let protocol = raw_frame.protocol;
let socket_id = raw_frame.socket_id;
tokio::spawn(async move {
while let Some(payload) = v_rx.recv().await {
if payload.is_empty() {
let close_frame =
RawCastFrame::close(protocol, socket_id, dst_ip, dst_port);
let _ = tx_engine_clone.send(close_frame).await;
break;
} else {
let data_frame = RawCastFrame::data(
protocol,
socket_id,
dst_ip,
dst_port,
payload.to_vec(),
);
if tx_engine_clone.send(data_frame).await.is_err() {
break;
}
}
}
muxer_clone.remove_stream(stream_id);
});
}
RawCastEvent::Data => {
let frame_type = if is_udp {
FrameType::UdpData
} else {
FrameType::Data
};
if let Err(e) = muxer
.send_control(stream_id, frame_type, raw_frame.payload)
.await
{
error!("Failed to send data frame: {}", e);
}
}
RawCastEvent::Close => {
let _ = muxer
.send_control(stream_id, FrameType::Close, Bytes::new())
.await;
muxer.remove_stream(stream_id);
}
}
}
}
info!("ClientHandler bridge task terminated.");
});
Ok(())
}
}
#[async_trait::async_trait]
impl TunnelHandler for ClientHandler {
async fn run(mut self) -> Result<(), String> {
info!("Starting SOCKS multiplexed handling");
self.conn.read_socks_request().await?;
self.conn
.send_socks_reply(SocksReply::HandshakeSelect { method: 0x00 })
.await?;
let req = self.conn.read_socks_request().await?;
match req {
SocksRequest::Connect {
command: 0x01,
target,
} => {
let stream_id = self.muxer.next_id();
let (v_tx, mut v_rx) =
mpsc::channel::<bytes::Bytes>(NetworkConfig::global().tcp_buffer_size);
self.muxer.register_stream(stream_id, v_tx);
self.muxer
.send_control(
stream_id,
FrameType::Connect,
bytes::Bytes::from(target.to_string()),
)
.await?;
let first_payload =
tokio::time::timeout(std::time::Duration::from_secs(10), v_rx.recv())
.await
.map_err(|_| "Timeout waiting for proxy response")?
.ok_or("No data from proxy")?;
if first_payload.len() >= 2 && first_payload[1] == 0x00 {
self.conn
.outbound
.write_all(&first_payload)
.await
.map_err(|e| e.to_string())?;
} else {
self.conn.outbound.write_all(&first_payload).await.ok();
return Err("Proxy rejected connection".into());
}
let browser_in = self.conn.inbound;
let browser_out = self.conn.outbound;
let muxer = self.muxer;
tokio::spawn(async move {
run_tcp_bridge(stream_id, browser_in, browser_out, muxer, v_rx).await;
});
Ok(())
}
SocksRequest::Connect { command: 0x03, .. } => {
info!("Handling UDP Associate request");
self.handle_udp_associate().await
}
_ => Err("Unsupported SOCKS command".into()),
}
}
}
pub struct ServerHandler {
pub(crate) conn: Connection,
}
impl ServerHandler {
async fn handle_stealth_fallback(
mut client_inbound: OwnedReadHalf,
@@ -295,14 +295,13 @@ impl ServerHandler {
}
}
}
#[async_trait::async_trait]
impl TunnelHandler for ServerHandler {
async fn run(mut self) -> Result<(), String> {
info!("Acting as TLS Server with Stealth Fallback");
let (control_tx, control_rx) = mpsc::channel(NetworkConfig::global().channel_capacity);
let (data_tx, data_rx) = mpsc::channel(NetworkConfig::global().channel_capacity);
let (control_tx, control_rx) = mpsc::channel(NetworkConfig::global().muxer_capacity);
let (data_tx, data_rx) = mpsc::channel(NetworkConfig::global().muxer_capacity);
let muxer = Muxer::new(control_tx, data_tx, false);
let handshake_timeout = std::time::Duration::from_secs(1);
core/src/net/connection/handler.rs
+14 -49
View File
@@ -1,4 +1,4 @@
use bytes::{Bytes, BytesMut};
use bytes::Bytes;
use netrunner_logger::{debug, error, info};
use crate::{
@@ -10,9 +10,7 @@ use crate::{
},
network::NetworkConfig,
},
nrxp::{
SocksReply, {Frame, FrameType},
},
nrxp::{Frame, FrameType},
};
pub(crate) struct StreamHandler {
@@ -43,7 +41,7 @@ impl StreamHandler {
let target_str = String::from_utf8_lossy(&payload).to_string();
let muxer = self.muxer.clone();
let (v_tx, v_rx) = tokio::sync::mpsc::channel(NetworkConfig::global().channel_capacity);
let (v_tx, v_rx) = tokio::sync::mpsc::channel(NetworkConfig::global().stream_capacity);
muxer.register_stream(stream_id, v_tx);
tokio::spawn(async move {
@@ -61,29 +59,17 @@ impl StreamHandler {
let elapsed = start.elapsed();
info!(stream_id, target = %target_str, latency_ms = elapsed.as_millis(), "Remote TCP connection established");
let mut reply_buf = BytesMut::with_capacity(10);
let reply = SocksReply::ConnectResult {
reply_code: 0x00,
atyp: 0x01,
addr: [0, 0, 0, 0],
port: 0,
};
reply.write_to(&mut reply_buf);
let _ = muxer
.send_control(stream_id, FrameType::Connect, reply_buf.freeze())
.await;
// Больше никаких ответов (Reply), просто прокидываем байты!
let (r, w) = stream.into_split();
run_tcp_bridge(stream_id, r, w, muxer, v_rx).await;
}
Ok(Err(e)) => {
error!(stream_id, target = %target_str, error = %e, "TCP connection failed");
Self::send_error_reply(&muxer, stream_id, 0x01, FrameType::Connect).await;
Self::close_stream(&muxer, stream_id).await;
}
Err(_) => {
error!(stream_id, target = %target_str, "Connection timed out (DNS/TCP)");
Self::send_error_reply(&muxer, stream_id, 0x04, FrameType::Connect).await;
Self::close_stream(&muxer, stream_id).await;
}
}
});
@@ -97,7 +83,7 @@ impl StreamHandler {
let target_str = String::from_utf8_lossy(&payload).to_string();
let muxer = self.muxer.clone();
let (v_tx, v_rx) = tokio::sync::mpsc::channel(NetworkConfig::global().channel_capacity);
let (v_tx, v_rx) = tokio::sync::mpsc::channel(NetworkConfig::global().stream_capacity);
muxer.register_stream(stream_id, v_tx);
tokio::spawn(async move {
@@ -107,30 +93,16 @@ impl StreamHandler {
Ok(socket) => {
if let Err(e) = socket.connect(&target_str).await {
error!(stream_id, target = %target_str, error = %e, "UDP connect failed");
Self::send_error_reply(&muxer, stream_id, 0x01, FrameType::UdpConnect)
.await;
Self::close_stream(&muxer, stream_id).await;
return;
}
let mut reply_buf = BytesMut::with_capacity(10);
let reply = SocksReply::ConnectResult {
reply_code: 0x00,
atyp: 0x01,
addr: [0, 0, 0, 0],
port: 0,
};
reply.write_to(&mut reply_buf);
let _ = muxer
.send_control(stream_id, FrameType::UdpConnect, reply_buf.freeze())
.await;
// Успех - просто начинаем слушать UDP и слать в туннель
run_udp_bridge(stream_id, socket, muxer, v_rx).await;
}
Err(e) => {
error!(stream_id, target = %target_str, error = %e, "UDP bind failed");
Self::send_error_reply(&muxer, stream_id, 0x01, FrameType::UdpConnect)
.await;
Self::close_stream(&muxer, stream_id).await;
}
}
});
@@ -143,19 +115,12 @@ impl StreamHandler {
self.muxer.dispatch_to_local(stream_id, payload).await;
}
async fn send_error_reply(muxer: &Muxer, stream_id: u32, code: u8, frame_type: FrameType) {
muxer.remove_stream(stream_id);
let mut reply_buf = BytesMut::with_capacity(10);
let reply = SocksReply::ConnectResult {
reply_code: code,
atyp: 0x01,
addr: [0, 0, 0, 0],
port: 0,
};
reply.write_to(&mut reply_buf);
// Вспомогательная функция вместо send_error_reply
async fn close_stream(muxer: &Muxer, stream_id: u32) {
let _ = muxer
.send_control(stream_id, frame_type, reply_buf.freeze())
.send_control(stream_id, FrameType::Close, Bytes::new())
.await;
muxer.remove_stream(stream_id);
}
async fn on_data(&self, stream_id: u32, payload: Bytes) {
core/src/net/network.rs
+45 -60
View File
@@ -1,10 +1,10 @@
use std::sync::OnceLock;
use crate::{
net::connection::{ClientHandler, Connection, ConnectionRole, ServerHandler, TunnelHandler},
net::connection::{Connection, ConnectionRole, ServerHandler, TunnelHandler},
nrxp::{FRAME_HEADER_SIZE, MAX_PADDING_SIZE},
};
use netrunner_logger::{error, info};
use netrunner_logger::{error, info, warn};
use tokio::net::TcpListener;
use tokio_util::sync::CancellationToken;
@@ -32,50 +32,36 @@ impl Network {
pub async fn run(&self, token: CancellationToken) {
let addr = format!("{}:{}", self.host, self.port);
// Инициализируем глобальный конфиг сети (MTU, размеры буферов)
NetworkConfig::init_global(1350);
match self.role {
ConnectionRole::Client => {
info!("Starting Client mode");
let server_addr = self
.remote_proxy_addr
.as_ref()
.ok_or("No proxy addr")
.unwrap();
let muxer = match ClientHandler::connect(server_addr).await {
Ok(m) => m,
Err(e) => {
error!(error = %e, "Global tunnel failed.");
return;
}
};
let listener = TcpListener::bind(&addr).await.expect("SOCKS bind failed");
loop {
tokio::select! {
_ = token.cancelled() => break,
res = listener.accept() => {
if let Ok((stream, _client_addr)) = res {
let conn = Connection::new(stream, false);
let handler = ClientHandler{ conn, muxer: muxer.clone() };
tokio::spawn(async move {
if let Err(e) = handler.run().await {
error!(error = %e, "Client handler error");
}
});
}
}
}
}
// В новой архитектуре клиент запускается через EngineBuilder + TUN.
// Структура Network теперь используется только для запуска Сервера.
error!("Client mode cannot be run via Network::run anymore.");
error!("Please use EngineBuilder to initialize the TUN client.");
panic!("Legacy SOCKS5 client mode has been removed.");
}
ConnectionRole::Server => {
info!("Starting Server mode on {}", addr);
let listener = TcpListener::bind(&addr).await.expect("Server bind failed");
loop {
tokio::select! {
_ = token.cancelled() => break,
_ = token.cancelled() => {
info!("Shutdown signal received, stopping server.");
break;
}
res = listener.accept() => {
if let Ok((stream, client_addr)) = res {
info!("New connection from {}", client_addr);
// Создаем соединение (init = true для сервера)
let conn = Connection::new(stream, true);
let handler = ServerHandler { conn };
tokio::spawn(async move {
if let Err(e) = handler.run().await {
error!(client = %client_addr, error = %e, "Server handler error");
@@ -96,52 +82,51 @@ pub struct NetworkConfig {
pub mtu: usize,
pub max_wire_frame_size: usize,
pub safe_payload_size: usize,
pub tcp_buffer_size: usize,
// --- ИЗМЕНЕНИЯ ЗДЕСЬ ---
pub tcp_buffer_size: usize, // Размер буфера для системного tokio::TcpStream
pub udp_buffer_size: usize,
pub channel_capacity: usize,
pub muxer_capacity: usize, // Глобальные каналы (Muxer <-> Engine)
pub stream_capacity: usize, // Локальные каналы 1 сокета (Engine <-> Muxer)
pub smoltcp_socket_buf: usize,
pub tcp_max_pending: usize,
pub tcp_chunk_size: usize,
}
impl NetworkConfig {
pub fn new(system_mtu: usize) -> Self {
let transport_overhead = 28; // IPv4 + UDP
let transport_overhead = 28;
let max_wire_frame = system_mtu.saturating_sub(transport_overhead);
let safe_payload = max_wire_frame.saturating_sub(10).saturating_sub(255);
let safe_payload = max_wire_frame
.saturating_sub(FRAME_HEADER_SIZE as usize)
.saturating_sub((MAX_PADDING_SIZE - 1) as usize);
let tcp_chunks_count = 65536 / safe_payload;
let tcp_buffer = safe_payload * tcp_chunks_count;
let udp_chunks_count = 16384 / safe_payload;
let udp_buffer = safe_payload * udp_chunks_count;
let channel_cap = 1024;
netrunner_logger::info!(
mtu = system_mtu,
payload = safe_payload,
tcp_buf = tcp_buffer,
"Network Optimizer: Calculations complete for current MTU"
);
let muxer_capacity = 64;
let stream_capacity = 4;
Self {
mtu: system_mtu,
max_wire_frame_size: max_wire_frame,
safe_payload_size: safe_payload,
tcp_buffer_size: tcp_buffer,
udp_buffer_size: udp_buffer,
channel_capacity: channel_cap,
// Заменяем громоздкие вычисления на стандартные 64KB чанки для системных сокетов
tcp_buffer_size: 64 * 1024,
udp_buffer_size: 64 * 1024,
muxer_capacity,
stream_capacity,
smoltcp_socket_buf: 64 * 1024,
tcp_max_pending: 64 * 1024,
tcp_chunk_size: 16 * 1024,
}
}
pub fn init_global(system_mtu: usize) {
let config = Self::new(system_mtu);
if GLOBAL_NET_CONFIG.set(config).is_err() {
netrunner_logger::warn!("Global network config was already initialized!");
warn!("Global network config was already initialized!");
}
}
pub fn global() -> &'static Self {
GLOBAL_NET_CONFIG
.get()