SHA-256.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<style>\n",
    "    .title_div {\n",
    "    padding: 60px;\n",
    "    text-align: center;\n",
    "    background: #ffffff;\n",
    "    }\n",
    "    #title {\n",
    "        color: #f2a900;\n",
    "        font-size: 80px;\n",
    "    }\n",
    "    #subtitle {\n",
    "        color: #4d4d4e;\n",
    "        font-size: 20px;\n",
    "    }\n",
    "</style>\n",
    "\n",
    "<div class=\"title_div\">\n",
    "  <h1 id=\"title\">SHA-256</h1>\n",
    "  <p id=\"subtitle\">Secure Hasing Algorithm 256 bits</p>\n",
    "</div>\n",
    "\n",
    "<div style=\"color:red; text-align: center; padding: 60px\">\n",
    "⚠ The following examples are just to see how SHA-256 work; no recommended to use this algorithms for hashing. ⚠\n",
    "</div>\n",
    "\n",
    "\n",
    "## TOC:\n",
    "* [First look](#First-Look)\n",
    "* [Atomic operations](#Atomic-Operations)\n",
    "    1. [SHR](#SHR)\n",
    "    2. [ROTR](#ROTR)\n",
    "    3. [XOR](#XOR)\n",
    "    4. [SUM](#SUM)\n",
    "* [Coumpound operations](#Compound-Operations)\n",
    "    1. [$\\sigma0$](#sigma0)\n",
    "    2. [$\\sigma1$](#sigma1)\n",
    "    3. [$\\Sigma0$](#Sigma0)\n",
    "    4. [$\\Sigma1$](#Sigma1)\n",
    "    5. [Choice](#Choice)\n",
    "    6. [Majority](#Majority)\n",
    "* [Constant K](#Constant-k)\n",
    "* [Hashing](#Hashing)\n",
    "    * [Encode](#Encode)\n",
    "    * [Padding](#Padding)\n",
    "    * [Message Schedule](#Message-Schedule)\n",
    "        * [Block Iterator](#Block-Iterator)\n",
    "        * [Word Iterator](#Word-Iterator)\n",
    "        * [Initializing message schedule](#Initializing-message-schedule)\n",
    "        * [Extending message shcedule](#Extending-message-schedule)\n",
    "    * [Compression](#Compression)\n",
    "        * [Initializing stage registers](#Initializing-stage-regs)\n",
    "        * [Block Compression](#Block-Compression)\n",
    "        * [Sum UP](#Sum-UP)\n",
    "* [Checking the result](#Checking-Result)\n",
    "* [Consolidating operations](#Consolidating-Operations)\n",
    "* [Testing](#Testing)\n",
    "    * [Simple Test](#Simple-Test)\n",
    "    * [Multiblock Test](#Multiblock-Test)\n",
    "    * [Unittest testing](#Unitest-Testing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Needed modules for running all notebook cells\n",
    "from IPython.display import clear_output\n",
    "from bitarray import bitarray, util\n",
    "from hashlib import sha256, sha512, new\n",
    "from time import sleep\n",
    "from math import sqrt, floor\n",
    "\n",
    "# tests\n",
    "import unittest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"First-Look\"></a>\n",
    "## First look\n",
    "\n",
    "Using the SHA-256 function incuded in the hashlib module as reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = sha256()\n",
    "print(f\"Hash type:\\t{m.name}\")\n",
    "print(f\"Void digest:\\t{m.hexdigest()}\")\n",
    "print(f\"Digest size:\\t{m.digest_size}\")\n",
    "\n",
    "string = \"Hello World!\"\n",
    "m.update(string.encode())\n",
    "print(f\"\\nString:\\t{string}\")\n",
    "print(f\"Digest:\\t{m.hexdigest()}\")\n",
    "\n",
    "del m, string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Atomic-Operations\"></a>\n",
    "## Atomic bit level operations\n",
    "\n",
    "1. [SHR](#SHR)\n",
    "2. [ROTR](#ROTR)\n",
    "3. [XOR](#XOR)\n",
    "4. [SUM](#SUM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"SHR\"></a>\n",
    "### 1. SHR\n",
    "Shift right, left bits populated with '0'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shr(bits, shifts):\n",
    "    for _ in range(shifts):\n",
    "        bits.pop()\n",
    "        bits.insert(0, 0)\n",
    "    return bits\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "a.frombytes(b'\\xff\\x00\\xff\\x00')\n",
    "\n",
    "print(\"\\n{:>8} {:>32}\".format(\"A:\", a.to01()))\n",
    "for i in range(32):\n",
    "    print(\"\\r{:>8} {:>32}\".format(\"SHR \"+str(i+1)+\":\", shr(a,1).to01()), end=\"\")\n",
    "    sleep(0.2)\n",
    "del a, i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"ROTR\"></a>\n",
    "### 2. ROTR\n",
    "Rotation right, dropping bits over right appear on the left hand side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotr(bits, shifts):\n",
    "    for _ in range(shifts):\n",
    "        bits.insert(0,bits.pop())\n",
    "    return bits\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "a.frombytes(b'\\xff\\x00\\xff\\x00')\n",
    "\n",
    "print(\"\\n{:>8} {:>32}\".format(\"A:\", a.to01()))\n",
    "for i in range(32):\n",
    "    print(\"\\r{:>8} {:>32}\".format(\"ROTR \"+str(i+1)+\":\", rotr(a,1).to01()), end=\"\")\n",
    "    sleep(0.2)\n",
    "del a, i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"XOR\"></a>\n",
    "### 3. XOR\n",
    "Exclusive OR\n",
    "\n",
    "\n",
    "\n",
    "| A | B | XOR |\n",
    "|---|---|-----|\n",
    "| 0 | 0 | 0   |\n",
    "| 0 | 1 | 1   |\n",
    "| 1 | 0 | 1   |\n",
    "| 1 | 1 | 0   |   \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def xor(a, b):\n",
    "    return a^b\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "b = bitarray(endian='big')\n",
    "a.frombytes(b'\\xff\\x00\\xff\\x00')\n",
    "b.frombytes(b'\\x00\\xff\\xff\\x00')\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"A:\", a.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"B:\", b.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "for i in range(32):\n",
    "    print(\"\\r{:>8} {:>32}\".format(\"\", xor(a,b).to01()[32-1-i:]), end=\"\")\n",
    "    sleep(0.2)\n",
    "del a, b, i\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"SUM\"></a>\n",
    "### 4. SUM\n",
    "Binary addition <br>\n",
    "Mod 32, ignoring the carry out that will overflow the 32 bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    result = bitarray(endian='big')\n",
    "    carry = 0\n",
    "    for i in range(32-1, -1, -1):\n",
    "        result.insert(0,(a[i]^b[i]^carry))\n",
    "        carry = 1 if (a[i] + b[i] + carry) > 1 else 0\n",
    "    return result\n",
    "\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "b = bitarray(endian='big')\n",
    "a.frombytes(b'\\x80\\x30\\xff\\xff')\n",
    "b.frombytes(b'\\x80\\x50\\x00\\x00')\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"A:\", a.to01()))\n",
    "print(\"{:>8} {:>32} +\".format(\"B:\", b.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "out = add(a,b)\n",
    "for i in range(32):\n",
    "    print(\"\\r{:>8} {:>32}\".format(\"\", out.to01()[32-1-i:]), end=\"\")\n",
    "    sleep(0.2)\n",
    "\n",
    "del a, b, i, out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<a ID=\"Compound-Operations\"></a>\n",
    "## Compound operations\n",
    "\n",
    "1. [$\\sigma0$](#sigma0)\n",
    "2. [$\\sigma1$](#sigma1)\n",
    "3. [$\\Sigma0$](#Sigma0)\n",
    "4. [$\\Sigma1$](#Sigma1)\n",
    "5. [Choice](#Choice)\n",
    "6. [Majority](#Majority)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"sigma0\"></a>\n",
    "### 1. $\\sigma0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigma0(a, b, c):\n",
    "    rotr(a, 7)\n",
    "    rotr(b, 18)\n",
    "    shr(c, 3)\n",
    "    return xor(xor(a,b),c)\n",
    "\n",
    "origin = bitarray(endian='big')\n",
    "origin.frombytes(b'\\x00\\x00\\x3f\\xff')\n",
    "\n",
    "a = origin.copy()\n",
    "b = origin.copy()\n",
    "c = origin.copy()\n",
    "\n",
    "result = sigma0(a, b, c)\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"Origin:\", origin.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"ROTR  7:\", a.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 18:\", b.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"SHR  7:\", c.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"\\u03C30:\", result.to01()))\n",
    "\n",
    "del a, b, c, result, origin\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"sigma1\"></a>\n",
    "### 1. $\\sigma1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigma1(a, b, c):\n",
    "    rotr(a, 17)\n",
    "    rotr(b, 19)\n",
    "    shr(c, 10)\n",
    "    return xor(xor(a,b),c)\n",
    "\n",
    "origin = bitarray(endian='big')\n",
    "origin.frombytes(b'\\x00\\x00\\x3f\\xff')\n",
    "\n",
    "a = origin.copy()\n",
    "b = origin.copy()\n",
    "c = origin.copy()\n",
    "\n",
    "result = sigma1(a, b, c)\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"Origin:\", origin.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"ROTR 17:\", a.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 19:\", b.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"SHR 10:\", c.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"\\u03C31:\", result.to01()))\n",
    "\n",
    "del a, b, c, result, origin\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Sigma0\"></a>\n",
    "### 3. $\\Sigma0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Sigma0(a, b, c):\n",
    "    rotr(a, 2)\n",
    "    rotr(b, 13)\n",
    "    rotr(c, 22)\n",
    "    return xor(xor(a,b),c)\n",
    "\n",
    "origin = bitarray(endian='big')\n",
    "origin.frombytes(b'\\x00\\x00\\x3f\\xff')\n",
    "\n",
    "a = origin.copy()\n",
    "b = origin.copy()\n",
    "c = origin.copy()\n",
    "\n",
    "result = Sigma0(a, b, c)\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"Origin:\", origin.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"ROTR  2:\", a.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 13:\", b.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 22:\", c.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"\\u03A30:\", result.to01()))\n",
    "\n",
    "del a, b, c, result, origin\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Sigma1\"></a>\n",
    "### 4. $\\Sigma1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Sigma1(a, b, c):\n",
    "    rotr(a, 6)\n",
    "    rotr(b, 11)\n",
    "    rotr(c, 25)\n",
    "    return xor(xor(a,b),c)\n",
    "\n",
    "origin = bitarray(endian='big')\n",
    "origin.frombytes(b'\\x00\\x00\\x3f\\xff')\n",
    "\n",
    "a = origin.copy()\n",
    "b = origin.copy()\n",
    "c = origin.copy()\n",
    "\n",
    "result = Sigma1(a, b, c)\n",
    "\n",
    "print(\"{:>8} {:>32}\".format(\"Origin:\", origin.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"ROTR  6:\", a.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 11:\", b.to01()))\n",
    "print(\"{:>8} {:>32} XOR\".format(\"ROTR 25:\", c.to01()))\n",
    "print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "print(\"{:>8} {:>32}\".format(\"\\u03A31:\", result.to01()))\n",
    "\n",
    "del a, b, c, result, origin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Choice\"></a>\n",
    "### 5. Choice\n",
    "\n",
    "Choose the bit at possition $X$ from 'a' in case choice bit '0' or from 'b' in case choice bit '1'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choice(a, b, c):\n",
    "    result = a.copy()\n",
    "    for i in range(32):\n",
    "        if a[i] == 1:\n",
    "            result[i] = b[i]\n",
    "        else:\n",
    "            result[i] = c[i]\n",
    "    return result\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "b = bitarray(endian='big')\n",
    "c = bitarray(endian='big')\n",
    "\n",
    "a.frombytes(b'\\x00\\xff\\x00\\xff')\n",
    "b.frombytes(b'\\x00\\x00\\xff\\xff')\n",
    "c.frombytes(b'\\xff\\xff\\x00\\x00')\n",
    "\n",
    "result = choice(a, b, c)\n",
    "\n",
    "for i in range(32):\n",
    "\n",
    "    print(\" \"*(41-(i+1))+\"\\u21D3\")\n",
    "    print(\"{:>8} {:>32}\".format(\"A:\", a.to01()))\n",
    "    print(\"{:>8} {:>32} {}\".format(\"B:\", b.to01(), \"\" if a[i]==1 else \"\\u21E6\"))\n",
    "    print(\"{:>8} {:>32} {}\".format(\"C:\", c.to01(), \"\" if a[i]==0 else \"\\u21E6\"))\n",
    "    print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "    print(\"{:>8} {:>32}\".format(\"OUT:\", result.to01()[32-(i+1):]))\n",
    "    \n",
    "    sleep(0.2)\n",
    "    clear_output(wait=True)\n",
    "    \n",
    "\n",
    "del a, b, c, result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Majority\"></a>\n",
    "### 6. Majority"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def majority(a, b, c):\n",
    "    result = bitarray(\"0\"*32)\n",
    "    for i in range(32):\n",
    "        result[i] = 1 if a[i]+b[i]+c[i] > 1 else 0\n",
    "    return result\n",
    "\n",
    "a = bitarray(endian='big')\n",
    "b = bitarray(endian='big')\n",
    "c = bitarray(endian='big')\n",
    "\n",
    "a.frombytes(b'\\x00\\xff\\x00\\xff')\n",
    "b.frombytes(b'\\x00\\x00\\xff\\xff')\n",
    "c.frombytes(b'\\xff\\xff\\x00\\x00')\n",
    "\n",
    "result = majority(a, b, c)\n",
    "\n",
    "for i in range(32):\n",
    "\n",
    "    print(\" \"*(41-(i+1))+\"\\u21D3\")\n",
    "    print(\"{:>8} {:>32} {}\".format(\"A:\", a.to01(), \" \"+str(a[32-(i+1)])))\n",
    "    print(\"{:>8} {:>32} {}\".format(\"B:\", b.to01(), \" \"+str(b[32-(i+1)])))\n",
    "    print(\"{:>8} {:>32} {}\".format(\"C:\", c.to01(), \" \"+str(c[32-(i+1)])))\n",
    "    print(\"{:>8} {:>32}\".format(\"\", \"-\"*32))\n",
    "    print(\"{:>8} {:>32}\".format(\"OUT:\", result.to01()[32-(i+1):]))\n",
    "    \n",
    "    sleep(0.2)\n",
    "    clear_output(wait=True)\n",
    "    \n",
    "\n",
    "del a, b, c, result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<a Id=\"Constant-K\"></a>\n",
    "## Constant K\n",
    "List of length 64 containing 32 bits from the decimal part of the cubic root of the 64 first prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first64primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,\n",
    " 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197,\n",
    " 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311]\n",
    "\n",
    "K = [] # The list is indexed from 0 even tho is printed starting from 1.\n",
    "\n",
    "def frac2bin(frac):\n",
    "    x = floor(frac*(2**32))\n",
    "    bin32 = \"\"\n",
    "    \n",
    "    for _ in range(32):\n",
    "        bin32 += str(x % 2)\n",
    "        x = x // 2\n",
    "\n",
    "    return bin32[::-1]\n",
    "    \n",
    "\n",
    "\n",
    "for j, i in enumerate(first64primes):\n",
    "    sqrt3 = i**(1./3.)\n",
    "    deciaml_part = float(str(sqrt3)[1:])\n",
    "    K.append(bitarray(frac2bin(deciaml_part)))\n",
    "\n",
    "    print(\"{:>4} \\u21FE {:>4} \\u21FE {:>18} \\u21FE {:>18} \\u21FE {:>32}  \".format(j+1, \"\\u221B\"+str(i), sqrt3, deciaml_part,K[j].to01()))\n",
    "\n",
    "del first64primes, deciaml_part, sqrt3, i, j\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<a ID=\"Hashing\"></a>\n",
    "## Hashing\n",
    "\n",
    "1. [Encode](#Encode)\n",
    "2. [Padding](#Padding)\n",
    "3. [Message Schedule](#Message-Schedule)\n",
    "    1. [Block Iterator](#Block-Iterator)\n",
    "    2. [Word Iterator](#Word-Iterator)\n",
    "    3. [Initializing message schedule](#Initializing-message-schedule)\n",
    "    4. [Extending message shcedule](#Extending-message-schedule)\n",
    "4. [Compression](#Compression)\n",
    "    1. [Initializing stage registers](#Initializing-stage-regs)\n",
    "    1. [Block Compression](#Block-Compression)\n",
    "    3. [Sum UP](#Sum-UP)\n",
    "\n",
    "\n",
    "\n",
    "<a ID=\"Encode\"></a>\n",
    "### Encode\n",
    "Always use the same encode to have a solid and consistent output; in the case of SHA256 we use ASCII (American Standard Code II)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"Hello World!\"\n",
    "message = bitarray(endian='big')\n",
    "message.frombytes(string.encode('ascii')) # passing it to binary with a ASCII encoding\n",
    "\n",
    "print(\"Message:\")\n",
    "print(\"\\t{} \\\"{}\\\"\".format(\"Input:\", string))\n",
    "print(\"\\tEncoding: ASCII\")\n",
    "print(\"\\t{} {}\".format(\"Message:\", message.to01()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Padding\"></a>\n",
    "### Padding\n",
    "Hashing algorithms work in badges or blocks. Padding adds bits to make the message length a multiple of the block size required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"SHA-256 block size: {sha256().block_size*8} bits\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pdding structure:\n",
    "* Padding flag bit, added right after the message.\n",
    "* Cero padding, ceros added to the message in order to make its length a multiple of the block.\n",
    "* Length on the message encoded in the last 64 bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def padding(message):\n",
    "\n",
    "    p_message = message.to01()\n",
    "    blocks = len(message) // 512 +1 # Number of block the message is gonna take\n",
    "\n",
    "    if (len(message) % 512 >= (512 - 65)):\n",
    "        blocks += 1\n",
    "\n",
    "    p_message += '1' # Padding flag\n",
    "\n",
    "    # Same result as the commented loop\n",
    "    p_message += '0'*(blocks*512 - 64 - len(p_message))\n",
    "    #for _ in range(len(p_message), blocks*512 - 64):\n",
    "    #    p_message += '0'\n",
    "\n",
    "    # Last 64 bits with message length\n",
    "    bin_len_message = bin(len(message))[2:]\n",
    "    len_bin_len_message = len(bin_len_message)\n",
    "    p_message += '0'*(64-len_bin_len_message) + bin_len_message\n",
    "\n",
    "    return bitarray(p_message)\n",
    "\n",
    "\n",
    "\n",
    "p_message = padding(message)\n",
    "\n",
    "print(f\"Padding message size: {len(p_message)} bits\")\n",
    "print(\"Message:\")\n",
    "\n",
    "colors = {'Message':'\\033[95m', 'Padding flag':'\\033[91m', 'Padding':'\\033[93m', 'Length':'\\033[96m', 'Message Length':'\\033[94m'}\n",
    "\n",
    "for i, bit in enumerate(p_message.to01()):\n",
    "    if i >= len(p_message) - len(bin(len(message))[2:]):\n",
    "        color = colors['Message Length']\n",
    "    elif i >= len(p_message) - 64:\n",
    "        color = colors['Length']\n",
    "    elif i >= len(message) + 1:\n",
    "        color = colors['Padding']\n",
    "    elif i >= len(message):\n",
    "        color = colors['Padding flag']\n",
    "    else:\n",
    "        color = colors['Message']\n",
    "    print(color+bit, end=\"\")\n",
    "\n",
    "print(f\"\\n{colors['Message']}\\u2589 {'Message'}\")\n",
    "print(f\"{colors['Padding flag']}\\u2589 {'Padding flag'}\")\n",
    "print(f\"{colors['Padding']}\\u2589 {'Padding'}\")\n",
    "print(f\"{colors['Length']}\\u2589 {'Reserved bits for mesage length'}\")\n",
    "print(f\"{colors['Message Length']}\\u2589 {'Message length'}\")\n",
    "\n",
    "del color, colors, bit, i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID='Message-Schedule'></a>\n",
    "### Message Schedule\n",
    "\n",
    "<a ID=\"Block-Iterator\"></a>\n",
    "#### Block Iterator\n",
    "Iterates over the chunks \"blocks\" of data of the padding message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def blck_iter(message):\n",
    "    N_blck = len(message) // 512\n",
    "    for blck in range(N_blck):\n",
    "        yield message[blck*512:(blck+1)*512]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Word-Iterator\"></a>\n",
    "#### Word Iterator\n",
    "Iterates over words (32 bit chuncks) of the block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def word_iter(block):\n",
    "    N_words = len(block) // 32\n",
    "    for word in range(N_words):\n",
    "        yield block[word*32:(word+1)*32]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID='Initializing-message-schedule'></a>\n",
    "#### Initializing message schedule\n",
    "Creates a list of 16 words of 32 bits each, from the block data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def init_message_schedule(message):\n",
    "\n",
    "    words = []\n",
    "\n",
    "    for i in blck_iter(message):\n",
    "        words = []\n",
    "        for j in word_iter(i):\n",
    "            words.append(j)\n",
    "        yield words\n",
    "\n",
    "word_list = next(init_message_schedule(p_message))\n",
    "\n",
    "for i, w in enumerate(word_list):\n",
    "    print(\"{:>4}: {}\".format(\"W\"+str(i+1), w.to01()))\n",
    "\n",
    "del i, w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID='Extending-message-schedule'></a>\n",
    "#### Extending message schedule\n",
    "\n",
    "Compute the following formula for the remaining 48 words, for a total of 64 (48 + 16 = 64). <br></br>\n",
    "$Wx = σ1(W(x-2)) + W(x-7) + σ0(W(x-15)) + W(x-16)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extend_message_schedule(words):\n",
    "    for i in range(64-16):\n",
    "        N = len(words)\n",
    "        a = words[N-16].copy()\n",
    "        b = sigma0(*[words[N-15].copy() for _ in range(3)]) # Weird unpaking to match args\n",
    "        c = words[N-7].copy()\n",
    "        d = sigma1(*[words[N-2].copy() for _ in range(3)]) # Weird unpaking to match args\n",
    "        words.append(add(add(a, b), add(c, d)))\n",
    "    return words\n",
    "    \n",
    "    \n",
    "if(len(word_list) < 64):\n",
    "    # To refresh extended word list you must first rerun the aboce cell\n",
    "    word_list = extend_message_schedule(word_list.copy())\n",
    "\n",
    "\n",
    "for i in range(16, len(word_list)-15):\n",
    "\n",
    "    for j in range(i, i + 16):\n",
    "        if (j == i):\n",
    "            right_side = f\"\\u2014\"*5+f\"\\u2192 {word_list[j].to01()}\"\n",
    "        elif( j == i + 1):\n",
    "            right_side = f\"\\u2014 \\u03C30 \\u2192 {sigma0(*[word_list[j].copy() for _ in range(3)]).to01()}\"\n",
    "        elif( j == i + 8):\n",
    "            right_side = f\"\\u2014\"*5+f\"\\u2192 {word_list[j].to01()}\"\n",
    "        elif( j == i + 13):\n",
    "            right_side = f\"\\u2014 \\u03C31 \\u2192 {sigma1(*[word_list[j].copy() for _ in range(3)]).to01()}\"\n",
    "        elif( j == i + 15):\n",
    "            right_side = \"\\u2190\"+\"\\u2014\"*5+f\" \\u03C31(W{i + 14}) + W{i + 9} + \\u03C30(W{i + 2}) + W{i + 1}\"\n",
    "        else:\n",
    "            right_side = \"\"\n",
    "        print(\"{:>4}: {:>32} {}\".format(\"W\"+str(j+1), word_list[j].to01(), right_side))\n",
    "\n",
    "    sleep(0.3)\n",
    "    clear_output(wait=True)\n",
    "\n",
    "del i, j, right_side"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID='Compression'></a>\n",
    "### Compression\n",
    "<a ID='Initializing-stage-regs'></a>\n",
    "#### Initializing stage registers\n",
    "Initializing stage registers with the 32 first bits of the fractional part of the 8 first primes square roots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_stage_registers():\n",
    "    regs = [2, 3, 5, 7, 11, 13, 17, 19]\n",
    "    for i in range(len(regs)):\n",
    "        aux = bin(int((sqrt(regs[i])%1)*2**32))[2:]\n",
    "        regs[i] = bitarray(\"0\"*(32-len(aux))+aux)\n",
    "    return regs\n",
    "\n",
    "stage_reg = init_stage_registers()\n",
    "\n",
    "for i, p in zip([2, 3, 5, 7, 11, 13, 17, 19], stage_reg):\n",
    "    print(\"{:>4} \\u21FE {:>4} \\u21FE {:>18} \\u21FE {:>20} \\u21FE {:>32}  \".format(i, \"\\u221A\"+str(i), sqrt(i), sqrt(i)%1, p.to01()))\n",
    "    #print(\"{:>2} {}\".format(i, p.to01()))\n",
    "\n",
    "del i, p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Block-Compression\"></a>\n",
    "#### Block compression\n",
    "\n",
    "For the compression step we take our stage or working register we had previusly initialize, the first word from our schedule, the first K constant, and solve the following operations:\n",
    "\n",
    "$T1 = Σ1(e) + Choice(e, f, g) + h + Ki + Wi$<br>\n",
    "$T2 = Σ0(a) + Majority(a, b, c)$\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Tip:</b> 'i' is the index in our word schelu array and K array.\n",
    "</div>\n",
    "\n",
    "Then we shift each of the 8 registers moving the last one out of the array and populating the first one with ( $T1 + T2$ ). We also update 5th register by adding $T1$ to it and repeat this two steps for each Word and (K) constant pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def block_compress(stage_reg, word_list, K, animation=False):\n",
    "\n",
    "    working_stage_reg = stage_reg\n",
    "\n",
    "    temp1 = bitarray(endian='big')\n",
    "    temp2 = bitarray(endian='big')\n",
    "\n",
    "    for i in range(64):\n",
    "        temp1 = add( add( add( Sigma1(*[working_stage_reg[4].copy() for _ in range(3)]), choice(working_stage_reg[4].copy(), working_stage_reg[5].copy(), working_stage_reg[6].copy())), add( working_stage_reg[7].copy(), K[i])), word_list[i])\n",
    "        temp2 = add(Sigma0(*[working_stage_reg[0].copy() for _ in range(3)]), majority(working_stage_reg[0].copy(), working_stage_reg[1].copy(), working_stage_reg[2].copy()))\n",
    "        top = working_stage_reg[0].copy()\n",
    "        working_stage_reg.insert(0, add(temp1, temp2))\n",
    "        trash = working_stage_reg.pop()\n",
    "        working_stage_reg[4] = add(working_stage_reg[4], temp1)\n",
    "\n",
    "        if animation:\n",
    "            for scene in range(3):\n",
    "                print(\"W{}: {}\".format(i+1, word_list[i].to01()))\n",
    "                print(\"K{}: {}\\n\".format(i+1, K[i].to01()))\n",
    "\n",
    "                print(\"T1: {:>32} = {}\".format(temp1.to01(), \"\\u03A31(e) + Choice(e, f, g) + h + K\"+str(i+1)+\" + W\"+str(i+1)))\n",
    "                print(\"T2: {:>32} = {}\\n\".format(temp2.to01(), \"\\u03A30(a) + Majority(a, b, c)\"))\n",
    "\n",
    "                if(scene == 0):\n",
    "                    right_side = \"\\u2193\"\n",
    "                    print(\"{:>4} = {:>32} {}\".format(chr(97), top.to01(), right_side))\n",
    "                    for j, reg in enumerate(working_stage_reg[:-1]):\n",
    "                        print(\"{:>4} = {:>32} {}\".format(chr(j+97+1), reg.to01(), right_side))\n",
    "                    print(\"\")\n",
    "                elif(scene == 1):\n",
    "                    for j, reg in enumerate(working_stage_reg):\n",
    "                        if( j == 0):\n",
    "                            reg = \"...\"\n",
    "                            right_side = \"\"\n",
    "                            print(\"{:>4} = {:<32} {}\".format(chr(j+97), reg, right_side))\n",
    "                        else:\n",
    "                            right_side = \"\"\n",
    "                            print(\"{:>4} = {:>32} {}\".format(chr(j+97), reg.to01(), right_side))\n",
    "                    print(\"{:>4} {:>32} {}\".format(\"\\U0001F6AE\", trash.to01(), right_side))\n",
    "                elif(scene == 2):\n",
    "                    for j, reg in enumerate(working_stage_reg):\n",
    "                        if( j == 0):\n",
    "                            right_side = \"\\u2190\"+\"\\u2014 T2 + T1\"\n",
    "                        elif( j == 4):\n",
    "                            right_side = \"\\u2190\"+\"\\u2014 e + T1\"\n",
    "                        else:\n",
    "                            right_side = \"\"\n",
    "                        print(\"{:>4} = {:>32} {}\".format(chr(j+97), reg.to01(), right_side))\n",
    "                    print(\"\")\n",
    "\n",
    "                if i < 12:\n",
    "                    sleep(0.5)\n",
    "                else:\n",
    "                    sleep(0.05)\n",
    "                clear_output(wait=True)\n",
    "    \n",
    "    return working_stage_reg\n",
    "\n",
    "stage_reg = block_compress(stage_reg.copy(), word_list, K, True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Sum-UP\"></a>\n",
    "### Sum UP\n",
    "\n",
    "As the final step we add the stage or working registers with the values of the initial registers, and encode this to hexadecimal. Then concatenate the hexadecimal values from first to last on a sigle string, and we have our hash digest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def sum_up(stage_reg, animation = False):\n",
    "    result = []\n",
    "    hexa = []\n",
    "    if animation:\n",
    "        print(\"{:8}   {:32}   {:32}   {:32}\".format(\"HEX\".center(8), \"Results\".center(32), \"Initial reg values\".center(32), \"Final compression values\".center(32)))\n",
    "        print(\"-\"*113)\n",
    "    for init_reg, temp_reg in zip(init_stage_registers(), stage_reg):\n",
    "        result.append(add(init_reg, temp_reg))\n",
    "        hexa.append(util.ba2hex(result[-1]))\n",
    "        if animation:\n",
    "            print(\"{} \\u2190 {} = {} + {}\".format(hexa[-1], result[-1].to01(), init_reg.to01(), temp_reg.to01()))\n",
    "    return \"\".join(hexa)\n",
    "        \n",
    "\n",
    "digest = sum_up(stage_reg, True)\n",
    "\n",
    "print(\"\\n\\t\\u250F\"+\"\\u2501\"*74+\"\\u2513\")\n",
    "print(\"\\t\\u2503 Digest: \"+digest+\" \\u2503\")\n",
    "print(\"\\t\\u2517\"+\"\\u2501\"*74+\"\\u251B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<a ID=\"Checking-Result\"></a>\n",
    "## Checking the result\n",
    "\n",
    "Checking the result of our hashing fuction against the SHA-256 build in hashlib module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_digests(digest1, digest2):\n",
    "    printout1 = \"\"\n",
    "    printout2 = \"\"\n",
    "    for i, j in zip(digest1, digest2):\n",
    "        if i != j:\n",
    "            color = \"\\033[91m\"\n",
    "        else:\n",
    "            color = \"\\033[92m\"\n",
    "        printout1 += color+i\n",
    "        printout2 += color+j\n",
    "    check = \"\\u2705\" if digest1 == digest2 else \"\\u274C\"\n",
    "    \n",
    "    print(printout1+\" \"+printout2+\" \"+check+\"\\033[0m\")\n",
    "\n",
    "print(f\"{'Type'.center(9)} {'Our digest'.center(64)} {'Hashlib digest'.center(64)}\\n\"+\"-\"*145)\n",
    "print(f\"  \\\"Correct\\\"   \", end=\"\")\n",
    "compare_digests(digest, sha256(string.encode('ascii')).hexdigest())\n",
    "print(\"  \\\"Wrong\\\"     \", end=\"\")\n",
    "compare_digests(digest, sha256(b\"Hello Kitty!\").hexdigest()) # Wrong on purpose, to see different output\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Consolidating-Operations\"></a>\n",
    "## Consolidating operations\n",
    "\n",
    "All the diferent parts and steps putted tougether in a single fucntion that can handle more than one block hashes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diy_sha256(data):\n",
    "    message = bitarray(endian='big')\n",
    "    message.frombytes(data)\n",
    "    message = padding(message)\n",
    "    #print(message)\n",
    "    virgin_stage_registers = init_stage_registers()\n",
    "    m_schedule = init_message_schedule(message)\n",
    "    working_stage_registers = init_stage_registers()#virgin_stage_registers\n",
    "    \n",
    "    #print(virgin_stage_registers)\n",
    "    for i, word_batch in enumerate(m_schedule):\n",
    "        \n",
    "        \n",
    "        #print(working_stage_registers)\n",
    "        word_batch = extend_message_schedule(word_batch.copy())\n",
    "        working_stage_registers = block_compress(working_stage_registers, word_batch, K)\n",
    "\n",
    "        for n in range(8):\n",
    "            working_stage_registers[n] = add(virgin_stage_registers[n], working_stage_registers[n])\n",
    "\n",
    "        virgin_stage_registers = working_stage_registers.copy()\n",
    "    \n",
    "    hex_regs = []\n",
    "    for i in working_stage_registers:\n",
    "        hex_regs.append(util.ba2hex(i))\n",
    "\n",
    "    #print(hex_regs)\n",
    "    \n",
    "    return \"\".join(hex_regs) #sum_up(working_stage_registers)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Testing\"></a>\n",
    "## Testing\n",
    "\n",
    "<a ID=\"Simple-test\"></a>\n",
    "#### Simple test\n",
    "\n",
    "Uses a word list to check for a couple of diferent inputs.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Tip:</b> The file \"BIP-0039_english.txt\" must be in the same directory as the notebook.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"{'   N'}\"+\" \"*7+f\"{'Input'} {'Our digest'.center(64)} {'Hashlib digest'.center(64)}\\n\"+\"-\"*150)\n",
    "with open(\"BIP-0039_english.txt\", 'r') as file:\n",
    "    for i, item in enumerate(file):\n",
    "        if i % 85 == 0:\n",
    "            print(\"{:>4} {:>12} \".format(i,item.rstrip()), end=\"\")\n",
    "            binary_item = item.rstrip().encode('ascii')\n",
    "            compare_digests(diy_sha256(binary_item), sha256(binary_item).hexdigest())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a ID=\"Multiblock-Test\"></a>\n",
    "#### Multiblock test\n",
    "\n",
    "The following code increments the size of a string in each of its iterations to proof the algorith with different block sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(\"{:>4}  {:>4} {:>64} {:>64}\\n\".format(\"Bits\", \"Blcks\", 'Our digest'.center(64), 'Hashlib digest'.center(64))+\"-\"*140)\n",
    "for i in range(10):\n",
    "    long_string = \"SHA-256\"*i*10\n",
    "    print(\"{:>4} {:>4} \".format(len(long_string)*8, len(long_string) // sha256().block_size), end=\" \")\n",
    "    bin_long_string = long_string.encode('ascii')\n",
    "    compare_digests(diy_sha256(bin_long_string), sha256(bin_long_string).hexdigest())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"Unitest-Testing\"></a>\n",
    "#### Unittest testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestSHA256(unittest.TestCase):\n",
    "    def test_sigleblock(self):\n",
    "        with open(\"BIP-0039_english.txt\", 'r') as file:\n",
    "            for i, item in enumerate(file):\n",
    "                binary_item = item.rstrip().encode('ascii')\n",
    "                diy_digest = diy_sha256(binary_item)\n",
    "                hashlib_digest = sha256(binary_item).hexdigest()\n",
    "                self.assertEqual(diy_digest, hashlib_digest)\n",
    "\n",
    "    def test_multiblok(self):\n",
    "        for i in range(200, 500):\n",
    "                binary_item = ('0'*i).encode('ascii')\n",
    "                diy_digest = diy_sha256(binary_item)\n",
    "                hashlib_digest = sha256(binary_item).hexdigest()\n",
    "                self.assertEqual(diy_digest, hashlib_digest)\n",
    "\n",
    "    def test_empty(self):\n",
    "        binary_item = \"\".encode('ascii')\n",
    "        diy_digest = diy_sha256(binary_item)\n",
    "        hashlib_digest = sha256(binary_item).hexdigest()\n",
    "        self.assertEqual(diy_digest, hashlib_digest)\n",
    "\n",
    "    def test_loremipsum(self):\n",
    "        text = \"\"\"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque ex nulla, tincidunt sed pretium vitae, sagittis nec urna.\n",
    "        Donec tempus scelerisque semper. Aliquam ut vestibulum ex, a varius tortor. Suspendisse eget metus condimentum, tincidunt nulla quis, eleifend nunc.\n",
    "        Vivamus sed volutpat eros. Vestibulum malesuada ac orci in fermentum. Aenean fringilla, elit in efficitur facilisis, arcu dolor convallis arcu, sed finibus leo orci id turpis.\n",
    "        Aliquam erat volutpat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Duis blandit congue massa. Aenean scelerisque turpis id elit aliquet efficitur.\n",
    "        Nam dignissim semper ultricies. Aliquam sed nunc in ligula finibus egestas eu eu mi. Donec pharetra nunc id turpis iaculis sagittis. Nulla in eleifend arcu.\n",
    "        Donec porta elit at cursus elementum. Nulla consectetur varius dui ac congue. Suspendisse at nisl ut augue placerat cursus at at mauris. Fusce ultricies dignissim velit, eu sodales ex venenatis augue.\"\"\"\n",
    "        binary_item = text.encode('ascii')\n",
    "        diy_digest = diy_sha256(binary_item)\n",
    "        hashlib_digest = sha256(binary_item).hexdigest()\n",
    "        self.assertEqual(diy_digest, hashlib_digest)\n",
    "    \n",
    "    def test_failbyonebyte(self):\n",
    "        binary_ascii = b'Hello World'\n",
    "        binary_utf = b'Hello world'\n",
    "        ascii_digest = diy_sha256(binary_ascii)\n",
    "        utf_digest = diy_sha256(binary_utf)\n",
    "        self.assertNotEqual(ascii_digest, utf_digest)\n",
    "\n",
    "\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a61bcf1725ac39fd63ff1bfe1b2a097d9bf3f5b24512166876b54ab35169d45a"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 ('hd-wallet-2EL5oofP')",
   "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.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}