tutorials/13-Android-Malware-Detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Android Malware Detection\n",
    "\n",
    "Machine Learning (ML) systems are nowadays being extensively used as the core\n",
    "components of many systems, including **malware detectors**. Despite the\n",
    "impressive performances reported by such systems on benchmark datasets,\n",
    "the problem of detection in the wild is still far from being solved. In fact,\n",
    "many of these algorithms were not designed to cope with *Adversarial Examples*.\n",
    "\n",
    "In this tutorial, we show how to use SecML to build, explain, attack and\n",
    "evaluate the security of a malware detector for **Android applications**,\n",
    "based on a linear Support Vector Machine (SVM), a common choice for this task\n",
    "given its performance and the interpretability of its decisions.\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](\n",
    "https://colab.research.google.com/github/pralab/secml/blob/HEAD/tutorials/13-Android-Malware-Detection.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr --no-display\n",
    "# NBVAL_IGNORE_OUTPUT\n",
    "\n",
    "try:\n",
    "  import secml\n",
    "except ImportError:\n",
    "  %pip install git+https://github.com/pralab/secml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by loading a toy dataset of Android applications, named `DrebinRed`,\n",
    "consisting of 12,000 benign and 550 malicious samples extracted from the\n",
    "`Drebin` dataset:\n",
    "\n",
    "  > [[arp2014drebin]](https://www.sec.cs.tu-bs.de/pubs/2014-ndss.pdf)\n",
    "  > Arp, Daniel, et al. \"Drebin: Effective and explainable detection of\n",
    "  > android malware in your pocket.\" NDSS. Vol. 14. 2014.\n",
    "\n",
    "See https://www.sec.cs.tu-bs.de/~danarp/drebin/ to obtain the full version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "import re\n",
    "import secml\n",
    "from secml import settings\n",
    "from secml.utils import fm\n",
    "from secml.utils.download_utils import dl_file_gitlab\n",
    "\n",
    "repo_url = 'https://gitlab.com/secml/secml-zoo'\n",
    "file_name = 'drebin-reduced.tar.gz'\n",
    "file_path = 'datasets/DrebinRed/' + file_name\n",
    "output_dir = fm.join(settings.SECML_DS_DIR, 'drebin-red')\n",
    "md5_digest = 'ecf87ddedf614dd53b89285c29cf1caf'\n",
    "\n",
    "ds_path = fm.join(output_dir, file_name)\n",
    "\n",
    "# The following tries to get the correct dataset for the current library version\n",
    "if not fm.file_exist(ds_path):\n",
    "    try:\n",
    "        # Try downloading from the branch corresponding to current version\n",
    "        min_version = re.search(r'^\\d+.\\d+', secml.__version__).group(0)\n",
    "        dl_file_gitlab(repo_url, file_path, output_dir,\n",
    "                       branch='v' + min_version, md5_digest=md5_digest)\n",
    "\n",
    "    except Exception as e:  # Try looking into 'master' branch...\n",
    "        dl_file_gitlab(repo_url, file_path, output_dir, md5_digest=md5_digest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num. samples:  12550\n",
      "Num. benign samples:  12000\n",
      "Num. malicious samples:  550\n",
      "Num. features:  1227080\n"
     ]
    }
   ],
   "source": [
    "from secml.utils import pickle_utils\n",
    "\n",
    "ds = pickle_utils.load(ds_path)\n",
    "\n",
    "print(\"Num. samples: \", ds.num_samples)\n",
    "\n",
    "n_neg = sum(ds.Y == 0)\n",
    "n_pos = sum(ds.Y == 1)\n",
    "\n",
    "print(\"Num. benign samples: \", n_neg)\n",
    "print(\"Num. malicious samples: \", n_pos)\n",
    "\n",
    "print(\"Num. features: \", ds.num_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and testing the detector\n",
    "\n",
    "We train the Support Vector Machine classifier on half the dataset, while\n",
    "using the rest for testing. The performance on the task of recognizing benign\n",
    "and malicious applications will be reported by means of the **Detection Rate @\n",
    "2% False Positive Rate**, the **F1 score** and by plotting the **Receiver\n",
    "Operating Characteristic (ROC) curve**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started...\n",
      "Training completed!\n"
     ]
    }
   ],
   "source": [
    "from secml.data.splitter import CTrainTestSplit\n",
    "\n",
    "tr, ts = CTrainTestSplit(6000, random_state=0).split(ds)\n",
    "\n",
    "from secml.ml.classifiers import CClassifierSVM\n",
    "\n",
    "clf = CClassifierSVM(C=0.1)\n",
    "\n",
    "print(\"Training started...\")\n",
    "clf.fit(tr.X, tr.Y)\n",
    "print(\"Training completed!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detection rate @ 2% FPR: 95.04%\n",
      "F1 score: 89.09%\n"
     ]
    }
   ],
   "source": [
    "# Classification of test set and computation of performance metrics\n",
    "y_pred, score_pred = clf.predict(ts.X, return_decision_function=True)\n",
    "\n",
    "from secml.ml.peval.metrics import CMetricTPRatFPR, CMetricF1, CRoc\n",
    "\n",
    "fpr_th = 0.02  # 2% False Positive Rate\n",
    "\n",
    "dr = CMetricTPRatFPR(fpr=fpr_th).performance_score(y_true=ts.Y, score=score_pred[:, 1].ravel())\n",
    "print(\"Detection rate @ 2% FPR: {:.2%}\".format(dr))\n",
    "\n",
    "f1 = CMetricF1().performance_score(y_true=ts.Y, y_pred=y_pred)\n",
    "print(\"F1 score: {:.2%}\".format(f1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fpr, tpr, _ = CRoc().compute(y_true=ts.Y, score=score_pred[:, 1].ravel())\n",
    "\n",
    "from secml.figure import CFigure\n",
    "# Only required for visualization in notebooks\n",
    "%matplotlib inline\n",
    "\n",
    "fig = CFigure(height=4, width=6)\n",
    "fig.sp.plot_roc(fpr, tpr)\n",
    "fig.sp._sp.axvline(x=2,  c='k', linestyle='--', zorder=-1)\n",
    "fig.sp.xlim(0.5, 20)\n",
    "fig.sp.ylim(90, 98)\n",
    "fig.sp.yticks([90, 92, 94, 96, 98])\n",
    "fig.sp.yticklabels([90, 92, 94, 96, 98])\n",
    "fig.sp.ylabel(r'Detection Rate $(\\%)$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explaining the decisions\n",
    "\n",
    "In this section of the tutorial, we compute the **post-hoc explanations**\n",
    "for the trained Android malware detector by analyzing the trained model\n",
    "to understand which components of the applications are more relevant during\n",
    "the decision (classification) phase.\n",
    "\n",
    "We use the **Gradient * Input** gradient-based explanation method, which is\n",
    "implemented by the `CExplainerGradientInput` class. Our algorithm is\n",
    "optimized to run on sparse data, which makes it suitable to be used in this\n",
    "application example.\n",
    "\n",
    "For each sample, one benign and one malicious, we compute the explanations\n",
    "with respect to the positive (malicious) class and list the top-10 influential\n",
    "features, along with the corresponding relevance (%).\n",
    "\n",
    "For further reference see:\n",
    "\n",
    "  > [[melis2018explaining]](https://arxiv.org/abs/1803.03544)\n",
    "  > M. Melis, D. Maiorca, B. Biggio, G. Giacinto and F. Roli,\n",
    "  > \"Explaining Black-box Android Malware Detection,\" 2018 26th European\n",
    "  > Signal Processing Conference (EUSIPCO), Rome, 2018, pp. 524-528.\n",
    "\n",
    "See also: [Explaining Machine Learning](10-Explanation.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing explanations using 'CExplainerGradientInput'\n"
     ]
    }
   ],
   "source": [
    "from secml.explanation import CExplainerGradientInput\n",
    "\n",
    "expl = CExplainerGradientInput(clf)\n",
    "\n",
    "print(\"Computing explanations using '{:}'\".format(expl.__class__.__name__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explanations for sample 137 (true class: 0)\n",
      " -8.30\treq_permissions::android.permission.CALL_PHONE\n",
      " -6.59\tsuspicious_calls::android/net/Uri;->toString\n",
      "  5.60\treq_permissions::android.permission.INTERNET\n",
      " -5.39\tused_permissions::ACCESS_NETWORK_STATE\n",
      " -5.08\tapi_calls::android/media/MediaPlayer;->start\n",
      " -4.24\tused_permissions::VIBRATE\n",
      " -3.65\tintent_filters::android.intent.category.LAUNCHER\n",
      " -3.56\treq_permissions::android.permission.ACCESS_FINE_LOCATION\n",
      " -3.43\tused_permissions::ACCESS_FINE_LOCATION\n",
      " -2.63\tapi_calls::android/location/LocationManager;->getLastKnownLocation\n"
     ]
    }
   ],
   "source": [
    "# Explanations for a benign sample\n",
    "i = 137\n",
    "x, y = ts[i, :].X, ts[i, :].Y\n",
    "\n",
    "print(\"Explanations for sample {:} (true class: {:})\".format(i, y.item()))\n",
    "\n",
    "attr = expl.explain(x, y=1)\n",
    "attr = attr / attr.norm(order=1)  # To display values in 0-100\n",
    "\n",
    "attr_argsort = abs(attr).argsort().ravel()[::-1]\n",
    "\n",
    "n_plot = 10\n",
    "\n",
    "for i in attr_argsort[:10]:\n",
    "    print(\"{:6.2f}\\t{:}\".format(attr[i].item() * 100, ds.header.feat_desc[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explanations for sample 138 (true class: 1)\n",
      " 15.18\tsuspicious_calls::android/telephony/TelephonyManager;->getNetworkOperator\n",
      " 12.55\treq_permissions::android.permission.SEND_SMS\n",
      "  8.69\treq_permissions::android.permission.READ_SMS\n",
      "  5.83\treq_permissions::android.permission.INTERNET\n",
      "  5.58\tintent_filters::android.intent.action.BOOT_COMPLETED\n",
      " -4.41\tused_permissions::VIBRATE\n",
      "  3.96\tintent_filters::android.intent.category.HOME\n",
      " -3.80\tintent_filters::android.intent.category.LAUNCHER\n",
      "  3.66\treceivers::com.google.android.c2dm.C2DMBroadcastReceiver\n",
      "  3.39\treq_permissions::android.permission.READ_PHONE_STATE\n"
     ]
    }
   ],
   "source": [
    "# Explanations for a malware\n",
    "i = 138\n",
    "x, y = ts[i, :].X, ts[i, :].Y\n",
    "\n",
    "print(\"Explanations for sample {:} (true class: {:})\".format(i, y.item()))\n",
    "\n",
    "attr = expl.explain(x, y=1)\n",
    "attr = attr / attr.norm(order=1)  # To display values in 0-100\n",
    "\n",
    "attr_argsort = abs(attr).argsort().ravel()[::-1]\n",
    "\n",
    "n_plot = 10\n",
    "\n",
    "for i in attr_argsort[:10]:\n",
    "    print(\"{:6.2f}\\t{:}\".format(attr[i].item() * 100, ds.header.feat_desc[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the first sample, a benign application, we can observe how\n",
    "*the majority of the features have a negative relevance* towards the decision,\n",
    "meaning that, for this classifier, are an indication of a *benign behavior*.\n",
    "\n",
    "Regarding the second sample, a malicious application, we can observe the\n",
    "opposite, as *the majority of the features have a positive relevance* value,\n",
    "meaning that, for this classifier, are an indication of a *malicious behavior*.\n",
    "\n",
    "We also observe that more than ~50% of the relevance is assigned to only\n",
    "10 features in both cases. This highlights a *known behavior* of these\n",
    "classifiers, which tend to assign most of the weight to a small set\n",
    "of features, making them vulnerable to adversarial evasion attacks.\n",
    "\n",
    "For further reference see:\n",
    "\n",
    "  > [[demontis2017-tdsc]](https://arxiv.org/abs/1704.08996)\n",
    "  > Demontis, Ambra, et al. \"Yes, machine learning can be more secure!\n",
    "  > a case study on android malware detection.\" IEEE Transactions on\n",
    "  > Dependable and Secure Computing (2017).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crafting Adversarial Examples\n",
    "\n",
    "We now set up a **gradient-based maximum-confidence evasion attack** to create\n",
    "adversarial examples against the SVM classifier on which the Android\n",
    "malware detector is based on.\n",
    "\n",
    "Firstly, we choose the solver parameters. As we are working with **boolean\n",
    "features** (each can take either 0 or 1 value), we use a line search grid step\n",
    "`eta` of 1. Then, we choose `l1` as the distance, in order to perform a\n",
    "**L1-order sparse attack**, were *only one feature* is changed (from 0 to 1 or\n",
    "vice-versa) at each iteration. Finally, as we only want malicious samples\n",
    "to be classified as benign, we set `y_target = 0` to perform a targeted attack.\n",
    "\n",
    "The lower and the upper bound constraints are critical in this application.\n",
    "To create malware able to fool a classifier, an attacker may, in theory,\n",
    "both *adding and removing features* from the original applications. However,\n",
    "in practice, **feature removal** is a non-trivial operation that can easily\n",
    "compromise the malicious functionalities of the application and, generally\n",
    "speaking, only be performed for not-`manifest` components.\n",
    "**Feature addition** is a safer operation, especially when the injected\n",
    "features belong to the manifest; for example, adding permissions does not\n",
    "influence any existing application functionality.\n",
    "\n",
    "Therefore, in this example, to only alow feature addition we set `lb = 'x0'`\n",
    "and `ub = 1`. To also allow feature removal, one can set `lb = 0`.\n",
    "\n",
    "See also: [Evasion Attacks against Machine Learning](03-Evasion.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Attack parameters\n",
    "params = {\n",
    "    \"classifier\": clf,\n",
    "    \"distance\": 'l1',\n",
    "    \"double_init\": False,\n",
    "    \"lb\": 'x0',\n",
    "    \"ub\": 1,\n",
    "    \"attack_classes\": 'all',\n",
    "    \"y_target\": 0,\n",
    "    \"solver_params\": {'eta': 1, 'eta_min': 1, 'eta_max': None, 'eps': 1e-4}\n",
    "}\n",
    "\n",
    "from secml.adv.attacks.evasion import CAttackEvasionPGDLS\n",
    "\n",
    "evasion = CAttackEvasionPGDLS(**params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Security Evaluation\n",
    "\n",
    "To evaluate the robustness of the Android malware detector against increasing\n",
    "number of modified (added) features, SecML provides a way to easily produce a\n",
    "**Security Evaluation Curve**, by means of the `CSecEval` class.\n",
    "\n",
    "The `CSecEval` instance will run the evasion attack on the classifier\n",
    "using increasing values of the L1-order perturbation `eps`.\n",
    "\n",
    "This process should last **around 60 seconds**, despite working on over\n",
    "*1 million features*, using the `CAttackEvasionPGDLS` attack, as it is\n",
    "optimized to run on sparse data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running security evaluation...\n",
      "Security evaluation completed!\n"
     ]
    }
   ],
   "source": [
    "n_mal = 10\n",
    "\n",
    "# Attack DS\n",
    "mal_idx = ts.Y.find(ts.Y == 1)[:n_mal]\n",
    "adv_ds = ts[mal_idx, :]\n",
    "\n",
    "# Security evaluation parameters\n",
    "param_name = 'dmax'  # This is the `eps` parameter\n",
    "dmax_start = 0\n",
    "dmax = 28\n",
    "dmax_step = 4\n",
    "\n",
    "from secml.array import CArray\n",
    "\n",
    "param_values = CArray.arange(\n",
    "    start=dmax_start, step=dmax_step, stop=dmax + dmax_step)\n",
    "\n",
    "from secml.adv.seceval import CSecEval\n",
    "\n",
    "sec_eval = CSecEval(\n",
    "    attack=evasion,\n",
    "    param_name=param_name,\n",
    "    param_values=param_values)\n",
    "\n",
    "print(\"Running security evaluation...\")\n",
    "sec_eval.run_sec_eval(adv_ds)\n",
    "print(\"Security evaluation completed!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from secml.figure import CFigure\n",
    "fig = CFigure(height=5, width=5)\n",
    "\n",
    "from secml.ml.peval.metrics import CMetricTHatFPR, CMetricTPRatTH\n",
    "\n",
    "# Get the ROC threshold at which Detection Rate should be computed\n",
    "th = CMetricTHatFPR(fpr=fpr_th).performance_score(y_true=ts.Y, score=score_pred[:, 1].ravel())\n",
    "\n",
    "# Convenience function for plotting the Security Evaluation Curve\n",
    "fig.sp.plot_sec_eval(sec_eval.sec_eval_data, metric=CMetricTPRatTH(th=th),\n",
    "                     percentage=True, label='SVM', color='green', marker='o')\n",
    "fig.sp.ylabel(r'Detection Rate $(\\%)$')\n",
    "fig.sp.xlabel(r\"$\\varepsilon$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see how this malware detector based on the SVM classifier is vulnerable\n",
    "to adversarial attacks and *after changing less than 10 features* half of the\n",
    "malicious samples are incorrectly classified as benign applications.\n",
    "This known vulnerability has also been [highlighted](#Explaining-the-decisions)\n",
    "when we listed the top influential features and observed that *most of the\n",
    "relevance is given to a very limited set of features*."
   ]
  }
 ],
 "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.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}