pata 0.0.1

A fast, lightweight, and evidence-driven email validation library for Rust
Documentation
//! Scripted SOCKS5 protocol tests.
#![cfg(feature = "proxy")]

use std::{
    io,
    net::SocketAddr,
    pin::Pin,
    sync::{Arc, Mutex},
    task::{Context, Poll},
    time::{Duration, Instant},
};

use futures_executor::block_on;
use futures_io::{AsyncRead, AsyncWrite};
use pata::{
    proxy::Socks5Connector,
    runtime::{BoxIo, Connect, Connector, Sleep, Timer},
};

struct ScriptConnector {
    input: &'static [u8],
    writes: Arc<Mutex<Vec<u8>>>,
}

impl Connector for ScriptConnector {
    fn connect(&self, _address: SocketAddr, _deadline: Instant) -> Connect<'_> {
        let stream = ScriptIo {
            input: self.input,
            position: 0,
            writes: Arc::clone(&self.writes),
        };
        Box::pin(async move { Ok(Box::new(stream) as BoxIo) })
    }
}

struct ScriptIo {
    input: &'static [u8],
    position: usize,
    writes: Arc<Mutex<Vec<u8>>>,
}

impl AsyncRead for ScriptIo {
    fn poll_read(
        mut self: Pin<&mut Self>,
        _context: &mut Context<'_>,
        buffer: &mut [u8],
    ) -> Poll<io::Result<usize>> {
        let remaining = &self.input[self.position..];
        let length = remaining.len().min(buffer.len());
        buffer[..length].copy_from_slice(&remaining[..length]);
        self.position += length;
        Poll::Ready(Ok(length))
    }
}

impl AsyncWrite for ScriptIo {
    fn poll_write(
        self: Pin<&mut Self>,
        _context: &mut Context<'_>,
        buffer: &[u8],
    ) -> Poll<io::Result<usize>> {
        self.writes.lock().unwrap().extend_from_slice(buffer);
        Poll::Ready(Ok(buffer.len()))
    }

    fn poll_flush(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }

    fn poll_close(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }
}

struct NeverTimer;

impl Timer for NeverTimer {
    fn sleep(&self, _duration: Duration) -> Sleep {
        Box::pin(std::future::pending())
    }
}

#[test]
fn local_dns_socks5_handshake_targets_the_revalidated_ip() {
    let writes = Arc::new(Mutex::new(Vec::new()));
    let connector = Socks5Connector::new(
        "127.0.0.1:1080".parse().unwrap(),
        ScriptConnector {
            input: &[5, 0, 5, 0, 0, 1, 127, 0, 0, 1, 0, 0],
            writes: Arc::clone(&writes),
        },
        NeverTimer,
    );

    let _stream = block_on(connector.connect(
        "1.1.1.1:25".parse().unwrap(),
        Instant::now() + Duration::from_secs(1),
    ))
    .unwrap();

    assert_eq!(
        *writes.lock().unwrap(),
        [5, 1, 0, 5, 1, 0, 1, 1, 1, 1, 1, 0, 25]
    );
}

#[test]
fn credentials_require_username_password_authentication() {
    let writes = Arc::new(Mutex::new(Vec::new()));
    let connector = Socks5Connector::new(
        "127.0.0.1:1080".parse().unwrap(),
        ScriptConnector {
            input: &[5, 2, 1, 0, 5, 0, 0, 1, 127, 0, 0, 1, 0, 0],
            writes: Arc::clone(&writes),
        },
        NeverTimer,
    )
    .credentials("agent", "secret")
    .unwrap();

    block_on(connector.connect(
        "1.1.1.1:25".parse().unwrap(),
        Instant::now() + Duration::from_secs(1),
    ))
    .unwrap();

    assert_eq!(
        *writes.lock().unwrap(),
        [
            5, 1, 2, 1, 5, b'a', b'g', b'e', b'n', b't', 6, b's', b'e', b'c', b'r', b'e', b't', 5,
            1, 0, 1, 1, 1, 1, 1, 0, 25
        ]
    );
}

#[test]
fn empty_password_is_rejected() {
    let connector = Socks5Connector::new(
        "127.0.0.1:1080".parse().unwrap(),
        ScriptConnector {
            input: &[],
            writes: Arc::new(Mutex::new(Vec::new())),
        },
        NeverTimer,
    );

    assert!(connector.credentials("agent", "").is_err());
}

#[test]
fn empty_response_domain_is_rejected() {
    let connector = Socks5Connector::new(
        "127.0.0.1:1080".parse().unwrap(),
        ScriptConnector {
            input: &[5, 0, 5, 0, 0, 3, 0, 0, 25],
            writes: Arc::new(Mutex::new(Vec::new())),
        },
        NeverTimer,
    );

    let error = block_on(connector.connect(
        "1.1.1.1:25".parse().unwrap(),
        Instant::now() + Duration::from_secs(1),
    ))
    .err()
    .unwrap();

    assert_eq!(error.kind(), io::ErrorKind::InvalidData);
}