Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
Ciphey — ⚡ कुंजी या सिफर जाने बिना स्वचालित रूप से एन्क्रिप्शन को डिक्रिप्ट करें, एन्कोडिंग को डिकोड करें, और हैश को क्रैक करें ⚡ | Kitploit
उपकरण/GitHubGitHub/bee-san/ciphey
एन्क्रिप्शन/डिक्रिप्शन उपकरणहैश विश्लेषणक्रिप्टोग्राफीCTFपेनिट्रेशन टेस्टिंगलर्निंग और शिक्षाक्रिप्टोग्राफी में शीर्ष #13CTF में शीर्ष #6एन्क्रिप्शन/डिक्रिप्शन उपकरण में शीर्ष #14हैश विश्लेषण में शीर्ष #5
21.6k1.4k19513 दिन पहलेKitploit द्वारा समीक्षित
साझा करें
GitHubbee-san/ciphey

Ciphey

⚡ कुंजी या सिफर जाने बिना स्वचालित रूप से एन्क्रिप्शन को डिक्रिप्ट करें, एन्कोडिंग को डिकोड करें, और हैश को क्रैक करें ⚡

रिपॉजिटरी देखें
<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: Base64 की चार परतें अंदर जाती हैं, Ciphey पूछता है कि क्या 'Ciphey peels back every layer of encoding' ही सादा पाठ है, फिर उसे Base64 → Base64 → Base64 → Base64 पथ के साथ प्रिंट करता है। एक मिनट का टूर देखने के लिए क्लिक करें।"></a>
</p>

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

<p align="center">
  <b>एन्कोड या एन्क्रिप्ट किए गए टेक्स्ट को पेस्ट करें। Ciphey पता लगाता है कि यह कैसे हुआ और आपको सादा पाठ दे देता है।</b><br>
  कोई कुंजी नहीं, कोई सिफर नाम नहीं, कोई संकेत नहीं। Base64, hex, Caesar/ROT13, Vigenère, मोर्स कोड और 19 अन्य, कई परतों की गहराई तक।
</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">इंस्टॉल करें</a> ·
  <a href="#quick-start">त्वरित शुरुआत</a> ·
  <a href="#features">विशेषताएँ</a> ·
  <a href="#use-it-as-a-library">लाइब्रेरी</a> ·
  <a href="#mcp-server-ai-assistants">MCP</a> ·
  <a href="#documentation">दस्तावेज़</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">एक मिनट का टूर देखें</a> (MP4, 61 सेकंड)</sub>
</p>

## इंस्टॉल करें

```bash
cargo install ciphey
```

