SACNAS 2018/Cyber-Challenge.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "# NSA Cyber Challenge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 0,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 33,
        "hidden": false,
        "row": 4,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "### What is Cyber Security?\n",
    "\n",
    "Especially in today's world, cyber security is crucial to ensuring the protection of computer systems and the information contained within them. \n",
    "\n",
    "### What is Cryptography?\n",
    "\n",
    "While there are many aspects to cyber security, one way to protect information is by the use of <b>cryptography</b>, which is the encrypting and decrypting of messages. Cryptography can be utilized for confidentiality,  authentification, security and many other applications.\n",
    "\n",
    "#### <i><u>KEY</u></i> terms\n",
    "\n",
    "There are 3 main terms to note when talking about cryptography: <b>Plain Text, Cipher Text, and Key. </b>\n",
    "\n",
    "+ In order to <u>encrypt</u> a message, you use a <b>Key</b> to transform the <b>Plain Text</b> into <b>Cipher Text</b>. \n",
    "+ To <u>decrypt</u> the message, the <b>Key</b> will then be used to transform the <b>Cipher Text</b> back into <b>Plain Text</b>.\n",
    "\n",
    "### History & Classical Cryptography\n",
    "\n",
    "The earliest known use of encryption methods were circa 1900 BCE with the use of hieroglyphs. In third century BCE, the Greeks and Spartans used a cryptographic device to send and receive secret messages called a Scytale, which used a cylindrical device and leather to wrap and \"jumble\" plain text into cipher text.\n",
    "\n",
    "Auguste Kerckhoffs was a Dutch cryptographer in the 19th century who stated 6 design principles for ciphers:\n",
    "+ Must be indecipherable\n",
    "+ Should not require secrecy; a.k.a not a problem when in enemy hands\n",
    "+ Easily communicable and easy to remember the key without notes\n",
    "+ Applicable to telegraphs (could say computers in today's world)\n",
    "+ Portable and not require several persons\n",
    "+ Easy to use\n",
    "\n",
    "Within classic cryptography, there are various kinds of ciphers including <b>substitution ciphers</b>, where text is <i>interchanged</i> with other text, and <b>transposition ciphers</b>, where the text is <i>rearranged</i> into a different order.\n",
    "\n",
    "The Caesar cipher is a simple example of a substitution cipher. Named after Julius Caesar, this particular cipher is used to encrypt  messages by replacing letters with another letter that is a particular distance away from the original character in the alphabet. For instance, Caesar used a shift of 3, which means, the letter A would be replaced with the letter D, the letter B would be replaced by E, and so on. Check out his mapping below:\n",
    "\n",
    "| | |\n",
    "| --- | ---------- |\n",
    "|Plain text |  ABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
    "|Cipher text| DEFGHIJKLMNOPQRSTUVWXYZABC\n",
    "\n",
    "\n",
    "### Example \n",
    "We will try using the provided ROT function below. Run the next cell without making any changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "# --- Simply, run this cell. No changes necessary.\n",
    "# Feel free to look through it to see if you can understand what this function is doing!\n",
    "\n",
    "import string\n",
    "\n",
    "def ROT(input_string, shift, encrypt_decrypt):\n",
    "  ''' Encrypt/Decrypt string using a given shift of the alphabet. \n",
    "  AKA. Caesar Cipher \n",
    "  \n",
    "  input_string = string type\n",
    "  shift = integer type\n",
    "  encrypt_decrypt = 0 (encrypt) or 1 (decrypt)'''\n",
    "  \n",
    "  # --- Verify inputs are of correct type\n",
    "  if type(input_string) is not str: \n",
    "    raise ValueError('input argument index 0 must be string type')\n",
    "  elif type(shift) is not int:\n",
    "    raise ValueError('input argument index 1 must be integer type')\n",
    "  elif encrypt_decrypt not in (0,1):\n",
    "    raise ValueError('input argument index 2 must be 0 or 1')\n",
    "    \n",
    "  # --- Cycle through string & replace value\n",
    "  output_string=''  \n",
    "  for char in input_string:\n",
    "    if char in string.ascii_lowercase: \n",
    "      char_set = string.ascii_lowercase\n",
    "      output_string += get_sister(char, char_set, shift, encrypt_decrypt)\n",
    "    elif char in string.ascii_uppercase: \n",
    "      char_set = string.ascii_uppercase\n",
    "      output_string += get_sister(char, char_set, shift, encrypt_decrypt)\n",
    "    else: \n",
    "      output_string += char\n",
    "  return output_string\n",
    "  \n",
    "def get_sister(char, char_set, shift, encrypt_decrypt):\n",
    "  ''' Retrieve shifted character '''\n",
    "  \n",
    "  # --- Verify given character is included in given set\n",
    "  if char not in char_set: raise ValueError ('char not in char_set')\n",
    "  char_set_len = len(char_set)\n",
    "  shift = abs(char_set_len*encrypt_decrypt-shift)\n",
    "  return char_set[(char_set.find(char)+shift)%char_set_len]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 6,
        "hidden": false,
        "row": 37,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "Now, let's try to actually encrypt a phrase using the ROT function.\n",
    "\n",
    "To use this function, you will need to provide a phrase to encrypt/decrypt, the shift value to create the key, and a 0 or 1 to say if you are encrypting or decrypting.\n",
    "\n",
    "<u>Run the cell below.</u> Feel free to replace the phrase with your own. \n",
    "\n",
    "Remember, the 13 is our shift value which creates the key.\n",
    "The 0 is telling us to ENCRYPT the phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 43,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "ROT('Hello World!', 13, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 47,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "If you kept 'Hello World!' you should have seen the cipher text as 'Uryyb Jbeyq!' Now, let's try to change it back by decrypting! \n",
    "\n",
    "Our key was created by using a shift of 13, so we want to keep that. However, now we need to DECRYPT (change 0 to 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 51,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "ROT('Uryyb Jbeyq!', 13, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 55,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "Let's try using Caesar's favorite shift of 3.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 59,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "ROT('Hello World!', 3, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 63,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "Now, our cipher text says 'Khoor Zruog!' Let's go ahead and retrieve the plain text back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 67,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "ROT('Khoor Zruog!', 3, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 71,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "Great! Now you are able to create your own secret messages!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 6,
        "hidden": false,
        "row": 75,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "### Modern Cryptography\n",
    "\n",
    "In modern times, cryptography is achieved through the use of algorithms, which encrypt and decrypt <b>bits</b> instead of letters. This is stronger, more complex and used for things such as emails, cellphones, banking, bluetooth, passwords, etc. Some examples of algorithms include XOR, which is a boolean logic operator, Data Encryption Standard (DES), which was developed in the early 70s at IBM and was highly influential in modern cryptography, and Public Key, which is an asymmetric key algorithm that uses a public and private key for encryption/decryption."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 23,
        "hidden": false,
        "row": 81,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "#### What is Base64?\n",
    "Base64 allows binary data to be represented in a way that looks and acts as plain text for email transmission over the Internet. It facilitates reliablility of data to be stored in databases, sent in emails, or used in text-based format such as XML. Base64 is basically used for representing data in an ASCII string format.\n",
    "\n",
    "#### How does Base64 work?\n",
    "\n",
    "Base64 encoding is executed as follows:\n",
    " 1. The text to be encoded is converted into its respective decimal values, that is, into their ASCII equivalent. \n",
    " 2. The decimal values are converted into their binary equivalents.\n",
    " 3. All the binary equivalents are concatenated, obtaining a large set of binary numbers.\n",
    " 4. The large set of binary numbers is divided into equal sections, with each section containing only 6 bits.\n",
    " 5. The equal sets of 6 bits are converted into their decimal equivalents.\n",
    " 6. The decimal equivalents are converted into their Base64 values.\n",
    "\n",
    "Base64 decoding is executed as follows:\n",
    " 1. Each character in the string is changed to its Base64 decimal value.\n",
    " 2. The decimal values are converted into their binary equivalents.\n",
    " 3. The first two bits of the binary numbers are truncated from each of the binary numbers obtained, and the sets of 6 bits are combined, forming one large string of binary digits\n",
    " 4. The large string of binary digits is split into groups of 8 bits.\n",
    " 5. The 8-bit binary numbers are converted into their decimal equivalents.\n",
    " 6. The decimal values obtained are converted into their ASCII equivalent.\n",
    "\n",
    "#### Hexa-what?\n",
    "You may have heard the term <i>hexadecimal</i> before, but what does it mean? Hexadecimal refers to the base-16 number system and is commonly used in the transmission of data for its readability as opposed to the lengthy binary formats such as base-2. You might be familiar with hexadecimal color representations:\n",
    "+ Black --> #000000\n",
    "+ Green --> #00FF00\n",
    "+ White --> #FFFFFF\n",
    "\n",
    "\n",
    "### Examples\n",
    "\n",
    "#### How are we going to implement this? Easy, with Python!\n",
    "\n",
    "For our benefit, python already includes a library, <i>base64</i> that contains all of the code we need to encode or decode using base64 and <i>binascii</i> that will help us \"hexlify\". Let's try some examples. Run the cell below to encode to base64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 104,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "import base64 \n",
    "\n",
    "string_to_encode = str.encode('Encode me!') # make the string a bytes object\n",
    "encoded = base64.b64encode(string_to_encode) # do base64 encoding\n",
    "print(encoded) # should output b'RW5jb2RlIG1lIQ==' where the b is for bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that we have a bytes object and it doesn't look anything like the string we gave it.\n",
    "<p>Let's get back the original..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 104,
        "width": 12
       },
       "report_default": {}
      }
     }
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data = base64.b64decode(encoded) # do base64 decoding\n",
    "string_to_decode = data.decode('utf-8') # make the bytes object back to a string \n",
    "print(string_to_decode) # should give us back the original 'Encode me!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 108,
        "width": 12
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "Awesome! If you wanted to encode an image, you could do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "with open('yourfile.ext','rb') as image_file:\n",
    "  encoded = base64.b64encode(image_file.read())\n",
    "\n",
    "print(encoded)\n",
    "\n",
    "# however, this code will not work because 'yourfile.ext' does not exist!\n",
    "# try uploading your own picture and testing it out \n",
    "# by replacing 'yourfile.ext' with your own file's name!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great job, now you know what base64 encoding looks like! Let's compare to hexadecimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import binascii\n",
    "\n",
    "string_to_hex = str.encode('Hex me!') # make the string a bytes object\n",
    "encoded = binascii.hexlify(string_to_hex) # hexlify!\n",
    "print(encoded) # should ouput b'486578206d6521' where b is for bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have ourselves another bytes object. Clearly a different encoding than before!\n",
    "<p> Can we decode back to the original?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = binascii.unhexlify(encoded) # un-hexlify\n",
    "string_to_unhex = data.decode('utf-8') # make the bytes object back to a string \n",
    "print(string_to_unhex) # should give us back the original 'Hex me!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes! Awesome! Time to save the galaxy..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "## Challenge Scenario - The Email Strikes Back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"We have received medium-confidence reports that the Empire is constructing a secret weapon. Some kind of super-laser space station weapon of impossible power. Naturally, our first instinct would be to reject these claims for the obvious nonsense they are, but just to be on the safe side, we would like you to decrypt these galaxymail intercepts which we believe may contain clues as to the truth of these claims. They were originally authored by one Galen Erso, until recently an engineering director at Kuat Drive Yards, present status unknown.\"\n",
    "\n",
    "-<b><i>Chair of the Alliance Council, Mon Mothma</i></b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's get to work. Here's what you need to know."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We were able to intercept some galaxymail during transmission, but data is transferred over the internet as a hexstream. Fortunately, the hex-to-character system is public knowledge and we can convert it to base64, and subsequently into plain text! Unfortunately, the Empire knows this and has implemented a Caesar cipher on the hex text!\n",
    "\n",
    "What you must do:\n",
    "\n",
    "+ Read in hextext.txt.\n",
    "+ Decode the Caesar cipher to figure out how to get back to original hexidecimal format.\n",
    "+ <i>Unhexlify</i> the hex text to convert into the email output.\n",
    "+ Decode the base64 encoding of the email.\n",
    "+ Save the galaxy!\n",
    "\n",
    "<b>Hint:</b> Start by reading in the hex text. Take a guess at what shift was used in the Caesar cipher to shift, then unhexlify. If you are correct, it will easily decrypt. Otherwise, you might get an error or something difficult to interpret. How fast/efficient can you decrypt the galaxymail?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read in <b>hextext.txt</b> and use your knowledge about Caesar ciphers, base64 & hexidecimals to decode the galaxymail. What information are you able to find that will help us stop the Empire?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Tips:</u>\n",
    "\n",
    "1. The Empire is tricky; don't be surprised if you find a different cipher to break. Provide any intelligence from the galaxymail that you can!\n",
    "<p>\n",
    "    \n",
    "2. When decoding base64, if you see an error such as:\n",
    "  <i>UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf0 in position 156</i> <p>\n",
    "  try adding the ignore errors option  --> data.decode('utf-8'<b>, errors='ignore'</b>)\n",
    "<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Write your own code here."
   ]
  }
 ],
 "metadata": {
  "extensions": {
   "jupyter_dashboards": {
    "activeView": "grid_default",
    "version": 1,
    "views": {
     "grid_default": {
      "cellMargin": 10,
      "defaultCellHeight": 20,
      "maxColumns": 12,
      "name": "grid",
      "type": "grid"
     },
     "report_default": {
      "name": "report",
      "type": "report"
     }
    }
   }
  },
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}