maltorch 0.1__tar.gz

maltorch-0.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: maltorch
+Version: 0.1
+Summary: Pytorch-based library for creating Adversarial EXEmples against Windows Malware detectors.
+Home-page: 
+Author: Luca Demetrio, Daniel Gibert, Andrea Ponte, Maura Pintor
+Author-email: luca.demetrio@unige.it
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: secml-torch
+Requires-Dist: lightgbm==3.3.5
+Requires-Dist: lief
+Requires-Dist: nevergrad
+Requires-Dist: joblib>=1.3.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+ # Maltorch: Pentesting of AI-based Windows Malware Detectors
+
+## Installation
+```bash
+pip install maltoch
+pip install git+https://github.com/zangobot/ember.git
+```

maltorch-0.1/README.md

@@ -0,0 +1,7 @@
+ # Maltorch: Pentesting of AI-based Windows Malware Detectors
+
+## Installation
+```bash
+pip install maltoch
+pip install git+https://github.com/zangobot/ember.git
+```

maltorch-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maltorch-0.1/setup.py

@@ -0,0 +1,63 @@
+import pathlib
+
+from setuptools import find_packages, setup
+
+here = pathlib.Path.cwd()
+readme_path = here / "README.md"
+version_path = here / "src" / "maltorch" / "VERSION"
+
+CLASSIFIERS = """\
+Development Status :: 3 - Alpha
+Intended Audience :: Science/Research
+Intended Audience :: Developers
+License :: OSI Approved
+Programming Language :: Python
+Programming Language :: Python :: 3
+Programming Language :: Python :: 3.8
+Programming Language :: Python :: 3.9
+Programming Language :: Python :: 3.10
+Programming Language :: Python :: Implementation :: PyPy
+Topic :: Software Development
+Topic :: Scientific/Engineering
+"""
+
+# Get the long description from the README file
+with readme_path.open() as f:
+    long_description = f.read()
+
+# Get the version from VERSION file
+with version_path.open() as f:
+    version = f.read()
+
+setup(
+    name='maltorch',
+    version=version,
+    packages=find_packages(
+        where="src",
+        exclude=[
+            "*.tests",
+            "*.tests.*",
+            "tests.*",
+            "tests",
+        ],
+    ),
+    package_dir={'': 'src'},
+    classifiers=[_f for _f in CLASSIFIERS.split("\n") if _f],
+    data_files=[("src/maltorch/VERSION", ["src/maltorch/VERSION"])],
+    url='',
+    license='MIT',
+    author='Luca Demetrio, Daniel Gibert, Andrea Ponte, Maura Pintor',
+    author_email='luca.demetrio@unige.it',
+    description='Pytorch-based library for creating Adversarial EXEmples against Windows Malware detectors.',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    install_requires=[
+        'torch',
+        'torchvision',
+        'secml-torch',
+        'lightgbm==3.3.5',
+        'lief',
+        'nevergrad',
+        'joblib>=1.3.2'
+    ],
+)

maltorch-0.1/src/maltorch/VERSION

@@ -0,0 +1 @@
+0.1

maltorch-0.1/src/maltorch/adv/evasion/__init__.py

@@ -0,0 +1 @@
+

maltorch-0.1/src/maltorch/adv/evasion/backend_attack.py

