Vigenere_cipher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color = \"blue\">The Vigenère Cipher</font>\n",
    "\n",
    "In this activity, we'll use Python programming to encrypt and decrypt messages using a Vigenère cipher."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>**For the rest of this notebook, your tasks will always be bold and red like this.**</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue>How to Use This Notebook</font>\n",
    "\n",
    "The webpage you are in is actually an app - much like the ones on your cellphone. This app consists of cells.\n",
    "\n",
    "An *input* cell looks like a light grey box with an `In [ ]:` on its left. Input cells each contain code - instructions to make the computer do something.\n",
    "\n",
    "To activate or select a cell, click anywhere inside of it. It will be outlined in a green box if it is selected.\n",
    "\n",
    "<font color=red>**Select the cell below and read its contents.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Text that follows a \"#\" is known as a comment.\n",
    "# Comments do not affect your code in any way.\n",
    "# You should always read the comments at the top of each cell you interact with.\n",
    "# Comments will be used to describe what the cell's code is actually doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To execute or run a selected cell, hit `[Shift + Enter]` on your keyboard (i.e., press those two keys at the same time). \n",
    "\n",
    "Alternatively, you can press the <span style='background:#D3D3D3'> &#9656;| Run</span>  button in the menu bar at the top of the page. <br>\n",
    "\n",
    "If you accidentally double click on a text cell and it looks like a code cell, use `[Shift + Enter]` to put it back to normal. \n",
    "\n",
    "<font color=red>**Select the cell below and read its contents. Then, run the cell.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Text that DOESN'T follow a \"#\" is considered code.\n",
    "# Lines of code are instructions given to your computer.\n",
    "# The line of code below is a \"print\" statement.\n",
    "# A print statement literally prints out the text between its quotes.\n",
    "\n",
    "print(\"Congrats! You have successfully run your first cell!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running a cell creates an *output* directly below it. An output can be some text, a graph, an interactive slider, or even nothing at all! For that last case, you know you have run a cell when the `In [ ]:` becomes `In [#]:`, where \"#\" is any number.  If the code is still in progress, the input cell will look like `In [*]:`.\n",
    "\n",
    "You can learn more about how Jupyter notebooks work at https://try.jupyter.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "## <font color=\"blue\">Creating Code: Thinking Like a Computer</font>\n",
    "\n",
    "As we alluded to in the last lesson, we're going to start using programming as a tool to help address cybersecurity in our local communities. To do this, we need to learn how to write code that makes a computer do what we want it to do. The challenge is that computers can't think on their own* - if you tell it to do something, it will do _exactly_ that thing and only that thing.\n",
    "\n",
    "<sub>*As a side note, while we've made great progress with developing artificial intelligence (AI), it currently requires _training data_ for it to learn what to do, so at some level, even AI requires specific instructions to function!</sub>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many ways, a computer code functions like a recipe you might use for cooking or baking. Here's an example of the ingredients in a simple tomato salsa recipe (technically, pico de gallo):\n",
    "\n",
    "> * 3 tbsp red onion, finely chopped\n",
    "> * 2 garlic cloves, minced\n",
    "> * 3 large ripe tomatoes, peeled and chopped\n",
    "> * 2 chile peppers, chopped\n",
    "> * 2-3 tbsp cilantro, chopped\n",
    "> * juice of half a lime (or more if you like)\n",
    "> * salt and pepper to taste\n",
    "> \n",
    "> If you don't like the sharp taste of red onion and garlic, you can calm it a bit by putting those ingredients in a strainer and pouring boiling water over them (sort of like blanching them). Once they're cooled down (or if you skipped that step), combine all the ingredients together and refrigerate the mixture for at least 2 hours. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, how is that like writing a computer program? Well, we have a bunch of ingredients, which in Python would be our variables and functions. So far, we've been mostly been using functions like `Caesar_encrypt`, which are fully-constructed functions that complete tasks we've created - it's like baking a cake using a box cake mix. However, as we saw at the end of the notebook from last class, that function was composed of many smaller steps which did individual tasks, kind of like if we made a cake from basic ingredients like flour, butter, and sugar.  In the salsa analogy, those ingredients are our onions, tomatoes, and so on.\n",
    "\n",
    "But for the salsa, we can't use those ingredients as-is; they have to be prepared first! And they each have different preparation methods, though some things like the chile peppers and cilantro require similar preparation (in this case, chopping). So, we might create something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# considering each ingredient in the list one at a time...\n",
    "#    if it's the onion\n",
    "#         finely chop 3 tbsp, and save the rest\n",
    "#    if it's the garlic\n",
    "#         mince\n",
    "#    if it's the tomato\n",
    "#         peel and chop\n",
    "#    if it's the chile pepper or cilantro\n",
    "#          chop\n",
    "#    if it's the lime\n",
    "#          cut in half, and juice at least one of the halves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that I've written each line as a comment (i.e., preceded by `#`), so if you accidentally tried to run the cell, nothing would happen. In our computer program, we have to consider each ingredient one-by-one. Depending on the ingredient, something different happens to it (though there's an `or` for the two that get chopped to group them together). Also, those commands are indented within the `if` statements to indicate they only happen if that particular statement is true (e.g., \"peel and chop\" only happens if the ingredient currently being considered is a tomato). \n",
    "\n",
    "If you're a more visual person, you might create something like this flow chart:\n",
    "\n",
    "<img src=\"Files/recipe_ingredients_flowchart.png\" width =\"600\">\n",
    "\n",
    "Note that this flow chart also specifies that the recipe preparation methods (like mincing garlic) has to be done to **each** one of that ingredient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But that's not all of the steps - we also have to do something with those ingredients (combine them to make the salsa!). So let's go back to the version in code comments, improving the accuracy of the current setup and adding in the final instructions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# onion_and_garlic = [] \n",
    "# prepped_ingredients = [] for everything else \n",
    "#\n",
    "# for each ingredient:\n",
    "#    if it's the onion\n",
    "#         finely chop 3 tbsp, and save the rest\n",
    "#         add the chopped onion to onion_and_garlic\n",
    "#    if it's the garlic\n",
    "#         mince 2 cloves\n",
    "#         add minced garlic to onion_and_garlic\n",
    "#    if it's the tomato\n",
    "#         peel and chop 3 tomatoes\n",
    "#         add chopped tomatoes to prepped_ingredients\n",
    "#    if it's the chile pepper or cilantro\n",
    "#         chop 2 peppers, 2 tbsp cilantro\n",
    "#         add chopped ingredients to prepped_ingredients\n",
    "#    if it's the lime\n",
    "#         cut in half\n",
    "#         add juice of (at least) one half to prepped_ingredients\n",
    "#\n",
    "# if desired:\n",
    "#    quick-blanch the onion_and_garlic by pouring boiling water over them\n",
    "#    wait for it to cool\n",
    "#\n",
    "# combine onion_and_garlic with prepped_ingredients into salsa_combined\n",
    "# refrigerate salsa_combined for 2 hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that some things may be \"code\"-ish, like the way `onion_and_garlic` and `prepped_ingedients` are written (in Python, variable names have to be one word only, so sometimes underscores are used as \"spaces\"). And if we add those things to the flow chart, we might get something like this:\n",
    "\n",
    "<img src=\"Files/recipe_full_flowchart.png\" width =\"600\">\n",
    "\n",
    "Both of these are forms of _pseudocode_ where we've written a program in plain language. In these particular examples, the written one may seem slightly more \"code\"-ish than plain language because the author has been coding in Python for years. Your own personal style of pseudocode can evolve as you further practice your programming skills."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">**Now it's your turn: create pseudocode for something from your daily life (e.g., a favorite recipe or daily routine). Use the cell below, or write/draw something on your own paper.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pseudocode for a daily activity:\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all that in mind, let's return to the Vigenère ciphers. This time, in addition to running finished functions (as in the Caesar cipher activity), you'll be asked to write some pseudocode for how these functions should work. There'll be space provided to do written pseudocode, but feel free to draw flow charts or other diagrams on paper if that makes more sense to you. It's also completely fine to try a mix of different methods - the author of these notebooks used a combination of flowcharts and written text when creating the functions for these notebooks :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## <font color=\"blue\">Vigenère Ciphers</font>\n",
    "\n",
    "Recall that the Vigenère cipher is a form of a _substitution cipher_ - each letter is replaced with another letter based on a _key_. Since the amount of shift for each character in the original message varies based on the key characters, it's also known as a _polyalphabetic_ cipher. The chart below can help use the cipher: if you look at the intersection between a character from the original message with the associated character from the key, you will see the encrypted character.\n",
    "\n",
    "<img src=\"Files/Vigenere_square.png\" width =\"600\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "## <font color=\"blue\">Pseudocode for Encrypting Messages</font>\n",
    "\n",
    "Just like with the Caesar cipher, we're going to use a Python function to encrypt text with the Vigenère cipher. Recall the steps to applying the cipher (if you want to look at the presentation we used earlier, [they're available at this link](https://docs.google.com/presentation/d/1FDoI811PzWi3jw52evW6hgssu3PiRhPuDO1t9bWDraE/edit?usp=sharing)). <font color=\"red\">**Working with your teammates, create your own pseudocode to apply the cipher to encrypt text. You can use the cell below (though you may not need all of the included lines, or you may want to add more), or write/draw something on your own paper.**</font> \n",
    "\n",
    "<font color=\"green\">Some suggestions as you write your pseudocode:</font>\n",
    "* Conisder starting with working out a single word in a single case, like \"TEST\" as we did in the presentation (or use all lowercase as in \"test\"). \n",
    "* Then start to add complexity: What needs to happen if you have a non-letter character, like a space or punctuation? How do you want your code to handle upper- vs. lowercase letters (e.g., should it just make everything uppercase, or will it handle them separately)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining the encryption function:\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"5\">🛑</font> <font color=red>**Let's wait for everyone to get here before going further.**</font> In your group, decide who will report out about your pseudocode and what challenges you encountered while creating it. If you finish early, here are a couple questions you can try to figure out:\n",
    "* How would you modify your pseudocode to create a decryption function?\n",
    "* Feel free to take a look at the actual method that's used in this notebook. Go back to the main Binder window (the one with the file list) and click on the `Files/` directory. In there is another notebook named `tools.ipynb` that contains the code we'll use here for the `Vigenere_encrypt()` function. Is your pseudocode similar to this function? What are the differences (e.g., are there steps done in a different order, or did you take a completely different approach)? If you did something different, you can try writing it up and testing it to see if you get the same answers. Note that if you name two functions the same thing in Python, it can make the code do weird things based on which function it decides to use, so make sure you name your function something different (e.g., `my_Vigenere_encrypt()`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "## <font color=\"blue\">Exchanging & Decrypting Messages<font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "#### <font color=blue>Before we start playing with ciphers...</font>\n",
    "We need to load some software that will enable us to use the Vigenère cipher.\n",
    "<font color=red>**Run the cell below.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT CHANGE THIS CELL\n",
    "# Behind-the-scenes tools to simplify code\n",
    "%run Files/tools.ipynb "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as with the Caesar cipher activity, you have access to a `Vigenere_encrypt()` and a `Vigenere_decrypt` method. Unlike the Caesar cipher, both functions require 2 arguments: (1) the text you want to encrypt and (2) the key for the cipher. <font color=\"red\">**Run the cells below.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Vigenere_encrypt(\"Hello world!\", 'key')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Vigenere_decrypt('Rijvs uyvjn!', 'key')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">**Using both the `Vigenere_encrypt` and `Vigenere_decrypt` functions, pass secret messages among your fellow students.**</font> Give the recipient a hint about the key, and see if they can figure it out (e.g., you can provide the first few letters of the original text). The empty cells below are provided for you to use; if you need additional cells, you can (1) click `Insert` in the menu bar and select one of the options to add a new cell, or (2) click the **`+`** sign below the menu bar, which adds a new cell below the currently selected cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"green\">(Optional) Interested in trying a bit more programming? During the Google Slides presentation, we talked about how the strongest key is a string of random letters that's the same length as the message to be encrypted (so there's no repeat characters for a frequency analysis), and that key can be used only once. Creating such a key by hand can be time-consuming, especially if it's a long message to be encrypted, but computer programming is a useful tool here, too! First, create some pseudocode for how you think a function to create a random key would work. Use the cell below, or write/draw on your own paper: </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining a function to generate a strong key with random letters:\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"green\">Now head over to the `tools.ipynb` notebook in the `Files/` directory (accessible from the main Binder window with the file list) and scroll down to the `random_key()` function. How is your pseudocode similar or different? Try out the function in the cell below.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"green\">(Optional) Want even more programming? Try out one (or more!) of the challenges at the end of the `tools.ipynb` notebook in the `Files/` directory!</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}