⚡ Decifra automaticamente crittografie senza conoscere la chiave o il cifrario, decodifica codifiche e decifra hash ⚡
<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 in un terminale: entrano quattro livelli di Base64, Ciphey chiede se 'Ciphey peels back every layer of encoding' è il testo in chiaro, poi lo stampa con il percorso Base64 → Base64 → Base64 → Base64. Clicca per guardare il tour di un minuto."></a>
</p>
<h1 align="center">Ciphey</h1>
<p align="center">
<b>Incolla del testo che è stato codificato o cifrato. Ciphey capisce come e ti restituisce il testo in chiaro.</b><br>
Nessuna chiave, nessun nome di cifrario, nessun indizio. Base64, hex, Caesar/ROT13, Vigenère, codice Morse e altri 19, anche su più livelli.
</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">Installa</a> ·
<a href="#quick-start">Avvio rapido</a> ·
<a href="#features">Funzionalità</a> ·
<a href="#use-it-as-a-library">Libreria</a> ·
<a href="#mcp-server-ai-assistants">MCP</a> ·
<a href="#documentation">Documentazione</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">Guarda il tour di un minuto</a> (MP4, 61 s)</sub>
</p>
## Installa
```bash
cargo install ciphey
```
I binari precompilati per Linux (x86_64), macOS (Intel e Apple silicon) e Windows (x86_64) sono disponibili nella [pagina delle release](https://github.com/bee-san/Ciphey/releases/latest), ciascuno con un checksum `.sha256`.
Per compilare dal codice sorgente, è necessario un toolchain Rust:
```bash
git clone https://github.com/bee-san/Ciphey
cd Ciphey
cargo build --release # the binary is target/release/ciphey
```
Oppure salta l'installazione: unisciti al [server Discord](http://discord.skerritt.blog), vai su `#bots` e digita `$ciphey <il tuo testo>` (`$help` elenca i comandi).
## Avvio rapido
```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 prima volta che lo esegui, una breve procedura di configurazione chiede un tema colori, come vuoi che vengano mostrati i risultati e se usare una wordlist, e salva le tue risposte in `~/.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` elenca tutte le opzioni.
## Funzionalità
### ⚡ Veloce
<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 terminale esegue time ciphey -d su una stringa Base64. Ciphey stampa 'Ciphey is very fast' e il percorso Base64 → Hexadecimal → caesar, e bash riporta real 0m0.157s. Un grafico confronta poi i 0,19 s di Ciphey (la mediana di 10 esecuzioni) con nessuna risposta dopo 60 s per Python Ciphey 5.14.0 sullo stesso input."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/fast.mp4">Guarda il video</a> (16 s)</sub>
Tre livelli (prima ROT13, poi hex, poi Base64) vengono rimossi in 0,16 s, misurati dal `time` di bash in una registrazione reale. Ecco lo stesso confronto per più input, contro Python Ciphey 5.14, la versione che Ciphey sostituisce:
| Input | 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 | nessuna risposta entro 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, risposta errata |
| ROT13 → Hex → Base64 → Base32 | 1,15 s | nessuna risposta entro 60 s |
<sub>Mediana del tempo reale di 10 esecuzioni per input (Python Ciphey: 3) su una macchina Linux condivisa a 16 CPU, Ciphey a 47bd16d6 con il prompt y/N disattivato e una <code>$HOME</code> nuova per ogni esecuzione, così che la sua cache non possa aiutare. Ogni esecuzione è stata limitata a 60 s. Lo script e i numeri grezzi sono in <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> sul branch <code>media/readme-videos</code>.</sub>
Dove entrambi ottengono la risposta corretta, Ciphey è da 1,9 a 8,6 volte più veloce. Da dove viene la velocità?
- È scritto in Rust.
- Una ricerca A* prova prima le catene di decoder più promettenti.
- Ogni decoder viene eseguito in parallelo con [Rayon](https://github.com/rayon-rs/rayon), su un massimo di 10 testi candidati alla volta.
- Le risposte vengono memorizzate nella cache in `~/.ciphey/database.sqlite`, così lo stesso input una seconda volta ritorna in millisecondi.
### 🧅 Livello dopo livello, senza bisogno di chiavi
Ciphey non ha bisogno che gli si dica cosa sta guardando. Cerca catene di decoder (Base64 dentro hex dentro ROT13, quattro livelli di Base64 e così via) e si ferma al primo candidato che sembra testo in chiaro. Per impostazione predefinita ti mostra quel candidato e chiede prima di accettarlo (`-d` disattiva questa opzione). Il video all'inizio di questa pagina mostra una decodifica a quattro livelli.
C'è anche un timer: se Ciphey non ha trovato nulla dopo 5 secondi, si ferma e lo segnala (`-c` modifica il limite).
Conosce 24 decoder e cracker:
| Tipo | Decoder |
| --- | --- |
| Codifiche Base | Base64 (standard e URL-safe), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| Altre codifiche | Esadecimale, binaria, URL (percent-encoding), codice Morse, Braille, A1Z26, Citrix CTX1 |
| Cifrari | Cesare (incluso ROT13), ROT47, Atbash, Vigenère (ricava la chiave da solo), rail fence, testo invertito |
| Stranezze | Brainfuck (esegue il programma), Morse o binario scritto con altri simboli |
Altri sono in arrivo: [#1030](https://github.com/bee-san/Ciphey/issues/1030) tiene traccia di 109 decoder non ancora inclusi.
### 🕵️ Sa cosa ha trovato
<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="Tre esecuzioni di Ciphey. Base64 decodifica in 'mount -o username=bee,password=hunter2', identificato come Mount Command With Clear Credentials. Base64 decodifica in un link otpauth://, identificato come Time-Based One-Time Password (TOTP) URI. Hex decodifica in 192.168.0.1, identificato come Internet Protocol (IP) Address Version 4."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/lemmeknow.mp4">Guarda la clip</a> (21 s)</sub>
Ogni candidato plaintext passa anche attraverso [LemmeKnow](https://github.com/swanandx/lemmeknow), il port in Rust di [pyWhat](https://github.com/bee-san/pyWhat), che riconosce più di 120 formati. Quindi Ciphey non si limita a decodificare la stringa, ma ti dice cos'è: una password in un comando `mount` o `sshpass`, un segreto TOTP, un token GitHub o una chiave Stripe, un indirizzo IP o MAC, un indirizzo email o URL, un wallet crypto, un ARN AWS, JSON o un flag CTF in qualsiasi formato (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`). I pattern di LemmeKnow che verificano solo quali caratteri contiene una stringa e la sua lunghezza (numeri di carta e di telefono, ad esempio) vengono ignorati: il rumore dei decoder li soddisfa continuamente.
```console
$ ciphey -t '3139322e3136382e302e31'
🕵️ I think the plaintext is Internet Protocol (IP) Address Version 4.
Possible plaintext: '192.168.0.1' (y/N):
```
### 🎯 Modalità crib e 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 terminale esegue ciphey -t su una stringa Base64 con -r 'picoCTF\{'. Ciphey riporta 'Regex matched: picoCTF\{', chiede informazioni su 'picoCTF{b4s3_64_1s_fun}' e lo stampa come testo in chiaro, decodificato con Base64."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/crib.mp4">Guarda il video</a> (14,5 s)</sub>
Se conosci parte della risposta (il formato della flag, una parola che deve essere presente, come inizia), passala a Ciphey come regex con `-r`. Gli altri checker si disattivano e viene accettato solo il testo che corrisponde. Questo trova testo in chiaro che gli altri checker salterebbero, oppure si ferma su quello che vuoi quando diversi candidati sembrano testo in chiaro: con `-r 'picoCTF\{'`, solo una flag `picoCTF{…}` termina la ricerca.
`--wordlist words.txt` funziona allo stesso modo per le corrispondenze esatte: un candidato che è una riga del file viene considerato testo in chiaro.
### 🎨 Pensato per il tuo terminale
La configurazione al primo avvio ti permette di scegliere un tema di colori (Capptucin, Darcula, GirlyPop, quello predefinito, oppure i tuoi valori RGB) e di scegliere se ricevere una domanda per ogni testo in chiaro o ottenere un elenco di candidati alla fine. Puoi vederlo [nel tour](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) a partire da 0:32. Tutto viene salvato in `~/.ciphey/config.toml`, che puoi modificare in seguito.
### 📚 Prima la libreria
Il binario `ciphey` è un sottile wrapper attorno al crate `ciphey`. Anche il [bot Discord](https://github.com/bee-san/discord-bot) lo utilizza, e così può fare il tuo codice.
## Usalo come libreria
`perform_cracking` esegue l'intera ricerca, come fa il binario `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}"),
}
}
```
Questo stampa `hello there general (via Base64)`.
### Un solo decoder
Se sai cosa stai guardando, chiama quel decoder. Ognuno è una funzione in `ciphey::decoders`: le codifiche vengono restituite decodificate, i cifrari vengono violati, e quelli che richiedono una chiave possono decifrare con la tua.
```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");
```
Per scegliere il decoder in fase di esecuzione, `decode_with` accetta il suo nome o un alias, e `list_decoders` li elenca tutti con i rispettivi alias, tag e la chiave che accettano:
```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"));
}
```
Niente viene filtrato: ottieni ciò che il decoder passa alla ricerca. Il testo in chiaro candidato accettato dai controlli di Ciphey viene per primo e porta con sé un `detection`; se nessuno lo accetta, ottieni le decodifiche non contrassegnate, da giudicare tu stesso (tutti e 25 gli spostamenti di Cesare, per esempio, anche se i cracker con molte chiavi passano solo i loro migliori).
### È testo in chiaro?
`detect_plaintext` esegue i controlli usati dalla ricerca (un crib regex, una wordlist, LemmeKnow, JSON, password comuni, inglese e codice) e indica quale ha accettato il testo e per cosa lo ha preso:
```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` illustra tutto questo, e `cargo run --example decode -- list` elenca i decoder.
- `perform_cracking` restituisce `Result<Option<DecoderResult>, CipheyError>` su `master` ([#915](https://github.com/bee-san/Ciphey/pull/915)), e le funzioni per decoder singolo e di rilevamento sono finora solo su `master`. L'ultima release su crates.io (0.12.0) restituisce ancora `Option<DecoderResult>`, quindi fino alla prossima release usa la versione git: `ciphey = { git = "https://github.com/bee-san/Ciphey" }`.
- La configurazione è globale per il processo. La `Config` della prima chiamata viene usata per ogni chiamata successiva, e anche i decoder singoli la seguono (un crib `regex`, una wordlist). Non chiedono mai input.
- L'API è documentata su [docs.rs](https://docs.rs/ciphey).
## Server MCP (assistenti AI)
<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="A un assistente AI (Kiro CLI) viene chiesto di decodificare una stringa Base64 da una challenge CTF. Chiama lo strumento decode di ciphey tramite MCP, che restituisce il flag in chiaro flag{ciphey_speaks_mcp} e i decoder usati, Base64 → Hexadecimal → caesar con chiave 13. L'assistente risponde quindi con il flag. Clicca per guardare il video di 30 secondi."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4">Guarda il video</a> (29,5 s). La chat riproduce una reale sessione di Kiro CLI con ciphey-mcp.</sub>
`ciphey-mcp` è un server [Model Context Protocol](https://modelcontextprotocol.io), così assistenti AI come Claude Desktop e Kiro possono decodificare testo con Ciphey. È dietro la feature `mcp`, quindi la build normale di `ciphey` non lo include:
```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 funzionalità `mcp` non è ancora presente in una release di crates.io (0.12.0 è l'ultima), quindi fino alla prossima, installa da git: `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`.
Fornisce quattro strumenti:
- `decode` decodifica `text` quando non sai come è stato codificato, e restituisce il `plaintext` e il `path` dei decoder utilizzati, con chiavi come lo shift di Cesare. Argomenti opzionali: `timeout_secs` (da 1 a 30, predefinito 10) e `regex`, un crib che il plaintext deve corrispondere, come `flag\{`.
- `decode_with` esegue un decoder che scegli tu su `text`: passagli l'id del `decoder`, il nome o un alias (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...). Senza una `key` decodifica il testo, oppure forza il cifrario provando ogni chiave; con una chiave decifra, per i cifrari che accettano una chiave (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`). Restituisce ogni decodifica candidata e se ciascuna supera il controllo del plaintext di Ciphey. `regex` funziona come per `decode`.
- `detect_plaintext` verifica se `text` è già plaintext, senza decodificarlo, e indica quale checker lo ha accettato, per cosa lo ha preso e, per i formati di LemmeKnow, quanto ne è sicuro. Argomenti opzionali: `checkers` (uno qualsiasi tra `lemmeknow`, `json`, `password`, `english` e `code`, per impostazione predefinita tutti e cinque), `sensitivity` del checker inglese (`low`, `medium` o `high`) e un crib `regex`.
- `list_decoders` elenca le codifiche e i cifrari supportati da Ciphey, con gli id e gli alias accettati da `decode_with` e il formato della chiave di ciascun cifrario che ne accetta una.
Un risultato di `decode` appare così. `status` è `decoded`, `not_found` o `timed_out`.
```json
{
"status": "decoded",
"plaintext": "hello there general",
"path": [{ "decoder": "Base64", "key": null }],
"checker": "English Checker",
"timeout_secs": 10
}
```
`decode_with` con `{"decoder": "rot13", "text": "Uryyb jbeyq"}` restituisce il risultato seguente. `status` è `plaintext_found`, `no_plaintext` (nessuno dei candidati ha superato il controllo, quindi valutali tu stesso) oppure `no_candidates` (il testo non è nel formato di quel decoder). Un risultato contiene al massimo 100 candidati e 65.536 caratteri del loro testo; `total_candidates` indica quanti erano, e un candidato troncato ha `truncated` impostato.
```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` con `{"text": "192.168.0.1"}` restituisce:
```json
{
"is_plaintext": true,
"detection": {
"checker": "lemmeknow",
"description": "Internet Protocol (IP) Address Version 4",
"confidence": 0.7
},
"checkers": ["lemmeknow", "json", "password", "english", "code"]
}
```
Ogni chiamata eccetto `list_decoders` viene eseguita in un proprio processo di breve durata. L'input è limitato a 65.536 caratteri (anche le chiavi) e le regex a 1.000. Una chiamata `decode` cerca per un massimo di 30 secondi e può utilizzare 1 GiB di memoria; una chiamata `decode_with` può essere eseguita per 30 secondi e una chiamata `detect_plaintext` per 10, con 256 MiB ciascuna. Al massimo due decode e quattro altre chiamate vengono eseguite contemporaneamente. Il server non legge né scrive `~/.ciphey`, quindi non c'è alcun file di configurazione e nessuna cache.
### Claude Desktop
Apri Impostazioni → Developer → Edit Config, aggiungi il server a `claude_desktop_config.json`, quindi riavvia Claude Desktop. Usa il percorso completo stampato da `which ciphey-mcp` (`where ciphey-mcp` su Windows, ad esempio `C:\\Users\\you\\.cargo\\bin\\ciphey-mcp.exe`), perché Claude Desktop potrebbe non vedere il `PATH` della tua shell.
```json
{
"mcpServers": {
"ciphey": {
"command": "/Users/you/.cargo/bin/ciphey-mcp"
}
}
}
```
### Kiro
```sh
kiro-cli mcp add --name ciphey --command ciphey-mcp
```
Oppure aggiungi la voce seguente a `~/.kiro/settings/mcp.json` (tutti i progetti) o `.kiro/settings/mcp.json` (un singolo progetto).
### Altri client
La maggior parte dei client MCP accetta la stessa voce `mcpServers`: un server stdio avviato da `ciphey-mcp` senza argomenti.
```json
{
"mcpServers": {
"ciphey": {
"command": "ciphey-mcp",
"args": []
}
}
}
```
## Da sapere
- Il rilevamento del testo in chiaro non è perfetto. I testi che non sono in inglese vengono spesso mancati, e una chiave quasi corretta (in particolare Vigenère) può comunque produrre un testo che sembra inglese. [#1031](https://github.com/bee-san/Ciphey/issues/1031) contiene la valutazione. Se sai qualcosa sulla risposta, un crib (`-r`) o una wordlist aiutano molto.
- Una flag il cui prefisso non è una parola flag (`SEKAI{…}` invece di `…CTF{…}` o `flag{…}`) appare identica ai propri spostamenti di Cesare, quindi sotto Cesare, ROT13 o Atbash Ciphey non può distinguere quale sia quella giusta. Forniscile il formato come crib: `-r 'SEKAI\{'`.
- Se una risposta in cache è sbagliata, elimina `~/.ciphey/database.sqlite` per svuotare la cache.
- Se sei bloccato, chiedi in `#coded-messages` su [Discord](http://discord.skerritt.blog).
## Documentazione
- [Documentazione API su docs.rs](https://docs.rs/ciphey)
- [La cartella `docs/`](https://github.com/bee-san/ciphey/blob/master/docs), che include una [panoramica](https://github.com/bee-san/ciphey/blob/master/docs/ares_overview.md), l'[architettura](https://github.com/bee-san/ciphey/blob/master/docs/ares_architecture.md), [come funziona la ricerca A*](https://github.com/bee-san/ciphey/blob/master/docs/astar.md) e [come viene rilevato il testo in chiaro](https://github.com/bee-san/ciphey/blob/master/docs/plaintext-detection.md)
- [Documentazione di Ciphey 2](https://broadleaf-angora-7db.notion.site/Ciphey2-32d5eea5d38b40c5b95a9442b4425710) su Notion
- [Introducing Ares](https://skerritt.blog/introducing-ares/), il post del blog sulla riscrittura in Rust (si chiamava Ares prima di diventare Ciphey)
## Contribuire
Segnalazioni di bug, idee e pull request sono benvenute nelle [issue](https://github.com/bee-san/Ciphey/issues). Un nuovo decoder è un buon primo contributo: scegline uno da [#1030](https://github.com/bee-san/Ciphey/issues/1030) e copia la struttura di uno esistente in [`src/decoders/`](https://github.com/bee-san/ciphey/blob/master/src/decoders). Puoi anche [sponsorizzare il progetto](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="Avatar delle persone che hanno contribuito a Ciphey"></a>
## Crediti
- [LemmeKnow](https://github.com/swanandx/lemmeknow) di [@swanandx](https://github.com/swanandx) identifica ciò che Ciphey trova, e [gibberish-or-not](https://github.com/bee-san/gibberish-or-not) decide se è inglese.
- [Rayon](https://github.com/rayon-rs/rayon) esegue i decoder in parallelo.
- Ciphey è nato come progetto Python; Python Ciphey 5.x è ancora su [PyPI](https://pypi.org/project/ciphey/). Grazie a tutti coloro che ci hanno lavorato.
- I video sono realizzati con [HyperFrames](https://hyperframes.heygen.com/) a partire da registrazioni reali del terminale. Il codice sorgente, le registrazioni e lo script di build sono in [`media/tui-video`](https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video) sul branch `media/readme-videos`.
## Uso dell'IA
Usiamo l'IA per 2 cose:
1. La TUI è interamente vibe coded.
2. Ho fatto passare ore all'IA a ricercare ogni singola challenge CTF esistente. Ha creato un elenco di 15.071 CTF. Poi ha esaminato ogni singolo CTF e cercato i writeup. In quei writeup ha cercato qualsiasi cosa relativa a encoding / decoding. Poi ha creato dei test a partire da essi. Questo ci ha permesso di aumentare la nostra copertura di test e di assicurarci che tutte le challenge CTF di encoding / decoding siano risolvibili con questo strumento.
## Licenza
MIT. Vedi [LICENSE](https://github.com/bee-san/ciphey/blob/master/LICENSE).