⚡ Automatisch Verschlüsselungen entschlüsseln, ohne den Schlüssel oder das Verfahren zu kennen, Kodierungen dekodieren und Hashes knacken ⚡
<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 einem Terminal: vier Base64-Schichten werden eingegeben, Ciphey fragt, ob „Ciphey peels back every layer of encoding“ der Klartext ist, und gibt ihn dann mit dem Pfad Base64 → Base64 → Base64 → Base64 aus. Klicken, um die einminütige Tour anzusehen."></a>
</p>
<h1 align="center">Ciphey</h1>
<p align="center">
<b>Füge Text ein, der kodiert oder verschlüsselt wurde. Ciphey findet heraus, wie, und liefert dir den Klartext.</b><br>
Kein Schlüssel, kein Cipher-Name, keine Hinweise. Base64, Hex, Caesar/ROT13, Vigenère, Morsecode und 19 weitere, über mehrere Schichten hinweg.
</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">Installation</a> ·
<a href="#quick-start">Schnellstart</a> ·
<a href="#features">Funktionen</a> ·
<a href="#use-it-as-a-library">Bibliothek</a> ·
<a href="#mcp-server-ai-assistants">MCP</a> ·
<a href="#documentation">Dokumentation</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">Sieh dir die einminütige Tour an</a> (MP4, 61 s)</sub>
</p>
## Installation
```bash
cargo install ciphey
```
Vorkompilierte Binärdateien für Linux (x86_64), macOS (Intel und Apple Silicon) und Windows (x86_64) finden sich auf der [Releases-Seite](https://github.com/bee-san/Ciphey/releases/latest), jeweils mit einer `.sha256`-Prüfsumme.
Um aus dem Quellcode zu bauen, benötigst du eine Rust-Toolchain:
```bash
git clone https://github.com/bee-san/Ciphey
cd Ciphey
cargo build --release # the binary is target/release/ciphey
```
Oder überspringen Sie die Installation: Treten Sie dem [Discord-Server](http://discord.skerritt.blog) bei, gehen Sie zu `#bots` und geben Sie `$ciphey <your text>` ein (`$help` listet die Befehle auf).
## Schnellstart
```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
```
Beim ersten Ausführen fragt ein kurzes Setup nach einem Farbthema, danach, wie Ergebnisse angezeigt werden sollen, und ob eine Wortliste verwendet werden soll, und speichert deine Antworten 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` listet jede Option auf.
## Funktionen
### ⚡ Schnell
<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="Ein Terminal führt time ciphey -d auf einer Base64-Zeichenkette aus. Ciphey gibt 'Ciphey is very fast' und den Pfad Base64 → Hexadecimal → caesar aus, und bash meldet real 0m0.157s. Ein Diagramm vergleicht dann Cipheys 0,19 s (den Median aus 10 Läufen) mit keiner Antwort nach 60 s für Python Ciphey 5.14.0 bei derselben Eingabe."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/fast.mp4">Clip ansehen</a> (16 s)</sub>
Drei Schichten (erst ROT13, dann Hex, dann Base64) werden in 0,16 s abgetragen, gemessen mit bashs `time` in einer echten Aufzeichnung. Hier ist derselbe Vergleich für weitere Eingaben, gegen Python Ciphey 5.14, die Version, die Ciphey ersetzt:
| Eingabe | 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 | keine Antwort innerhalb von 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, falsche Antwort |
| ROT13 → Hex → Base64 → Base32 | 1,15 s | keine Antwort innerhalb von 60 s |
<sub>Median der Wanduhrzeit aus 10 Läufen pro Eingabe (Python Ciphey: 3) auf einer gemeinsam genutzten Linux-Maschine mit 16 CPUs, Ciphey bei 47bd16d6 mit deaktiviertem y/N-Prompt und einem frischen <code>$HOME</code> pro Lauf, damit sein Cache nicht helfen kann. Jeder Lauf war auf 60 s begrenzt. Das Skript und die Rohzahlen befinden sich in <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> im Branch <code>media/readme-videos</code>.</sub>
Wo beide die richtige Antwort liefern, ist Ciphey 1,9- bis 8,6-mal schneller. Woher kommt die Geschwindigkeit?
- Es ist Rust.
- Eine A*-Suche probiert zuerst die vielversprechendsten Ketten von Decodern aus.
- Jeder Decoder läuft parallel mit [Rayon](https://github.com/rayon-rs/rayon), auf bis zu 10 Kandidatentexten gleichzeitig.
- Antworten werden in `~/.ciphey/database.sqlite` zwischengespeichert, sodass dieselbe Eingabe beim zweiten Mal in Millisekunden zurückkommt.
### 🧅 Schicht um Schicht, kein Schlüssel nötig
Ciphey muss nicht gesagt werden, worauf es schaut. Es durchsucht Ketten von Decodern (Base64 in Hex in ROT13, vier Schichten Base64 und so weiter) und stoppt beim ersten Kandidaten, der wie Klartext aussieht. Standardmäßig zeigt es diesen Kandidaten an und fragt nach, bevor es ihn akzeptiert (`-d` schaltet dies aus). Der Clip oben auf dieser Seite zeigt eine vierstufige Dekodierung.
Es gibt außerdem einen Timer: Wenn Ciphey nach 5 Sekunden nichts gefunden hat, stoppt es und teilt dies mit (`-c` ändert das Limit).
Es kennt 24 Decoder und Knacker:
| Art | Decoder |
| --- | --- |
| Base-Kodierungen | Base64 (Standard und URL-sicher), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| Andere Kodierungen | Hexadezimal, Binär, URL (Prozentkodierung), Morsecode, Braille, A1Z26, Citrix CTX1 |
| Chiffren | Caesar (einschließlich ROT13), ROT47, Atbash, Vigenère (ermittelt den Schlüssel selbst), Zaun-Chiffre, umgekehrter Text |
| Kuriositäten | Brainfuck (führt das Programm aus), Morse oder Binär, geschrieben mit anderen Symbolen |
Weitere sind in Arbeit: [#1030](https://github.com/bee-san/Ciphey/issues/1030) verfolgt 109 Decoder, die noch fehlen.
### 🕵️ Weiß, was es gefunden hat
<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="Drei Ciphey-Läufe. Base64 dekodiert zu 'mount -o username=bee,password=hunter2', identifiziert als Mount Command With Clear Credentials. Base64 dekodiert zu einem otpauth://-Link, identifiziert als Time-Based One-Time Password (TOTP) URI. Hex dekodiert zu 192.168.0.1, identifiziert als 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">Clip ansehen</a> (21 s)</sub>
Jeder Kandidaten-Klartext durchläuft außerdem [LemmeKnow](https://github.com/swanandx/lemmeknow), den Rust-Port von [pyWhat](https://github.com/bee-san/pyWhat), der mehr als 120 Formate erkennt. Ciphey dekodiert die Zeichenkette also nicht nur, sondern sagt dir auch, was sie ist: ein Passwort in einem `mount`- oder `sshpass`-Befehl, ein TOTP-Secret, ein GitHub-Token oder Stripe-Key, eine IP- oder MAC-Adresse, eine E-Mail-Adresse oder URL, eine Krypto-Wallet, ein AWS-ARN, JSON oder eine CTF-Flag in beliebigem Format (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`). LemmeKnow-Muster, die nur prüfen, welche Zeichen eine Zeichenkette enthält und wie lang sie ist (etwa Karten- und Telefonnummern), werden ignoriert: Decoder-Müll passt ständig darauf.
```console
$ ciphey -t '3139322e3136382e302e31'
🕵️ I think the plaintext is Internet Protocol (IP) Address Version 4.
Possible plaintext: '192.168.0.1' (y/N):
```
### 🎯 Crib- und Regex-Modus
<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="Ein Terminal führt ciphey -t auf einer Base64-Zeichenkette mit -r 'picoCTF\{' aus. Ciphey meldet 'Regex matched: picoCTF\{', fragt nach 'picoCTF{b4s3_64_1s_fun}' und gibt ihn als Klartext aus, dekodiert mit Base64."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/crib.mp4">Clip ansehen</a> (14,5 s)</sub>
Wenn du einen Teil der Antwort kennst (das Flag-Format, ein Wort, das darin vorkommen muss, wie sie beginnt), gib ihn Ciphey als Regex mit `-r`. Die anderen Checker werden abgeschaltet und nur Text, der übereinstimmt, wird akzeptiert. So findest du Klartext, den die anderen Checker übersehen würden, oder hältst bei dem an, den du willst, wenn mehrere Kandidaten wie Klartext aussehen: Mit `-r 'picoCTF\{'` beendet nur ein `picoCTF{…}`-Flag die Suche.
`--wordlist words.txt` funktioniert auf dieselbe Weise für exakte Übereinstimmungen: Ein Kandidat, der eine Zeile in der Datei ist, zählt als Klartext.
### 🎨 Für dein Terminal gemacht
Das Einrichtungsprogramm beim ersten Start lässt dich ein Farbthema wählen (Capptucin, Darcula, GirlyPop, das Standardthema oder deine eigenen RGB-Werte) und entscheiden, ob du zu jedem Klartext gefragt wirst oder am Ende eine Liste von Kandidaten bekommst. Du kannst es [in der Tour](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) ab 0:32 sehen. Alles wird in `~/.ciphey/config.toml` gespeichert, die du später bearbeiten kannst.
### 📚 Bibliothek zuerst
Die Binärdatei `ciphey` ist ein dünner Wrapper um das Crate `ciphey`. Der [Discord-Bot](https://github.com/bee-san/discord-bot) verwendet es ebenfalls, und dein Code kann das auch.
## Als Bibliothek verwenden
`perform_cracking` führt die gesamte Suche aus, so wie es die Binärdatei `ciphey` tut:
```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}"),
}
}
```
Dies gibt `hello there general (via Base64)` aus.
### Ein Decoder
Wenn Sie wissen, womit Sie es zu tun haben, rufen Sie diesen Decoder auf. Jeder ist eine Funktion in `ciphey::decoders`: Kodierungen werden dekodiert zurückgegeben, Chiffren werden geknackt, und diejenigen, die einen Schlüssel benötigen, können mit Ihrem entschlüsseln.
```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");
```
Um den Decoder zur Laufzeit auszuwählen, nimmt `decode_with` seinen Namen oder einen Alias entgegen, und `list_decoders` listet alle mit ihren Aliasen, Tags und dem Schlüssel, den sie entgegennehmen, auf:
```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"));
}
```
Nichts wird herausgefiltert: Du bekommst, was der Decoder an die Suche weitergibt. Der Klartext-Kandidat, den die Prüfungen von Ciphey akzeptieren, kommt zuerst und trägt eine `detection`; wenn keine Prüfung akzeptiert, erhältst du die Dekodierungen ohne Markierung, damit du selbst urteilen kannst (etwa alle 25 Caesar-Verschiebungen, obwohl Cracker mit vielen Schlüsseln nur ihre besten wenigen weitergeben).
### Handelt es sich um Klartext?
`detect_plaintext` führt die Prüfungen aus, die die Suche verwendet (ein Regex-Crib, eine Wortliste, LemmeKnow, JSON, gängige Passwörter, Englisch und Code) und gibt an, welche davon den Text akzeptiert hat und wofür sie ihn gehalten hat:
```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` führt durch all dies, und `cargo run --example decode -- list` listet die Decoder auf.
- `perform_cracking` gibt auf `master` `Result<Option<DecoderResult>, CipheyError>` zurück ([#915](https://github.com/bee-san/Ciphey/pull/915)), und die Single-Decoder- und Erkennungsfunktionen sind bisher nur auf `master` verfügbar. Die letzte Veröffentlichung auf crates.io (0.12.0) gibt weiterhin `Option<DecoderResult>` zurück, daher verwende bis zur nächsten Veröffentlichung die Git-Version: `ciphey = { git = "https://github.com/bee-san/Ciphey" }`.
- Die Konfiguration ist global für den Prozess. Die `Config` des ersten Aufrufs wird für jeden späteren Aufruf verwendet, und die einzelnen Decoder folgen ihr ebenfalls (ein `regex`-Crib, eine Wortliste). Sie fragen nie nach.
- Die API ist auf [docs.rs](https://docs.rs/ciphey) dokumentiert.
## MCP-Server (KI-Assistenten)
<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="Ein KI-Assistent (Kiro CLI) wird gebeten, einen Base64-String aus einer CTF-Challenge zu decodieren. Er ruft das decode-Tool von ciphey über MCP auf, das den Klartext flag{ciphey_speaks_mcp} und die verwendeten Decoder zurückgibt: Base64 → Hexadecimal → caesar mit Schlüssel 13. Der Assistent antwortet dann mit dem Flag. Klicken, um das 30-sekündige Video anzusehen."></a>
<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4">Video ansehen</a> (29,5 s). Der Chat spielt eine echte Kiro-CLI-Sitzung mit ciphey-mcp wieder ab.</sub>
`ciphey-mcp` ist ein [Model Context Protocol](https://modelcontextprotocol.io)-Server, sodass KI-Assistenten wie Claude Desktop und Kiro Text mit Ciphey decodieren können. Er ist hinter dem `mcp`-Feature verborgen, daher enthält der normale `ciphey`-Build ihn nicht:
```sh
cargo install ciphey --features mcp --bin ciphey-mcp
# or, from a clone of this repository:
cargo install --path . --features mcp --bin ciphey-mcp
```
Das `mcp`-Feature ist noch nicht in einer crates.io-Version enthalten (0.12.0 ist die neueste), daher installiere bis zur nächsten Version aus git: `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`.
Es stellt vier Tools bereit:
- `decode` dekodiert `text`, wenn du nicht weißt, wie er kodiert wurde, und gibt den `plaintext` und den `path` der verwendeten Decoder zurück, mit Schlüsseln wie dem Caesar-Shift. Optionale Argumente: `timeout_secs` (1 bis 30, Standard 10) und `regex`, ein Crib, dem der Klartext entsprechen muss, etwa `flag\{`.
- `decode_with` führt einen von dir gewählten Decoder auf `text` aus: Gib ihm die id, den Namen oder einen Alias des `decoder` (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...). Ohne `key` dekodiert es den Text oder knackt die Verschlüsselung, indem es jeden Schlüssel ausprobiert; mit einem entschlüsselt es, für Verschlüsselungen, die einen Schlüssel benötigen (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`). Es gibt jede Kandidaten-Dekodierung zurück und ob jede Cipheys Klartext-Prüfung besteht. `regex` funktioniert wie bei `decode`.
- `detect_plaintext` prüft, ob `text` bereits Klartext ist, ohne ihn zu dekodieren, und gibt an, welcher Checker ihn akzeptiert hat, wofür er ihn hielt und, bei LemmeKnows Formaten, wie sicher er ist. Optionale Argumente: `checkers` (beliebige aus `lemmeknow`, `json`, `password`, `english` und `code`, standardmäßig alle fünf), `sensitivity` des English-Checkers (`low`, `medium` oder `high`) und ein `regex`-Crib.
- `list_decoders` listet die von Ciphey unterstützten Kodierungen und Verschlüsselungen auf, mit den ids und Aliasen, die `decode_with` akzeptiert, und dem Schlüsselformat jeder Verschlüsselung, die einen benötigt.
Ein `decode`-Ergebnis sieht so aus. `status` ist `decoded`, `not_found` oder `timed_out`.
```json
{
"status": "decoded",
"plaintext": "hello there general",
"path": [{ "decoder": "Base64", "key": null }],
"checker": "English Checker",
"timeout_secs": 10
}
```
`decode_with` mit `{"decoder": "rot13", "text": "Uryyb jbeyq"}` liefert das untenstehende Ergebnis. `status` ist `plaintext_found`, `no_plaintext` (keiner der Kandidaten hat die Prüfung bestanden, also beurteilen Sie sie selbst) oder `no_candidates` (der Text liegt nicht im Format dieses Decoders vor). Ein Ergebnis enthält höchstens 100 Kandidaten und 65.536 Zeichen ihres Textes; `total_candidates` gibt an, wie viele es waren, und bei einem abgeschnittenen Kandidaten ist `truncated` gesetzt.
```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` mit `{"text": "192.168.0.1"}` ergibt:
```json
{
"is_plaintext": true,
"detection": {
"checker": "lemmeknow",
"description": "Internet Protocol (IP) Address Version 4",
"confidence": 0.7
},
"checkers": ["lemmeknow", "json", "password", "english", "code"]
}
```
Jeder Aufruf außer `list_decoders` läuft in einem eigenen kurzlebigen Prozess. Die Eingabe ist auf 65.536 Zeichen (auch Schlüssel) und reguläre Ausdrücke auf 1.000 begrenzt. Ein `decode` sucht höchstens 30 Sekunden lang und darf 1 GiB Arbeitsspeicher verwenden; ein `decode_with`-Aufruf darf 30 Sekunden laufen und ein `detect_plaintext`-Aufruf 10, jeweils mit 256 MiB. Höchstens zwei Decodes und vier andere Aufrufe laufen gleichzeitig. Der Server liest oder schreibt `~/.ciphey` nicht, daher gibt es keine Konfigurationsdatei und keinen Cache.
### Claude Desktop
Öffne Einstellungen → Entwickler → Konfiguration bearbeiten, füge den Server zu `claude_desktop_config.json` hinzu und starte Claude Desktop anschließend neu. Verwende den vollständigen Pfad, den `which ciphey-mcp` ausgibt (`where ciphey-mcp` unter Windows, zum Beispiel `C:\\Users\\you\\.cargo\\bin\\ciphey-mcp.exe`), da Claude Desktop möglicherweise das `PATH` deiner Shell nicht sieht.
```json
{
"mcpServers": {
"ciphey": {
"command": "/Users/you/.cargo/bin/ciphey-mcp"
}
}
}
```
### Kiro
```sh
kiro-cli mcp add --name ciphey --command ciphey-mcp
```
Oder fügen Sie den folgenden Eintrag zu `~/.kiro/settings/mcp.json` (alle Projekte) oder `.kiro/settings/mcp.json` (ein Projekt) hinzu.
### Andere Clients
Die meisten MCP-Clients verwenden denselben `mcpServers`-Eintrag: einen stdio-Server, der von `ciphey-mcp` ohne Argumente gestartet wird.
```json
{
"mcpServers": {
"ciphey": {
"command": "ciphey-mcp",
"args": []
}
}
}
```
## Wissenswertes
- Die Klartext-Erkennung ist nicht perfekt. Text, der nicht auf Englisch ist, wird oft übersehen, und ein knapp danebenliegender Schlüssel (insbesondere Vigenère) kann immer noch Text erzeugen, der als Englisch durchgeht. [#1031](https://github.com/bee-san/Ciphey/issues/1031) enthält die Auswertung. Wenn du etwas über die Antwort weißt, helfen ein Crib (`-r`) oder eine Wortliste sehr.
- Ein Flag, dessen Präfix kein Flag-Wort ist (`SEKAI{…}` statt `…CTF{…}` oder `flag{…}`), sieht genauso aus wie seine eigenen Caesar-Verschiebungen, sodass Ciphey unter Caesar, ROT13 oder Atbash nicht erkennen kann, welches davon richtig ist. Gib das Format als Crib an: `-r 'SEKAI\{'`.
- Wenn eine zwischengespeicherte Antwort falsch ist, lösche `~/.ciphey/database.sqlite`, um den Cache zu leeren.
- Wenn du nicht weiterkommst, frag in `#coded-messages` auf [Discord](http://discord.skerritt.blog).
## Dokumentation
- [API-Dokumentation auf docs.rs](https://docs.rs/ciphey)
- [Der Ordner `docs/`](https://github.com/bee-san/ciphey/blob/master/docs), einschließlich einer [Übersicht](https://github.com/bee-san/ciphey/blob/master/docs/ares_overview.md), der [Architektur](https://github.com/bee-san/ciphey/blob/master/docs/ares_architecture.md), [wie die A*-Suche funktioniert](https://github.com/bee-san/ciphey/blob/master/docs/astar.md) und [wie Klartext erkannt wird](https://github.com/bee-san/ciphey/blob/master/docs/plaintext-detection.md)
- [Ciphey 2-Dokumentation](https://broadleaf-angora-7db.notion.site/Ciphey2-32d5eea5d38b40c5b95a9442b4425710) auf Notion
- [Introducing Ares](https://skerritt.blog/introducing-ares/), der Blogbeitrag über die Rust-Neuimplementierung (sie hieß Ares, bevor daraus Ciphey wurde)
## Mitwirken
Fehlerberichte, Ideen und Pull Requests sind in den [Issues](https://github.com/bee-san/Ciphey/issues) willkommen. Ein neuer Decoder ist ein guter erster Beitrag: Wähle einen aus [#1030](https://github.com/bee-san/Ciphey/issues/1030) und übernimm die Struktur eines bestehenden Decoders in [`src/decoders/`](https://github.com/bee-san/ciphey/blob/master/src/decoders). Du kannst das Projekt auch [sponsern](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="Avatare der Personen, die zu Ciphey beigetragen haben"></a>
## Danksagungen
- [LemmeKnow](https://github.com/swanandx/lemmeknow) von [@swanandx](https://github.com/swanandx) erkennt, was Ciphey findet, und [gibberish-or-not](https://github.com/bee-san/gibberish-or-not) entscheidet, ob es Englisch ist.
- [Rayon](https://github.com/rayon-rs/rayon) führt die Decoder parallel aus.
- Ciphey begann als Python-Projekt; Python Ciphey 5.x ist weiterhin auf [PyPI](https://pypi.org/project/ciphey/) verfügbar. Danke an alle, die daran mitgearbeitet haben.
- Die Videos wurden mit [HyperFrames](https://hyperframes.heygen.com/) aus echten Terminal-Aufzeichnungen erstellt. Der Quellcode, die Aufzeichnungen und das Build-Skript befinden sich in [`media/tui-video`](https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video) im Branch `media/readme-videos`.
## KI-Nutzung
Wir nutzen KI für 2 Dinge:
1. Die TUI ist vollständig vibe-coded.
2. Ich habe KI stundenlang jede einzelne CTF-Challenge recherchieren lassen, die es gibt. Sie erstellte eine Liste mit 15.071 CTFs. Dann ging sie jede einzelne CTF durch und suchte nach Writeups. In diesen Writeups suchte sie nach allem, was mit Kodierung/Dekodierung zu tun hat. Daraus erstellte sie Tests. Dies ermöglichte es uns, unsere Testabdeckung zu erhöhen und sicherzustellen, dass alle CTF-Kodierungs-/Dekodierungs-Challenges mit diesem Tool lösbar sind.
## Lizenz
MIT. Siehe [LICENSE](https://github.com/bee-san/ciphey/blob/master/LICENSE).