Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
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é.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Ciphey — ⚡ Déchiffrer automatiquement des cryptages sans connaître la clé ou le chiffrement, décoder des encodages et craquer des hachages ⚡ | Kitploit
Outils/GitHubGitHub/bee-san/ciphey
Outils de Chiffrement/DéchiffrementAnalyse de HachageCryptographieCTFTests d'IntrusionApprentissage et ÉducationTop en Cryptographie n°13Top en CTF n°6Top en Outils de Chiffrement/Déchiffrement n°14Top en Analyse de Hachage n°5
21.6k1.4k195il y a 13 joursVérifié par Kitploit
Partager
GitHubbee-san/ciphey

Ciphey

⚡ Déchiffrer automatiquement des cryptages sans connaître la clé ou le chiffrement, décoder des encodages et craquer des hachages ⚡

Voir le dépôt
<p align="center">
  <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4"><img src="https://assets.kitploit.com/production/public/readmes/673/7997e478fcffb1efb25627ba54c13073857f3927bc487f77bf4e905af8ee8e84/5c182b65ae7b92166bf4175c31e9540f3575bfef35204b2120acd9d42870f0be-display-v1.webp" alt="Ciphey dans un terminal : quatre couches de Base64 en entrée, Ciphey demande si « Ciphey peels back every layer of encoding » est le texte en clair, puis l'affiche avec le chemin Base64 → Base64 → Base64 → Base64. Cliquez pour regarder la visite d'une minute."></a>
</p>

<h1 align="center">Ciphey</h1>

<p align="center">
  <b>Collez un texte qui a été encodé ou chiffré. Ciphey détermine comment et vous remet le texte en clair.</b><br>
  Pas de clé, pas de nom de chiffrement, pas d'indices. Base64, hex, Caesar/ROT13, Vigenère, code Morse et 19 autres, sur plusieurs couches de profondeur.
</p>

<p align="center">
  <a href="https://crates.io/crates/ciphey"><img alt="crates.io" src="https://img.shields.io/crates/v/ciphey"></a>
  <a href="https://docs.rs/ciphey"><img alt="docs.rs" src="https://img.shields.io/docsrs/ciphey"></a>
  <a href="https://github.com/bee-san/ciphey/blob/master/LICENSE"><img alt="MIT license" src="https://img.shields.io/badge/license-MIT-blue"></a>
</p>

<p align="center">
  <a href="#install">Installer</a> ·
  <a href="#quick-start">Démarrage rapide</a> ·
  <a href="#features">Fonctionnalités</a> ·
  <a href="#use-it-as-a-library">Bibliothèque</a> ·
  <a href="#mcp-server-ai-assistants">MCP</a> ·
  <a href="#documentation">Docs</a> ·
  <a href="http://discord.skerritt.blog">Discord</a>
  <br><sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4">Regarder la visite d'une minute</a> (MP4, 61 s)</sub>
</p>

## Installer

```bash
cargo install ciphey
```

