Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ciphey — ⚡ Descriptografa automaticamente criptografias sem conhecer a chave ou cifra, decodifica codificações e quebra hashes ⚡ | Kitploit
Ferramentas/GitHubGitHub/bee-san/ciphey
Ferramentas de Criptografia/DescriptografiaAnálise de HashCriptografiaCTFTestes de PenetraçãoAprendizado e EducaçãoTop em Criptografia nº13Top em CTF nº6Top em Ferramentas de Criptografia/Descriptografia nº14
21.6k1.4k195há 12 diasRevisado pelo Kitploit
Compartilhar
Top em Análise de Hash nº5
GitHubbee-san/ciphey

Ciphey

⚡ Descriptografa automaticamente criptografias sem conhecer a chave ou cifra, decodifica codificações e quebra hashes ⚡

Ver Repositório
<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 em um terminal: entram quatro camadas de Base64, o Ciphey pergunta se 'Ciphey peels back every layer of encoding' é o texto simples e então o imprime com o caminho Base64 → Base64 → Base64 → Base64. Clique para assistir ao tour de um minuto."></a>
</p>

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

<p align="center">
  <b>Cole um texto que foi codificado ou criptografado. O Ciphey descobre como e entrega o texto simples.</b><br>
  Sem chave, sem nome de cifra, sem dicas. Base64, hex, Caesar/ROT13, Vigenère, código Morse e mais 19, em várias camadas de profundidade.
</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">Início rápido</a> ·
  <a href="#features">Recursos</a> ·
  <a href="#use-it-as-a-library">Biblioteca</a> ·
  <a href="#mcp-server-ai-assistants">MCP</a> ·
  <a href="#documentation">Documentação</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">Assista ao tour de um minuto</a> (MP4, 61 s)</sub>
</p>

## Instalar

```bash
cargo install ciphey
```

