Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Ciphey — ⚡ Descifra automáticamente cifrados sin conocer la clave o el cifrado, decodifica codificaciones y descifra hashes ⚡ | Kitploit
Herramientas/GitHubGitHub/bee-san/ciphey
Herramientas de Cifrado/DescifradoAnálisis de HashCriptografíaCTFPruebas de PenetraciónAprendizaje y EducaciónTop en Criptografía #13Top en CTF #6Top en Herramientas de Cifrado/Descifrado #14Top en Análisis de Hash #5
21.6k1.4k195hace 13 díasRevisado por Kitploit
Compartir
GitHubbee-san/ciphey

Ciphey

⚡ Descifra automáticamente cifrados sin conocer la clave o el cifrado, decodifica codificaciones y descifra hashes ⚡

Ver Repositorio
<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 en una terminal: entran cuatro capas de Base64, Ciphey pregunta si 'Ciphey peels back every layer of encoding' es el texto plano y luego lo imprime con la ruta Base64 → Base64 → Base64 → Base64. Haz clic para ver el recorrido de un minuto."></a>
</p>

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

<p align="center">
  <b>Pega texto que ha sido codificado o cifrado. Ciphey averigua cómo y te entrega el texto plano.</b><br>
  Sin clave, sin nombre de cifrado, sin pistas. Base64, hex, Caesar/ROT13, Vigenère, código Morse y 19 más, varias capas de profundidad.
</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">Instalar</a> ·
  <a href="#quick-start">Inicio rápido</a> ·
  <a href="#features">Características</a> ·
  <a href="#use-it-as-a-library">Biblioteca</a> ·
  <a href="#mcp-server-ai-assistants">MCP</a> ·
  <a href="#documentation">Documentación</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">Ver el recorrido de un minuto</a> (MP4, 61 s)</sub>
</p>

## Instalar

```bash
cargo install ciphey
```

