notebooks/3_glitch_double_loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glitching a simple double loop\n",
    "\n",
    "In this notebook we target a dummy program (a double loop) using voltage glitching. The goal is to determine how suseptible our target is to voltage glitching. We also use this target to determine a range of glitch widths that result in faulty outputs. \n",
    "\n",
    "The following code snippet shows the code we are tying to glitch.\n",
    "\n",
    "```C\n",
    "void double_loop()\n",
    "{\n",
    "    char input;\n",
    "    volatile int i, j, cnt;\n",
    "\n",
    "    while (1)\n",
    "    {\n",
    "        UART_read(uart, &input, 1);\n",
    "        if (input == 0xAA)\n",
    "        {\n",
    "            cnt = 0;\n",
    "            GPIO_write(Board_GPIO_LED0, 1); // Set trigger high\n",
    "            for (i = 0; i < 100; i++)\n",
    "            {\n",
    "                for (j = 0; j < 100; j++)\n",
    "                {\n",
    "                    cnt++;\n",
    "                }\n",
    "            }\n",
    "            GPIO_write(Board_GPIO_LED0, 0); // Set trigger low\n",
    "            UART_write(uart, &cnt, 4);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "## Hardware Setup\n",
    "To run this notebook you will need the hardware outlined in the main README of the repository. You will also need to modify your target for voltage glitching, at a minimum this requires removing C19 and connecting the ChipWhisperer glitch port to the DCOUPL pin. All instructions for modifying the targets are provided in the main README.\n",
    "\n",
    "Make sure to connect your ChipWhisperer to the modified LAUNCHXL-CC2640R2 board before running the notebook.\n",
    "* Connect the target SMA connector to your ChipWhisperer's Glitch/Crowbar port\n",
    "* Remove the 3V3 jumper and connect the target side pin to the ChipWhisperer's 3V3 output\n",
    "* Remove the RESET jumper and connect the target side to the ChipWhisperer's NRST output\n",
    "* Connect the ChipWhisperer's IO4/TRG to the target's DIO6 pin\n",
    "* Connect the ChipWhisperer's ground to a ground pin on the target board"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparation\n",
    "\n",
    "The following cells load the required libraries and initialise the ChipWhisperer as well as our target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:ChipWhisperer Other:Could not check ChipWhisperer version, error __init__() got an unexpected keyword argument 'capture_output'\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import time\n",
    "import os\n",
    "import numpy as np\n",
    "import chipwhisperer as cw\n",
    "from tqdm.notebook import tqdm\n",
    "import serial\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ser = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Connect to the ChipWhisperer and perform some basic initialization\n",
    "\n",
    "scope = cw.scope()\n",
    "\n",
    "scope.clock.clkgen_src = 'system' \n",
    "scope.clock.clkgen_freq = 200e6          # Main ChipWhisperer clock\n",
    "scope.clock.adc_mul = 0\n",
    "scope.trigger.triggers = 'tio4'          # Trigger on a rising edge of TIO4 (connected to DIO6)\n",
    "scope.adc.basic_mode = 'rising_edge'\n",
    "scope.io.target_pwr = True\n",
    "\n",
    "scope.glitch.enabled = True\n",
    "scope.glitch.clk_src = 'pll'\n",
    "#scope.clock.pll.update_fpga_vco(600e6)\n",
    "scope.glitch.output = 'enable_only'\n",
    "scope.glitch.trigger_src = 'ext_single'\n",
    "scope.io.glitch_lp = True                # only using the 'low power' glitch mosfet\n",
    "scope.io.glitch_hp = False\n",
    "scope.glitch.repeat = 15                 # Glitch repeat (or glitch width) in cycles of the main CW clock.\n",
    "scope.glitch.ext_offset = 300            # Glitch offset from the external trigger (in cycles of the main CW clock)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Connect to the LAUNCHXL-CC2640R2 UART\n",
    "# You may have to change the serial port ('/dev/ttyACM1')\n",
    "\n",
    "if ser:\n",
    "    ser.close()\n",
    "\n",
    "ser = serial.Serial('/dev/ttyACM1', 115200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target has been flashed!\n"
     ]
    }
   ],
   "source": [
    "# Modify the dslite_path variable to point to your installation of Uniflash\n",
    "# Running this cell will load the example target firmware\n",
    "# THIS WILL OVERWRITE THE FIRMWARE ON YOUR LAUNCHXL-CC2640R2\n",
    "\n",
    "import subprocess\n",
    "from pathlib import Path\n",
    "\n",
    "home_dir = str(Path.home()) \n",
    "dslite_path = home_dir + '/ti/uniflash_7.0.0/dslite.sh'\n",
    "erase_cmd = dslite_path + ' --mode cc13xx-cc26xx-mass-erase -d XDS110'\n",
    "flash_cmd = dslite_path + ' --config ./bin/CC2640R2F.ccxml --flash ./bin/VFI_SCA_CC2640R2.out' \n",
    "\n",
    "process = subprocess.Popen(erase_cmd.split(' '), stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n",
    "output = process.communicate()\n",
    "\n",
    "if b'Device Unlocked' not in output[0]:\n",
    "    print('There was an error while trying to erase the microcontroller')\n",
    "    print(output)\n",
    "else:\n",
    "    scope.io.nrst = 'low'\n",
    "    scope.io.target_pwr = False\n",
    "    time.sleep(0.1)\n",
    "    scope.io.target_pwr = True\n",
    "    scope.io.nrst = 'high'\n",
    "    \n",
    "    process = subprocess.Popen(flash_cmd.split(' '), stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n",
    "    output = process.communicate()\n",
    "    if b'Board Reset Complete' in output[0]:\n",
    "        print('Target has been flashed!')\n",
    "    else:\n",
    "        print('Error flashing target. Check your connections and try again.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple function to reset the target microcontroller\n",
    "def reset_dut(delay=0.1):\n",
    "    scope.io.nrst = 'low'\n",
    "    scope.io.target_pwr = False\n",
    "    time.sleep(delay)\n",
    "    scope.io.target_pwr = True\n",
    "    scope.io.nrst = 'high'\n",
    "    time.sleep(0.05)\n",
    "    ser.flushInput()\n",
    "    ser.write(b'd') # To select the double loop function of the firmware\n",
    "    \n",
    "\n",
    "# A more thorough reset function that verifies that the target is alive again\n",
    "def thorough_reset_dut(delay=0.05): \n",
    "    reset_dut(delay)\n",
    "    \n",
    "    ser.flushInput()\n",
    "    ser.write(bytes([0xAA]))\n",
    "    time.sleep(0.05)\n",
    "    ret = ser.read(ser.in_waiting)\n",
    "        \n",
    "    while int.from_bytes(ret, 'little') != 10000:\n",
    "        delay += 0.5\n",
    "        reset_dut(delay)\n",
    "        ser.write(bytes([0xAA]))\n",
    "        time.sleep(0.05)\n",
    "        ret = ser.read(ser.in_waiting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All set to start glitching!\n"
     ]
    }
   ],
   "source": [
    "# Make sure the target is performing the double loop function\n",
    "\n",
    "reset_dut(1)\n",
    "ser.write(bytes([0xAA]))\n",
    "time.sleep(0.05)\n",
    "ret = ser.read(ser.in_waiting)\n",
    "cnt = int.from_bytes(ret, 'little')\n",
    "\n",
    "if cnt != 10000:\n",
    "    print('The output received from the target is not correct..')\n",
    "    print(ret, cnt)\n",
    "else:\n",
    "    print('All set to start glitching!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A basic glitching experiment\n",
    "\n",
    "The following cell uses a fixed glitch width (`scope.glitch.repeat`) and iterates over a range of offsets starting from the trigger signal. At each offset we try to inject 5 glitches.\n",
    "\n",
    "We assume the target crashed if it does not return any output. We successfully injected a glitch if the target replies with a counter value that is not equal to 10000, those values will be printed. In both cases we reset the target device.\n",
    "\n",
    "This cell should take roughly 50 seconds to complete and should produce at least a few faulty counter outputs!\n",
    "Feel free to play around with the parameters (`scope.glitch.repeat`, `offsets`, `repeats`).\n",
    "If you are not getting any faulted outputs and 0% crashes you might want to try and increase the `scope.glitch.repeat` value. Similarly, if you get 100% crashes you can try lowering this value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c316948bc0a477db655dbbc93edc053",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fault?! 10001 11270000\n",
      "Fault?! 10002 12270000\n",
      "Fault?! 10002 12270000\n",
      "Fault?! 9899 ab260000\n",
      "Fault?! 9999 0f270000\n",
      "Fault?! 10001 11270000\n",
      "Fault?! 9911 b7260000\n",
      "Fault?! 8899 c3220000\n",
      "Fault?! 9999 0f270000\n",
      "Fault?! 9999 0f270000\n",
      "Fault?! 9911 b7260000\n",
      "Fault?! 9901 ad260000\n",
      "Fault?! 9999 0f270000\n",
      "Fault?! 9914 ba260000\n",
      "Fault?! 9915 bb260000\n",
      "Fault?! 10001 11270000\n",
      "Fault?! 9885 9d260000\n",
      "Fault?! 30231 17760000\n",
      "Fault?! 9918 be260000\n",
      "Fault?! 10001 11270000\n",
      "Fault?! 10018 22270000\n",
      "Fault?! 10018 22270000\n",
      "Fault?! 8318 7e200000\n",
      "Fault?! 10063 4f270000\n",
      "Fault?! 9909 b5260000\n",
      "Fault?! 9921 c1260000\n",
      "Fault?! 9921 c1260000\n",
      "Fault?! 9924 c4260000\n",
      "Fault?! 7599 af1d0000\n",
      "Fault?! 9924 c4260000\n",
      "Fault?! 9926 c6260000\n",
      "Fault?! 10027 2b270000\n",
      "Fault?! 9927 c7260000\n",
      "Fault?! 10001 11270000\n",
      "\n",
      "Total # attempts: 500\n",
      "Total # faults: 34 (6.800000%)\n",
      "Total # crashes: 92 (18.400000%)\n"
     ]
    }
   ],
   "source": [
    "scope.glitch.repeat = 15\n",
    "offsets = np.arange(0, 2000, 20)\n",
    "repeats = 5\n",
    "\n",
    "crashes = 0\n",
    "faults = 0\n",
    "\n",
    "for offset in tqdm(range(len(offsets))):\n",
    "    scope.glitch.ext_offset = offsets[offset]\n",
    "    \n",
    "    for i in range(repeats):\n",
    "        scope.arm()\n",
    "        ser.write(bytes([0xAA]))\n",
    "        time.sleep(0.05)\n",
    "        ret = ser.read(ser.in_waiting)\n",
    "        \n",
    "        if ret != b\"\\x10'\\x00\\x00\":\n",
    "            if ret == b'':\n",
    "                crashes += 1\n",
    "            else:\n",
    "                faults += 1\n",
    "                print('Fault?!', int.from_bytes(ret, 'little'), ret.hex())\n",
    "            thorough_reset_dut() \n",
    "                \n",
    "total = len(offsets)*repeats\n",
    "print(\"\\nTotal # attempts:\", total) \n",
    "print(\"Total # faults: %d (%f%%)\" % (faults, (faults/total)*100))\n",
    "print(\"Total # crashes: %d (%f%%)\" % (crashes, (crashes/total)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determining a good glitch width\n",
    "\n",
    "The following cells perform a similar experiment to the previous one, but in this case we also iterate over multiple glitch widths and keep track of the number of faults and crashes per combination of glitch offset and glitch width. This allows to create a visual map (similar to Figure 3 in the paper)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "offsets = np.arange(0, 100, 4)\n",
    "widths = np.arange(10, 28, 1)\n",
    "repeats = 10\n",
    "\n",
    "#offsets = np.arange(0, 400, 4)\n",
    "#widths = np.arange(10, 28, 1)\n",
    "#repeats = 50\n",
    "\n",
    "crashes = np.zeros((len(offsets), len(widths)))\n",
    "faults = np.zeros((len(offsets), len(widths)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "83434ad542bc489b916156d484f36809",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/25 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1585152 003018\n",
      "Offset: 0, faults: 1, crashes: 119\n",
      "1581056 002018\n",
      "Offset: 4, faults: 1, crashes: 111\n",
      "532480 002008\n",
      "1585152 003018\n",
      "Offset: 8, faults: 2, crashes: 122\n",
      "Offset: 12, faults: 0, crashes: 109\n",
      "Offset: 16, faults: 0, crashes: 107\n",
      "Offset: 20, faults: 0, crashes: 105\n",
      "1585152 003018\n",
      "532480 002008\n",
      "1585152 003018\n",
      "536576 003008\n",
      "532480 002008\n",
      "Offset: 24, faults: 5, crashes: 105\n",
      "1585152 003018\n",
      "1585152 003018\n",
      "532480 002008\n",
      "Offset: 28, faults: 3, crashes: 110\n",
      "Offset: 32, faults: 0, crashes: 121\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "1581056 002018\n",
      "Offset: 36, faults: 3, crashes: 98\n",
      "1342191276 ac360050\n",
      "1342191376 10370050\n",
      "9900 ac260000\n",
      "1342191376 10370050\n",
      "9900 ac260000\n",
      "532480 002008\n",
      "Offset: 40, faults: 6, crashes: 92\n",
      "9900 ac260000\n",
      "0 00000000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "0 00000000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9999 0f270000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "Offset: 44, faults: 15, crashes: 88\n",
      "0 00000000\n",
      "9901 ad260000\n",
      "9901 ad260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "0 00000000\n",
      "0 00000000\n",
      "Offset: 48, faults: 7, crashes: 90\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9901 ad260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "Offset: 52, faults: 9, crashes: 85\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9901 ad260000\n",
      "9901 ad260000\n",
      "9901 ad260000\n",
      "9901 ad260000\n",
      "0 00000000\n",
      "Offset: 56, faults: 8, crashes: 93\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "100 64000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "Offset: 60, faults: 11, crashes: 96\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "100 64000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "9900 ac260000\n",
      "Offset: 64, faults: 12, crashes: 97\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "0 00000000\n",
      "100 64000000\n",
      "Offset: 68, faults: 9, crashes: 104\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "Offset: 72, faults: 10, crashes: 110\n",
      "1342181376 00100050\n",
      "532480 002008\n",
      "1585152 003018\n",
      "1585152 003018\n",
      "1585152 003018\n",
      "Offset: 76, faults: 5, crashes: 91\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "1585152 003018\n",
      "532480 002008\n",
      "1581056 002018\n",
      "532480 002008\n",
      "532480 002008\n",
      "1585152 003018\n",
      "1585152 003018\n",
      "532480 002008\n",
      "532480 002008\n",
      "Offset: 80, faults: 11, crashes: 89\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "1585152 003018\n",
      "536576 003008\n",
      "1585152 003018\n",
      "Offset: 84, faults: 11, crashes: 93\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9999 0f270000\n",
      "Offset: 88, faults: 3, crashes: 105\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "9900 ac260000\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "10029 2d270000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "9900 ac260000\n",
      "1585152 003018\n",
      "Offset: 92, faults: 11, crashes: 110\n",
      "9999 0f270000\n",
      "9999 0f270000\n",
      "99 63000000\n",
      "99 63000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "0 00000000\n",
      "Offset: 96, faults: 17, crashes: 109\n",
      "The glitch width resuling in most fauly counter outputs is: 20\n"
     ]
    }
   ],
   "source": [
    "for offset in tqdm(range(len(offsets))):\n",
    "    for width in range(len(widths)):\n",
    "        scope.glitch.ext_offset = offsets[offset]\n",
    "        scope.glitch.repeat = widths[width]\n",
    "    \n",
    "        for i in range(repeats):\n",
    "            scope.arm()\n",
    "            ser.write(bytes([0xAA]))\n",
    "            time.sleep(0.05)\n",
    "            ret = ser.read(ser.in_waiting)\n",
    "            if ret != b\"\\x10'\\x00\\x00\":\n",
    "                if ret == b'':\n",
    "                    crashes[offset, width] += 1\n",
    "                    thorough_reset_dut()\n",
    "                else:\n",
    "                    faults[offset, width] += 1\n",
    "                    print(int.from_bytes(ret, 'little'), ret.hex())\n",
    "\n",
    "                thorough_reset_dut()\n",
    "                    \n",
    "                    \n",
    "    print('Offset: %d, faults: %d, crashes: %d' % (offsets[offset], np.sum(faults[offset,:]), np.sum(crashes[offset,:])))\n",
    "    \n",
    "print('The glitch width resuling in most fauly counter outputs is:', widths[np.argmax(np.sum(faults, axis=0))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8, 8))\n",
    "plt.title('Number of faults')\n",
    "plt.xlabel('Glitch offset')\n",
    "plt.ylabel('Glitch width')\n",
    "plt.imshow(faults.T, interpolation='none')\n",
    "plt.xticks(range(0,len(offsets)), offsets)\n",
    "plt.yticks(range(0,len(widths)), widths)\n",
    "plt.colorbar(orientation='horizontal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8, 8))\n",
    "plt.title('Number of crashes')\n",
    "plt.xlabel('Glitch offset')\n",
    "plt.ylabel('Glitch width')\n",
    "plt.imshow(crashes.T, interpolation='none')\n",
    "plt.xticks(range(0,len(offsets)), offsets)\n",
    "plt.yticks(range(0,len(widths)), widths)\n",
    "plt.colorbar(orientation='horizontal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser.close()\n",
    "scope.dis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}