Binários pré-compilados para Linux (x86_64), macOS (Intel e Apple silicon) e Windows (x86_64) estão na [página de releases](https://github.com/bee-san/Ciphey/releases/latest), cada um com um checksum `.sha256`.

Para compilar a partir do código-fonte, você precisa de uma toolchain Rust:

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

Ou pule a instalação: entre no [servidor Discord](http://discord.skerritt.blog), vá para `#bots` e digite `$ciphey <seu texto>` (`$help` lista os comandos).

## Início 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
```

Na primeira vez que você o executa, uma breve configuração solicita um tema de cores, como você deseja que os resultados sejam exibidos e se deve usar uma wordlist, e salva suas respostas em `~/.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` lista todas as opções.

## Recursos

### ⚡ 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="Um terminal executa time ciphey -d em uma string Base64. O Ciphey imprime 'Ciphey is very fast' e o caminho Base64 → Hexadecimal → caesar, e o bash reporta real 0m0.157s. Um gráfico então compara os 0,19 s do Ciphey (a mediana de 10 execuções) com nenhuma resposta após 60 s para o Python Ciphey 5.14.0 na mesma entrada."></a>

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

Três camadas (ROT13, depois hex, depois Base64) são removidas em 0,16 s, medido pelo `time` do bash em uma gravação real. Aqui está a mesma comparação para mais entradas, contra o Python Ciphey 5.14, a versão que o Ciphey substitui:

| 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 | nenhuma resposta em 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, resposta errada |
| ROT13 → Hex → Base64 → Base32 | 1,15 s | nenhuma resposta em 60 s |

<sub>Mediana de tempo real de 10 execuções por entrada (Python Ciphey: 3) em uma máquina Linux compartilhada de 16 CPUs, Ciphey em 47bd16d6 com o prompt y/N desativado e um <code>$HOME</code> novo por execução para que seu cache não possa ajudar. Cada execução foi limitada a 60 s. O script e os números brutos estão em <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> no branch <code>media/readme-videos</code>.</sub>

Onde ambos chegam à resposta correta, o Ciphey é de 1,9 a 8,6 vezes mais rápido. De onde vem a velocidade?

- É Rust.
- Uma busca A* tenta primeiro as cadeias de decodificadores mais promissoras.
- Cada decodificador roda em paralelo com [Rayon](https://github.com/rayon-rs/rayon), em até 10 textos candidatos por vez.
- As respostas são armazenadas em cache em `~/.ciphey/database.sqlite`, então a mesma entrada uma segunda vez retorna em milissegundos.

### 🧅 Camada após camada, sem necessidade de chave

O Ciphey não precisa que lhe digam o que está vendo. Ele busca cadeias de decodificadores (Base64 dentro de hex dentro de ROT13, quatro camadas de Base64, e assim por diante) e para no primeiro candidato que parece texto simples. Por padrão, ele mostra esse candidato e pergunta antes de aceitá-lo (`-d` desativa isso). O clipe no topo desta página mostra uma decodificação de quatro camadas.

Há também um temporizador: se o Ciphey não encontrar nada após 5 segundos, ele para e avisa (`-c` altera o limite).

Ele conhece 24 decodificadores e quebradores:

| Tipo | Decodificadores |
| --- | --- |
| Codificações Base | Base64 (padrão e URL-safe), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| Outras codificações | Hexadecimal, binário, URL (percent-encoding), código Morse, Braille, A1Z26, Citrix CTX1 |
| Cifras | César (incluindo ROT13), ROT47, Atbash, Vigenère (ele descobre a chave sozinho), cerca de trilhos, texto invertido |
| Excentricidades | Brainfuck (ele executa o programa), Morse ou binário escrito com outros símbolos |

Mais estão a caminho: [#1030](https://github.com/bee-san/Ciphey/issues/1030) acompanha 109 decodificadores que ainda não estão incluídos.

### 🕵️ Sabe o que encontrou

<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="Três execuções do Ciphey. Base64 decodifica para 'mount -o username=bee,password=hunter2', identificado como um Comando Mount Com Credenciais em Texto Simples. Base64 decodifica para um link otpauth://, identificado como uma URI de Senha de Uso Único Baseada em Tempo (TOTP). Hex decodifica para 192.168.0.1, identificado como um Endereço de Protocolo de Internet (IP) Versão 4."></a>

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

Todo texto simples candidato também passa pelo [LemmeKnow](https://github.com/swanandx/lemmeknow), o port em Rust do [pyWhat](https://github.com/bee-san/pyWhat), que reconhece mais de 120 formatos. Assim, o Ciphey não apenas decodifica a string, mas também informa o que ela é: uma senha em um comando `mount` ou `sshpass`, um segredo TOTP, um token do GitHub ou chave do Stripe, um endereço IP ou MAC, um endereço de e-mail ou URL, uma carteira de criptomoedas, um ARN da AWS, JSON ou uma flag de CTF em qualquer formato (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`). Os padrões do LemmeKnow que apenas verificam quais caracteres uma string possui e seu comprimento (números de cartão e telefone, por exemplo) são ignorados: o lixo dos decodificadores corresponde a eles o tempo todo.

```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 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="Um terminal executa ciphey -t em uma string Base64 com -r 'picoCTF\{'. O Ciphey informa 'Regex matched: picoCTF\{', pergunta sobre 'picoCTF{b4s3_64_1s_fun}' e o exibe como texto simples, decodificado com Base64."></a>

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

Se você conhece parte da resposta (o formato da flag, uma palavra que precisa estar lá, como ela começa), forneça-a ao Ciphey como uma regex com `-r`. Os outros verificadores são desativados e apenas o texto que corresponder é aceito. Isso encontra texto simples que os outros verificadores ignorariam, ou para no que você quer quando vários candidatos parecem texto simples: com `-r 'picoCTF\{'`, apenas uma flag `picoCTF{…}` encerra a busca.

`--wordlist words.txt` funciona da mesma forma para correspondências exatas: um candidato que é uma linha do arquivo conta como texto simples.

### 🎨 Feito para o seu terminal

A configuração de primeira execução permite escolher um tema de cores (Capptucin, Darcula, GirlyPop, o padrão, ou seus próprios valores RGB) e escolher entre ser questionado sobre cada texto simples ou receber uma lista de candidatos no final. Você pode vê-lo [no tour](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) a partir de 0:32. Tudo é salvo em `~/.ciphey/config.toml`, que você pode editar depois.

### 📚 Biblioteca em primeiro lugar

O binário `ciphey` é um wrapper fino em torno da crate `ciphey`. O [bot do Discord](https://github.com/bee-san/discord-bot) também a utiliza, e o seu código também pode.

## Use como biblioteca

`perform_cracking` executa toda a busca, assim como o binário `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}"),
    }
}
```

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

### Um decodificador

Se você sabe com o que está lidando, chame esse decodificador. Cada um é uma função em `ciphey::decoders`: codificações são retornadas decodificadas, cifras são quebradas, e as que exigem uma chave podem descriptografar com a sua.

```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 escolher o decodificador em tempo de execução, `decode_with` recebe o seu nome ou um alias, e `list_decoders` lista todos eles com os seus aliases, tags e a chave que recebem:

```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 é filtrado: você recebe o que o decodificador entrega à busca. O primeiro texto em claro que as verificações do Ciphey aceitam vem primeiro e carrega uma `detection`; se nenhuma aceitar, você recebe as decodificações sem marcação, para julgar por conta própria (todas as 25 rotações de César, por exemplo, embora crackers com muitas chaves entreguem apenas as melhores).

### É texto em claro?

`detect_plaintext` executa as verificações que a busca utiliza (um crib regex, uma wordlist, LemmeKnow, JSON, senhas comuns, inglês e código) e informa qual delas aceitou o texto e pelo que o tomou:

```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` percorre tudo isso, e `cargo run --example decode -- list` lista os decodificadores.

- `perform_cracking` retorna `Result<Option<DecoderResult>, CipheyError>` no `master` ([#915](https://github.com/bee-san/Ciphey/pull/915)), e as funções de decodificador único e de detecção estão apenas no `master` até agora. A última versão no crates.io (0.12.0) ainda retorna `Option<DecoderResult>`, então até a próxima versão use a versão do git: `ciphey = { git = "https://github.com/bee-san/Ciphey" }`.
- A configuração é global para o processo. O `Config` da primeira chamada é usado para todas as chamadas posteriores, e os decodificadores únicos também o seguem (um crib `regex`, uma wordlist). Eles nunca solicitam entrada.
- A API está documentada em [docs.rs](https://docs.rs/ciphey).

## Servidor MCP (assistentes 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="Um assistente de IA (Kiro CLI) recebe o pedido de decodificar uma string Base64 de um desafio CTF. Ele chama a ferramenta decode do ciphey via MCP, que retorna o texto simples flag{ciphey_speaks_mcp} e os decodificadores usados, Base64 → Hexadecimal → caesar com chave 13. O assistente então responde com a flag. Clique para assistir ao 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">Assista ao vídeo</a> (29,5 s). O chat reproduz uma sessão real do Kiro CLI com o ciphey-mcp.</sub>

`ciphey-mcp` é um servidor [Model Context Protocol](https://modelcontextprotocol.io), para que assistentes de IA como Claude Desktop e Kiro possam decodificar texto com o Ciphey. Ele está por trás da feature `mcp`, então a build normal do `ciphey` não o inclui:

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

O recurso `mcp` ainda não está em uma versão do crates.io (a 0.12.0 é a mais recente), então até a próxima, instale a partir do git: `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`.

Ele fornece quatro ferramentas:

- `decode` decodifica `text` quando você não sabe como ele foi codificado, e retorna o `plaintext` e o `path` dos decodificadores usados, com chaves como o deslocamento de César. Argumentos opcionais: `timeout_secs` (1 a 30, padrão 10) e `regex`, uma dica que o texto simples deve corresponder, como `flag\{`.
- `decode_with` executa um decodificador que você escolher sobre `text`: forneça o id, o nome ou um alias do `decoder` (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...). Sem uma `key` ele decodifica o texto, ou quebra a cifra tentando todas as chaves; com uma, ele descriptografa, para cifras que aceitam uma chave (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`). Ele retorna todas as decodificações candidatas e se cada uma passa na verificação de texto simples do Ciphey. `regex` funciona como em `decode`.
- `detect_plaintext` verifica se `text` já é texto simples, sem decodificá-lo, e informa qual verificador o aceitou, pelo que o tomou e, para os formatos do LemmeKnow, quão certo ele está. Argumentos opcionais: `checkers` (qualquer um entre `lemmeknow`, `json`, `password`, `english` e `code`, por padrão todos os cinco), `sensitivity` do verificador de inglês (`low`, `medium` ou `high`) e uma dica `regex`.
- `list_decoders` lista as codificações e cifras suportadas pelo Ciphey, com os ids e aliases que `decode_with` aceita e o formato de chave de cada cifra que aceita uma.

Um resultado de `decode` se parece com isto. `status` é `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` com `{"decoder": "rot13", "text": "Uryyb jbeyq"}` fornece o resultado abaixo. `status` é `plaintext_found`, `no_plaintext` (nenhum dos candidatos passou na verificação, então avalie-os você mesmo) ou `no_candidates` (o texto não está no formato desse decodificador). Um resultado contém no máximo 100 candidatos e 65.536 caracteres do texto deles; `total_candidates` indica quantos havia, e um candidato cortado tem `truncated` definido.

```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` com `{"text": "192.168.0.1"}` retorna:

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

Todas as chamadas, exceto `list_decoders`, são executadas em seu próprio processo de curta duração. A entrada é limitada a 65.536 caracteres (as chaves também) e as regexes a 1.000. Um `decode` procura por no máximo 30 segundos e pode usar 1 GiB de memória; uma chamada `decode_with` pode ser executada por 30 segundos e uma chamada `detect_plaintext` por 10, com 256 MiB cada. No máximo dois decodes e quatro outras chamadas são executados ao mesmo tempo. O servidor não lê nem grava em `~/.ciphey`, portanto não há arquivo de configuração nem cache.

### Claude Desktop

