attack_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SecML Malware Tutorial\n",
    "\n",
    "In this tutorial, you will learn how to use this plugin to test the already implemented attacks against a PyTorch network of your choice."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-05T12:16:49.931441Z",
     "start_time": "2024-07-05T12:16:46.624903Z"
    }
   },
   "source": [
    "import os\n",
    "import magic\n",
    "from secml.array import CArray\n",
    "\n",
    "from secml_malware.models.malconv import MalConv\n",
    "from secml_malware.models.c_classifier_end2end_malware import CClassifierEnd2EndMalware, End2EndModel\n",
    "\n",
    "net = MalConv() # CNN trained on RAW BYTES\n",
    "net = CClassifierEnd2EndMalware(net)\n",
    "net.load_pretrained_model()"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, we have created the network (MalConv) and it has been passed wrapped with a *CClassifierEnd2EndMalware* model class.\n",
    "This object generalizes PyTorch end-to-end ML models.\n",
    "Since MalConv is already coded inside the plugin, the weights are also stored, and they can be retrieved with the *load_pretrained_model* method.\n",
    "\n",
    "If you wish to use diffierent weights, pass the path to the PyTorch *pth* file to that method."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-05T12:18:49.769767Z",
     "start_time": "2024-07-05T12:18:49.750141Z"
    }
   },
   "source": [
    "from secml_malware.attack.whitebox.c_header_evasion import CHeaderEvasion\n",
    "\n",
    "partial_dos = CHeaderEvasion(net, random_init=False, iterations=50, optimize_all_dos=False, threshold=0.0)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how an attack is created, no further action is needed.\n",
    "The `random_init` parameter specifies if the bytes should be assigned with random values before beginning the optimization process, `iterations` sets the number of steps of the attack, `optimize_all_dos` sets if all the DOS header should be perturbed, or just the first 58 bytes, while `threshold` is the detection threshold used as a stopping condition.\n",
    "\n",
    "If you want to see how much the network is deteriorated by the attack, set this parameter to 0, or it will stop as soon as the confidence decreases below such value."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-05T12:18:58.337864Z",
     "start_time": "2024-07-05T12:18:58.264111Z"
    }
   },
   "source": [
    "folder = \"secml_malware/data/malware_samples/test_folder\"\n",
    "X = []\n",
    "y = []\n",
    "file_names = []\n",
    "for i, f in enumerate(os.listdir(folder)):\n",
    "    path = os.path.join(folder, f)\n",
    "    if 'petya' not in path:\n",
    "        continue\n",
    "    if \"PE32\" not in magic.from_file(path):\n",
    "        continue\n",
    "    with open(path, \"rb\") as file_handle:\n",
    "        code = file_handle.read()\n",
    "    x = End2EndModel.bytes_to_numpy(\n",
    "        code, net.get_input_max_length(), 256, False\n",
    "    )\n",
    "    _, confidence = net.predict(CArray(x), True)\n",
    "\n",
    "    if confidence[0, 1].item() < 0.5:\n",
    "        continue\n",
    "\n",
    "    print(f\"> Added {f} with confidence {confidence[0,1].item()}\")\n",
    "    X.append(x)\n",
    "    conf = confidence[1][0].item()\n",
    "    y.append([1 - conf, conf])\n",
    "    file_names.append(path)\n",
    "    # PETYA RANSOMWARE\n",
    "# 0.9112256765365601"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Added petya.file with confidence 0.9112256765365601\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We load a simple dataset from the `malware_samples/test_folder` that you have filled with malware to test the attacks.\n",
    "We discard all the samples that are not seen by the network.\n",
    "The `CArray` class is the base object you will handle when dealing with vectors in this library."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-05T12:20:45.112257Z",
     "start_time": "2024-07-05T12:20:30.984066Z"
    }
   },
   "source": [
    "for sample, label in zip(X, y):\n",
    "    y_pred, adv_score, adv_ds, f_obj = partial_dos.run(CArray(sample), CArray(label[1]))\n",
    "    print(partial_dos.confidences_)\n",
    "    print(f_obj)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9112256765365601, 0.06050168350338936, 0.02569282241165638, 0.013263005763292313, 0.007708318531513214, 0.006512514315545559, 0.00256469938904047, 0.0010069687850773335, 0.00042997609125450253, 0.00031924922950565815, 0.0005989515921100974, 0.0002068594767479226, 0.00011205733608221635, 8.947109017753974e-05, 8.69965588208288e-05, 0.00044750436791218817, 0.00020894983026664704, 0.00012765263090841472, 0.00010658507380867377, 0.0003574001893866807, 0.00016230311302933842, 0.00010355764243286103, 8.281883492600173e-05, 7.962167001096532e-05, 0.0005361491348594427, 0.00022481686028186232, 0.0001238513650605455, 9.08773290575482e-05, 7.962690142448992e-05, 7.131584425223991e-05, 7.284294406417757e-05, 0.00020154037338215858, 0.00037678476655855775, 0.0001889022532850504, 0.00011984687444055453, 0.00010659441613825038, 0.00022499141050502658, 0.0003707527357619256, 0.00016528736159671098, 0.0001126341157942079, 8.412790339207277e-05, 7.938232738524675e-05, 7.359428855124861e-05, 7.929849380161613e-05, 0.0004184528661426157, 0.00019326900655869395, 0.00011624045146163553, 8.87721762410365e-05, 8.388037531403825e-05, 0.00035471623414196074, 0.00015971656830515712]\n",
      "0.00015971656830515712\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the `adv_ds` object, you can find the adversarial example computed by the attack.\n",
    "You can reconstruct the functioning example by using a specific function inside the plugin:"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-05T12:23:05.182100Z",
     "start_time": "2024-07-05T12:23:05.043460Z"
    }
   },
   "source": [
    "adv_x = adv_ds.X[0,:]\n",
    "real_adv_x = partial_dos.create_real_sample_from_adv(file_names[0], adv_x)\n",
    "print(len(real_adv_x))\n",
    "real_x = End2EndModel.bytes_to_numpy(real_adv_x, net.get_input_max_length(), 256, False)\n",
    "_, confidence = net.predict(CArray(real_x), True)\n",
    "print(confidence[0,1].item())"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "806912\n",
      "0.00015971656830515712\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and you're done!\n",
    "If you want to create a real sample (stored on disk), just have a look at the `create_real_sample_from_adv` of each attack. It accepts a third string argument that will be used as a destination file path for storing the adversarial example."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Bonus: more attacks!\n",
    "We used one attack, which is the Partial DOS one. But what if we want to use others?\n",
    "Easy peasy task! Just open the [source code](https://github.com/pralab/secml_malware/tree/master/secml_malware/attack/whitebox) or the [documentation](https://secml-malware.readthedocs.io/en/docs/source/secml_malware.attack.whitebox.html) of the other white box attacks, and instantiate the one you like!\n",
    "Let's use the [FGSM attack](https://arxiv.org/abs/1802.04528), for instance:"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from secml_malware.attack.whitebox import CKreukEvasion\n",
    "\n",
    "fgsm = CKreukEvasion(net, how_many_padding_bytes=1024, epsilon=4.0, iterations=5)\n",
    "for i, (sample, label) in enumerate(zip(X, y)):\n",
    "    y_pred, adv_score, adv_ds, f_obj = fgsm.run(CArray(sample), CArray(label[1]))\n",
    "    print(fgsm.confidences_)\n",
    "    print(f_obj)\n",
    "    real_adv_x = fgsm.create_real_sample_from_adv(file_names[i], adv_ds.X[i, :])\n",
    "    with open(file_names[i], 'rb') as f:\n",
    "        print('Original length: ', len(f.read()))\n",
    "    print('Adversarial sample length: ', len(real_adv_x))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "is_executing": true,
    "jupyter": {
     "is_executing": true
    }
   },
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "... and you're done! Remember that this particular attack might take a while, depending on how many bytes the algorithm is tasked to edit (and also for the number of iterations).\n",
    "In the meantime, **happy coding with SecML Malware!**"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}