ssh_keys.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# example of Diffie-Hellman-Merkle key exchange\n",
    "\n",
    "check out [this article](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) on DHM key exchange. extra shoutout to the example, which is super helpful and what we're about to do here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner up!\n",
    "\n",
    "pair up. One of you is partner 1, the other is partner 2. Both of you should execute the following (don't change these numbers!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "p = 23\n",
    "g = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "afterward, go through you respective section below and think about each cell you execute. Then, switch roles and try again"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner 1 does this\n",
    "\n",
    "this person is Alice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*pick a secret number! Don't tell anyone!!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1secretnumber = random.randint(1, 100)\n",
    "p1secretnumber"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*prepare a special number to send to partner 2*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forp2 = (g ** p1secretnumber) % p\n",
    "forp2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*give that number to partner 2 and then wait for them to get back to you*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what number did partner 2 give back to you? 14\n"
     ]
    }
   ],
   "source": [
    "fromp2 = int(input('what number did partner 2 give back to you? '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1result = (fromp2 ** p1secretnumber) % p\n",
    "p1result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*check with partner 2 that you have the same values. Then switch roles*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner 2 does this\n",
    "\n",
    "this person is Bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*wait for a special number from partner 1*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what number did partner 1 give you? 21\n"
     ]
    }
   ],
   "source": [
    "fromp1 = int(input(\"what number did partner 1 give you? \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*now you choose your own secret, don't tell partner 1 or anyone!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2secretnumber = random.randint(1, 100)\n",
    "p2secretnumber"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forp1 = (g ** p2secretnumber) % p\n",
    "forp1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*give that number back to partner 1 and move on*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2result = (fromp1 ** p2secretnumber) % p\n",
    "p2result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*check with partner 1 that you have the same values. Then switch roles*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## why does this work?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this is simply the result of a property of prime numbers:\n",
    "\n",
    "$$\n",
    "\\left(a \\cdot b\\right) \\mod n = \\left((a \\mod n) \\cdot (b \\mod n)\\right) \\mod n\n",
    "$$\n",
    "\n",
    "to prove: you could write $a = d_a * n + r_a$, and same with b. multiply $a$ and $b$ and all but the remainder terms (the results of the modulo expressions themselves) will fall out because they will have at least one factor of $n$\n",
    "\n",
    "as a result\n",
    "\n",
    "$$\n",
    "\\left(g^a \\mod p\\right)^b = g^{ab} \\mod p \\\\\n",
    "\\left(g^b \\mod p\\right)^a = g^{ba} \\mod p\n",
    "$$\n",
    "\n",
    "and the value that you get from that is necessarily identical."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## primitive root diversion\n",
    "\n",
    "check out [this article](https://en.wikipedia.org/wiki/Primitive_root_modulo_n) on primitive roots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 9, 27, 81, 243, 729]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[3 ** i for i in range(1, 7)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 6, 4, 5, 1]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(3 ** i) % 7 for i in range(1, 7)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_primitive(root, modulus):\n",
    "    return set(range(1, modulus)) == {(root ** i) % modulus for i in range(1, modulus)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "assert is_primitive(g, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## concluding thoughts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the process of picking secret numbers and using modulo exponentiation tricks as we did above has one cool feature: between partner 1's secret number, partner 2's secret number, and the secret result, no one in the room knows all three numbers. This is important for public exchange of information -- we just created one shared secret using mutually un-shared secrets.\n",
    "\n",
    "I wonder if there's an application here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# making it a bit harder: RSA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do something similar now, but add in a bit more mathematical complexity (we're paranoid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner up!\n",
    "\n",
    "Same drill, but now you don't even start with the same information. go through you respective section below and think about each cell you execute. Then, switch roles and try again"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner 1 does this\n",
    "\n",
    "this person is Alice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*pick two prime numbers with different orders of magnitude. then multiply them -- that's our modulus now*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25831"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 1987\n",
    "q = 13\n",
    "\n",
    "n = p * q\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*now we do some magic with least common multiples (functions stolend from [here](https://stackoverflow.com/questions/147515/least-common-multiple-for-3-or-more-numbers))*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ripped straight from here\n",
    "def gcd(a, b):\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a\n",
    "\n",
    "def lcm(a, b):\n",
    "    return a * b // gcd(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*calculate the following SUPER SECRET NUMBER*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3972"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambdaN = lcm(p - 1, q - 1)\n",
    "lambdaN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*find any number $1 < e < \\lambda_n$ such that $e$ and $\\lambda_n$ are coprime*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "845"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# note: this is a fun but super dumb way to do this. In practice we often just use \n",
    "# a favorite number (e.g. 2^16 + 1) every time\n",
    "\n",
    "while True:\n",
    "    e = random.randint(1, lambdaN)\n",
    "    if gcd(e, lambdaN) == 1:\n",
    "        break\n",
    "        \n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# this cell is set aside for hard-coding the value of e.\n",
    "# uncomment the line below to hard-code e to a value of 451\n",
    "\n",
    "#e = 451"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*find the [modular multiplicative inverse](https://en.wikipedia.org/wiki/Modular_multiplicative_inverse) of $e$ modulo $\\lambda_n$*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "785"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = 1\n",
    "while True:\n",
    "    if (d * e) % lambdaN == 1:\n",
    "        break\n",
    "    d += 1\n",
    "        \n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MY PUBLIC KEYS ARE\n",
      "  n = 25831\n",
      "  e = 845 (e is for \"encryption\")\n",
      "\n",
      "MY PRIVATE KEYS ARE\n",
      "  n = 25831\n",
      "  d = 785 (d is for \"decryption\")\n",
      "\n",
      "I should also keep the following secret, because they could be used to calculate d:\n",
      "  p = 1987\n",
      "  q = 13\n",
      "  lambdaN = 3972\n",
      "\n",
      "so mind your ps and qs, gang\n"
     ]
    }
   ],
   "source": [
    "print('MY PUBLIC KEYS ARE')\n",
    "print('  n = {}'.format(n))\n",
    "print('  e = {} (e is for \"encryption\")'.format(e))\n",
    "print('\\nMY PRIVATE KEYS ARE')\n",
    "print('  n = {}'.format(n))\n",
    "print('  d = {} (d is for \"decryption\")'.format(d))\n",
    "print('\\nI should also keep the following secret, because they could be used to calculate d:')\n",
    "print('  p = {}'.format(p))\n",
    "print('  q = {}'.format(q))\n",
    "print('  lambdaN = {}'.format(lambdaN))\n",
    "print('\\nso mind your ps and qs, gang')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*send your public key values $n$ and $e$ to your partner and move on*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "was the encrypted message partner 2 gave you? 595\n"
     ]
    }
   ],
   "source": [
    "encryptedMessage = int(input('was the encrypted message partner 2 gave you? '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*let's decrypt that message*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1447"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# note -- d below is totally private, partner 2 doesn't know it\n",
    "decryptedMessage = (encryptedMessage ** d) % n\n",
    "decryptedMessage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*check with partner 2 that you have the same values. Then switch roles*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## partner 2 does this\n",
    "\n",
    "this person is Bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*wait for a pair of special numbers from partner 1*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what number did partner 1 give you for n? 25831\n",
      "what number did partner 1 give you for e? 845\n"
     ]
    }
   ],
   "source": [
    "fromp1n = int(input(\"what number did partner 1 give you for n? \"))\n",
    "fromp1e = int(input(\"what number did partner 1 give you for e? \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*let's send a message to our partner*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "595"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message = 1447\n",
    "encryptedMessage = (message ** fromp1e) % fromp1n\n",
    "encryptedMessage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*give that encrypted message to partner 1*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*check with partner 1 that they got your message. Then switch roles*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# advanced: ssh keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the convoluted process above is effectively exactly what is going on when you log in to your `ec2` server. the `ssh` private and public keys that you create are complex files which contain (among several other things) those `n`, `e`, and `d` values we created in the previous section. \n",
    "\n",
    "the following section will show you that there is a complex structure to these private and public keys, but underneath it all it is really just a very compact means of communicating several large integers.\n",
    "\n",
    "let's start by creating a public and private key and seeing how that works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in a shell session, execute the following:\n",
    "\n",
    "```shell\n",
    "ssh-keygen -t rsa\n",
    "```\n",
    "\n",
    "and at the prompt, enter\n",
    "\n",
    "```\n",
    "/tmp/key\n",
    "```\n",
    "\n",
    "as the path of the key. you can pick a different path if you'd like; you will have to update the cells below, though. \n",
    "\n",
    "Do not enter a password."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's read that private key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----BEGIN RSA PRIVATE KEY-----\n",
      "MIIEpAIBAAKCAQEAumH2f/6cmk0FyMbNpBgfr6+AOybWoMG8L8G+Vq4jQ3FBuWu9\n",
      "AWYsqE/OxET8g6Us7tvtrVGnYyNb5wWgpN5AC8CIRpKZBymtfeUQtXF+QdBidmiZ\n",
      "An+UuFOYF1X/hCnrT/g0OxCePG3nNTNEU2h0qCkythJeM++jfL8CHnDDhC102BPR\n",
      "qYoQk3LE+Mxq4LwOWhB2XnU6NBw1K3Lm75kjvcCfTponcWaGqlX8LkQLCWN/1c2k\n",
      "lpD4v6MxmMQn0yOzDM3X9/DvOiWfoAILbNzCkYAXVTwMyLzKg8HCcd66t9ppdkmX\n",
      "/3F/Gwmw9NqPbI5zkdorPD5Hd9QVylP358RwLwIDAQABAoIBADHM0RdcCa303JHM\n",
      "BNBOndDMfN/RPdHQUh8Ujm4Ms2Fm1p/bmLHSAiaqxF2O7UWjkcD0xKnlwmrr3Ld6\n",
      "unSy6bv6Iq9wpjDSwwd7eB5zB8BAFL78rb2MJ0mlFGNP2CkRJk3EzPfnNdCBsSB2\n",
      "5U+//kOcVm9tsvv/kNhZFRDbInKjWfIvB/0hmUf3V2kj4oTX2ghhdw/nCV0kPt9I\n",
      "pWqIgOlk3alUxMLVJgeRQ7rVpdsnYbdq++XTvSG/KbVtwjsHtn/LYU27gpitG0xa\n",
      "nn6c8qYAaGUs802D68Gig7GggpJOwdI3EMpudB9mWd3wK/czBl/f4AxopyILhU/8\n",
      "2W3oNxkCgYEA3YCHal2WT4UijAbrQFqaIZdjD78qyClzkYf0sfY4J0kS1GCLhArL\n",
      "67tYzpQJ4FKQvNpWYLpHyb3sJu1BKmvZxgyydZDLi+OeYBdnpQOiawp90079CGUM\n",
      "LKiv4B8tYUieJUctvwSfEYYc0YRftsIik1RGpNh2hddKxjMmByYkChMCgYEA12kx\n",
      "wsSNsLBFvB4VkSQxHb8h1nhBb6B4IcRVzagF7h2b7U/TSEE5NoCm9ppWsZwu7JPN\n",
      "4Vucg8NFdQCxJfIz9bEIUbw0T0NLJfUjfPrf1Fkw3dOOQwbTBtRTjK48giM1twjH\n",
      "RjzeaGibZSTeK/2iksJgBaH5u2sUDugu3rg3hPUCgYEAw4BSBTudE4q6t0TUFvTg\n",
      "3Y00zg04wXp0mpqZCwn6/hGtIO4lteGhouq0s4BOR0QYo9dCLhW8jv+mk6UMw1h1\n",
      "2iwSx1mJjmrUupNt02Ol0zxrWjp5cxNc733j3bkm4JqrmtN8OQDnNRxeCz7/C9vF\n",
      "kKvtvkmgMvmW8eDrS5wKaykCgYEAuN6SEzrG843Eu3cCQWdTM9lWPA9G8XtBvpEW\n",
      "poJ+XGZS7O8mQAuiA3GUWW4J2zJUXztWZQNPpxGOaaTnY86i40hFAIjKSABT3Uau\n",
      "Z1OTh1Xoh2hJ3qJbt6+/6KucSH/ZWLWS+GfC5M5qFvr2JcDupo9lA1CI2F1EgKqp\n",
      "lwF4vIUCgYB7WUzrn+7ROr3vkVJqG77mKDv/GQ2FdVsV6iUUIrOreeUKSWZdfj31\n",
      "DAsP/yyIH40d/w0oUR64BMv/P3TYIO1nGSU888XJ1lODhDAEdhropSj9thA6mRk2\n",
      "XAj2pG84jdqX2W7eCet3iNnp8QeVrBswCOlzMo82mzKr28EhwGrEig==\n",
      "-----END RSA PRIVATE KEY-----\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "less /tmp/key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if you received an error, go back and make sure you used `ssh-keygen` to create `/tmp/key` as described two cells above.\n",
    "\n",
    "remember -- if you're sharing this (like I am, by publishing this), this private key is *totally worthless*\n",
    "\n",
    "there is also a \"public\" version of this key, created with the same name and an additional `.pub` extension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC6YfZ//pyaTQXIxs2kGB+vr4A7Jtagwbwvwb5WriNDcUG5a70BZiyoT87ERPyDpSzu2+2tUadjI1vnBaCk3kALwIhGkpkHKa195RC1cX5B0GJ2aJkCf5S4U5gXVf+EKetP+DQ7EJ48bec1M0RTaHSoKTK2El4z76N8vwIecMOELXTYE9GpihCTcsT4zGrgvA5aEHZedTo0HDUrcubvmSO9wJ9OmidxZoaqVfwuRAsJY3/VzaSWkPi/ozGYxCfTI7MMzdf38O86JZ+gAgts3MKRgBdVPAzIvMqDwcJx3rq32ml2SZf/cX8bCbD02o9sjnOR2is8Pkd31BXKU/fnxHAv zlamberty@megaman\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "less /tmp/key.pub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## key structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keys above look like a bunch of random characters, but there is a complicated structure in that string of characters.\n",
    "\n",
    "These keys can both be parsed into a particular structured format called ASN.1. You can use linux tools to do this parsing, (see below), or you can go to [this awesome online parser site](http://lapo.it/asn1js/).\n",
    "\n",
    "**note**: you have to do a little conversion to the public key (see two cells below) before the online parser commands will work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    0:d=0  hl=4 l=1188 cons: SEQUENCE          \n",
      "    4:d=1  hl=2 l=   1 prim: INTEGER           :00\n",
      "    7:d=1  hl=4 l= 257 prim: INTEGER           :BA61F67FFE9C9A4D05C8C6CDA4181FAFAF803B26D6A0C1BC2FC1BE56AE23437141B96BBD01662CA84FCEC444FC83A52CEEDBEDAD51A763235BE705A0A4DE400BC0884692990729AD7DE510B5717E41D062766899027F94B853981755FF8429EB4FF8343B109E3C6DE7353344536874A82932B6125E33EFA37CBF021E70C3842D74D813D1A98A109372C4F8CC6AE0BC0E5A10765E753A341C352B72E6EF9923BDC09F4E9A27716686AA55FC2E440B09637FD5CDA49690F8BFA33198C427D323B30CCDD7F7F0EF3A259FA0020B6CDCC2918017553C0CC8BCCA83C1C271DEBAB7DA69764997FF717F1B09B0F4DA8F6C8E7391DA2B3C3E4777D415CA53F7E7C4702F\n",
      "  268:d=1  hl=2 l=   3 prim: INTEGER           :010001\n",
      "  273:d=1  hl=4 l= 256 prim: INTEGER           :31CCD1175C09ADF4DC91CC04D04E9DD0CC7CDFD13DD1D0521F148E6E0CB36166D69FDB98B1D20226AAC45D8EED45A391C0F4C4A9E5C26AEBDCB77ABA74B2E9BBFA22AF70A630D2C3077B781E7307C04014BEFCADBD8C2749A514634FD82911264DC4CCF7E735D081B12076E54FBFFE439C566F6DB2FBFF90D8591510DB2272A359F22F07FD219947F7576923E284D7DA0861770FE7095D243EDF48A56A8880E964DDA954C4C2D526079143BAD5A5DB2761B76AFBE5D3BD21BF29B56DC23B07B67FCB614DBB8298AD1B4C5A9E7E9CF2A60068652CF34D83EBC1A283B1A082924EC1D23710CA6E741F6659DDF02BF733065FDFE00C68A7220B854FFCD96DE83719\n",
      "  533:d=1  hl=3 l= 129 prim: INTEGER           :DD80876A5D964F85228C06EB405A9A2197630FBF2AC829739187F4B1F638274912D4608B840ACBEBBB58CE9409E05290BCDA5660BA47C9BDEC26ED412A6BD9C60CB27590CB8BE39E601767A503A26B0A7DD34EFD08650C2CA8AFE01F2D61489E25472DBF049F11861CD1845FB6C222935446A4D87685D74AC633260726240A13\n",
      "  665:d=1  hl=3 l= 129 prim: INTEGER           :D76931C2C48DB0B045BC1E159124311DBF21D678416FA07821C455CDA805EE1D9BED4FD34841393680A6F69A56B19C2EEC93CDE15B9C83C3457500B125F233F5B10851BC344F434B25F5237CFADFD45930DDD38E4306D306D4538CAE3C822335B708C7463CDE68689B6524DE2BFDA292C26005A1F9BB6B140EE82EDEB83784F5\n",
      "  797:d=1  hl=3 l= 129 prim: INTEGER           :C38052053B9D138ABAB744D416F4E0DD8D34CE0D38C17A749A9A990B09FAFE11AD20EE25B5E1A1A2EAB4B3804E474418A3D7422E15BC8EFFA693A50CC35875DA2C12C759898E6AD4BA936DD363A5D33C6B5A3A7973135CEF7DE3DDB926E09AAB9AD37C3900E7351C5E0B3EFF0BDBC590ABEDBE49A032F996F1E0EB4B9C0A6B29\n",
      "  929:d=1  hl=3 l= 129 prim: INTEGER           :B8DE92133AC6F38DC4BB770241675333D9563C0F46F17B41BE9116A6827E5C6652ECEF26400BA2037194596E09DB32545F3B5665034FA7118E69A4E763CEA2E348450088CA480053DD46AE6753938755E8876849DEA25BB7AFBFE8AB9C487FD958B592F867C2E4CE6A16FAF625C0EEA68F65035088D85D4480AAA9970178BC85\n",
      " 1061:d=1  hl=3 l= 128 prim: INTEGER           :7B594CEB9FEED13ABDEF91526A1BBEE6283BFF190D85755B15EA251422B3AB79E50A49665D7E3DF50C0B0FFF2C881F8D1DFF0D28511EB804CBFF3F74D820ED6719253CF3C5C9D65383843004761AE8A528FDB6103A9919365C08F6A46F388DDA97D96EDE09EB7788D9E9F10795AC1B3008E973328F369B32ABDBC121C06AC48A\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "openssl asn1parse -in /tmp/key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the public key (`/tmp/key.pub`) is in openssh format, which is not the expected format (`pem`) for the `openssl` tool. fortunately, we can make the conversion pretty easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----BEGIN RSA PUBLIC KEY-----\n",
      "MIIBCgKCAQEAumH2f/6cmk0FyMbNpBgfr6+AOybWoMG8L8G+Vq4jQ3FBuWu9AWYs\n",
      "qE/OxET8g6Us7tvtrVGnYyNb5wWgpN5AC8CIRpKZBymtfeUQtXF+QdBidmiZAn+U\n",
      "uFOYF1X/hCnrT/g0OxCePG3nNTNEU2h0qCkythJeM++jfL8CHnDDhC102BPRqYoQ\n",
      "k3LE+Mxq4LwOWhB2XnU6NBw1K3Lm75kjvcCfTponcWaGqlX8LkQLCWN/1c2klpD4\n",
      "v6MxmMQn0yOzDM3X9/DvOiWfoAILbNzCkYAXVTwMyLzKg8HCcd66t9ppdkmX/3F/\n",
      "Gwmw9NqPbI5zkdorPD5Hd9QVylP358RwLwIDAQAB\n",
      "-----END RSA PUBLIC KEY-----\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "ssh-keygen -f /tmp/key.pub -e -m pem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "take that key and write it to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    0:d=0  hl=4 l= 266 cons: SEQUENCE          \n",
      "    4:d=1  hl=4 l= 257 prim:  INTEGER           :BA61F67FFE9C9A4D05C8C6CDA4181FAFAF803B26D6A0C1BC2FC1BE56AE23437141B96BBD01662CA84FCEC444FC83A52CEEDBEDAD51A763235BE705A0A4DE400BC0884692990729AD7DE510B5717E41D062766899027F94B853981755FF8429EB4FF8343B109E3C6DE7353344536874A82932B6125E33EFA37CBF021E70C3842D74D813D1A98A109372C4F8CC6AE0BC0E5A10765E753A341C352B72E6EF9923BDC09F4E9A27716686AA55FC2E440B09637FD5CDA49690F8BFA33198C427D323B30CCDD7F7F0EF3A259FA0020B6CDCC2918017553C0CC8BCCA83C1C271DEBAB7DA69764997FF717F1B09B0F4DA8F6C8E7391DA2B3C3E4777D415CA53F7E7C4702F\n",
      "  265:d=1  hl=2 l=   3 prim:  INTEGER           :010001\n",
      "  270:d=0  hl=4 l= 266 cons: SEQUENCE          \n",
      "  274:d=1  hl=4 l= 257 prim:  INTEGER           :BA61F67FFE9C9A4D05C8C6CDA4181FAFAF803B26D6A0C1BC2FC1BE56AE23437141B96BBD01662CA84FCEC444FC83A52CEEDBEDAD51A763235BE705A0A4DE400BC0884692990729AD7DE510B5717E41D062766899027F94B853981755FF8429EB4FF8343B109E3C6DE7353344536874A82932B6125E33EFA37CBF021E70C3842D74D813D1A98A109372C4F8CC6AE0BC0E5A10765E753A341C352B72E6EF9923BDC09F4E9A27716686AA55FC2E440B09637FD5CDA49690F8BFA33198C427D323B30CCDD7F7F0EF3A259FA0020B6CDCC2918017553C0CC8BCCA83C1C271DEBAB7DA69764997FF717F1B09B0F4DA8F6C8E7391DA2B3C3E4777D415CA53F7E7C4702F\n",
      "  535:d=1  hl=2 l=   3 prim:  INTEGER           :010001\n",
      "  540:d=0  hl=4 l= 266 cons: SEQUENCE          \n",
      "  544:d=1  hl=4 l= 257 prim:  INTEGER           :BA61F67FFE9C9A4D05C8C6CDA4181FAFAF803B26D6A0C1BC2FC1BE56AE23437141B96BBD01662CA84FCEC444FC83A52CEEDBEDAD51A763235BE705A0A4DE400BC0884692990729AD7DE510B5717E41D062766899027F94B853981755FF8429EB4FF8343B109E3C6DE7353344536874A82932B6125E33EFA37CBF021E70C3842D74D813D1A98A109372C4F8CC6AE0BC0E5A10765E753A341C352B72E6EF9923BDC09F4E9A27716686AA55FC2E440B09637FD5CDA49690F8BFA33198C427D323B30CCDD7F7F0EF3A259FA0020B6CDCC2918017553C0CC8BCCA83C1C271DEBAB7DA69764997FF717F1B09B0F4DA8F6C8E7391DA2B3C3E4777D415CA53F7E7C4702F\n",
      "  805:d=1  hl=2 l=   3 prim:  INTEGER           :010001\n",
      "  810:d=0  hl=4 l= 266 cons: SEQUENCE          \n",
      "  814:d=1  hl=4 l= 257 prim:  INTEGER           :BA61F67FFE9C9A4D05C8C6CDA4181FAFAF803B26D6A0C1BC2FC1BE56AE23437141B96BBD01662CA84FCEC444FC83A52CEEDBEDAD51A763235BE705A0A4DE400BC0884692990729AD7DE510B5717E41D062766899027F94B853981755FF8429EB4FF8343B109E3C6DE7353344536874A82932B6125E33EFA37CBF021E70C3842D74D813D1A98A109372C4F8CC6AE0BC0E5A10765E753A341C352B72E6EF9923BDC09F4E9A27716686AA55FC2E440B09637FD5CDA49690F8BFA33198C427D323B30CCDD7F7F0EF3A259FA0020B6CDCC2918017553C0CC8BCCA83C1C271DEBAB7DA69764997FF717F1B09B0F4DA8F6C8E7391DA2B3C3E4777D415CA53F7E7C4702F\n",
      " 1075:d=1  hl=2 l=   3 prim:  INTEGER           :010001\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "ssh-keygen -f /tmp/key.pub -e -m pem >> /tmp/key.pub.pem\n",
    "PUBKEY=$(grep -v -- ----- /tmp/key.pub.pem | tr -d '\\n')\n",
    "echo $PUBKEY | base64 -d | openssl asn1parse -inform DER -i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "both the public and private keys can be broken up into sequences of integers. Note that the first large integer in the private key (three cells above) is *identical* to the first large integer in the public key (cell immediately above).\n",
    "\n",
    "this is proof of one of the claims we made in class: the public key can always be constructed from the private key, because the private key contains it in its entirety."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the structure above isn't exactly the most convenient to use, is it? We may have demonstrated that a structure *exists*, but what is it telling us?\n",
    "\n",
    "fortunately, the `openssl` command has the subcommand `rsa` which allows us to print out those values a little more explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Private-Key: (2048 bit)\n",
      "modulus:\n",
      "    00:ba:61:f6:7f:fe:9c:9a:4d:05:c8:c6:cd:a4:18:\n",
      "    1f:af:af:80:3b:26:d6:a0:c1:bc:2f:c1:be:56:ae:\n",
      "    23:43:71:41:b9:6b:bd:01:66:2c:a8:4f:ce:c4:44:\n",
      "    fc:83:a5:2c:ee:db:ed:ad:51:a7:63:23:5b:e7:05:\n",
      "    a0:a4:de:40:0b:c0:88:46:92:99:07:29:ad:7d:e5:\n",
      "    10:b5:71:7e:41:d0:62:76:68:99:02:7f:94:b8:53:\n",
      "    98:17:55:ff:84:29:eb:4f:f8:34:3b:10:9e:3c:6d:\n",
      "    e7:35:33:44:53:68:74:a8:29:32:b6:12:5e:33:ef:\n",
      "    a3:7c:bf:02:1e:70:c3:84:2d:74:d8:13:d1:a9:8a:\n",
      "    10:93:72:c4:f8:cc:6a:e0:bc:0e:5a:10:76:5e:75:\n",
      "    3a:34:1c:35:2b:72:e6:ef:99:23:bd:c0:9f:4e:9a:\n",
      "    27:71:66:86:aa:55:fc:2e:44:0b:09:63:7f:d5:cd:\n",
      "    a4:96:90:f8:bf:a3:31:98:c4:27:d3:23:b3:0c:cd:\n",
      "    d7:f7:f0:ef:3a:25:9f:a0:02:0b:6c:dc:c2:91:80:\n",
      "    17:55:3c:0c:c8:bc:ca:83:c1:c2:71:de:ba:b7:da:\n",
      "    69:76:49:97:ff:71:7f:1b:09:b0:f4:da:8f:6c:8e:\n",
      "    73:91:da:2b:3c:3e:47:77:d4:15:ca:53:f7:e7:c4:\n",
      "    70:2f\n",
      "publicExponent: 65537 (0x10001)\n",
      "privateExponent:\n",
      "    31:cc:d1:17:5c:09:ad:f4:dc:91:cc:04:d0:4e:9d:\n",
      "    d0:cc:7c:df:d1:3d:d1:d0:52:1f:14:8e:6e:0c:b3:\n",
      "    61:66:d6:9f:db:98:b1:d2:02:26:aa:c4:5d:8e:ed:\n",
      "    45:a3:91:c0:f4:c4:a9:e5:c2:6a:eb:dc:b7:7a:ba:\n",
      "    74:b2:e9:bb:fa:22:af:70:a6:30:d2:c3:07:7b:78:\n",
      "    1e:73:07:c0:40:14:be:fc:ad:bd:8c:27:49:a5:14:\n",
      "    63:4f:d8:29:11:26:4d:c4:cc:f7:e7:35:d0:81:b1:\n",
      "    20:76:e5:4f:bf:fe:43:9c:56:6f:6d:b2:fb:ff:90:\n",
      "    d8:59:15:10:db:22:72:a3:59:f2:2f:07:fd:21:99:\n",
      "    47:f7:57:69:23:e2:84:d7:da:08:61:77:0f:e7:09:\n",
      "    5d:24:3e:df:48:a5:6a:88:80:e9:64:dd:a9:54:c4:\n",
      "    c2:d5:26:07:91:43:ba:d5:a5:db:27:61:b7:6a:fb:\n",
      "    e5:d3:bd:21:bf:29:b5:6d:c2:3b:07:b6:7f:cb:61:\n",
      "    4d:bb:82:98:ad:1b:4c:5a:9e:7e:9c:f2:a6:00:68:\n",
      "    65:2c:f3:4d:83:eb:c1:a2:83:b1:a0:82:92:4e:c1:\n",
      "    d2:37:10:ca:6e:74:1f:66:59:dd:f0:2b:f7:33:06:\n",
      "    5f:df:e0:0c:68:a7:22:0b:85:4f:fc:d9:6d:e8:37:\n",
      "    19\n",
      "prime1:\n",
      "    00:dd:80:87:6a:5d:96:4f:85:22:8c:06:eb:40:5a:\n",
      "    9a:21:97:63:0f:bf:2a:c8:29:73:91:87:f4:b1:f6:\n",
      "    38:27:49:12:d4:60:8b:84:0a:cb:eb:bb:58:ce:94:\n",
      "    09:e0:52:90:bc:da:56:60:ba:47:c9:bd:ec:26:ed:\n",
      "    41:2a:6b:d9:c6:0c:b2:75:90:cb:8b:e3:9e:60:17:\n",
      "    67:a5:03:a2:6b:0a:7d:d3:4e:fd:08:65:0c:2c:a8:\n",
      "    af:e0:1f:2d:61:48:9e:25:47:2d:bf:04:9f:11:86:\n",
      "    1c:d1:84:5f:b6:c2:22:93:54:46:a4:d8:76:85:d7:\n",
      "    4a:c6:33:26:07:26:24:0a:13\n",
      "prime2:\n",
      "    00:d7:69:31:c2:c4:8d:b0:b0:45:bc:1e:15:91:24:\n",
      "    31:1d:bf:21:d6:78:41:6f:a0:78:21:c4:55:cd:a8:\n",
      "    05:ee:1d:9b:ed:4f:d3:48:41:39:36:80:a6:f6:9a:\n",
      "    56:b1:9c:2e:ec:93:cd:e1:5b:9c:83:c3:45:75:00:\n",
      "    b1:25:f2:33:f5:b1:08:51:bc:34:4f:43:4b:25:f5:\n",
      "    23:7c:fa:df:d4:59:30:dd:d3:8e:43:06:d3:06:d4:\n",
      "    53:8c:ae:3c:82:23:35:b7:08:c7:46:3c:de:68:68:\n",
      "    9b:65:24:de:2b:fd:a2:92:c2:60:05:a1:f9:bb:6b:\n",
      "    14:0e:e8:2e:de:b8:37:84:f5\n",
      "exponent1:\n",
      "    00:c3:80:52:05:3b:9d:13:8a:ba:b7:44:d4:16:f4:\n",
      "    e0:dd:8d:34:ce:0d:38:c1:7a:74:9a:9a:99:0b:09:\n",
      "    fa:fe:11:ad:20:ee:25:b5:e1:a1:a2:ea:b4:b3:80:\n",
      "    4e:47:44:18:a3:d7:42:2e:15:bc:8e:ff:a6:93:a5:\n",
      "    0c:c3:58:75:da:2c:12:c7:59:89:8e:6a:d4:ba:93:\n",
      "    6d:d3:63:a5:d3:3c:6b:5a:3a:79:73:13:5c:ef:7d:\n",
      "    e3:dd:b9:26:e0:9a:ab:9a:d3:7c:39:00:e7:35:1c:\n",
      "    5e:0b:3e:ff:0b:db:c5:90:ab:ed:be:49:a0:32:f9:\n",
      "    96:f1:e0:eb:4b:9c:0a:6b:29\n",
      "exponent2:\n",
      "    00:b8:de:92:13:3a:c6:f3:8d:c4:bb:77:02:41:67:\n",
      "    53:33:d9:56:3c:0f:46:f1:7b:41:be:91:16:a6:82:\n",
      "    7e:5c:66:52:ec:ef:26:40:0b:a2:03:71:94:59:6e:\n",
      "    09:db:32:54:5f:3b:56:65:03:4f:a7:11:8e:69:a4:\n",
      "    e7:63:ce:a2:e3:48:45:00:88:ca:48:00:53:dd:46:\n",
      "    ae:67:53:93:87:55:e8:87:68:49:de:a2:5b:b7:af:\n",
      "    bf:e8:ab:9c:48:7f:d9:58:b5:92:f8:67:c2:e4:ce:\n",
      "    6a:16:fa:f6:25:c0:ee:a6:8f:65:03:50:88:d8:5d:\n",
      "    44:80:aa:a9:97:01:78:bc:85\n",
      "coefficient:\n",
      "    7b:59:4c:eb:9f:ee:d1:3a:bd:ef:91:52:6a:1b:be:\n",
      "    e6:28:3b:ff:19:0d:85:75:5b:15:ea:25:14:22:b3:\n",
      "    ab:79:e5:0a:49:66:5d:7e:3d:f5:0c:0b:0f:ff:2c:\n",
      "    88:1f:8d:1d:ff:0d:28:51:1e:b8:04:cb:ff:3f:74:\n",
      "    d8:20:ed:67:19:25:3c:f3:c5:c9:d6:53:83:84:30:\n",
      "    04:76:1a:e8:a5:28:fd:b6:10:3a:99:19:36:5c:08:\n",
      "    f6:a4:6f:38:8d:da:97:d9:6e:de:09:eb:77:88:d9:\n",
      "    e9:f1:07:95:ac:1b:30:08:e9:73:32:8f:36:9b:32:\n",
      "    ab:db:c1:21:c0:6a:c4:8a\n",
      "-----BEGIN RSA PRIVATE KEY-----\n",
      "MIIEpAIBAAKCAQEAumH2f/6cmk0FyMbNpBgfr6+AOybWoMG8L8G+Vq4jQ3FBuWu9\n",
      "AWYsqE/OxET8g6Us7tvtrVGnYyNb5wWgpN5AC8CIRpKZBymtfeUQtXF+QdBidmiZ\n",
      "An+UuFOYF1X/hCnrT/g0OxCePG3nNTNEU2h0qCkythJeM++jfL8CHnDDhC102BPR\n",
      "qYoQk3LE+Mxq4LwOWhB2XnU6NBw1K3Lm75kjvcCfTponcWaGqlX8LkQLCWN/1c2k\n",
      "lpD4v6MxmMQn0yOzDM3X9/DvOiWfoAILbNzCkYAXVTwMyLzKg8HCcd66t9ppdkmX\n",
      "/3F/Gwmw9NqPbI5zkdorPD5Hd9QVylP358RwLwIDAQABAoIBADHM0RdcCa303JHM\n",
      "BNBOndDMfN/RPdHQUh8Ujm4Ms2Fm1p/bmLHSAiaqxF2O7UWjkcD0xKnlwmrr3Ld6\n",
      "unSy6bv6Iq9wpjDSwwd7eB5zB8BAFL78rb2MJ0mlFGNP2CkRJk3EzPfnNdCBsSB2\n",
      "5U+//kOcVm9tsvv/kNhZFRDbInKjWfIvB/0hmUf3V2kj4oTX2ghhdw/nCV0kPt9I\n",
      "pWqIgOlk3alUxMLVJgeRQ7rVpdsnYbdq++XTvSG/KbVtwjsHtn/LYU27gpitG0xa\n",
      "nn6c8qYAaGUs802D68Gig7GggpJOwdI3EMpudB9mWd3wK/czBl/f4AxopyILhU/8\n",
      "2W3oNxkCgYEA3YCHal2WT4UijAbrQFqaIZdjD78qyClzkYf0sfY4J0kS1GCLhArL\n",
      "67tYzpQJ4FKQvNpWYLpHyb3sJu1BKmvZxgyydZDLi+OeYBdnpQOiawp90079CGUM\n",
      "LKiv4B8tYUieJUctvwSfEYYc0YRftsIik1RGpNh2hddKxjMmByYkChMCgYEA12kx\n",
      "wsSNsLBFvB4VkSQxHb8h1nhBb6B4IcRVzagF7h2b7U/TSEE5NoCm9ppWsZwu7JPN\n",
      "4Vucg8NFdQCxJfIz9bEIUbw0T0NLJfUjfPrf1Fkw3dOOQwbTBtRTjK48giM1twjH\n",
      "RjzeaGibZSTeK/2iksJgBaH5u2sUDugu3rg3hPUCgYEAw4BSBTudE4q6t0TUFvTg\n",
      "3Y00zg04wXp0mpqZCwn6/hGtIO4lteGhouq0s4BOR0QYo9dCLhW8jv+mk6UMw1h1\n",
      "2iwSx1mJjmrUupNt02Ol0zxrWjp5cxNc733j3bkm4JqrmtN8OQDnNRxeCz7/C9vF\n",
      "kKvtvkmgMvmW8eDrS5wKaykCgYEAuN6SEzrG843Eu3cCQWdTM9lWPA9G8XtBvpEW\n",
      "poJ+XGZS7O8mQAuiA3GUWW4J2zJUXztWZQNPpxGOaaTnY86i40hFAIjKSABT3Uau\n",
      "Z1OTh1Xoh2hJ3qJbt6+/6KucSH/ZWLWS+GfC5M5qFvr2JcDupo9lA1CI2F1EgKqp\n",
      "lwF4vIUCgYB7WUzrn+7ROr3vkVJqG77mKDv/GQ2FdVsV6iUUIrOreeUKSWZdfj31\n",
      "DAsP/yyIH40d/w0oUR64BMv/P3TYIO1nGSU888XJ1lODhDAEdhropSj9thA6mRk2\n",
      "XAj2pG84jdqX2W7eCet3iNnp8QeVrBswCOlzMo82mzKr28EhwGrEig==\n",
      "-----END RSA PRIVATE KEY-----\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "writing RSA key\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "openssl rsa -text -in /tmp/key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the modulus number above\n",
    "\n",
    "```\n",
    "00:ba:61:f6:7f:fe:9c:9a:4d:05:c8:c6:cd:a4:18:\n",
    "1f:af:af:80:3b:26:d6:a0:c1:bc:2f:c1:be:56:ae:\n",
    "23:43:71:41:b9:6b:bd:01:66:2c:a8:4f:ce:c4:44:\n",
    "fc:83:a5:2c:ee:db:ed:ad:51:a7:63:23:5b:e7:05:\n",
    "a0:a4:de:40:0b:c0:88:46:92:99:07:29:ad:7d:e5:\n",
    "10:b5:71:7e:41:d0:62:76:68:99:02:7f:94:b8:53:\n",
    "98:17:55:ff:84:29:eb:4f:f8:34:3b:10:9e:3c:6d:\n",
    "e7:35:33:44:53:68:74:a8:29:32:b6:12:5e:33:ef:\n",
    "a3:7c:bf:02:1e:70:c3:84:2d:74:d8:13:d1:a9:8a:\n",
    "10:93:72:c4:f8:cc:6a:e0:bc:0e:5a:10:76:5e:75:\n",
    "3a:34:1c:35:2b:72:e6:ef:99:23:bd:c0:9f:4e:9a:\n",
    "27:71:66:86:aa:55:fc:2e:44:0b:09:63:7f:d5:cd:\n",
    "a4:96:90:f8:bf:a3:31:98:c4:27:d3:23:b3:0c:cd:\n",
    "d7:f7:f0:ef:3a:25:9f:a0:02:0b:6c:dc:c2:91:80:\n",
    "17:55:3c:0c:c8:bc:ca:83:c1:c2:71:de:ba:b7:da:\n",
    "69:76:49:97:ff:71:7f:1b:09:b0:f4:da:8f:6c:8e:\n",
    "73:91:da:2b:3c:3e:47:77:d4:15:ca:53:f7:e7:c4:\n",
    "70:2f\n",
    "```\n",
    "\n",
    "is a [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) number. if we were to convert it to "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23528632025451081503654664519357809878788927014931688176803070904651921514735649324143761835639775196479774864949574831534018952634137353983638723762428445841865004899115804198982379976750979547176170474109114878032997154293143184236842715773870150309191001271358262865986157704149864281001740058759671081424469834811972420221509294323803400872858321753572922972215183511013878395298927808012100222333046440517716288464859742372160758961278411579395639226728603713418708072408522126151714702442158279443403857429045942589893673776730493301416192404020542813754080664617618680448286284177102123014222829615588812550191"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = \"\"\"\n",
    "00:ba:61:f6:7f:fe:9c:9a:4d:05:c8:c6:cd:a4:18:\n",
    "1f:af:af:80:3b:26:d6:a0:c1:bc:2f:c1:be:56:ae:\n",
    "23:43:71:41:b9:6b:bd:01:66:2c:a8:4f:ce:c4:44:\n",
    "fc:83:a5:2c:ee:db:ed:ad:51:a7:63:23:5b:e7:05:\n",
    "a0:a4:de:40:0b:c0:88:46:92:99:07:29:ad:7d:e5:\n",
    "10:b5:71:7e:41:d0:62:76:68:99:02:7f:94:b8:53:\n",
    "98:17:55:ff:84:29:eb:4f:f8:34:3b:10:9e:3c:6d:\n",
    "e7:35:33:44:53:68:74:a8:29:32:b6:12:5e:33:ef:\n",
    "a3:7c:bf:02:1e:70:c3:84:2d:74:d8:13:d1:a9:8a:\n",
    "10:93:72:c4:f8:cc:6a:e0:bc:0e:5a:10:76:5e:75:\n",
    "3a:34:1c:35:2b:72:e6:ef:99:23:bd:c0:9f:4e:9a:\n",
    "27:71:66:86:aa:55:fc:2e:44:0b:09:63:7f:d5:cd:\n",
    "a4:96:90:f8:bf:a3:31:98:c4:27:d3:23:b3:0c:cd:\n",
    "d7:f7:f0:ef:3a:25:9f:a0:02:0b:6c:dc:c2:91:80:\n",
    "17:55:3c:0c:c8:bc:ca:83:c1:c2:71:de:ba:b7:da:\n",
    "69:76:49:97:ff:71:7f:1b:09:b0:f4:da:8f:6c:8e:\n",
    "73:91:da:2b:3c:3e:47:77:d4:15:ca:53:f7:e7:c4:\n",
    "70:2f\n",
    "\"\"\"\n",
    "h = h.replace(':', '').replace('\\n', '')\n",
    "i = int(h, 16)\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "617"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(str(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## let's encrypt and decrypt something\n",
    "\n",
    "just because we can!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "echo \"my super secret secret is now super secret, except that it's in plain text here\" > /tmp/secret.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we need an `openssl`-specific public key in order to encrypt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "writing RSA key\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "openssl rsa -in /tmp/key -inform PEM -pubout -out /tmp/key.pub.openssl.pem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use the `openssl rsautl` subcommand along with our `openssl.pem` formatted public key to encrypt any file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "openssl rsautl -encrypt -inkey /tmp/key.pub.openssl.pem -pubin -in /tmp/secret.txt -out /tmp/secret.ssl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!mWKs\\\u001a��⎉�Ж\u0000Nw\u0000,�\u001d",
      "P�<��{��j�C�+�q�\u0018`{�K����m���(t�&��|���!�Br@\u0015q�T�U2`\u0006d��՗��1�w^\u001c",
      "UP��L:i�vS�\u0018@�|�,M�3\u0016���Χ�\u0010�Y\u0005�����=\u000e>E�;w����^O��L̠��pzN��m�ñ&�����ͼF|���\r",
      "�*\\̨��\\٦N�\b\u0003�\u000e#�{b%!T��}��zA\u0007d)������J�A�e��fx\u0005�����/��\u0017�R��Bʑ!A��wXV�ri���Q4�T\u0010o"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cat /tmp/secret.ssl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my super secret secret is now super secret, except that it's in plain text here\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "openssl rsautl -decrypt -inkey /tmp/key -in /tmp/secret.ssl"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}