Add files using upload-large-folder tool

benchmark/IOAI/IOAI2025/Individual-Contest/Pixel/Pixel.ipynb

@@ -0,0 +1,643 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "362e9f36-2300-4851-8f49-b952e62a2c78",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Pixel/Pixel.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4509a190",
+   "metadata": {},
+   "source": [
+    "# Pixel Efficiency\n",
+    "\n",
+    "## 1. Problem Description\n",
+    "\n",
+    "You are a student in wildlife biology, working on a groundbreaking research project at the Starr Park Research Center. Your team has deployed thousands of camera traps across remote wilderness areas to monitor endangered species populations. However, the satellite internet connections in these remote locations have extremely limited bandwidth. Your job is to write code that identifies the most critical pixels in each wildlife photograph so that only the essential visual information needs to be transmitted back to headquarters.\n",
+    "\n",
+    "<img src=\"./figs/Pixel Fig 1.png\" width=\"400\">\n",
+    "\n",
+    "## 2. Dataset\n",
+    "\n",
+    "The dataset consists of a training set and a test set. Datasets are loaded using `load_from_disk`, and are in the format of `datasets`. Test set is not visible to the contestants.\n",
+    "\n",
+    "In the dataset there are the following fields:\n",
+    "\n",
+    "- `image`: the image are RGB full color images in PIL format, the size of each image is (224, 224)\n",
+    "- `name`: the animal species label\n",
+    "- `idx`: unique identifiers used to track the records.\n",
+    "\n",
+    "1. **Training Set (`train_dataset` folder)**:\n",
+    "    - The training set is used for training your models/ doing experimentations on and can be accessed and downloaded directly during the competition.\n",
+    "    - There are 700 images in the training set.\n",
+    "\n",
+    "2. **Test Set (`test_dataset` folder)**: \n",
+    "    - These follow the same format as the training set but do not contain the `name` field.\n",
+    "    - There are 698 images in test set, which had been separated into 2 testing sets within the ratio of 3:7, i.e. 30% of the data would be used to calculate the Leaderboard A score, another 70% data would be used to calculate the Leaderboard B score.\n",
+    "    - The testing set is used to calculate the Leaderboard A score and the Leaderboard B score and is not directly accessible during the competition. Contestants can access the result on Leaderboard A , but cannot access the result on Leaderboard B. The final score would be counted using Leaderboard B only. The subsets for Leaderboard A and Leaderboard B are completely distinct.\n",
+    "    \n",
+    "\n",
+    "## 3. Task\n",
+    "You are given a dataset of animal photographs and a CLIP model that can do a zero-shot classification of animal species. To conserve bandwidth, you need to retain at most **6.25%** of the pixels of each image, while keeping classification accuracy as high as possible.\n",
+    "\n",
+    "More specifically, your task is to return **one rectangle mask** for each image, which contain a single rectangular area indicating the area to keep. Each mask is defined by two coordinate tuples: one for the top-left corner and one for the bottom-right corner of the rectangle. Below is a visualization of what the image would look like after applying a rectangular mask using the process from the baseline:\n",
+    "\n",
+    "<img src=\"./figs/Pixel Fig 2.png\" width=\"400\">\n",
+    "\n",
+    "**Coordinate Convention:**\n",
+    "- Top-left corner coordinates are **inclusive** (the pixel at this position is included in the mask) \n",
+    "- Bottom-right corner coordinates are **exclusive** (the pixel at this position is NOT included in the mask)\n",
+    "\n",
+    "For example, if you specify coordinates `((10, 20), (15, 25))`, the mask will cover pixels from row 10 to 14 (inclusive) and column 20 to 24 (inclusive), for a total area of 25 pixels.\n",
+    "\n",
+    "As an illustration, if an image size is 3x3 and we wanted to keep only the top-right pixel using coordinates `((0, 2), (1, 3))`, the resulting binary mask would be:\n",
+    "\n",
+    "```\n",
+    "[[0, 0, 1],\n",
+    " [0, 0, 0],\n",
+    " [0, 0, 0]]\n",
+    "```\n",
+    "\n",
+    "Below is a summary of the requirements for your masks:\n",
+    "\n",
+    "- Return one rectangle mask defined by coordinate tuples: `((top, left), (bottom, right))`\n",
+    "- Top-left corner coordinates are inclusive, bottom-right corner coordinates are exclusive\n",
+    "- The rectangle mask should cover at most *6.25%* of the original pixels (minimum 93.75% reduction of the original pixels)\n",
+    "- All images are of size (224, 224), so coordinate values should be within the range [0, 224]\n",
+    "\n",
+    "\n",
+    "Images would be masked using the mask you created, outside the masked rectangle, all pixels outside the masked rectangle will be replaced with RGB(0, 0, 0) (black) values. The masked image will be then passed through the CLIP model during evaluation, and your task is to keep the classification accuracy of the CLIP model on these masked images as high as possible. **An additional `other` class would be added into the classes for classification** to ensure that your masked image retains actual useful information for the researchers back at Starr Park Headquarters. So for example, if your image doesn't contain any animal information, the model will predict the `others` class instead of predicting a random animal and having a chance of getting it correct.\n",
+    "\n",
+    "You need to work only with the provided CLIP model and dataset. As a reminder, CLIP generates representations for both text and image, and it can compute a similarity score between them. So if you have ten animal classes, CLIP can look at the provided image and decide which text (class) is closest to the image. \n",
+    "\n",
+    "To ensure that your solution would handle the traffic of images for the research center, your code should run in **UNDER 8 MINUTES for the 698 images in the test dataset**. It is recommended that you test your solution on the training set first, which contain 700 images, to understand how much time your solution takes (testing set would take slightly longer due to dataset loading).\n",
+    "\n",
+    "## 4. Submission\n",
+    "\n",
+    "Contestants need to submit a notebook file named `submission.ipynb`. The file should output a `.jsonl` file titled `submission.jsonl`, which contains all the generated masks for the dataset split. Each mask in the `submission.jsonl` file should be stored as a tuple of two coordinate tuples: `((top, left), (bottom, right))`, where the top-left corner is inclusive and the bottom-right corner is exclusive.\n",
+    "\n",
+    "Contestants don't need to separate test sets into Leaderboard A and Leaderboard B, the evaluation machine will read `submission.jsonl` and automatically calculate the scores for Leaderboard A and Leaderboard B based on the prediction results and true labels. \n",
+    "\n",
+    "The submission files must strictly follow the above format and naming; otherwise, the system will not be able to read them correctly. \n",
+    "\n",
+    "## 5. Score\n",
+    "\n",
+    "The evaluation metric will be **classification accuracy**, defined as the proportion of correctly predicted samples over the total number of evaluated samples.\n",
+    "\n",
+    "Your score is the zero-shot classification accuracy of CLIP on the masked test images. **If a submitted mask for an image is invalid (wrong shape, more than 6.25% pixels retained, etc.), that image is counted as incorrect. A sample script is provided to compute the training split score.**\n",
+    "\n",
+    "\n",
+    "## 6. Baseline and Training Set\n",
+    "\n",
+    "- Below you can find the baseline solution.\n",
+    "- The dataset is in `training_set` folder.\n",
+    "- The highest score by the Scientific Committee for this task is 0.83 in Leader Board B, this score is used for score unification.\n",
+    "- The baseline score by the Scientific Committee for this task is 0.19 in Leader Board B, this score is used for score unification."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d1ad03b-ba1e-4c24-b866-fe6a138b58c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "seed = 42\n",
+    "\n",
+    "random.seed(seed)                  # Python built-in random\n",
+    "np.random.seed(seed)               # NumPy\n",
+    "torch.manual_seed(seed)            # PyTorch (CPU)\n",
+    "torch.cuda.manual_seed(seed)       # PyTorch (single GPU)\n",
+    "torch.cuda.manual_seed_all(seed)   # PyTorch (all GPUs)\n",
+    "\n",
+    "# Ensures deterministic behavior\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af37a8ed",
+   "metadata": {},
+   "source": [
+    "### Dependencies and Config Variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23b68a41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from collections import Counter\n",
+    "from PIL import Image\n",
+    "from tqdm import tqdm\n",
+    "import glob\n",
+    "import json\n",
+    "import math\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "from datasets import load_dataset, load_from_disk\n",
+    "from transformers import CLIPProcessor, CLIPModel\n",
+    "from PIL import Image\n",
+    "from tqdm.auto import tqdm \n",
+    "\n",
+    "TRAIN_PATH = \"./training_set/\"\n",
+    "# The training set is deployed automatically in the testing machine. \n",
+    "# You notebook can access the TRAIN_PATH even if you do not mount it along with notebook.\n",
+    "\n",
+    "MODEL_PATH = \"./clip-vit-large-patch14\"\n",
+    "# The clip model is deployed automatically in the testing machine. \n",
+    "# You notebook can access the MODEL_PATH even if you do not mount it along with notebook.\n",
+    "\n",
+    "DATASET_PATH = TRAIN_PATH + \"train_dataset\"\n",
+    "SPLIT = \"train\"\n",
+    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "BACKGROUND_CLASS = \"other\" # Class used to catch masked images that have no useful information, preventing completely off masks from \"guessing\" the answer from the 10 classes\n",
+    "\n",
+    "# Image and Masking Configuration\n",
+    "HEIGHT = 224\n",
+    "WIDTH = 224\n",
+    "RETAIN_RATIO = 0.0625  # Retain 6.25% of pixels\n",
+    "MEAN_COLOR = (0, 0, 0)  # RGB mean values for masked out areas\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b888c040",
+   "metadata": {},
+   "source": [
+    "### Dataset loading\n",
+    "\n",
+    "Let's first load the dataset in and see what's in it:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "857ab7ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the dataset\n",
+    "print(\"Loading dataset...\")\n",
+    "dataset_whole = load_from_disk(DATASET_PATH)\n",
+    "dataset = dataset_whole[SPLIT]\n",
+    "\n",
+    "# Print first item to check available fields\n",
+    "print(\"\\nFirst item keys:\")\n",
+    "print(dataset_whole[SPLIT][0].keys())\n",
+    "\n",
+    "# Show basic dataset statistics without converting fields yet\n",
+    "print(f\"\\nDataset loaded successfully!\")\n",
+    "print(f\"Total samples: {len(dataset)}\")\n",
+    "\n",
+    "print(f\"\\nSample item structure:\")\n",
+    "sample_item = dataset[0]\n",
+    "print(f\"  Keys: {list(sample_item.keys())}\")\n",
+    "print(f\"  Image type: {type(sample_item['image'])}\")\n",
+    "print(f\"  Image size: {sample_item['image'].size}\")\n",
+    "print(f\"  Index: {sample_item['idx']}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37c2dbfa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize first 10 samples\n",
+    "fig, axes = plt.subplots(2, 5, figsize=(15, 8))\n",
+    "axes = axes.flatten()\n",
+    "\n",
+    "print(\"Visualizing first 10 samples...\")\n",
+    "\n",
+    "for i in range(10):\n",
+    "    sample = dataset[i]\n",
+    "    image = sample['image']\n",
+    "    label = sample['name']\n",
+    "    \n",
+    "    axes[i].imshow(image)\n",
+    "    axes[i].set_title(f\"{label}\\n\", fontsize=12)\n",
+    "    axes[i].axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.suptitle('First 10 Samples from Dataset', fontsize=16, y=1.02)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24cee96a",
+   "metadata": {},
+   "source": [
+    "### Model\n",
+    "\n",
+    "Now let's load the model and see some predictions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd92b376",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"Loading CLIP model and processor: {MODEL_PATH}...\")\n",
+    "model = CLIPModel.from_pretrained(MODEL_PATH).to(DEVICE)\n",
+    "processor = CLIPProcessor.from_pretrained(MODEL_PATH)\n",
+    "print(\"Model and processor loaded successfully.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2e25924",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = dataset[0]['image']\n",
+    "# Visualize the image with its true label\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image)\n",
+    "plt.title(f\"Sample Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "labels = sorted(list(set(dataset['name']))) + [BACKGROUND_CLASS]\n",
+    "text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "image_processed = processor(images=image, return_tensors=\"pt\").to(DEVICE)\n",
+    "pixel_values = image_processed['pixel_values']\n",
+    "outputs_full = model(pixel_values=pixel_values, **text_inputs)\n",
+    "logits_full = outputs_full.logits_per_image  # Shape: (1, num_styles)\n",
+    "predicted_index_full = logits_full.argmax(dim=-1).item()\n",
+    "\n",
+    "print(f\"Predicted label: {labels[predicted_index_full]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54467f0c",
+   "metadata": {},
+   "source": [
+    "### Baseline: A trivial masking method\n",
+    "\n",
+    "We will now be implementing a trivial masking solution, one that randomly masks out 90% of the pixels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ee24b90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_center_crop_coordinates(image):\n",
+    "    \"\"\"\n",
+    "    Generate coordinates for a center crop mask.\n",
+    "    \n",
+    "    Returns:\n",
+    "        tuple: ((top, left), (bottom, right)) coordinates for the crop\n",
+    "    \"\"\"\n",
+    "    H, W = image.size\n",
+    "    total_px = H * W\n",
+    "    k = int(total_px * RETAIN_RATIO)\n",
+    "    \n",
+    "    # Calculate side length of the square crop\n",
+    "    side_length = int(np.sqrt(k))\n",
+    "    \n",
+    "    # Calculate center coordinates\n",
+    "    center_h, center_w = H // 2, W // 2\n",
+    "    \n",
+    "    # Calculate crop boundaries\n",
+    "    half_side = side_length // 2\n",
+    "    top = max(0, center_h - half_side)\n",
+    "    left = max(0, center_w - half_side)\n",
+    "    bottom = min(H, top + side_length)\n",
+    "    right = min(W, left + side_length)\n",
+    "    \n",
+    "    return ((top, left), (bottom, right))\n",
+    "\n",
+    "def generate_mask_from_coordinates(image, coordinates):\n",
+    "    \"\"\"\n",
+    "    Generate a binary mask from crop coordinates.\n",
+    "    \n",
+    "    Parameters:\n",
+    "        image: PIL Image\n",
+    "        coordinates: tuple of ((top, left), (bottom, right))\n",
+    "    \n",
+    "    Returns:\n",
+    "        numpy array: Binary mask with 1s in the crop area\n",
+    "    \"\"\"\n",
+    "    H, W = image.size\n",
+    "    mask = np.zeros((H, W), dtype=np.int8)\n",
+    "    \n",
+    "    (top, left), (bottom, right) = coordinates\n",
+    "    mask[top:bottom, left:right] = 1\n",
+    "    \n",
+    "    return mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e87f8f85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def apply_mask_with_mean(image, mask, mean_rgb=MEAN_COLOR):\n",
+    "    \"\"\"\n",
+    "    Apply arbitrary binary mask to image, replacing masked areas with mean values\n",
+    "\n",
+    "    Parameters:\n",
+    "    - image: PIL Image (224x224)\n",
+    "    - mask: Binary numpy array or PIL Image (224x224) where 0 is the area to drop and 1 is the area to keep\n",
+    "    - mean_rgb: RGB mean values to use (default: from config)\n",
+    "\n",
+    "    Returns: Modified PIL Image\n",
+    "    \"\"\"\n",
+    "    # Convert images to numpy arrays\n",
+    "    img_array = np.array(image).copy()\n",
+    "\n",
+    "    # Ensure mask is numpy array\n",
+    "    if isinstance(mask, Image.Image):\n",
+    "        mask_array = np.array(mask.convert('L')) > 127  # Convert to binary\n",
+    "    else:\n",
+    "        mask_array = mask > 0\n",
+    "\n",
+    "    # Reshape mask for broadcasting with RGB\n",
+    "    mask_3d = np.stack([mask_array] * 3, axis=2)\n",
+    "\n",
+    "    # Convert mean values to 0-255 range\n",
+    "    mean_values = np.array([int(m * 255) for m in mean_rgb])\n",
+    "    # Apply mask - replace areas where mask is 0 (drop) with mean values, keep areas where mask is 1\n",
+    "    img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))\n",
+    "\n",
+    "    return Image.fromarray(img_array.astype(np.uint8))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a84ed28b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = dataset[0]['image']\n",
+    "# Visualize the image with its true label\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image)\n",
+    "plt.title(f\"Sample Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "labels = sorted(list(set(dataset['name']))) + [BACKGROUND_CLASS]\n",
+    "text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "\n",
+    "mask = generate_mask_from_coordinates(image, generate_center_crop_coordinates(image))\n",
+    "image_masked = apply_mask_with_mean(image, mask)\n",
+    "\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image_masked)\n",
+    "plt.title(f\"Masked Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "image_processed = processor(images=image_masked, return_tensors=\"pt\").to(DEVICE)\n",
+    "pixel_values = image_processed['pixel_values']\n",
+    "outputs_full = model(pixel_values=pixel_values, **text_inputs)\n",
+    "logits_full = outputs_full.logits_per_image  # Shape: (1, num_styles)\n",
+    "predicted_index_full = logits_full.argmax(dim=-1).item()\n",
+    "\n",
+    "print(f\"Predicted label: {labels[predicted_index_full]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6987536",
+   "metadata": {},
+   "source": [
+    "### Exporting the masks\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa65a80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#DATA_PATH is the secret environment variable to point the address of the validation set and test set on the testing machine. \n",
+    "#Contestants cannot access this address locally.\n",
+    "import os\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    TEST_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    TEST_PATH = \"\"  # Fallback for local testing\n",
+    "\n",
+    "dataset = load_from_disk(TEST_PATH + \"test_dataset\")\n",
+    "split = \"test\"\n",
+    "dataset = dataset[split]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5cae01f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Exporting results and validating on full dataset\n",
+    "RETAIN_RATIO = 0.0625\n",
+    "\n",
+    "masks = {}\n",
+    "for item in tqdm(dataset):\n",
+    "    image = item['image']\n",
+    "\n",
+    "    ## you should replace mask generation with your function\n",
+    "    coordinates = generate_center_crop_coordinates(image)\n",
+    "    \n",
+    "    # don't need to change below, it's just saving to file\n",
+    "    idx = item['idx']\n",
+    "    # For validation, we still need to generate the full mask\n",
+    "    mask = generate_mask_from_coordinates(image, coordinates)\n",
+    "    assert mask.shape == (224, 224), \"Mask should be 224x224\"\n",
+    "    assert mask.sum() <= RETAIN_RATIO * 224 * 224, \"You should leave only 6.25% of pixels\"\n",
+    "    \n",
+    "    # Save only the coordinates (topleft, bottomright) instead of the full mask\n",
+    "    masks[idx] = coordinates\n",
+    "\n",
+    "# Save as JSONL (one JSON object per line) - much safer than pickle\n",
+    "with open('submission.jsonl', 'w') as f:\n",
+    "    for idx, coordinates in masks.items():\n",
+    "        json.dump({\"idx\": idx, \"coordinates\": coordinates}, f)\n",
+    "        f.write('\\n')\n",
+    "\n",
+    "print(\"Masks saved to masks.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed60e044",
+   "metadata": {},
+   "source": [
+    "### Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d1ef680",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Validation code for generated masks\n",
+    "\n",
+    "# def check_validity(coordinates):\n",
+    "#     \"\"\"\n",
+    "#     Check if coordinates are valid according to the requirements.\n",
+    "#     Returns True if valid, False otherwise.\n",
+    "#     \"\"\"\n",
+    "#     try:\n",
+    "#         # Check if coordinates is a tuple of two tuples\n",
+    "#         if not isinstance(coordinates, tuple) or len(coordinates) != 2:\n",
+    "#             print(f\"Coordinates is not a tuple of two tuples\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         (top, left), (bottom, right) = coordinates\n",
+    "        \n",
+    "#         # Check if all coordinates are integers\n",
+    "#         if not all(isinstance(coord, (int, np.integer)) for coord in [top, left, bottom, right]):\n",
+    "#             print(f\"Coordinates are not integers\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check if coordinates are within image bounds\n",
+    "#         # For slicing mask[top:bottom, left:right], valid ranges are:\n",
+    "#         # top, left: [0, 223] (inclusive)\n",
+    "#         # bottom, right: [1, 224] (inclusive) since we need top < bottom and left < right\n",
+    "#         if not (0 <= top < 224 and 0 <= left < 224 and 1 <= bottom <= 224 and 1 <= right <= 224):\n",
+    "#             print(f\"Coordinates are not within image bounds\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check if top-left is actually top-left of bottom-right (proper ordering)\n",
+    "#         if not (top < bottom and left < right):\n",
+    "#             print(f\"Top-left is not actually top-left of bottom-right\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check that the crop area doesn't exceed RETAIN_RATIO\n",
+    "#         crop_area = (bottom - top) * (right - left)\n",
+    "#         max_area = RETAIN_RATIO * 224 * 224\n",
+    "#         if crop_area > max_area:\n",
+    "#             print(f\"Crop area {crop_area} exceeds max area {max_area}\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         return True\n",
+    "#     except Exception:\n",
+    "#         return False\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "# def validate_masks(masks):\n",
+    "#     \"\"\"Simple validation of generated masks on the dataset\"\"\"\n",
+    "#     correct = 0\n",
+    "#     total = 0\n",
+    "\n",
+    "#     labels = sorted(list(set(dataset['name']))) + ['other']\n",
+    "#     text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "\n",
+    "#     with torch.no_grad():\n",
+    "#         for item in tqdm(dataset, desc=\"Validating masks\"):\n",
+    "#             idx = item['idx']\n",
+    "#             if idx not in masks:\n",
+    "#                 continue\n",
+    "\n",
+    "#             if not check_validity(masks[idx]):\n",
+    "#                 continue\n",
+    "                \n",
+    "#             mask_coordinates = masks[idx]\n",
+    "#             image = item['image']\n",
+    "#             true_label = item['name']\n",
+    "            \n",
+    "#             # Apply mask to image\n",
+    "#             if image.mode != \"RGB\":\n",
+    "#                 image = image.convert(\"RGB\")\n",
+    "            \n",
+    "#             mask = generate_mask_from_coordinates(image, mask_coordinates)\n",
+    "\n",
+    "#             # Apply mask with mean color replacement\n",
+    "#             img_array = np.array(image).copy()\n",
+    "#             mask_array = mask > 0\n",
+    "#             mask_3d = np.stack([mask_array] * 3, axis=2)\n",
+    "#             mean_values = np.array([0, 0, 0])  # Black mean color\n",
+    "#             img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))\n",
+    "#             masked_image = Image.fromarray(img_array.astype(np.uint8))\n",
+    "            \n",
+    "#             # Get prediction on masked image\n",
+    "#             image_processed = processor(images=masked_image, return_tensors=\"pt\").to(DEVICE)\n",
+    "#             pixel_values = image_processed['pixel_values']\n",
+    "#             outputs = model(pixel_values=pixel_values, **text_inputs)\n",
+    "#             logits = outputs.logits_per_image\n",
+    "#             predicted_idx = logits.argmax(dim=-1).item()\n",
+    "#             predicted_label = labels[predicted_idx]\n",
+    "            \n",
+    "#             # Check if prediction is correct\n",
+    "#             if predicted_label == true_label:\n",
+    "#                 correct += 1\n",
+    "#             total += 1\n",
+    "    \n",
+    "#     accuracy = correct / total if total > 0 else 0\n",
+    "#     print(f\"Validation Results:\")\n",
+    "#     print(f\"Total samples: {total}\")\n",
+    "#     print(f\"Correct predictions: {correct}\")\n",
+    "#     print(f\"Accuracy: {accuracy:.4f} ({accuracy*100:.2f}%)\")\n",
+    "    \n",
+    "#     return accuracy\n",
+    "\n",
+    "# # Run validation\n",
+    "# accuracy = validate_masks(masks)\n"
+   ]
+  }
+ ],
+ "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

benchmark/IOAI/IOAI2025/Individual-Contest/Radar/Radar.ipynb

@@ -0,0 +1,564 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Radar/Radar.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Radar\n",
+    "\n",
+    "## 1. Problem Description \n",
+    "\n",
+    "Radar is a key technology in wireless communication, with widespread applications such as self-driving cars. It typically involves an antenna that transmits specific signals and receives their reflections from objects in the environment. By processing these signals, the system determines the angular direction, distance, and velocity of target objects.\n",
+    "\n",
+    "In real-world applications, radar signal processing is challenging due to noise and reflections from non-target objects in the surroundings. For example, when attempting to detect pedestrians, the radar may also receive reflections from trees or other background objects, which can degrade accuracy. Your task is to use AI to analyze the signals received by the radar and identify the presence of a human at each position.\n",
+    "\n",
+    "In this task, we provide an **indoor radar experiment dataset**, and your objective is to develop a model that performs **radar semantic segmentation**. \n",
+    "\n",
+    "\n",
+    "## 2. Dataset\n",
+    "\n",
+    "To measure objects surrounding a radar, the following key parameters are used:\n",
+    "\n",
+    "- **Range**: The straight-line distance between the radar and an object.\n",
+    "- **Azimuth**: The horizontal angle (left to right) between the radar and the object.\n",
+    "- **Elevation**: The vertical angle (up or down) of the object relative to the radar.\n",
+    "- **Velocity**: The speed at which the object is moving toward or away from the radar.\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 1.png\" width=\"300\">\n",
+    "\n",
+    "\n",
+    "The radar data is processed into multiple **heatmaps**, each encoding the **received signal strength** at various positions and directions.\n",
+    "\n",
+    "- **Static heatmaps** emphasize reflections from **stationary** objects.\n",
+    "- **Dynamic heatmaps** highlight changes caused by **moving** objects.\n",
+    "\n",
+    "When no object is present at a specific location, the signal consists mostly of background noise and appears weak. In contrast, reflections from an object increase signal intensity, enabling detection of the object.\n",
+    "\n",
+    "For example, the **static range-azimuth heatmap** represents signal strength across different distances (**range**) and horizontal angles (**azimuth**), mainly reflected by stationary objects.\n",
+    "\n",
+    "Each sample in the dataset is stored in a `.mat.pt` file as a tensor of shape $7 \\times 50 \\times 181$, where:\n",
+    "\n",
+    "- 7 is the number of maps (6 heatmaps + 1 semantic label map),\n",
+    "- 50 represents range bins (distance),\n",
+    "- 181 represents angular or velocity bins, covering angles from \\-90° to \\+90° in either the horizontal or vertical plane. You can assume that the velocity bins are also remapped from \\-90° to \\+90° for visualization consistency.\n",
+    "- each heatmap intensity value is normalized to [0, 1], representing received signal strength.\n",
+    "\n",
+    "The 6 heatmaps are structured as follows:\n",
+    "\n",
+    "- **Index 0**: Static range-azimuth heatmap\n",
+    "- **Index 1**: Dynamic range-azimuth heatmap\n",
+    "- **Index 2**: Static range-elevation heatmap\n",
+    "- **Index 3**: Dynamic range-elevation heatmap\n",
+    "- **Index 4**: Static range-velocity heatmap\n",
+    "- **Index 5**: Dynamic range-velocity heatmap\n",
+    "\n",
+    "All values in heatmaps are **normalized**, so no unit conversion is required.\n",
+    "\n",
+    "The **map at Index 6** is the semantic label map, stored in range-azimuth format. \n",
+    "\n",
+    "- **-1**: Background (no target)\n",
+    "- **0**: Suitcase\n",
+    "- **1**: Chair\n",
+    "- **2**: Human\n",
+    "- **3**: Wall\n",
+    "\n",
+    "This is the visualization of 1.mat.pt in training_set:\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 2.png\" width=\"675\">\n",
+    "\n",
+    "Here is part of a sample from the dataset:\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 3.png\" width=\"675\">\n",
+    "\n",
+    "\n",
+    "Data scale: 1800 samples in the training set, 500 samples in the validation set, and 500 samples in the test set.\n",
+    "\n",
+    "## 3\\. Task\n",
+    "\n",
+    "Your task is to develop a model that takes the **first six heatmaps** (indices 0 to 5) as input, and predicts the **semantic label map** (index 6) as the output. The goal is to accurately identify what the target is(-1 to 3) at each location in the radar’s field of view.\n",
+    "\n",
+    "1. **Input**: A tensor of shape $6 \\times 50 \\times 181$, representing six radar heatmaps.\n",
+    "2. **Output**: A tensor of shape $50 \\times 181$, representing the target semantic label map.\n",
+    "\n",
+    "\n",
+    "## 4\\. Submission \n",
+    "\n",
+    "Please submit a file named `submission.ipynb`. The output is a zip file named \"submission.zip\", which contains two tables `submission_val.csv` and `submission_test.csv` corresponding to the prediction results of the validation set and the test set respectively.\n",
+    "\n",
+    "**Note:** The output table should have a header, the data in the table is not the actual solved data, it is only used as an example of the submission format.\n",
+    "\n",
+    "| filename | pixel_0 | pixel_1 | ... | pixel_9049 |\n",
+    "| :------: | :-----: | ------- | --- | ---------- |\n",
+    "| 1.mat.pt |   -1    | -1      | ... | -1         |\n",
+    "|   ...    |   ...   | ...     | ... | ...        |\n",
+    "\n",
+    "## 5\\. Score\n",
+    "\n",
+    "The score is based on the **accuracy of label recognition**. Correctly identifying target points is weighted more heavily than correctly identifying background points. \n",
+    "\n",
+    "### Scoring Criteria: \n",
+    "\n",
+    "* Each correctly identified **background pixel** earns **1 point**. \n",
+    "\n",
+    "* Each correctly identified **non-background pixel** earns **50 points**. \n",
+    "\n",
+    "* The final score is normalized to a **0-1 point** by comparing it to the maximum possible score. \n",
+    "\n",
+    "### Formula：\n",
+    "$$\n",
+    "Score = \\frac{|C_{0,correct}| \\times 1 + |C_{1,correct}| \\times bonus}{|C_0| \\times 1 + |C_1| \\times bonus}\n",
+    "$$\n",
+    "where:\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "I &= \\{1, 2, \\dots, 50\\times 181\\}\\\\\n",
+    "C_0 &= \\{i \\in I \\mid y_i = -1\\}\\\\\n",
+    "C_1 &= \\{i \\in I \\mid y_i \\neq -1\\}\\\\\n",
+    "C_{0,correct} &= \\{i \\in C_0 \\mid p_i = y_i\\}\\\\\n",
+    "C_{1,correct} &= \\{i \\in C_1 \\mid p_i = y_i\\}\\\\\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "\n",
+    "### Example\n",
+    "\n",
+    "For a $3\\times3$ heatmap, assume the Ground Truth is:\n",
+    "\n",
+    "$$\n",
+    "\\begin{bmatrix}\n",
+    "-1 & -1 & -1 \\\\\n",
+    "1 & 2 & 3 \\\\\n",
+    "-1 & -1 & -1\n",
+    "\\end{bmatrix}\n",
+    "$$\n",
+    "\n",
+    "The intenteded result is:\n",
+    "\n",
+    "$$\n",
+    "\\begin{bmatrix}\n",
+    "-1 & 1 & -1 \\\\\n",
+    "-1 & 2 & -1 \\\\\n",
+    "-1 & 3 & -1\n",
+    "\\end{bmatrix}\n",
+    "$$\n",
+    "\n",
+    "Then there are four correctly identified `-1` and one correctly identified `2`. Your score is 4 + 50 = 54 points. The maximum possible score is 6 + 50 * 3 = 156, that is, the score for six background pixels and three non-background pixels. Your normalized score is 54 / 156 = 0.346.\n",
+    "\n",
+    "$$\n",
+    "Score = \\frac{4 \\times 1 + 1 \\times 50}{6 \\times 1 + 3 \\times 50}=0.346\n",
+    "$$\n",
+    "\n",
+    "## 6. Baseline and Training Set\n",
+    "\n",
+    "- Below you can find the baseline solution.\n",
+    "- The dataset is in `training_set` folder.\n",
+    "- The highest score by the Scientific Committee for this task is 0.90 in Leaderboard B, this score is used for score unification.\n",
+    "- The baseline score by the Scientific Committee for this task is 0.67 in Leaderboard B, this score is used for score unification."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "seed = 42\n",
+    "\n",
+    "random.seed(seed)                  # Python built-in random\n",
+    "np.random.seed(seed)               # NumPy\n",
+    "torch.manual_seed(seed)            # PyTorch (CPU)\n",
+    "torch.cuda.manual_seed(seed)       # PyTorch (single GPU)\n",
+    "torch.cuda.manual_seed_all(seed)   # PyTorch (all GPUs)\n",
+    "\n",
+    "# Ensures deterministic behavior\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "class CustomDataset(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]  \n",
+    "        labels = data[6]           \n",
+    "        \n",
+    "        images = images.float()  \n",
+    "        labels = labels.long()   \n",
+    "        labels = labels + 1\n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "            labels = self.transform(labels)\n",
+    "        \n",
+    "        return images, labels, self.file_names[idx]\n",
+    "\n",
+    "class CustomDataset_test(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]        \n",
+    "        \n",
+    "        images = images.float()  \n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "        \n",
+    "        return images, self.file_names[idx]\n",
+    "\n",
+    "def generate_file_paths(base_path):\n",
+    "    file_paths = []\n",
+    "    for frame in os.listdir(base_path):\n",
+    "        frame_path = os.path.join(base_path, frame)\n",
+    "        if frame_path.endswith('.mat.pt'):\n",
+    "            file_paths.append(frame_path)\n",
+    "    return [path for path in file_paths if os.path.exists(path)]\n",
+    "\n",
+    "def load_data(base_path, batch_size=4, num_workers=2, test_size=0.2):\n",
+    "    file_paths = generate_file_paths(base_path)\n",
+    "    \n",
+    "    train_paths, test_paths = train_test_split(file_paths, test_size=test_size, random_state=42)\n",
+    "    \n",
+    "    train_dataset = CustomDataset(file_paths=train_paths)\n",
+    "    test_dataset = CustomDataset(file_paths=test_paths)\n",
+    "    \n",
+    "    train_loader = DataLoader(\n",
+    "        train_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=True, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    test_loader = DataLoader(\n",
+    "        test_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=False, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    return train_loader, test_loader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model Definition and Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "\n",
+    "class MyModel(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MyModel, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=3, padding=1)  \n",
+    "        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)  \n",
+    "        self.conv3 = nn.Conv2d(in_channels=32, out_channels=5, kernel_size=3, padding=1)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.conv1(x))\n",
+    "        x = self.relu(self.conv2(x))\n",
+    "        x = self.conv3(x)  \n",
+    "        return x\n",
+    "\n",
+    "def train(model, train_loader, test_loader, optimizer, criterion, num_epochs=100):\n",
+    "    train_losses = []\n",
+    "    val_losses = []\n",
+    "    \n",
+    "    for epoch in range(num_epochs):\n",
+    "        model.train()\n",
+    "        epoch_loss = 0.0\n",
+    "        batch_count = 0\n",
+    "        \n",
+    "        for images, labels, _ in train_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            labels = labels.cuda() if torch.cuda.is_available() else labels\n",
+    "            \n",
+    "            outputs = model(images)\n",
+    "            outputs = outputs.view(outputs.size(0), outputs.size(1), -1)  # [B, C, H*W]\n",
+    "            labels = labels.view(labels.size(0), -1)  # [B, H*W]\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            \n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            \n",
+    "            epoch_loss += loss.item()\n",
+    "            batch_count += 1\n",
+    "        \n",
+    "        avg_train_loss = epoch_loss / batch_count\n",
+    "        train_losses.append(avg_train_loss)\n",
+    "        \n",
+    "        model.eval()\n",
+    "        val_loss = 0.0\n",
+    "        val_batch_count = 0\n",
+    "        \n",
+    "        with torch.no_grad():\n",
+    "            for images, labels, _ in test_loader:\n",
+    "                images = images.cuda() if torch.cuda.is_available() else images\n",
+    "                labels = labels.cuda() if torch.cuda.is_available() else labels\n",
+    "                \n",
+    "                outputs = model(images)\n",
+    "                outputs = outputs.view(outputs.size(0), outputs.size(1), -1)\n",
+    "                labels = labels.view(labels.size(0), -1)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                \n",
+    "                val_loss += loss.item()\n",
+    "                val_batch_count += 1\n",
+    "        \n",
+    "        avg_val_loss = val_loss / val_batch_count\n",
+    "        val_losses.append(avg_val_loss)\n",
+    "        \n",
+    "        if (epoch+1) % 2 == 0:\n",
+    "            print(f'Epoch [{epoch+1}/{num_epochs}], '\n",
+    "                  f'Train Loss: {avg_train_loss:.4f}, '\n",
+    "                  f'Val Loss: {avg_val_loss:.4f}')\n",
+    "    \n",
+    "    return train_losses, val_losses\n",
+    "TRAIN_PATH = \"./\"\n",
+    "# The training set is deployed automatically in the testing machine. \n",
+    "# You notebook can access the TRAIN_PATH even if you do not mount it along with notebook.\n",
+    "data_path = TRAIN_PATH + 'training_set'\n",
+    "\n",
+    "train_loader, test_loader = load_data(\n",
+    "    base_path=data_path,\n",
+    "    batch_size=4,  \n",
+    "    num_workers=2,\n",
+    "    test_size=0.2\n",
+    ")\n",
+    "\n",
+    "model = MyModel()\n",
+    "if torch.cuda.is_available():\n",
+    "    model = model.cuda()\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.001) \n",
+    "\n",
+    "train_losses, val_losses = train(\n",
+    "    model=model,\n",
+    "    train_loader=train_loader,\n",
+    "    test_loader=test_loader,\n",
+    "    optimizer=optimizer,\n",
+    "    criterion=criterion,\n",
+    "    num_epochs=40\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generate CSV for Submission"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run inference on validation set and testing set\n",
+    "from torch.utils.data import DataLoader\n",
+    "import pandas as pd\n",
+    "\n",
+    "def run_inference(model, data_loader):\n",
+    "    \"\"\"Run inference and return predictions with filenames\"\"\"\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    filenames = []\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        for images, file_names in data_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            \n",
+    "            outputs = model(images)\n",
+    "            preds = torch.argmax(outputs, dim=1)\n",
+    "            \n",
+    "            # Convert predictions back to original label range [-1, 3]\n",
+    "            preds = preds - 1\n",
+    "            \n",
+    "            # Flatten predictions for each sample\n",
+    "            for i, pred in enumerate(preds):\n",
+    "                predictions.append(pred.cpu().numpy().flatten())\n",
+    "                filenames.append(file_names[i])\n",
+    "    \n",
+    "    return predictions, filenames\n",
+    "\n",
+    "#DATA_PATH is the secret environment variable to point the address of the validation set and test set on the testing machine. \n",
+    "#You cannot access this address locally.\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load validation set\n",
+    "val_paths = generate_file_paths(DATA_PATH + 'validation_set')\n",
+    "val_dataset = CustomDataset_test(file_paths=val_paths)\n",
+    "val_loader = DataLoader(\n",
+    "    val_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=2\n",
+    ")\n",
+    "\n",
+    "# Load testing set\n",
+    "test_paths = generate_file_paths(DATA_PATH + 'testing_set')\n",
+    "test_dataset = CustomDataset_test(file_paths=test_paths)\n",
+    "test_loader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=2\n",
+    ")\n",
+    "\n",
+    "# Run inference on validation set\n",
+    "print(\"Running inference on validation set...\")\n",
+    "val_predictions, val_filenames = run_inference(model, val_loader)\n",
+    "\n",
+    "# Save validation results to CSV\n",
+    "val_results = []\n",
+    "for filename, pred in zip(val_filenames, val_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    val_results.append(row)\n",
+    "\n",
+    "val_df = pd.DataFrame(val_results)\n",
+    "val_df.to_csv('submission_val.csv', index=False)\n",
+    "print(f\"Validation results saved to output_validation.csv with shape: {val_df.shape}\")\n",
+    "\n",
+    "# Run inference on testing set\n",
+    "print(\"Running inference on testing set...\")\n",
+    "test_predictions, test_filenames = run_inference(model, test_loader)\n",
+    "\n",
+    "# Save testing results to CSV\n",
+    "test_results = []\n",
+    "for filename, pred in zip(test_filenames, test_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    test_results.append(row)\n",
+    "\n",
+    "test_df = pd.DataFrame(test_results)\n",
+    "test_df.to_csv('submission_test.csv', index=False)\n",
+    "print(f\"Testing results saved to output_testing.csv with shape: {test_df.shape}\")\n",
+    "\n",
+    "print(\"\\nInference completed! Results saved to:\")\n",
+    "print(\"- submission_val.csv (for validation set leaderboard)\")\n",
+    "print(\"- submission_test.csv (for testing set leaderboard)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create .zip File"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import zipfile\n",
+    "import os\n",
+    "\n",
+    "# Define the files to zip and the zip file name.\n",
+    "files_to_zip = ['submission_val.csv', 'submission_test.csv']\n",
+    "zip_filename = 'submission.zip'\n",
+    "\n",
+    "# Create a zip file\n",
+    "with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
+    "    for file in files_to_zip:\n",
+    "        # Add the file to the zip fil\n",
+    "        zipf.write(file, os.path.basename(file))\n",
+    "\n",
+    "print(f'{zip_filename} Created successfully!')"
+   ]
+  }
+ ],
+ "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

benchmark/IOL/ioling_hf/reports/answer_given_rationale/Qwen_Qwen3-4B-Instruct-2507__v14_hakhun_manual_derivation_n4.md

@@ -0,0 +1,232 @@
+# Answer-Given Rationale Probe
+
+- generated: `2026-07-12T02:14:37.885128+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- data: `data/rl/ioling_qwen3_4b_manual_v14_expanded_clean`
+- samples: `40` across `10` records
+- exact final-box samples: `1.000`
+- valid final-box samples: `1.000`
+- truncation rate: `0.000`
+- mean rationale chars: `994.9`
+
+## Per Record
+
+| record | samples | exact boxes | valid boxes | best score | mean rationale chars |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| iol-2018-individual-p2-sub-a-atomic-a.1 | 4 | 4 | 4 | 1.000 | 1140.2 |
+| iol-2018-individual-p2-sub-a-atomic-a.2 | 4 | 4 | 4 | 1.000 | 1143.8 |
+| iol-2018-individual-p2-sub-a-atomic-a.3 | 4 | 4 | 4 | 1.000 | 1078.5 |
+| iol-2018-individual-p2-sub-a-atomic-a.4 | 4 | 4 | 4 | 1.000 | 914.0 |
+| iol-2018-individual-p2-sub-a-atomic-a.5 | 4 | 4 | 4 | 1.000 | 921.2 |
+| iol-2018-individual-p2-sub-a-atomic-a.6 | 4 | 4 | 4 | 1.000 | 921.0 |
+| iol-2018-individual-p2-sub-b-atomic-b.1 | 4 | 4 | 4 | 1.000 | 757.8 |
+| iol-2018-individual-p2-sub-b-atomic-b.2 | 4 | 4 | 4 | 1.000 | 1031.2 |
+| iol-2018-individual-p2-sub-b-atomic-b.3 | 4 | 4 | 4 | 1.000 | 959.0 |
+| iol-2018-individual-p2-sub-b-atomic-b.4 | 4 | 4 | 4 | 1.000 | 1081.8 |
+
+## Sample Outputs
+
+### `iol-2018-individual-p2-sub-a-atomic-a.1` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- "nɤ" is second-person singular, requiring the present-tense suffix -u in place of past -ʔ, as shown in example 2 where "nɤ ʒip tuʔ ne" uses past tense with t-...-ʔ.  
+- "ʒip" means "sleep", as confirmed in example 2: "nɤ ʒip tuʔ ne — Did you(sg) sleep?" with past tense.  
+- In present tense, second-person singular uses -u, as in example 5: "nɤbə ati cʰam tuʔ ne" uses past tense with -ʔ, contrasting with present "nɤ ʒip ku ne" where -u appears.  
+- The suffix -u marks second-person singular present tense, as shown in example 3: "ŋabə ati lapkʰi tɤʔ ne" (past) vs. logic of present formation.  
+- Example 10: "ati kəmə ŋa lapkʰi tʰɤ ne" uses tʰ- for present tense with third-person object, showing tense and agreement segmentation.  
+- The structure "nɤ ʒip ku ne" matches known present-tense second-person singular form with "sleep" and present agreement -u, as no subject-object hierarchy reversal occurs.  
+
+\boxed{a.1: Do you(sg) sleep?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.1` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 2, "nɤ ʒip tuʔ ne" translates to "Did you(sg) sleep?", showing that ʒip with second-person singular subject takes past tense form tuʔ, indicating that present tense uses k- and past uses t- or tʰ- depending on person hierarchy.  
+- Sentence 5, "nɤbə ŋa lapkʰi rɤ ne", shows first-person singular subject with -bə, and past tense predicate with rɤ, confirming that second-person singular has -u suffix in present and -u or -an in agreement when relevant.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", uses third-person subject ati with present tense tʰɤ, aligning with the rule that if the object outranks the subject, present tense uses r- or tʰ-; here, the object ŋa is third and outranks the subject ati.  
+- Sentence 3, "ŋabə ati lapkʰi tɤʔ ne", has first-person singular subject with -bə and past tense predicate tɤʔ, indicating that present tense uses k- and past uses t- or tʰ- depending on person dominance.  
+- In sentence 6, "tarum kəmə nuʔrum cʰam ki ne", the present tense predicate ki appears with a third-person subject tarum, confirming that present tense forms use k- or kəmə with appropriate agreement.  
+- Sentence 1, "nɤ ʒip ku ne", matches the structure of sentence 2, where second-person singular subject nɤ with sleep verb ʒip uses present tense k- and suffix -u, resulting in ku.
+
+\boxed{a.1: Do you(sg) sleep?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.1` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 2, "nɤ ʒip tuʔ ne" translates to "Did you(sg) sleep?", showing that ʒip with second-person singular subject uses past tense with tʰ- and present with k- depending on subject-object ranking.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", uses third-person subject "he" and object "me", with past tense suffix tʰ- indicating object outranks subject.  
+- Sentence 1, "nɤ ʒip ku ne", has second-person subject with present tense verb "sleep"; second-person singular uses suffix -u, matching the pattern in sentence 2 where ʒip with second-person subject uses -u in present tense.  
+- In sentence 5, "nirum kəmə nɤ cʰam tiʔ ne", second-person singular subject with verb "know" uses -u suffix in present tense, confirming -u is used when subject is second-person singular and present tense is used.  
+- Sentence 8, "nɤbə ati cʰam tuʔ ne", shows first-person singular subject with "see" in past tense, where -bə is used with past tense verb showing subject outranks object.  
+- Sentence 10 uses "lapkʰi" (see) with third-person subject and object, resulting in tʰ- suffix, consistent with object outranking subject in past tense.  
+
+\boxed{a.1: Do you(sg) sleep?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.1` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 2, "nɤ ʒip tuʔ ne" translates to "Did you(sg) sleep?", showing that second-person singular with present tense sleep uses -u suffix derivation.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", uses past tense with object outranking subject, yielding tʰ-; in contrast, sentence 3 uses present tense with k- and -u, confirming present tense applies to "sleep" with second-person subject.  
+- "nɤ" is second-person singular, and in sentence 2, it combines with "ʒip" in past tense to form "tuʔ", indicating that "ʒip" with second-person singular must take -u in present tense.  
+- In sentence 5, "nɤbə" is first-person singular with transitive verb, and uses -bə suffix; in contrast, "nɤ" without -bə remains second-person, supporting that -bə is only for first/second persons with transitive verbs in past tense.  
+- The present tense marker "k-" appears with second-person singular verb forms in sentence 2 and implied in sentence 1, confirming k- + -u = "ku" for present second-person speech.  
+- "ku" in "nɤ ʒip ku ne" matches the structure of "nɤ ʒip tuʔ ne" (past) with only the tense marker differing, confirming k- + -u is used for present tense with second-person subject and sleep.  
+
+\boxed{a.1: Do you(sg) sleep?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.2` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 3, "nuʔrum kəmə ati lapkʰi kan ne" uses tʰ- and -i, showing that when first-person plural (us) is the object and third-person (he) is the subject, past tense with first-person plural agreement applies.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", has tʰ- and -ɤ, indicating third-person subject with first-person object, where object outranks subject, resulting in past tense with first-person singular agreement.  
+- Sentence 4, "nirum kəmə tarum lan ki ne", uses k- and -u, showing second-person subject with object outranking subject; the present tense surface form implies k- despite object rank.  
+- Sentence 2, "ati kəmə nirum lapkʰi tʰi ne", mirrors sentence 10 in structure: third-person subject (ati), first-person object (nirum), and past tense with -i, confirming object outranks subject and first-person plural agreement.  
+- Sentence 8, "tarum kəmə nuʔrum cʰam ran ne", shows past tense with tʰ- and -an, indicating second-person plural object outranks subject, which triggers tʰ- form in past, consistent with object ranking.  
+- The presence of tʰ- in past tense with first-person plural agreement (-i) in multiple examples confirms that object-ranking rules override subject personality in tense assignment.  
+
+\boxed{a.2: Did he see us?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.2` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", the third-person subject "ati" and first-person object "ŋa" show past tense with tʰ- due to object outranking subject.  
+- Sentence 3, "ŋabə ati lapkʰi tɤʔ ne", uses -bə for first-person subject and t- agreement, indicating present tense with subject ranking over object.  
+- Sentence 8, "nɤbə ati cʰam tuʔ ne", employs -bə for first-person subject and -u agreement, matching subject-object ranking where object outranks subject in past.  
+- Sentence 5, "nirum kəmə nɤ cʰam tiʔ ne", features third-person object "nɤ" and second-person subject "nirum", requiring tʰ- due to object outranking subject in past.  
+- Sentence 6, "tarum kəmə nuʔrum cʰam ran ne", has plural subject "tarum" and object "nuʔrum", using tʰ- consistently when object outranks subject.  
+- Sentence 4, "nirum kəmə tarum lan ki ne", shows no agreement suffix change despite plural subject-object pair, confirming tʰ- only when object outranks subject in past tense.  
+
+\boxed{a.2: Did he see us?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.2` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 10, 'ati kəmə ŋa lapkʰi tʰɤ ne', the third-person subject 'ati' outranks the first-person object 'ŋa', triggering past tense with tʰ- and first-person-plural agreement -i, matching the structure of sentence 3.  
+- Sentence 3, 'ŋabə ati lapkʰi tɤʔ ne', uses first-person subject with -bə and past tense -tɤʔ, indicating subject-first with subject ranking above object, confirmed by the use of t- before agreement.  
+- Sentence 5, 'nirum kəmə nɤ cʰam tiʔ ne', shows second-person plural subject 'nirum' with -u agreement, but the agreement is -an due to object outranking subject, showing inconsistency unless it's second-person plural with -an.  
+- In sentence 6, 'nuʔrum kəmə ati lapkʰi kan ne', 'ati' is third-person subject, 'nuʔrum' is second-person plural object, with past tense tʰ- and -an agreement, confirming object outranks subject.  
+- Sentence 4, 'nirum kəmə tarum lan ki ne', uses second-person plural subject with -an agreement, despite 'tarum' being third-person, indicating that agreement depends on object rank, not subject identity.  
+- Sentence 7, 'nirum kəmə nuʔrum cʰam ran ne', uses second-person plural subject and object 'nuʔrum' outranking it, triggering past tense tʰ- and -an agreement, confirming that object outranks subject in past tense.  
+
+\boxed{a.2: Did he see us?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.2` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", the third-person subject "he" (ati) sees the first-person object "me" (ŋa), and the past tense marker tʰ- appears due to object outranking subject.  
+- Sentence 3 uses "ŋabə ati lapkʰi rɤ ne" for "Did I see him?", showing first-person subject (ŋa) with -bə, and past tense r- when object outranks subject.  
+- Sentence 8, "nɤbə ati cʰam tuʔ ne", employs "you(sg) know him", confirming that -bə marks first-person subject and -u applies to second-person object in past tense.  
+- Sentence 2, "ati kəmə nirum lapkʰi tʰi ne", parallels sentence 10 with "he" (ati) as subject and "us" (nirum) as object, showing past tense tʰ- due to object outranking subject.  
+- The agreement suffix -i occurs when first-person plural participates, as in "nirum kəmə ati lapkʰi kan ne" (Do you(pl) see him?), where "nirum" is first-person plural.  
+- In "ati kəmə nirum lapkʰi tʰi ne", "tʰi" is past tense with object outranking subject, matching "tʰɤ" in sentence 10, confirming consistency in tense marking based on subject-object hierarchy.  
+
+\boxed{a.2: Did he see us?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.3` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The subject "tarum" (they) is third-person plural, and the object "nuʔrum" (you-pl) is second-person plural, confirming object outranks subject, triggering present form with r-.  
+- The verb "cʰam" means "know", and its agreement with second-person plural object requires -an suffix, evidenced by "nuʔrum cʰam ran" matching "Do you(pl) know us?" in structure.  
+- In sentence 9, "tarum kəmə nirum lapkʰi ri ne" translates to "Do they see us?", showing third-person subject with object outranking, using present r- form with -an agreement.  
+- Sentence 4, "nirum kəmə tarum lan ki ne", shows second-person plural subject with third-person object, using r- due to object outranking, supporting present tense marking.  
+- Sentence 8, "nɤbə ati cʰam tuʔ ne" translates to "Did you(sg) know him?", showing singular object outranks subject, using past tense with tʰ- and -u agreement.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne" uses past tense with tʰ- and object outranking, proving tense and agreement depend on relative person rank, not subject alone.  
+
+\boxed{a.3: Do they know you(pl)?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.3` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 3, "tarum kəmə nuʔrum cʰam ran ne", the object "nuʔrum" (you(pl)) outranks the subject "tarum" (they), triggering present tense with r- in "cʰam ran".  
+- The suffix "ran" matches the second-person plural agreement -an, confirming object precedence over subject in tense marking.  
+- Sentences 6 and 8 show that when object outranks subject, present tense uses r- (e.g., "cʰam ran" vs. "cʰam ki" in sentence 4).  
+- Sentence 4 contrasts "nirum kəmə tarum lan ki ne" (Do we know you(pl)?) with "tarum kəmə nuʔrum cʰam ran ne", showing object-ranking-induced present tense via r- and -an agreement.  
+- The verb "cʰam" (know) paired with "ran" in present tense confirms the rule that object outranking subject causes r- instead of tʰ- or k-.  
+- Sentence 8, "nɤbə ati cʰam tuʔ ne" (Did you(sg) know him?), uses tʰ- with object (him), indicating third-person object ranking, whereas "cʰam ran" in sentence 3 uses r- with second-person-plural object, confirming tense choice based on object rank.  
+
+\boxed{a.3: Do they know you(pl)?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.3` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 3, "tarum kəmə nuʔrum cʰam ran ne", "tarum" is third-person plural subject, and "nuʔrum" is second-person plural object, showing object outranks subject.  
+- The object outranks the subject, so present tense uses r- (as in "ran" instead of "tʰan"), confirming present tense marker r- in the predicate.  
+- "nuʔrum" uses -um with second-person plural, indicating agreement suffix -an, consistent with second-person plural object being second in hierarchy.  
+- The predicate "cʰam" means "know", and in sentence 4, "nirum kəmə tarum lan ki ne" uses "lan" (beat), showing "cʰam" is paired with "know" in Hakhun.  
+- In sentence 8, "nɤbə ati cʰam tuʔ ne" = "Did you(sg) know him?", showing cʰam with first-person singular subject and object outranking, triggering past tense tʰ-; thus, present tense with object outranking uses r-.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", uses tʰɤ (past) due to object outranking subject, but in sentence 3, "ran" is present, indicating tense matches object precedence, not subject.  
+
+\boxed{a.3: Do they know you(pl)?}
+```
+
+### `iol-2018-individual-p2-sub-a-atomic-a.3` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 3, "tarum kəmə nuʔrum cʰam ran ne", "tarum" is third-person plural subject, and "nuʔrum" is second-person plural object, confirming object outranks subject which triggers present tense marker r-.  
+- The presence of "cʰam" as the lexical verb "know" is confirmed by sentence 8: "nɤbə ati cʰam tuʔ ne" translates to "Did you(sg) know him?", showing consistent use of cʰam.  
+- Sentence 9, "tarum kəmə nirum lapkʰi ri ne", shows third-person plural subject with second-person plural object in "nirum", and uses "r" in "ri", aligning with object-ranking present tense marker.  
+- Sentence 5, "nirum kəmə nɤ cʰam tiʔ ne", features second-person plural subject and first-person singular object, where object ranks lower, using past tense tʰ- with -i agreement, indicating tense is tied to rank.  
+- Sentence 4, "nirum kəmə tarum lan ki ne", has second-person plural subject and third-person plural object, resulting in past tense tʰ- (ki) due to object outranking, matching the rule for present tense with object-ranking.  
+- Sentence 10, "ati kəmə ŋa lapkʰi tʰɤ ne", has third-person subject and first-person object; object outranks, so past tense tʰ- is used, confirming tense is determined by subject-object rank.
+
+\boxed{a.3: Do they know you(pl)?}
+```
+

benchmark/IOL/ioling_hf/reports/curation_queue/queue.json

@@ -0,0 +1,712 @@
+[
+  {
+    "source_problem_id": "2003-individual-1",
+    "title": "Transcendental Algebra",
+    "year": 2003,
+    "round": "individual",
+    "problem_number": 1,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-individual-1-problem-p1.png",
+      "images/2003-individual-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2003-individual-1-solution-p1.png",
+      "images/2003-individual-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-individual-1.json"
+  },
+  {
+    "source_problem_id": "2003-individual-2",
+    "title": "Arabic Arithmetic",
+    "year": 2003,
+    "round": "individual",
+    "problem_number": 2,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-individual-2-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2003-individual-2-solution-p2.png",
+      "images/2003-individual-2-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-individual-2.json"
+  },
+  {
+    "source_problem_id": "2003-individual-3",
+    "title": "Basque Dates",
+    "year": 2003,
+    "round": "individual",
+    "problem_number": 3,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-individual-3-problem-p2.png",
+      "images/2003-individual-3-problem-p3.png"
+    ],
+    "solution_images": [
+      "images/2003-individual-3-solution-p3.png",
+      "images/2003-individual-3-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-individual-3.json"
+  },
+  {
+    "source_problem_id": "2003-individual-4",
+    "title": "Adyghe",
+    "year": 2003,
+    "round": "individual",
+    "problem_number": 4,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-individual-4-problem-p3.png",
+      "images/2003-individual-4-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2003-individual-4-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-individual-4.json"
+  },
+  {
+    "source_problem_id": "2003-individual-5",
+    "title": "French",
+    "year": 2003,
+    "round": "individual",
+    "problem_number": 5,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-individual-5-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2003-individual-5-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-individual-5.json"
+  },
+  {
+    "source_problem_id": "2003-team-1",
+    "title": "Tocharian",
+    "year": 2003,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-team-1-problem-p1.png",
+      "images/2003-team-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2003-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-team-1.json"
+  },
+  {
+    "source_problem_id": "2003-team-2",
+    "title": "Subscripts",
+    "year": 2003,
+    "round": "team",
+    "problem_number": 2,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-team-2-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2003-team-2-solution-p1.png",
+      "images/2003-team-2-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-team-2.json"
+  },
+  {
+    "source_problem_id": "2003-team-3",
+    "title": "Verbs",
+    "year": 2003,
+    "round": "team",
+    "problem_number": 3,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2003-team-3-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2003-team-3-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2003-team-3.json"
+  },
+  {
+    "source_problem_id": "2004-individual-1",
+    "title": "Kayapo",
+    "year": 2004,
+    "round": "individual",
+    "problem_number": 1,
+    "problem_confidence": "heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2004-individual-1-problem-p1.png"
+    ],
+    "solution_images": [
+      "images/2004-individual-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2004-individual-1.json"
+  },
+  {
+    "source_problem_id": "2004-individual-2",
+    "title": "Swift News Agency",
+    "year": 2004,
+    "round": "individual",
+    "problem_number": 2,
+    "problem_confidence": "heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2004-individual-2-problem-p1.png",
+      "images/2004-individual-2-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2004-individual-2-solution-p1.png",
+      "images/2004-individual-2-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2004-individual-2.json"
+  },
+  {
+    "source_problem_id": "2004-individual-3",
+    "title": "Latin",
+    "year": 2004,
+    "round": "individual",
+    "problem_number": 3,
+    "problem_confidence": "heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2004-individual-3-problem-p2.png",
+      "images/2004-individual-3-problem-p3.png"
+    ],
+    "solution_images": [
+      "images/2004-individual-3-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2004-individual-3.json"
+  },
+  {
+    "source_problem_id": "2004-individual-4",
+    "title": "Lakhota",
+    "year": 2004,
+    "round": "individual",
+    "problem_number": 4,
+    "problem_confidence": "heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2004-individual-4-problem-p3.png",
+      "images/2004-individual-4-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2004-individual-4-solution-p2.png",
+      "images/2004-individual-4-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2004-individual-4.json"
+  },
+  {
+    "source_problem_id": "2004-individual-5",
+    "title": "Chuvash",
+    "year": 2004,
+    "round": "individual",
+    "problem_number": 5,
+    "problem_confidence": "heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2004-individual-5-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2004-individual-5-solution-p3.png",
+      "images/2004-individual-5-solution-p4.png",
+      "images/2004-individual-5-solution-p5.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2004-individual-5.json"
+  },
+  {
+    "source_problem_id": "2005-individual-1",
+    "title": "Tzotzil",
+    "year": 2005,
+    "round": "individual",
+    "problem_number": 1,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2005-individual-1-problem-p1.png",
+      "images/2005-individual-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2005-individual-1-solution-p1.png",
+      "images/2005-individual-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2005-individual-1.json"
+  },
+  {
+    "source_problem_id": "2005-individual-2",
+    "title": "Lango",
+    "year": 2005,
+    "round": "individual",
+    "problem_number": 2,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2005-individual-2-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2005-individual-2-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2005-individual-2.json"
+  },
+  {
+    "source_problem_id": "2005-individual-3",
+    "title": "Mansi",
+    "year": 2005,
+    "round": "individual",
+    "problem_number": 3,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2005-individual-3-problem-p2.png",
+      "images/2005-individual-3-problem-p3.png"
+    ],
+    "solution_images": [
+      "images/2005-individual-3-solution-p2.png",
+      "images/2005-individual-3-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2005-individual-3.json"
+  },
+  {
+    "source_problem_id": "2005-individual-4",
+    "title": "Yoruba",
+    "year": 2005,
+    "round": "individual",
+    "problem_number": 4,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2005-individual-4-problem-p3.png",
+      "images/2005-individual-4-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2005-individual-4-solution-p3.png",
+      "images/2005-individual-4-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2005-individual-4.json"
+  },
+  {
+    "source_problem_id": "2005-individual-5",
+    "title": "Lithuanian",
+    "year": 2005,
+    "round": "individual",
+    "problem_number": 5,
+    "problem_confidence": "ocr_heading",
+    "solution_confidence": "ocr_heading",
+    "problem_images": [
+      "images/2005-individual-5-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2005-individual-5-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2005-individual-5.json"
+  },
+  {
+    "source_problem_id": "2007-individual-1",
+    "title": "Braille",
+    "year": 2007,
+    "round": "individual",
+    "problem_number": 1,
+    "problem_confidence": "heading",
+    "solution_confidence": "page_index",
+    "problem_images": [
+      "images/2007-individual-1-problem-p1.png",
+      "images/2007-individual-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2007-individual-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2007-individual-1.json"
+  },
+  {
+    "source_problem_id": "2007-team-1",
+    "title": "Hawaiian",
+    "year": 2007,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2007-team-1-problem-p1.png",
+      "images/2007-team-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2007-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2007-team-1.json"
+  },
+  {
+    "source_problem_id": "2008-team-1",
+    "title": "Fanqie",
+    "year": 2008,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2008-team-1-problem-p1.png",
+      "images/2008-team-1-problem-p2.png",
+      "images/2008-team-1-problem-p3.png"
+    ],
+    "solution_images": [
+      "images/2008-team-1-solution-p1.png",
+      "images/2008-team-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2008-team-1.json"
+  },
+  {
+    "source_problem_id": "2009-team-1",
+    "title": "Vietnamese",
+    "year": 2009,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2009-team-1-problem-p1.png",
+      "images/2009-team-1-problem-p2.png",
+      "images/2009-team-1-problem-p3.png",
+      "images/2009-team-1-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2009-team-1-solution-p1.png",
+      "images/2009-team-1-solution-p2.png",
+      "images/2009-team-1-solution-p3.png",
+      "images/2009-team-1-solution-p4.png",
+      "images/2009-team-1-solution-p5.png",
+      "images/2009-team-1-solution-p6.png",
+      "images/2009-team-1-solution-p7.png",
+      "images/2009-team-1-solution-p8.png",
+      "images/2009-team-1-solution-p9.png",
+      "images/2009-team-1-solution-p10.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2009-team-1.json"
+  },
+  {
+    "source_problem_id": "2010-team-1",
+    "title": "Mongolian",
+    "year": 2010,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2010-team-1-problem-p1.png",
+      "images/2010-team-1-problem-p2.png"
+    ],
+    "solution_images": [
+      "images/2010-team-1-solution-p1.png",
+      "images/2010-team-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2010-team-1.json"
+  },
+  {
+    "source_problem_id": "2011-team-1",
+    "title": "Sanskrit Poetry",
+    "year": 2011,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2011-team-1-problem-p1.png",
+      "images/2011-team-1-problem-p2.png",
+      "images/2011-team-1-problem-p3.png",
+      "images/2011-team-1-problem-p4.png",
+      "images/2011-team-1-problem-p5.png",
+      "images/2011-team-1-problem-p6.png",
+      "images/2011-team-1-problem-p7.png"
+    ],
+    "solution_images": [
+      "images/2011-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2011-team-1.json"
+  },
+  {
+    "source_problem_id": "2012-team-1",
+    "title": "Lao",
+    "year": 2012,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2012-team-1-problem-p1.png"
+    ],
+    "solution_images": [
+      "images/2012-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2012-team-1.json"
+  },
+  {
+    "source_problem_id": "2014-team-1",
+    "title": "Armenian",
+    "year": 2014,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2014-team-1-problem-p1.png",
+      "images/2014-team-1-problem-p2.png",
+      "images/2014-team-1-problem-p3.png",
+      "images/2014-team-1-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2014-team-1-solution-p1.png",
+      "images/2014-team-1-solution-p2.png",
+      "images/2014-team-1-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2014-team-1.json"
+  },
+  {
+    "source_problem_id": "2015-team-1",
+    "title": "Northern Sotho",
+    "year": 2015,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2015-team-1-problem-p1.png",
+      "images/2015-team-1-problem-p2.png",
+      "images/2015-team-1-problem-p3.png"
+    ],
+    "solution_images": [
+      "images/2015-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2015-team-1.json"
+  },
+  {
+    "source_problem_id": "2016-team-1",
+    "title": "Taa",
+    "year": 2016,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2016-team-1-problem-p1.png"
+    ],
+    "solution_images": [
+      "images/2016-team-1-solution-p1.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2016-team-1.json"
+  },
+  {
+    "source_problem_id": "2017-team-1",
+    "title": "Emoji/Indonesian",
+    "year": 2017,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2017-team-1-problem-p1.png",
+      "images/2017-team-1-problem-p2.png",
+      "images/2017-team-1-problem-p3.png",
+      "images/2017-team-1-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2017-team-1-solution-p1.png",
+      "images/2017-team-1-solution-p2.png",
+      "images/2017-team-1-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2017-team-1.json"
+  },
+  {
+    "source_problem_id": "2018-team-1",
+    "title": "Mẽbêngôkre, Xavante and Krĩkatí",
+    "year": 2018,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2018-team-1-problem-p1.png",
+      "images/2018-team-1-problem-p2.png",
+      "images/2018-team-1-problem-p3.png",
+      "images/2018-team-1-problem-p4.png"
+    ],
+    "solution_images": [
+      "images/2018-team-1-solution-p1.png",
+      "images/2018-team-1-solution-p2.png",
+      "images/2018-team-1-solution-p3.png",
+      "images/2018-team-1-solution-p4.png",
+      "images/2018-team-1-solution-p5.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2018-team-1.json"
+  },
+  {
+    "source_problem_id": "2019-team-1",
+    "title": "Rhythmic Gymnastics",
+    "year": 2019,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2019-team-1-problem-p1.png",
+      "images/2019-team-1-problem-p2.png",
+      "images/2019-team-1-problem-p3.png",
+      "images/2019-team-1-problem-p4.png",
+      "images/2019-team-1-problem-p5.png"
+    ],
+    "solution_images": [
+      "images/2019-team-1-solution-p1.png",
+      "images/2019-team-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2019-team-1.json"
+  },
+  {
+    "source_problem_id": "2021-team-1",
+    "title": "Garífuna, Lokono and Kari’ña",
+    "year": 2021,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2021-team-1-problem-p1.png",
+      "images/2021-team-1-problem-p2.png",
+      "images/2021-team-1-problem-p3.png",
+      "images/2021-team-1-problem-p4.png",
+      "images/2021-team-1-problem-p5.png",
+      "images/2021-team-1-problem-p6.png",
+      "images/2021-team-1-problem-p7.png",
+      "images/2021-team-1-problem-p8.png",
+      "images/2021-team-1-problem-p9.png",
+      "images/2021-team-1-problem-p10.png",
+      "images/2021-team-1-problem-p11.png",
+      "images/2021-team-1-problem-p12.png",
+      "images/2021-team-1-problem-p13.png"
+    ],
+    "solution_images": [
+      "images/2021-team-1-solution-p1.png",
+      "images/2021-team-1-solution-p2.png",
+      "images/2021-team-1-solution-p3.png",
+      "images/2021-team-1-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2021-team-1.json"
+  },
+  {
+    "source_problem_id": "2022-team-1",
+    "title": "Manchu",
+    "year": 2022,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2022-team-1-problem-p2.png",
+      "images/2022-team-1-problem-p3.png",
+      "images/2022-team-1-problem-p4.png",
+      "images/2022-team-1-problem-p5.png",
+      "images/2022-team-1-problem-p6.png",
+      "images/2022-team-1-problem-p7.png",
+      "images/2022-team-1-problem-p8.png",
+      "images/2022-team-1-problem-p9.png",
+      "images/2022-team-1-problem-p10.png"
+    ],
+    "solution_images": [
+      "images/2022-team-1-solution-p1.png",
+      "images/2022-team-1-solution-p2.png",
+      "images/2022-team-1-solution-p3.png",
+      "images/2022-team-1-solution-p4.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2022-team-1.json"
+  },
+  {
+    "source_problem_id": "2023-team-1",
+    "title": "Murrinh-patha",
+    "year": 2023,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2023-team-1-problem-p1.png",
+      "images/2023-team-1-problem-p2.png",
+      "images/2023-team-1-problem-p3.png",
+      "images/2023-team-1-problem-p4.png",
+      "images/2023-team-1-problem-p5.png",
+      "images/2023-team-1-problem-p6.png",
+      "images/2023-team-1-problem-p7.png",
+      "images/2023-team-1-problem-p8.png",
+      "images/2023-team-1-problem-p9.png"
+    ],
+    "solution_images": [
+      "images/2023-team-1-solution-p1.png",
+      "images/2023-team-1-solution-p2.png",
+      "images/2023-team-1-solution-p3.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2023-team-1.json"
+  },
+  {
+    "source_problem_id": "2024-team-1",
+    "title": "Lexicostatistics",
+    "year": 2024,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2024-team-1-problem-p1.png",
+      "images/2024-team-1-problem-p2.png",
+      "images/2024-team-1-problem-p3.png",
+      "images/2024-team-1-problem-p4.png",
+      "images/2024-team-1-problem-p5.png",
+      "images/2024-team-1-problem-p6.png",
+      "images/2024-team-1-problem-p7.png",
+      "images/2024-team-1-problem-p8.png",
+      "images/2024-team-1-problem-p9.png"
+    ],
+    "solution_images": [
+      "images/2024-team-1-solution-p1.png",
+      "images/2024-team-1-solution-p2.png",
+      "images/2024-team-1-solution-p3.png",
+      "images/2024-team-1-solution-p4.png",
+      "images/2024-team-1-solution-p5.png",
+      "images/2024-team-1-solution-p6.png",
+      "images/2024-team-1-solution-p7.png",
+      "images/2024-team-1-solution-p8.png",
+      "images/2024-team-1-solution-p9.png",
+      "images/2024-team-1-solution-p10.png",
+      "images/2024-team-1-solution-p11.png",
+      "images/2024-team-1-solution-p12.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2024-team-1.json"
+  },
+  {
+    "source_problem_id": "2025-team-1",
+    "title": "Camling and Bantawa",
+    "year": 2025,
+    "round": "team",
+    "problem_number": 1,
+    "problem_confidence": "team_full_document",
+    "solution_confidence": "team_full_document",
+    "problem_images": [
+      "images/2025-team-1-problem-p1.png",
+      "images/2025-team-1-problem-p2.png",
+      "images/2025-team-1-problem-p3.png",
+      "images/2025-team-1-problem-p4.png",
+      "images/2025-team-1-problem-p5.png",
+      "images/2025-team-1-problem-p6.png",
+      "images/2025-team-1-problem-p7.png",
+      "images/2025-team-1-problem-p8.png",
+      "images/2025-team-1-problem-p9.png"
+    ],
+    "solution_images": [
+      "images/2025-team-1-solution-p1.png",
+      "images/2025-team-1-solution-p2.png"
+    ],
+    "manual_override_path": "data/manual_overrides/2025-team-1.json"
+  }
+]

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/configparser-4.0.2.dist-info/LICENSE

@@ -0,0 +1,7 @@
+Copyright Jason R. Coombs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/configparser-4.0.2.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.1
+Name: configparser
+Version: 4.0.2
+Summary: Updated configparser from Python 3.7 for Python 2.6+.
+Home-page: https://github.com/jaraco/configparser/
+Author: Łukasz Langa
+Author-email: lukasz@langa.pl
+Maintainer: Jason R. Coombs
+Maintainer-email: jaraco@jaraco.com
+License: UNKNOWN
+Keywords: configparser ini parsing conf cfg configuration file
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=2.6
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: jaraco.packaging (>=3.2) ; extra == 'docs'
+Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: pytest (!=3.7.3,>=3.5) ; extra == 'testing'
+Requires-Dist: pytest-checkdocs (>=1.2) ; extra == 'testing'
+Requires-Dist: pytest-flake8 ; extra == 'testing'
+Requires-Dist: pytest-black-multipy ; extra == 'testing'
+
+.. image:: https://img.shields.io/pypi/v/configparser.svg
+   :target: https://pypi.org/project/configparser
+
+.. image:: https://img.shields.io/pypi/pyversions/configparser.svg
+
+.. image:: https://img.shields.io/travis/jaraco/configparser/master.svg
+   :target: https://travis-ci.org/jaraco/configparser
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/ambv/black
+   :alt: Code style: Black
+
+.. .. image:: https://img.shields.io/appveyor/ci/jaraco/configparser/master.svg
+..    :target: https://ci.appveyor.com/project/jaraco/configparser/branch/master
+
+.. image:: https://readthedocs.org/projects/configparser/badge/?version=latest
+   :target: https://configparser.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://tidelift.com/badges/package/pypi/configparser
+   :target: https://tidelift.com/subscription/pkg/pypi-configparser?utm_source=pypi-configparser&utm_medium=readme
+
+
+The ancient ``ConfigParser`` module available in the standard library 2.x has
+seen a major update in Python 3.2. This is a backport of those changes so that
+they can be used directly in Python 2.6 - 3.5.
+
+To use the ``configparser`` backport instead of the built-in version on both
+Python 2 and Python 3, simply import it explicitly as a backport::
+
+  from backports import configparser
+
+If you'd like to use the backport on Python 2 and the built-in version on
+Python 3, use that invocation instead::
+
+  import configparser
+
+For detailed documentation consult the vanilla version at
+http://docs.python.org/3/library/configparser.html.
+
+Why you'll love ``configparser``
+--------------------------------
+
+Whereas almost completely compatible with its older brother, ``configparser``
+sports a bunch of interesting new features:
+
+* full mapping protocol access (`more info
+  <http://docs.python.org/3/library/configparser.html#mapping-protocol-access>`_)::
+
+    >>> parser = ConfigParser()
+    >>> parser.read_string("""
+    [DEFAULT]
+    location = upper left
+    visible = yes
+    editable = no
+    color = blue
+
+    [main]
+    title = Main Menu
+    color = green
+
+    [options]
+    title = Options
+    """)
+    >>> parser['main']['color']
+    'green'
+    >>> parser['main']['editable']
+    'no'
+    >>> section = parser['options']
+    >>> section['title']
+    'Options'
+    >>> section['title'] = 'Options (editable: %(editable)s)'
+    >>> section['title']
+    'Options (editable: no)'
+
+* there's now one default ``ConfigParser`` class, which basically is the old
+  ``SafeConfigParser`` with a bunch of tweaks which make it more predictable for
+  users. Don't need interpolation? Simply use
+  ``ConfigParser(interpolation=None)``, no need to use a distinct
+  ``RawConfigParser`` anymore.
+
+* the parser is highly `customizable upon instantiation
+  <http://docs.python.org/3/library/configparser.html#customizing-parser-behaviour>`__
+  supporting things like changing option delimiters, comment characters, the
+  name of the DEFAULT section, the interpolation syntax, etc.
+
+* you can easily create your own interpolation syntax but there are two powerful
+  implementations built-in (`more info
+  <http://docs.python.org/3/library/configparser.html#interpolation-of-values>`__):
+
+  * the classic ``%(string-like)s`` syntax (called ``BasicInterpolation``)
+
+  * a new ``${buildout:like}`` syntax (called ``ExtendedInterpolation``)
+
+* fallback values may be specified in getters (`more info
+  <http://docs.python.org/3/library/configparser.html#fallback-values>`__)::
+
+    >>> config.get('closet', 'monster',
+    ...            fallback='No such things as monsters')
+    'No such things as monsters'
+
+* ``ConfigParser`` objects can now read data directly `from strings
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_string>`__
+  and `from dictionaries
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_dict>`__.
+  That means importing configuration from JSON or specifying default values for
+  the whole configuration (multiple sections) is now a single line of code. Same
+  goes for copying data from another ``ConfigParser`` instance, thanks to its
+  mapping protocol support.
+
+* many smaller tweaks, updates and fixes
+
+A few words about Unicode
+-------------------------
+
+``configparser`` comes from Python 3 and as such it works well with Unicode.
+The library is generally cleaned up in terms of internal data storage and
+reading/writing files.  There are a couple of incompatibilities with the old
+``ConfigParser`` due to that. However, the work required to migrate is well
+worth it as it shows the issues that would likely come up during migration of
+your project to Python 3.
+
+The design assumes that Unicode strings are used whenever possible [1]_.  That
+gives you the certainty that what's stored in a configuration object is text.
+Once your configuration is read, the rest of your application doesn't have to
+deal with encoding issues. All you have is text [2]_. The only two phases when
+you should explicitly state encoding is when you either read from an external
+source (e.g. a file) or write back.
+
+Versioning
+----------
+
+This project uses `semver <https://semver.org/spec/v2.0.0.html>`_ to
+communicate the impact of various releases while periodically syncing
+with the upstream implementation in CPython.
+`The changelog <https://github.com/jaraco/configparser/blob/master/CHANGES.rst>`_
+serves as a reference indicating which versions incorporate
+which upstream functionality.
+
+Prior to the ``4.0.0`` release, `another scheme
+<https://github.com/jaraco/configparser/blob/3.8.1/README.rst#versioning>`_
+was used to associate the CPython and backports releases.
+
+Maintenance
+-----------
+
+This backport was originally authored by Łukasz Langa, the current vanilla
+``configparser`` maintainer for CPython and is currently maintained by
+Jason R. Coombs:
+
+* `configparser repository <https://github.com/jaraco/configparser>`_
+
+* `configparser issue tracker <https://github.com/jaraco/configparser/issues>`_
+
+Security Contact
+----------------
+
+To report a security vulnerability, please use the
+`Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+Conversion Process
+------------------
+
+This section is technical and should bother you only if you are wondering how
+this backport is produced. If the implementation details of this backport are
+not important for you, feel free to ignore the following content.
+
+``configparser`` is converted using `python-future
+<http://python-future.org>`_. The project takes the following
+branching approach:
+
+* the ``3.x`` branch holds unchanged files synchronized from the upstream
+  CPython repository. The synchronization is currently done by manually copying
+  the required files and stating from which CPython changeset they come from.
+
+* the ``master`` branch holds a version of the ``3.x`` code with some tweaks
+  that make it independent from libraries and constructions unavailable on 2.x.
+  Code on this branch still *must* work on the corresponding Python 3.x but
+  will also work on Python 2.6 and 2.7 (including PyPy).  You can check this
+  running the supplied unit tests with ``tox``.
+
+The process works like this:
+
+1. In the ``3.x`` branch, run ``pip-run -- sync-upstream.py``, which
+   downloads the latest stable release of Python and copies the relevant
+   files from there into their new locations here and then commits those
+   changes with a nice reference to the relevant upstream commit hash.
+
+2. I check for new names in ``__all__`` and update imports in
+   ``configparser.py`` accordingly. I run the tests on Python 3. Commit.
+
+3. I merge the new commit to ``master``. I run ``tox``. Commit.
+
+4. If there are necessary changes, I do them now (on ``master``). Note that
+   the changes should be written in the syntax subset supported by Python
+   2.6.
+
+5. I run ``tox``. If it works, I update the docs and release the new version.
+   Otherwise, I go back to point 3. I might use ``pasteurize`` to suggest me
+   required changes but usually I do them manually to keep resulting code in
+   a nicer form.
+
+
+Footnotes
+---------
+
+.. [1] To somewhat ease migration, passing bytestrings is still supported but
+       they are converted to Unicode for internal storage anyway. This means
+       that for the vast majority of strings used in configuration files, it
+       won't matter if you pass them as bytestrings or Unicode. However, if you
+       pass a bytestring that cannot be converted to Unicode using the naive
+       ASCII codec, a ``UnicodeDecodeError`` will be raised. This is purposeful
+       and helps you manage proper encoding for all content you store in
+       memory, read from various sources and write back.
+
+.. [2] Life gets much easier when you understand that you basically manage
+       **text** in your application.  You don't care about bytes but about
+       letters.  In that regard the concept of content encoding is meaningless.
+       The only time when you deal with raw bytes is when you write the data to
+       a file.  Then you have to specify how your text should be encoded.  On
+       the other end, to get meaningful text from a file, the application
+       reading it has to know which encoding was used during its creation.  But
+       once the bytes are read and properly decoded, all you have is text.  This
+       is especially powerful when you start interacting with multiple data
+       sources.  Even if each of them uses a different encoding, inside your
+       application data is held in abstract text form.  You can program your
+       business logic without worrying about which data came from which source.
+       You can freely exchange the data you store between sources.  Only
+       reading/writing files requires encoding your text to bytes.
+
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/configparser-4.0.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+backports/__init__.py,sha256=elt6uFwbaEv80X8iGWsCJ_w_n_h1X8repgOoNrN0Syg,212
+backports/__init__.pyc,,
+backports/configparser/__init__.py,sha256=thhQqB1qWNKf-F3CpZFYsjC8YT-_I_vF0w4JiuQfiWI,56628
+backports/configparser/__init__.pyc,,
+backports/configparser/helpers.py,sha256=TxT00ldsHvIciQpml1YaoHfdtTl033Km6ywwT-U2nRc,7543
+backports/configparser/helpers.pyc,,
+configparser-4.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+configparser-4.0.2.dist-info/LICENSE,sha256=pV4v_ptEmY5iHVHYwJS-0JrMS1I27nPX3zlaM7o8GP0,1050
+configparser-4.0.2.dist-info/METADATA,sha256=oDqeXQXq8JhFEDHKDOBmbUtXmQ3CiiXB1Mr4UheTZ8Y,10910
+configparser-4.0.2.dist-info/RECORD,,
+configparser-4.0.2.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+configparser-4.0.2.dist-info/top_level.txt,sha256=mIs8gajd7cvEWhVluv4u6ocaHw_TJ9rOrpkZEFv-7Hc,23
+configparser.py,sha256=4VADEswCwzy_RDVgvje3BmZhD6iwo3k4EkUZcgzLD4M,1546
+configparser.pyc,,

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/configparser-4.0.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+backports
+configparser

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/_compat.py

@@ -0,0 +1,45 @@
+import cffi
+import warnings
+
+
+class OpenSSLVersion:
+    V1_0 = "1_0"
+    V1_1 = "1_1"
+
+
+def get_abi_lib():
+    ffi = cffi.FFI()
+    ffi.cdef("unsigned long OpenSSL_version_num();")
+    ffi.cdef("unsigned long SSLeay();")
+    lib = ffi.dlopen("crypto")
+    return lib
+
+
+def get_openssl_version(lib=None, warn=False):
+    """Returns the OpenSSL version that is used for bindings."""
+
+    if lib is None:
+        lib = get_abi_lib()
+
+    try:
+        full_version = lib.OpenSSL_version_num()
+    except AttributeError:
+        full_version = lib.SSLeay()
+
+    version = full_version >> 20
+    if version == 0x101:
+        return OpenSSLVersion.V1_1
+    elif version == 0x100:
+        if warn:
+            warnings.warn(
+                "Support for the system OpenSSL version (0x%x) is pending deprecation. "
+                "Please upgrade to OpenSSL v1.1" % version)
+        return OpenSSLVersion.V1_0
+    else:
+        # If the version is not 1.0 or 1.1, assume its a later one, and optimistically
+        # assume it doesn't horribly break the interface this time.
+        if warn:
+            warnings.warn(
+                "System OpenSSL version is not supported: %d. "
+                "Attempting to use in OpenSSL v1.1 mode." % version)
+        return OpenSSLVersion.V1_1

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/bindings.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+import os
+import platform
+import cffi
+import sys
+
+try:
+    from ._petlib import ffi, lib
+    _FFI = ffi
+    _C = lib
+
+except BaseException:
+    print("Support not loading the library to build docs without compiling.")
+    _C = None
+    _FFI = None
+
+
+from ._compat import get_openssl_version, OpenSSLVersion  # pylint: disable=unused-import
+_OPENSSL_VERSION = get_openssl_version(_C)
+
+
+# Store constants
+class Const:
+    POINT_CONVERSION_COMPRESSED = 2,
+    POINT_CONVERSION_UNCOMPRESSED = 4,
+    POINT_CONVERSION_HYBRID = 6
+
+
+_inited = False
+
+
+def version():
+    if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+        cstr = _C.SSLeay_version(_C.SSLEAY_VERSION)
+    else:
+        cstr = _C.OpenSSL_version(_C.OPENSSL_VERSION)
+
+    return str(_FFI.string(cstr))
+
+
+def get_errors():
+    errors = []
+    err = _C.ERR_get_error()
+    while err != 0:
+        errors += [err]
+        err = _C.ERR_get_error()
+    assert isinstance(errors, list)
+    return errors
+
+
+class InitCiphers(object):
+    # pylint: disable=global-statement
+
+    def __init__(self):
+        global _inited
+        self.on = False
+        self._C = _C
+        if not _inited:
+            _C.OPENSSL_init()
+            _C.init_ciphers()
+            _inited = True
+            self.on = True
+
+    def __del__(self):
+        global _inited
+        if _inited and self.on and self._C:
+            _inited = False
+            self._C.cleanup_ciphers()
+
+
+if _C and _FFI:
+    _ciphers = InitCiphers()
+    if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+        if _C.CRYPTO_get_locking_callback() == _FFI.NULL:
+            _C.setup_ssl_threads()
+
+
+def test_double_load():
+    _c2 = InitCiphers()
+    del _c2
+    # Nothing bad should happen
+
+
+def test_version():
+    print(version())
+    assert version()
+
+
+def test_errors():
+    assert get_errors() == []
+
+
+def test_locks():
+    if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+        assert _C.CRYPTO_get_locking_callback() != _FFI.NULL
+
+
+def test_multithread():
+    import threading
+    from .ec import EcPt, EcGroup
+
+    G = EcGroup()
+    g = G.generator()
+    o = G.order()
+    g2 = o.random() * g
+    g2_s = g2.export()
+
+    def worker():
+        for _ in range(100):
+            EcPt.from_binary(g2_s, G)
+
+    threads = []
+    for _ in range(100):
+        t = threading.Thread(target=worker)
+        threads.append(t)
+        t.start()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/bn.py

@@ -0,0 +1,1047 @@
+from .bindings import _FFI, _C, get_errors
+
+from functools import wraps
+from copy import copy, deepcopy
+from binascii import hexlify, unhexlify  # pylint: disable=unused-import
+
+# Py2/3 compatibility
+try:
+    from builtins import int        # pylint: disable=redefined-builtin
+    from builtins import object     # pylint: disable=redefined-builtin
+except BaseException:                             # pylint: disable=bare-except
+    print("Cannot mock for docs")
+
+try:
+    from future.utils import python_2_unicode_compatible
+except Exception as e:              # pylint: disable=broad-except
+    # An identity decorator
+    def python_2_unicode_compatible(x): return x
+
+import pytest
+
+
+def force_Bn(n):
+    """A decorator that coerces the nth input to be a Big Number"""
+
+    def convert_nth(f):
+        # pylint: disable=star-args
+        @wraps(f)
+        def new_f(*args, **kwargs):
+            new_args = args
+            try:
+                if not n < len(args) or args[n].bn:  # isinstance(args[n], Bn):
+                    new_args = args
+            except BaseException:
+                # if not n < len(args):
+                #    new_args = args
+
+                if isinstance(args[n], int):
+                    r = Bn.from_num(args[n])
+                    new_args = list(args)
+                    new_args[n] = r
+                    new_args = tuple(new_args)
+                else:
+                    return NotImplemented
+
+            return f(*new_args, **kwargs)
+
+        return new_f
+    return convert_nth
+
+
+def _check(return_val):
+    """Checks the return code of the C calls"""
+    if __debug__:
+        if isinstance(return_val, int) and return_val == 1:
+            return
+        if isinstance(return_val, bool) and return_val == True:
+            return
+
+    if return_val == True and return_val == 1:
+        return
+
+    errs = get_errors()
+    raise Exception("BN exception: %s" % errs)
+
+
+class BnCtx(object):
+    """ A Bn Context for use by the petlib library """
+
+    __slots__ = ['bnctx', '_C']
+
+    def __init__(self):
+        self._C = _C
+        self.bnctx = self._C.BN_CTX_new()
+        _check(self.bnctx != _FFI.NULL)
+
+    def __del__(self):
+        if self.bnctx is not None:
+            self._C.BN_CTX_free(self.bnctx)
+
+
+class BnCtxNULL(BnCtx):
+    """ A Bn Context for use by the petlib library """
+
+    __slots__ = ['bnctx', '_C']
+
+    def __init__(self):
+        self._C = _C
+        self.bnctx = _FFI.NULL
+
+    def __del__(self):
+        pass
+
+
+import threading
+_thread_local = threading.local()
+
+
+def get_ctx():
+    global _thread_local
+
+    try:
+        return _thread_local.ctx
+    except BaseException:
+        _thread_local.ctx = BnCtx()
+        return _thread_local.ctx
+
+
+@python_2_unicode_compatible
+class Bn(object):
+    """The core Big Number class.
+         It supports all comparisons (<, <=, ==, !=, >=, >),
+         arithmetic operations (+, -, %, /, divmod, pow)
+         and copy operations (copy and deep copy). The right-hand
+         side operand may be a small native python integer (<2^64). """
+
+    __C = _C
+
+    # We know this class will keep minimal state
+    __slots__ = ['bn']
+
+    # -- static methods
+
+    @staticmethod
+    def from_num(num):
+        if isinstance(num, int):
+            return Bn(num)
+        elif isinstance(num, Bn):
+            return num
+        else:
+            # raise TypeError("Cannot coerce %s into a BN." % num)
+            return NotImplemented
+
+    @staticmethod
+    def from_decimal(sdec):
+        """Creates a Big Number from a decimal string.
+
+        Args:
+            sdec (string): numeric string possibly starting with minus.
+
+        See Also:
+            str() produces a decimal string from a big number.
+
+        Example:
+            >>> hundred = Bn.from_decimal("100")
+            >>> str(hundred)
+            '100'
+
+        """
+
+        ptr = _FFI.new("BIGNUM **")
+        read_bytes = _C.BN_dec2bn(ptr, sdec.encode("utf8"))
+        if read_bytes != len(sdec):
+            raise Exception("BN Error")
+
+        ret = Bn()
+        _C.BN_copy(ret.bn, ptr[0])
+        _C.BN_clear_free(ptr[0])
+        return ret
+
+    @staticmethod
+    def from_hex(shex):
+        """Creates a Big Number from a hexadecimal string.
+
+        Args:
+            shex (string): hex (0-F) string possibly starting with minus.
+
+        See Also:
+            hex() produces a hexadecimal representation of a big number.
+
+        Example:
+            >>> Bn.from_hex("FF")
+            255
+        """
+
+        ptr = _FFI.new("BIGNUM **")
+        read_bytes = _C.BN_hex2bn(ptr, shex.encode("utf8"))
+        if read_bytes != len(shex):
+            raise Exception("BN Error")
+
+        ret = Bn()
+        _C.BN_copy(ret.bn, ptr[0])
+        _C.BN_clear_free(ptr[0])
+        return ret
+
+    @staticmethod
+    def from_binary(sbin):
+        """Creates a Big Number from a byte sequence representing the number in Big-endian 8 byte atoms. Only positive values can be represented as byte sequence, and the library user should store the sign bit separately.
+
+        Args:
+            sbin (string): a byte sequence.
+
+        Example:
+            >>> byte_seq = unhexlify(b"010203")
+            >>> Bn.from_binary(byte_seq)
+            66051
+            >>> (1 * 256**2) + (2 * 256) + 3
+            66051
+        """
+        ret = Bn()
+        _C.BN_bin2bn(sbin, len(sbin), ret.bn)
+        return ret
+
+    @staticmethod
+    def get_prime(bits, safe=1):
+        """
+        Builds a prime Big Number of length bits.
+
+        Args:
+                bits (int) -- the number of bits.
+                safe (int) -- 1 for a safe prime, otherwise 0.
+
+        """
+        _check(0 < bits < 10000)
+        _check(safe in [0, 1])
+
+        ret = Bn()
+        _check(
+            _C.BN_generate_prime_ex(
+                ret.bn,
+                bits,
+                safe,
+                _FFI.NULL,
+                _FFI.NULL,
+                _FFI.NULL))
+        return ret
+
+    ## -- methods
+
+    _upper_bound = 2**(64 - 1)
+
+    def __init__(self, num=0):
+        'Allocate a Big Number structure, initialized with a small integer or zero.'
+        self.bn = _C.BN_new()
+
+        if num == 0:
+            return
+
+        if __debug__:
+            _check(0 <= abs(num) <= self._upper_bound)
+            _check(isinstance(num, int))
+
+        # Assign
+        if num != 0:
+            ret = _C.BN_set_word(self.bn, abs(num))
+            if __debug__:
+                _check(ret)
+            if ret != 1:
+                raise Exception("Bn Exception.")
+
+        if num < 0:
+            self._set_neg(1)
+
+    def _set_neg(self, sign=1):
+        # """Sets the sign to "-" (1) or "+" (0)"""
+        if not (sign == 0 or sign == 1):
+            raise Exception("Sign has to be 0 or 1.")
+        _C.BN_set_negative(self.bn, sign)
+
+    def copy(self):
+        """Returns a copy of the Bn object."""
+        return self.__copy__()
+
+    def __copy__(self):
+        # 'Copies the big number. Support for copy module'
+        other = Bn()
+        _C.BN_copy(other.bn, self.bn)
+        return other
+
+    def __deepcopy__(self, memento):
+        # 'Deepcopy is the same as copy'
+        # pylint: disable=unused-argument
+        return self.__copy__()
+
+    def __del__(self):
+        # 'Deallocate all resources of the big number'
+        self.__C.BN_clear_free(self.bn)
+
+    def __inner_cmp__(self, other):
+        # 'Irel comparison function'
+        # if __debug__:
+        #    _check( type(other) == Bn )
+        try:
+            sig = int(_C.BN_cmp(self.bn, other.bn))
+            return sig
+        except AttributeError:
+            return self.__inner_cmp__(Bn.from_num(other))
+
+    def __lt__(self, other):
+        return self.__inner_cmp__(other) < 0
+
+    def __le__(self, other):
+        return self.__inner_cmp__(other) <= 0
+
+    def __eq__(self, other):
+        return self.__inner_cmp__(other) == 0
+
+    def __ne__(self, other):
+        return self.__inner_cmp__(other) != 0
+
+    def __gt__(self, other):
+        return self.__inner_cmp__(other) > 0
+
+    def __ge__(self, other):
+        return self.__inner_cmp__(other) >= 0
+
+    def bool(self):
+        'Turn Bn into boolean. False if zero, True otherwise.'
+        return self.__bool__()
+
+    def __bool__(self):
+        # 'Turn into boolean'
+        return not (self == Bn(0))
+
+    # Python 2 compatibility
+    def __nonzero__(self):
+        return self.__bool__()
+
+    # Export in different representations
+
+    def repr(self):
+        'The representation of the number as a decimal string'
+        return self.__repr__()
+
+    def __repr__(self):
+        # 'The representation of the number as a decimal string'
+        buf = _C.BN_bn2dec(self.bn)
+        s = bytes(_FFI.string(buf))
+        _C.OPENSSL_free(buf)
+        return s.decode('utf8')
+
+    def int(self):
+        """A native python integer representation of the Big Number.
+             Synonym for int(bn).
+        """
+        return self.__int__()
+
+    def __int__(self):
+        return int(self.__repr__())
+
+    def __index__(self):
+        return int(self.__repr__())
+
+    def hex(self):
+        """The representation of the string in hexadecimal.
+        Synonym for hex(n)."""
+        return self.__hex__()
+
+    def __hex__(self):
+        # """The representation of the string in hexadecimal"""
+        buf = _C.BN_bn2hex(self.bn)
+        s = bytes(_FFI.string(buf))
+        _C.OPENSSL_free(buf)
+        return s.decode("utf8")
+
+    def binary(self):
+        """Returns a byte sequence storing the absolute value of the Big
+        Number in Big-Endian format (with 8 bit atoms). You need to extact the sign separately.
+
+        Example:
+            >>> bin = Bn(66051).binary()
+            >>> hexlify(bin) == b'010203'
+            True
+        """
+        if self < 0:
+            raise Exception("Cannot represent negative numbers")
+        size = _C.bn_num_bytes(self.bn)
+        bin_string = _FFI.new("unsigned char[]", size)
+
+        l = _C.BN_bn2bin(self.bn, bin_string)
+        assert int(l) == size
+        return bytes(_FFI.buffer(bin_string)[:])
+
+    def random(self):
+        """Returns a cryptographically strong random number 0 <= rnd < self.
+
+        Example:
+            >>> r = Bn(100).random()
+            >>> 0 <= r < 100
+            True
+
+        """
+        rnd = Bn()
+        err = _C.BN_rand_range(rnd.bn, self.bn)
+        if __debug__:
+            _check(err)
+        return rnd
+
+    # ---------- Arithmetic --------------
+
+    def int_neg(self):
+        """Returns the negative of this number. Synonym with -self.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> one100.int_neg()
+            -100
+            >>> -one100
+            -100
+
+        """
+        return self.__neg__()
+
+    def int_add(self, other):
+        """Returns the sum of this number with another. Synonym for self + other.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> two100 = Bn(200)
+            >>> two100.int_add(one100) # Function syntax
+            300
+            >>> two100 + one100        # Operator syntax
+            300
+
+        """
+        return self.__add__(other)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __add__(self, other):
+        try:
+            r = Bn()
+            err = _C.BN_add(r.bn, self.bn, other.bn)
+
+            if __debug__:
+                _check(err)
+            return r
+        except AttributeError:
+            return self.__add__(Bn.from_num(other))
+
+    def int_sub(self, other):
+        """Returns the difference between this number and another.
+        Synonym for self - other.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> two100 = Bn(200)
+            >>> two100.int_sub(one100) # Function syntax
+            100
+            >>> two100 - one100        # Operator syntax
+            100
+
+        """
+        return self - other
+
+    def __rsub__(self, other):
+        return Bn(other) - self
+
+    def __sub__(self, other):
+        try:
+            r = Bn()
+            err = _C.BN_sub(r.bn, self.bn, other.bn)
+
+            if __debug__:
+                _check(err)
+
+            return r
+        except AttributeError:
+            return self.__sub__(Bn.from_num(other))
+
+    def int_mul(self, other):
+        """Returns the product of this number with another.
+        Synonym for self * other.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> two100 = Bn(200)
+            >>> one100.int_mul(two100) # Function syntax
+            20000
+            >>> one100 * two100        # Operator syntax
+            20000
+
+        """
+        return self.__mul__(other)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __mul__(self, other):
+
+        try:
+            r = Bn()
+            local_ctx = get_ctx()
+            err = _C.BN_mul(r.bn, self.bn, other.bn, local_ctx.bnctx)
+
+            if __debug__:
+                _check(err)
+
+            return r
+        except AttributeError:
+            other = Bn.from_num(other)
+            if other is NotImplemented:
+                return NotImplemented
+            return self.__mul__(other)
+
+
+# ------------------ Mod arithmetic -------------------------
+
+
+    def mod_add(self, other, m):
+        """
+        mod_add(other, m)
+        Returns the sum of self and other modulo m.
+
+        Example:
+
+            >>> Bn(10).mod_add(Bn(2), Bn(11))  # Only function notation available
+            1
+
+        """
+        try:
+            r = Bn()
+            local_ctx = get_ctx()
+            err = _C.BN_mod_add(r.bn, self.bn, other.bn, m.bn, local_ctx.bnctx)
+            if __debug__:
+                _check(err)
+
+            return r
+        except AttributeError:
+            return self.mod_add(Bn.from_num(other), Bn.from_num(m))
+
+    def mod_sub(self, other, m):
+        """
+        mod_sub(other, m)
+        Returns the difference of self and other modulo m.
+
+        Example:
+
+            >>> Bn(10).mod_sub(Bn(2), Bn(11))  # Only function notation available
+            8
+
+        """
+
+        try:
+            r = Bn()
+            local_ctx = get_ctx()
+            err = _C.BN_mod_sub(r.bn, self.bn, other.bn, m.bn, local_ctx.bnctx)
+
+            if __debug__:
+                _check(err)
+
+            return r
+        except AttributeError:
+            return self.mod_sub(Bn.from_num(other), Bn.from_num(m))
+
+    def mod_mul(self, other, m):
+        """
+        mod_mul(other, m)
+        Return the product of self and other modulo m.
+
+        Example:
+
+            >>> Bn(10).mod_mul(Bn(2), Bn(11))  # Only function notation available
+            9
+
+        """
+        try:
+            r = Bn()
+            local_ctx = get_ctx()
+            err = _C.BN_mod_mul(r.bn, self.bn, other.bn, m.bn, local_ctx.bnctx)
+
+            if __debug__:
+                _check(err)
+
+            return r
+        except AttributeError:
+            return self.mod_mul(Bn.from_num(other), Bn.from_num(m))
+
+    def mod_inverse(self, m):
+        """
+        mod_inverse(m)
+        Compute the inverse mod m, such that self * res == 1 mod m.
+
+        Example:
+
+            >>> Bn(10).mod_inverse(m = Bn(11))  # Only function notation available
+            10
+            >>> Bn(10).mod_mul(Bn(10), m = Bn(11)) == Bn(1)
+            True
+
+        """
+
+        try:
+            res = Bn()
+            local_ctx = get_ctx()
+            err = _C.BN_mod_inverse(res.bn, self.bn, m.bn, local_ctx.bnctx)
+
+            if err == _FFI.NULL:
+                errs = get_errors()
+
+                if errs == [50770023]:
+                    raise Exception("No inverse")
+
+                elif errs == [50782316]:
+                    raise Exception("No inverse")
+
+                else:
+                    raise Exception("Unknown error: %s" % errs)
+
+            return res
+        except AttributeError:
+            return self.mod_inverse(Bn.from_num(m))
+
+    def mod_pow(self, other, m, ctx=None):
+        """ Performs the modular exponentiation of self ** other % m.
+
+            Example:
+                >>> one100 = Bn(100)
+                >>> one100.mod_pow(2, 3)   # Modular exponentiation
+                1
+
+        """
+        return self.__pow__(other, m, ctx=ctx)
+
+    def divmod(self, other):
+        """Returns the integer division and remainder of this number by another.
+        Synonym for (div, mod) = divmod(self, other)"""
+        return self.__divmod__(other)
+
+    def __rdivmod__(self, other):
+        return Bn(other).__divmod__(self)
+
+    def __divmod__(self, other):
+        try:
+            dv = Bn()
+            rem = Bn()
+            local_ctx = get_ctx()
+            ret = _C.BN_div(dv.bn, rem.bn, self.bn, other.bn, local_ctx.bnctx)
+            if __debug__:
+                _check(ret)
+            return (dv, rem)
+        except AttributeError:
+            return self.__divmod__(Bn.from_num(other))
+
+    def int_div(self, other):
+        """Returns the integer division of this number by another.
+        Synonym of self / other.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> two100 = Bn(200)
+            >>> two100.int_div(one100) # Function syntax
+            2
+            >>> two100 / one100        # Operator syntax
+            2
+
+        """
+        return self.__div__(other)
+
+    def __rdiv__(self, other):
+        return Bn(other).__div__(self)
+
+    def __div__(self, other):
+        dv, _ = divmod(self, other)
+        return dv
+
+    def mod(self, other):
+        """Returns the remainder of this number modulo another.
+        Synonym for self % other.
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> two100 = Bn(200)
+            >>> two100.mod(one100) # Function syntax
+            0
+            >>> two100 % one100        # Operator syntax
+            0
+
+
+        """
+        return self.__mod__(other)
+
+    def __rmod__(self, other):
+        return Bn(other).__mod__(self)
+
+    def __mod__(self, other):
+
+        try:
+            rem = Bn()
+
+            local_ctx = get_ctx()
+            err = _C.BN_nnmod(rem.bn, self.bn, other.bn, local_ctx.bnctx)
+
+            if __debug__:
+                _check(err)
+            return rem
+        except AttributeError:
+            self.__mod__(Bn.from_num(other))
+
+    def __rtruediv__(self, other):
+        return Bn(other).__truediv__(self)
+
+    def __truediv__(self, other):
+        return self.__div__(other)
+
+    def __rfloordiv__(self, other):
+        return Bn(other).__floordiv__(self)
+
+    def __floordiv__(self, other):
+        return self.__div__(other)
+
+    def __rpow__(self, other):
+        return Bn(other).__pow__(self)
+
+    def pow(self, other, modulo=None, ctx=None):
+        """Returns the number raised to the power other optionally modulo a third number.
+        Synonym with pow(self, other, modulo).
+
+        Example:
+
+            >>> one100 = Bn(100)
+            >>> one100.pow(2)      # Function syntax
+            10000
+            >>> one100 ** 2        # Operator syntax
+            10000
+            >>> one100.pow(2, 3)   # Modular exponentiation
+            1
+
+        """
+        if modulo:
+            return self.__pow__(other, modulo, ctx)
+        else:
+            return self ** other
+
+    def __pow__(self, other, modulo=None, ctx=None):
+
+        try:
+            res = Bn()
+
+            if ctx is None:
+                ctx = BnCtx()
+
+            if modulo is None:
+                _check(_C.BN_exp(res.bn, self.bn, other.bn, ctx.bnctx))
+            else:
+                _check(
+                    _C.BN_mod_exp(
+                        res.bn,
+                        self.bn,
+                        other.bn,
+                        modulo.bn,
+                        ctx.bnctx))
+
+            return res
+        except BaseException:
+            other = Bn.from_num(other)
+            if modulo is not None:
+                modulo = Bn.from_num(modulo)
+            return self.__pow__(other, modulo, ctx)
+
+    def is_prime(self):
+        """Returns True if the number is prime, with negligible prob. of error."""
+
+        res = int(_C.BN_is_prime_ex(self.bn, 0, get_ctx().bnctx, _FFI.NULL))
+        if res == 0:
+            return False
+        if res == 1:
+            return True
+        raise Exception("Primality test failure %s" % int(res))
+
+    def is_odd(self):
+        """Returns True if the number is odd."""
+
+        return bool(_C.bn_is_odd(self.bn))
+
+    def is_bit_set(self, n):
+        """Returns True if the nth bit is set"""
+        return int(_C.BN_is_bit_set(self.bn, n))
+
+    def num_bits(self):
+        """Returns the number of bits representing this Big Number"""
+        return int(_C.BN_num_bits(self.bn))
+
+    # Implement negative
+    def __neg__(self):
+        # pylint: disable=protected-access
+        global zero
+        ret = copy(self)
+        if ret >= zero:
+            ret._set_neg(1)
+        else:
+            ret._set_neg(0)
+        return ret
+
+    def __hash__(self):
+        return int(self).__hash__()
+
+# Unsuported
+# object.__lshift__(self, other)
+# object.__rshift__(self, other)
+# object.__and__(self, other)
+# object.__xor__(self, other)
+# object.__or__(self, other)
+
+# ---------- Tests ------------
+
+
+# Some globals
+zero = Bn(0)
+
+
+def test_bn_constructors():
+    assert Bn.from_decimal("100") == 100
+    assert Bn.from_decimal("-100") == -100
+
+    with pytest.raises(Exception) as excinfo:
+        Bn.from_decimal("100ABC")
+    assert 'BN Error' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        Bn.from_hex("100ABCZ")
+    assert 'BN Error' in str(excinfo.value)
+
+    assert Bn.from_hex(Bn(-100).hex()) == -100
+    assert Bn(15).hex() == Bn(15).hex()
+
+    with pytest.raises(Exception) as excinfo:
+        Bn(-100).binary()
+    assert 'negative' in str(excinfo.value)
+
+    #assert Bn.from_binary(Bn(-100).binary()) == 100
+    assert Bn.from_binary(Bn(100).binary()) == Bn(100)
+    assert Bn.from_binary(Bn(100).binary()) == 100
+
+    with pytest.raises(Exception) as excinfo:
+        s = 10**10
+        Bn(s)
+    assert 'does not fit' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        _check(False)
+    assert 'BN' in str(excinfo.value)
+
+    #assert Bn.from_binary(Bn(-100).binary()) != Bn(50)
+    assert int(Bn(-100)) == -100
+
+    assert repr(Bn(5)) == Bn(5).repr() == "5"
+    assert range(10)[Bn(4)] == 4
+
+    d = {Bn(5): 5, Bn(6): 6}
+    assert Bn(5) in d
+
+
+def test_bn_prime():
+    p = Bn.get_prime(128)
+    assert p > Bn(0)
+    assert p.is_prime()
+    assert not Bn(16).is_prime()
+    assert p.num_bits() > 127
+
+
+def test_bn_arithmetic():
+    assert (Bn(1) + Bn(1) == Bn(2))
+    assert (Bn(1).int_add(Bn(1)) == Bn(2))
+
+    assert (Bn(1) + 1 == Bn(2))
+    # assert (1 + Bn(1) == Bn(2))
+
+    assert (Bn(1) + Bn(-1) == Bn(0))
+    assert (Bn(10) + Bn(10) == Bn(20))
+    assert (Bn(-1) * Bn(-1) == Bn(1))
+    assert (Bn(-1).int_mul(Bn(-1)) == Bn(1))
+
+    assert (Bn(10) * Bn(10) == Bn(100))
+    assert (Bn(10) - Bn(10) == Bn(0))
+    assert (Bn(10) - Bn(100) == Bn(-90))
+    assert (Bn(10) + (-Bn(10)) == Bn(0))
+    s = -Bn(100)
+    assert (Bn(10) + s == Bn(-90))
+    assert (Bn(10) - (-Bn(10)) == Bn(20))
+    assert -Bn(-10) == 10
+    assert Bn(-10).int_neg() == 10
+
+    assert divmod(Bn(10), Bn(3)) == (Bn(3), Bn(1))
+    assert Bn(10).divmod(Bn(3)) == (Bn(3), Bn(1))
+
+    assert Bn(10) / Bn(3) == Bn(3)
+    assert Bn(10) // Bn(3) == Bn(3)
+    assert Bn(10).int_div(Bn(3)) == Bn(3)
+
+    assert Bn(10) % Bn(3) == Bn(1)
+    assert Bn(10).mod(Bn(3)) == Bn(1)
+
+    assert Bn(2) ** Bn(8) == Bn(2 ** 8)
+    assert pow(Bn(2), Bn(8), Bn(27)) == Bn(2 ** 8 % 27)
+
+    pow(Bn(10), Bn(10)).binary()
+
+    assert pow(Bn(2), 8, 27) == 2 ** 8 % 27
+
+    assert Bn(3).mod_inverse(16) == 11
+
+    with pytest.raises(Exception) as excinfo:
+        Bn(3).mod_inverse(0)
+        print("Got inverse")
+    assert 'No inverse' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        x = Bn(0).mod_inverse(Bn(13))
+        print("!!! Got inverse", x)
+    assert 'No inverse' in str(excinfo.value)
+
+    # with pytest.raises(Exception) as excinfo:
+    #    x = Bn(0).mod_inverse(Bn(13))
+    #    print("Got inverse", x)
+    #assert 'No inverse' in str(excinfo.value)
+
+    assert Bn(10).mod_add(10, 15) == (10 + 10) % 15
+    assert Bn(10).mod_sub(100, 15) == (10 - 100) % 15
+    assert Bn(10).mod_mul(10, 15) == (10 * 10) % 15
+    assert Bn(-1).bool()
+
+
+def test_bn_right_arithmetic():
+    assert (1 + Bn(1) == Bn(2))
+
+    assert (-1 * Bn(-1) == Bn(1))
+
+    assert (10 * Bn(10) == Bn(100))
+    assert (10 - Bn(10) == Bn(0))
+    assert (10 - Bn(100) == Bn(-90))
+    assert (10 + (-Bn(10)) == Bn(0))
+    s = -Bn(100)
+    assert (10 + s == Bn(-90))
+    assert (10 - (-Bn(10)) == Bn(20))
+
+    assert divmod(10, Bn(3)) == (Bn(3), Bn(1))
+
+    assert 10 / Bn(3) == Bn(3)
+    assert 10 // Bn(3) == Bn(3)
+
+    assert 10 % Bn(3) == Bn(1)
+    assert 2 ** Bn(8) == Bn(2 ** 8)
+
+    assert 100 == Bn(100)
+
+    pow(10, Bn(10))
+
+
+def test_bn_allocate():
+    # Test allocation
+    n0 = Bn(10)
+    assert True
+
+    assert str(Bn()) == "0"
+    assert str(Bn(1)) == "1"
+    assert str(Bn(-1)) == "-1"
+
+    assert Bn(15).hex() == "0F"
+    assert Bn(-15).hex() == "-0F"
+
+    assert int(Bn(5)) == 5
+    assert Bn(5).int() == 5
+
+    assert 0 <= Bn(15).random() < 15
+
+    # Test copy
+    o0 = copy(n0)
+    o1 = deepcopy(n0)
+
+    assert o0 == n0
+    assert o1 == n0
+
+    # Test nonzero
+    assert not Bn()
+    assert not Bn(0)
+    assert Bn(1)
+    assert Bn(100)
+
+
+def test_bn_cmp():
+    assert Bn(1) < Bn(2)
+    assert Bn(1) <= Bn(2)
+    assert Bn(2) <= Bn(2)
+    assert Bn(2) == Bn(2)
+    assert Bn(2) <= Bn(3)
+    assert Bn(2) < Bn(3)
+
+
+def test_extras():
+    two = Bn(2)
+    two2 = two.copy()
+    assert two == two2
+
+
+def test_odd():
+    assert Bn(1).is_odd()
+    assert Bn(1).is_bit_set(0)
+    assert not Bn(1).is_bit_set(1)
+
+    assert Bn(3).is_odd()
+    assert Bn(3).is_bit_set(0)
+    assert Bn(3).is_bit_set(1)
+
+    assert not Bn(0).is_odd()
+    assert not Bn(2).is_odd()
+
+    assert Bn(100).is_bit_set(Bn(100).num_bits() - 1)
+
+
+def test_check():
+    with pytest.raises(Exception) as excinfo:
+        _check(False)
+    assert 'BN' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        _check(-1)
+    assert 'BN' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        _check(0)
+    assert 'BN' in str(excinfo.value)
+
+
+def test_timing_exp():
+    p = Bn.from_decimal("158261031819091141711717027498980088325079888681498417129323009913367867128038610210948802263526234270043507882496188624614467036250990588401775690578042934008692254417273606807265961724843618743242066301529332478013432957153823449143202719186309012133210922613102725038632605463022887306439116579645787938883")
+    psmall = Bn.from_decimal(
+        "90123082853250477832412338337738008391831682960497136029451532639902615425459")
+
+    xs = [p.random() for _ in range(1000)]
+    ys = [p.random() for _ in range(1000)]
+
+    import time
+
+    print
+    t0 = time.time()
+    X = [xi.mod_mul(yi, psmall) for (xi, yi) in zip(xs, ys)]
+    t1 = time.time()
+    print("Mod_mul time: %.2fms" % ((t1 - t0) * 1000.0 / 1000.0))
+
+    t0 = time.time()
+    X = [xi.pow(yi, p) for (xi, yi) in zip(xs, ys)]
+    t1 = time.time()
+    print("    Pow time: %.2fms" % ((t1 - t0) * 1000.0 / 1000.0))
+
+    ctx = BnCtx()
+    t0 = time.time()
+    X = [xi.pow(yi, p, ctx) for (xi, yi) in zip(xs, ys)]
+    t1 = time.time()
+    print("Pow ctx time: %.2fms" % ((t1 - t0) * 1000.0 / 1000.0))

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/cipher.py

@@ -0,0 +1,603 @@
+from .bindings import _FFI, _C, _OPENSSL_VERSION, OpenSSLVersion
+
+import pytest
+
+
+def _check(return_val):
+    """Checks the return code of the C calls"""
+    if isinstance(return_val, int) and return_val == 1:
+        return
+    if isinstance(return_val, bool) and return_val == True:
+        return
+
+    raise Exception(
+        "Cipher exception: Unknown type %s or value %s" %
+        (str(
+            type(return_val)),
+            str(return_val)))
+
+
+class Cipher(object):
+    """A class representing a symmetric cipher and mode.
+
+    Example:
+        An example of encryption and decryption using AES in counter mode.
+
+        >>> from os import urandom
+        >>> aes = Cipher("AES-128-CTR")     # Init AES in Counter mode
+        >>> key = urandom(16)
+        >>> iv  = urandom(16)
+        >>>
+        >>> # Get a CipherOperation object for encryption
+        >>> enc = aes.enc(key, iv)
+        >>> ref = b"Hello World"
+        >>> ciphertext = enc.update(ref)
+        >>> ciphertext += enc.finalize()
+        >>>
+        >>> # Get a CipherOperation object for decryption
+        >>> dec = aes.dec(key, iv)
+        >>> plaintext = dec.update(ciphertext)
+        >>> plaintext += dec.finalize()
+        >>> plaintext == ref # Check resulting plaintest matches referece one.
+        True
+
+    """
+
+    __slots__ = ["alg", "gcm"]
+
+    def __init__(self, name, _alg=None):
+        """Initialize the cipher by name."""
+
+        if _alg:
+            self.alg = _alg
+            self.gcm = True
+            return
+        else:
+
+            self.alg = _C.EVP_get_cipherbyname(name.encode("utf8"))
+            self.gcm = False
+            if self.alg == _FFI.NULL:
+                raise Exception("Unknown cipher: %s" % name)
+
+        if "gcm" in name.lower():
+            self.gcm = True
+
+        if "ccm" in name.lower():
+            raise Exception("CCM mode not supported")
+
+    def len_IV(self):
+        """Return the Initialization Vector length in bytes."""
+        if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+            return int(self.alg.iv_len)
+        else:
+            return int(_C.EVP_CIPHER_iv_length(self.alg))
+
+    def len_key(self):
+        """Return the secret key length in bytes."""
+        if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+            return int(self.alg.key_len)
+        else:
+            return int(_C.EVP_CIPHER_key_length(self.alg))
+
+    def len_block(self):
+        """Return the block size in bytes."""
+        if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+            return int(self.alg.block_size)
+        else:
+            return int(_C.EVP_CIPHER_block_size(self.alg))
+
+    def get_nid(self):
+        """Return the OpenSSL nid of the cipher and mode."""
+        if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+            return int(self.alg.nid)
+        else:
+            return int(_C.EVP_CIPHER_nid(self.alg))
+
+    def op(self, key, iv, enc=1):
+        """Initializes a cipher operation, either encrypt or decrypt
+        and returns a CipherOperation object
+
+        Args:
+            key (str): the block cipher symmetric key. Length depends on block cipher choice.
+            iv (str): an Initialization Vector of up to the block size. (Can be shorter.)
+            enc (int): set to 1 to perform encryption, or 0 to perform decryption.
+
+        """
+        c_op = CipherOperation(enc)
+        _check(len(key) == self.len_key())
+        _check(enc in [0, 1])
+
+        if not self.gcm:
+            _check(len(iv) == self.len_IV())
+            _check(_C.EVP_CipherInit_ex(c_op.ctx,
+                                        self.alg, _FFI.NULL, key, iv, enc))
+
+        else:
+            _check(_C.EVP_CipherInit_ex(c_op.ctx,
+                                        self.alg, _FFI.NULL, _FFI.NULL, _FFI.NULL, enc))
+
+            # assert len(iv) <= self.len_block()
+
+            _check(_C.EVP_CIPHER_CTX_ctrl(c_op.ctx,
+                                          _C.EVP_CTRL_GCM_SET_IVLEN, len(iv), _FFI.NULL))
+
+            _C.EVP_CIPHER_CTX_ctrl(
+                c_op.ctx, _C.EVP_CTRL_GCM_SET_IV_FIXED, -1, iv)
+            _C.EVP_CIPHER_CTX_ctrl(c_op.ctx, _C.EVP_CTRL_GCM_IV_GEN, 0, iv)
+
+            _check(_C.EVP_CipherInit_ex(c_op.ctx,
+                                        _FFI.NULL, _FFI.NULL, key, iv, enc))
+
+        c_op.cipher = self
+        return c_op
+
+    def enc(self, key, iv):
+        """Initializes an encryption engine with the cipher with a specific key and Initialization Vector (IV).
+        Returns the CipherOperation engine.
+
+        Args:
+            key (str): the block cipher symmetric key. Length depends on block cipher choice.
+            iv (str): an Initialization Vector of up to the block size. (Can be shorter.)
+
+        """
+        return self.op(key, iv, enc=1)
+
+    def dec(self, key, iv):
+        """Initializes a decryption engine with the cipher with a specific key and Initialization Vector (IV).
+        Returns the CipherOperation engine.
+
+        Args:
+            key (str): the block cipher symmetric key. Length depends on block cipher choice.
+            iv (str): an Initialization Vector of up to the block size. (Can be shorter.)
+
+        """
+        return self.op(key, iv, enc=0)
+
+    def __del__(self):
+        pass
+
+# --------- AES GCM special functions ---------------
+
+    @staticmethod
+    def aes_128_gcm():
+        """Returns a pre-initalized AES-GCM cipher with 128 bits key size"""
+        return Cipher(None, _C.EVP_aes_128_gcm())
+
+    @staticmethod
+    def aes_192_gcm():
+        """Returns a pre-initalized AES-GCM cipher with 192 bits key size"""
+        return Cipher(None, _C.EVP_aes_192_gcm())
+
+    @staticmethod
+    def aes_256_gcm():
+        """Returns a pre-initalized AES-GCM cipher with 256 bits key size"""
+        return Cipher(None, _C.EVP_aes_256_gcm())
+
+    def quick_gcm_enc(self, key, iv, msg, assoc=None, tagl=16):
+        """One operation GCM encryption.
+
+        Args:
+            key (str): the AES symmetric key. Length depends on block cipher choice.
+            iv (str): an Initialization Vector of up to the block size. (Can be shorter.)
+            msg (str): the message to encrypt.
+            assoc (str): associated data that will be integrity protected, but not encrypted.
+            tagl (int): the length of the tag, up to the block length.
+
+        Example:
+            Use of `quick_gcm_enc` and `quick_gcm_dec` for AES-GCM operations.
+
+            >>> from os import urandom      # Secure OS random source
+            >>> aes = Cipher("aes-128-gcm") # Initialize AES-GCM with 128 bit keys
+            >>> iv = urandom(16)
+            >>> key = urandom(16)
+            >>> # Encryption using AES-GCM returns a ciphertext and a tag
+            >>> ciphertext, tag = aes.quick_gcm_enc(key, iv, b"Hello")
+            >>> # Decrytion using AES-GCM
+            >>> p = aes.quick_gcm_dec(key, iv, ciphertext, tag)
+            >>> assert p == b'Hello'
+
+        """
+        enc = self.enc(key, iv)
+        if assoc:
+            enc.update_associated(assoc)
+        ciphertext = enc.update(msg)
+        ciphertext += enc.finalize()
+        tag = enc.get_tag(tagl)
+
+        return (ciphertext, tag)
+
+    def quick_gcm_dec(self, key, iv, cip, tag, assoc=None):
+        """One operation GCM decrypt. See usage example in "quick_gcm_enc".
+        Throws an exception on failure of decryption
+
+        Args:
+            key (str): the AES symmetric key. Length depends on block cipher choice.
+            iv (str): an Initialization Vector of up to the block size. (Can be shorter.)
+            cip (str): the ciphertext to decrypt.
+            tag (int): the integrity tag.
+            assoc (str): associated data that will be integrity protected, but not encrypted.
+
+        """
+        dec = self.dec(key, iv)
+        if assoc:
+            dec.update_associated(assoc)
+
+        dec.set_tag(tag)
+        plain = dec.update(cip)
+
+        try:
+            plain += dec.finalize()
+        except BaseException:
+            raise Exception("Cipher: decryption failed.")
+        return plain
+
+
+class CipherOperation(object):
+
+    __slots__ = ["ctx", "cipher", "xenc"]
+
+    def __init__(self, xenc):
+        self.ctx = _C.EVP_CIPHER_CTX_new()
+        self.cipher = None
+        self.xenc = xenc
+
+    def update(self, data):
+        """Processes some data, and returns a partial result."""
+        block_len = self.cipher.len_block()
+        alloc_len = len(data) + block_len + 1
+        outl = _FFI.new("int *")
+        outl[0] = alloc_len
+        out = _FFI.new("unsigned char[]", alloc_len)
+
+        _check(_C.EVP_CipherUpdate(self.ctx, out, outl, data, len(data)))
+
+        ret = bytes(_FFI.buffer(out)[:int(outl[0])])
+        return ret
+
+    def finalize(self):
+        """Finalizes the operation and may return some additional data.
+        Throws an exception if the authenticator tag is different from the expected value.
+
+        Example:
+            Example of the exception thrown when an invalid tag is provided.
+
+            >>> from os import urandom
+            >>> aes = Cipher.aes_128_gcm()              # Define an AES-GCM cipher
+            >>> iv = urandom(16)
+            >>> key = urandom(16)
+            >>> ciphertext, tag = aes.quick_gcm_enc(key, iv, b"Hello")
+            >>>
+            >>> dec = aes.dec(key, iv)                  # Get a decryption CipherOperation
+            >>> dec.set_tag(urandom(len(tag)))          # Provide an invalid tag.
+            >>> plaintext = dec.update(ciphertext)      # Feed in the ciphertext for decryption.
+            >>> try:
+            ...    dec.finalize()                       # Check and Finalize.
+            ... except:
+            ...    print("Failure")
+            Failure
+
+            Throws an exception since integrity check fails due to the invalid tag.
+
+        """
+        block_len = self.cipher.len_block()
+        alloc_len = block_len
+        outl = _FFI.new("int *")
+        outl[0] = alloc_len
+        out = _FFI.new("unsigned char[]", alloc_len)
+
+        try:
+            _check(_C.EVP_CipherFinal_ex(self.ctx, out, outl))
+            if outl[0] == 0:
+                return b''
+
+            ret = bytes(_FFI.buffer(out)[:int(outl[0])])
+            return ret
+        except BaseException:
+            raise Exception("Cipher: decryption failed.")
+
+    def update_associated(self, data):
+        """Processes some GCM associated data, and returns nothing."""
+
+        if self.xenc == 0:
+            self.set_tag(b"\00" * 16)
+
+        outl = _FFI.new("int *")
+        _check(_C.EVP_CipherUpdate(self.ctx, _FFI.NULL, outl, data, len(data)))
+        _check(outl[0] == len(data))
+
+    def get_tag(self, tag_len=16):
+        """Get the GCM authentication tag. Execute after finalizing the encryption.
+
+        Example:
+            AES-GCM encryption usage:
+
+            >>> from os import urandom
+            >>> aes = Cipher.aes_128_gcm()          # Initialize AES cipher
+            >>> key = urandom(16)
+            >>> iv = urandom(16)
+            >>> enc = aes.enc(key, iv)              # Get an encryption CipherOperation
+            >>> enc.update_associated(b"Hello")     # Include some associated data
+            >>> ciphertext = enc.update(b"World!")  # Include some plaintext
+            >>> nothing = enc.finalize()            # Finalize
+            >>> tag = enc.get_tag(16)               # Get the AES-GCM tag
+
+        """
+        tag = _FFI.new("unsigned char []", tag_len)
+        ret = _C.EVP_CIPHER_CTX_ctrl(
+            self.ctx, _C.EVP_CTRL_GCM_GET_TAG, tag_len, tag)
+        _check(ret)
+        s = bytes(_FFI.buffer(tag)[:])
+        return s
+
+    def set_tag(self, tag):
+        """Specify the GCM authenticator tag. Must be done before finalizing decryption
+
+        Example:
+            AES-GCM decryption and check:
+
+            >>> aes = Cipher.aes_128_gcm()              # Define an AES-GCM cipher
+            >>> ciphertext, tag = (b'dV\\xb9:\\xd0\\xbe', b'pA\\xbe?\\xfc\\xd1&\\x03\\x1438\\xc5\\xf8In\\xaa')
+            >>> dec = aes.dec(key=b"A"*16, iv=b"A"*16)  # Get a decryption CipherOperation
+            >>> dec.update_associated(b"Hello")         # Feed in the non-secret assciated data.
+            >>> plaintext = dec.update(ciphertext)      # Feed in the ciphertext for decryption.
+            >>> dec.set_tag(tag)                        # Provide the AES-GCM tag for integrity.
+            >>> nothing = dec.finalize()                # Check and finalize.
+            >>> assert plaintext == b'World!'
+
+        """
+        _check(
+            _C.EVP_CIPHER_CTX_ctrl(
+                self.ctx,
+                _C.EVP_CTRL_GCM_SET_TAG,
+                len(tag),
+                tag))
+
+    def __del__(self):
+        _C.EVP_CIPHER_CTX_free(self.ctx)
+
+
+# When testing ignore extra variables
+# pylint: disable=unused-variable,redefined-outer-name
+
+def test_aes_init():
+    aes = Cipher("AES-128-CBC")
+    assert aes.alg != _FFI.NULL
+    assert aes.len_IV() == 16
+    assert aes.len_block() == 16
+    assert aes.len_key() == 16
+    assert aes.get_nid() == 419
+    del aes
+
+
+def test_errors():
+    with pytest.raises(Exception) as excinfo:
+        aes = Cipher("AES-128-XXF")
+    assert 'Unknown' in str(excinfo.value)
+
+
+def test_aes_enc():
+    aes = Cipher("AES-128-CBC")
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+
+    ref = b"Hello World" * 10000
+
+    ciphertext = enc.update(ref)
+    ciphertext += enc.finalize()
+
+    dec = aes.op(key=b"A" * 16, iv=b"A" * 16, enc=0)
+    plaintext = dec.update(ciphertext)
+    plaintext += dec.finalize()
+    assert plaintext == ref
+
+
+def test_aes_ctr():
+    aes = Cipher("AES-128-CTR")
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+
+    ref = b"Hello World" * 10000
+
+    ciphertext = enc.update(ref)
+    ciphertext += enc.finalize()
+
+    dec = aes.op(key=b"A" * 16, iv=b"A" * 16, enc=0)
+    plaintext = dec.update(ciphertext)
+    plaintext += dec.finalize()
+    assert plaintext == ref
+
+
+def test_aes_ops():
+    aes = Cipher("AES-128-CTR")
+    enc = aes.enc(key=b"A" * 16, iv=b"A" * 16)
+
+    ref = b"Hello World" * 10000
+
+    ciphertext = enc.update(ref)
+    ciphertext += enc.finalize()
+
+    dec = aes.dec(key=b"A" * 16, iv=b"A" * 16)
+    plaintext = dec.update(ciphertext)
+    plaintext += dec.finalize()
+    assert plaintext == ref
+
+
+def test_aes_gcm_encrypt():
+    aes = Cipher.aes_128_gcm()
+    assert aes.gcm
+
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    assert c2 == b''
+
+    tag = enc.get_tag(16)
+    assert len(tag) == 16
+
+
+def test_aes_gcm_encrypt_192():
+    aes = Cipher.aes_192_gcm()
+    assert aes.gcm
+
+    enc = aes.op(key=b"A" * 24, iv=b"A" * 16)
+
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    assert c2 == b''
+
+    tag = enc.get_tag(16)
+    assert len(tag) == 16
+
+
+def test_aes_gcm_encrypt_256():
+    aes = Cipher.aes_256_gcm()
+    assert aes.gcm
+
+    enc = aes.op(key=b"A" * 32, iv=b"A" * 16)
+
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    assert c2 == b''
+
+    tag = enc.get_tag(16)
+    assert len(tag) == 16
+
+
+@pytest.fixture
+def aesenc():
+    aes = Cipher.aes_128_gcm()
+    assert aes.gcm
+
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    assert c2 == b''
+
+    tag = enc.get_tag(16)
+    assert len(tag) == 16
+
+    return (aes, enc, ciphertext, tag)
+
+
+def test_gcm_dec(aesenc):
+    aes, enc, ciphertext, tag = aesenc
+    dec = aes.dec(key=b"A" * 16, iv=b"A" * 16)
+    dec.update_associated(b"Hello")
+    plaintext = dec.update(ciphertext)
+
+    dec.set_tag(tag)
+
+    dec.finalize()
+
+    assert plaintext == b"World!"
+
+
+def test_gcm_dec_badassoc(aesenc):
+    aes, enc, ciphertext, tag = aesenc
+
+    dec = aes.dec(key=b"A" * 16, iv=b"A" * 16)
+    dec.update_associated(b"H4llo")
+    plaintext = dec.update(ciphertext)
+
+    dec.set_tag(tag)
+
+    with pytest.raises(Exception) as excinfo:
+        dec.finalize()
+    assert "Cipher" in str(excinfo.value)
+
+
+def test_gcm_dec_badkey(aesenc):
+    aes, enc, ciphertext, tag = aesenc
+
+    dec = aes.dec(key=b"B" * 16, iv=b"A" * 16)
+    dec.update_associated(b"Hello")
+    plaintext = dec.update(ciphertext)
+
+    dec.set_tag(tag)
+
+    with pytest.raises(Exception) as excinfo:
+        dec.finalize()
+    assert "Cipher" in str(excinfo.value)
+
+
+def test_gcm_dec_badiv(aesenc):
+    aes, enc, ciphertext, tag = aesenc
+    dec = aes.dec(key=b"A" * 16, iv=b"B" * 16)
+    dec.update_associated(b"Hello")
+    plaintext = dec.update(ciphertext)
+
+    dec.set_tag(tag)
+
+    with pytest.raises(Exception) as excinfo:
+        dec.finalize()
+    assert "Cipher" in str(excinfo.value)
+
+
+def test_aes_gcm_byname():
+    aes = Cipher("aes-128-gcm")
+    assert aes.gcm
+
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    assert c2 == b''
+
+    tag = enc.get_tag(16)
+    assert len(tag) == 16
+
+    dec = aes.dec(key=b"A" * 16, iv=b"A" * 16)
+    dec.update_associated(b"Hello")
+    plaintext = dec.update(ciphertext)
+
+    dec.set_tag(tag)
+
+    dec.finalize()
+
+    assert plaintext == b"World!"
+
+
+def test_aes_gcm_different_IV():
+    aes = Cipher("aes-128-gcm")
+
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+    enc.update_associated(b"Hello")
+    ciphertext = enc.update(b"World!")
+    c2 = enc.finalize()
+    tag = enc.get_tag(16)
+
+    enc = aes.op(key=b"A" * 16, iv=b"A" * 16)
+    enc.update_associated(b"Hello")
+    ciphertext2 = enc.update(b"World!")
+    c2 = enc.finalize()
+    tag2 = enc.get_tag(16)
+
+    enc = aes.op(key=b"A" * 16, iv=b"B" * 16)
+    enc.update_associated(b"Hello")
+    ciphertext3 = enc.update(b"World!")
+    c2 = enc.finalize()
+    tag3 = enc.get_tag(16)
+
+    assert ciphertext == ciphertext2
+    assert ciphertext != ciphertext3
+
+
+def test_quick():
+    aes = Cipher("aes-128-gcm")
+    c, t = aes.quick_gcm_enc(b"A" * 16, b"A" * 16, b"Hello")
+    p = aes.quick_gcm_dec(b"A" * 16, b"A" * 16, c, t)
+    assert p == b"Hello"
+
+
+def test_quick_assoc():
+    aes = Cipher("aes-128-gcm")
+    c, t = aes.quick_gcm_enc(b"A" * 16, b"A" * 16, b"Hello", assoc=b"blah")
+    p = aes.quick_gcm_dec(b"A" * 16, b"A" * 16, c, t, assoc=b"blah")
+    assert p == b"Hello"
+
+# pylint: enable=unused-variable,redefined-outer-name

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/compile.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+import os
+import platform
+import cffi
+
+
+CURRENT_PATH = os.path.abspath(os.path.dirname(__file__))
+OPENSSL_BINDINGS_PATH = os.path.join(CURRENT_PATH, '_cffi_src/openssl')
+COMPAT_FILE_PATH = os.path.join(CURRENT_PATH, '_compat.py')
+
+
+# Load the OpenSSL version utility.
+with open(COMPAT_FILE_PATH) as compat_file:
+    exec(compat_file.read())  # pylint: disable=exec-used
+
+
+if platform.system() == "Windows":
+    # Windows building instructions:
+    # * Ensure you compile with a 64bit lib and toolchain
+    #   (run vcvarsx86_amd64.bat)
+    # * Ensure the OpenSSL 64 bit lib is on the path.
+    #   (PATH=C:\OpenSSL-Win64\bin;%PATH%)
+    libraries = ["libeay32"]
+    include_dirs = [r"."]
+    extra_compile_args = []
+
+    # if "VCINSTALLDIR" not in os.environ:
+    #     raise Exception(r"Cannot find the Visual Studio %VCINSTALLDIR% variable. Ensure you ran the appropriate vcvars.bat script.")
+
+    # if "OPENSSL_CONF" not in os.environ:
+    #     raise Exception(r"Cannot find the Visual Studio %OPENSSL_CONF% variable. Ensure you install OpenSSL for Windows.")
+
+    openssl_conf = os.environ["OPENSSL_CONF"]
+    openssl_bin, conf_name = os.path.split(openssl_conf)
+    openssl_base, bin_name = os.path.split(openssl_bin)
+    assert bin_name == "bin"
+    include_dirs += [os.path.join(openssl_base, "include")]
+    library_dirs = [
+        openssl_base, os.path.join(
+            openssl_base, "lib"), os.path.join(
+            openssl_base, "bin")]
+    link_args = []
+
+else:
+    # Asume we are running on a posix system
+    # LINUX: libraries=["crypto"],
+    # extra_compile_args=['-Wno-deprecated-declarations']
+    link_args = []
+    libraries = ["crypto"]
+    extra_compile_args = ['-Wno-deprecated-declarations']
+    if platform.system() == "Darwin":
+        include_dirs = ['/usr/local/opt/openssl@1.1/include',
+                        '/usr/local/opt/openssl/include',
+                        '/usr/local/ssl/include']
+        library_dirs = ['/usr/local/opt/openssl@1.1/lib',
+                        '/usr/local/opt/openssl/lib',
+                        '/usr/local/ssl/lib']
+
+        # Ensure that our dynamic ABI-based version finding code in
+        # _compat.get_openssl_version also tries to load the
+        # brew-installed openssl libraries first.
+        os.environ["DYLD_LIBRARY_PATH"] = str.join(":", library_dirs)
+    else:
+        include_dirs = []
+        library_dirs = []
+        # link_args = ['libcrypto.so']
+
+
+def get_openssl_bindings(filename):
+    src_path = os.path.join(OPENSSL_BINDINGS_PATH, filename)
+    with open(src_path) as src_file:
+        return src_file.read()
+
+
+openssl_version_code = get_openssl_version(warn=True)  # pylint: disable=undefined-variable
+openssl_bindings_defs = get_openssl_bindings(
+    'openssl_v%s.h' % openssl_version_code)
+openssl_bindings_src = get_openssl_bindings(
+    'openssl_v%s.c' % openssl_version_code)
+
+_FFI = cffi.FFI()
+_FFI.set_source("petlib._petlib", openssl_bindings_src,
+                libraries=libraries,
+                extra_compile_args=extra_compile_args,
+                include_dirs=include_dirs,
+                library_dirs=library_dirs,
+                extra_link_args=link_args)
+_FFI.cdef(openssl_bindings_defs)
+
+
+if __name__ == "__main__":
+    print("Compiling petlib for OpenSSL version %s..." % openssl_version_code)
+    _FFI.compile()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/ec.py

@@ -0,0 +1,787 @@
+from .bindings import _FFI, _C, Const
+from .bn import Bn, force_Bn, get_ctx
+
+from copy import copy
+from binascii import hexlify
+from hashlib import sha512
+
+try:
+    from builtins import int        # pylint: disable=redefined-builtin
+    from builtins import object     # pylint: disable=redefined-builtin
+except BaseException:                             # pylint: disable=bare-except
+    print('Cannot mock for docs')
+
+try:
+    from future.utils import python_2_unicode_compatible
+except Exception:              # pylint: disable=broad-except
+    # An identity decorator
+    def python_2_unicode_compatible(x): return x
+
+import pytest
+
+_debug = True
+
+
+def _check(return_val):
+    """Checks the return code of the C calls"""
+    if __debug__:
+        if isinstance(return_val, int) and return_val == 1:
+            return
+        if isinstance(return_val, bool) and return_val == True:
+            return
+
+    if return_val == 1 or return_val == True:
+        return
+
+    raise Exception("EC exception")
+
+
+class EcGroup(object):
+
+    @staticmethod
+    def list_curves():
+        """Return a dictionary of name id (int) to curve names (str).
+
+        Example:
+            >>> curves = EcGroup.list_curves()
+            >>> curves[713]
+            'NIST/SECG curve over a 224 bit prime field'
+
+        """
+        size_t = int(_C.EC_get_builtin_curves(_FFI.NULL, 0))
+        _check(0 < size_t)
+        names = _FFI.new("EC_builtin_curve[]", size_t)
+        _C.EC_get_builtin_curves(names, size_t)
+
+        all_curves = []
+        for i in range(size_t):
+            all_curves += [(int(names[i].nid),
+                            str(_FFI.string(names[i].comment).decode("utf8")))]
+        return dict(all_curves)
+
+    def __init__(self, nid=713, optimize_mult=True):
+        """Build an EC group from the Open SSL nid. By default use NIST p224, which in OpenSSL 64bit supports constant-time operations."""
+        self.ecg = _C.EC_GROUP_new_by_curve_name(nid)
+
+        self.gen = None
+        self.ord = None
+        self.inf = None
+
+        if optimize_mult:
+            _check(_C.EC_GROUP_precompute_mult(self.ecg, get_ctx().bnctx))
+
+    def parameters(self):
+        """Returns a dictionary with the parameters (a,b and p) of the curve.
+
+        Example:
+            >>> params = EcGroup(713).parameters()
+            >>> params["a"]
+            26959946667150639794667015087019630673557916260026308143510066298878
+            >>> params["b"]
+            18958286285566608000408668544493926415504680968679321075787234672564
+            >>> params["p"]
+            26959946667150639794667015087019630673557916260026308143510066298881
+
+        """
+        p, a, b = Bn(), Bn(), Bn()
+        _check(
+            _C.EC_GROUP_get_curve_GFp(
+                self.ecg,
+                p.bn,
+                a.bn,
+                b.bn,
+                get_ctx().bnctx))
+        return {"p": p, "a": a, "b": b}
+
+    def generator(self):
+        """Returns the generator of the EC group."""
+
+        if self.gen is None:
+            g = EcPt(self)
+            internal_g = _C.EC_GROUP_get0_generator(self.ecg)
+            _check(_C.EC_POINT_copy(g.pt, internal_g))
+            self.gen = g
+
+        return self.gen
+
+    def infinite(self):
+        """Returns a point at infinity.
+
+        Example:
+            >>> G = EcGroup()
+            >>> G.generator() + G.infinite() == G.generator() ## Should hold.
+            True
+
+        """
+        if self.inf is None:
+            zero = EcPt(self)
+            _check(_C.EC_POINT_set_to_infinity(self.ecg, zero.pt))
+            self.inf = zero
+        return self.inf
+
+    def order(self):
+        """Returns the order of the group as a Big Number.
+
+        Example:
+            >>> G = EcGroup()
+            >>> G.order() * G.generator() == G.infinite() ## Should hold.
+            True
+
+        """
+
+        if self.ord is None:
+            o = Bn()
+            _check(_C.EC_GROUP_get_order(self.ecg, o.bn, get_ctx().bnctx))
+            self.ord = o
+
+        return self.ord
+
+    def sum(self, elems):
+        """ Sum efficiently a number of elements """
+
+        result = copy(elems[0])  # EcPt(self)
+
+        for el in elems[1:]:
+            err = _C.EC_POINT_add(
+                self.ecg,
+                result.pt,
+                result.pt,
+                el.pt,
+                get_ctx().bnctx)
+
+            if __debug__:
+                _check(err)
+
+        return result
+
+    def wsum(self, weights, elems):
+        """ Sum efficiently a number of elements each multiplied by a bn in weights """
+
+        res = EcPt(self)
+
+        if __debug__:
+            assert len(weights) == len(elems)
+            assert all(isinstance(e, Bn) for e in weights)
+            assert all(isinstance(e, EcPt) for e in elems)
+
+        all_ws = [e.bn for e in weights]
+        all_es = [e.pt for e in elems]
+        err = _C.EC_POINTs_mul(
+            self.ecg,
+            res.pt,
+            _FFI.NULL,
+            len(all_es),
+            all_es,
+            all_ws,
+            get_ctx().bnctx)
+
+        if __debug__:
+            _check(err)
+
+        return res
+
+    def __eq__(self, other):
+        res = _C.EC_GROUP_cmp(self.ecg, other.ecg, get_ctx().bnctx)
+        return res == 0
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return "EcGroup(%s)" % self.nid()
+
+    def nid(self):
+        """Returns the Open SSL group ID"""
+        return int(_C.EC_GROUP_get_curve_name(self.ecg))
+
+    def __del__(self):
+        if _C:
+            _C.EC_GROUP_free(self.ecg)
+
+    def check_point(self, pt):
+        """Ensures the point is on the curve.
+
+        Example:
+            >>> G = EcGroup()
+            >>> G.check_point(G.generator())
+            True
+            >>> G.check_point(G.infinite())
+            True
+
+        """
+        res = int(_C.EC_POINT_is_on_curve(self.ecg, pt.pt, get_ctx().bnctx))
+        return res == 1
+
+    def hash_to_point(self, hinput):
+        """Hash a string into an EC Point."""
+        p = self.parameters()["p"]
+
+        pt = EcPt(self)
+        xhash = hinput
+        y = 1
+        ret = 0
+
+        while ret == 0:
+            xhash = sha512(xhash).digest()
+            x = Bn.from_binary(xhash) % p
+            ret = _C.EC_POINT_set_compressed_coordinates_GFp(
+                self.ecg, pt.pt, x.bn, y, get_ctx().bnctx)
+
+        assert self.check_point(pt)
+        _check(ret)
+        return pt
+
+    def get_points_from_x(self, x):
+        """ Returns the two EC points with the given x coordinate. """
+
+        pt0 = EcPt(self)
+        pt1 = EcPt(self)
+
+        ret0 = _C.EC_POINT_set_compressed_coordinates_GFp(
+            self.ecg, pt0.pt, x.bn, True, get_ctx().bnctx)
+        ret1 = _C.EC_POINT_set_compressed_coordinates_GFp(
+            self.ecg, pt1.pt, x.bn, False, get_ctx().bnctx)
+
+        assert self.check_point(pt0) and self.check_point(pt1)
+        _check(ret0)
+        _check(ret1)
+
+        return (pt0, pt1)
+
+
+# Class constants
+try:
+    POINT_CONVERSION_UNCOMPRESSED = _C.POINT_CONVERSION_UNCOMPRESSED
+    POINT_CONVERSION_COMPRESSED = _C.POINT_CONVERSION_COMPRESSED
+except BaseException:
+    POINT_CONVERSION_UNCOMPRESSED = None
+    POINT_CONVERSION_COMPRESSED = None
+
+
+@python_2_unicode_compatible
+class EcPt(object):
+    """An EC point, supporting point addition, doubling
+    and multiplication with a scalar
+    """
+    __slots__ = ["pt", "group"]
+
+    @staticmethod
+    def from_binary(sbin, group):
+        """Create a point from a byte sequence.
+
+        Example:
+            >>> G = EcGroup()
+            >>> byte_string = G.generator().export()                # Export EC point as byte string
+            >>> EcPt.from_binary(byte_string, G) == G.generator()   # Import EC point from binary string
+            True
+
+        """
+        new_pt = EcPt(group)
+        err = _C.EC_POINT_oct2point(
+            group.ecg,
+            new_pt.pt,
+            sbin,
+            len(sbin),
+            get_ctx().bnctx)
+        _check(err)
+
+        return new_pt
+
+    def __init__(self, group):
+        self.group = group
+        self.pt = _C.EC_POINT_new(group.ecg)
+
+    def __copy__(self):
+        new_point = EcPt(self.group)
+        err = _C.EC_POINT_copy(new_point.pt, self.pt)
+        if __debug__:
+            _check(err)
+        return new_point
+
+    def pt_add(self, other):
+        """Adds two points together. Synonym with self + other.
+
+        Example:
+            >>> g = EcGroup().generator()
+            >>> g.pt_add(g) == (g + g) == (2 * g) == g.pt_double() # Equivalent formulations
+            True
+        """
+        return self.__add__(other)
+
+    def pt_add_inplace(self, other):
+        """Adds two points together and puts the result in self.pt.
+
+        """
+        return self.__add_inplace__(other)
+
+    def __add__(self, other):
+        if __debug__:
+            _check(isinstance(other, EcPt))
+            _check(other.group == self.group)
+
+        result = EcPt(self.group)
+        err = _C.EC_POINT_add(
+            self.group.ecg,
+            result.pt,
+            self.pt,
+            other.pt,
+            get_ctx().bnctx)
+
+        if __debug__:
+            _check(err)
+
+        return result
+
+    def __add_inplace__(self, other):
+        if __debug__:
+            _check(isinstance(other, EcPt))
+            _check(other.group == self.group)
+
+        err = _C.EC_POINT_add(
+            self.group.ecg,
+            self.pt,
+            self.pt,
+            other.pt,
+            _FFI.NULL)
+
+        if __debug__:
+            _check(err)
+
+    def pt_double(self):
+        """Doubles the point. equivalent to "self + self"."""
+        result = EcPt(self.group)
+        _check(
+            _C.EC_POINT_dbl(
+                self.group.ecg,
+                result.pt,
+                self.pt,
+                get_ctx().bnctx))
+        return result
+
+    def pt_double_inplace(self):
+        """Doubles the point and mutates it to hold the result."""
+        _check(
+            _C.EC_POINT_dbl(
+                self.group.ecg,
+                self.pt,
+                self.pt,
+                get_ctx().bnctx))
+
+    def pt_neg(self):
+        """Returns the negative of the point. Synonym with -self.
+
+        Example:
+            >>> G = EcGroup()
+            >>> g = G.generator()
+            >>> g + (-g) == G.infinite() # Unary negative operator.
+            True
+            >>> g - g == G.infinite()    # Binary negative operator.
+            True
+
+        """
+        return self.__neg__()
+
+    def pt_neg_inplace(self):
+        """Mutates the point to hold the negative value of the point.
+
+        """
+        return self.__neg_inplace__()
+
+    def __sub__(self, other):
+        # """ Simulates (abuses notation) subtraction as addition with a negative point."""
+        return self + (-other)
+
+    def __neg__(self):
+        # result = copy(self)
+
+        result = EcPt(self.group)
+        err = _C.EC_POINT_copy(result.pt, self.pt)
+        if __debug__:
+            _check(err)
+
+        err = _C.EC_POINT_invert(self.group.ecg, result.pt, get_ctx().bnctx)
+        if __debug__:
+            _check(err)
+        return result
+
+    def __neg_inplace__(self):
+        # result = copy(self)
+
+        err = _C.EC_POINT_invert(self.group.ecg, self.pt, get_ctx().bnctx)
+        if __debug__:
+            _check(err)
+
+    def pt_mul(self, scalar):
+        """Returns the product of the point with a scalar (not commutative). Synonym with scalar * self.
+
+        Example:
+            >>> G = EcGroup()
+            >>> g = G.generator()
+            >>> 100 * g == g.pt_mul(100) # Operator and function notation mean the same
+            True
+            >>> G.order() * g == G.infinite() # Scalar mul. by the order returns the identity element.
+            True
+
+        """
+        return self.__rmul__(scalar)
+
+    def pt_mul_inplace(self, scalar):
+        """ Multiplies a scalar with a point and mutates the point to hold the result.
+
+        """
+        return self.__rmul_inplace__(scalar)
+
+    # @force_Bn(1)
+    def __rmul__(self, other):
+        try:
+            result = EcPt(self.group)
+            err = _C.EC_POINT_mul(
+                self.group.ecg,
+                result.pt,
+                _FFI.NULL,
+                self.pt,
+                other.bn,
+                get_ctx().bnctx)
+            if __debug__:
+                _check(err)
+            return result
+        except AttributeError:
+            return self.__rmul__(Bn.from_num(other))
+
+    # @force_Bn(1)
+    def __rmul_inplace__(self, other):
+        try:
+            err = _C.EC_POINT_mul(
+                self.group.ecg,
+                self.pt,
+                _FFI.NULL,
+                self.pt,
+                other.bn,
+                _FFI.NULL)
+            if __debug__:
+                _check(err)
+        except AttributeError:
+            return self.__rmul_inplace__(Bn.from_num(other))
+
+    def pt_eq(self, other):
+        """Returns a boolean denoting whether the points are equal. Synonym with self == other.
+
+        Example:
+            >>> G = EcGroup()
+            >>> g = G.generator()
+            >>> 40 * g + 60 * g == 100 * g
+            True
+            >>> g == 2 * g
+            False
+
+        """
+        return self.__eq__(other)
+
+    def __eq__(self, other):
+        if __debug__:
+            _check(isinstance(other, EcPt))
+            _check(other.group == self.group)
+        r = int(
+            _C.EC_POINT_cmp(
+                self.group.ecg,
+                self.pt,
+                other.pt,
+                get_ctx().bnctx))
+        return r == 0
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __del__(self):
+        if _C:
+            _C.EC_POINT_clear_free(self.pt)
+
+    def __hash__(self):
+        return self.export().__hash__()
+
+    def export(self, form=POINT_CONVERSION_COMPRESSED):
+        """export(form=POINT_CONVERSION_COMPRESSED)
+
+        Returns a string binary representation of the point in compressed coordinates.
+
+        Example:
+            >>> G = EcGroup()
+            >>> byte_string = G.generator().export()
+            >>> print(hexlify(byte_string).decode("utf8"))
+            02b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21
+
+        """
+        size = _C.EC_POINT_point2oct(self.group.ecg, self.pt, form,
+                                     _FFI.NULL, 0, get_ctx().bnctx)
+        buf = _FFI.new("unsigned char[]", size)
+        _C.EC_POINT_point2oct(self.group.ecg, self.pt, form,
+                              buf, size, get_ctx().bnctx)
+        output = bytes(_FFI.buffer(buf)[:])
+        return output
+
+    def is_infinite(self):
+        """Returns True if this point is at infinity, otherwise False.
+
+        Example:
+            >>> G = EcGroup()
+            >>> g, o = G.generator(), G.order()
+            >>> (o * g).is_infinite()
+            True
+
+        """
+        return self == self.group.infinite()
+
+    def get_affine(self):
+        """Return the affine coordinates (x,y) of this EC Point.
+
+        Example:
+            >>> G = EcGroup()
+            >>> g = G.generator()
+            >>> x, y = g.get_affine()
+            >>> x
+            19277929113566293071110308034699488026831934219452440156649784352033
+            >>> y
+            19926808758034470970197974370888749184205991990603949537637343198772
+
+        """
+        if self == self.group.infinite():
+            raise Exception("EC Infinity has no affine coordinates.")
+        x = Bn()
+        y = Bn()
+        _check(_C.EC_POINT_get_affine_coordinates_GFp(self.group.ecg,
+                                                      self.pt, x.bn, y.bn, get_ctx().bnctx))
+        return (x, y)
+
+    def __str__(self):
+        return hexlify(self.export()).decode("utf8")
+
+    def __repr__(self):
+        return "EcPt(%s)" % self.__str__()
+
+
+# Ignore some lint warning in tests
+# pylint: disable=unused-variable
+
+def test_ec_list_group():
+    c = EcGroup.list_curves()
+    assert len(c) > 0
+    assert 713 in c
+    assert 410 in c
+
+
+def test_ec_build_group():
+    G = EcGroup(409)
+    assert G.nid() == 409
+    H = EcGroup(410)
+    assert G.check_point(G.generator())
+    assert not H.check_point(G.generator())
+    order = G.order()
+    assert str(
+        order) == "6277101735386680763835789423176059013767194773182842284081"
+    assert G == G
+    assert not (G == H)
+    assert G != H
+    assert not (G != G)
+    assert "a" in G.parameters()
+
+    h1 = G.hash_to_point(b"Hello2")
+
+
+def test_ec_from_x():
+    G = EcGroup(409)
+
+    g = G.generator()
+    x, y = g.get_affine()
+
+    g1, g2 = G.get_points_from_x(x)
+    assert g == g1 or g == g2
+
+
+def test_ec_arithmetic():
+    G = EcGroup(713)
+    g = G.generator()
+    assert g + g == g + g
+    assert g + g == g.pt_double()
+    assert g + g == Bn(2) * g
+    assert g + g == 2 * g
+
+    assert g + g != g + g + g
+    assert g + (-g) == G.infinite()
+    d = {}
+    d[2 * g] = 2
+    assert d[2 * g] == 2
+
+    # Test long names
+    assert (g + g).pt_eq(g + g)
+    assert g + g == g.pt_add(g)
+    assert -g == g.pt_neg()
+    assert 10 * g == g.pt_mul(10)
+
+    assert len(str(g)) > 0
+
+
+def test_ec_io():
+    G = EcGroup(713)
+    g = G.generator()
+
+    x, y = g.get_affine()
+    assert len(g.export()) == 29
+    i = G.infinite()
+    assert len(i.export()) == 1
+    assert EcPt.from_binary(g.export(), G) == g
+    assert EcPt.from_binary(i.export(), G) == i
+
+
+def test_ec_sum():
+    G = EcGroup(713)
+    g = G.generator()
+    assert G.sum([g] * 10) == (10 * g)
+
+    order = G.order()
+    h = order.random() * g
+    assert G.wsum([Bn(10), Bn(20)], [g, h]) == 10 * g + 20 * h
+
+
+def test_pt_add_inplace():
+    G = EcGroup(713)
+    g = G.generator()
+    """
+    Does pt_add_inplace add correctly?
+    """
+    a = g.pt_add(g)
+    g.pt_add_inplace(g)
+    assert a == g
+
+    """
+    Does it save the result in the same memory location?
+    """
+    a = G.generator()
+    b = a
+    a.pt_add_inplace(a)
+    assert id(b) == id(a)
+
+
+def test_pt_double_inplace():
+    G = EcGroup(713)
+    g = G.generator()
+    """
+    Does pt_double_inplace double correctly?
+    """
+    a = g.pt_double()
+    g.pt_double_inplace()
+    assert a == g
+
+    """
+    Does it save the result in the same memory location?
+    """
+    a = G.generator()
+    b = a
+    a.pt_double_inplace()
+    assert id(b) == id(a)
+
+
+def test_pt_mul_inplace():
+    G = EcGroup(713)
+    g = G.generator()
+    """
+    Does pt_mul_inplace multiply correctly?
+    """
+    a = g.pt_mul(5)
+    g.pt_mul_inplace(5)
+    assert a == g
+
+    """
+    Does it save the result in the same memory location?
+    """
+    a = G.generator()
+    b = a
+    a.pt_mul_inplace(5)
+    assert id(b) == id(a)
+
+
+def test_pt_neg_inplace():
+    G = EcGroup(713)
+    g = G.generator()
+    """
+    Does pt_neg_inplace negate correctly?
+    """
+    a = g.pt_neg()
+    g.pt_neg_inplace()
+    assert a == g
+
+    """
+    Does it save the result in the same memory location?
+    """
+    a = G.generator()
+    b = a
+    a.pt_neg_inplace()
+    assert id(b) == id(a)
+
+
+def test_ec_affine_inf():
+    G = EcGroup(713)
+    inf = G.infinite()
+
+    with pytest.raises(Exception) as excinfo:
+        inf.get_affine()
+    assert 'EC Infinity' in str(excinfo.value)
+
+
+def test_ec_bin_translation():
+    from timeit import default_timer as timer
+
+    G = EcGroup()
+    o = G.order()
+    g = G.generator()
+    pt1000 = [o.random() * g for _ in range(1000)]
+
+    exp = []
+    for pt in pt1000:
+        exp += [pt.export()]
+
+    t0 = timer()
+    for ept in exp:
+        EcPt.from_binary(ept, G)
+    t1 = timer()
+    print("\nParsed compressed Pt: %2.4f" % (t1 - t0))
+
+    exp = []
+    for pt in pt1000:
+        exp += [pt.export(POINT_CONVERSION_UNCOMPRESSED)]
+
+    t0 = timer()
+    for ept in exp:
+        EcPt.from_binary(ept, G)
+    t1 = timer()
+    print("\nParsed uncompressed Pt: %2.4f" % (t1 - t0))
+
+
+import platform
+
+
+@pytest.mark.xfail(platform.system() in ["Windows", "Darwin"],
+                   reason="No const time mult in Win / OS X OpenSSL")
+def test_p224_const_timing():
+    import time
+    print("Platform: " + platform.system())
+
+    # Note: NIST / SECG p224 is nid: 713/712 (p192 is nid:711)
+    G = EcGroup(713)
+    g = G.generator()
+    order = G.order()
+    h = order.random() * g
+
+    repreats = 100
+    t = []
+    for x in range(0, 200, 20):
+        o = Bn(2) ** x
+        tests = [o.random() for _ in range(repreats)]
+
+        t0 = time.clock()
+        for y in tests:
+            dud = y * h
+        t += [time.clock() - t0]
+        print(x, t[-1] / repreats)
+    assert abs(t[0] - t[-1]) < 5.0 / 100
+
+# pylint: enable=unused-variable

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/ecdsa.py

@@ -0,0 +1,250 @@
+""" A library providing signature and verification functions for the ECDSA scheme.
+
+Example:
+    How to use ``do_ecdsa_sign`` and ``do_ecdsa_verify`` to sign and verify a string:
+
+    >>> from hashlib import sha1
+    >>> # Generate a signature / verification key pair.
+    >>> G = EcGroup()
+    >>> sig_key = G.order().random()
+    >>> ver_key = sig_key * G.generator()
+    >>> # Hash the (potentially long) message into a short digest.
+    >>> digest = sha1(b"Hello World!").digest()
+    >>> # Sign and verify signature
+    >>> sig = do_ecdsa_sign(G, sig_key, digest)
+    >>> do_ecdsa_verify(G, ver_key, sig, digest)
+    True
+
+    Fast signatures can be constructed using ``do_ecdsa_setup``:
+
+    >>> from hashlib import sha1
+    >>> # Generate a signature / verification key pair.
+    >>> G = EcGroup()
+    >>> sig_key = G.order().random()
+    >>> ver_key = sig_key * G.generator()
+    >>> # Hash the (potentially long) message into a short digest.
+    >>> digest = sha1(b"Hello World!").digest()
+    >>> # Sign and verify signature
+    >>> kinv_rp = do_ecdsa_setup(G, sig_key)
+    >>> sig = do_ecdsa_sign(G, sig_key, digest, kinv_rp = kinv_rp)
+    >>> do_ecdsa_verify(G, ver_key, sig, digest)
+    True
+
+"""
+
+
+from .bindings import _FFI, _C, _OPENSSL_VERSION, OpenSSLVersion
+
+from .ec import EcGroup, _check
+from .bn import Bn, get_ctx
+
+
+def do_ecdsa_setup(G, priv):
+    """Compute the parameters kinv and rp to (optionally) speed up ECDSA signing."""
+
+    ec_key = _C.EC_KEY_new()
+    _check(_C.EC_KEY_set_group(ec_key, G.ecg))
+    _check(_C.EC_KEY_set_private_key(ec_key, priv.bn))
+
+    ptr_kinv = _FFI.new("BIGNUM **")
+    ptr_rp = _FFI.new("BIGNUM **")
+
+    _check(_C.ECDSA_sign_setup(ec_key, get_ctx().bnctx, ptr_kinv, ptr_rp))
+
+    kinv = Bn()
+    _C.BN_copy(kinv.bn, ptr_kinv[0])
+    _C.BN_clear_free(ptr_kinv[0])
+
+    rp = Bn()
+    _C.BN_copy(rp.bn, ptr_rp[0])
+    _C.BN_clear_free(ptr_rp[0])
+
+    return kinv, rp
+
+
+def do_ecdsa_sign(G, priv, data, kinv_rp=None):
+    """A quick function to ECDSA sign a hash.
+
+    Args:
+        G (EcGroup): the group in which math is done.
+        priv (Bn): the secret key.
+        data (str): the string to sign.
+        kinv_rp (opaque): optional setup parameters.
+
+    Returns:
+        Bn, Bn: The (r, s) signature
+
+    """
+    ec_key = _C.EC_KEY_new()
+    _check(_C.EC_KEY_set_group(ec_key, G.ecg))
+    _check(_C.EC_KEY_set_private_key(ec_key, priv.bn))
+    # _check( _C.EC_KEY_precompute_mult(ec_key, _FFI.NULL) )
+
+    if kinv_rp is None:
+        ecdsa_sig = _C.ECDSA_do_sign(data, len(data), ec_key)
+
+    else:
+        kinv, rp = kinv_rp
+        ecdsa_sig = _C.ECDSA_do_sign_ex(
+            data, len(data), kinv.bn, rp.bn, ec_key)
+
+    r = Bn()
+    s = Bn()
+
+    if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+        _C.BN_copy(r.bn, ecdsa_sig.r)
+        _C.BN_copy(s.bn, ecdsa_sig.s)
+    else:
+        rptr = _FFI.new("BIGNUM **")
+        sptr = _FFI.new("BIGNUM **")
+
+        _C.ECDSA_SIG_get0(ecdsa_sig, rptr, sptr)
+        _C.BN_copy(r.bn, rptr[0])
+        _C.BN_copy(s.bn, sptr[0])
+
+    _C.ECDSA_SIG_free(ecdsa_sig)
+    _C.EC_KEY_free(ec_key)
+
+    return (r, s)
+
+
+def do_ecdsa_verify(G, pub, sig, data):
+    """A quick function to ECDSA verify a hash.
+
+    Args:
+        G (EcGroup): the group in which math is done.
+        pub (EcPt): the secret key
+        sig (Bn, Bn): the (r,s) signature
+        data (str): the string to sign
+
+    Returns:
+        bool: A Boolean indicating whether the signature verifies.
+    """
+
+    r, s = sig
+
+    ec_key = _C.EC_KEY_new()
+    _check(_C.EC_KEY_set_group(ec_key, G.ecg))
+    _check(_C.EC_KEY_set_public_key(ec_key, pub.pt))
+    _check(_C.EC_KEY_precompute_mult(ec_key, get_ctx().bnctx))
+
+    ec_sig = _C.ECDSA_SIG_new()
+
+    if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+        _C.BN_copy(ec_sig.r, r.bn)
+        _C.BN_copy(ec_sig.s, s.bn)
+    else:
+        _check(_C.ECDSA_SIG_set0_petlib(ec_sig, r.bn, s.bn))
+
+    try:
+        result = int(_C.ECDSA_do_verify(data, len(data), ec_sig, ec_key))
+        if result == -1:
+            raise Exception("ECDSA Error")
+
+    finally:
+        _C.EC_KEY_free(ec_key)
+        _C.ECDSA_SIG_free(ec_sig)
+
+    return bool(result)
+
+
+def get_ecdsa_keys(G, sig, data):
+    """ Returns the two possible public keys corresponding to this signature.
+
+    Args:
+        G (EcGroup): the group in which math is done.
+        data (str): the string to sign
+        sign (Bn, Bn): the (r,s) signature
+
+    Returns:
+        pub1, pub2: The two candidate public keys
+
+    """
+
+    (r, s) = sig
+    g = G.generator()
+    R1, R2 = G.get_points_from_x(r)
+
+    r_inv = r.mod_inverse(G.order())
+    z = Bn.from_binary(data)
+
+    if not (0 < z < G.order()):
+        raise Exception("Digest too long")
+
+    K1 = r_inv * (s * R1 - z * g)
+    K2 = r_inv * (s * R2 - z * g)
+
+    return K1, K2
+
+
+def test_ecdsa():
+    G = EcGroup()
+    priv = G.order().random()
+    g = G.generator()
+    sig = do_ecdsa_sign(G, priv, b"Hello")
+    assert do_ecdsa_verify(G, priv * g, sig, b"Hello")
+
+
+def test_get_ecdsa_keys():
+    G = EcGroup()
+    g = G.generator()
+
+    priv = G.order().random()
+    pub = priv * g
+
+    sig = do_ecdsa_sign(G, priv, b"Hello")
+    assert do_ecdsa_verify(G, priv * g, sig, b"Hello")
+
+    pk1, pk2 = get_ecdsa_keys(G, sig, b"Hello")
+    assert pk1 == pub or pk2 == pub
+
+
+def test_ecdsa_fail():
+    G = EcGroup()
+    priv = G.order().random()
+    g = G.generator()
+    sig = do_ecdsa_sign(G, priv, b"Hello")
+
+    assert not do_ecdsa_verify(G, priv * g, sig, b"Hellx")
+
+
+def test_ecdsa_timing():
+    repreats = 1000
+
+    from hashlib import sha1
+    import time
+
+    G = EcGroup()
+    sig_key = G.order().random()
+    ver_key = sig_key * G.generator()
+
+    digest = sha1(b"Hello World!").digest()
+
+    print
+    t = []
+
+    x = "Sign. plain"
+    t0 = time.clock()
+    for y in range(repreats):
+        sig = do_ecdsa_sign(G, sig_key, digest)
+    t += [time.clock() - t0]
+
+    print("%s:\t%2.2f/sec" % (x, 1.0 / (float(t[-1]) / repreats)))
+
+    x = "Sign. with setup"
+    t0 = time.clock()
+    kinv_rp = do_ecdsa_setup(G, sig_key)
+    for y in range(repreats):
+        sig = do_ecdsa_sign(G, sig_key, digest, kinv_rp=kinv_rp)
+    t += [time.clock() - t0]
+
+    print("%s:\t%2.2f/sec" % (x, 1.0 / (float(t[-1]) / repreats)))
+
+    x = "Verification"
+    t0 = time.clock()
+    kinv_rp = do_ecdsa_setup(G, sig_key)
+    for y in range(repreats):
+        do_ecdsa_verify(G, ver_key, sig, digest)
+    t += [time.clock() - t0]
+
+    print("%s:\t%2.2f/sec" % (x, 1.0 / (float(t[-1]) / repreats)))

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/hmac.py

@@ -0,0 +1,177 @@
+from .bindings import _FFI, _C, _OPENSSL_VERSION, OpenSSLVersion
+
+from binascii import hexlify
+
+import pytest
+
+
+def _check(return_val):
+    """Checks the return code of the C calls"""
+    if isinstance(return_val, int) and return_val == 1:
+        return
+    if isinstance(return_val, bool) and return_val == True:
+        return
+
+    raise Exception("HMAC exception")
+
+
+def secure_compare(a1, a2):
+    """A constant-time comparison function. Returns True if the two strings are equal and False otherwise.
+
+    Args:
+        a1 (str): the first string
+        a2 (str): the second string
+
+    Returns:
+        bool: whether the two stings are equal.
+    """
+    _check(isinstance(a1, type(a2)))
+
+    if len(a1) != len(a2):
+        return False
+
+    x = _C.CRYPTO_memcmp(a1, a2, len(a1))
+    if int(x) == 0:
+        return True
+
+    return False
+
+
+class Hmac(object):
+    """Initialize the HMAC by name with a key.
+
+    Args:
+        name: the name of the hash function to be used.
+        key: the cryptographic symmetric key of the HMAC.
+
+    Returns:
+        An HMAC instance, ready to accept data to MAC.
+
+    Example:
+
+        >>> h = Hmac(b"sha512", b"Jefe")
+        >>> h.update(b"what do ya want ")
+        >>> h.update(b"for nothing?")
+        >>> d = h.digest()
+        >>> len(d)
+        64
+        >>> hexlify(d)[:10] == b"164b7a7bfc"
+        True
+
+    """
+
+    def __init__(self, name, key):
+        self.mac_ctx = None
+        md = _C.EVP_get_digestbyname(name)
+        if md == _FFI.NULL:
+            raise Exception("HMAC Error loading function %s" % name)
+
+        self.outsize = _C.EVP_MD_size(md)
+        if _OPENSSL_VERSION == OpenSSLVersion.V1_0:
+            self.mac_ctx = _FFI.new("HMAC_CTX *")
+            _C.HMAC_CTX_init(self.mac_ctx)
+        else:
+            self.mac_ctx = _C.HMAC_CTX_new()
+
+        _check(_C.HMAC_Init_ex(self.mac_ctx, key, len(key), md, _FFI.NULL))
+        self.active = True
+
+    def update(self, data):
+        """Update the HMAC with some data to authenticate.
+
+        Args:
+            data: the data to add to the MAC.
+
+        Note: you must not call update after you finalize the HMAC.
+
+        Raises:
+            Exception: if called after the HMAC has been finalized.
+        """
+        if not self.active:
+            raise Exception("HMAC already finalized!")
+        _check(_C.HMAC_Update(self.mac_ctx, data, len(data)))
+
+    def digest(self):
+        """Output the HMAC digest as a binary string.
+
+        Returns:
+            The digest as a binary data string.
+        """
+        if not self.active:
+            raise Exception("HMAC already finalized!")
+
+        self.active = False
+        out_md = _FFI.new("unsigned char[]", self.outsize)
+        out_len = _FFI.new("unsigned int *")
+        _check(_C.HMAC_Final(self.mac_ctx, out_md, out_len))
+
+        if int(out_len[0]) != self.outsize:
+            raise Exception("HMAC Unexpected length")
+
+        return bytes(_FFI.buffer(out_md)[:])
+
+    def __del__(self):
+        if self.mac_ctx is not None and _OPENSSL_VERSION == OpenSSLVersion.V1_1:
+            _C.HMAC_CTX_free(self.mac_ctx)
+
+
+def test_init():
+    h = Hmac(b"md5", b"Hello")
+    h.update(b"hello")
+    d = h.digest()
+    assert d
+    assert len(d) == 128 / 8
+
+
+def test_vectors():
+    """
+    Key =          4a656665                          ("Jefe")
+   Data =         7768617420646f2079612077616e7420  ("what do ya want ")
+                  666f72206e6f7468696e673f          ("for nothing?")
+
+   HMAC-SHA-224 = a30e01098bc6dbbf45690f3a7e9e6d0f
+                  8bbea2a39e6148008fd05e44
+   HMAC-SHA-256 = 5bdcc146bf60754e6a042426089575c7
+                  5a003f089d2739839dec58b964ec3843
+   HMAC-SHA-384 = af45d2e376484031617f78d2b58a6b1b
+                  9c7ef464f5a01b47e42ec3736322445e
+                  8e2240ca5e69e2c78b3239ecfab21649
+   HMAC-SHA-512 = 164b7a7bfcf819e2e395fbe73b56e0a3
+                  87bd64222e831fd610270cd7ea250554
+                  9758bf75c05a994a6d034f65f8f0e6fd
+                  caeab1a34d4a6b4b636e070a38bce737
+    """
+
+    h = Hmac(b"sha512", b"Jefe")
+    assert 512 / 8 == h.outsize
+    h.update(b"what do ya want ")
+    h.update(b"for nothing?")
+    d = h.digest()
+
+    with pytest.raises(Exception) as excinfo:
+        h.update(b"some more")
+    assert 'finalized' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        h.digest()
+    assert 'finalized' in str(excinfo.value)
+
+    with pytest.raises(Exception) as excinfo:
+        h = Hmac(b"sha999", b"Jefe")
+    assert 'Error' in str(excinfo.value)
+
+    ans1 = hexlify(d)
+    ans2 = b"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
+
+    assert len(ans1) == len(ans2)
+    assert ans1 == ans2
+
+
+def test_cmp():
+    assert secure_compare(b"Hello", b"Hello")
+    assert not secure_compare(b"Hello", b"Hellx")
+    assert not secure_compare(b"Hello", b"Hell")
+
+    with pytest.raises(Exception) as excinfo:
+        assert not secure_compare(b"Hello", 2)
+    assert 'HMAC' in str(excinfo.value)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/pack.py

@@ -0,0 +1,318 @@
+"""The module provides functions to pack and unpack petlib Bn, EcGroup, and EcPt
+strucures.
+
+Example:
+    >>> # Define a custom class, encoder and decoder
+    >>> class CustomType:
+    ...     def __eq__(self, other):
+    ...         return isinstance(other, CustomType)
+    >>>
+    >>> def enc_custom(obj):
+    ...     return b''
+    >>>
+    >>> def dec_custom(data):
+    ...     return CustomType()
+    >>>
+    >>> register_coders(CustomType, 10, enc_custom, dec_custom)
+    >>>
+    >>> # Define a structure
+    >>> G = EcGroup()
+    >>> custom_obj = CustomType()
+    >>> test_data = [G, G.generator(), G.order(), custom_obj]
+    >>>
+    >>> # Encode and decode custom structure
+    >>> packed = encode(test_data)
+    >>> x = decode(packed)
+    >>> assert x == test_data
+
+"""
+
+import msgpack
+
+from .ec import EcGroup, EcPt
+from .bn import Bn
+
+__all__ = ["encode", "decode", "register_coders"]
+
+_pack_reg = {}
+_unpack_reg = {}
+
+
+def register_coders(cls, num, enc_func, dec_func):
+    """ Register a new type for encoding and decoding.
+    Take a class type, a number, an encoding and a decoding function."""
+
+    if num in _unpack_reg or cls in _pack_reg:
+        raise Exception("Class or number already in use.")
+
+    coders = (cls, num, enc_func, dec_func)
+    _pack_reg[cls] = coders
+    _unpack_reg[num] = coders
+
+
+def bn_enc(obj):
+    if obj < 0:
+        neg = b"-"
+        data = (-obj).binary()
+    else:
+        neg = b"+"
+        data = obj.binary()
+    return neg + data
+
+
+def bn_dec(data):
+    num = Bn.from_binary(data[1:])
+    # Accomodate both Python 2 and Python 3
+    if data[0] == ord("-") or data[0] == "-":
+        return -num
+    return num
+
+
+def ecg_enc(obj):
+    # Serialize EcGroup objects
+    nid = obj.nid()
+    packed_nid = msgpack.packb(nid)
+    return packed_nid
+
+
+def ecg_dec(data):
+    # Decode EcGroup
+    nid = msgpack.unpackb(data)
+    return EcGroup(nid)
+
+
+def ecpt_enc(obj):
+    # Serialize EcPt objects
+    nid = obj.group.nid()
+    data = obj.export()
+    packed_data = msgpack.packb((nid, data))
+    return packed_data
+
+
+def ecpt_dec(data):
+    # Decode EcPt
+    nid, ptdata = msgpack.unpackb(data)
+    return EcPt.from_binary(ptdata, EcGroup(nid))
+
+
+def _init_coders():
+    global _pack_reg, _unpack_reg
+    _pack_reg, _unpack_reg = {}, {}
+    register_coders(Bn, 0, bn_enc, bn_dec)
+    register_coders(EcGroup, 1, ecg_enc, ecg_dec)
+    register_coders(EcPt, 2, ecpt_enc, ecpt_dec)
+
+
+# Register default coders
+_init_coders()
+
+
+def default(obj):
+    # Serialize Bn objects
+    for T in _pack_reg:
+        if isinstance(obj, T):
+            _, num, enc, _ = _pack_reg[T]
+            return msgpack.ExtType(num, enc(obj))
+
+    raise TypeError("Unknown type: %r" % (type(obj),))
+
+
+def make_encoder(out_encoder=None):
+    if out_encoder is None:
+        return default
+    else:
+        def new_encoder(obj):
+            try:
+                encoded = default(obj)
+                return encoded
+            except BaseException:
+                return out_encoder(obj)
+        return new_encoder
+
+
+def ext_hook(code, data):
+    if code in _unpack_reg:
+        _, _, _, dec = _unpack_reg[code]
+        return dec(data)
+
+    # Other
+    return msgpack.ExtType(code, data)
+
+
+def make_decoder(custom_decoder=None):
+    if custom_decoder is None:
+        return ext_hook
+    else:
+        def new_decoder(code, data):
+            out = ext_hook(code, data)
+            if not isinstance(out, msgpack.ExtType):
+                return out
+            else:
+                return custom_decoder(code, data)
+        return new_decoder
+
+
+def encode(structure, custom_encoder=None):
+    """ Encode a structure containing petlib objects to a binary format. May define a custom encoder for user classes. """
+    encoder = make_encoder(custom_encoder)
+    packed_data = msgpack.packb(structure, default=encoder, use_bin_type=True)
+    return packed_data
+
+
+def decode(packed_data, custom_decoder=None):
+    """ Decode a binary byte sequence into a structure containing pelib objects. May define a custom decoder for custom classes. """
+    decoder = make_decoder(custom_decoder)
+    structure = msgpack.unpackb(
+        packed_data,
+        ext_hook=decoder,
+        encoding='utf-8')
+    return structure
+
+# --- TESTS ---
+
+
+def test_basic():
+    x = [b'spam', u'egg']
+    packed = msgpack.packb(x, use_bin_type=True)
+    y = msgpack.unpackb(packed, encoding='utf-8')
+    assert x == y
+
+
+def test_bn():
+    bn1, bn2 = Bn(1), Bn(2)
+    test_data = [bn1, bn2, -bn1, -bn2]
+    packed = msgpack.packb(test_data, default=default, use_bin_type=True)
+    x = msgpack.unpackb(packed, ext_hook=ext_hook, encoding='utf-8')
+    assert x == test_data
+
+
+def test_ecgroup():
+    G = EcGroup()
+    test_data = [G]
+    packed = msgpack.packb(test_data, default=default, use_bin_type=True)
+    x = msgpack.unpackb(packed, ext_hook=ext_hook, encoding='utf-8')
+    assert x == test_data
+
+
+def test_ecpt():
+    G = EcGroup()
+    test_data = [G.generator()]
+    packed = msgpack.packb(test_data, default=default, use_bin_type=True)
+    x = msgpack.unpackb(packed, ext_hook=ext_hook, encoding='utf-8')
+    assert x == test_data
+
+
+def test_mixed():
+    G = EcGroup()
+    test_data = [G, G.generator(), G.order()]
+    packed = msgpack.packb(test_data, default=default, use_bin_type=True)
+    x = msgpack.unpackb(packed, ext_hook=ext_hook, encoding='utf-8')
+    assert x == test_data
+
+
+def test_enc_dec():
+    G = EcGroup()
+    test_data = [G, G.generator(), G.order()]
+    packed = encode(test_data)
+    x = decode(packed)
+    assert x == test_data
+
+
+def test_enc_dec_dict():
+    G = EcGroup()
+    # , G.generator():"1", "2":G.order()}
+    test_data = {G.order(): [G, G.generator()]}
+    packed = encode(test_data)
+    x = decode(packed)
+    assert x[G.order()] == test_data[G.order()]
+
+
+def test_enc_dec_custom():
+
+    # Define a custom class, encoder and decoder
+    class CustomClass:
+        def __eq__(self, other):
+            return isinstance(other, CustomClass)
+
+    def enc_CustomClass(obj):
+        if isinstance(obj, CustomClass):
+            return msgpack.ExtType(11, b'')
+        raise TypeError("Unknown type: %r" % (obj,))
+
+    def dec_CustomClass(code, data):
+        if code == 11:
+            return CustomClass()
+
+        return msgpack.ExtType(code, data)
+
+    # Define a structure
+    G = EcGroup()
+    custom_obj = CustomClass()
+    test_data = [G, G.generator(), G.order(), custom_obj]
+
+    # Encode and decode custom structure
+    packed = encode(test_data, enc_CustomClass)
+    x = decode(packed, dec_CustomClass)
+    assert x == test_data
+
+
+def test_streaming():
+
+    # Define a custom class, encoder and decoder
+    class CustomClass2:
+        def __eq__(self, other):
+            return isinstance(other, CustomClass2)
+
+    def enc_CustomClass(obj):
+        if isinstance(obj, CustomClass2):
+            return msgpack.ExtType(12, b'')
+        raise TypeError("Unknown type: %r" % (obj,))
+
+    def dec_CustomClass(code, data):
+        if code == 12:
+            return CustomClass2()
+
+        return msgpack.ExtType(code, data)
+
+    # Define a structure
+    G = EcGroup()
+    custom_obj = CustomClass2()
+    test_data = [G, G.generator(), G.order(), custom_obj]
+    packed1 = encode(test_data, enc_CustomClass)
+    packed2 = encode(test_data, enc_CustomClass)
+
+    data = packed1 + packed2
+
+    decoder = make_decoder(dec_CustomClass)
+    Up = msgpack.Unpacker(ext_hook=decoder)
+    Up.feed(data)
+    for o in Up:
+        assert o == test_data
+
+
+def test_docstring():
+    # Define a custom class, encoder and decoder
+    class CustomType:
+        def __eq__(self, other):
+            return isinstance(other, CustomType)
+
+    def enc_custom(obj):
+        return b''
+
+    def dec_custom(data):
+        return CustomType()
+
+    _init_coders()
+    register_coders(CustomType, 14, enc_custom, dec_custom)
+    assert CustomType in _pack_reg
+
+    # Define a structure
+    G = EcGroup()
+    custom_obj = CustomType()
+    test_data = [G, G.generator(), G.order(), custom_obj]
+
+    # Encode and decode custom structure
+    packed = encode(test_data)
+    x = decode(packed)
+    assert x == test_data
+    _init_coders()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytest-4.6.5.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.4)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+