Enigma Machine Emulator

110 Views, 2 Favorites, 0 Comments

Enigma Machine Emulator

The Enigma Machine Simulator is a visually appealing, interactive application that emulates the functionality of the historical Enigma machine, a cipher device used during World War II for encrypting and decrypting messages. Built using Pygame, the simulator provides a user-friendly interface to explore the Enigma's cryptographic process, including its rotors, plugboard, and reflector. The interface is designed with a vintage aesthetic, featuring a gradient background, gold accents, and a metallic panel look to evoke the feel of the original machine.

Key Features:

Rotors: Three simulated rotors (I, II, III) with visible letter strips that move as the rotors rotate, showing the current letter in gold and surrounding letters in white. The rotors step with each keypress, mimicking the mechanical advancement of the Enigma.
Plugboard: A customizable plugboard where users can swap letter pairs by clicking keys in plugboard mode. Each pair is connected by a colored line (with 10 distinct colors for up to 10 pairs), and the paired letters are highlighted in the same color as their connecting line.
Keyboard: An on-screen keyboard with circular keys that light up in yellow when pressed during typing, or in the pair's color when configuring the plugboard.
Input/Output: Two text boxes display the input message and its encrypted/decrypted output, limited to 20 characters to fit the UI, with spaces supported.
Visual Feedback: Dynamic visual elements include moving rotor letters, highlighted keys, and colored plugboard connections, enhancing the interactive experience.
Plugboard Mode: Toggled via a clickable "PLUGBOARD" button, allowing users to configure letter swaps with a click-to-select mechanism.

The simulator supports typing letters (A-Z) and spaces, with the space bar adding spaces to both input and output without affecting encryption. The plugboard configuration is displayed in real-time, and the rotor positions update visually with each keypress, providing an intuitive way to understand the Enigma's mechanics.

Supplies

a laptop ig( how else u run python)

Launch the Simulator

Run the Python script containing the simulator code in a Pygame-compatible environment (e.g., a local Python installation with Pygame or a Pyodide-based environment like a Jupyter notebook).

( I,m using py charm and pip installed py game)

Ensure Pygame is installed (pip install pygame) if running locally.

The simulator window will open, displaying the Enigma Machine interface with rotors, a keyboard, input/output boxes, and a plugboard button.

the code:

import asyncio

import platform

import pygame

import random

# Initialize Pygame

pygame.init()

# Screen settings

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Enigma Machine Simulator")

# Colors

DARK_GRAY = (50, 50, 50)

LIGHT_GRAY = (150, 150, 150)

GOLD = (200, 150, 50)

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (200, 50, 50)

YELLOW = (255, 255, 0) # For key highlight during typing

# Distinct colors for plugboard pairs

PLUGBOARD_COLORS = [

(50, 200, 50), # Green

(200, 50, 200), # Purple

(50, 200, 200), # Cyan

(200, 200, 50), # Yellow-Green

(255, 100, 100), # Light Red

(100, 100, 255), # Light Blue

(255, 165, 0), # Orange

(128, 0, 128), # Deep Purple

(0, 255, 255), # Bright Cyan

(255, 50, 50) # Bright Red

]

# Fonts

font = pygame.font.SysFont("courier", 24, bold=True)

small_font = pygame.font.SysFont("courier", 18, bold=True)

rotor_font = pygame.font.SysFont("courier", 16, bold=True)

# Enigma Machine settings

ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

ROTORS = [

"EKMFLGDQVZNTOWYHXUSPAIBRCJ", # Rotor I

"AJDKSIRUXBLHWTMCQGZNPYFVOE", # Rotor II

"BDFHJLCPRTXVZNYEIWGAKMUSQO" # Rotor III

]

REFLECTOR = "YRUHQSLDPXNGOKMIEBFZCWVJAT" # Reflector B

PLUGBOARD = {} # Example: {'A': 'B', 'B': 'A'}

# Rotor positions

rotor_positions = [0, 0, 0] # Starting positions for 3 rotors

# Input and output

input_text = ""

output_text = ""

active = True

highlighted_key = None

highlight_timer = 0

# Plugboard customization

plugboard_mode = False

selected_plug = None # Currently selected letter for pairing

plugboard_pairs = [] # List to store (letter1, letter2, color) tuples

# Plugboard button (increased width from 100 to 150)

plugboard_button_rect = pygame.Rect(575, 500, 150, 40)