@@ -0,0 +1,122 @@
+from typing import Union, List, Callable
+
+import torch
+from secmlt.adv.evasion.base_evasion_attack import BaseEvasionAttack
+from secmlt.models.base_model import BaseModel
+from secmlt.optimization.initializer import Initializer
+from secmlt.trackers import Tracker
+
+from maltorch.manipulations.byte_manipulation import ByteManipulation
+
+
+class BackendAttack(BaseEvasionAttack):
+    @classmethod
+    def _trackers_allowed(cls):
+        return True
+
+    @staticmethod
+    def get_perturbation_models():
+        pass
+
+    def __init__(
+        self,
+        y_target: Union[int, None],
+        query_budget: int,
+        loss_function: Union[str, torch.nn.Module],
+        optimizer_cls: Callable,
+        manipulation_function: ByteManipulation,
+        initializer: Initializer,
+        trackers: Union[List[Tracker], Tracker] = None,
+        **kwargs
+    ):
+        self.y_target = y_target
+        self.query_budget = query_budget
+        self.loss_function = loss_function
+        self.manipulation_function = manipulation_function
+        self.initializer = initializer
+        self.trackers = trackers
+        self.optimizer = None
+        self.optimizer_cls = optimizer_cls
+        self._best_loss = None
+        self._best_delta = None
+
+    def _init_attack_manipulation(
+        self, samples: torch.Tensor
+    ) -> (torch.Tensor, torch.Tensor):
+        return self.manipulation_function.initialize(samples.data)
+
+    def _apply_manipulation(
+        self, x: torch.Tensor, delta: torch.Tensor
+    ) -> (torch.Tensor, torch.Tensor):
+        raise NotImplementedError()
+
+    def _optimizer_step(self, delta: torch.Tensor, loss: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError()
+
+    def _init_optimizer(self, model: BaseModel, delta: torch.Tensor) -> Callable:
+        raise NotImplementedError()
+
+    def _consumed_budget(self):
+        raise NotImplementedError()
+
+    def _init_best_tracking(self, delta: torch.Tensor):
+        self._best_delta = torch.zeros_like(delta.detach().cpu())
+        self._best_loss = torch.zeros((delta.shape[0], 1)).fill_(torch.inf)
+
+    def _track_best(self, loss: torch.Tensor, delta: torch.Tensor):
+        where_best = (loss < self._best_loss).squeeze(1)
+        self._best_delta[where_best] = delta[where_best]
+        self._best_loss[where_best] = loss[where_best]
+
+    def _get_best_delta(self):
+        return self._best_delta
+
+    def _track(
+        self,
+        iteration: int,
+        loss: torch.Tensor,
+        scores: torch.Tensor,
+        x_adv: torch.Tensor,
+        delta: torch.Tensor,
+    ):
+        if self._trackers_allowed():
+            if self.trackers:
+                for tracker in self.trackers:
+                    tracker.track(
+                        iteration=iteration,
+                        loss=loss.data,
+                        scores=scores.data,
+                        x_adv=x_adv.data,
+                        delta=delta,
+                        grad=None,
+                    )
+
+    def _run(
+        self,
+        model: BaseModel,
+        samples: torch.Tensor,
+        labels: torch.Tensor,
+        **optim_kwargs,
+    ) -> (torch.Tensor, torch.Tensor):
+        multiplier = 1 if self.y_target is not None else -1
+        target = (
+            torch.zeros_like(labels) + self.y_target
+            if self.y_target is not None
+            else labels
+        ).type(labels.dtype)
+        target = target.to(labels.device)
+        x_adv, delta = self._init_attack_manipulation(samples)
+        self.optimizer = self._init_optimizer(model, delta)
+        budget = 0
+        self._init_best_tracking(delta)
+        while budget < self.query_budget:
+            x_adv, _ = self._apply_manipulation(samples, delta)
+            scores = model.decision_function(x_adv)
+            loss = self.loss_function(scores, target) * multiplier
+            delta = self._optimizer_step(delta, loss)
+            budget += self._consumed_budget()
+            self._track(budget, loss, scores, x_adv, delta)
+            self._track_best(loss, delta)
+        best_delta = self._get_best_delta()
+        best_x, _ = self._apply_manipulation(samples, best_delta)
+        return best_x, self._best_delta

maltorch-0.1/src/maltorch/adv/evasion/base_optim_attack_creator.py

@@ -0,0 +1,114 @@
+import importlib
+from abc import abstractmethod
+from typing import Type
+
+from maltorch.adv.evasion.backend_attack import BackendAttack
+
+
+class OptimizerBackends:
+    """Available backends."""
+
+    NG = "nevergrad"
+    GRADIENT = "gradient"
+
+
+class BaseOptimAttackCreator:
+    """Generic creator for attacks."""
+
+    @classmethod
+    def get_implementation(cls, backend: str) -> Type[BackendAttack]:
+        """
+        Get the implementation of the attack with the given backend.
+
+        Parameters
+        ----------
+        backend : str
+            The backend for the attack. See secmlt.adv.backends for
+            available backends.
+
+        Returns
+        -------
+        BaseEvasionAttack
+            Attack implementation.
+        """
+        implementations = {
+            OptimizerBackends.NG: cls.get_nevergrad_implementation,
+            OptimizerBackends.GRADIENT: cls._get_native_implementation,
+        }
+        cls.check_backend_available(backend)
+        return implementations[backend]()
+
+    @classmethod
+    def check_backend_available(cls, backend: str) -> bool:
+        """
+        Check if a given backend is available for the attack.
+
+        Parameters
+        ----------
+        backend : str
+            Backend string.
+
+        Returns
+        -------
+        bool
+            True if the given backend is implemented.
+
+        Raises
+        ------
+        NotImplementedError
+            Raises NotImplementedError if the requested backend is not in
+            the list of the possible backends (check secmlt.adv.backends).
+        """
+        if backend in cls.get_backends():
+            return True
+        msg = "Unsupported or not-implemented backend."
+        raise NotImplementedError(msg)
+
+    @classmethod
+    def get_nevergrad_implementation(cls) -> BackendAttack:
+        """
+        Get the Nevergrad implementation of the attack.
+
+        Returns
+        -------
+        BaseEvasionAttack
+            Nevergrad implementation of the attack.
+
+        Raises
+        ------
+        ImportError
+            Raises ImportError if Nevergrad extra is not installed.
+        """
+        if importlib.util.find_spec("nevergrad", None) is not None:
+            return cls._get_nevergrad_implementation()
+        msg = "Nevergrad extra not installed."
+        raise ImportError(msg)
+
+    @staticmethod
+    def _get_nevergrad_implementation() -> BackendAttack:
+        msg = "Nevergrad implementation not available."
+        raise NotImplementedError(msg)
+
+    @staticmethod
+    def _get_native_implementation() -> BackendAttack:
+        msg = "Native implementation not available."
+        raise NotImplementedError(msg)
+
+    @staticmethod
+    @abstractmethod
+    def get_backends() -> set[str]:
+        """
+        Get the available backends for the given attack.
+
+        Returns
+        -------
+        set[str]
+            Set of implemented backends available for the attack.
+
+        Raises
+        ------
+        NotImplementedError
+            Raises NotImplementedError if not implemented in the inherited class.
+        """
+        msg = "Backends should be specified in inherited class."
+        raise NotImplementedError(msg)

maltorch-0.1/src/maltorch/adv/evasion/content_shift.py

@@ -0,0 +1,121 @@
+from typing import Type, Union, List, Callable
+
+from secmlt.trackers import Tracker
+from torch.nn import BCEWithLogitsLoss
+
+from maltorch.adv.evasion.base_optim_attack_creator import (
+    BaseOptimAttackCreator,
+    OptimizerBackends,
+)
+from maltorch.adv.evasion.gradfree_attack import GradientFreeBackendAttack
+from maltorch.adv.evasion.gradient_attack import GradientBackendAttack
+from maltorch.initializers.content_shift_initializer import ContentShiftInitializer
+from maltorch.manipulations.replacement_manipulation import ReplacementManipulation
+from maltorch.optim.optimizer_factory import MalwareOptimizerFactory
+
+
+class ContentShiftGradFree(GradientFreeBackendAttack):
+    def __init__(
+            self,
+            query_budget: int,
+            manipulation_size: int,
+            y_target: Union[int, None] = None,
+            population_size: int = 10,
+            random_init: bool = False,
+            trackers: Union[List[Tracker], Tracker] = None,
+    ):
+        initializer = ContentShiftInitializer(
+            random_init=random_init, preferred_manipulation_size=manipulation_size
+        )
+        optimizer_cls = MalwareOptimizerFactory.create_ga(
+            population_size=population_size
+        )
+        loss_function = BCEWithLogitsLoss(reduction="none")
+        manipulation_function = ReplacementManipulation(initializer=initializer)
+        super().__init__(
+            y_target=y_target,
+            query_budget=query_budget,
+            loss_function=loss_function,
+            initializer=initializer,
+            manipulation_function=manipulation_function,
+            optimizer_cls=optimizer_cls,
+            trackers=trackers,
+        )
+
+
+class ContentShiftGrad(GradientBackendAttack):
+    def __init__(
+            self,
+            query_budget: int,
+            manipulation_size: int,
+            y_target: Union[int, None] = None,
+            random_init: bool = False,
+            step_size: int = 58,
+            device: str = "cpu",
+            trackers: Union[List[Tracker], Tracker] = None,
+    ):
+        initializer = ContentShiftInitializer(
+            random_init=random_init, preferred_manipulation_size=manipulation_size
+        )
+        optimizer_cls = MalwareOptimizerFactory.create_bgd(lr=step_size, device=device)
+        loss_function = BCEWithLogitsLoss(reduction="none")
+        manipulation_function = ReplacementManipulation(initializer=initializer)
+        super().__init__(
+            y_target=y_target,
+            query_budget=query_budget,
+            loss_function=loss_function,
+            optimizer_cls=optimizer_cls,
+            manipulation_function=manipulation_function,
+            initializer=initializer,
+            trackers=trackers,
+        )
+
+
+class ContentShift(BaseOptimAttackCreator):
+    """
+    Content Shift attack
+
+    Demetrio, L., Coull, S. E., Biggio, B., Lagorio, G., Armando, A., & Roli, F. (2021).
+    Adversarial EXEmples: A survey and experimental evaluation of practical attacks on machine learning for windows malware detection.
+        ACM Transactions on Privacy and Security (TOPS), 24(4), 1-31.
+    """
+
+    @staticmethod
+    def get_backends() -> set[str]:
+        return {OptimizerBackends.GRADIENT, OptimizerBackends.NG}
+
+    @staticmethod
+    def _get_nevergrad_implementation() -> Type[ContentShiftGradFree]:
+        return ContentShiftGradFree
+
+    @staticmethod
+    def _get_native_implementation() -> Type[ContentShiftGrad]:
+        return ContentShiftGrad
+
+    def __new__(
+            cls,
+            query_budget: int,
+            y_target: Union[int, None] = None,
+            perturbation_size: int = 512,
+            random_init: bool = False,
+            step_size: int = 16,
+            population_size: int = 10,
+            device: str = "cpu",
+            trackers: Union[List[Tracker], Tracker] = None,
+            backend: str = OptimizerBackends.GRADIENT,
+    ) -> Callable:
+        implementation: Callable = cls.get_implementation(backend)
+        if backend == OptimizerBackends.GRADIENT:
+            kwargs = {"step_size": step_size, "device": device}
+        else:
+            kwargs = {
+                "population_size": population_size,
+            }
+        return implementation(
+            query_budget=query_budget,
+            perturbation_size=perturbation_size,
+            y_target=y_target,
+            trackers=trackers,
+            random_init=random_init,
+            **kwargs,
+        )

maltorch-0.1/src/maltorch/adv/evasion/gamma_section_injection.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+from typing import Type, Union, List, Callable
+
+from secmlt.trackers import Tracker
+from torch.nn import BCEWithLogitsLoss
+
+from maltorch.adv.evasion.base_optim_attack_creator import (
+    BaseOptimAttackCreator,
+    OptimizerBackends,
+)
+from maltorch.adv.evasion.gradfree_attack import GradientFreeBackendAttack
+from maltorch.initializers.initializers import IdentityInitializer
+from maltorch.manipulations.gamma_section_injection_manipulation import GAMMASectionInjectionManipulation
+from maltorch.optim.optimizer_factory import MalwareOptimizerFactory
+
+
+class GAMMASectionInjectionGradFree(GradientFreeBackendAttack):
+    def __init__(
+            self,
+            query_budget: int,
+            benignware_folder: Path,
+            how_many_sections: int,
+            which_sections: list = None,
+            y_target: Union[int, None] = None,
+            population_size: int = 10,
+            random_init: bool = False,
+            trackers: Union[List[Tracker], Tracker] = None,
+    ):
+        if which_sections is None:
+            which_sections = ['rodata']
+        initializer = IdentityInitializer(
+            random_init=random_init
+        )
+        optimizer_cls = MalwareOptimizerFactory.create_ga(
+            population_size=population_size
+        )
+        loss_function = BCEWithLogitsLoss(reduction="none")
+        manipulation_function = GAMMASectionInjectionManipulation(benignware_folder=benignware_folder,
+                                                                  which_sections=which_sections,
+                                                                  how_many_sections=how_many_sections)
+        super().__init__(
+            y_target=y_target,
+            query_budget=query_budget,
+            loss_function=loss_function,
+            initializer=initializer,
+            manipulation_function=manipulation_function,
+            optimizer_cls=optimizer_cls,
+            trackers=trackers,
+        )
+
+
+class GAMMASectionInjection(BaseOptimAttackCreator):
+    """
+    GAMMA Section Injection attack
+
+    Demetrio, L., Biggio, B., Lagorio, G., Roli, F., & Armando, A. (2021).
+    Functionality-preserving black-box optimization of adversarial windows malware.
+    IEEE Transactions on Information Forensics and Security, 16, 3469-3478.
+    """
+
+    @staticmethod
+    def get_backends() -> set[str]:
+        return {OptimizerBackends.NG}
+
+    @staticmethod
+    def _get_nevergrad_implementation() -> Type[GAMMASectionInjectionGradFree]:
+        return GAMMASectionInjectionGradFree
+
+    def __new__(
+            cls,
+            query_budget: int,
+            benignware_folder: Path,
+            which_sections: list = None,
+            y_target: Union[int, None] = None,
+            how_many_sections: int = 75,
+            random_init: bool = False,
+            step_size: int = 16,
+            population_size: int = 10,
+            device: str = "cpu",
+            trackers: Union[List[Tracker], Tracker] = None,
+            backend: str = OptimizerBackends.NG,
+    ) -> Callable:
+        if which_sections is None:
+            which_sections = ['rodata']
+        return GAMMASectionInjectionGradFree(
+            query_budget=query_budget,
+            benignware_folder=benignware_folder,
+            how_many_sections=how_many_sections,
+            which_sections=which_sections,
+            population_size=population_size,
+            y_target=y_target,
+            trackers=trackers,
+            random_init=random_init,
+        )

maltorch-0.1/src/maltorch/adv/evasion/gradfree_attack.py

@@ -0,0 +1,70 @@
+import nevergrad
+import torch
+from nevergrad.optimization import Optimizer
+from secmlt.models.base_model import BaseModel
+from torch.utils.data import DataLoader, TensorDataset
+
+from maltorch.adv.evasion.backend_attack import BackendAttack
+
+
+class GradientFreeBackendAttack(BackendAttack):
+    def _optimizer_step(
+        self, delta: nevergrad.p.Array, loss: torch.Tensor
+    ) -> nevergrad.p.Array:
+        self.optimizer.tell(delta, loss.item())
+        delta = self.optimizer.ask()
+        return delta
+
+    def _apply_manipulation(
+        self, x: torch.Tensor, delta: nevergrad.p.Array
+    ) -> (torch.Tensor, torch.Tensor):
+        p_delta = torch.from_numpy(delta.value)
+        return self.manipulation_function(x.data, p_delta)
+
+    def _consumed_budget(self):
+        return 1
+
+    def _init_attack_manipulation(
+        self, samples: torch.Tensor
+    ) -> (torch.Tensor, nevergrad.p.Array):
+        x_adv, delta = super()._init_attack_manipulation(samples)
+        optim_delta = nevergrad.p.Array(shape=delta.shape, lower=0.0, upper=255.0)
+        optim_delta.value = delta.numpy()
+        return x_adv, optim_delta
+
+    def _init_optimizer(self, model: BaseModel, delta: nevergrad.p.Array) -> Optimizer:
+        self.optimizer = self.optimizer_cls(
+            parametrization=nevergrad.p.Array(
+                shape=delta.value.shape, lower=0.0, upper=255.0
+            )
+        )
+        return self.optimizer
+
+    def __call__(self, model: BaseModel, data_loader: DataLoader) -> DataLoader:
+        adversarials = []
+        original_labels = []
+        for samples, labels in data_loader:
+            for sample, label in zip(samples, labels):
+                sample = sample.unsqueeze(0)
+                label = label.unsqueeze(0)
+                x_adv, _ = self._run(model, sample, label)
+                adversarials.append(x_adv)
+                original_labels.append(label)
+        adversarials = (
+            torch.nn.utils.rnn.pad_sequence(adversarials, padding_value=256)
+            .squeeze()
+            .long()
+        )
+        original_labels = torch.vstack(original_labels)
+        adversarial_dataset = TensorDataset(adversarials, original_labels)
+        return DataLoader(
+            adversarial_dataset,
+            batch_size=data_loader.batch_size,
+        )
+
+    def _init_best_tracking(self, delta: torch.Tensor): ...
+
+    def _track_best(self, loss: torch.Tensor, delta: torch.Tensor): ...
+
+    def _get_best_delta(self):
+        return self.optimizer.provide_recommendation()

maltorch-0.1/src/maltorch/adv/evasion/gradient_attack.py

@@ -0,0 +1,39 @@
+import torch
+from secmlt.models.base_model import BaseModel
+
+from maltorch.adv.evasion.backend_attack import BackendAttack
+from maltorch.optim.base import BaseByteOptimizer
+
+
+class GradientBackendAttack(BackendAttack):
+    def _init_attack_manipulation(
+        self, samples: torch.Tensor
+    ) -> (torch.Tensor, torch.Tensor):
+        x_adv, delta = self.manipulation_function.initialize(samples.data)
+        delta = delta.to(samples.device)
+        delta.requires_grad = True
+        return x_adv, delta
+
+    def _apply_manipulation(
+        self, x: torch.Tensor, delta: torch.Tensor
+    ) -> (torch.Tensor, torch.Tensor):
+        x.data, delta.data = self.manipulation_function(x.data, delta.data)
+        return x, delta
+
+    def _init_optimizer(
+        self, model: BaseModel, delta: torch.Tensor
+    ) -> BaseByteOptimizer:
+        self.optimizer = self.optimizer_cls(
+            [delta],
+            indexes_to_perturb=self.manipulation_function.indexes_to_perturb,
+            model=model,
+        )
+        return self.optimizer
+
+    def _optimizer_step(self, delta: torch.Tensor, loss: torch.Tensor) -> torch.Tensor:
+        loss.sum().backward()
+        self.optimizer.step()
+        return delta
+
+    def _consumed_budget(self):
+        return 2