Hay binarios precompilados para Linux (x86_64), macOS (Intel y Apple silicon) y Windows (x86_64) en la [página de releases](https://github.com/bee-san/Ciphey/releases/latest), cada uno con una suma de verificación `.sha256`.

Para compilar desde el código fuente, necesitas una toolchain de Rust:

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

O bien, omite la instalación: únete al [servidor de Discord](http://discord.skerritt.blog), ve a `#bots` y escribe `$ciphey <tu texto>` (`$help` lista los comandos).

## Inicio rápido

```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 primera vez que lo ejecutes, una breve configuración te pedirá un tema de color, cómo quieres que se muestren los resultados y si deseas usar una lista de palabras, y guardará tus respuestas en `~/.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` enumera todas las opciones.

## Características

### ⚡ Rápido

<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="Una terminal ejecuta time ciphey -d sobre una cadena Base64. Ciphey imprime 'Ciphey is very fast' y la ruta Base64 → Hexadecimal → caesar, y bash informa real 0m0.157s. A continuación, un gráfico compara los 0,19 s de Ciphey (la mediana de 10 ejecuciones) con la ausencia de respuesta tras 60 s de Python Ciphey 5.14.0 sobre la misma entrada."></a>

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

Tres capas (ROT13, luego hex y luego Base64) se descifran en 0,16 s, medido con `time` de bash en una grabación real. Aquí está la misma comparación para más entradas, frente a Python Ciphey 5.14, la versión que Ciphey reemplaza:

| Entrada | 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 | sin respuesta 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, respuesta incorrecta |
| ROT13 → Hex → Base64 → Base32 | 1,15 s | sin respuesta en 60 s |

<sub>Mediana de tiempo real de 10 ejecuciones por entrada (Python Ciphey: 3) en una máquina Linux compartida de 16 CPU, Ciphey en 47bd16d6 con el aviso y/N desactivado y un <code>$HOME</code> nuevo por ejecución para que su caché no pueda ayudar. Cada ejecución se limitó a 60 s. El script y los números en bruto están en <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> en la rama <code>media/readme-videos</code>.</sub>

Donde ambos obtienen la respuesta correcta, Ciphey es de 1,9 a 8,6 veces más rápido. ¿De dónde viene la velocidad?

- Está escrito en Rust.
- Una búsqueda A* prueba primero las cadenas de decodificadores más prometedoras.
- Cada decodificador se ejecuta en paralelo con [Rayon](https://github.com/rayon-rs/rayon), sobre hasta 10 textos candidatos a la vez.
- Las respuestas se almacenan en caché en `~/.ciphey/database.sqlite`, por lo que la misma entrada por segunda vez se devuelve en milisegundos.

### 🧅 Capa tras capa, sin necesidad de clave

Ciphey no necesita que se le diga qué está mirando. Busca cadenas de decodificadores (Base64 dentro de hex dentro de ROT13, cuatro capas de Base64, etc.) y se detiene en el primer candidato que parece texto plano. Por defecto te muestra ese candidato y pregunta antes de aceptarlo (`-d` desactiva esto). El clip al principio de esta página muestra una decodificación de cuatro capas.

También hay un temporizador: si Ciphey no ha encontrado nada después de 5 segundos, se detiene y lo indica (`-c` cambia el límite).

Conoce 24 decodificadores y crackers:

| Tipo | Decodificadores |
| --- | --- |
| Codificaciones Base | Base64 (estándar y URL-safe), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| Otras codificaciones | Hexadecimal, binario, URL (codificación porcentual), código Morse, Braille, A1Z26, Citrix CTX1 |
| Cifrados | César (incluido ROT13), ROT47, Atbash, Vigenère (calcula la clave por sí mismo), rail fence, texto invertido |
| Rarezas | Brainfuck (ejecuta el programa), Morse o binario escrito con otros símbolos |

Hay más en camino: [#1030](https://github.com/bee-san/Ciphey/issues/1030) rastrea 109 decodificadores que aún no están incluidos.

### 🕵️ Sabe lo que ha encontrado

<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="Tres ejecuciones de Ciphey. Base64 decodifica a 'mount -o username=bee,password=hunter2', identificado como Mount Command With Clear Credentials. Base64 decodifica a un enlace otpauth://, identificado como Time-Based One-Time Password (TOTP) URI. Hex decodifica a 192.168.0.1, identificado como 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">Ver el clip</a> (21 s)</sub>

Cada texto plano candidato también pasa por [LemmeKnow](https://github.com/swanandx/lemmeknow), el port a Rust de [pyWhat](https://github.com/bee-san/pyWhat), que reconoce más de 120 formatos. Así, Ciphey no solo decodifica la cadena, sino que te dice qué es: una contraseña en un comando `mount` o `sshpass`, un secreto TOTP, un token de GitHub o una clave de Stripe, una dirección IP o MAC, una dirección de correo electrónico o URL, una cartera cripto, un ARN de AWS, JSON o una flag de CTF en cualquier formato (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`). Se ignoran los patrones de LemmeKnow que solo comprueban qué caracteres tiene una cadena y su longitud (números de tarjeta y de teléfono, por ejemplo): la basura de los decodificadores los coincide todo el tiempo.

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

### 🎯 Modo crib y 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="Una terminal ejecuta ciphey -t sobre una cadena Base64 con -r 'picoCTF\{'. Ciphey informa 'Regex matched: picoCTF\{', pregunta sobre 'picoCTF{b4s3_64_1s_fun}' y lo imprime como el texto plano, decodificado con Base64."></a>

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

Si conoces parte de la respuesta (el formato de la flag, una palabra que tiene que estar ahí, cómo empieza), dásela a Ciphey como una regex con `-r`. Los demás verificadores se desactivan y solo se acepta el texto que coincida. Esto encuentra texto plano que los otros verificadores pasarían por alto, o se detiene en el que quieres cuando varios candidatos parecen texto plano: con `-r 'picoCTF\{'`, solo una flag `picoCTF{…}` termina la búsqueda.

`--wordlist words.txt` funciona de la misma manera para coincidencias exactas: un candidato que sea una línea del archivo cuenta como texto plano.

### 🎨 Hecho para tu terminal

La configuración inicial te permite elegir un tema de color (Capptucin, Darcula, GirlyPop, el predeterminado, o tus propios valores RGB) y elegir entre que se te pregunte sobre cada texto plano o recibir una lista de candidatos al final. Puedes verlo [en el tour](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) a partir de 0:32. Todo se guarda en `~/.ciphey/config.toml`, que puedes editar más tarde.

### 📚 La biblioteca primero

El binario `ciphey` es un envoltorio fino alrededor del crate `ciphey`. El [bot de Discord](https://github.com/bee-san/discord-bot) también lo usa, y tu código también puede hacerlo.

## Úsalo como biblioteca

`perform_cracking` ejecuta toda la búsqueda, igual que el 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}"),
    }
}
```

Esto imprime `hello there general (via Base64)`.

### Un decodificador

Si sabes qué estás viendo, llama a ese decodificador. Cada uno es una función en `ciphey::decoders`: las codificaciones se devuelven decodificadas, los cifrados se descifran, y los que requieren una clave pueden descifrar con la tuya.

```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");
```

Para elegir el decodificador en tiempo de ejecución, `decode_with` toma su nombre o un alias, y `list_decoders` los lista todos con sus alias, etiquetas y la clave que toman:

```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"));
}
```

Nada se filtra: obtienes lo que el decodificador pasa a la búsqueda. El texto plano candidato que las comprobaciones de Ciphey aceptan aparece primero y lleva una `detection`; si no aceptan ninguno, obtienes las decodificaciones sin marcar, para que las juzgues tú (los 25 desplazamientos César, por ejemplo, aunque los crackers con muchas claves solo entregan sus mejores pocas).

### ¿Es texto plano?

`detect_plaintext` ejecuta las comprobaciones que usa la búsqueda (una pista regex, una lista de palabras, LemmeKnow, JSON, contraseñas comunes, inglés y código) e indica cuál aceptó el texto y por qué lo tomó:

```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` recorre todo esto, y `cargo run --example decode -- list` lista los decodificadores.

- `perform_cracking` devuelve `Result<Option<DecoderResult>, CipheyError>` en `master` ([#915](https://github.com/bee-san/Ciphey/pull/915)), y las funciones de decodificador único y de detección solo están en `master` por ahora. La última versión en crates.io (0.12.0) todavía devuelve `Option<DecoderResult>`, así que hasta la próxima versión usa la versión de git: `ciphey = { git = "https://github.com/bee-san/Ciphey" }`.
- La configuración es global para el proceso. El `Config` de la primera llamada se usa para todas las llamadas posteriores, y los decodificadores individuales también lo siguen (un crib de `regex`, una wordlist). Nunca solicitan entrada.
- La API está documentada en [docs.rs](https://docs.rs/ciphey).

## Servidor MCP (asistentes de 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="Se le pide a un asistente de IA (Kiro CLI) que decodifique una cadena Base64 de un reto CTF. Llama a la herramienta decode de ciphey a través de MCP, que devuelve el flag en texto plano flag{ciphey_speaks_mcp} y los decodificadores que usó, Base64 → Hexadecimal → caesar con clave 13. El asistente responde entonces con el flag. Haz clic para ver el vídeo de 30 segundos."></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4">Ver el vídeo</a> (29,5 s). El chat reproduce una sesión real de Kiro CLI con ciphey-mcp.</sub>

`ciphey-mcp` es un servidor de [Model Context Protocol](https://modelcontextprotocol.io), para que asistentes de IA como Claude Desktop y Kiro puedan decodificar texto con Ciphey. Está detrás de la característica `mcp`, por lo que la compilación normal de `ciphey` no lo incluye:

```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 función `mcp` aún no está en una versión de crates.io (0.12.0 es la más reciente), así que hasta la próxima, instálala desde git: `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`.

