one_time_pad_answers_final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_to_decimal(sentence):\n",
    "    result = []  ##empty list to store results\n",
    "    \n",
    "    for i in range( len(sentence)):\n",
    "      \n",
    "    #[ENTER CODE]\n",
    "        # append result to list. remember that you use list_name[i]\n",
    "        # to iterate through a list. Use the ord function on each list \n",
    "        #element\n",
    "        \n",
    "        \n",
    "        result.append(ord(sentence[i]))\n",
    "        \n",
    "    print(\"result is\" + str(result) )\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    " \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#from Symmetric Key Encryption\n",
    "\n",
    "\n",
    "def decimal_to_binary_string(number_list):\n",
    "    \n",
    "    binary_string = \"\"\n",
    "    \n",
    "    for i in range(len(number_list)):\n",
    "        \n",
    "        bin_number_whole = bin(number_list[i])\n",
    "        \n",
    "        #chop the  \"Ob\" off of the binary conversion string output\n",
    "        \n",
    "        bin_number_chopped = bin_number_whole[2: len(bin_number_whole)]\n",
    "        \n",
    "        bin_number_chopped = \"0\" + bin_number_chopped\n",
    "        \n",
    "        \n",
    "        # To deal with the 'Space' unicode (32) we need to add a '0' at the head of the binary number to make it '00100000'\n",
    "        \n",
    "        if (bin_number_chopped == '0100000'):\n",
    "            bin_number_chopped = '0'+ bin_number_chopped\n",
    "            \n",
    "        #[ENTER CODE]   you should have a binary number in 8 bit form. now you need to append it to a string, but add a space at the tail \n",
    "        \n",
    "        binary_string += bin_number_chopped + ' '   \n",
    "        \n",
    "        print(\"binary number \" + str(i) + \" is \" + bin_number_chopped)\n",
    "        \n",
    "    print(\"binary string is \" + binary_string)\n",
    "    return binary_string\n",
    "        \n",
    "        #iterate through list of numbers, converting each number to binary and appending\n",
    "       # it to a string. You should end up with a long string of 0's and 1's\n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode(binary_string):\n",
    "    \n",
    "    end_string = '' # create and empty string\n",
    "    \n",
    "    for i in range (0,len(binary_string), 9): \n",
    "        \n",
    "       my_binary = binary_string[i : i+9]\n",
    "       \n",
    "       print(\"my_binary is \" + my_binary)\n",
    "    \n",
    "       my_int = int(my_binary,2)\n",
    "        \n",
    "       print( \"my_int is \" + str(my_int)) \n",
    "        \n",
    "       my_character = chr(my_int) \n",
    "        \n",
    "       print(\"my_character is \" + my_character)\n",
    "    \n",
    "    \n",
    "       # [ENTER CODE] append the decoded character my_character to end_string\n",
    " \n",
    "    \n",
    "       end_string += my_character\n",
    "        \n",
    "       \n",
    "       # Remember that you can't use the append function here. Why? What\n",
    "        # alternative method can you use?\n",
    "    print(end_string)    \n",
    "    return end_string       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One Time Pad: New functions\n",
    "\n",
    "Here are the new functions. You can run the main program once you have pasted the necessary functions from the Symmetric Key Encryption activity. From there, use the sanity checks to help you finish the new functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def secret_key_generator(desired_length):\n",
    "    \n",
    "    key = ''\n",
    "    for i in range(desired_length):\n",
    "        for j in range(8):\n",
    "            key+= str(random.randint(0,1)) \n",
    "    \n",
    "        key+= \" \"\n",
    "    return key\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_time_encrypt(original_binary_message, key):\n",
    "    \n",
    "    if(len(original_binary_message)< len(key)):\n",
    "        \n",
    "        difference = len(original_binary_message) - len(key)\n",
    "        \n",
    "        print( \"Key is longer than message, don't need \" + str(abs(difference)) + \" key digits \")\n",
    "        \n",
    "        key = key[0: (len(key) - difference)]  \n",
    "    \n",
    "   # print(chopped_secret_key)\n",
    "   # print(len(chopped_secret_key))\n",
    "    \n",
    "    encrypted_binary_string = ''\n",
    "    \n",
    "    print( \"key is \" + key)\n",
    "    \n",
    "    for i in range(len(original_binary_message)):\n",
    "     \n",
    "      #[ENTER CODE] Apply mod 2 sum logic\n",
    "                   \n",
    "         if ((original_binary_message[i] == '0') and (key[i] == '0')):\n",
    "            encrypted_binary_string += '0'\n",
    "            \n",
    "         if ((original_binary_message[i] == '0') and (key[i] == '1')):\n",
    "            encrypted_binary_string += '1'  \n",
    "            \n",
    "         if ((original_binary_message[i] == '1') and (key[i] == '0')):\n",
    "            encrypted_binary_string += '1'  \n",
    "            \n",
    "         if ((original_binary_message[i] == '1') and (key[i] == '1')):\n",
    "            encrypted_binary_string += '0' \n",
    "        \n",
    "         if ((original_binary_message[i] == ' ') and (key[i] == ' ')):\n",
    "            encrypted_binary_string += ' '  \n",
    "      \n",
    "         #print ( \"encrypted string so far \" + encrypted_binary_string )\n",
    "            \n",
    "    return  encrypted_binary_string  \n",
    "               \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Eve intercepts\n",
    "\n",
    "What would it look like if Eve intercepted the encrypted binary string, and then tried to decode into decimal and back to characters? What would Eve see? This function is complete, and essentially the same as the decode function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eve_attempt(encrypted_binary_string):\n",
    "    \n",
    "    gibberish_end_string = '' # create and empty string\n",
    "    \n",
    "    for i in range (0,len(encrypted_binary_string), 9): \n",
    "        \n",
    "       my_binary = encrypted_binary_string[i : i+9]\n",
    "       \n",
    "       #print(\"my_binary is \" + my_binary)\n",
    "    \n",
    "       my_int = int(my_binary,2)\n",
    "        \n",
    "       #print( \"my_int is \" + str(my_int)) \n",
    "        \n",
    "       my_character = chr(my_int) \n",
    "        \n",
    "       #print(\"my_character is \" + my_character)\n",
    "    \n",
    "    \n",
    "       # [ENTER CODE] append the decoded character my_character to end_string\n",
    "       gibberish_end_string += my_character\n",
    "        \n",
    "       \n",
    "       # Remember that you can't use the append function here. Why? What\n",
    "        # alternative method can you use?\n",
    "    print(\"Eve intercepts encrypted string, sees this : \" + gibberish_end_string)    \n",
    "    return gibberish_end_string \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apply_key( encrypted_binary_string, key):\n",
    "    \n",
    "    unencrypted_binary_string = ''\n",
    "        \n",
    "    print( \"encrypted_binary_string \" + encrypted_binary_string)\n",
    "    print(\"key is \" + key)\n",
    "    \n",
    "    for i in range(len(encrypted_binary_string)):\n",
    "    \n",
    "        # [ENTER CODE] Apply mod 2 sum logic\n",
    "\n",
    "        if ((encrypted_binary_string[i] == '0') and (key[i] == '0')):\n",
    "                   unencrypted_binary_string  += '0'\n",
    "\n",
    "        if ((encrypted_binary_string[i] == '0') and (key[i] == '1')):\n",
    "                   unencrypted_binary_string  += '1'  \n",
    "\n",
    "        if ((encrypted_binary_string[i] == '1') and (key[i] == '0')):\n",
    "                   unencrypted_binary_string  += '1'  \n",
    "\n",
    "        if ((encrypted_binary_string[i] == '1') and (key[i] == '1')):\n",
    "                     unencrypted_binary_string += '0'\n",
    "        \n",
    "        if ((encrypted_binary_string[i] == ' ') and (key[i] == ' ')):\n",
    "                     unencrypted_binary_string += ' '\n",
    "    \n",
    "    return  unencrypted_binary_string  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input a sentence for encryption goo\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result is[103, 111, 111]\n",
      "binary number 0 is 01100111\n",
      "binary number 1 is 01101111\n",
      "binary number 2 is 01101111\n",
      "binary string is 01100111 01101111 01101111 \n",
      "key is 11101000 01000111 00101100 \n",
      "Eve sees this : (C\n",
      "encrypted_binary_string 10001111 00101000 01000011 \n",
      "key is 11101000 01000111 00101100 \n",
      "my_binary is 01100111 \n",
      "my_int is 103\n",
      "my_character is g\n",
      "my_binary is 01101111 \n",
      "my_int is 111\n",
      "my_character is o\n",
      "my_binary is 01101111 \n",
      "my_int is 111\n",
      "my_character is o\n",
      "goo\n"
     ]
    }
   ],
   "source": [
    "# This bit is called the main() part. It allows the python file to run \n",
    "#by itself. You can dowload this file as .py and run it on your command\n",
    "#line if you are on a laptop or desktop once this is done.\n",
    "\n",
    "\n",
    "def main():\n",
    "    s = input(\"Input a sentence for encryption\")\n",
    "    encoded_message = encode_to_decimal(s)\n",
    "    my_binary_string = decimal_to_binary_string(encoded_message)\n",
    "    \n",
    "    #generate key\n",
    "    \n",
    "    my_key = secret_key_generator( len(encoded_message))\n",
    "    \n",
    "    my_encrypted_binary_string = one_time_encrypt(my_binary_string, my_key)\n",
    "    \n",
    "    #Eve attempts to intercept!\n",
    "    \n",
    "    eve_attempt (my_encrypted_binary_string)\n",
    "\n",
    "    my_unencrypted_binary_string = apply_key( my_encrypted_binary_string, my_key )\n",
    "    \n",
    "    \n",
    "    \n",
    "    decode(my_unencrypted_binary_string )\n",
    "    \n",
    "    \n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}