0

{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Use Fuzzing Book Resources\n", "\n", "Clone the [Fuzzing Book](https://www.fuzzingbook.org/) repository and put this notebook under the directory `fuzzingbook/notebooks/`. Then you can use the fuzzing book resources in this notebook." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'f9e386d0a19f8b21a36a63a167c434dc'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import bookutils\n", "from typing import List, Tuple, Dict, Any\n", "from Fuzzer import RandomFuzzer\n", "from html.parser import HTMLParser\n", "from Coverage import Coverage\n", "import pickle\n", "import hashlib\n", "\n", "# Create simple fuzzer\n", "fuzzer = RandomFuzzer(\n", " min_length=1, max_length=100, char_start=32, char_range=94\n", ")\n", "\n", "\n", "# Create simple program-under-test\n", "def my_parser(inp: str) -> None:\n", " parser = HTMLParser()\n", " parser.feed(inp)\n", "\n", "\n", "def getTraceHash(cov: Coverage) -> str:\n", " pickledCov = pickle.dumps(cov.coverage())\n", " hashedCov = hashlib.md5(pickledCov).hexdigest()\n", " return hashedCov\n", "\n", "\n", "# Every program path is a color\n", "inp = \"\"\n", "\n", "with Coverage() as cov:\n", " my_parser(inp)\n", "getTraceHash(cov)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# **The rarity differs for different coverage**" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Use the fuzzer to create a population" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['\"N&+slk%hyp5o\\'@[3(rW*M5W]tMFPU4\\\\P@tz%[X?uo\\\\1?b4T;1bDeYtHx #UJ5w}pMmPodJM,_%%',\n", " 'CdYN6*g|Y*Ou9I:\\\\=V" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "num_unique = len(all_coverage_dict)\n", "print(f\"Number of unique traces: {num_unique}\")\n", "print(\n", " f\"Top 3 frequencies: {sorted(list(all_coverage_dict.values()), reverse=True)[:3]}\"\n", ")\n", "print(f\"Bottom 3 frequencies: {sorted(list(all_coverage_dict.values()))[:3]}\")\n", "freqs = sorted(list(all_coverage_dict.values()), reverse=True)\n", "# print bar chart of the frequencies\n", "fig, ax = plt.subplots()\n", "sns.barplot(x=list(range(len(freqs))), y=freqs, ax=ax)\n", "# remove the x labels\n", "ax.set_xticks([])\n", "# set log-scale for y-axis\n", "ax.set_yscale(\"log\")\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Some Definitions\n", "\n", "- Singletons: colors that appear only once in the sample\n", "- Doubletons: colors that appear twice in the sample\n", "\n", "$$\n", "\\Phi_k = \\text{the number of colors that appear $k$ times in the sample}\n", "$$\n", "\n", "- $\\Phi_1$ = the number of singletons, $\\Phi_2$ = the number of doubletons, etc." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The number of coverage elements seen exactly once is 216\n", "The number of coverage elements seen exactly twice is 77\n" ] } ], "source": [ "# TODO: Compute the singletons and doubletons\n", "\n", "############# IMPLEMENT HERE #############\n", "singletons = {k: v for k, v in all_coverage_dict.items() if v == 1}\n", "doubletons = {k: v for k, v in all_coverage_dict.items() if v == 2}\n", "##########################################\n", "\n", "print(\n", " \"The number of coverage elements seen exactly once is \"\n", " + str(len(singletons))\n", ")\n", "print(\n", " \"The number of coverage elements seen exactly twice is \"\n", " + str(len(doubletons))\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***💡 Go back to the slides***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# **Missing Mass**: What is the probability that the next generated input increases coverage?" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Estimating the propobability of generating a coverage-increasing input\n", "\n", "- **Good-Turing** estimator:\n", "$$\n", "\\hat{M_0} = \\frac{\\Phi_1}{n}\n", "$$" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The probability that the next input increases coverage is estimated as 0.00432\n" ] } ], "source": [ "# TODO: Implement the Good-Turing estimator\n", "\n", "############# IMPLEMENT HERE #############\n", "estimate = len(singletons) / trials\n", "##########################################\n", "\n", "print(\n", " \"The probability that the next input increases coverage is estimated as \"\n", " + str(estimate)\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### How do we evaluate this?" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The probability that the next input increases coverage is empirically 0.00414\n" ] } ], "source": [ "# TODO: Evaluate the estimator empirically\n", "\n", "############# IMPLEMENT HERE #############\n", "curr_coverage = all_coverage_dict.keys()\n", "\n", "count = 0\n", "validation = []\n", "for i in range(trials): # sample the same number of inputs as in the population\n", " validation.append(fuzzer.fuzz())\n", "\n", "for inp in validation:\n", " with Coverage() as cov:\n", " try:\n", " my_parser(inp)\n", " except BaseException:\n", " pass\n", " this_coverage = set([getTraceHash(cov)])\n", " if len(curr_coverage & this_coverage) == 0:\n", " count = count + 1\n", "\n", "empirical = count / trials\n", "##########################################\n", "\n", "print(\n", " \"The probability that the next input increases coverage is empirically \"\n", " + str(empirical)\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Why does Good-Turing work so well?\n", "\n", "Intuitive explanation: \"if you observe a new thing at this round, it becomes one of the singletons at the next round.\"\n", "\n", "***💡 Go back to the slides for a little bit deeper explanation :)***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# **Species Richness**: What is the maximum coverage we can achieve?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The estimate of the lower bound of the remaining coverage is\n", "$$\n", "\\frac{n - 1}{n}\\frac{(\\Phi_1)^2}{2\\Phi_2}\n", "$$" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The lower bound of the number of coverages that are still unexplored is 302\n" ] } ], "source": [ "# TODO: Estimate the Species Richness\n", "\n", "############# IMPLEMENT HERE #############\n", "estimate = int(\n", " (trials - 1) / trials * (len(singletons) ** 2) / (2 * len(doubletons))\n", ")\n", "##########################################\n", "\n", "print(\n", " f\"The lower bound of the number of coverages that are still unexplored is {estimate}\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### How do we evaluate this?\n", "\n", "Let's try to run the fuzzer much longer and see if we can reach the estimate." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processed 100000 inputs / 100000\n", "Number of new coverages: 275\n" ] } ], "source": [ "# TODO: Evaluate the estimator by empirically observing \n", "# the number of new coverages for a large number of inputs\n", "\n", "############# IMPLEMENT HERE #############\n", "extra_trials = trials * 2\n", "validation = []\n", "for i in range(extra_trials):\n", " validation.append(fuzzer.fuzz())\n", "\n", "extra_coverage = set()\n", "for idx, inp in enumerate(validation, 1):\n", " if idx % trials == 0:\n", " print(f\"Processed {idx} inputs / {extra_trials}\", end=\"\\r\", flush=True)\n", " with Coverage() as cov:\n", " try:\n", " my_parser(inp)\n", " except BaseException:\n", " pass\n", " cov_hash = set([getTraceHash(cov)])\n", " extra_coverage |= cov_hash\n", "print()\n", "extra_coverage -= curr_coverage\n", "##########################################\n", "\n", "print(f\"Number of new coverages: {len(extra_coverage)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***💡 Go back to the slides***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# **Extrapolation**: How much can I discover more when I spend $X$ more time here?\n", "\n", "- $\\Delta(m)$: the number of new discoveries when $m$ more samples are retrieved.\n", "\n", "$$\n", "\\hat \\Delta(m) = \\hat \\Phi_0 \\left[1 - \\left(1 - \\frac{\\Phi_1}{n\\hat \\Phi_0 + \\Phi_1} \\right)^m\\right]\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Show the coverage increase with the number of samples.\n", "\n", "- Compute the cumulative coverage of the population with size 200,000 + (additional) 200,000\n", "- Extrapolate the number of unique coverage from the point where we have 200,000 samples." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "############################################################\n", "# First 200,000 inputs\n", "############################################################\n", "trials = 200000\n", "population = []\n", "for i in range(trials):\n", " population.append(fuzzer.fuzz())\n", "\n", "cumulative_coverage = []\n", "all_coverage = set()\n", "singletons = set() # Store the number of singletons \n", "doubletons = set() # and doubletons for the extrapolation\n", "\n", "for inp in population:\n", " with Coverage() as cov:\n", " try:\n", " my_parser(inp)\n", " except BaseException:\n", " pass\n", " this_coverage = set([getTraceHash(cov)])\n", " doubletons -= this_coverage\n", " doubletons |= singletons & this_coverage\n", " singletons -= this_coverage\n", " singletons |= this_coverage - all_coverage\n", " all_coverage |= this_coverage\n", " cumulative_coverage.append(len(all_coverage))\n", "\n", "num_singletons = len(singletons)\n", "num_doubletons = len(doubletons)\n", "\n", "############################################################\n", "# Additional 200,000 inputs\n", "############################################################\n", "extra_trials = 200000\n", "validation = []\n", "for i in range(extra_trials):\n", " validation.append(fuzzer.fuzz())\n", "\n", "for inp in validation:\n", " with Coverage() as cov:\n", " try:\n", " my_parser(inp)\n", " except BaseException:\n", " pass\n", " this_coverage = set([getTraceHash(cov)])\n", " all_coverage |= this_coverage\n", " cumulative_coverage.append(len(all_coverage))\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "coverage_ateach_1000trial = [0] + cumulative_coverage[\n", " 999::1000\n", "] # for every 1000 trials\n", "sub_coverage_until_half = coverage_ateach_1000trial[:201]\n", "sns.lineplot(\n", " x=range(0, 200001, 1000),\n", " y=sub_coverage_until_half,\n", " ax=ax,\n", ")\n", "ax.set_xlim(0, 400000)\n", "ax.set_ylim(0, cumulative_coverage[-1])\n", "ax.set_xticks([0, 100000, 200000, 300000, 400000])\n", "ax.set_xlabel(\"Number of inputs\")\n", "ax.set_ylabel(\"Number of unique coverages\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "sns.lineplot(\n", " x=range(0, 400001, 1000),\n", " y=coverage_ateach_1000trial,\n", " ax=ax,\n", ")\n", "ax.set_xlabel(\"Number of inputs\")\n", "ax.set_ylabel(\"Number of unique coverages\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## formula:\n", "## - \\Phi_0 = (n - 1) / n * (\\Phi_1^2 / (2 \\Phi_2))\n", "## - \\Delta(m) = \\Phi_0 [1 - (1 - \\Phi_1/(n \\Phi_0 + \\Phi_1) )^m ]\n", "\n", "############# IMPLEMENT HERE #############\n", "phi1 = num_singletons\n", "phi2 = num_doubletons\n", "phi0 = (trials - 1) / trials * (phi1**2 / (2 * phi2))\n", "extrapolator = lambda m: phi0 * (1 - (1 - phi1 / (trials * phi0 + phi1)) ** m)\n", "\n", "extrapolated = [extrapolator(i) for i in range(1, 200001)]\n", "extrapolated = [delta + sub_coverage_until_half[-1] for delta in extrapolated]\n", "##########################################\n", "\n", "fig, ax = plt.subplots()\n", "sns.lineplot(\n", " x=range(0, 200001, 1000),\n", " y=sub_coverage_until_half,\n", " ax=ax,\n", " color=\"black\",\n", ")\n", "sns.lineplot(\n", " x=range(201000, 400001, 1000),\n", " y=extrapolated[999::1000],\n", " ax=ax,\n", " color=\"blue\",\n", " dashes=True,\n", ")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", "\n", "# 1.\n", "sns.lineplot(\n", " x=range(0, 200001, 1000),\n", " y=sub_coverage_until_half,\n", " ax=axes[0],\n", ")\n", "axes[0].set_xlim(0, 400000)\n", "axes[0].set_ylim(0, cumulative_coverage[-1])\n", "axes[0].set_xticks([0, 100000, 200000, 300000, 400000])\n", "axes[0].set_xlabel(\"Number of inputs\")\n", "axes[0].set_ylabel(\"Number of unique coverages\")\n", "\n", "# 2.\n", "sns.lineplot(\n", " x=range(0, 400001, 1000),\n", " y=coverage_ateach_1000trial,\n", " ax=axes[1],\n", ")\n", "axes[1].set_xlabel(\"Number of inputs\")\n", "axes[1].set_ylabel(\"Number of unique coverages\")\n", "\n", "# 3.\n", "sns.lineplot(\n", " x=range(0, 200001, 1000),\n", " y=sub_coverage_until_half,\n", " ax=axes[2],\n", " color=\"black\",\n", ")\n", "sns.lineplot(\n", " x=range(201000, 400001, 1000),\n", " y=extrapolated[999::1000],\n", " ax=axes[2],\n", " color=\"blue\",\n", " dashes=True,\n", ")\n", "sns.lineplot(\n", " x=range(201000, 400001, 1000),\n", " y=coverage_ateach_1000trial[201:],\n", " ax=axes[2],\n", " color=\"red\",\n", ")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***💡 Go back to the slides***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# **Reaching Probability**: What is the probability of reaching a specific program element?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Let's consider an example of the control flow graph of a program.\n", "\n", "Starting from small one with five statements." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Min prob: 0.00614593848538574 at node 3\n" ] } ], "source": [ "from bn import SimpleBN\n", "import numpy as np\n", "\n", "np.random.seed(0)\n", "sbn = SimpleBN(5)\n", "display(sbn.draw())\n", "min_prob = min(sbn.reach_prob_dict.values())\n", "min_nidx = min(sbn.reach_prob_dict, key=sbn.reach_prob_dict.get)\n", "print(f\"Min prob: {min_prob} at node {min_nidx}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Of course, there's some issue with using the bayesian network for CFGs.\n", "- Using the bayesian network for CFGs means the branch conditions are independent.\n", "- Which is not true in general.\n", " \n", "But, it's a fair approximation for the exercises :)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Edge list:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{0: (0, 1), 1: (0, 4), 2: (1, 2), 3: (1, 4), 4: (2, 3), 5: (2, 4), 6: (3, 4)}" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(sbn.edgeidx2edge)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Generate execution" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 0, 0, 0, 0, 0], dtype=int8)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sbn.gen_obss(1)[0]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 0, 0, 0, 0, 0],\n", " [1, 0, 1, 0, 0, 1, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [1, 0, 0, 1, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [1, 0, 0, 1, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0]], dtype=int8)" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "array([[1, 0, 0, 0, 1],\n", " [1, 1, 1, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 1, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 1, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1],\n", " [1, 0, 0, 0, 1]], dtype=int8)" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "array([0, 1, 2, 4])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "edge_cov = sbn.gen_obss(20)\n", "display(edge_cov)\n", "\n", "node_cov = sbn.edgecov2nodecov(edge_cov)\n", "display(node_cov)\n", "\n", "covered_nodes = np.logical_or.reduce(node_cov, 0).astype(np.int8)\n", "covered_node_idxs = np.nonzero(covered_nodes)[0]\n", "display(covered_node_idxs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's consider a little bit bigger program." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Min prob: 1.8651992743955428e-07 at node 21\n" ] } ], "source": [ "sbn = SimpleBN(30)\n", "display(sbn.draw())\n", "min_prob = min(sbn.reach_prob_dict.values())\n", "min_nidx = min(sbn.reach_prob_dict, key=sbn.reach_prob_dict.get)\n", "print(f\"Min prob: {min_prob} at node {min_nidx}\")\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Coverage frequencies:\n" ] }, { "data": { "text/plain": [ "{0: 1000,\n", " 1: 651,\n", " 2: 603,\n", " 3: 349,\n", " 4: 48,\n", " 5: 300,\n", " 6: 45,\n", " 7: 3,\n", " 8: 124,\n", " 9: 5,\n", " 10: 1,\n", " 11: 49,\n", " 12: 0,\n", " 13: 8,\n", " 14: 37,\n", " 15: 0,\n", " 16: 3,\n", " 17: 8,\n", " 18: 7,\n", " 19: 46,\n", " 20: 0,\n", " 21: 0,\n", " 22: 490,\n", " 23: 0,\n", " 24: 46,\n", " 25: 38,\n", " 26: 121,\n", " 27: 492,\n", " 28: 309,\n", " 29: 40}" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Uncovered nodes: [12, 15, 20, 21, 23]\n", "Pr(12) = 4.8272237587007876e-05\n", "Pr(15) = 4.660665704523967e-06\n", "Pr(20) = 6.127973733909666e-07\n", "Pr(21) = 1.8651992743955428e-07\n", "Pr(23) = 4.262774459514123e-07\n" ] } ], "source": [ "num_exec = 1000\n", "edge_cov = sbn.gen_obss(num_exec)\n", "node_cov = sbn.edgecov2nodecov(edge_cov)\n", "coverage_freq = np.sum(node_cov, 0)\n", "coverage_freq_dict = {i: coverage_freq[i] for i in range(len(coverage_freq))}\n", "print(\"Coverage frequencies:\")\n", "display(coverage_freq_dict)\n", "covered_nodes = coverage_freq > 0\n", "covered_node_idxs = set(np.nonzero(covered_nodes)[0])\n", "uncovered_node_idxs = set(np.nonzero(1 - covered_nodes)[0])\n", "print(\"Uncovered nodes:\", sorted(uncovered_node_idxs))\n", "for node_idx in sorted(uncovered_node_idxs):\n", " print(f\"Pr({node_idx}) = {sbn.reach_prob_dict[node_idx]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Blackbox estimation" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated Laplace: 0.00199203187250996\n", "Estimated Good-Turing: 0.004\n" ] } ], "source": [ "# Laplace estimator\n", "alpha = 2\n", "esti_laplace = 2 / (num_exec + 4)\n", "\n", "# Good-Turing estimator\n", "edge_cov_str = [\"\".join(map(str, row)) for row in edge_cov]\n", "edge_cov_freq = {edge: edge_cov_str.count(edge) for edge in set(edge_cov_str)}\n", "singletons = {k: v for k, v in edge_cov_freq.items() if v == 1}\n", "est_goodturing = len(singletons) / num_exec\n", "\n", "print(f\"Estimated Laplace: {esti_laplace}\")\n", "print(f\"Estimated Good-Turing: {est_goodturing}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Structure-aware estimation\n", "\n", "For each uncovered statement,\n", "1. find the set of closest reached statements\n", "2. for each of them\n", " 1. find the set of paths from the closest reached statement to the uncovered statement only through the uncovered statements\n", " 2. compute the probability through the paths\n", "3. sum the probabilities" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Node 12 is uncovered.\n", "Ancestor nodes: {0, 1, 4, 7, 10, 12}\n", "Reached ancestor nodes: {0, 1, 4, 7, 10}\n" ] } ], "source": [ "uncovered_node = sorted(uncovered_node_idxs)[0]\n", "print(f\"Node {uncovered_node} is uncovered.\")\n", "\n", "ancestor_nodes = sbn.get_ancestors(uncovered_node)\n", "print(f\"Ancestor nodes: {ancestor_nodes}\")\n", "\n", "############# IMPLEMENT HERE #############\n", "reached_ancestor_nodes = ancestor_nodes & covered_node_idxs\n", "print(f\"Reached ancestor nodes: {reached_ancestor_nodes}\")\n", "##########################################" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Closest reached ancestor nodes: {10}\n" ] } ], "source": [ "def find_closest_reached_ancestor(\n", " target_node: int, reached_ancestor_nodes: set, sbn: SimpleBN\n", ") -> int:\n", " if target_node in reached_ancestor_nodes:\n", " return {target_node}\n", " \n", " ############# IMPLEMENT HERE #############\n", " closest = set()\n", " visited = set()\n", " queue = [target_node]\n", " while len(queue):\n", " node = queue.pop(0)\n", " if node in visited:\n", " continue\n", " visited.add(node)\n", " if node in reached_ancestor_nodes:\n", " closest.add(node)\n", " else:\n", " queue.extend(sbn.get_parents(node))\n", " ##########################################\n", " \n", " return closest\n", "\n", "\n", "closest_reached_ancestors = find_closest_reached_ancestor(\n", " uncovered_node, reached_ancestor_nodes, sbn\n", ")\n", "\n", "print(f\"Closest reached ancestor nodes: {closest_reached_ancestors}\")" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Paths from 10 to 12: [[10, 12]]\n" ] } ], "source": [ "def find_paths(\n", " source_node: int, target_node: int, avoid_nodes: List[int], sbn: SimpleBN\n", "):\n", " ############# IMPLEMENT HERE #############\n", " paths = []\n", " queue = [[source_node]]\n", " while len(queue):\n", " path = queue.pop(0)\n", " node = path[-1]\n", " if node == target_node:\n", " paths.append(path)\n", " else:\n", " for child in sbn.get_children(node):\n", " if child in avoid_nodes:\n", " continue\n", " queue.append(path + [child])\n", " ##########################################\n", " \n", " return paths\n", "\n", "for cra in sorted(closest_reached_ancestors):\n", " paths = find_paths(cra, uncovered_node, covered_node_idxs, sbn)\n", " print(f\"Paths from {cra} to {uncovered_node}: {paths}\")" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Probability of path [10, 12]: 0.0004\n", "Total probability of reaching node 12: 0.0004\n" ] } ], "source": [ "def compute_prob(path: list, sbn: SimpleBN, n: int, start_freq: int) -> float:\n", " ############# IMPLEMENT HERE #############\n", " prob = start_freq / n # empirical reaching probability of the start node\n", " prob *= 2 / (start_freq + 4) # laplace smoothing\n", " # print(f\"Pr[{path[0]} -> {path[1]}] = {start_freq / n} * {2 / (start_freq + 4)} = {prob}\")\n", " if len(path) > 2:\n", " for node in path[1:-1]:\n", " # print(f\"Num children of {node}: {len(sbn.get_children(node))}\")\n", " # print(f\"Pr[{node} -> {path[path.index(node) + 1]}] = {1 / len(sbn.get_children(node))}\", end=\", \")\n", " prob *= 1 / len(\n", " sbn.get_children(node)\n", " ) # uniform probability for each child\n", " # print(f\"Pr = {prob}\")\n", " ##########################################\n", "\n", " return prob\n", "\n", "\n", "total_prob = 0\n", "for cra in sorted(closest_reached_ancestors):\n", " paths = find_paths(cra, uncovered_node, covered_node_idxs, sbn)\n", " for path in paths:\n", " prob = compute_prob(path, sbn, num_exec, coverage_freq_dict[cra])\n", " print(f\"Probability of path {path}: {prob}\")\n", " total_prob += prob\n", "print(f\"Total probability of reaching node {uncovered_node}: {total_prob}\")" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Node None is uncovered.\n" ] }, { "ename": "KeyError", "evalue": "None", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", "Input \u001b[0;32mIn [27]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m uncovered_node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNode \u001b[39m\u001b[38;5;132;01m{\u001b[39;00muncovered_node\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is uncovered.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m ancestor_nodes \u001b[38;5;241m=\u001b[39m \u001b[43msbn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_ancestors\u001b[49m\u001b[43m(\u001b[49m\u001b[43muncovered_node\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAncestor nodes: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mancestor_nodes\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 9\u001b[0m reached_ancestor_nodes \u001b[38;5;241m=\u001b[39m ancestor_nodes \u001b[38;5;241m&\u001b[39m covered_node_idxs\n", "File \u001b[0;32m~/Documents/research/FuzzingSummerSchool/fuzzingbook/notebooks/bn.py:197\u001b[0m, in \u001b[0;36mSimpleBN.get_ancestors\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 195\u001b[0m visited\u001b[38;5;241m.\u001b[39madd(curr_node)\n\u001b[1;32m 196\u001b[0m ancestors\u001b[38;5;241m.\u001b[39madd(curr_node)\n\u001b[0;32m--> 197\u001b[0m queue\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_parents\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcurr_node\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 198\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ancestors\n", "File \u001b[0;32m~/Documents/research/FuzzingSummerSchool/fuzzingbook/notebooks/bn.py:182\u001b[0m, in \u001b[0;36mSimpleBN.get_parents\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 181\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_parents\u001b[39m(\u001b[38;5;28mself\u001b[39m, node: \u001b[38;5;28mint\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Set[\u001b[38;5;28mint\u001b[39m]:\n\u001b[0;32m--> 182\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparent_map\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnode\u001b[49m\u001b[43m]\u001b[49m\n", "\u001b[0;31mKeyError\u001b[0m: None" ] } ], "source": [ "# Another one\n", "\n", "uncovered_node = None\n", "print(f\"Node {uncovered_node} is uncovered.\")\n", "\n", "ancestor_nodes = sbn.get_ancestors(uncovered_node)\n", "print(f\"Ancestor nodes: {ancestor_nodes}\")\n", "\n", "reached_ancestor_nodes = ancestor_nodes & covered_node_idxs\n", "print(f\"Reached ancestor nodes: {reached_ancestor_nodes}\")\n", "\n", "closest_reached_ancestors = find_closest_reached_ancestor(\n", " uncovered_node, reached_ancestor_nodes, sbn\n", ")\n", "print(f\"Closest reached ancestor nodes: {closest_reached_ancestors}\")\n", "\n", "total_prob = 0\n", "for cra in sorted(closest_reached_ancestors):\n", " paths = find_paths(cra, uncovered_node, covered_node_idxs, sbn)\n", " print(f\"Paths from {cra} to {uncovered_node}: {paths}\")\n", " for path in paths:\n", " prob = compute_prob(path, sbn, num_exec, coverage_freq_dict[cra])\n", " print(f\"Probability of path {path}: {prob}\")\n", " total_prob += prob\n", "print(f\"Total probability of reaching node {uncovered_node}: {total_prob}\")" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "def structure_aware_esti(\n", " uncovered_node: int, sbn: SimpleBN, coverage_freq_dict\n", "):\n", " ancestor_nodes = sbn.get_ancestors(uncovered_node)\n", " covered_node_idxs = {k for k, v in coverage_freq_dict.items() if v > 0}\n", " reached_ancestor_nodes = ancestor_nodes & covered_node_idxs\n", " closest_reached_ancestors = find_closest_reached_ancestor(\n", " uncovered_node, reached_ancestor_nodes, sbn\n", " )\n", " num_exec = sum([v for k, v in coverage_freq_dict.items()])\n", " total_prob = 0\n", " for cra in sorted(closest_reached_ancestors):\n", " remaining_cras = closest_reached_ancestors - {cra}\n", " paths = find_paths(cra, uncovered_node, remaining_cras, sbn)\n", " for path in paths:\n", " prob = compute_prob(path, sbn, num_exec, coverage_freq[cra])\n", " total_prob += prob\n", " return total_prob" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "

	node	true	lap	good	struct
0	12	4.827224e-05	0.001992	0.004	0.000083
1	15	4.660666e-06	0.001992	0.004	0.000041
2	20	6.127974e-07	0.001992	0.004	0.000021
3	21	1.865199e-07	0.001992	0.004	0.000010
4	23	4.262774e-07	0.001992	0.004	0.000010

\n", "

" ], "text/plain": [ " node true lap good struct\n", "0 12 4.827224e-05 0.001992 0.004 0.000083\n", "1 15 4.660666e-06 0.001992 0.004 0.000041\n", "2 20 6.127974e-07 0.001992 0.004 0.000021\n", "3 21 1.865199e-07 0.001992 0.004 0.000010\n", "4 23 4.262774e-07 0.001992 0.004 0.000010" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "\n", "df = pd.DataFrame(\n", " {\n", " \"node\": sorted(uncovered_node_idxs),\n", " \"true\": [sbn.reach_prob_dict[n] for n in sorted(uncovered_node_idxs)],\n", " \"lap\": [esti_laplace] * len(uncovered_node_idxs),\n", " \"good\": [est_goodturing] * len(uncovered_node_idxs),\n", " \"struct\": [\n", " structure_aware_esti(n, sbn, coverage_freq_dict)\n", " for n in sorted(uncovered_node_idxs)\n", " ],\n", " }\n", ")\n", "display(df)\n", "\n", "# draw barplot\n", "df_melt = df.melt(id_vars=\"node\", var_name=\"method\", value_name=\"prob\")\n", "fig, ax = plt.subplots(figsize=(10, 5))\n", "sns.barplot(x=\"node\", y=\"prob\", hue=\"method\", data=df_melt, ax=ax)\n", "plt.show()\n", "\n", "fig, ax = plt.subplots(figsize=(10, 5))\n", "sns.barplot(x=\"node\", y=\"prob\", hue=\"method\", data=df_melt, ax=ax)\n", "ax.set_yscale(\"log\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***💡 Go back to the slides***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] } ], "metadata": { "interpreter": { "hash": "e14d36d868a7b57a60d32b8e35cbda475d023cdffb81cafc20acf470005baaf6" }, "kernelspec": { "display_name": "Python 3.8.9 64-bit ('fuzzingbook-AP08n1K5': pipenv)", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.6" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }