bgp_routing_attacks_sim_poc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNEw0o1heII+rjRlz3b6rYp",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ericyoc/bgp-routing-attacks-sim-poc/blob/main/bgp_routing_attacks_sim_poc.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qo2GtMo79Ggk",
        "outputId": "8e1d998a-7d4d-4dfc-d4f5-86ca427b5938"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Routing Table before BGP Attacks:\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Router          | AS1               | AS2               | AS3               | AS4               |\n",
            "+=================+===================+===================+===================+===================+\n",
            "| Attacker ASN: 4 |                   |                   |                   |                   |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Target ASN: 1   |                   |                   |                   |                   |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "|                 |                   |                   |                   |                   |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Router 1        | 0 (AS1) [1]       | 1 (AS2) [2, 1]    | 1 (AS3) [3, 1]    | 2 (AS2) [4, 2, 1] |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Router 2        | 1 (AS1) [1, 2]    | 0 (AS2) [2]       | 2 (AS4) [3, 4, 2] | 1 (AS4) [4, 2]    |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Router 3        | 1 (AS1) [1, 3]    | 2 (AS4) [2, 4, 3] | 0 (AS3) [3]       | 1 (AS4) [4, 3]    |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "| Router 4        | 2 (AS2) [1, 2, 4] | 1 (AS2) [2, 4]    | 1 (AS3) [3, 4]    | 0 (AS4) [4]       |\n",
            "+-----------------+-------------------+-------------------+-------------------+-------------------+\n",
            "\n",
            "Explanation:\n",
            "Before the BGP attacks, the routing table shows the normal distances, next-hop\n",
            "ASNs, and paths between routers. Each router has learned the best paths to reach\n",
            "other ASNs based on the shortest distances advertised by their neighbors.\n",
            "\n",
            "Routing Paths:\n",
            "AS1\n",
            "AS1 -> AS2\n",
            "AS1 -> AS3\n",
            "AS1 -> AS2 -> AS4\n",
            "\n",
            "Routing Table after Sub-Prefix Hijacking:\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Router          | AS1            | AS2               | AS3               | AS4               |\n",
            "+=================+================+===================+===================+===================+\n",
            "| Attacker ASN: 4 |                |                   |                   |                   |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Target ASN: 1   |                |                   |                   |                   |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "|                 |                |                   |                   |                   |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Router 1        | 0 (AS1) [1]    | 1 (AS2) [2, 1]    | 1 (AS3) [3, 1]    | 2 (AS2) [4, 2, 1] |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Router 2        | 1 (AS1) [1, 2] | 0 (AS2) [2]       | 2 (AS4) [3, 4, 2] | 1 (AS4) [4, 2]    |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Router 3        | 1 (AS1) [1, 3] | 2 (AS4) [2, 4, 3] | 0 (AS3) [3]       | 1 (AS4) [4, 3]    |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "| Router 4        | 0 (AS4) [4]    | 1 (AS2) [2, 4]    | 1 (AS3) [3, 4]    | 0 (AS4) [4]       |\n",
            "+-----------------+----------------+-------------------+-------------------+-------------------+\n",
            "\n",
            "Explanation:\n",
            "In a sub-prefix hijacking attack, the attacker (AS4) advertises a more specific\n",
            "prefix of the target ASN (AS1). This causes other routers to prefer the more\n",
            "specific route advertised by the attacker, effectively hijacking the traffic\n",
            "destined for the target ASN.\n",
            "\n",
            "Routing Paths:\n",
            "AS1\n",
            "AS1 -> AS2\n",
            "AS1 -> AS3\n",
            "AS4\n",
            "\n",
            "Routing Table after BGP Prepending:\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Router          | AS1                     | AS2                  | AS3                        | AS4                     |\n",
            "+=================+=========================+======================+============================+=========================+\n",
            "| Attacker ASN: 4 |                         |                      |                            |                         |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Target ASN: 1   |                         |                      |                            |                         |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "|                 |                         |                      |                            |                         |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Router 1        | 0 (AS1) [1]             | 1 (AS2) [2, 1]       | 1 (AS3) [3, 1]             | 2 (AS2) [4, 2, 1]       |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Router 2        | 1 (AS1) [2, 2, 2, 1, 2] | 0 (AS2) [2, 2, 2, 2] | 2 (AS4) [2, 2, 2, 3, 4, 2] | 1 (AS4) [2, 2, 2, 4, 2] |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Router 3        | 1 (AS1) [1, 3]          | 2 (AS4) [2, 4, 3]    | 0 (AS3) [3]                | 1 (AS4) [4, 3]          |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "| Router 4        | 0 (AS4) [4]             | 1 (AS2) [2, 4]       | 1 (AS3) [3, 4]             | 0 (AS4) [4]             |\n",
            "+-----------------+-------------------------+----------------------+----------------------------+-------------------------+\n",
            "\n",
            "Explanation:\n",
            "In a BGP prepending attack, the prepender (AS2) artificially increases the\n",
            "length of the AS path by prepending its own ASN multiple times (3). This makes\n",
            "the route appear less attractive to other routers, discouraging them from using\n",
            "the prepender as a transit point.\n",
            "\n",
            "Routing Paths:\n",
            "AS1\n",
            "AS2 -> AS2 -> AS2 -> AS1 -> AS2\n",
            "AS1 -> AS3\n",
            "AS4\n"
          ]
        }
      ],
      "source": [
        "import random\n",
        "from collections import defaultdict\n",
        "from tabulate import tabulate\n",
        "from textwrap import wrap\n",
        "\n",
        "class Router:\n",
        "    def __init__(self, asn):\n",
        "        self.asn = asn\n",
        "        self.neighbors = []\n",
        "        self.routing_table = defaultdict(lambda: float('inf'))\n",
        "        self.routing_table[asn] = (0, asn, [asn])\n",
        "\n",
        "    def add_neighbor(self, neighbor):\n",
        "        self.neighbors.append(neighbor)\n",
        "\n",
        "    def receive_update(self, asn, distance, next_hop, path):\n",
        "        if asn not in self.routing_table or distance + 1 < self.routing_table[asn][0]:\n",
        "            self.routing_table[asn] = (distance + 1, next_hop, path + [self.asn])\n",
        "\n",
        "    def send_updates(self):\n",
        "        for neighbor in self.neighbors:\n",
        "            for asn, (distance, next_hop, path) in self.routing_table.items():\n",
        "                if asn != neighbor.asn:\n",
        "                    neighbor.receive_update(asn, distance, self.asn, path)\n",
        "\n",
        "    def get_best_path(self, asn):\n",
        "        distance, next_hop, path = self.routing_table[asn]\n",
        "        if distance == float('inf'):\n",
        "            return None, None, None\n",
        "        return distance, next_hop, path\n",
        "\n",
        "def simulate_bgp(routers, iterations):\n",
        "    for _ in range(iterations):\n",
        "        for router in routers:\n",
        "            router.send_updates()\n",
        "\n",
        "def print_routing_table(routers, attacker_asn, target_asn, explanation, routing_paths):\n",
        "    table_data = []\n",
        "    headers = [\"Router\"] + [f\"AS{router.asn}\" for router in routers]\n",
        "\n",
        "    table_data.append([f\"Attacker ASN: {attacker_asn}\", \"\", \"\", \"\", \"\"])\n",
        "    table_data.append([f\"Target ASN: {target_asn}\", \"\", \"\", \"\", \"\"])\n",
        "    table_data.append([\"\"] * len(headers))\n",
        "\n",
        "    for router in routers:\n",
        "        row_data = [f\"Router {router.asn}\"]\n",
        "        for asn in range(1, len(routers) + 1):\n",
        "            distance, next_hop, path = router.get_best_path(asn)\n",
        "            if distance is None:\n",
        "                row_data.append(\"∞\")\n",
        "            else:\n",
        "                row_data.append(f\"{distance} (AS{next_hop}) {path}\")\n",
        "        table_data.append(row_data)\n",
        "\n",
        "    print(tabulate(table_data, headers, tablefmt=\"grid\"))\n",
        "\n",
        "    wrapped_explanation = wrap(explanation, width=80)\n",
        "    print(\"\\nExplanation:\")\n",
        "    for line in wrapped_explanation:\n",
        "        print(line)\n",
        "\n",
        "    print(\"\\nRouting Paths:\")\n",
        "    for path in routing_paths:\n",
        "        print(path)\n",
        "\n",
        "def perform_subprefix_hijacking(routers, attacker_asn, target_asn):\n",
        "    attacker_router = None\n",
        "    for router in routers:\n",
        "        if router.asn == attacker_asn:\n",
        "            attacker_router = router\n",
        "            break\n",
        "\n",
        "    if attacker_router:\n",
        "        # Perform sub-prefix hijacking by advertising a more specific prefix of the target ASN\n",
        "        attacker_router.routing_table[target_asn] = (0, attacker_asn, [attacker_asn])\n",
        "        attacker_router.send_updates()\n",
        "\n",
        "def perform_bgp_prepending(routers, prepender_asn, prepend_count):\n",
        "    prepender_router = None\n",
        "    for router in routers:\n",
        "        if router.asn == prepender_asn:\n",
        "            prepender_router = router\n",
        "            break\n",
        "\n",
        "    if prepender_router:\n",
        "        # Perform BGP prepending by adding multiple instances of the prepender's ASN to the path\n",
        "        for asn, (distance, next_hop, path) in prepender_router.routing_table.items():\n",
        "            prepender_router.routing_table[asn] = (distance, next_hop, [prepender_asn] * prepend_count + path)\n",
        "        prepender_router.send_updates()\n",
        "\n",
        "def get_routing_paths(routers, target_asn):\n",
        "    routing_paths = []\n",
        "    for router in routers:\n",
        "        distance, next_hop, path = router.get_best_path(target_asn)\n",
        "        routing_paths.append(\" -> \".join(f\"AS{asn}\" for asn in path))\n",
        "    return routing_paths\n",
        "\n",
        "def main():\n",
        "    # Create routers\n",
        "    routers = [Router(1), Router(2), Router(3), Router(4)]\n",
        "\n",
        "    # Set up neighbor relationships\n",
        "    routers[0].add_neighbor(routers[1])\n",
        "    routers[0].add_neighbor(routers[2])\n",
        "    routers[1].add_neighbor(routers[0])\n",
        "    routers[1].add_neighbor(routers[3])\n",
        "    routers[2].add_neighbor(routers[0])\n",
        "    routers[2].add_neighbor(routers[3])\n",
        "    routers[3].add_neighbor(routers[1])\n",
        "    routers[3].add_neighbor(routers[2])\n",
        "\n",
        "    # Define the attacker and target ASNs\n",
        "    attacker_asn = 4\n",
        "    target_asn = 1\n",
        "\n",
        "    # Simulate BGP routing before the attack\n",
        "    print(\"Routing Table before BGP Attacks:\")\n",
        "    before_explanation = \"Before the BGP attacks, the routing table shows the normal distances, next-hop ASNs, and paths between routers. Each router has learned the best paths to reach other ASNs based on the shortest distances advertised by their neighbors.\"\n",
        "    simulate_bgp(routers, 5)\n",
        "    before_routing_paths = get_routing_paths(routers, target_asn)\n",
        "    print_routing_table(routers, attacker_asn, target_asn, before_explanation, before_routing_paths)\n",
        "\n",
        "    # Perform sub-prefix hijacking\n",
        "    print(\"\\nRouting Table after Sub-Prefix Hijacking:\")\n",
        "    subprefix_explanation = \"In a sub-prefix hijacking attack, the attacker (AS4) advertises a more specific prefix of the target ASN (AS1). This causes other routers to prefer the more specific route advertised by the attacker, effectively hijacking the traffic destined for the target ASN.\"\n",
        "    perform_subprefix_hijacking(routers, attacker_asn, target_asn)\n",
        "    simulate_bgp(routers, 5)\n",
        "    subprefix_routing_paths = get_routing_paths(routers, target_asn)\n",
        "    print_routing_table(routers, attacker_asn, target_asn, subprefix_explanation, subprefix_routing_paths)\n",
        "\n",
        "    # Perform BGP prepending\n",
        "    prepender_asn = 2\n",
        "    prepend_count = 3\n",
        "    print(\"\\nRouting Table after BGP Prepending:\")\n",
        "    prepending_explanation = f\"In a BGP prepending attack, the prepender (AS{prepender_asn}) artificially increases the length of the AS path by prepending its own ASN multiple times ({prepend_count}). This makes the route appear less attractive to other routers, discouraging them from using the prepender as a transit point.\"\n",
        "    perform_bgp_prepending(routers, prepender_asn, prepend_count)\n",
        "    simulate_bgp(routers, 5)\n",
        "    prepending_routing_paths = get_routing_paths(routers, target_asn)\n",
        "    print_routing_table(routers, attacker_asn, target_asn, prepending_explanation, prepending_routing_paths)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    }
  ]
}