def draw_background():

# Gradient background

for y in range(HEIGHT):

color = (50, 50, 50 + int(y / HEIGHT * 50))

pygame.draw.line(screen, color, (0, y), (WIDTH, y))

# Draw machine panel

pygame.draw.rect(screen, DARK_GRAY, (50, 50, 700, 500), border_radius=20)

pygame.draw.rect(screen, LIGHT_GRAY, (50, 50, 700, 500), 5, border_radius=20)

# Title

title = font.render("ENIGMA MACHINE SIMULATOR", True, GOLD)

screen.blit(title, (WIDTH // 2 - title.get_width() // 2, 70))

def draw_rotors():

for i in range(3):

x = 200 + i * 150

y = 120

# Rotor cam background

pygame.draw.rect(screen, BLACK, (x, y, 100, 100), border_radius=10)

pygame.draw.rect(screen, LIGHT_GRAY, (x, y, 100, 100), 2, border_radius=10)

# Draw rotor letters (simulate a moving strip)

pos = rotor_positions[i]

for j in range(-3, 4): # Show 7 letters (3 above, current, 3 below)

letter_idx = (pos + j) % 26

letter = ALPHABET[letter_idx]

letter_y = y + 50 + j * 14 # Spacing for letters

color = GOLD if j == 0 else WHITE # Highlight current letter

text = rotor_font.render(letter, True, color)

text_x = x + 50 - text.get_width() // 2

screen.blit(text, (text_x, letter_y - text.get_height() // 2))

def draw_keyboard():

highlighted_pairs = {}

if plugboard_mode and selected_plug:

highlighted_pairs[selected_plug] = PLUGBOARD_COLORS[len(plugboard_pairs) % len(PLUGBOARD_COLORS)]

for letter1, letter2, color in plugboard_pairs:

highlighted_pairs[letter1] = color

highlighted_pairs[letter2] = color

for i, letter in enumerate(ALPHABET):

x = 70 + (i % 13) * 50

y = 260 + (i // 13) * 60

# Key

color = YELLOW if letter == highlighted_key else (

highlighted_pairs.get(letter, LIGHT_GRAY) if plugboard_mode else LIGHT_GRAY)

pygame.draw.circle(screen, color, (x + 25, y + 25), 20)

pygame.draw.circle(screen, BLACK, (x + 25, y + 25), 20, 2)

# Letter

text = small_font.render(letter, True, WHITE)

screen.blit(text, (x + 25 - text.get_width() // 2, y + 25 - text.get_height() // 2))

def draw_plugboard_lines():

for letter1, letter2, color in plugboard_pairs:

idx1 = ALPHABET.index(letter1)

idx2 = ALPHABET.index(letter2)

x1 = 70 + (idx1 % 13) * 50 + 25

y1 = 260 + (idx1 // 13) * 60 + 25

x2 = 70 + (idx2 % 13) * 50 + 25

y2 = 260 + (idx2 // 13) * 60 + 25

pygame.draw.line(screen, color, (x1, y1), (x2, y2), 2)

def draw_text_boxes():

# Input box

pygame.draw.rect(screen, BLACK, (100, 400, 300, 40), border_radius=5)

pygame.draw.rect(screen, LIGHT_GRAY, (100, 400, 300, 40), 2, border_radius=5)

# Limit input text to fit box

max_chars = 20 # Approximate max chars that fit

display_input = input_text[-max_chars:] if len(input_text) > max_chars else input_text

input_surface = small_font.render(display_input, True, WHITE)

screen.blit(input_surface, (110, 410))

# Output box

pygame.draw.rect(screen, BLACK, (400, 400, 300, 40), border_radius=5)

pygame.draw.rect(screen, LIGHT_GRAY, (400, 400, 300, 40), 2, border_radius=5)

display_output = output_text[-max_chars:] if len(output_text) > max_chars else output_text

output_surface = small_font.render(display_output, True, WHITE)

screen.blit(output_surface, (410, 410))

def draw_plugboard():

plug_text = "Plugboard: " + ", ".join(f"{k}<->{v}" for k, v in sorted(PLUGBOARD.items()))

plug_surface = small_font.render(plug_text[:50], True, GOLD)

screen.blit(plug_surface, (100, 460))

# Plugboard mode indicator

mode_text = "Plugboard Mode: " + ("ON" if plugboard_mode else "OFF")

mode_surface = small_font.render(mode_text, True, RED if plugboard_mode else GOLD)

screen.blit(mode_surface, (100, 500))

# Plugboard button

pygame.draw.rect(screen, LIGHT_GRAY, plugboard_button_rect, border_radius=5)

pygame.draw.rect(screen, BLACK, plugboard_button_rect, 2, border_radius=5)

button_text = small_font.render("PLUGBOARD", True, BLACK)

screen.blit(button_text, (plugboard_button_rect.x + (plugboard_button_rect.width - button_text.get_width()) // 2,

plugboard_button_rect.y + 10))

def enigma_encrypt(char):

if char not in ALPHABET:

return char

# Step rotors

rotor_positions[0] = (rotor_positions[0] + 1) % 26

if rotor_positions[0] == 0:

rotor_positions[1] = (rotor_positions[1] + 1) % 26

if rotor_positions[1] == 0:

rotor_positions[2] = (rotor_positions[2] + 1) % 26

# Plugboard

char = PLUGBOARD.get(char, char)

# Forward through rotors

current = ALPHABET.index(char)

for i in range(3):

rotor = ROTORS[i]

pos = (current + rotor_positions[i]) % 26

current = ALPHABET.index(rotor[pos])

current = (current - rotor_positions[i]) % 26

# Reflector

current = ALPHABET.index(REFLECTOR[current])

# Backward through rotors

for i in range(2, -1, -1):

rotor = ROTORS[i]

pos = (current + rotor_positions[i]) % 26

current = rotor.index(ALPHABET[pos])

current = (current - rotor_positions[i]) % 26

# Plugboard again

result = ALPHABET[current]

result = PLUGBOARD.get(result, result)

return result

def setup():

# Initialize plugboard with random pairs

letters = list(ALPHABET)

random.shuffle(letters)

for i in range(0, min(10, len(letters) - 1), 2):

PLUGBOARD[letters[i]] = letters[i + 1]

PLUGBOARD[letters[i + 1]] = letters[i]

color = PLUGBOARD_COLORS[i // 2 % len(PLUGBOARD_COLORS)]

plugboard_pairs.append((letters[i], letters[i + 1], color))

def handle_plugboard_click(pos):

global plugboard_mode, selected_plug

if not plugboard_mode:

return False

# Check if a key was clicked

for i, letter in enumerate(ALPHABET):

x = 70 + (i % 13) * 50

y = 260 + (i // 13) * 60

if (x <= pos[0] <= x + 50) and (y <= pos[1] <= y + 50):

if selected_plug is None:

selected_plug = letter

else:

second_plug = letter

if selected_plug != second_plug:

# Remove any existing plugs for these letters

for k, v in list(PLUGBOARD.items()):

if k == selected_plug or v == selected_plug or k == second_plug or v == second_plug:

del PLUGBOARD[k]

if v in PLUGBOARD:

del PLUGBOARD[v]

plugboard_pairs[:] = [(a, b, c) for a, b, c in plugboard_pairs if

a not in (selected_plug, second_plug) and b not in (

selected_plug, second_plug)]

# Add new plug

PLUGBOARD[selected_plug] = second_plug

PLUGBOARD[second_plug] = selected_plug

color = PLUGBOARD_COLORS[len(plugboard_pairs) % len(PLUGBOARD_COLORS)]

plugboard_pairs.append((selected_plug, second_plug, color))

selected_plug = None

return True

return False

def update_loop():

global input_text, output_text, active, highlighted_key, highlight_timer, plugboard_mode, selected_plug

for event in pygame.event.get():

if event.type == pygame.QUIT:

active = False

elif event.type == pygame.KEYDOWN:

if event.key == pygame.K_BACKSPACE:

input_text = input_text[:-1]

output_text = output_text[:-1]

elif event.key == pygame.K_ESCAPE:

active = False

elif event.key == pygame.K_SPACE and not plugboard_mode:

input_text += " "

output_text += " "

else:

char = event.unicode.upper()

if char in ALPHABET and not plugboard_mode:

input_text += char

output_text += enigma_encrypt(char)

highlighted_key = char

highlight_timer = 10 # Highlight for ~0.167 seconds at 60 FPS

elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:

if plugboard_button_rect.collidepoint(event.pos):

plugboard_mode = not plugboard_mode

selected_plug = None

else:

handle_plugboard_click(event.pos)

# Update highlight timer

if highlight_timer > 0:

highlight_timer -= 1

if highlight_timer == 0:

highlighted_key = None

# Draw everything

screen.fill(DARK_GRAY)

draw_background()

draw_rotors()

draw_keyboard()

if plugboard_mode:

draw_plugboard_lines()

draw_text_boxes()

draw_plugboard()

pygame.display.flip()

async def main():

setup()

while active:

update_loop()

await asyncio.sleep(1.0 / 60)

if platform.system() == "Emscripten":

asyncio.ensure_future(main())

else:

if __name__ == "__main__":

asyncio.run(main())

Understand the Interface

Rotors: Located at the top, three black rectangles show a strip of letters for each rotor (I, II, III). The current letter is highlighted in gold, and surrounding letters are in white, moving upward as the rotor steps.

Keyboard: Below the rotors, a grid of circular keys displays A-Z. Keys light up yellow when typed or in a pair's color (e.g., green, purple) during plugboard configuration.

Input/Output Boxes: Two boxes below the keyboard show the input text (left) and encrypted output (right), each limited to 20 characters.

Plugboard Display: At the bottom left, shows current plugboard pairs (e.g., "A<->B, C<->D") and the plugboard mode status ("ON" in red or "OFF" in gold).

Plugboard Button: At the bottom right, a "PLUGBOARD" button toggles plugboard mode.

Encrypt a Message

Ensure plugboard mode is off (check that "Plugboard Mode: OFF" is displayed in gold).

Type letters (A-Z) using your keyboard. Each letter will:

Appear in the input box (left).
Be encrypted and appear in the output box (right).
Cause the first rotor to step, updating the visible letter strip. If the first rotor completes a full rotation (26 steps), the second rotor steps, and so on.
Light up the corresponding key in yellow briefly.

Press the space bar to add a space to both input and output text (spaces are not encrypted).

If the text exceeds 20 characters, only the last 20 are shown in each box.

Configure the Plugboard

Click the "PLUGBOARD" button (bottom right) to enter plugboard mode ("Plugboard Mode: ON" in red).

To swap two letters:

Click a key on the on-screen keyboard (e.g., A). It highlights in the next available pair color (e.g., green for the first pair).
Click another key (e.g., B). The two letters are paired (A<->B), and:
A line in the pair’s color (e.g., green) connects the keys.
Both keys remain highlighted in the pair’s color while in plugboard mode.
The plugboard display updates to show the new pair (e.g., "A<->B").
Repeat to add more pairs (up to 10, each with a unique color from green, purple, cyan, etc.).

To remove or change a pair, select one letter of an existing pair and pair it with a new letter; the old pair is automatically removed.

Click the "PLUGBOARD" button again to exit plugboard mode ("Plugboard Mode: OFF"). The plugboard settings are saved and applied to encryption.

Edit Text

Press Backspace to delete the last character or space from both input and output boxes.

Note: Backspace does not reverse rotor steps, as this mimics the Enigma’s one-way operation.

Exit the Simulator

Press Esc or close the window to quit the simulator.

Tips for Use

The plugboard starts with 5 random pairs, which you can modify in plugboard mode.

In plugboard mode, clicking the same letter twice does nothing (you must select two different letters).

The rotor letter strips visually show the current position and movement, helping you track the encryption process.

If the plugboard display text is too long, it truncates at 50 characters, but all pairs are still active.

Example Usage

Goal: Encrypt "HELLO" with a custom plugboard setting.
Start the simulator.
Click the "PLUGBOARD" button to enter plugboard mode.
Click H then K to pair them (a green line connects H and K).
Click E then L to pair them (a purple line connects E and L).
Click the "PLUGBOARD" button to exit plugboard mode.
Type HELLO:
Input box shows "HELLO".
Output box shows the encrypted text (e.g., "QJKEV", depending on rotor positions and plugboard).
Each keypress lights up the key in yellow, and the rotor letters shift upward.
Press space, then type WORLD to continue the message.
Press Backspace to correct mistakes if needed.
Press Esc to exit.

NOW U KNOW HOW a ENIGMA MAHCINE WORKS

YYYYYYYYIIIIIIIIIIIIPPPPPPPPPPEEEEEEEEEEEEE!!!!!!!!!!!!!!!!!!!!!