enigma-cli 1.0.0

A command-line interface for an Enigma machine simulator. Configurable with any reflector, number of rotors, and plugboard pairs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

# Enigma Machine

## Description
### Introduction
The enigma was an encryption machine used in and post WWII. It used physical rotors to encode and decode message. My implementation is for the "Glühlampenmaschine" and later models; Complete with plugboard, rotors, and reflector. The enigma machine was deemed unbreakable at the time due it it's complexity but it's cipher is not secure by today's standards. 

### My Implementation
I have implemented the enigma machine as a command line tool using rust and standard library (std::env). My main goal was to create a command line interface to gain experience parsing arguments and flags to configure the encoding of the message. There are no other dependencies. 

### Soruces
- [Wikipedia 1 - Enigma Page](https://en.wikipedia.org/wiki/Enigma_machine)
- [Wikipedia 2 - Rotors and Internals](https://en.wikipedia.org/wiki/Enigma_rotor_details)

## Using
### Example
This example will decode "JDPEN XCJJO" into Hello World. 
*This can be found in the help page.*
```bash
./enigma --rotor "EKMFLGDQVZNTOWYHXUSPAIBRCJ" V A --rotor "AJDKSIRUXBLHWTMCQGZNPYFVOE" E A --rotor "BDFHJLCPRTXVZNYEIWGAKMUSQO" Q A --reflector "YR UH QS LD PX NG OK MI EB FZ CW VJ AT" --message "JDPEN XCJJO"
OUTPUT: "HELLO WORLD"
```
### Flags
#### --rotor | -r
Use `--rotor ENCODING TURNOVER POSITION` to add and configure a rotor. 

`ENCODING` is the encoding of the rotor. This is a string of 26 characters. Each character is a letter in the alphabet. A letter can only be used once but can be used in any order.

`TURNOVER` is the letter that will cause the next rotor to turn. This is a single character.

`POSITION` is the starting position of the rotor. This is a single character.
  
*You can have as many rotors as you want.*

###### Example:
```bash
./enigma ... --rotor "EKMFLGDQVZNTOWYHXUSPAIBRCJ" D A --rotor "AJDKSIRUXBLHWTMCQGZNPYFVOE" F B --rotor "BDFHJLCPRTXVZNYEIWGAKMUSQO" E C``
```

#### --reflector | -rf
Use `--reflector "PAIRS"` to configure the reflector.

`PAIRS` represents the pairs of letters that are connected in the reflector (required for symmetrical encryption). Each pair are two letters separated by a space. Each letter can only be used once but can be used in any order.

*The reflector must be included*

###### Example:
```bash
./enigma ... --reflector "AB CD EF GH IJ KL MN OP QR ST UV WX YZ"
```

#### --message | -m
Use `--message "MESSAGE"` to set the message to be encoded.

`MESSAGE` is the message to be encoded. This is a string of characters. Any non-alphabetic characters will be ignored and passed through.

*The message must be included*

###### Example:
```bash
./enigma ... --message "HELLO WORLD"
```

#### --plugboard | -pb
Use `--plugboard "PAIRS"` to configure the plugboard.

`PAIRS` represents the pairs of letters that are connected in the plugboard. Each pair are two letters separated by a space. Each letter can only be used once but can be used in any order. You can have as many pairs as you want.

*The plugboard is optional*

###### Example:
```bash
./enigma ... --plugboard "AB CD EF GH IJ KL MN OP QR ST UV WX YZ"
```

#### --help | -h
Use `--help` to print the help page.

*All other arguments will be ignored*

###### Example:
```bash
./enigma --help
```

#### --state | -s
Use `--state` to print the finial state of the enigma machine after encoding the message.

*This is optional*

###### Example:
```bash
./enigma ... --state
```

## Errors
I tried to make the error messages informative. I will not show them all here but this is an example:
```bash
$ ./enigma wooooop -rotor abcdefghijklmnopqrstuvwxyz a y -rotor abc a a
["$", "wooooop", "-rotor", "abcdefghijklmnopqrstuvwxyz", "a", "y", "-rotor", "abc", "a", "a"]
Error parsing rotor 2.
Encoding must be 26 characters long.
```


## Building
### Installation 
Clone the repo, build and run. (Cargo required)
```bash
$ git clone https://GitHub.com/Andrew-McCall/enigma-rs.git
$ cd enigma-rs
$ cargo build
```

### Cargo Build
Use `cargo build --release` to build the binary. 
```bash
$ ./enigma [flags]
```
The binary will be located in `target/release/enigma`.
### Cargo Run
Use `cargo run --release -- [flags]` to build and run the binary with one command.

## License
MIT License
Copyright (c) 2023 Andrew McCall