KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agent #developer-tools #codex #typescript #cli #deepseek-harness #claude-code #ai-agents #mcp #rust

bruteforce-enigma

★ 27 Open GitHub ↗

A tool for cracking and bruteforcing Enigma ciphers.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Enigma Bruteforcer

A tool for cracking and bruteforcing ciphertext-only enigma ciphers. The ultimate aim of this tool is to be as fast as possible on a household multi-core machine.

Currently breaks ciphers where the plugboard is already known.

Best [performance](#Performance) so far:

| Core i7 2.5GHz, 4 threads | 252.30 million chars / second |
|-|-|

# Installation

Clone or download the project. Open up `crack_enigma.cpp` and in the `main` function place your code (see [Usage](#Usage) below). Compile by running `make` or `make crack_enigma` and run with `./crack_enigma`.

To import into an existing project, you need the the contents of the `source/` and `include/` folders. `include/bruteforce-enigma.h` adds a nicer interface and multithreading, but doesn't contain any core functionality. Compile and link with the .cpp files from `source/`, but you can only compile against one quadgram language file (`qgr.cpp` or `de_qgr.cpp`) at a time. Requires compiling with C++20 and pthreads.

# Table of Contents

[About](#About) 
[Usage](#Usage) 
[Performance](#Performance) 
[Future Plans](#Future-Plans) 
[Why I created this tool](#Why-I-created-this-tool) 
[License](#License)

# About

This tool assumes a working knowledge of enigma terminology (there is no wizard). Some good resources I have used for learning about enigma are [Wikipedia](https://en.wikipedia.org/wiki/Enigma_machine), [Practical Cryptography](http://practicalcryptography.com/ciphers/enigma-cipher/), and [Crypto Museum](https://www.cryptomuseum.com/crypto/enigma/).

It also expects basic C++ programming knowledge so that you can modify the source code for your particular needs. There is no command line interface. I haven't written documentation yet, so you're expected to read the code if you're going beyond the most basic usage.

## Features
* Decipher with a known setting
* Crack ring or rotor positions
* Crack rotors
* Quick solve or full bruteforce
* Score by IOC, quadgram, or a custom scoring function
* Change the number of top scores considered while breaking

## Flaws
* Does not support the use of cribs
* Does not crack plugboards
* Does not support pausing and resuming a decryption
* Does not progressively show the scores (it slows down the decryption)
* Wheel order is in reverse and numerical positions start at 0 (I have to fix these to match the norm)

## Available Models

Enigma model definitions can be found in `models.cpp`. The list includes:
* M3 (rotors I, II, III, IV, and V)
* Kriegsmarine (M3 with rotors VI, VII, and VIII added)
* M4
* Enigma I
* Norenigma
* Sondermaschine
* Railway
* CrypTool Railway (different notches and stator)
* CrypTool M3 (adds reflector UKWA to Kriegsmarine)
* Commercial Enigma
* Tirpitz

The following rotor definitions are included, but the unique machine behaviors have not been implemented.
* Swiss K
* Enigma KD
* Zahlwerk
* Enigma G-111
* Enigma G-312
* Enigma G-260

## Compatibility with Other Enigma Tools

It is often helpful to compare several enigma decrypters at the same time. Below is a list of some decrypters I know of. Most online tools follow the wheel order of the historical Enigma, which runs right to left. This one doesn't, so you'll have to reverse the order of the rotors you're testing. Additionally, most online tools start ring and rotor positions at 1 (if not using letters) while this tool starts at 0.

* [cryptii](https://cryptii.com/)
* [CrypTool-Online](https://www.cryptool.org/en/cto/enigma-step-by-step)
* [dCode](https://www.dcode.fr/enigma-machine-cipher)
* [Enigma Simulator](https://www.ciphermachinesandcryptology.com/en/enigmasim.htm) (Dirk Rijmenants)
* [Practical Cryptography](http://practicalcryptography.com/ciphers/enigma-cipher/)
* [pycipher](https://github.com/jameslyons/pycipher)
* [Universal Enigma](http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html)

# Usage

The abstract signature is

`Enigma(stator, rotor1, rotor2, rotor3, reflector, plugboard, rotor_positions, ring_positions)`

For the concrete signatures see *bruteforce-enigma.h*. The model names are located in *models.h* (definitions in *models.cpp*).

**Decipher with a known setting**
```Cpp
Ciphertext ct = "odlio qsapd tbttn ueokz jbqzw hlynd mmbvn dlanx tvrny lvqmj kovre v";
Plugboard plug = "bq cr di ej kw mt os px uz gh";

Enigma enigma {ETW_ABCDEF, m3_I, m3_III, m3_I, m3_UKWB, plug, "BLQ", "BEC"};

Ciphertext pt = enigma.encrypt(ct);
std::cout << pt;
```

To decipher an m4 model, replace `Enigma` above with `Enigma4`, like so.
```Cpp
Enigma4 enigma {ETW_ABCDEF, m3_I, m3_III, m3_I, m4_beta, m4_UKWB_thin, plug, "BLQA", "BECA"};
```

**Cracking unknown ring and rotor positions**

The smart decipher should be sufficient for almost all ciphers. It uses a similar algorithm that [Practical Cryptography](http://www.practicalcryptography.com/cryptanalysis/breaking-machine-ciphers/cryptanalysis-enigma-part-2/) does, by first finding the best rotor combination and position, and then from the top results finding the best ring positions.