notebook/Chapter_A_Basic_Cipher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Cipher\n",
    "\n",
    "Cipher methods are techniques for scrambling messages to keep their contents confidential. They work by transforming readable text (called plaintext) into an unreadable format (ciphertext) using a secret key. This key acts like a decoder ring, allowing the intended recipient to decrypt the message back to plaintext.\n",
    "\n",
    "There are many cipher methods, but here's a quick look at a classic one:\n",
    "\n",
    "Caesar Cipher: This is a simple substitution cipher, where each letter in the message is shifted a certain number of positions down the alphabet. \n",
    "\n",
    "For example, shifting every letter by 3 positions would turn \"hello\" into \"khoor.\" The key in this case is the number of positions to shift (3). Caesar ciphers are easy to crack, but they were a good starting point for understanding encryption.\n",
    "\n",
    "Modern ciphers are far more complex and use sophisticated algorithms to scramble data. These algorithms are often categorized based on the type of key used (symmetric or asymmetric) and the way data is processed (block ciphers or stream ciphers).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Table of Content:\n",
    "\n",
    "1. [Basic Letter Encryption](#1)\n",
    "   1. [Caesar Cipher](#1.1)\n",
    "   2. [Random Mapping](#1.2)\n",
    "   3. [Multiply Random Mappings](#1.3)\n",
    "   4. [Advanced Mapping by Looping Different Ciphers](#1.4)\n",
    "   5. [Growing Cipher Issue](#1.5)\n",
    "   6. [Hacker Game](#1.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1\"></a> \n",
    "## 1. Basic Letter Encryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "%%writefile basic_cipher.py\n",
    "\n",
    "import re\n",
    "import sys\n",
    "import random\n",
    "import string\n",
    "from datetime import datetime\n",
    "\n",
    "# basic class of cipher\n",
    "class BasicCipher:\n",
    "    def __init__(self, name=\"Basic\"):\n",
    "        self.ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "        self.name = name + \"_Cipher\"\n",
    "        self.cipher = {}\n",
    "        self.reverse_cipher = {} \n",
    "        self.ciphers = []\n",
    "        self.reverse_ciphers = []  \n",
    "\n",
    "    def __str__(self) -> str:\n",
    "        cipher_size = sum([len(cipher) for cipher in self.ciphers])\n",
    "        description =  f\"\"\"\n",
    "        {\"*\"*37}\n",
    "        Name: {self.name}\n",
    "        Ciphers: {len(self.ciphers)}\n",
    "        Total Size: {cipher_size}, KB: {cipher_size/1024}\n",
    "        {\"*\"*37}\n",
    "        \"\"\"\n",
    "        return description\n",
    "\n",
    "    def __repr__(self):\n",
    "        return self.__str__()   \n",
    "\n",
    "    def selfcheck(self):\n",
    "        plaintext = self.format_string(\"Hello World\")\n",
    "        ciphertext = self.encrypt(plaintext)\n",
    "        message = self.decrypt(ciphertext)\n",
    "        \n",
    "        print(\"_\"*79)\n",
    "        print(self)\n",
    "        run_time = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "        print(f\"Init Run at {run_time}\")\n",
    "        print(f\"input/{plaintext      = }\")\n",
    "        print(f\"encoding/{ciphertext  = }\")\n",
    "        print(f\"decoding/{message     = }\")        \n",
    "        print(\"_\"*79)\n",
    "\n",
    "\n",
    "    def format_string(self, input_string): \n",
    "        # Only keep the letters and space from input string\n",
    "        # ! normally we don't care about the space, but for some cipher,\n",
    "        # ! space is also important, so we keep it for demonstration purpose.\n",
    "        return re.sub(r'[^A-Za-z ]', '', input_string).upper()\n",
    "         \n",
    "    # function need to be implemented in the subclass\n",
    "    def generate_ciphers(self):\n",
    "        pass\n",
    "\n",
    "    def generate_ciphers(self):\n",
    "        pass     \n",
    "\n",
    "    # encode and decode are the same as encrypt and decrypt    \n",
    "    def encode(self, plaintext)-> str:\n",
    "        return self.encrypt(plaintext)\n",
    "    \n",
    "    def decode(self, ciphertext):\n",
    "        return self.decrypt(ciphertext)\n",
    "\n",
    "    def encrypt(self, plaintext)-> str:\n",
    "        letters = list(self.format_string(plaintext))\n",
    "        if not self.ciphers:\n",
    "            return plaintext\n",
    "        else:                \n",
    "            for self.cipher in self.ciphers:\n",
    "                cipher_letters = []\n",
    "                for letter in letters:\n",
    "                    if letter in self.cipher:\n",
    "                        cipher_letters.append(self.cipher[letter])\n",
    "                    else:\n",
    "                        cipher_letters.append(letter)   \n",
    "                letters = \"\".join(cipher_letters)         \n",
    "            return \"\".join(cipher_letters)  \n",
    "\n",
    "    def decrypt(self, ciphertext) -> str:\n",
    "        letters = list(self.format_string(ciphertext))\n",
    "        if not self.reverse_ciphers:\n",
    "            return ciphertext\n",
    "        else:\n",
    "            for self.reverse_cipher in self.reverse_ciphers:\n",
    "                plain_letters = []\n",
    "                for letter in letters:\n",
    "                    if letter in self.reverse_cipher:\n",
    "                        plain_letters.append(self.reverse_cipher[letter])\n",
    "                    else:\n",
    "                        plain_letters.append(letter) \n",
    "                letters = plain_letters\n",
    "            return \"\".join(plain_letters)\n",
    " \n",
    "\n",
    "    def run_cipher_demo(self) -> tuple:\n",
    "        plaintext=\"The quick brown fox jumps over the lazy dog\".upper()\n",
    "        ciphertext = self.encrypt(plaintext)\n",
    "        message = self.decrypt(ciphertext)\n",
    "        run_time = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "        print(f\"Demo Run at {run_time}\")\n",
    "        print(f\"{plaintext   = }\")\n",
    "        print(f\"{ciphertext  = }\")\n",
    "        print(f\"{message     = }\")\n",
    "        print(\"_\"*79)\n",
    "        return plaintext, ciphertext, message \n",
    " \n",
    "    def run_cipher_demo_repeat(self) -> tuple:\n",
    "        plaintext=\"AAABBB BBBCCC XXXYYY YYYZZZ ABCXYZ ABCXYZ\".upper()\n",
    "        ciphertext = self.encrypt(plaintext)\n",
    "        message = self.decrypt(ciphertext)\n",
    "        run_time = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "        print(f\"Demo Run at {run_time}\")\n",
    "        print(f\"{plaintext   = }\")\n",
    "        print(f\"{ciphertext  = }\")\n",
    "        print(f\"{message     = }\")\n",
    "        print(\"_\"*79)\n",
    "        return plaintext, ciphertext, message \n",
    "\n",
    "\n",
    "# test the class\n",
    "if __name__ == \"__main__\":\n",
    "    cipher = BasicCipher()\n",
    "    cipher.selfcheck()\n",
    "    cipher.run_cipher_demo() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from basic_cipher import BasicCipher\n",
    "cipher_basic = BasicCipher()\n",
    "cipher_basic.selfcheck() \n",
    "# results = cipher_basic.run_cipher_demo()\n",
    "results = cipher_basic.run_cipher_demo_repeat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.1\"></a> \n",
    "### 1.1 Caesar Cipher\n",
    "\n",
    "Caesar Cipher: Letter Mapping by Shifting the Alphabet order.\n",
    "\n",
    "To decrypt the Caesar Cipher, we only need to know the shift number.\n",
    "For example, A -> F means right-shift 5, thus key is 5.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile caesar_cipher.py\n",
    "\n",
    "from basic_cipher import BasicCipher\n",
    "\n",
    "class CaesarCipher(BasicCipher):\n",
    "    def __init__(self, name=\"Caesar\", right_shift=1):\n",
    "        super().__init__(name)\n",
    "        self.key = right_shift % 26 # only 25 possible keys\n",
    "        self.generate_ciphers() # generate the cipher dictionary\n",
    "        self.generate_reverse_ciphers()\n",
    "\n",
    "    def generate_ciphers(self):\n",
    "        alphabet = list(self.ALPHABET)\n",
    "        alphabet_shift = alphabet[self.key:] + alphabet[:self.key]\n",
    "        self.cipher = dict(zip(alphabet, alphabet_shift))\n",
    "        self.ciphers.append(self.cipher)\n",
    "        return self.cipher\n",
    "\n",
    "    def generate_reverse_ciphers(self):\n",
    "        reverse_cipher = dict(zip(self.cipher.values(), self.cipher.keys()))\n",
    "        self.reverse_cipher = reverse_cipher\n",
    "        self.reverse_ciphers.append(reverse_cipher)\n",
    "        return reverse_cipher"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from caesar_cipher import CaesarCipher\n",
    "\n",
    "# use the default shift key\n",
    "# caesar_cipher = CaesarCipher()\n",
    "# use the shift key of 10\n",
    "cipher_caesar = CaesarCipher(right_shift=10)\n",
    "cipher_caesar.selfcheck()\n",
    "# results = cipher_caesar.run_cipher_demo()\n",
    "results = cipher_caesar.run_cipher_demo_repeat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caesar Cipher is considered simple because it only contains 25 different mappings which can be easily solved by brutal force methods, search all the keys from 1 to 25.\n",
    "\n",
    "However, we can using random mapping to make it more difficult."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.2\"></a> \n",
    "### 1.2 Random Mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Random Mapping can help but we have to share the cipher code to decrypt the message. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile random_cipher.py\n",
    "\n",
    "from basic_cipher import BasicCipher\n",
    "import random\n",
    "\n",
    "class RandomCipher(BasicCipher):\n",
    "    def __init__(self, name=\"Random\", cipher_number=1):\n",
    "        super().__init__(name)\n",
    "        self.cipher_number = cipher_number\n",
    "        self.generate_ciphers() # generate the cipher dictionary\n",
    "        self.generate_reverse_ciphers()\n",
    "\n",
    "    def generate_ciphers(self):\n",
    "        alphabet = list(self.ALPHABET)\n",
    "        alphabet_shuffled = alphabet.copy()\n",
    "        for i in range(self.cipher_number):\n",
    "            random.shuffle(alphabet_shuffled) \n",
    "            self.cipher = dict(zip(alphabet, alphabet_shuffled))\n",
    "            self.ciphers.append(self.cipher)\n",
    "        return True\n",
    "\n",
    "    def generate_reverse_ciphers(self):\n",
    "        for i in range(self.cipher_number):\n",
    "            self.reverse_cipher = dict(zip(self.ciphers[i].values(), self.ciphers[i].keys()))\n",
    "            self.reverse_ciphers.append(self.reverse_cipher )\n",
    "        self.reverse_ciphers.reverse() # reverse the list\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random_cipher import RandomCipher\n",
    "\n",
    "cipher_random = RandomCipher()\n",
    "cipher_random.selfcheck()\n",
    "# results = cipher_random.run_cipher_demo()\n",
    "results = cipher_random.run_cipher_demo_repeat() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make it more difficult my using multiply mappings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.3\"></a> \n",
    "### 1.3 Multiply Random Mappings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random_cipher import RandomCipher\n",
    "\n",
    "cipher_random_many = RandomCipher(cipher_number=3)\n",
    "cipher_random_many.selfcheck()\n",
    "# results = cipher_random_many.run_cipher_demo()\n",
    "results = cipher_random_many.run_cipher_demo_repeat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we see there is still a problem, because we are using letter mapping, the same letter is mapped to the same cipher code. \n",
    "\n",
    "\n",
    "Based on the statistic analysis, we can use letter frequency to find the mappings.\n",
    "\n",
    "\n",
    "For example, the \"LL\" from \"HELLO WORLD\" is mapped to \"LL\" then \"PP\", then \"MM\", etc.\n",
    "\n",
    "As you can see, just mapping the letter by comparing the letter frequency, the encryption is decoded / hacked."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.4\"></a> \n",
    "### 1.4 Advanced Mapping by Looping Different Ciphers\n",
    "\n",
    "To avoid the same letter being mapped to the same cipher, we need to roll the mapping based the letter's order.\n",
    "This means if we have N ciphers, for the \n",
    "- 1st letter using the 1st cipher mapping. \n",
    "- 2nd letter using the 2nd cipher mapping.\n",
    "- ...\n",
    "- N letter using the Nth cipher mapping.\n",
    "- N+1 letter, go back, using the 1st again.\n",
    "- ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile rolling_cipher.py\n",
    "\n",
    "from random_cipher import RandomCipher\n",
    "\n",
    "class RollingCipher(RandomCipher):\n",
    "    def __init__(self, name=\"Rolling\", cipher_number=1):\n",
    "        super().__init__(name, cipher_number)\n",
    "        self.cipher_number = cipher_number\n",
    "\n",
    "    # overwrite the encrypt and decrypt function\n",
    "    def encrypt(self, plaintext)-> str:\n",
    "        letters = list(self.format_string(plaintext))\n",
    "        if not self.ciphers:\n",
    "            return plaintext\n",
    "        else:                \n",
    "            cipher_letters = []\n",
    "            for i, letter in enumerate(letters):\n",
    "                if letter in self.ciphers[i % self.cipher_number]:\n",
    "                    cipher_letters.append(self.ciphers[i % self.cipher_number][letter])\n",
    "                else:\n",
    "                    cipher_letters.append(letter)   \n",
    "            return \"\".join(cipher_letters) \n",
    "    \n",
    "    def decrypt(self, ciphertext) -> str:\n",
    "        letters = list(self.format_string(ciphertext))\n",
    "        if not self.reverse_ciphers:\n",
    "            return ciphertext\n",
    "        else:\n",
    "            plain_letters = []\n",
    "            for i, letter in enumerate(letters):\n",
    "                cipher = self.ciphers[i % self.cipher_number]\n",
    "                reverse_cipher = dict(zip(cipher.values(), cipher.keys()))\n",
    "                if letter in cipher:\n",
    "                    plain_letters.append(reverse_cipher[letter])\n",
    "                else:\n",
    "                    plain_letters.append(letter) \n",
    "            return \"\".join(plain_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rolling_cipher import RollingCipher\n",
    "\n",
    "cipher_rolling = RollingCipher(cipher_number = 5)\n",
    "cipher_rolling.selfcheck()\n",
    "# results = cipher_rolling.run_cipher_demo() \n",
    "results = cipher_rolling.run_cipher_demo_repeat()\n",
    "# now we see the repeated letter are encrypted differently"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.5\"></a>\n",
    "### 1.5 Issue the Growing Cipher Size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From 1.1 to 1.4, we see the evolution of the encrypt and decrypt functions.\n",
    "\n",
    "And the size of my key (ciphers) keep growing, it will be really difficult to keep a large ciphers in real world. \n",
    "\n",
    "This is where we get to know the Enigma Machine.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Previous_Cipher_list = [cipher_caesar, cipher_random, cipher_random_many, cipher_rolling]\n",
    "for one_cipher in Previous_Cipher_list:\n",
    "    print(one_cipher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1.6\"></a>\n",
    "### 1.6 Hacker Game: Simple Mapping Cipher vs Rolling Mapping Cipher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate the issue, I used the Book Mobi Dict as the plaintext, the apply the random cipher with `RandomCipher` with `3` Ciphers.\n",
    "\n",
    "Next we redo the case study by replace the my cipher to `RollingCipher`.\n",
    "\n",
    "We will see the mapping can not be easily used to decrypt the cipher.\n",
    "And with a larger rolling cipher, the distribution of cipher test is more evenly to human language. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile hack_the_code_demo.py\n",
    "\n",
    "import re\n",
    "import requests\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from random_cipher import RandomCipher\n",
    "from rolling_cipher import RollingCipher \n",
    "from pathlib import Path\n",
    "import argparse\n",
    "\n",
    "def format_clean(text):\n",
    "    text = str(text)\n",
    "    # Remove all non-alphabetic characters\n",
    "    text = re.sub('[^a-zA-Z]', ' ', text)\n",
    "    # Replace multiple spaces with a single space\n",
    "    # text = ' '.join(text.split())\n",
    "    text = ''.join(text.split()) # <- remove all spaces\n",
    "    return text\n",
    "\n",
    "def letter_frequency(text):\n",
    "    text = text.upper()\n",
    "    letter_count = {}\n",
    "    for letter in text:\n",
    "        if letter in letter_count:\n",
    "            letter_count[letter] += 1\n",
    "        else:\n",
    "            letter_count[letter] = 1\n",
    "    letter_count = dict(sorted(letter_count.items()))\n",
    "    return letter_count\n",
    "\n",
    "def hack_decrypt(cipher_text, hack_cipher):\n",
    "    cipher_text = cipher_text.upper() \n",
    "    reverse_cipher = {v: k for k, v in hack_cipher.items()}\n",
    "    plaintext = []\n",
    "    for letter in cipher_text:\n",
    "        if letter in reverse_cipher:\n",
    "            plaintext.append(reverse_cipher[letter])\n",
    "        else:\n",
    "            plaintext.append(letter)\n",
    "    return \"\".join(plaintext)    \n",
    "# Download the text\n",
    "\n",
    "def download_text(textbook_url):\n",
    "    response = requests.get(textbook_url)\n",
    "    text = response.text\n",
    "    plaintext = format_clean(text)\n",
    "    print(f\"The Book has {len(plaintext)} letters\") \n",
    "    return plaintext\n",
    "\n",
    "def main(cipher_type :str, cipher_number: int) -> dict:\n",
    "    # Step 1: Download the text\n",
    "    textbook_url = \"https://www.gutenberg.org/cache/epub/2701/pg2701.txt\"\n",
    "    plaintext = download_text(textbook_url)  \n",
    "\n",
    "    # Step 2: init cipher and get the cipher text\n",
    "    match cipher_type:\n",
    "        case \"random_cipher\":\n",
    "            my_cipher = RandomCipher(cipher_number = cipher_number)\n",
    "        case \"rolling_cipher\":\n",
    "            my_cipher = RollingCipher(cipher_number = cipher_number)\n",
    "    my_cipher.selfcheck()\n",
    "    cipher_text = my_cipher.encrypt(plaintext)\n",
    "    \n",
    "    # Step 3: Get the plain text letter count and the cipher text letter count \n",
    "    letter_count = letter_frequency(plaintext)\n",
    "    cipher_count = letter_frequency(cipher_text)\n",
    "\n",
    "    # step 4: Plot the letter count of the plain text and the cipher text\n",
    "    # Plot the letter count of the plain text and the cipher text\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(10, 7))\n",
    "    df_letter_count = pd.DataFrame(letter_count.items(), columns=['letter', 'count'])\n",
    "    df_cipher_count = pd.DataFrame(cipher_count.items(), columns=['letter', 'count'])\n",
    "    df_letter_count.plot(kind='bar', x='letter', y='count', title='Plaintext A-Z',ax=axs[0][0], rot=0) \n",
    "    df_cipher_count.plot(kind='bar', x='letter', y='count', title=f'{cipher_type.upper()} Text A-Z', ax=axs[0][1], rot=0, color='red')\n",
    "    df_letter_count = df_letter_count.sort_values(by='count', ascending=False)\n",
    "    df_cipher_count = df_cipher_count.sort_values(by='count', ascending=False)\n",
    "    df_letter_count = df_letter_count.reset_index(drop=True)\n",
    "    df_cipher_count = df_cipher_count.reset_index(drop=True) \n",
    "    df_letter_count = df_letter_count.add_prefix('plain_')\n",
    "    df_cipher_count = df_cipher_count.add_prefix('cipher_')\n",
    "    df_letter_count.plot(kind='bar', x='plain_letter', y='plain_count', title='Plaintext High-Low', ax=axs[1][0], rot=0)\n",
    "    df_cipher_count.plot(kind='bar', x='cipher_letter', y='cipher_count', title=f'{cipher_type.upper()}  High-Low', ax=axs[1][1], rot=0, color='red')\n",
    "    plt.tight_layout() \n",
    "\n",
    "    Path(\"img\").mkdir(parents=True, exist_ok=True)\n",
    "    fig.savefig(f\"img/{cipher_type}_{str(cipher_number)}.png\", dpi=300)\n",
    "\n",
    "    # Step 5: Hack the cipher text buy mapping the letter frequency of the cipher text to the letter frequency of the plain text\n",
    "    df_letter_cipher_join = pd.concat([df_letter_count, df_cipher_count], axis=1)\n",
    "    # use the plain_letter and cipher_letter to create a cipher and reverse_cipher\n",
    "    hack_cipher = dict(zip(df_letter_cipher_join['plain_letter'], df_letter_cipher_join['cipher_letter']))\n",
    "    \n",
    "    # Step 6: Hack the cipher text and get the message\n",
    "    plaintext_sample = plaintext[:200]\n",
    "    cipher_text_sample = cipher_text[:200]\n",
    "    hack_message = hack_decrypt(cipher_text_sample, hack_cipher)\n",
    "    message = my_cipher.decrypt(cipher_text_sample)\n",
    "\n",
    "    results = { \"plaintext_sample\": plaintext_sample,\n",
    "                \"cipher_text_sample\": cipher_text_sample,\n",
    "                \"hack_message\": hack_message,\n",
    "                \"message\": message}\n",
    "    return results\n",
    "\n",
    "def text_segment(results):\n",
    "    from wordsegment import load, segment\n",
    "    load()\n",
    "    hack_message = results['hack_message']\n",
    "    hack_message_segments = segment(hack_message)\n",
    "    fmt_hack_message = \" \".join(hack_message_segments)\n",
    "    print(\"-\" * 80)\n",
    "    print(f\"{hack_message       = }\")\n",
    "    print(f\"{fmt_hack_message   = }\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # add the command line argument for cipher_type and cipher_number\n",
    "    # python hack_the_code_demo.py random_cipher 1\n",
    "    # python hack_the_code_demo.py rolling_cipher 3\n",
    "\n",
    "    # Create the parser\n",
    "    parser = argparse.ArgumentParser(description=\"Process some integers.\")\n",
    "\n",
    "    # Add the arguments\n",
    "    parser.add_argument(\"cipher_type\", type=str, help=\"The type of cipher to use.\", default=\"random_cipher\")\n",
    "    parser.add_argument(\"cipher_number\", type=int, help=\"The number of ciphers to use.\", default=1)\n",
    "\n",
    "    # Parse the arguments\n",
    "    args = parser.parse_args() \n",
    "    results = main(args.cipher_type, args.cipher_number)\n",
    "\n",
    "    print(f\"{results['plaintext_sample'] = }\")\n",
    "    print(f\"{results['cipher_text_sample'] = }\")\n",
    "    print(f\"{results['hack_message'] = }\")\n",
    "    print(f\"{results['message'] = }\")\n",
    "    text_segment(results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run hack_the_code_demo.py random_cipher 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run hack_the_code_demo.py rolling_cipher 5000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Enigma Machine` is similar to the rolling cipher above, but with a huge cipher mapping and extra letter switching to make the decryption extremely difficult."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**END**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}