Proporciona cuatro herramientas:

- `decode` decodifica `text` cuando no sabes cómo se codificó, y devuelve el `plaintext` y la `path` de los decodificadores utilizados, con claves como el desplazamiento César. Argumentos opcionales: `timeout_secs` (de 1 a 30, por defecto 10) y `regex`, un crib que el texto plano debe coincidir, como `flag\{`.
- `decode_with` ejecuta un decodificador que elijas sobre `text`: dale el id, el nombre o un alias del `decoder` (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...). Sin una `key` decodifica el texto, o rompe el cifrado probando todas las claves; con una descifra, para cifrados que aceptan una clave (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`). Devuelve todas las decodificaciones candidatas y si cada una pasa la comprobación de texto plano de Ciphey. `regex` funciona igual que en `decode`.
- `detect_plaintext` comprueba si `text` ya es texto plano, sin decodificarlo, e indica qué comprobador lo aceptó, por qué lo tomó y, para los formatos de LemmeKnow, cuán seguro está. Argumentos opcionales: `checkers` (cualquiera de `lemmeknow`, `json`, `password`, `english` y `code`, por defecto los cinco), `sensitivity` del comprobador de inglés (`low`, `medium` o `high`) y un crib `regex`.
- `list_decoders` lista las codificaciones y cifrados que admite Ciphey, con los ids y alias que acepta `decode_with` y el formato de clave de cada cifrado que acepta una.

Un resultado de `decode` se ve así. `status` es `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"}` da el resultado que se muestra a continuación. `status` es `plaintext_found`, `no_plaintext` (ninguno de los candidatos superó la comprobación, así que júzgalos tú mismo) o `no_candidates` (el texto no está en el formato de ese decodificador). Un resultado contiene como máximo 100 candidatos y 65.536 caracteres de su texto; `total_candidates` indica cuántos había, y un candidato cortado tiene `truncated` establecido.

```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"}` da:

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

Todas las llamadas excepto `list_decoders` se ejecutan en su propio proceso de corta duración. La entrada está limitada a 65.536 caracteres (las claves también) y las expresiones regulares a 1.000. Un `decode` busca durante un máximo de 30 segundos y puede usar 1 GiB de memoria; una llamada `decode_with` puede ejecutarse durante 30 segundos y una llamada `detect_plaintext` durante 10, con 256 MiB cada una. Como máximo se ejecutan a la vez dos decodificaciones y cuatro llamadas de otro tipo. El servidor no lee ni escribe `~/.ciphey`, por lo que no hay archivo de configuración ni caché.

### Claude Desktop

Abre Settings → Developer → Edit Config, añade el servidor a `claude_desktop_config.json` y luego reinicia Claude Desktop. Usa la ruta completa que imprime `which ciphey-mcp` (`where ciphey-mcp` en Windows, por ejemplo `C:\\Users\\you\\.cargo\\bin\\ciphey-mcp.exe`), porque puede que Claude Desktop no vea el `PATH` de tu shell.

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

### Kiro

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

O añade la entrada de abajo a `~/.kiro/settings/mcp.json` (todos los proyectos) o `.kiro/settings/mcp.json` (un proyecto).

### Otros clientes

La mayoría de los clientes MCP aceptan la misma entrada `mcpServers`: un servidor stdio iniciado por `ciphey-mcp` sin argumentos.

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

## Conviene saber

- La detección de texto plano no es perfecta. A menudo se pasa por alto el texto que no está en inglés, y una clave casi acertada (Vigenère en particular) puede seguir produciendo texto que parece inglés. [#1031](https://github.com/bee-san/Ciphey/issues/1031) tiene la evaluación. Si sabes algo sobre la respuesta, una criba (`-r`) o una lista de palabras ayuda mucho.
- Una flag cuyo prefijo no es una palabra de flag (`SEKAI{…}` en lugar de `…CTF{…}` o `flag{…}`) se ve igual que sus propios desplazamientos César, así que bajo César, ROT13 o Atbash Ciphey no puede distinguir cuál es la correcta. Dale el formato como criba: `-r 'SEKAI\{'`.
- Si una respuesta en caché es incorrecta, elimina `~/.ciphey/database.sqlite` para vaciar la caché.
- Si te quedas atascado, pregunta en `#coded-messages` en [Discord](http://discord.skerritt.blog).

## Documentación

- [Documentación de la API en docs.rs](https://docs.rs/ciphey)
- [La carpeta `docs/`](https://github.com/bee-san/ciphey/blob/master/docs), que incluye una [descripción general](https://github.com/bee-san/ciphey/blob/master/docs/ares_overview.md), la [arquitectura](https://github.com/bee-san/ciphey/blob/master/docs/ares_architecture.md), [cómo funciona la búsqueda A*](https://github.com/bee-san/ciphey/blob/master/docs/astar.md) y [cómo se detecta el texto plano](https://github.com/bee-san/ciphey/blob/master/docs/plaintext-detection.md)
- [Documentación de Ciphey 2](https://broadleaf-angora-7db.notion.site/Ciphey2-32d5eea5d38b40c5b95a9442b4425710) en Notion
- [Introducing Ares](https://skerritt.blog/introducing-ares/), la entrada de blog sobre la reescritura en Rust (se llamaba Ares antes de convertirse en Ciphey)

## Contribuir

Los informes de errores, las ideas y las pull requests son bienvenidos en [issues](https://github.com/bee-san/Ciphey/issues). Un nuevo decodificador es una buena primera contribución: elige uno de [#1030](https://github.com/bee-san/Ciphey/issues/1030) y copia la forma de uno existente en [`src/decoders/`](https://github.com/bee-san/ciphey/blob/master/src/decoders). También puedes [patrocinar el proyecto](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="Avatares de las personas que han contribuido a Ciphey"></a>

## Créditos

- [LemmeKnow](https://github.com/swanandx/lemmeknow) de [@swanandx](https://github.com/swanandx) identifica lo que encuentra Ciphey, y [gibberish-or-not](https://github.com/bee-san/gibberish-or-not) decide si es inglés.
- [Rayon](https://github.com/rayon-rs/rayon) ejecuta los decodificadores en paralelo.
- Ciphey comenzó como un proyecto en Python; Python Ciphey 5.x sigue en [PyPI](https://pypi.org/project/ciphey/). Gracias a todos los que trabajaron en él.
- Los vídeos están hechos con [HyperFrames](https://hyperframes.heygen.com/) a partir de grabaciones reales de terminal. El código fuente, las grabaciones y el script de compilación están en [`media/tui-video`](https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video) en la rama `media/readme-videos`.

## Uso de IA

Usamos IA para 2 cosas:

1. La TUI está completamente vibe codeada.
2. Hice que la IA pasara horas investigando cada uno de los retos CTF que existen. Creó una lista de 15.071 CTFs. Luego revisó cada uno de los CTFs y buscó writeups. En esos writeups buscó cualquier cosa relacionada con codificación / decodificación. Después creó tests a partir de ellos. Esto nos permitió aumentar nuestra cobertura de pruebas y asegurarnos de que todos los retos CTF de codificación / decodificación se pueden resolver con esta herramienta.

## Licencia

MIT. Consulta [LICENSE](https://github.com/bee-san/ciphey/blob/master/LICENSE).
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    282

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →