Add mult graphs visualization.

Author: J08nY

analysis/scalarmults/epare/config.py

@@ -3,6 +3,7 @@
 from enum import Enum
 from functools import total_ordering
 from typing import Any, Optional, Type
+from anytree import Node
 
 from pyecsca.ec.countermeasures import (
     GroupScalarRandomization,
@@ -43,7 +44,11 @@ def mult(self):
         """
         Extract the MultIdent out of the Composable.
 
-        We assume there is only one somewhere in the tree (at the leafs).
+        We assume there is only one somewhere in the tree
+        (in all the leafs). We also assume the Composable only has up to 3 layers:
+          Countermeasure(Countermeasure(Mult)), or
+          Countermeasure(Mult), or
+          Mult
         """
         if isinstance(self, MultIdent):
             return self
@@ -54,6 +59,30 @@ def mult(self):
             if isinstance(kwarg, Composable):
                 return kwarg.mult
 
+    def walk(self, callback):
+        """
+        Recursively walk the Composable, applying the callback.
+        """
+        callback(self)
+        for arg in self.args:
+            if isinstance(arg, Composable):
+                arg.walk(callback)
+        for kwarg in self.kwargs.values():
+            if isinstance(kwarg, Composable):
+                kwarg.walk(callback)
+
+    def tree(self) -> Node:
+        me = Node(self)
+        children = []
+        for arg in self.args:
+            if isinstance(arg, Composable):
+                children.append(arg.tree())
+        for kwarg in self.kwargs.values():
+            if isinstance(kwarg, Composable):
+                children.append(kwarg.tree())
+        me.children = children
+        return me
+
     def construct(self, *mult_args, **mult_kwargs):
         """Recursively construct this composable."""
         args, kwargs = self._build_args_kwargs(mult_args, mult_kwargs)
@@ -242,6 +271,13 @@ def mult(self):
     def has_countermeasure(self):
         return isinstance(self.composition, CountermeasureIdent)
 
+    @property
+    def countermeasures(self) -> set[CountermeasureIdent]:
+        r = set()
+        if not self.has_countermeasure:
+            return r
+        self.composition.walk(lambda c: r.add(c) if isinstance(c, CountermeasureIdent) else None)
+
     @property
     def has_error_model(self):
         return self.error_model is not None

analysis/scalarmults/epare/filters.py

@@ -0,0 +1,84 @@
+from pyecsca.ec.mult import LTRMultiplier, RTLMultiplier, SlidingWindowMultiplier, CombMultiplier, ProcessingDirection
+
+from epare.error_model import ErrorModel
+from epare.config import MultIdent, Config
+
+
+def only_ltr_example(config: Config, always=False, complete=False):
+    """Select single LTRMultiplier example."""
+    return config.mult.klass == LTRMultiplier and config.mult.kwargs["always"] == always and config.mult.kwargs["complete"] == complete
+
+
+def only_rtl_example(config: Config, always=False, complete=False):
+    """Select single RTLMultiplier example."""
+    return config.mult.klass == RTLMultiplier and config.mult.kwargs["always"] == always and config.mult.kwargs["complete"] == complete
+
+
+def only_sliding_example(config: Config, width=4, recoding_direction=ProcessingDirection.LTR):
+    """Select single SlidingWindow example."""
+    return config.mult.klass == SlidingWindowMultiplier and config.mult.kwargs["width"] == width and config.mult.kwargs["recoding_direction"] == recoding_direction
+
+
+def only_comb_example(config: Config, width=4, always=True):
+    """Select single Comb example."""
+    return config.mult.klass == CombMultiplier and config.mult.kwargs["width"] == width and config.mult.kwargs["always"] == always
+
+
+def only_ltrs(config: Config):
+    """Select all LTRs."""
+    return config.mult.klass == LTRMultiplier
+
+
+def only_rtls(config: Config):
+    """Select all RTLs."""
+    return config.mult.klass == RTLMultiplier
+
+
+def only_slidingws(config: Config):
+    """Select all SlidingWindows."""
+    return config.mult.klass == SlidingWindowMultiplier
+
+
+def only_combs(config: Config):
+    """Select all Combs (not BGMW)."""
+    return config.mult.klass == CombMultiplier
+
+
+def no_combs(config: Config):
+    """Select all but Comb and BGMW."""
+    return config.mult.klass not in (CombMultiplier, BGMWMultiplier)
+
+
+def single_layer_ctr(config: Config):
+    """Select configs with only a single countermeasure."""
+    return all(map(lambda ident: isinstance(ident, MultIdent), config.composition.args))
+
+
+def single_type_ctr(config: Config):
+    """Select configs with only a single type of countermeasure (can be nested)."""
+    return all(map(lambda ident: isinstance(ident, MultIdent) or ident.klass == config.composition.klass, config.composition.args))
+
+
+def single_type_ctr_full(config: Config):
+    """Select configs with only a single type of countermeasure that is fully nested."""
+    return all(map(lambda ident: ident.klass == config.composition.klass, config.composition.args))
+
+
+def fixed_error_model(config: Config):
+    """Select a single example error model."""
+    return config.error_model == ErrorModel({"divides"}, "all", True)
+
+
+def fixed_no_countermeasure(config: Config):
+    """Select configs with no countermeasures."""
+    return not config.has_countermeasure
+
+
+def has_gsr(config: Config):
+    """Select configs with GSR."""
+    return any(lambda ident: ident.klass == GroupScalarRandomization, config.countermeasures)
+
+
+
+
+

analysis/scalarmults/graphs.ipynb

@@ -10,7 +10,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "3232df80-2a65-47ce-bc77-6a64f44d2404",
    "metadata": {},
    "outputs": [],
@@ -36,6 +36,7 @@
     "from epare.config import all_configs, Config, MultIdent, CountermeasureIdent\n",
     "from epare.prob_map import ProbMap\n",
     "from epare.error_model import ErrorModel\n",
+    "from epare.filters import *\n",
     "\n",
     "if sys.version_info >= (3, 14):\n",
     "    from compression import zstd\n",
@@ -56,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "e89e66dc-4a9b-4320-8612-a8fa9af04b69",
    "metadata": {},
    "outputs": [],
@@ -79,10 +80,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "bab2a086-8b3d-4e76-bf5c-46ea2b617708",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "small_primes                [3, 5, 7] ... [199]\n",
+      "medium_primes               [211, 223, 227] ... [397]\n",
+      "large_primes                [401, 409, 419] ... [997]\n",
+      "all_primes                  [3, 5, 7] ... [997]\n",
+      "all_integers                [1, 2, 3] ... [399]\n",
+      "all_even                    [2, 4, 6] ... [398]\n",
+      "all_odd                     [1, 3, 5] ... [399]\n",
+      "powers_of_2                 [2, 4, 8] ... [524288]\n",
+      "powers_of_2_large           [2, 4, 8] ... [57896044618658097711785492504343953926634992332820282019728792003956564819968]\n",
+      "powers_of_2_large_3         [6, 12, 24] ... [173688133855974293135356477513031861779904976998460846059186376011869694459904]\n",
+      "powers_of_2_large_p1        [3, 5, 9] ... [57896044618658097711785492504343953926634992332820282019728792003956564819969]\n",
+      "powers_of_2_large_m1        [1, 3, 7] ... [57896044618658097711785492504343953926634992332820282019728792003956564819967]\n",
+      "powers_of_2_large_pmautobus [1, 2, 3] ... [57896044618658097711785492504343953926634992332820282019728792003956564819972]\n",
+      "powers_of_3                 [3, 9, 27] ... [1162261467]\n",
+      "all                         [1, 2, 3] ... [173688133855974293135356477513031861779904976998460846059186376011869694459904]\n"
+     ]
+    }
+   ],
    "source": [
     "from epare.divisors import divisor_map\n",
     "for d, ds in divisor_map.items():\n",
@@ -100,7 +123,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "19d986ab-5fe7-4dd6-b5b5-4e75307217d6",
    "metadata": {},
    "outputs": [],
@@ -137,13 +160,14 @@
     "plot_divisors = divisor_map[\"small_primes\"]\n",
     "\n",
     "# Here are several useful filters when playing around with the data. We want to select a single multiplier and countereasure combination.\n",
-    "only_ltr_example = lambda config: config.mult.klass == LTRMultiplier and not config.mult.kwargs[\"always\"] and not config.mult.kwargs[\"complete\"]\n",
-    "only_rtl_example = lambda config: config.mult.klass == RTLMultiplier and not config.mult.kwargs[\"always\"] and not config.mult.kwargs[\"complete\"]\n",
-    "only_sliding_example = lambda config: config.mult.klass == SlidingWindowMultiplier and config.mult.kwargs[\"width\"] == 4 and config.mult.kwargs[\"recoding_direction\"] == ProcessingDirection.LTR\n",
-    "only_comb_example = lambda config: config.mult.klass == CombMultiplier and config.mult.kwargs[\"width\"] == 4 and config.mult.kwargs[\"always\"] == True\n",
-    "single_layer_ctr = lambda config: all(map(lambda ident: isinstance(ident, MultIdent), config.composition.args))\n",
-    "single_type_ctr = lambda config: all(map(lambda ident: isinstance(ident, MultIdent) or ident.klass == config.composition.klass, config.composition.args))\n",
-    "single_type_ctr_full = lambda config: all(map(lambda ident: ident.klass == config.composition.klass, config.composition.args))\n",
+    "# See the filters module for more.\n",
+    "#   only_ltr_example\n",
+    "#   only_rtl_example\n",
+    "#   only_sliding_example\n",
+    "#   only_comb_example\n",
+    "#   single_layer_ctr\n",
+    "#   single_type_ctr\n",
+    "#   single_type_ctr_full\n",
     "\n",
     "groups = {}\n",
     "for config, probmap in config_map.items():\n",
@@ -234,15 +258,15 @@
     "plot_divisors = divisor_map[\"small_primes\"]\n",
     "\n",
     "# Here are several useful filters when playing around with the data. We want to select a single multiplier and error model.\n",
-    "only_ltr_example = lambda config: config.mult.klass == LTRMultiplier and not config.mult.kwargs[\"always\"] and not config.mult.kwargs[\"complete\"]\n",
-    "only_rtl_example = lambda config: config.mult.klass == RTLMultiplier and not config.mult.kwargs[\"always\"] and not config.mult.kwargs[\"complete\"]\n",
-    "only_sliding_example = lambda config: config.mult.klass == SlidingWindowMultiplier and config.mult.kwargs[\"width\"] == 4 and config.mult.kwargs[\"recoding_direction\"] == ProcessingDirection.LTR\n",
-    "only_comb_example = lambda config: config.mult.klass == CombMultiplier and config.mult.kwargs[\"width\"] == 4 and config.mult.kwargs[\"always\"] == True\n",
-    "\n",
-    "fixed_error_model = lambda config: config.error_model == ErrorModel({\"divides\"}, \"all\", True)\n",
-    "single_layer_ctr = lambda config: all(map(lambda ident: isinstance(ident, MultIdent), config.composition.args))\n",
-    "single_type_ctr = lambda config: all(map(lambda ident: isinstance(ident, MultIdent) or ident.klass == config.composition.klass, config.composition.args))\n",
-    "single_type_ctr_full = lambda config: all(map(lambda ident: ident.klass == config.composition.klass, config.composition.args))\n",
+    "# See the filters module for more.\n",
+    "#   only_ltr_example\n",
+    "#   only_rtl_example\n",
+    "#   only_sliding_example\n",
+    "#   only_comb_example\n",
+    "#   fixed_error_model\n",
+    "#   single_layer_ctr\n",
+    "#   single_type_ctr\n",
+    "#   single_type_ctr_full\n",
     "\n",
     "groups = {}\n",
     "for config, probmap in config_map.items():\n",
@@ -324,15 +348,18 @@
     "plot_divisors = divisor_map[\"small_primes\"]\n",
     "\n",
     "# Here are several useful filters when playing around with the data. We want to select a single countermeasure config and error_model\n",
-    "only_ltrs = lambda config: config.mult.klass == LTRMultiplier\n",
-    "only_rtls = lambda config: config.mult.klass == RTLMultiplier\n",
-    "only_slidings = lambda config: config.mult.klass == SlidingWindowMultiplier\n",
-    "only_combs = lambda config: config.mult.klass == CombMultiplier\n",
-    "no_combs = lambda config: config.mult.klass not in (CombMultiplier, BGMWMultiplier)\n",
-    "\n",
-    "fixed_error_model = lambda config: config.error_model == ErrorModel({\"divides\"}, \"all\", True)\n",
-    "fixed_no_countermeasure = lambda config: isinstance(config.composition, MultIdent)\n",
-    "fixed_gsr_countermeasure = lambda config: config.composition.klass == GroupScalarRandomization\n",
+    "# See the filters module for more.\n",
+    "#   only_ltrs\n",
+    "#   only_rtls\n",
+    "#   only_slidingws\n",
+    "#   only_combs\n",
+    "#   no_combs\n",
+    "#   fixed_error_model\n",
+    "#   fixed_no_countermeasure\n",
+    "#   single_layer_ctr\n",
+    "#   single_type_ctr\n",
+    "#   single_type_ctr_full\n",
+    "#   has_gsr\n",
     "\n",
     "groups = {}\n",
     "for config, probmap in config_map.items():\n",
@@ -426,18 +453,23 @@
     "plot_divisors = divisor_map[\"small_primes\"]\n",
     "\n",
     "# Here are several useful filters when playing around with the data. We want to select a single countermeasure config and error_model\n",
-    "only_ltrs = lambda config: config.mult.klass == LTRMultiplier\n",
-    "only_rtls = lambda config: config.mult.klass == RTLMultiplier\n",
-    "only_slidings = lambda config: config.mult.klass == SlidingWindowMultiplier\n",
-    "only_combs = lambda config: config.mult.klass == CombMultiplier\n",
+    "# See the filters module for more.\n",
+    "#   only_ltrs\n",
+    "#   only_rtls\n",
+    "#   only_slidingws\n",
+    "#   only_combs\n",
+    "#   no_combs\n",
+    "#   fixed_error_model\n",
+    "#   fixed_no_countermeasure\n",
+    "#   single_layer_ctr\n",
+    "#   single_type_ctr\n",
+    "#   single_type_ctr_full\n",
+    "#   has_gsr\n",
     "\n",
-    "fixed_error_model = lambda config: config.error_model == ErrorModel({\"divides\"}, \"all\", True)\n",
-    "fixed_no_countermeasure = lambda config: isinstance(config.composition, MultIdent)\n",
-    "fixed_gsr_countermeasure = lambda config: config.composition.klass == GroupScalarRandomization\n",
     "\n",
     "groups = {}\n",
     "for config, probmap in config_map.items():\n",
-    "    if fixed_error_model(config) and fixed_no_countermeasure(config) and only_slidings(config):\n",
+    "    if fixed_error_model(config) and fixed_no_countermeasure(config) and only_slidingws(config):\n",
     "        plot_configs.append(config)\n",
     "        pmap = deepcopy(probmap)\n",
     "        pmap.narrow(plot_divisors)\n",
@@ -495,6 +527,14 @@
     "plt.close();"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "7995e2b5-550e-423e-b51c-f40f10c66cc3",
+   "metadata": {},
+   "source": [
+    "## Misc (broken)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,