async-proxy: fast proxy clients implementation

Async proxy is a fast and flexible, as well as asyncronous implementation of proxy clients in the Rust programming language

Getting started

Add the line below in your Cargo.toml file async-proxy = "0.1.1"

Protocols

Since it is the first stable version of the library (it has been created yesterday, lol), currently the only supported protocol is the Socks4 proxification protocol. We are working on these protocols, and, we hope, they will be released in the coming days * SOCKS4 (Stable) * SOCKS5 (Working on, WIP) * HTTP(s) (Working on, WIP)

Example

An example of using an async-proxy Socks4 protocol implementation without ident in connection needed

```rust use asyncproxy::clients::socks4::noident::{ Socks4NoIdent, ConnParams }; use asyncproxy::general::ConnectionTimeouts; use asyncproxy::proxy::ProxyStream; use tokio::net::TcpStream; use std::net::{ SocketAddr, SocketAddrV4, IpAddr, Ipv4Addr }; use std::time::Duration;

[tokio::main]

async fn main() { // The address of the proxy server that // will be used to connect through. // (We used a random proxy from https://hidemy.name/en/proxy-list/) const PROXY_IPADDR: Ipv4Addr = Ipv4Addr::new(104, 248, 63, 15);

// The port of the proxy server
const PROXY_PORT: u16 = 30_588;

// The full `SocketAddr` proxy server address representation
let proxy_addr: SocketAddr = SocketAddr::new(IpAddr::V4(PROXY_IPADDR), PROXY_PORT);

// Setting up timeouts
let timeouts = ConnectionTimeouts::new(
    // Connecting timeout
    Duration::from_secs(8),
    // Write timeout
    Duration::from_secs(8),
    // Read timeout
    Duration::from_secs(8)
);

// The address of the destination service
// that we will be connecting to through proxy.
// (We used a tcp echo server from `http://tcpbin.org/`)
const DEST_IPADDR: Ipv4Addr = Ipv4Addr::new(52, 20, 16, 20);

// The port of the destination service
let DEST_PORT: u16 = 30_000;

// The full `SocketAddrV4` destination service address representation
let dest_addr: SocketAddrV4 = SocketAddrV4::new(DEST_IPADDR, DEST_PORT);

// Creating required connection parameters
// for Socks4 proxy client
let connection_params = ConnParams::new(dest_addr, timeouts);

// `Socks4NoIdent` performs operations on
// an existant stream, so we need to connect
// to the proxy server by ourselves
let stream = TcpStream::connect(proxy_addr)
                       .await
                       .expect("Unable to connect to the proxy server");

// Connecting to the service through proxy.
// If connection succeed, `Socks4NoIdent::connect` returns
// both a readable and writeable stream that you will
// be working on as on a normal tcp connection stream
let stream = match Socks4NoIdent::connect(stream, connection_params).await {
    Ok(stream) => stream /* Successfully connected to the service*/,
    Err(error) => {
        /* Connection error */
        // -- snip -- //
    }
};

// -- using stream --

}

```

More examples can be found here