Linux (x86_64), macOS (Intel और Apple silicon) और Windows (x86_64) के लिए पहले से बने बाइनरीज़ [releases पेज](https://github.com/bee-san/Ciphey/releases/latest) पर उपलब्ध हैं, प्रत्येक के साथ एक `.sha256` चेकसम है।

सोर्स से बिल्ड करने के लिए, आपको एक Rust टूलचेन की आवश्यकता होगी:

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

या इंस्टॉल करना छोड़ें: [Discord सर्वर](http://discord.skerritt.blog) से जुड़ें, `#bots` पर जाएं और `$ciphey <your text>` टाइप करें (`$help` कमांड की सूची दिखाता है)।

## त्वरित शुरुआत

```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
```

पहली बार चलाने पर, एक छोटा सेटअप रंग थीम, परिणाम कैसे दिखाए जाएँ और क्या वर्डलिस्ट का उपयोग करना है, यह पूछता है, और आपके उत्तरों को `~/.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` हर विकल्प को सूचीबद्ध करता है।

## विशेषताएँ

### ⚡ तेज़

<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="एक टर्मिनल Base64 स्ट्रिंग पर time ciphey -d चलाता है। Ciphey 'Ciphey is very fast' और पथ Base64 → Hexadecimal → caesar प्रिंट करता है, और bash real 0m0.157s रिपोर्ट करता है। फिर एक चार्ट Ciphey के 0.19 s (10 रन का माध्यक) की तुलना उसी इनपुट पर Python Ciphey 5.14.0 के 60 s बाद भी कोई उत्तर न मिलने से करता है।"></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/fast.mp4">क्लिप देखें</a> (16 s)</sub>

तीन परतें (पहले ROT13, फिर hex, फिर Base64) 0.16 s में हट जाती हैं, जो एक वास्तविक रिकॉर्डिंग में bash के `time` द्वारा मापा गया है। यहाँ अधिक इनपुट के लिए वही तुलना दी गई है, Python Ciphey 5.14 के विरुद्ध, जिस संस्करण को Ciphey प्रतिस्थापित करता है:

| इनपुट | 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 | 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, गलत उत्तर |
| ROT13 → Hex → Base64 → Base32 | 1.15 s | 60 s के भीतर कोई उत्तर नहीं |

<sub>प्रति इनपुट 10 रन का वास्तविक-समय माध्यक (Python Ciphey: 3) एक साझा 16-CPU Linux मशीन पर, Ciphey 47bd16d6 पर y/N प्रॉम्प्ट बंद करके और प्रति रन एक नया <code>$HOME</code> ताकि इसका कैश मदद न कर सके। प्रत्येक रन 60 s पर सीमित था। स्क्रिप्ट और कच्चे आँकड़े <code>media/readme-videos</code> ब्रांच पर <a href="https://github.com/bee-san/Ciphey/tree/media/readme-videos/media/tui-video/bench"><code>media/tui-video/bench</code></a> में हैं।</sub>

जहाँ दोनों सही उत्तर देते हैं, Ciphey 1.9 से 8.6 गुना तेज़ है। यह गति कहाँ से आती है?

- यह Rust है।
- एक A* खोज सबसे आशाजनक डिकोडर श्रृंखलाओं को पहले आज़माती है।
- प्रत्येक डिकोडर [Rayon](https://github.com/rayon-rs/rayon) के साथ समानांतर में चलता है, एक बार में 10 तक उम्मीदवार टेक्स्ट पर।
- उत्तर `~/.ciphey/database.sqlite` में कैश किए जाते हैं, इसलिए वही इनपुट दूसरी बार मिलीसेकंड में वापस आ जाता है।

### 🧅 परत के बाद परत, किसी कुंजी की आवश्यकता नहीं

Ciphey को यह बताने की आवश्यकता नहीं है कि वह क्या देख रहा है। यह डिकोडरों की श्रृंखलाओं की खोज करता है (hex के अंदर Base64, ROT13 के अंदर, Base64 की चार परतें, इत्यादि) और पहले ऐसे उम्मीदवार पर रुक जाता है जो सादे टेक्स्ट जैसा दिखता है। डिफ़ॉल्ट रूप से यह आपको वह उम्मीदवार दिखाता है और उसे स्वीकार करने से पहले पूछता है (`-d` इसे बंद कर देता है)। इस पृष्ठ के शीर्ष पर दी गई क्लिप चार-परत डिकोड दिखाती है।

एक टाइमर भी है: यदि Ciphey को 5 सेकंड के बाद कुछ नहीं मिलता है, तो यह रुक जाता है और ऐसा बताता है (`-c` सीमा बदलता है)।

यह 24 डिकोडर और क्रैकर जानता है:

| प्रकार | डिकोडर |
| --- | --- |
| Base एन्कोडिंग | Base64 (मानक और URL-सुरक्षित), Base32, Base58 (Bitcoin, Flickr, Monero, Ripple), Base91, Base65536, Z85 |
| अन्य एन्कोडिंग | Hexadecimal, binary, URL (प्रतिशत-एन्कोडिंग), मोर्स कोड, ब्रेल, A1Z26, Citrix CTX1 |
| सिफर | Caesar (ROT13 सहित), ROT47, Atbash, Vigenère (यह कुंजी स्वयं निकाल लेता है), rail fence, उलटा टेक्स्ट |
| विचित्रताएँ | Brainfuck (यह प्रोग्राम चलाता है), अन्य प्रतीकों के साथ लिखा गया मोर्स या binary |

और भी आने वाले हैं: [#1030](https://github.com/bee-san/Ciphey/issues/1030) उन 109 डिकोडरों को ट्रैक करता है जो अभी तक शामिल नहीं हैं।

### 🕵️ जानता है कि उसे क्या मिला

<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="तीन Ciphey रन। Base64 'mount -o username=bee,password=hunter2' में डिकोड होता है, जिसे Mount Command With Clear Credentials के रूप में पहचाना जाता है। Base64 एक otpauth:// लिंक में डिकोड होता है, जिसे Time-Based One-Time Password (TOTP) URI के रूप में पहचाना जाता है। Hex 192.168.0.1 में डिकोड होता है, जिसे 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">क्लिप देखें</a> (21 सेकंड)</sub>

हर उम्मीदवार plaintext [LemmeKnow](https://github.com/swanandx/lemmeknow) से भी गुज़रता है, जो [pyWhat](https://github.com/bee-san/pyWhat) का Rust पोर्ट है और 120 से अधिक फ़ॉर्मैट पहचानता है। इसलिए Ciphey सिर्फ़ स्ट्रिंग को डिकोड नहीं करता, बल्कि आपको बताता है कि वह क्या है: किसी `mount` या `sshpass` कमांड में एक पासवर्ड, एक TOTP सीक्रेट, एक GitHub टोकन या Stripe कुंजी, एक IP या MAC पता, एक ईमेल पता या URL, एक क्रिप्टो वॉलेट, एक AWS ARN, JSON या किसी भी फ़ॉर्मैट में एक CTF फ़्लैग (`flag{…}`, `picoCTF{…}`, `DUCTF{…}`)। LemmeKnow के वे पैटर्न जो केवल यह जाँचते हैं कि किसी स्ट्रिंग में कौन-से अक्षर हैं और वह कितनी लंबी है (उदाहरण के लिए कार्ड और फ़ोन नंबर), उन्हें अनदेखा किया जाता है: डिकोडर का कचरा उनसे हर समय मेल खाता है।

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

### 🎯 क्रिब और रेगेक्स मोड

<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="एक टर्मिनल Base64 स्ट्रिंग पर -r 'picoCTF\{' के साथ ciphey -t चलाता है। Ciphey 'Regex matched: picoCTF\{' रिपोर्ट करता है, 'picoCTF{b4s3_64_1s_fun}' के बारे में पूछता है, और इसे Base64 से डिकोड किए गए plaintext के रूप में प्रिंट करता है।"></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/crib.mp4">क्लिप देखें</a> (14.5 सेकंड)</sub>

यदि आप उत्तर का कुछ हिस्सा जानते हैं (फ़्लैग फ़ॉर्मेट, कोई शब्द जो उसमें होना ही चाहिए, वह कैसे शुरू होता है), तो इसे `-r` के साथ रेगेक्स के रूप में Ciphey को दें। अन्य चेकर बंद हो जाते हैं और केवल वही टेक्स्ट स्वीकार किया जाता है जो मेल खाता है। यह उस plaintext को ढूँढता है जिसे अन्य चेकर छोड़ देते, या जब कई उम्मीदवार plaintext जैसे लगते हैं तो आपके इच्छित वाले पर रुक जाता है: `-r 'picoCTF\{'` के साथ, केवल एक `picoCTF{…}` फ़्लैग ही खोज समाप्त करता है।

`--wordlist words.txt` सटीक मिलान के लिए उसी तरह काम करता है: कोई उम्मीदवार जो फ़ाइल में एक पंक्ति है, plaintext माना जाता है।

### 🎨 आपके टर्मिनल के लिए बनाया गया

पहली बार चलाने पर सेटअप आपको एक रंग थीम चुनने देता है (Capptucin, Darcula, GirlyPop, डिफ़ॉल्ट, या आपके अपने RGB मान) और यह चुनने देता है कि प्रत्येक plaintext के बारे में पूछा जाए या अंत में उम्मीदवारों की सूची मिले। आप इसे [टूर में](https://cdn.jsdelivr.net/gh/bee-san/Ciphey@d41d19946234477346fede14dadf8c351cc469e6/media/tui-video/out/ciphey-tui-promo.mp4) 0:32 से देख सकते हैं। सब कुछ `~/.ciphey/config.toml` में सहेजा जाता है, जिसे आप बाद में संपादित कर सकते हैं।

### 📚 लाइब्रेरी पहले

`ciphey` बाइनरी `ciphey` क्रेट के चारों ओर एक पतला रैपर है। [Discord बॉट](https://github.com/bee-san/discord-bot) भी इसका उपयोग करता है, और आपका कोड भी कर सकता है।

## इसे लाइब्रेरी के रूप में उपयोग करें

`perform_cracking` पूरी खोज चलाता है, जैसे `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}"),
    }
}
```

यह `hello there general (via Base64)` प्रिंट करता है।

### एक डिकोडर

यदि आप जानते हैं कि आप क्या देख रहे हैं, तो उस डिकोडर को कॉल करें। प्रत्येक `ciphey::decoders` में एक फ़ंक्शन है: एन्कोडिंग डिकोड होकर वापस आती हैं, सिफर क्रैक हो जाते हैं, और जो कुंजी लेते हैं वे आपकी कुंजी से डिक्रिप्ट कर सकते हैं।

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

डिकोडर को रन टाइम पर चुनने के लिए, `decode_with` उसका नाम या उपनाम लेता है, और `list_decoders` उन सभी को उनके उपनामों, टैगों और उनके द्वारा ली जाने वाली कुंजी के साथ सूचीबद्ध करता है:

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

कुछ भी फ़िल्टर नहीं किया जाता: आपको वही मिलता है जो डिकोडर खोज को सौंपता है। Ciphey के plaintext जाँच जिस उम्मीदवार को स्वीकार करते हैं वह पहले आता है और उस पर एक `detection` होता है; यदि वे किसी को भी स्वीकार नहीं करते, तो आपको बिना चिह्नित डिकोडिंग मिलती हैं, जिन्हें आपको स्वयं आँकना है (मान लीजिए सभी 25 Caesar shifts, हालाँकि कई कुंजियों वाले crackers केवल अपने सर्वश्रेष्ठ कुछ ही सौंपते हैं)।

### क्या यह plaintext है?

`detect_plaintext` उन जाँचों को चलाता है जिनका उपयोग खोज करती है (एक regex crib, एक wordlist, LemmeKnow, JSON, सामान्य पासवर्ड, अंग्रेज़ी और कोड) और बताता है कि किसने पाठ को स्वीकार किया और उसे क्या समझा:

```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` इस सब का भ्रमण कराता है, और `cargo run --example decode -- list` डिकोडरों की सूची दिखाता है।

- `perform_cracking` `master` पर `Result<Option<DecoderResult>, CipheyError>` लौटाता है ([#915](https://github.com/bee-san/Ciphey/pull/915)), और एकल-डिकोडर तथा डिटेक्शन फ़ंक्शन अभी तक केवल `master` पर ही हैं। crates.io पर अंतिम रिलीज़ (0.12.0) अभी भी `Option<DecoderResult>` लौटाती है, इसलिए अगली रिलीज़ तक git संस्करण का उपयोग करें: `ciphey = { git = "https://github.com/bee-san/Ciphey" }`।
- कॉन्फ़िग प्रोसेस के लिए वैश्विक है। पहली कॉल का `Config` हर बाद की कॉल के लिए उपयोग होता है, और एकल डिकोडर भी इसका पालन करते हैं (एक `regex` क्रिब, एक वर्डलिस्ट)। वे कभी प्रॉम्प्ट नहीं करते।
- API का दस्तावेज़ीकरण [docs.rs](https://docs.rs/ciphey) पर है।

## MCP सर्वर (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="एक AI सहायक (Kiro CLI) से CTF चुनौती से एक Base64 स्ट्रिंग डिकोड करने के लिए कहा जाता है। यह MCP के माध्यम से ciphey के decode टूल को कॉल करता है, जो प्लेनटेक्स्ट flag{ciphey_speaks_mcp} और उपयोग किए गए डिकोडर, Base64 → Hexadecimal → caesar key 13 के साथ, लौटाता है। सहायक फिर फ़्लैग के साथ उत्तर देता है। 30-सेकंड का वीडियो देखने के लिए क्लिक करें।"></a>

<sub>▶ <a href="https://cdn.jsdelivr.net/gh/bee-san/Ciphey@5aa9760b2912611755d037c01b9d2ed14fd3bf81/media/mcp-video/out/ciphey-mcp.mp4">वीडियो देखें</a> (29.5 सेकंड)। चैट ciphey-mcp के साथ एक वास्तविक Kiro CLI सत्र को फिर से चलाती है।</sub>

`ciphey-mcp` एक [Model Context Protocol](https://modelcontextprotocol.io) सर्वर है, इसलिए Claude Desktop और Kiro जैसे AI सहायक Ciphey के साथ टेक्स्ट डिकोड कर सकते हैं। यह `mcp` फ़ीचर के पीछे है, इसलिए सामान्य `ciphey` बिल्ड इसे शामिल नहीं करता:

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

`mcp` फ़ीचर अभी किसी crates.io रिलीज़ में नहीं है (0.12.0 नवीनतम है), इसलिए अगली रिलीज़ तक इसे git से इंस्टॉल करें: `cargo install --git https://github.com/bee-san/Ciphey ciphey --features mcp --bin ciphey-mcp`।

यह चार टूल प्रदान करता है:

- `decode` तब `text` को डिकोड करता है जब आपको पता नहीं होता कि इसे कैसे एनकोड किया गया था, और `plaintext` तथा उपयोग किए गए डिकोडरों का `path` लौटाता है, जिसमें Caesar shift जैसी कुंजियाँ शामिल होती हैं। वैकल्पिक आर्ग्युमेंट: `timeout_secs` (1 से 30, डिफ़ॉल्ट 10) और `regex`, एक crib जिससे plaintext का मेल खाना चाहिए, जैसे `flag\{`।
- `decode_with` आपके द्वारा चुने गए एक डिकोडर को `text` पर चलाता है: इसे `decoder` की id, नाम या कोई alias दें (`base64`, `rot13`, `vigenere`, `xor_single_byte`, ...)। `key` के बिना यह टेक्स्ट को डिकोड करता है, या हर कुंजी आज़माकर सिफ़र को क्रैक करता है; कुंजी के साथ यह डिक्रिप्ट करता है, उन सिफ़रों के लिए जो कुंजी लेते हैं (`13`, `LEMON`, `a=5, b=8`, `rails=3, offset=1`)। यह हर उम्मीदवार डिकोडिंग और यह कि प्रत्येक Ciphey के plaintext जाँच में पास होती है या नहीं, लौटाता है। `regex` उसी तरह काम करता है जैसे `decode` के लिए।
- `detect_plaintext` जाँचता है कि `text` पहले से ही plaintext है या नहीं, बिना इसे डिकोड किए, और बताता है कि किस checker ने इसे स्वीकार किया, उसने इसे क्या समझा और, LemmeKnow के फ़ॉर्मेट के लिए, यह कितना निश्चित है। वैकल्पिक आर्ग्युमेंट: `checkers` (`lemmeknow`, `json`, `password`, `english` और `code` में से कोई भी, डिफ़ॉल्ट रूप से सभी पाँच), English checker की `sensitivity` (`low`, `medium` या `high`) और एक `regex` crib।
- `list_decoders` Ciphey द्वारा समर्थित एनकोडिंग और सिफ़रों की सूची देता है, साथ में वे id और alias जो `decode_with` लेता है और प्रत्येक ऐसे सिफ़र का कुंजी फ़ॉर्मेट जो कुंजी लेता है।

एक `decode` परिणाम ऐसा दिखता है। `status` `decoded`, `not_found` या `timed_out` होता है।

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

`decode_with` को `{"decoder": "rot13", "text": "Uryyb jbeyq"}` के साथ दिए जाने पर नीचे परिणाम मिलता है। `status` का मान `plaintext_found`, `no_plaintext` (कोई भी उम्मीदवार जाँच में पास नहीं हुआ, इसलिए आप स्वयं उनका आकलन करें) या `no_candidates` (पाठ उस डिकोडर के प्रारूप में नहीं है) होता है। एक परिणाम में अधिकतम 100 उम्मीदवार और उनके पाठ के 65,536 अक्षर होते हैं; `total_candidates` बताता है कि कुल कितने थे, और जिस उम्मीदवार को काटा गया है उसके लिए `truncated` सेट होता है।

```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` को `{"text": "192.168.0.1"}` के साथ निष्पादित करने पर प्राप्त होता है:

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

---

[Read more](https://github.com/bee-san/ciphey)
टूल डाउनलोड करें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    911
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    548
  • 3

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    366
  • 4

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    362
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    311
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    287

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →