GraphGuard.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GraphGuard\n",
    "\n",
    "***Locate and find Classes in Apks with updated Obfuscation Mapping***\n",
    "\n",
    "\n",
    "Processing Steps:\n",
    "1. String Strategy (Classes + Methods) \\\n",
    "  Strategy using 2 different variants only involving Strings:\n",
    "  * String Counter: used in Classes and Methods and try to find exact matching counter.\n",
    "  * Unique Strings: Match Classes by identifying Strings used only in this single Class.\n",
    "\n",
    "\n",
    "\n",
    "2. Structure Strategy (Classes) \\\n",
    "  Strategy that enumerates all classes and tries to find an optimal match by using the following (weighted) criteria:\n",
    "  * Modifiers of class\n",
    "  * Modifiers, Parameters, Parameter Types and Return Types of Methods\n",
    "  * Number and Types of Fields.\n",
    "\n",
    "\n",
    "\n",
    "3. Method Strategy (Methods) \\\n",
    "  Strategy that uses already matched classes and tries to find an optimal Method Match in the class by using the following (weighted) criteria:\n",
    "  * Modifiers\n",
    "  * Return Type, Parameter Types\n",
    "  * Bytecode Length\n",
    "  * References to and from\n",
    "\n",
    "\n",
    "4. Field Strategy (Fields) \\\n",
    "  Strategy that uses already matched classes and tries to find an optimal Field Match in the class by using the following (weighted criteria)\n",
    "  * By Type if a matching Type has been found\n",
    "  * By weighted sub-criteria such as:\n",
    "    * Access Flags\n",
    "    * Size\n",
    "    * Number of reads & Number of writes (references)\n",
    "\n",
    "***If you use Akrolyb, please have a look at [Akrolyb Interoptability](#Interoptability-with-Akrolyb)***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>div.output_area pre {white-space: pre;}</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "\n",
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>div.output_area pre {white-space: pre;}</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%autoreload\n",
    "from collections.abc import Iterable\n",
    "\n",
    "from core.start import process_files\n",
    "from utils.formats import *\n",
    "\n",
    "from core.accumulator import Accumulator\n",
    "from core.decs import *\n",
    "\n",
    "from strategies import\\\n",
    "    strings as strings_strategy,\\\n",
    "    methods as methods_strategy,\\\n",
    "    structures as structures_strategy,\\\n",
    "    fields as fields_strategy\n",
    "\n",
    "from core.strategy_handler import StrategyHandler, FLAG_CLASS, FLAG_METHOD, FLAG_FIELD\n",
    "\n",
    "from utils import generate\n",
    "from utils import io_akrolyb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading Androguard\n",
    "\n",
    "The following code loads the files and starts Androguard\n",
    "\n",
    "It should support multiprocessing, however the Pipe communication seems to break when transmitting the processed Androguard Objects. I suspect the Object is simply too big for Pickle to serialize or another component in the transmitting chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "AG_SESSION_FILE = \"./Androguard.ag\"\n",
    "MULTIPROCESS_FILES = False  # Currently not working due to serialization issues\n",
    "\n",
    "apk_dir = \"../../../Downloads/\"\n",
    "\n",
    "# APK Files to load\n",
    "file_paths = (\n",
    "    \"com.snapchat.android_11.6.1.66-2125_minAPI19(arm64-v8a)(nodpi)_apkmirror.com.apk\",\n",
    "    \"com.snapchat.android_11.15.1.34-2150_minAPI19(arm64-v8a)(nodpi)_apkmirror.com.apk\"\n",
    ")\n",
    "\n",
    "\n",
    "# file_paths = (\n",
    "#     \"com.instagram.android_169.1.0.29.135-262886990_minAPI23(arm64-v8a)(nodpi)_apkmirror.com.apk\",\n",
    "#     \"com.instagram.android_171.0.0.0.61-266880311_minAPI23(arm64-v8a)(420,400,360,480dpi)_apkmirror.com.apk\"\n",
    "# )\n",
    "file_paths = tuple(map(lambda apk_name: apk_dir + apk_name, file_paths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Session from Apk at ../../../Downloads/com.snapchat.android_11.6.1.66-2125_minAPI19(arm64-v8a)(nodpi)_apkmirror.com.apk\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Requested API level 29 is larger than maximum we have, returning API level 28 instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Session from Apk at ../../../Downloads/com.snapchat.android_11.15.1.34-2150_minAPI19(arm64-v8a)(nodpi)_apkmirror.com.apk\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Requested API level 29 is larger than maximum we have, returning API level 28 instead.\n"
     ]
    }
   ],
   "source": [
    "(a, d, dx), (a2, d2, dx2) = process_files(*file_paths, MULTIPROCESS_FILES)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List of Classes, Methods and Fields\n",
    "\n",
    "Defining Elements that GraphGuard should try to match (obviously requires full class names).\n",
    "\n",
    "GraphGuard has full Akrolyb support. Read about it at [Akrolyb Interoptability](#Interoptability-with-Akrolyb). Using this is optional. In case you don't want to use this functionality, do not run the few last cells that are related to Akrolyb Support and Automation\n",
    "\n",
    "\n",
    "* For using Akrolyb Support:\n",
    "    * Use CodeGen in Akrolyb to generate a Python-compatible tuple of declarations that you can copy paste into `named_c_decs`, `named_f_decs` and `named_f_decs`.\n",
    "    * Specify the correct file for auto replacing values, the \"declarations files\".\n",
    "    * Types of the variables:\n",
    "        * `named_c_decs` in form of a `Dict[str, str]`\n",
    "        * `named_m_decs` in form of a `Dict[str, MethodDec]`\n",
    "        * `named_f_decs` in form of a `Dict[str, FieldDec]`\n",
    "    * GraphGuard extracts the declarations and uses the given names for Auto-Updates.\n",
    "\n",
    "\n",
    "* For not using Akrolyb, and just simply try and match the values (without Auto-Replacing):\n",
    "    * Leave named_c_decs, named_m_decs, named_f_decs empty.\n",
    "    * Assign the declarations directly to c_decs, m_decs, f_decs further below by uncommenting the existing cell.\n",
    "    * Types of the variables:\n",
    "        * `c_decs` in form of a `Tuple[str]`\n",
    "        * `m_decs` in form of a `Tuple[MethodDec]`\n",
    "        * `f_decs` in form of a `Tuple[FieldDec]`\n",
    "\n",
    "Note that classes of methods and fields are automatically merged with `c_decs`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "named_c_decs = {\n",
    "    'SCREENSHOT_DETECTOR': 'Zf6',\n",
    "    'STORY_VIEWED_PLUGIN': 'tRi',\n",
    "    'SNAP_MODEL': 'hgd',\n",
    "    'APP_START_EXPERIMENT_MANAGER': 'y9g',\n",
    "    'CBC_ENCRYPTION_ALGORITHM': 'ut7',\n",
    "    'CAPTION_EDIT_TEXT_VIEW': 'com.snap.previewtools.caption.ui.CaptionEditTextView'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "named_m_decs = {\n",
    "    'SCREENSHOT_DETECTED': MethodDec('Zf6', 'a', 'Zf6', 'Yf6'),\n",
    "    'MARK_STORY_AS_VIEWED': MethodDec('tRi', 'Z', 'Ikf', 'Haf'),\n",
    "    'SNAP_MODEL_CONSTRUCTOR': MethodDec('hgd', '<init>', 'java.lang.String', 'boolean', 'java.lang.String', 'java.lang.String', 'java.lang.String', 'java.lang.Long', 'j46', 'long', 'boolean', 'java.lang.Long', 'long'),\n",
    "    'FORCE_APP_DECK': MethodDec('y9g', 'f', 'Su5'),\n",
    "    'DECRYPT_MEDIA_STREAM': MethodDec('ut7', 'n0', 'java.io.InputStream')\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "named_f_decs = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_decs = tuple(named_m_decs.values())\n",
    "f_decs = []\n",
    "for f_dec in named_f_decs.values():\n",
    "    if isinstance(f_dec, Iterable):\n",
    "        f_decs.extend(f_dec)\n",
    "    else:\n",
    "        f_decs.append(f_dec)\n",
    "f_decs = tuple(f_decs)\n",
    "\n",
    "# Add Classes of Methods and Fields to c_decs\n",
    "c_decs = tuple(map(lambda m: m.class_name, m_decs)) \\\n",
    "        + tuple(map(lambda v: v.class_name, f_decs)) + tuple(named_c_decs.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Without using Akrolyb's Auto-Replacing Values:\n",
    "\n",
    "# c_decs = tuple()\n",
    "# m_decs = tuple()\n",
    "# f_decs = tuple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Processing and Matching\n",
    "\n",
    "Loading the accumulator, an object that manages all the possible candidates that are matched by the different Matchers, and extracts the matching candidates. It also performs Inner joins on previous candidates to find the exact (or optimal) match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "accumulator = Accumulator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolving the previously defined MethodDecs. If this fails, the MethodDecs are wrong and contain an error. Make sure the method specified with the MethodDec exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resolved all Classes, Methods and Fields\n"
     ]
    }
   ],
   "source": [
    "dec_cas = resolve_classes(dx, c_decs)\n",
    "\n",
    "r_cas = tuple(dec_cas.values())\n",
    "r_mas = resolve_methods(m_decs, dec_cas)\n",
    "r_fas = resolve_fields(f_decs, dec_cas)\n",
    "\n",
    "print(\"Resolved all Classes, Methods and Fields\")\n",
    "if False:\n",
    "    print(\"\", *map(pretty_format_ma, r_mas), sep=\"\\n* \")\n",
    "\n",
    "# Arguments to provide to Strategies\n",
    "s_args = (dx, dx2, r_cas, r_mas, r_fas, accumulator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategies & StrategyHandler\n",
    "\n",
    "Strategies are essentially functions returning candidates for Classes, Methods or Fields. A `strategy` gets registered in the `StrategyHandler` with Flags indicating whether it tries to match Classes, Methods or Fields. If a search is invoked for a matching flag, the strategy gets invoked on the given arguments.\n",
    "\n",
    "Global Parameters and Rules of the Strategies allow for easily changing criteria, e. g. use a more lenient search and not require strict matches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "strategies = StrategyHandler()\n",
    "\n",
    "\n",
    "strings_strategy.MAX_USAGE_COUNT_STR = 20\n",
    "strings_strategy.UNIQUE_STRINGS_MAJORITY = 2 / 3\n",
    "\n",
    "methods_strategy.MIN_MATCH_POINTS = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Strategy\n",
    "\n",
    "### Exact Counter Match\n",
    "\n",
    "Extracts Strings used either in the given methods directly or in the classes the methods define for both, the old version and the new version. It then compares the Counters for classes and methods and tries to find exact matches between the Counter Objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ Found single candidate for Method. Considering it a match \n",
      "\tZf6#a(Zf6, Yf6) -> Fq6#a(Fq6, Eq6)\n",
      "+ Matching Class of single candidate method match \n",
      "\tLZf6; -> LFq6;\n",
      "Could resolve 1 new Classes, 1 new Methods, 0 new Fields.\n"
     ]
    }
   ],
   "source": [
    "def string_counter_strategy(r_cas, r_mas, r_fas):\n",
    "    string_s = strings_strategy.StringStrategy(dx, dx2, r_cas, r_mas, r_fas, accumulator)\n",
    "    candidates_cs, candidates_ms = string_s.compare_counters()\n",
    "    \n",
    "    accumulator.add_candidates(candidates_cs, candidates_ms)\n",
    "\n",
    "strategies.add_strategy(string_counter_strategy, FLAG_CLASS | FLAG_METHOD)\n",
    "strategies.invoke_strategies(r_cas, r_mas, r_fas, only_new=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unique Strings\n",
    "\n",
    "Gather all Strings that are used only in a single class (\"Unique Strings\") that we still need to match. Then try to find the matching class by only searching for the Unique Strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ Found single candidate for Class. Considering it a match! \n",
      "\tLut7; -> LVC7;\n",
      "+ Found single candidate for Class. Considering it a match! \n",
      "\tLy9g; -> Luxg;\n",
      "+ Found single candidate for Class. Considering it a match! \n",
      "\tLtRi; -> LVfj;\n",
      "Could resolve 3 new Classes, 0 new Methods, 0 new Fields.\n"
     ]
    }
   ],
   "source": [
    "def unique_strings_strategy(r_cas, r_mas, r_fas):\n",
    "    string_s = strings_strategy.StringStrategy(dx, dx2, r_cas, r_mas, r_fas, accumulator)\n",
    "    candidates_cs = string_s.compare_unique_strings()\n",
    "    \n",
    "    accumulator.add_candidates(candidates_cs)\n",
    "\n",
    "strategies.add_strategy(unique_strings_strategy, FLAG_CLASS)\n",
    "strategies.invoke_strategies(r_cas, r_mas, r_fas, only_new=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Structure Strategy\n",
    "\n",
    "Iterating through every single class and checks for each unmatched class if both have a similar \"Profile\":\n",
    "* Number of Methods and Fields\n",
    "* Types of Fields and Descriptors of Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ Found single candidate for Class. Considering it a match! \n",
      "\tLhgd; -> LSDd;\n",
      "+ Found single candidate for Class. Considering it a match! \n",
      "\tLcom/snap/previewtools/caption/ui/CaptionEditTextView; -> Lcom/snap/previewtools/caption/ui/CaptionEditTextView;\n",
      "Could resolve 2 new Classes, 0 new Methods, 0 new Fields.\n"
     ]
    }
   ],
   "source": [
    "def structure_strategy(r_cas, r_mas, r_fas):\n",
    "    structure_s = structures_strategy.StructureStrategy(dx, dx2, r_cas, r_mas, r_fas, accumulator)\n",
    "    candidates_cs = structure_s.get_exact_structure_matches()\n",
    "\n",
    "    accumulator.add_candidates(candidates_cs)\n",
    "\n",
    "strategies.add_strategy(structure_strategy, FLAG_CLASS)\n",
    "strategies.invoke_strategies(r_cas, r_mas, r_fas, only_new=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Method Strategy\n",
    "\n",
    "Uses different weighted criteria to get exact or optimal matches. The criteria are:\n",
    "* Modifiers\n",
    "* Return Type and Parameter Types\n",
    "* Length of Bytecode\n",
    "* References to and from"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact Matching\n",
      "\n",
      "+ Found single candidate for Method. Considering it a match \n",
      "\ttRi#Z(Ikf, Haf) -> Vfj#a0(aIf, byf)\n",
      "+ Found single candidate for Method. Considering it a match \n",
      "\thgd#<init>(java.lang.String, boolean, java.lang.String, java.lang.String, java.lang.String, java.lang.Long, j46, long, boolean, java.lang.Long, long) -> SDd#<init>(java.lang.String, boolean, java.lang.String, java.lang.String, java.lang.String, java.lang.Long, Fe6, long, boolean, java.lang.Long, long)\n",
      "+ Found single candidate for Method. Considering it a match \n",
      "\tut7#n0(java.io.InputStream) -> VC7#L0(java.io.InputStream)\n",
      "Could resolve 0 new Classes, 3 new Methods, 0 new Fields.\n",
      "\n",
      "Non-Exact Matching\n",
      "\n",
      "+ Found single candidate for Method. Considering it a match \n",
      "\ty9g#f(Su5) -> uxg#f(sF5)\n",
      "Could resolve 0 new Classes, 1 new Methods, 0 new Fields.\n"
     ]
    }
   ],
   "source": [
    "def method_strategy(r_cas, r_mas, r_fas):\n",
    "    method_s = methods_strategy.MethodStrategy(dx, dx2, r_cas, r_mas, r_fas, accumulator)\n",
    "\n",
    "    print(\"Exact Matching\")\n",
    "    print()\n",
    "\n",
    "    # Exact Matches\n",
    "    candidates_ms = method_s.try_resolve_ms(True)\n",
    "    accumulator.add_candidates(candidates_ms=candidates_ms)\n",
    "\n",
    "    print()\n",
    "    print(\"Non-Exact Matching\")\n",
    "    print()\n",
    "\n",
    "    method_s.update_matched()\n",
    "    # Non-Exact Matches by using weights on the criteria\n",
    "    candidates_ms = method_s.try_resolve_ms(False)\n",
    "    accumulator.add_candidates(candidates_ms=candidates_ms)\n",
    "    \n",
    "strategies.add_strategy(method_strategy, FLAG_METHOD)\n",
    "strategies.invoke_strategies(r_cas, r_mas, r_fas, only_new=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Field Strategy\n",
    "\n",
    "Gathers all fields of matching Class and filters using the following criteria:\n",
    "* By Type if a matching Type has been found\n",
    "* By weighted sub-criteria such as:\n",
    "  * Access Flags\n",
    "  * Size\n",
    "  * Number of reads & Number of writes\n",
    "* By Index if the list of Fields has not changed dramatically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def field_strategy(r_cas, r_mas, r_fas):\n",
    "    field_s = fields_strategy.FieldStrategy(*s_args)\n",
    "    \n",
    "    print(\"Resolving Types of Fields\")\n",
    "    strategies.invoke_strategies(tuple(field_s.get_types_to_match()))\n",
    "    print()\n",
    "    \n",
    "    candidates_fs = field_s.try_resolve_fs()\n",
    "    \n",
    "    accumulator.add_candidates(candidates_fs=candidates_fs)\n",
    "    \n",
    "strategies.add_strategy(field_strategy, FLAG_FIELD)\n",
    "strategies.invoke_strategies(r_cas, r_mas, r_fas, only_new=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results\n",
    "Display summary and matching pairs.\n",
    "\n",
    "Output to compatible MethodDec input to update from auto-updated values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 / 11 Classes were matched\n",
      "5 / 5 Methods were matched\n",
      "0 / 0 Fields were matched\n",
      "\n",
      "Matching Classes:\n",
      "• Zf6 -> Fq6\n",
      "• ut7 -> VC7\n",
      "• y9g -> uxg\n",
      "• tRi -> Vfj\n",
      "• hgd -> SDd\n",
      "• com.snap.previewtools.caption.ui.CaptionEditTextView -> com.snap.previewtools.caption.ui.CaptionEditTextView\n",
      "\n",
      "Matching Methods:\n",
      "• Zf6#a(Zf6, Yf6) -> Fq6#a(Fq6, Eq6)\n",
      "• tRi#Z(Ikf, Haf) -> Vfj#a0(aIf, byf)\n",
      "• hgd#<init>(java.lang.String, boolean, java.lang.String, java.lang.String, java.lang.String, java.lang.Long, j46, long, boolean, java.lang.Long, long) -> SDd#<init>(java.lang.String, boolean, java.lang.String, java.lang.String, java.lang.String, java.lang.Long, Fe6, long, boolean, java.lang.Long, long)\n",
      "• ut7#n0(java.io.InputStream) -> VC7#L0(java.io.InputStream)\n",
      "• y9g#f(Su5) -> uxg#f(sF5)\n",
      "\n",
      "Matching Fields:\n"
     ]
    }
   ],
   "source": [
    "print(len(accumulator.matching_cs), \"/\", len(c_decs), \"Classes were matched\")\n",
    "print(len(accumulator.matching_ms), \"/\", len(m_decs), \"Methods were matched\")\n",
    "print(len(accumulator.matching_fs), \"/\", len(f_decs), \"Fields were matched\")\n",
    "\n",
    "print()\n",
    "print(\"Matching Classes:\")\n",
    "for c1, c2 in accumulator.matching_cs.items():\n",
    "    print(\"•\", pretty_format_class(c1), \"->\", pretty_format_class(c2))\n",
    "\n",
    "print()\n",
    "print(\"Matching Methods:\")\n",
    "for m, ma in accumulator.matching_ms.items():\n",
    "    print(\"•\", pretty_format_ma(m), \"->\", pretty_format_ma(ma))\n",
    "\n",
    "print()\n",
    "print(\"Matching Fields:\")\n",
    "for fa, fa2 in accumulator.matching_fs.items():\n",
    "    print(\"•\", pretty_format_fa(fa), \"->\", pretty_format_fa(fa2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m_decs = (\n",
      "    MethodDec('Fq6', 'a', 'Fq6', 'Eq6'),\n",
      "    MethodDec('Vfj', 'a0', 'aIf', 'byf'),\n",
      "    MethodDec('SDd', '<init>', 'java.lang.String', 'boolean', 'java.lang.String', 'java.lang.String', 'java.lang.String', 'java.lang.Long', 'Fe6', 'long', 'boolean', 'java.lang.Long', 'long'),\n",
      "    MethodDec('uxg', 'f', 'sF5'),\n",
      "    MethodDec('VC7', 'L0', 'java.io.InputStream'),\n",
      ")\n",
      "c_decs = (\n",
      "    'Fq6'\n",
      "    'Vfj'\n",
      "    'SDd'\n",
      "    'uxg'\n",
      "    'VC7'\n",
      "    'Fq6'\n",
      "    'Vfj'\n",
      "    'SDd'\n",
      "    'uxg'\n",
      "    'VC7'\n",
      "    'com.snap.previewtools.caption.ui.CaptionEditTextView',\n",
      ")\n",
      "f_decs = (\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "generate.generate_m_decs(m_decs, r_mas, accumulator.matching_ms)\n",
    "generate.generate_c_decs(c_decs, r_cas, accumulator.matching_cs)\n",
    "generate.generate_f_decs(f_decs, r_fas, accumulator.matching_fs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warnings\n",
    "\n",
    "Shows some warnings that result in common bugs, so that the Hooks (or other kind of modifications applied) must be updated logic-wise. \n",
    "\n",
    "Currently supports: \n",
    "* Change in number of parameters "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for m_old, m_new in accumulator.matching_ms.items():\n",
    "    def get_number_of_params(m):\n",
    "        return len(tuple(get_pretty_params(str(m.get_descriptor()))))\n",
    "    \n",
    "    if get_number_of_params(m_old) != get_number_of_params(m_new):\n",
    "        print(\"Warning: Number of parameters changed for:\", pretty_format_ma(m_old), \"-\", pretty_format_ma(m_new))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interoptability with Akrolyb\n",
    "\n",
    "GraphGuard was build with Akrolyb in mind and has full Akrolyb support, meaning that it is not only capable of automatically matching the given declarations, but also automatically editing the \"declaration file\" to update matched declarations and mark unmatched items with a `/* TODO */` comment.\n",
    "\n",
    "The following Code snippet allows to \"extract\" MethodDecs from MemberDeclarations in Akrolyb. This automates the process of providing GraphGuard the hooks it should find. See [this](#List-of-Classes,-Methods-and-Fields) to learn how to use GraphGuard's Akrolyb Support."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extract\n",
    "\n",
    "It is not in Python, since it would require a Kotlin Parser and evaluating imports, variables etc. Just executing the Constructors in Kotlin, then getting the values is much easier than static analysis. \n",
    "\n",
    "The `main` function can (and should) be run statically (locally on the machine and not on your Android) to build the list of `MethodDec`s that GraphGuard is supposed to match in an updated build of the target application. Adjust the MemberDeclarations Class to the Class where you declared the `MemberDeclaration`s.\n",
    "\n",
    "\n",
    "```kotlin\n",
    "fun main() {\n",
    "    GraphGuard.printGeneratedDecs(ClassDecs, MemberDecs, VariableDecs)\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_dir = \"/home/jaqxues/CodeProjects/StudioProjects/SnipTools/\"\n",
    "c_file = file_dir + \"packimpl/src/main/java/com/jaqxues/sniptools/packimpl/hookdec/ClassDeclarations.kt\"\n",
    "m_file = file_dir + \"packimpl/src/main/java/com/jaqxues/sniptools/packimpl/hookdec/MemberDeclarations.kt\"\n",
    "p_file = f_file = \"/dev/null\"\n",
    "\n",
    "# file_dir = \"/home/jaqxues/CodeProjects/StudioProjects/Instaprefs/\"\n",
    "# c_file = file_dir + \"packimpl/src/main/java/com/marz/instaprefs/packimpl/decs/armv8/ClassDecsV8.kt\"\n",
    "# m_file = file_dir + \"packimpl/src/main/java/com/marz/instaprefs/packimpl/decs/armv8/MemberDecsV8.kt\"\n",
    "# f_file = file_dir + \"packimpl/src/main/java/com/marz/instaprefs/packimpl/decs/armv8/VariableDecsV8.kt\"\n",
    "\n",
    "# p_file = file_dir + \"pro_packimpl/src/main/java/com/marz/instaprefs/pro_packimpl/decs/PDecsV8.kt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_txt = io_akrolyb.replace_cs_f(c_file, accumulator)\n",
    "m_txt = io_akrolyb.replace_ms_f(m_file, accumulator, named_m_decs)\n",
    "f_txt = io_akrolyb.replace_fs_f(f_file, accumulator, named_f_decs)\n",
    "\n",
    "pctnt = io_akrolyb.replace_cs_f(p_file, accumulator)\n",
    "pctnt = io_akrolyb.replace_ms(pctnt, accumulator, named_m_decs)\n",
    "pctnt = io_akrolyb.replace_fs(pctnt, accumulator, named_f_decs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "package com.jaqxues.sniptools.packimpl.hookdec\n",
      "\n",
      "import com.jaqxues.akrolyb.genhook.decs.ClassDec\n",
      "\n",
      "object ClassDeclarations {\n",
      "    val SCREENSHOT_DETECTOR = ClassDec(\"Fq6\")\n",
      "    val STORY_VIEWED_PLUGIN = ClassDec(\"Vfj\")\n",
      "    val SNAP_MODEL = ClassDec(\"SDd\")\n",
      "    val APP_START_EXPERIMENT_MANAGER = ClassDec(\"uxg\")\n",
      "    val CBC_ENCRYPTION_ALGORITHM = ClassDec(\"VC7\")\n",
      "    val CAPTION_EDIT_TEXT_VIEW = ClassDec(\"com.snap.previewtools.caption.ui.CaptionEditTextView\")\n",
      "}\n",
      "package com.jaqxues.sniptools.packimpl.hookdec\n",
      "\n",
      "import com.jaqxues.akrolyb.genhook.decs.MemberDec.ConstructorDec\n",
      "import com.jaqxues.akrolyb.genhook.decs.MemberDec.MethodDec\n",
      "import com.jaqxues.sniptools.packimpl.features.*\n",
      "import com.jaqxues.sniptools.packimpl.hookdec.ClassDeclarations.APP_START_EXPERIMENT_MANAGER\n",
      "import com.jaqxues.sniptools.packimpl.hookdec.ClassDeclarations.CBC_ENCRYPTION_ALGORITHM\n",
      "import com.jaqxues.sniptools.packimpl.hookdec.ClassDeclarations.SCREENSHOT_DETECTOR\n",
      "import com.jaqxues.sniptools.packimpl.hookdec.ClassDeclarations.SNAP_MODEL\n",
      "import com.jaqxues.sniptools.packimpl.hookdec.ClassDeclarations.STORY_VIEWED_PLUGIN\n",
      "import java.io.InputStream\n",
      "\n",
      "object MemberDeclarations {\n",
      "    val SCREENSHOT_DETECTED = MethodDec(\n",
      "        SCREENSHOT_DETECTOR,\n",
      "        \"a\",\n",
      "        arrayOf(ScreenshotBypass::class.java),\n",
      "\n",
      "        SCREENSHOT_DETECTOR, \"Eq6\"\n",
      "    )\n",
      "\n",
      "    val MARK_STORY_AS_VIEWED = MethodDec(\n",
      "        STORY_VIEWED_PLUGIN,\n",
      "        \"a0\",\n",
      "        arrayOf(StealthViewing::class.java),\n",
      "\n",
      "        \"aIf\", \"byf\"\n",
      "    )\n",
      "\n",
      "    val SNAP_MODEL_CONSTRUCTOR = ConstructorDec(\n",
      "        SNAP_MODEL,\n",
      "        arrayOf(UnlimitedViewing::class.java),\n",
      "\n",
      "        String::class.java, Boolean::class.java, String::class.java, String::class.java,\n",
      "        String::class.java, Long::class.javaObjectType, \"Fe6\", Long::class.java,\n",
      "        Boolean::class.java, Long::class.javaObjectType, Long::class.java\n",
      "    )\n",
      "\n",
      "    val FORCE_APP_DECK = MethodDec(\n",
      "        APP_START_EXPERIMENT_MANAGER,\n",
      "        \"f\",\n",
      "        arrayOf(MiscFeatures::class.java),\n",
      "\n",
      "        \"sF5\"\n",
      "    )\n",
      "\n",
      "    val DECRYPT_MEDIA_STREAM = MethodDec(\n",
      "        CBC_ENCRYPTION_ALGORITHM,\n",
      "        \"L0\",\n",
      "        arrayOf(SavingFeature::class.java),\n",
      "\n",
      "        InputStream::class.java\n",
      "    )\n",
      "}\n",
      "/dev/null\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(c_txt)\n",
    "print(m_txt)\n",
    "print(f_txt)\n",
    "print(pctnt)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "graphguard_venv",
   "language": "python",
   "name": "graphguard_venv"
  },
  "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}