Des binaires précompilés pour Linux (x86_64), macOS (Intel et Apple silicon) et Windows (x86_64) sont disponibles sur la [page des releases](https://github.com/bee-san/Ciphey/releases/latest), chacun accompagné d'une somme de contrôle `.sha256`.

Pour compiler depuis les sources, vous avez besoin d'une toolchain Rust :

```bash
git clone https://github.com/bee-san/Ciphey
cd Ciphey
cargo build --release    # the binary is target/release/ciphey
```

Ou ignorez l'installation : rejoignez le [serveur Discord](http://discord.skerritt.blog), allez dans `#bots` et tapez `$ciphey <votre texte>` (`$help` liste les commandes).

## Démarrage rapide

```console
$ ciphey -t 'aGVsbG8gdGhlcmUgZ2VuZXJhbA=='
🕵️ I think the plaintext is Words.
Possible plaintext: 'hello there general' (y/N):
y

🥳 ciphey has decoded 64 times.

The plaintext is:
hello there general
the decoder used is Base64
```

La première fois que vous l'exécutez, une courte configuration vous demande un thème de couleurs, la façon dont vous souhaitez que les résultats soient affichés et si vous voulez utiliser une liste de mots, puis enregistre vos réponses dans `~/.ciphey/config.toml`.

```bash
ciphey -t 'NTA3NjYzNzU3MjZjMjA3NjY2MjA2OTcyNjU2YzIwNzM2ZTY2Njc='   # ROT13 → hex → Base64, nothing else needed
ciphey -f secret.txt                    # read the input from a file
ciphey -d -t '...'                      # no y/N prompt: take the first plaintext found (handy in scripts)
ciphey -c 15 -t '...'                   # keep searching for up to 15 seconds (the default is 5)
ciphey -r 'flag\{' -t '...'             # only accept plaintext that matches a regex (a crib)
ciphey --wordlist words.txt -t '...'    # also accept any exact match from a wordlist
```

`ciphey --help` liste toutes les options.

## Fonctionnalités

### ⚡ Rapide

<a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/fast.mp4"><img src="https://assets.kitploit.com/production/public/readmes/673/159bba837c593380b7087cd9b5854db1f11a641fc229e940d5aac07fcef4d8f2/44ee23ca554ede298904e43da81dc7795cb7856d7d8bd2c1de11b1e622c521b1-display-v1.webp" alt="Un terminal exécute time ciphey -d sur une chaîne Base64. Ciphey affiche 'Ciphey is very fast' et le chemin Base64 → Hexadecimal → caesar, et bash rapporte real 0m0.157s. Un graphique compare ensuite les 0,19 s de Ciphey (la médiane de 10 exécutions) à l'absence de réponse après 60 s pour Python Ciphey 5.14.0 sur la même entrée."></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/fast.mp4">Regarder le clip</a> (16 s)</sub>

Trois couches (ROT13, puis hex, puis Base64) sont retirées en 0,16 s, mesuré par la commande `time` de bash dans un enregistrement réel. Voici la même comparaison pour davantage d'entrées, face à Python Ciphey 5.14, la version que Ciphey remplace :

| Entrée | Ciphey | Python Ciphey 5.14 |
| --- | --- | --- |
| Base64 | 0,11 s | 0,92 s |
| Hex → Base64 | 0,14 s | 1,02 s |
| ROT13 → Hex → Base64 | 0,19 s | aucune réponse en 60 s |
| URL → Base64 → Hex | 0,24 s | 1,15 s |
| Base64 ×4 | 0,41 s | 0,78 s |
| Hex → Base32 → Base64 → Hex | 0,54 s | 0,72 s, mauvaise réponse |
| ROT13 → Hex → Base64 → Base32 | 1,15 s | aucune réponse en 60 s |

<sub>Médiane du temps réel de 10 exécutions par entrée (Python Ciphey : 3) sur une machine Linux partagée à 16 CPU, Ciphey à 47bd16d6 avec l'invite y/N désactivée et un <code>$HOME</code> neuf à chaque exécution pour que son cache ne puisse pas aider. Chaque exécution était plafonnée à 60 s. Le script et les chiffres bruts se trouvent dans <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> sur la branche <code>media/readme-videos</code>.</sub>

Là où les deux obtiennent la bonne réponse, Ciphey est de 1,9 à 8,6 fois plus rapide. D'où vient cette vitesse ?

- C'est du Rust.
- Une recherche A* essaie d'abord les chaînes de décodeurs les plus prometteuses.
- Chaque décodeur s'exécute en parallèle avec [Rayon](https://github.com/rayon-rs/rayon), sur jusqu'à 10 textes candidats à la fois.
- Les réponses sont mises en cache dans `~/.ciphey/database.sqlite`, si bien que la même entrée une seconde fois revient en quelques millisecondes.

### 🧅 Couche après couche, sans clé nécessaire

Ciphey n'a pas besoin qu'on lui dise ce qu'il examine. Il explore des chaînes de décodeurs (du Base64 dans de l'hex dans du ROT13, quatre couches de Base64, etc.) et s'arrête au premier candidat qui ressemble à du texte en clair. Par défaut, il vous montre ce candidat et demande confirmation avant de l'accepter (`-d` désactive cela). Le clip en haut de cette page montre un décodage à quatre couches.

Il y a aussi un minuteur : si Ciphey n'a rien trouvé après 5 secondes, il s'arrête et le signale (`-c` modifie la limite).

Il connaît 24 décodeurs et casseurs :

| Type | Décodeurs |
| --- | --- |
| Encodages Base | Base64 (standard et URL-safe), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| Autres encodages | Hexadécimal, binaire, URL (percent-encoding), code Morse, Braille, A1Z26, Citrix CTX1 |
| Chiffrements | César (y compris ROT13), ROT47, Atbash, Vigenère (il détermine la clé lui-même), rail fence, texte inversé |
| Curiosités | Brainfuck (il exécute le programme), Morse ou binaire écrit avec d'autres symboles |

D'autres arrivent : [#1030](https://github.com/bee-san/Ciphey/issues/1030) suit 109 décodeurs qui ne sont pas encore intégrés.

### 🕵️ Sait ce qu'il a trouvé

<a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/lemmeknow.mp4"><img src="https://assets.kitploit.com/production/public/readmes/673/84c20243d028a257087ba77f28e72c257dbf75119ee45f245ff2fc22dde12c3a/b020e730db61fb989370dcf80d464b8c2827a8382a10f9b94bc0cac445dd48f7-display-v1.webp" alt="Trois exécutions de Ciphey. Base64 décode en 'mount -o username=bee,password=hunter2', identifié comme une commande mount avec identifiants en clair. Base64 décode en un lien otpauth://, identifié comme un URI de mot de passe à usage unique basé sur le temps (TOTP). Hex décode en 192.168.0.1, identifié comme une adresse Internet Protocol (IP) version 4."></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/lemmeknow.mp4">Regarder le clip</a> (21 s)</sub>

Chaque texte en clair candidat passe également par [LemmeKnow](https://github.com/swanandx/lemmeknow), le portage en Rust de [pyWhat](https://github.com/bee-san/pyWhat), qui reconnaît plus de 120 formats. Ainsi, Ciphey ne se contente pas de décoder la chaîne, il vous indique ce qu'elle est : un mot de passe dans une commande `mount` ou `sshpass`, un secret TOTP, un jeton GitHub ou une clé Stripe, une adresse IP ou MAC, une adresse e-mail ou une URL, un portefeuille crypto, un ARN AWS, du JSON ou un flag CTF dans n'importe quel format (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`). Les motifs LemmeKnow qui vérifient uniquement quels caractères contient une chaîne et sa longueur (les numéros de carte et de téléphone, par exemple) sont ignorés : les déchets produits par les décodeurs les font correspondre en permanence.

```console
$ ciphey -t '3139322e3136382e302e31'
🕵️ I think the plaintext is Internet Protocol (IP) Address Version 4.
Possible plaintext: '192.168.0.1' (y/N):
```

### 🎯 Mode crib et regex

<a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/crib.mp4"><img src="https://assets.kitploit.com/production/public/readmes/673/09c2bd5e4f4bf82d39a594ac92dbaefdc1546878abc64d4995bbd6484e8ee9bf/0bbe6aaae2adda71b0043dcc7d134c497722dfe5cf94815f5055e589162b27b3-display-v1.webp" alt="Un terminal exécute ciphey -t sur une chaîne Base64 avec -r 'picoCTF\{'. Ciphey indique 'Regex matched: picoCTF\{', demande à propos de 'picoCTF{b4s3_64_1s_fun}', et l'affiche comme texte en clair, décodé avec Base64."></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/crib.mp4">Regarder le clip</a> (14,5 s)</sub>

Si vous connaissez une partie de la réponse (le format du flag, un mot qui doit s'y trouver, comment elle commence), donnez-la à Ciphey sous forme de regex avec `-r`. Les autres vérificateurs se désactivent et seul le texte correspondant est accepté. Cela permet de trouver du texte en clair que les autres vérificateurs ignoreraient, ou de s'arrêter sur celui que vous voulez lorsque plusieurs candidats ressemblent à du texte en clair : avec `-r 'picoCTF\{'`, seul un flag `picoCTF{…}` met fin à la recherche.

`--wordlist words.txt` fonctionne de la même manière pour les correspondances exactes : un candidat qui est une ligne du fichier est considéré comme du texte en clair.

### 🎨 Conçu pour votre terminal

La configuration au premier lancement vous permet de choisir un thème de couleurs (Capptucin, Darcula, GirlyPop, celui par défaut, ou vos propres valeurs RGB) et de choisir entre être interrogé sur chaque texte en clair ou obtenir une liste de candidats à la fin. Vous pouvez le voir [dans la visite guidée](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) à partir de 0:32. Tout est enregistré dans `~/.ciphey/config.toml`, que vous pouvez modifier plus tard.

### 📚 La bibliothèque d'abord

Le binaire `ciphey` est une fine enveloppe autour de la crate `ciphey`. Le [bot Discord](https://github.com/bee-san/discord-bot) l'utilise également, et votre code peut le faire aussi.

## L'utiliser comme bibliothèque

`perform_cracking` exécute toute la recherche, comme le fait le binaire `ciphey` :

```rust
use ciphey::config::Config;
use ciphey::{perform_cracking, CipheyError};

fn main() {
    let mut config = Config::default();
    config.timeout = 5; // seconds
    config.human_checker_on = false; // never prompt on stdin
    config.api_mode = true; // don't print progress to stdout
    // config.regex = Some(r"flag\{".to_string()); // only accept plaintext matching a crib

    match perform_cracking("aGVsbG8gdGhlcmUgZ2VuZXJhbA==", config) {
        Ok(Some(result)) => {
            let path: Vec<&str> = result.path.iter().map(|step| step.decoder).collect();
            println!("{} (via {})", result.text[0], path.join(" → "));
        }
        Ok(None) => println!("no plaintext found"),
        Err(CipheyError::Timeout { secs }) => println!("gave up after {secs}s"),
        Err(e) => eprintln!("error: {e}"),
    }
}
```

Cela affiche `hello there general (via Base64)`.

### Un seul décodeur

Si vous savez à quoi vous avez affaire, appelez ce décodeur. Chacun est une fonction dans `ciphey::decoders` : les encodages sont décodés, les chiffrements sont cassés, et ceux qui nécessitent une clé peuvent déchiffrer avec la vôtre.

```rust
use ciphey::decoders;

let decoded = decoders::base64("aGVsbG8gd29ybGQ=");
assert_eq!(decoded.candidates[0].text, "hello world");

// No key: Ciphey tries every shift and marks the one its checks accept
let cracked = decoders::caesar("Uryyb jbeyq");
let plaintext = cracked.plaintext().expect("a shift reads as English");
assert_eq!(plaintext.text, "Hello world");
assert_eq!(plaintext.key.as_deref(), Some("13"));

// With the key
let decrypted = decoders::vigenere_with_key("Rijvs uyvjn", "KEY")?;
assert_eq!(decrypted.candidates[0].text, "Hello world");
```

Pour choisir le décodeur au moment de l'exécution, `decode_with` prend son nom ou un alias, et `list_decoders` les liste tous avec leurs alias, tags et la clé qu'ils prennent :

```rust
use ciphey::{decode_with, list_decoders, DecodeOptions};

let cracked = decode_with("rot13", "Uryyb jbeyq", &DecodeOptions::default())?;
let decrypted = decode_with("affine", "IHHWVC SWFRCP", &DecodeOptions::with_key("a=5, b=8"))?;

for decoder in list_decoders() {
    println!("{}: {}", decoder.name, decoder.key_format.unwrap_or("no key"));
}
```

Rien n'est filtré : vous obtenez ce que le décodeur transmet à la recherche. Le texte en clair candidat accepté par les vérifications de Ciphey arrive en premier et porte une `detection` ; si aucune n'est acceptée, vous obtenez les décodages non marqués, à vous de juger (les 25 décalages de César, par exemple, bien que les crackers à nombreuses clés ne transmettent que leurs meilleurs).

### Est-ce du texte en clair ?

`detect_plaintext` exécute les vérifications utilisées par la recherche (un crib regex, une liste de mots, LemmeKnow, JSON, mots de passe courants, anglais et code) et indique laquelle a accepté le texte et pour quoi elle l'a pris :

```rust
use ciphey::detection::{detect_plaintext, CheckerKind, DetectOptions, Sensitivity};

let found = detect_plaintext("192.168.0.1", &DetectOptions::default()).unwrap();
assert_eq!(found.checker, CheckerKind::LemmeKnow);
assert_eq!(found.description, "Internet Protocol (IP) Address Version 4");
assert_eq!(found.confidence, Some(0.7)); // the format's rarity in pyWhat

// Pick the checkers and how strict the English checker is, or give a crib
let english_only = DetectOptions::new()
    .checkers([CheckerKind::English])
    .sensitivity(Sensitivity::Low);
let crib = DetectOptions::new().regex(r"^flag\{")?;
```

`cargo run --example decode` parcourt tout cela, et `cargo run --example decode -- list` liste les décodeurs.

- `perform_cracking` renvoie `Result<Option<DecoderResult>, CipheyError>` sur `master` ([#915](https://github.com/bee-san/Ciphey/pull/915)), et les fonctions de décodeur unique et de détection ne sont pour l'instant que sur `master`. La dernière version publiée sur crates.io (0.12.0) renvoie encore `Option<DecoderResult>`, donc jusqu'à la prochaine version, utilisez la version git : `ciphey = { git = "https://github.com/bee-san/Ciphey" }`.
- La configuration est globale au processus. Le `Config` du premier appel est utilisé pour tous les appels suivants, et les décodeurs uniques le suivent aussi (un crib `regex`, une wordlist). Ils ne demandent jamais d'interaction.
- L'API est documentée sur [docs.rs](https://docs.rs/ciphey).

## Serveur MCP (assistants IA)

<a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4"><img src="https://assets.kitploit.com/production/public/readmes/673/67404d20c9782de7baa1586f0240cde7a50e100c9b6761f080c2104f94242d1d/dd2d9b2e27182c74582e74bca4cebf9ca58a72d35ff166f76ce1dc167f9b0b29-display-v1.webp" alt="On demande à un assistant IA (Kiro CLI) de décoder une chaîne Base64 issue d'un challenge CTF. Il appelle l'outil decode de ciphey via MCP, qui renvoie le flag en clair flag{ciphey_speaks_mcp} et les décodeurs utilisés, Base64 → Hexadécimal → caesar avec la clé 13. L'assistant répond ensuite avec le flag. Cliquez pour regarder la vidéo de 30 secondes."></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4">Regarder la vidéo</a> (29,5 s). Le chat rejoue une véritable session Kiro CLI avec ciphey-mcp.</sub>

`ciphey-mcp` est un serveur [Model Context Protocol](https://modelcontextprotocol.io), permettant à des assistants IA comme Claude Desktop et Kiro de décoder du texte avec Ciphey. Il est activé par la fonctionnalité `mcp`, donc la compilation normale de `ciphey` ne l'inclut pas :

```sh
cargo install ciphey --features mcp --bin ciphey-mcp
# or, from a clone of this repository:
cargo install --path . --features mcp --bin ciphey-mcp
```

La fonctionnalité `mcp` n'est pas encore disponible dans une version publiée sur crates.io (0.12.0 est la dernière), donc jusqu'à la prochaine, installez-la depuis git : `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`.

Elle fournit quatre outils :

- `decode` décode `text` lorsque vous ne savez pas comment il a été encodé, et renvoie le `plaintext` ainsi que le `path` des décodeurs utilisés, avec des clés telles que le décalage de César. Arguments optionnels : `timeout_secs` (de 1 à 30, par défaut 10) et `regex`, un indice que le texte en clair doit respecter, comme `flag\{`.
- `decode_with` exécute un décodeur que vous choisissez sur `text` : indiquez-lui l'id, le nom ou un alias du `decoder` (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...). Sans `key`, il décode le texte, ou casse le chiffrement en essayant toutes les clés ; avec une clé, il déchiffre, pour les chiffrements qui acceptent une clé (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`). Il renvoie chaque décodage candidat et indique si chacun passe la vérification de texte en clair de Ciphey. `regex` fonctionne comme pour `decode`.
- `detect_plaintext` vérifie si `text` est déjà du texte en clair, sans le décoder, et indique quel vérificateur l'a accepté, pour quoi il l'a pris et, pour les formats de LemmeKnow, à quel point il en est sûr. Arguments optionnels : `checkers` (parmi `lemmeknow`, `json`, `password`, `english` et `code`, par défaut les cinq), `sensitivity` du vérificateur anglais (`low`, `medium` ou `high`) et un indice `regex`.
- `list_decoders` liste les encodages et chiffrements pris en charge par Ciphey, avec les ids et alias acceptés par `decode_with` et le format de clé de chaque chiffrement qui en accepte une.

Un résultat de `decode` ressemble à ceci. `status` vaut `decoded`, `not_found` ou `timed_out`.

```json
{
  "status": "decoded",
  "plaintext": "hello there general",
  "path": [{ "decoder": "Base64", "key": null }],
  "checker": "English Checker",
  "timeout_secs": 10
}
```

`decode_with` avec `{"decoder": "rot13", "text": "Uryyb jbeyq"}` donne le résultat ci-dessous. `status` vaut `plaintext_found`, `no_plaintext` (aucun des candidats n'a passé la vérification, donc jugez-les vous-même) ou `no_candidates` (le texte n'est pas au format de ce décodeur). Un résultat contient au plus 100 candidats et 65 536 caractères de leur texte ; `total_candidates` indique combien il y en avait, et un candidat tronqué a `truncated` défini.

```json
{
  "decoder": "caesar",
  "status": "plaintext_found",
  "candidates": [
    {
      "text": "Hello world",
      "truncated": false,
      "key": "13",
      "is_plaintext": true,
      "detection": { "checker": "english", "description": "Words", "confidence": null }
    }
  ],
  "total_candidates": 1
}
```

`detect_plaintext` avec `{"text": "192.168.0.1"}` donne :

```json
{
  "is_plaintext": true,
  "detection": {
    "checker": "lemmeknow",
    "description": "Internet Protocol (IP) Address Version 4",
    "confidence": 0.7
  },
  "checkers": ["lemmeknow", "json", "password", "english", "code"]
}
```

Chaque appel, sauf `list_decoders`, s'exécute dans son propre processus de courte durée. L'entrée est limitée à 65 536 caractères (clés comprises) et les regex à 1 000. Un appel `decode` recherche pendant au plus 30 secondes et peut utiliser 1 Gio de mémoire ; un appel `decode_with` peut s'exécuter pendant 30 secondes et un appel `detect_plaintext` pendant 10, avec 256 Mio chacun. Au plus deux décodages et quatre autres appels s'exécutent simultanément. Le serveur ne lit ni n'écrit `~/.ciphey`, il n'y a donc ni fichier de configuration ni cache.

### Claude Desktop

Ouvrez Settings → Developer → Edit Config, ajoutez le serveur à `claude_desktop_config.json`, puis redémarrez Claude Desktop. Utilisez le chemin complet affiché par `which ciphey-mcp` (`where ciphey-mcp` sous Windows, par exemple `C:\\Users\\you\\.cargo\\bin\\ciphey-mcp.exe`), car Claude Desktop peut ne pas voir le `PATH` de votre shell.

```json
{
  "mcpServers": {
    "ciphey": {
      "command": "/Users/you/.cargo/bin/ciphey-mcp"
    }
  }
}
```

### Kiro

```sh
kiro-cli mcp add --name ciphey --command ciphey-mcp
```

Ou ajoutez l'entrée ci-dessous à `~/.kiro/settings/mcp.json` (tous les projets) ou `.kiro/settings/mcp.json` (un seul projet).

### Autres clients

La plupart des clients MCP acceptent la même entrée `mcpServers` : un serveur stdio lancé par `ciphey-mcp` sans arguments.

```json
{
  "mcpServers": {
    "ciphey": {
      "command": "ciphey-mcp",
      "args": []
    }
  }
}
```

## Bon à savoir

- La détection de texte en clair n'est pas parfaite. Les textes qui ne sont pas en anglais sont souvent manqués, et une clé presque correcte (Vigenère en particulier) peut tout de même produire un texte qui passe pour de l'anglais. [#1031](https://github.com/bee-san/Ciphey/issues/1031) contient l'évaluation. Si vous avez une idée de la réponse, un crib (`-r`) ou une wordlist aide beaucoup.
- Un flag dont le préfixe n'est pas un mot de flag (`SEKAI{…}` plutôt que `…CTF{…}` ou `flag{…}`) ressemble à ses propres décalages César, donc sous César, ROT13 ou Atbash, Ciphey ne peut pas dire lequel est le bon. Indiquez-lui le format comme crib : `-r 'SEKAI\{'`.
- Si une réponse mise en cache est erronée, supprimez `~/.ciphey/database.sqlite` pour vider le cache.
- Si vous êtes bloqué, posez la question dans `#coded-messages` sur [Discord](http://discord.skerritt.blog).

## Documentation

- [Documentation de l'API sur docs.rs](https://docs.rs/ciphey)
- [Le dossier `docs/`](https://github.com/bee-san/ciphey/blob/master/docs), comprenant une [vue d'ensemble](https://github.com/bee-san/ciphey/blob/master/docs/ares_overview.md), l'[architecture](https://github.com/bee-san/ciphey/blob/master/docs/ares_architecture.md), [comment fonctionne la recherche A*](https://github.com/bee-san/ciphey/blob/master/docs/astar.md) et [comment le texte en clair est détecté](https://github.com/bee-san/ciphey/blob/master/docs/plaintext-detection.md)
- [Documentation de Ciphey 2](https://broadleaf-angora-7db.notion.site/Ciphey2-32d5eea5d38b40c5b95a9442b4425710) sur Notion
- [Introducing Ares](https://skerritt.blog/introducing-ares/), l'article de blog sur la réécriture en Rust (il s'appelait Ares avant de devenir Ciphey)

## Contribuer

Les rapports de bugs, les idées et les pull requests sont les bienvenus dans les [issues](https://github.com/bee-san/Ciphey/issues). Un nouveau décodeur est une bonne première contribution : choisissez-en un dans [#1030](https://github.com/bee-san/Ciphey/issues/1030), et copiez la forme d'un décodeur existant dans [`src/decoders/`](https://github.com/bee-san/ciphey/blob/master/src/decoders). Vous pouvez aussi [sponsoriser le projet](https://github.com/sponsors/bee-san).

<a href="https://github.com/bee-san/Ciphey/graphs/contributors"><img src="https://contrib.rocks/image?repo=bee-san/Ciphey" alt="Avatars of the people who have contributed to Ciphey"></a>

## Crédits

- [LemmeKnow](https://github.com/swanandx/lemmeknow) par [@swanandx](https://github.com/swanandx) identifie ce que Ciphey trouve, et [gibberish-or-not](https://github.com/bee-san/gibberish-or-not) décide s'il s'agit d'anglais.
- [Rayon](https://github.com/rayon-rs/rayon) exécute les décodeurs en parallèle.
- Ciphey a commencé comme un projet Python ; Python Ciphey 5.x est toujours sur [PyPI](https://pypi.org/project/ciphey/). Merci à toutes les personnes qui y ont travaillé.
- Les vidéos sont réalisées avec [HyperFrames](https://hyperframes.heygen.com/) à partir de véritables enregistrements de terminal. La source, les enregistrements et le script de build se trouvent dans [`media/tui-video`](https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video) sur la branche `media/readme-videos`.

## Utilisation de l'IA

Nous utilisons l'IA pour 2 choses :

1. La TUI est entièrement vibe codée.
2. J'ai fait passer des heures à l'IA à rechercher chacun des challenges CTF existants. Elle a créé une liste de 15 071 CTFs. Elle a ensuite parcouru chaque CTF et cherché des writeups. Dans ces writeups, elle a cherché tout ce qui concernait l'encodage / le décodage. Elle en a ensuite créé des tests. Cela nous a permis d'augmenter notre couverture de tests et de nous assurer que tous les challenges CTF d'encodage / décodage sont résolubles avec cet outil.

## Licence

MIT. Voir [LICENSE](https://github.com/bee-san/ciphey/blob/master/LICENSE).
Télécharger l’outil

Populaires

Voir tout →

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

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    282

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →