Set 4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lib import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 25: Break \"random access read/write\" AES CTR\n",
    "[Link](https://cryptopals.com/sets/4/challenges/25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Back to CTR. Encrypt the recovered plaintext from [this file](https://cryptopals.com/static/challenge-data/25.txt) (the ECB exercise) under CTR with a random key (for this exercise the key should be unknown to you, but hold on to it).  \n",
    "Now, write the code that allows you to \"seek\" into the ciphertext, decrypt, and re-encrypt with different plaintext. Expose this as a function, like, \"edit(ciphertext, key, offset, newtext)\".  \n",
    "Imagine the \"edit\" function was exposed to attackers by means of an API call that didn't reveal the key or the original plaintext; the attacker has the ciphertext and controls the offset and \"new text\".  \n",
    "Recover the original plaintext."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os\n",
    "import base64\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "data = open(\"25.txt\", \"r\").read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def edit(ciphertext: bytes, key: bytes, offset: int, newtext: bytes, nonce: int) -> bytes:\n",
    "    \"\"\"\n",
    "    Seek into the ciphertext at the given offset and edit the ciphertext to add the newtext's cipher at the offset.\n",
    "    \"\"\"\n",
    "    keystream = b\"\"\n",
    "    # Obtain the keystream used to encrypt in the AES CTR Mode.\n",
    "    # Encrypting newtext to be inserted at offset requires CTR keystream at that offset too.\n",
    "    stream = CTR_keystream_generator(key, nonce)\n",
    "    for i in itertools.islice(stream, offset, offset+len(newtext)):\n",
    "        keystream += i.to_bytes(1, \"big\")\n",
    "    \n",
    "    # Get the cipher for newtext.\n",
    "    append_cipher = xor_bytes(newtext, keystream)\n",
    "    \n",
    "    # Append the cipher of newtext to original cipher.\n",
    "    result = ciphertext[:offset] + append_cipher\n",
    "    if len(result) < len(ciphertext):\n",
    "        return result + ciphertext[len(result):]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test the edit function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original text: hello there\n",
      "Edited text: hell####ere\n"
     ]
    }
   ],
   "source": [
    "random_key = os.urandom(16)\n",
    "nonce = 0\n",
    "\n",
    "plaintext = b\"hello there\"\n",
    "cipher = CTR(plaintext, random_key, nonce)\n",
    "print(\"Original text:\", CTR(cipher, random_key, nonce).decode(\"utf-8\"))\n",
    "edited_cipher = edit(cipher, random_key, 4, b\"####\", nonce)\n",
    "print(\"Edited text:\", CTR(edited_cipher, random_key, nonce).decode(\"utf-8\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you give text as \\x00 it gives out keystream, xors keystream with 0 and thus can decode keystream \n",
    "# by using offset as 0.\n",
    "recovered_bytes = base64.b64decode(data)\n",
    "\n",
    "random_key = os.urandom(16)\n",
    "nonce = 0\n",
    "\n",
    "ciphertext = CTR(recovered_bytes, random_key, nonce)\n",
    "recovered_keystream = edit(ciphertext, random_key, 0, b'\\x00'*len(ciphertext), nonce)\n",
    "deciphered_bytes = xor_bytes(ciphertext, recovered_keystream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(deciphered_bytes == recovered_bytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 26: CTR bitflipping\n",
    "[Link](https://cryptopals.com/sets/4/challenges/26)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> There are people in the world that believe that CTR resists bit flipping attacks of the kind to which CBC mode is susceptible.  \n",
    "Re-implement [the CBC bitflipping exercise from earlier](https://cryptopals.com/sets/2/challenges/16) to use CTR mode instead of CBC mode. Inject an \"admin=true\" token."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "prepend_string = \"comment1=cooking%20MCs;userdata=\"\n",
    "append_string = \";comment2=%20like%20a%20pound%20of%20bacon\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function to prepend the URL encoded string to text and encrypt it with CTR."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encryptor(text: bytes, key: bytes, nonce: int) -> bytes:\n",
    "    \"\"\"\n",
    "    Prepends the string to given text and encrypts with CTR.\n",
    "    \"\"\"\n",
    "    plaintext =  (prepend_string.encode() + text + append_string.encode()).replace(b';', b'\";\"').replace(b'=', b'\"=\"')\n",
    "    ciphertext = CTR(plaintext, key, nonce)\n",
    "    return ciphertext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function to decrypt the cipihertext and check if \"admin=true\" is present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decryptor(byte_string: bytes, random_key: bytes, nonce: int) -> bool:\n",
    "    \"\"\"\n",
    "    Decrypts the ciphertext via AES CTR Mode and checks if admin is set to true.\n",
    "    \"\"\"\n",
    "    decrypted_string = CTR(byte_string, random_key, nonce)\n",
    "    if b';admin=true;' in decrypted_string:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prefix length:  38\n"
     ]
    }
   ],
   "source": [
    "target_bytes = b\";admin=true;\"\n",
    "random_key = os.urandom(16)\n",
    "nonce = 0\n",
    "\n",
    "modified_string = b\"\"\n",
    "\n",
    "# we take out prefix length and then combine the recovered\n",
    "# keystream from that offset onwards with inut text to produce\n",
    "# the required string\n",
    "prefix_length = len(os.path.commonprefix([encryptor(b'AAAA', random_key, nonce), encryptor(b'', random_key, nonce)]))\n",
    "print(\"Prefix length: \", prefix_length)\n",
    "\n",
    "dummy_input = b\"heytheremama\"\n",
    "ciphertext = encryptor(dummy_input, random_key, nonce)\n",
    "null_cipher = encryptor(b'\\x00'*len(ciphertext), random_key, nonce)\n",
    "recovered_keystream = null_cipher[prefix_length:len(ciphertext)]\n",
    "\n",
    "injected_bytes = b\"\"\n",
    "for i in range(len(target_bytes)):\n",
    "    injected_bytes += (target_bytes[i] ^ recovered_keystream[i]).to_bytes(1, \"big\")\n",
    "\n",
    "modified_ciphertext = ciphertext[:prefix_length] + injected_bytes + ciphertext[prefix_length + len(injected_bytes):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(decryptor(modified_ciphertext, random_key, nonce) == True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 27: Recover the key from CBC with IV=Key\n",
    "[Link](https://cryptopals.com/sets/4/challenges/27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Take your code from the CBC exercise and modify it so that it repurposes the key for CBC encryption as the IV.  \n",
    "Applications sometimes use the key as an IV on the auspices that both the sender and the receiver have to know the key already, and can save some space by using it as both a key and an IV.  \n",
    "Using the key as an IV is insecure; an attacker that can modify ciphertext in flight can get the receiver to decrypt a value that will reveal the key.  \n",
    "The CBC code from exercise 16 encrypts a URL string. Verify each byte of the plaintext for ASCII compliance (ie, look for high-ASCII values). Noncompliant messages should raise an exception or return an error that includes the decrypted plaintext (this happens all the time in real systems, for what it's worth).  \n",
    "Use your code to encrypt a message that is at least 3 blocks long:  \n",
    "**AES-CBC(P_1, P_2, P_3) -> C_1, C_2, C_3**  \n",
    "Modify the message (you are now the attacker):  \n",
    "**C_1, C_2, C_3 -> C_1, 0, C_1**  \n",
    "Decrypt the message (you are now the receiver) and raise the appropriate error if high-ASCII is found.  \n",
    "As the attacker, recovering the plaintext from the error, extract the key:  \n",
    "**P'_1 XOR P'_3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "prepend_string = \"comment1=cooking%20MCs;userdata=\"\n",
    "append_string = \";comment2=%20like%20a%20pound%20of%20bacon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_ascii_compliance(plaintext: bytes) -> bool:\n",
    "    \"\"\"\n",
    "    Returns true if all the characters of plaintext are ASCII compliant (ie are in the ASCII table).\n",
    "    \"\"\"\n",
    "    return all(c < 128 for c in plaintext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encryptor(text: bytes, IV: bytes, key: bytes) -> bytes:\n",
    "    \"\"\"\n",
    "    Encrypts the text with AES CBC Mode.\n",
    "    \"\"\"\n",
    "    plaintext = text.replace(b';', b'\";\"').replace(b'=', b'\"=\"')\n",
    "    ciphertext = AES_CBC_encrypt(PKCS7_pad(plaintext, len(key)), IV, key)\n",
    "    return ciphertext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decryptor(byte_string: bytes, IV: bytes, key: bytes) -> bool:\n",
    "    \"\"\"\n",
    "    Decrypts the ciphertext via AES CBC Mode and checks if all characters are ASCII.\n",
    "    \"\"\"\n",
    "    decrypted_string = AES_CBC_decrypt(byte_string, IV, key)\n",
    "    print(len(decrypted_string), decrypted_string)\n",
    "    if not check_ascii_compliance(decrypted_string):\n",
    "        raise Exception(decrypted_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66 b'lorem\"=\"ipsum\";\"#\\xc3\\x81\\xc2\\xa9\\\\\\x02\\xc3\\xae\\xc3\\x8b\\xc3\\xa47\\xc2\\x9fsnJ\\xc2\\xb0MV\\xc2\\xba\\xc3\\x99)\\xc3\\x94\\xc3\\x83\\xc2\\x9c\\x7f\\xc3\\x80\\xc3\\x9aX\\xc2\\x94\\xc3\\x94l\\xc3\\xbc\\x01\\xc3\\xa2'\n",
      "> Key found to be: b'\\x1aFU3.9\\x15\\x12\\x0f~\\x11\\x13@)\\x15C'\n"
     ]
    }
   ],
   "source": [
    "keysize = 16\n",
    "random_key = os.urandom(keysize)\n",
    "IV = random_key\n",
    "\n",
    "plaintext = b\"lorem=ipsum;test=fun;padding=dull\"\n",
    "ciphertext = encryptor(plaintext, IV, random_key)\n",
    "c1 = ciphertext[:keysize]\n",
    "c2 = ciphertext[keysize:2*keysize]\n",
    "c3 = ciphertext[2*keysize:]\n",
    "\n",
    "try:\n",
    "    decryptor(c1 + b'\\x00'*16 + c1, IV, random_key)\n",
    "except Exception as e:\n",
    "    decrypted_string = str(e).encode()\n",
    "    p1 = decrypted_string[:keysize]\n",
    "    p3 = decrypted_string[2*keysize:]\n",
    "    decrypted_key = xor_bytes(p1, p3)\n",
    "    print(\"> Key found to be:\", decrypted_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 28: Implement a SHA-1 keyed MAC\n",
    "[Link](https://cryptopals.com/sets/4/challenges/28)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Find a SHA-1 implementation in the language you code in.  \n",
    "Write a function to authenticate a message under a secret key by using a secret-prefix MAC, which is simply:  \n",
    "**SHA1(key || message)**  \n",
    "Verify that you cannot tamper with the message without breaking the MAC you've produced, and that you can't produce a new MAC without knowing the secret key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os\n",
    "import struct\n",
    "import hashlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def left_rotate(value: int, shift: int) -> int:\n",
    "    \"\"\"\n",
    "    Returns value left-rotated by shift bits. In other words, performs a circular shift to the left.\n",
    "    \"\"\"\n",
    "    return ((value << shift) & 0xffffffff) | (value >> (32 - shift))\n",
    "\n",
    "\n",
    "def sha1(message: bytes, ml=None, h0=0x67452301, h1=0xEFCDAB89, h2=0x98BADCFE, h3=0x10325476, h4=0xC3D2E1F0) -> bytes:\n",
    "    \"\"\"\n",
    "    Returns a string containing the SHA1 hash of the input message. This is a pure python 3 SHA1\n",
    "    implementation, written starting from the SHA1 pseudo-code on Wikipedia.\n",
    "    The parameters ml, h0, ..., h5 are for the next challenge.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Pre-processing:\n",
    "    if ml is None:\n",
    "        ml = len(message) * 8\n",
    "\n",
    "    message += b'\\x80'\n",
    "    while (len(message) * 8) % 512 != 448:\n",
    "        message += b'\\x00'\n",
    "\n",
    "    message += struct.pack('>Q', ml)\n",
    "\n",
    "    # Process the message in successive 512-bit chunks:\n",
    "    for i in range(0, len(message), 64):\n",
    "\n",
    "        # Break chunk into sixteen 32-bit big-endian integers w[i]\n",
    "        w = [0] * 80\n",
    "        for j in range(16):\n",
    "            w[j] = struct.unpack('>I', message[i + j * 4:i + j * 4 + 4])[0]\n",
    "\n",
    "        # Extend the sixteen 32-bit integers into eighty 32-bit integers:\n",
    "        for j in range(16, 80):\n",
    "            w[j] = left_rotate(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1)\n",
    "\n",
    "        # Initialize hash value for this chunk:\n",
    "        a = h0\n",
    "        b = h1\n",
    "        c = h2\n",
    "        d = h3\n",
    "        e = h4\n",
    "\n",
    "        # Main loop\n",
    "        for j in range(80):\n",
    "            if j <= 19:\n",
    "                f = d ^ (b & (c ^ d))\n",
    "                k = 0x5A827999\n",
    "            elif 20 <= j <= 39:\n",
    "                f = b ^ c ^ d\n",
    "                k = 0x6ED9EBA1\n",
    "            elif 40 <= j <= 59:\n",
    "                f = (b & c) | (d & (b | c))\n",
    "                k = 0x8F1BBCDC\n",
    "            else:\n",
    "                f = b ^ c ^ d\n",
    "                k = 0xCA62C1D6\n",
    "\n",
    "            temp = left_rotate(a, 5) + f + e + k + w[j] & 0xffffffff\n",
    "            e = d\n",
    "            d = c\n",
    "            c = left_rotate(b, 30)\n",
    "            b = a\n",
    "            a = temp\n",
    "\n",
    "        # Add this chunk's hash to result so far:\n",
    "        h0 = (h0 + a) & 0xffffffff\n",
    "        h1 = (h1 + b) & 0xffffffff\n",
    "        h2 = (h2 + c) & 0xffffffff\n",
    "        h3 = (h3 + d) & 0xffffffff\n",
    "        h4 = (h4 + e) & 0xffffffff\n",
    "\n",
    "    # Produce the final hash value (big-endian) as a 160 bit number, hex formatted:\n",
    "    return \"%08x%08x%08x%08x%08x\" % (h0, h1, h2, h3, h4)\n",
    "\n",
    "def sha1_mac(key: bytes, message: bytes) -> bytes:\n",
    "    return sha1(key + message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "keysize = 16\n",
    "random_key = os.urandom(keysize)\n",
    "message = \"This is a message to test that our implementation of the SHA1 MAC works properly.\"\n",
    "\n",
    "hashed = sha1_mac(random_key, message.encode())\n",
    "\n",
    "# Verify that I implemented SHA1 correctly\n",
    "h = hashlib.sha1(random_key + message.encode())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(hashed == h.hexdigest())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 29: Break a SHA-1 keyed MAC using length extension\n",
    "[Link](https://cryptopals.com/sets/4/challenges/29)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Secret-prefix SHA-1 MACs are trivially breakable.  \n",
    "The attack on secret-prefix SHA1 relies on the fact that you can take the ouput of SHA-1 and use it as a new starting point for SHA-1, thus taking an arbitrary SHA-1 hash and \"feeding it more data\".  \n",
    "Since the key precedes the data in secret-prefix, any additional data you feed the SHA-1 hash in this fashion will appear to have been hashed with the secret key.  \n",
    "To carry out the attack, you'll need to account for the fact that SHA-1 is \"padded\" with the bit-length of the message; your forged message will need to include that padding. We call this \"glue padding\". The final message you actually forge will be:  \n",
    "**SHA1(key || original-message || glue-padding || new-message)**  \n",
    "(where the final padding on the whole constructed message is implied)  \n",
    "Note that to generate the glue padding, you'll need to know the original bit length of the message; the message itself is known to the attacker, but the secret key isn't, so you'll need to guess at it.  \n",
    "This sounds more complicated than it is in practice.  \n",
    "To implement the attack, first write the function that computes the MD padding of an arbitrary message and verify that you're generating the same padding that your SHA-1 implementation is using. This should take you 5-10 minutes.  \n",
    "Now, take the SHA-1 secret-prefix MAC of the message you want to forge --- this is just a SHA-1 hash --- and break it into 32 bit SHA-1 registers (SHA-1 calls them \"a\", \"b\", \"c\", &c).  \n",
    "Modify your SHA-1 implementation so that callers can pass in new values for \"a\", \"b\", \"c\" &c (they normally start at magic numbers). With the registers \"fixated\", hash the additional data you want to forge.  \n",
    "Using this attack, generate a secret-prefix MAC under a secret key (choose a random word from /usr/share/dict/words or something) of the string:  \n",
    "**\"comment1=cooking%20MCs;userdata=foo;comment2=%20like%20a%20pound%20of%20bacon\"**  \n",
    "Forge a variant of this message that ends with \";admin=true\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os\n",
    "import struct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "message = \"comment1=cooking%20MCs;userdata=foo;comment2=%20like%20a%20pound%20of%20bacon\"\n",
    "payload = b\";admin=true\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating a pseudo random key, to be run only once.\n",
    "key = os.urandom(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def md_pad(message: bytes) -> bytes:\n",
    "    \"\"\"\n",
    "    Pads the message in accordance with SHA1 padding.\n",
    "    \"\"\"\n",
    "    ml = len(message) * 8\n",
    "    message += b'\\x80'\n",
    "    while (len(message) * 8) % 512 != 448:\n",
    "        message += b'\\x00'\n",
    "\n",
    "    message += struct.pack('>Q', ml)\n",
    "    return message\n",
    "    \n",
    "def validate(modified_message: bytes, new_md: bytes) -> bool:\n",
    "    \"\"\"\n",
    "    Verifies the MAC .\n",
    "    \"\"\"\n",
    "    if sha1_mac(key, modified_message) == new_md:\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "def sha1_length_extension_attack(message: bytes, original_md: bytes, payload: bytes) -> (bytes, bytes):\n",
    "    \"\"\"\n",
    "    Perform the SHA1 length extension attack.\n",
    "    \"\"\"\n",
    "    for key_length in range(20):\n",
    "        h = struct.unpack('>5I', bytes.fromhex(original_md))\n",
    "        modified_message = md_pad(b'A'*key_length + message)[key_length:] + payload\n",
    "        new_md = sha1(payload, (len(modified_message) + key_length)*8, h[0], h[1], h[2], h[3], h[4])\n",
    "        if validate(modified_message, new_md):\n",
    "            print(\"> Length extension attack successful.\")\n",
    "            return modified_message, new_md\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Length extension attack successful.\n"
     ]
    }
   ],
   "source": [
    "original_md = sha1_mac(key, message.encode())\n",
    "modified_message, new_md = sha1_length_extension_attack(message.encode(), original_md, payload)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(payload in modified_message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 30: Break an MD4 keyed MAC using length extension\n",
    "[Link](https://cryptopals.com/sets/4/challenges/30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Second verse, same as the first, but use MD4 instead of SHA-1. Having done this attack once against SHA-1, the MD4 variant should take much less time; mostly just the time you'll spend Googling for an implementation of MD4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os\n",
    "import struct\n",
    "import binascii"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "message = \"comment1=cooking%20MCs;userdata=foo;comment2=%20like%20a%20pound%20of%20bacon\"\n",
    "payload = b\";admin=true\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating a pseudo random key, to be run only once.\n",
    "key = os.urandom(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MD4:\n",
    "    \"\"\"\n",
    "    This implementation resembles the one of the Wikipedia pseudo-code.\n",
    "    \"\"\"\n",
    "    \n",
    "    buf = [0x00] * 64\n",
    "\n",
    "    _F = lambda self, x, y, z: ((x & y) | (~x & z))\n",
    "    _G = lambda self, x, y, z: ((x & y) | (x & z) | (y & z))\n",
    "    _H = lambda self, x, y, z: (x ^ y ^ z)\n",
    "\n",
    "    def __init__(self: object, message: bytes, ml=None, A=0x67452301, B=0xefcdab89, C=0x98badcfe, D=0x10325476):\n",
    "        self.A, self.B, self.C, self.D = A, B, C, D\n",
    "\n",
    "        if ml is None:\n",
    "            ml = len(message) * 8\n",
    "        length = struct.pack('<Q', ml)\n",
    "\n",
    "        while len(message) > 64:\n",
    "            self._handle(message[:64])\n",
    "            message = message[64:]\n",
    "\n",
    "        message += b'\\x80'\n",
    "        message += bytes((56 - len(message) % 64) % 64)\n",
    "        message += length\n",
    "\n",
    "        while len(message):\n",
    "            self._handle(message[:64])\n",
    "            message = message[64:]\n",
    "\n",
    "    def _handle(self: object, chunk: bytes):\n",
    "        X = list(struct.unpack('<' + 'I' * 16, chunk))\n",
    "        A, B, C, D = self.A, self.B, self.C, self.D\n",
    "\n",
    "        for i in range(16):\n",
    "            k = i\n",
    "            if i % 4 == 0:\n",
    "                A = left_rotate((A + self._F(B, C, D) + X[k]) & 0xffffffff, 3)\n",
    "            elif i % 4 == 1:\n",
    "                D = left_rotate((D + self._F(A, B, C) + X[k]) & 0xffffffff, 7)\n",
    "            elif i % 4 == 2:\n",
    "                C = left_rotate((C + self._F(D, A, B) + X[k]) & 0xffffffff, 11)\n",
    "            elif i % 4 == 3:\n",
    "                B = left_rotate((B + self._F(C, D, A) + X[k]) & 0xffffffff, 19)\n",
    "\n",
    "        for i in range(16):\n",
    "            k = (i // 4) + (i % 4) * 4\n",
    "            if i % 4 == 0:\n",
    "                A = left_rotate((A + self._G(B, C, D) + X[k] + 0x5a827999) & 0xffffffff, 3)\n",
    "            elif i % 4 == 1:\n",
    "                D = left_rotate((D + self._G(A, B, C) + X[k] + 0x5a827999) & 0xffffffff, 5)\n",
    "            elif i % 4 == 2:\n",
    "                C = left_rotate((C + self._G(D, A, B) + X[k] + 0x5a827999) & 0xffffffff, 9)\n",
    "            elif i % 4 == 3:\n",
    "                B = left_rotate((B + self._G(C, D, A) + X[k] + 0x5a827999) & 0xffffffff, 13)\n",
    "\n",
    "        order = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]\n",
    "        for i in range(16):\n",
    "            k = order[i]\n",
    "            if i % 4 == 0:\n",
    "                A = left_rotate((A + self._H(B, C, D) + X[k] + 0x6ed9eba1) & 0xffffffff, 3)\n",
    "            elif i % 4 == 1:\n",
    "                D = left_rotate((D + self._H(A, B, C) + X[k] + 0x6ed9eba1) & 0xffffffff, 9)\n",
    "            elif i % 4 == 2:\n",
    "                C = left_rotate((C + self._H(D, A, B) + X[k] + 0x6ed9eba1) & 0xffffffff, 11)\n",
    "            elif i % 4 == 3:\n",
    "                B = left_rotate((B + self._H(C, D, A) + X[k] + 0x6ed9eba1) & 0xffffffff, 15)\n",
    "\n",
    "        self.A = (self.A + A) & 0xffffffff\n",
    "        self.B = (self.B + B) & 0xffffffff\n",
    "        self.C = (self.C + C) & 0xffffffff\n",
    "        self.D = (self.D + D) & 0xffffffff\n",
    "\n",
    "    def digest(self: object) -> bytes:\n",
    "        return struct.pack('<4I', self.A, self.B, self.C, self.D)\n",
    "\n",
    "    def hex_digest(self: object) -> bytes:\n",
    "        return binascii.hexlify(self.digest()).decode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def md_pad(message: bytes) -> bytes:\n",
    "    \"\"\"\n",
    "    Pads the given message the same way the pre-processing of the MD4 algorithm does.\n",
    "    \"\"\"\n",
    "    ml = len(message) * 8\n",
    "\n",
    "    message += b'\\x80'\n",
    "    message += bytes((56 - len(message) % 64) % 64)\n",
    "    message += struct.pack('<Q', ml)\n",
    "\n",
    "    return message\n",
    "    \n",
    "def validate(modified_message: bytes, new_md: bytes) -> bool:\n",
    "    \"\"\"\n",
    "    Verifies if the padding is correct.\n",
    "    \"\"\"\n",
    "    if MD4(modified_message).hex_digest() == new_md:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def md4_length_extension_attack(message: bytes, original_md: bytes, payload: bytes) -> bytes:\n",
    "    \"\"\"\n",
    "    Performs the length extension attack on an MD4.\n",
    "    \"\"\"\n",
    "    for key_length in range(20):\n",
    "        h = struct.unpack('<4I', bytes.fromhex(original_md))\n",
    "        modified_message = md_pad(b'A'*key_length + message)[key_length:] + payload\n",
    "        new_md = MD4(payload, (len(modified_message) + key_length)*8, h[0], h[1], h[2], h[3]).hex_digest()\n",
    "        if validate(modified_message, new_md):\n",
    "            print(\"> Length extension attack successful.\")\n",
    "            return modified_message, new_md\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Length extension attack successful.\n"
     ]
    }
   ],
   "source": [
    "original_md = MD4(message.encode()).hex_digest()\n",
    "modified_message, new_md = md4_length_extension_attack(message.encode(), original_md, payload)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(payload in modified_message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 31: Implement and break HMAC-SHA1 with an artificial timing leak\n",
    "[Link](https://cryptopals.com/sets/4/challenges/31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The psuedocode on Wikipedia should be enough. HMAC is very easy.  \n",
    "Using the web framework of your choosing (Sinatra, web.py, whatever), write a tiny application that has a URL that takes a \"file\" argument and a \"signature\" argument, like so:  \n",
    "**http://localhost:9000/test?file=foo&signature=46b4ec586117154dacd49d664e5d63fdc88efb51**  \n",
    "Have the server generate an HMAC key, and then verify that the \"signature\" on incoming requests is valid for \"file\", using the \"==\" operator to compare the valid MAC for a file with the \"signature\" parameter (in other words, verify the HMAC the way any normal programmer would verify it).  \n",
    "Write a function, call it \"insecure_compare\", that implements the == operation by doing byte-at-a-time comparisons with early exit (ie, return false at the first non-matching byte).  \n",
    "In the loop for \"insecure_compare\", add a 50ms sleep (sleep 50ms after each byte).  \n",
    "Use your \"insecure_compare\" function to verify the HMACs on incoming requests, and test that the whole contraption works. Return a 500 if the MAC is invalid, and a 200 if it's OK.  \n",
    "Using the timing leak in this application, write a program that discovers the valid MAC for any file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import os\n",
    "import web\n",
    "import json\n",
    "import time\n",
    "import hashlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "delay = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HMAC:\n",
    "    \"\"\"\n",
    "    Computes the HMAC for the hash function given at the time of initialisation.\n",
    "    This implementation resembles the one of the Wikipedia pseudo-code.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self: object, random_key: bytes, hash_func: callable):\n",
    "        self.hash_func = hash_func\n",
    "        self.block_size = hash_func().block_size\n",
    "\n",
    "        if len(random_key) > self.block_size:\n",
    "            self.key = hash_func(random_key).digest()\n",
    "        elif len(random_key) < self.block_size:\n",
    "            self.key = random_key + b'\\x00' * (self.block_size-len(random_key))\n",
    "\n",
    "    def compute(self: object, message: bytes) -> bytes:\n",
    "        o_key_pad = xor_bytes(self.key, b'\\x5c' * self.block_size)\n",
    "        i_key_pad = xor_bytes(self.key, b'\\x36' * self.block_size)\n",
    "        \n",
    "        inner_hash = self.hash_func(i_key_pad + message).digest()\n",
    "        \n",
    "        return self.hash_func(o_key_pad + inner_hash).hexdigest()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Web server using web.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "urls = (\n",
    "    '/hello', 'Hello',\n",
    "    '/test', 'Hash'\n",
    ")\n",
    "\n",
    "app = web.application(urls, globals())\n",
    "\n",
    "HMAC_obj = HMAC(b\"YELLOW_SUBMARINE\", hashlib.sha1)\n",
    "\n",
    "class Hello:        \n",
    "    \n",
    "    def GET(self):\n",
    "        params = web.input()\n",
    "        name = params.name\n",
    "        if not name:\n",
    "            name = 'World'\n",
    "            \n",
    "        string = \"Hello, \" + name + \"!\"\n",
    "        return {\"name\" : string}\n",
    "\n",
    "class Hash:\n",
    "    \n",
    "    def _insecure_compare(self, hash1, hash2, delay):\n",
    "        for b1, b2 in zip(hash1, hash2):\n",
    "            if b1 != b2:\n",
    "                return False\n",
    "            time.sleep(delay)\n",
    "        return True\n",
    "    \n",
    "    def GET(self):\n",
    "        global HMAC_obj\n",
    "        params = web.input()\n",
    "        file = params.file\n",
    "        signature = params.signature\n",
    "        delay = params.delay\n",
    "        \n",
    "        hmac = HMAC_obj.compute(file.encode())\n",
    "        if self._insecure_compare(hmac.encode(), signature.encode(), float(delay)):\n",
    "            return web.HTTPError(200)\n",
    "        else:\n",
    "            return web.HTTPError(500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test the web server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\"{'name': 'Hello, World!'}\"\n",
      "{'name': 'Hello, hexterisk!'}\n"
     ]
    }
   ],
   "source": [
    "response1 = app.request(\"/hello?name=\")\n",
    "print(response1.data)\n",
    "\n",
    "response2 = app.request(\"/hello?name=hexterisk\")\n",
    "print(json.loads(response2.data.decode(\"utf-8\").replace(\"'\",'\"')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Storage {'status': 500, 'headers': {}, 'header_items': [], 'data': b'500'}>\n",
      "<Storage {'status': 200, 'headers': {}, 'header_items': [], 'data': b'200'}>\n"
     ]
    }
   ],
   "source": [
    "filename = \"foo\"\n",
    "signature = \"274b7c4d98605fcf739a0bf9237551623f415fb8\"\n",
    "response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature)\n",
    "print(response)\n",
    "\n",
    "signature = \"8c80a95a8e72b3e822a13924553351a433e267d8\"\n",
    "response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature)\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produces a 160-bit (20-byte) hash value known as a message digest, typically rendered as a hexadecimal number, 40 digits long.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Discovered signature: 8\n",
      "> Discovered signature: 8c\n",
      "> Discovered signature: 8c8\n",
      "> Discovered signature: 8c80\n",
      "> Discovered signature: 8c80a\n",
      "> Discovered signature: 8c80a9\n",
      "> Discovered signature: 8c80a95\n",
      "> Discovered signature: 8c80a95a\n",
      "> Discovered signature: 8c80a95a8\n",
      "> Discovered signature: 8c80a95a8e\n",
      "> Discovered signature: 8c80a95a8e7\n",
      "> Discovered signature: 8c80a95a8e72\n",
      "> Discovered signature: 8c80a95a8e72b\n",
      "> Discovered signature: 8c80a95a8e72b3\n",
      "> Discovered signature: 8c80a95a8e72b3e\n",
      "> Discovered signature: 8c80a95a8e72b3e8\n",
      "> Discovered signature: 8c80a95a8e72b3e82\n",
      "> Discovered signature: 8c80a95a8e72b3e822\n",
      "> Discovered signature: 8c80a95a8e72b3e822a\n",
      "> Discovered signature: 8c80a95a8e72b3e822a1\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13\n",
      "> Discovered signature: 8c80a95a8e72b3e822a139\n",
      "> Discovered signature: 8c80a95a8e72b3e822a1392\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924\n",
      "> Discovered signature: 8c80a95a8e72b3e822a139245\n",
      "> Discovered signature: 8c80a95a8e72b3e822a1392455\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553\n",
      "> Discovered signature: 8c80a95a8e72b3e822a139245533\n",
      "> Discovered signature: 8c80a95a8e72b3e822a1392455335\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a4\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a43\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e2\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e26\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e267\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e267d\n",
      "> Discovered signature: 8c80a95a8e72b3e822a13924553351a433e267d8\n",
      "> Brute force successful.\n",
      "> Signature: 8c80a95a8e72b3e822a13924553351a433e267d8\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div style=\"border:1px solid #c3e6cb;padding:.75rem 3rem;border-radius:.5rem;font-weight:bold;text-align: center;background-color:#d4edda;color:#155724;border-color:#c3e6cb;\">Completed</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "signature = \"\"\n",
    "# We go for twice the size because hexadecimal byte is 2 digits long.\n",
    "for _ in range(hashlib.sha1().digest_size * 2):\n",
    "    \n",
    "    times = []\n",
    "    # This loop goes over all 16 hexadecimal bytes.\n",
    "    for i in range(16):\n",
    "        start = time.time()\n",
    "        response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature + hex(i)[-1])\n",
    "        finish = time.time()\n",
    "        times.append(finish - start)\n",
    "    signature += hex(times.index(max(times)))[-1]\n",
    "    print(\"> Discovered signature:\", signature)\n",
    "\n",
    "response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature + hex(i)[-1])\n",
    "if response.status == 200:\n",
    "    print(\"> Brute force successful.\\n> Signature:\", signature)\n",
    "    test(True)\n",
    "else:\n",
    "    print(\"Brute force failed.\")\n",
    "    test(False)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 32: Break HMAC-SHA1 with a slightly less artificial timing leak\n",
    "[Link](https://cryptopals.com/sets/4/challenges/32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Reduce the sleep in your \"insecure_compare\" until your previous solution breaks. (Try 5ms to start.)  \n",
    "Now break it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given\n",
    "delay = 0.005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "HMAC_obj = HMAC(b\"YELLOW_SUBMARINE\", hashlib.sha1)\n",
    "\n",
    "file = \"foo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produces a 160-bit (20-byte) hash value known as a message digest, typically rendered as a hexadecimal number, 40 digits long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Discovered signature: 8\n",
      "> Discovered signature: 8c\n",
      "> Discovered signature: 8c8\n",
      "> Discovered signature: 8c80\n",
      "> Discovered signature: 8c80a\n",
      "> Discovered signature: 8c80af\n",
      "> Discovered signature: 8c80aff\n",
      "> Discovered signature: 8c80aff0\n",
      "> Discovered signature: 8c80aff0f\n",
      "> Discovered signature: 8c80aff0f0\n",
      "> Discovered signature: 8c80aff0f0f\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-86665c1b3a4b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m             \u001b[0mstart\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m             \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"/test?delay=\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelay\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"&file=\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mfilename\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"&signature=\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0msignature\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mhex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m             \u001b[0mfinish\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m             \u001b[0mruntime\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mfinish\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, localpart, method, data, host, headers, https, **kw)\u001b[0m\n\u001b[1;32m    270\u001b[0m             \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mheader_items\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    271\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwsgifunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_response\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    273\u001b[0m         \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mb\"\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    274\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mwsgi\u001b[0;34m(env, start_resp)\u001b[0m\n\u001b[1;32m    327\u001b[0m                     \u001b[0;32mraise\u001b[0m \u001b[0mweb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnomethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    328\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 329\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle_with_processors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    330\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mis_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    331\u001b[0m                     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpeep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mhandle_with_processors\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    298\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    299\u001b[0m         \u001b[0;31m# processors must be applied in the resvere order. (??)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 300\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    301\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    302\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwsgifunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmiddleware\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(processors)\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocessor\u001b[0;34m(handler)\u001b[0m\n\u001b[1;32m    698\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprocessor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhandler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    699\u001b[0m         \u001b[0mh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 700\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    701\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    702\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mprocessor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(processors)\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocessor\u001b[0;34m(handler)\u001b[0m\n\u001b[1;32m    715\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprocessor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhandler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    716\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 717\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    718\u001b[0m             \u001b[0mis_gen\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mis_iter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    719\u001b[0m         \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(processors)\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocessor\u001b[0;34m(handler)\u001b[0m\n\u001b[1;32m    698\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprocessor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhandler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    699\u001b[0m         \u001b[0mh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 700\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mhandler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    701\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    702\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mprocessor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    286\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprocessors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    290\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mprocess\u001b[0;34m(processors)\u001b[0m\n\u001b[1;32m    288\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprocess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    289\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 290\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    291\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mweb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHTTPError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    292\u001b[0m                 \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mhandle\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    279\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    280\u001b[0m         \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_match\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmapping\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 281\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_delegate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfvars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    282\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    283\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mhandle_with_processors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36m_delegate\u001b[0;34m(self, f, fvars, args)\u001b[0m\n\u001b[1;32m    529\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    530\u001b[0m                 \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfvars\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 531\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    532\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"__call__\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    533\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/web/application.py\u001b[0m in \u001b[0;36mhandle_class\u001b[0;34m(cls)\u001b[0m\n\u001b[1;32m    507\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mweb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnomethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    508\u001b[0m             \u001b[0mtocall\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmeth\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 509\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mtocall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    510\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    511\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mf\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-41-373efb50eb42>\u001b[0m in \u001b[0;36mGET\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0mhmac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mHMAC_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_insecure_compare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhmac\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelay\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mweb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHTTPError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-41-373efb50eb42>\u001b[0m in \u001b[0;36m_insecure_compare\u001b[0;34m(self, hash1, hash2, delay)\u001b[0m\n\u001b[1;32m     25\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mb1\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mb2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m             \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelay\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     28\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "signature = \"\"\n",
    "for _ in range(hashlib.sha1().digest_size * 2):\n",
    "# We go for twice the size because hexadecimal byte is 2 digits long.\n",
    "    times = []\n",
    "    # This loop goes over all 16 hexadecimal bytes.\n",
    "    for i in range(16):\n",
    "        runtime = 0\n",
    "        # Introduced more rounds so the time difference is prominent\n",
    "        for _ in range(20):\n",
    "            start = time.time()\n",
    "            response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature + hex(i)[-1])\n",
    "            finish = time.time()\n",
    "            runtime += finish - start\n",
    "        times.append(runtime)\n",
    "    signature += hex(times.index(max(times)))[-1]\n",
    "    print(\"> Discovered signature:\", signature)\n",
    "\n",
    "response = app.request(\"/test?delay=\" + str(delay) + \"&file=\" + filename + \"&signature=\" + signature + hex(i)[-1])\n",
    "if response.status == 200:\n",
    "    print(\"> Brute force successful.\\n> Signature:\", signature)\n",
    "    test(True)\n",
    "else:\n",
    "    print(\"Brute force failed.\")\n",
    "    test(False)"
   ]
  },
  {
   "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}