Abra Configurações → Desenvolvedor → Editar Configuração, adicione o servidor ao `claude_desktop_config.json` e reinicie o Claude Desktop. Use o caminho completo exibido por `which ciphey-mcp` (`where ciphey-mcp` no Windows, por exemplo `C:\\Users\\you\\.cargo\\bin\\ciphey-mcp.exe`), pois o Claude Desktop pode não enxergar o `PATH` do seu shell.

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

### Kiro

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

Ou adicione a entrada abaixo a `~/.kiro/settings/mcp.json` (todos os projetos) ou `.kiro/settings/mcp.json` (um projeto).

### Outros clientes

A maioria dos clientes MCP aceita a mesma entrada `mcpServers`: um servidor stdio iniciado por `ciphey-mcp` sem argumentos.

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

## Bom saber

- A detecção de texto simples não é perfeita. Textos que não estão em inglês costumam passar despercebidos, e uma chave quase correta (Vigenère em particular) ainda pode produzir um texto que parece inglês. [#1031](https://github.com/bee-san/Ciphey/issues/1031) tem a avaliação. Se você souber algo sobre a resposta, uma crib (`-r`) ou uma wordlist ajuda bastante.
- Uma flag cujo prefixo não é uma palavra de flag (`SEKAI{…}` em vez de `…CTF{…}` ou `flag{…}`) parece igual aos seus próprios deslocamentos de César, então sob César, ROT13 ou Atbash o Ciphey não consegue dizer qual está correta. Informe o formato como crib: `-r 'SEKAI\{'`.
- Se uma resposta em cache estiver errada, exclua `~/.ciphey/database.sqlite` para limpar o cache.
- Se você estiver travado, pergunte em `#coded-messages` no [Discord](http://discord.skerritt.blog).

## Documentação

- [Documentação da API em docs.rs](https://docs.rs/ciphey)
- [A pasta `docs/`](https://github.com/bee-san/ciphey/blob/master/docs), incluindo uma [visão geral](https://github.com/bee-san/ciphey/blob/master/docs/ares_overview.md), a [arquitetura](https://github.com/bee-san/ciphey/blob/master/docs/ares_architecture.md), [como a busca A* funciona](https://github.com/bee-san/ciphey/blob/master/docs/astar.md) e [como o texto simples é detectado](https://github.com/bee-san/ciphey/blob/master/docs/plaintext-detection.md)
- [Documentação do Ciphey 2](https://broadleaf-angora-7db.notion.site/Ciphey2-32d5eea5d38b40c5b95a9442b4425710) no Notion
- [Apresentando o Ares](https://skerritt.blog/introducing-ares/), o post do blog sobre a reescrita em Rust (ele se chamava Ares antes de se tornar Ciphey)

## Contribuindo

Relatos de bugs, ideias e pull requests são bem-vindos nas [issues](https://github.com/bee-san/Ciphey/issues). Um novo decodificador é uma boa primeira contribuição: escolha um da [#1030](https://github.com/bee-san/Ciphey/issues/1030) e copie a estrutura de um existente em [`src/decoders/`](https://github.com/bee-san/ciphey/blob/master/src/decoders). Você também pode [patrocinar o projeto](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 das pessoas que contribuíram com o Ciphey"></a>

## Créditos

- [LemmeKnow](https://github.com/swanandx/lemmeknow), de [@swanandx](https://github.com/swanandx), identifica o que o Ciphey encontra, e [gibberish-or-not](https://github.com/bee-san/gibberish-or-not) decide se é inglês.
- [Rayon](https://github.com/rayon-rs/rayon) executa os decodificadores em paralelo.
- O Ciphey começou como um projeto em Python; o Python Ciphey 5.x ainda está no [PyPI](https://pypi.org/project/ciphey/). Obrigado a todos que trabalharam nele.
- Os vídeos são feitos com [HyperFrames](https://hyperframes.heygen.com/) a partir de gravações reais de terminal. O código-fonte, as gravações e o script de build estão em [`media/tui-video`](https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video) no branch `media/readme-videos`.

## Uso de IA

Usamos IA para 2 coisas:

1. A TUI é inteiramente vibe coded.
2. Fiz a IA passar horas pesquisando cada desafio de CTF existente. Ela criou uma lista de 15.071 CTFs. Depois percorreu cada CTF e procurou writeups. Nesses writeups, procurou qualquer coisa relacionada a codificação/decodificação. Em seguida, criou testes a partir disso. Isso nos permitiu aumentar nossa cobertura de testes e garantir que todos os desafios de codificação/decodificação de CTF sejam solucionáveis com esta ferramenta.

## Licença

MIT. Veja [LICENSE](https://github.com/bee-san/ciphey/blob/master/LICENSE).
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    496
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    394
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    258
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de testes de penetração autónoma com multiagentes de IA que executa reconhecimento, descoberta de superfície de ataque, validação de exploração e entrega de relatórios com evidências.

    254

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →