configextractor-py 1.0.dev0__tar.gz → 1.1.0__tar.gz

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/.vscode/settings.json

@@ -29,4 +29,8 @@
         //Added the ignore of E203 for now : https://github.com/PyCQA/pycodestyle/issues/373
         "--ignore=E203,W503"
     ],
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.pytestEnabled": true,
 }

{configextractor-py-1.0.dev0/configextractor_py.egg-info → configextractor-py-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: configextractor-py
-Version: 1.0.dev0
+Version: 1.1.0
 Summary: A library for extracting malware configurations across multiple frameworks
 Description-Content-Type: text/markdown
 Requires-Dist: cart

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/configextractor/frameworks/base.py

@@ -11,7 +11,8 @@ from plyara.utils import rebuild_yara_rule
 
 
 class Extractor:
-    def __init__(self, framework, module, module_path, root_directory, yara_rule, venv=None) -> None:
+    def __init__(self, id, framework, module, module_path, root_directory, yara_rule, venv=None) -> None:
+        self.id = id
         self.framework = framework
         self.module = module
         self.module_path = module_path
@@ -36,45 +37,26 @@ class Framework:
     def get_name(extractor: Extractor):
         return extractor.module.__name__.split(".")[-1]
 
+    # Define a template for results from this Extractor
+    def result_template(self, extractor: Extractor, yara_matches: List[yara.Match]) -> Dict[str, str]:
+        return dict(id=extractor.id, yara_hits=[y.rule for y in yara_matches])
+
     # Extract YARA rules from module
-    def extract_yara_from_module(self, decoder: object, module_name: str, existing_rule_names=[]) -> List[str]:
+    def extract_yara_from_module(self, decoder: object) -> List[str]:
         if self.yara_attr_name and hasattr(decoder, self.yara_attr_name) and getattr(decoder, self.yara_attr_name):
-            yara_rules = list()
-            # Modify YARA rule to include meta about the parser
             yara_parser = plyara.Plyara()
-            for yara_rule_frag in yara_parser.parse_string(getattr(decoder, self.yara_attr_name)):
-                # If this rule came with no metadata then instantiate it
-                if not yara_rule_frag.get("metadata"):
-                    yara_rule_frag["metadata"] = list()
-                yara_rule_name = yara_rule_frag["rule_name"]
-                yara_rule_frag["metadata"].extend(
-                    [
-                        {"yara_identifier": yara_rule_name},
-                        {"parser_module": module_name},
-                    ]
-                )
-
-                # Modify the name of the rule to avoid duplicate identifiers during compilation
-                if yara_rule_name in existing_rule_names:
-                    yara_rule_frag[
-                        "rule_name"
-                    ] = f"{yara_rule_name}_{len([i for i in existing_rule_names if i.startswith(yara_rule_name)])}"
-
-                existing_rule_names.append(yara_rule_name)
-                rebuilt_rule = rebuild_yara_rule(yara_rule_frag)
-                try:
-                    yara.compile(source=rebuilt_rule)
-                    yara_rules.append(rebuilt_rule)
-                except Exception as e:
-                    self.log.error(f"{decoder.__name__}: {e}")
-            return yara_rules
+            return [
+                rebuild_yara_rule(yara_rule_frag)
+                for yara_rule_frag in yara_parser.parse_string(getattr(decoder, self.yara_attr_name))
+            ]
+        return []
 
     # Validate module against framework
     def validate(self, module: Any) -> bool:
         NotImplementedError()
 
     # Run a series of modules
-    def run(self, sample_path: str, parsers: Dict[Extractor, List[yara.Match]]) -> Dict[str, dict]:
+    def run(self, sample_path: str, parsers: Dict[Extractor, List[yara.Match]]) -> List[dict]:
         return NotImplementedError()
 
     def run_in_venv(self, sample_path: str, extractor: Extractor) -> Dict[str, dict]:

configextractor-py-1.1.0/configextractor/frameworks/cape.py

@@ -0,0 +1,61 @@
+# CAPE framework
+from inspect import signature
+from typing import Any, Dict, List
+
+import yara
+from maco.model import ExtractorModel
+
+from configextractor.frameworks.base import Extractor, Framework
+
+
+class CAPE(Framework):
+    @staticmethod
+    def get_classification(extractor: Extractor):
+        if hasattr(extractor.module, "TLP"):
+            return extractor.module.TLP
+        return None
+
+    def validate(self, module: Any) -> bool:
+        if hasattr(module, "extract_config"):
+            s = signature(module.extract_config)
+            # Ensure function isn't part of a class, which doesn't follow CAPE's extractor format
+            return len(s.parameters) == 1 and "self" not in s.parameters
+
+    def result_template(self, extractor: Extractor, yara_matches: List[yara.Match]) -> Dict[str, str]:
+        template = super().result_template(extractor, yara_matches)
+        template.update(
+            {
+                "author": extractor.module.AUTHOR if hasattr(extractor.module, "AUTHOR") else "<MISSING_AUTHOR>",
+                "description": extractor.module.DESCRIPTION
+                if hasattr(extractor.module, "DESCRIPTION")
+                else "<MISSING_DESCRIPTION>",
+            }
+        )
+
+        return template
+
+    def run(self, sample_path: str, parsers: Dict[Extractor, List[yara.Match]]) -> List[dict]:
+        results = list()
+        for parser, yara_matches in parsers.items():
+            # Just run CAPE parsers as-is
+            try:
+                result = self.result_template(parser, yara_matches)
+                if parser.venv:
+                    raise NotImplementedError()
+                else:
+                    cfg = parser.module.extract_config(open(sample_path, "rb").read())
+
+                if not (cfg or yara_matches):
+                    # Nothing of interest to report
+                    continue
+
+                if cfg:
+                    result.update({"config": ExtractorModel(**cfg).dict(exclude_defaults=True, exclude_none=True)})
+            except Exception as e:
+                # If an exception was raised at runtime, append to results
+                result["exception"] = str(e)
+                self.log.error(f"{parser.id}: {e}")
+
+            results.append(result)
+
+        return results

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/configextractor/frameworks/maco.py

@@ -36,42 +36,47 @@ with open("{output_path}", 'w') as fp:
 
     def validate(self, module: Any) -> bool:
         if inspect.isclass(module):
-            return issubclass(module, MACO_Extractor)
+            # 'author' has to be implemented otherwise will raise an exception according to MWCP
+            return issubclass(module, MACO_Extractor) and module.author
 
-    def run(self, sample_path: str, parsers: Dict[Extractor, List[str]]) -> Dict[str, dict]:
-        results = dict()
+    def result_template(self, extractor: Extractor, yara_matches: List) -> Dict[str, str]:
+        template = super().result_template(extractor, yara_matches)
+        decoder = extractor.module()
+        template.update(
+            {
+                "author": decoder.author,
+                "description": decoder.__doc__,
+                "config": {"family": decoder.family if hasattr(decoder, "family") else decoder.__class__.__name__},
+            }
+        )
+        return template
+
+    def run(self, sample_path: str, parsers: Dict[Extractor, List[str]]) -> List[dict]:
+        results = list()
         for extractor, yara_matches in parsers.items():
             try:
-                decoder: Extractor = extractor.module()
-                config = {}
-                if hasattr(decoder, "family") and decoder.family:
-                    config["family"] = decoder.family
-                else:
-                    config["family"] = decoder.__class__.__name__
+                decoder = extractor.module()
+                result = self.result_template(extractor, yara_matches)
+
                 # Run MaCo parser with YARA matches
-                results[decoder.name] = {
-                    "author": decoder.author,
-                    "description": decoder.__doc__,
-                    "config": config,
-                }
-                result: ExtractorModel = None
+                r: ExtractorModel = None
                 if extractor.venv:
                     # Run in special mode using the virtual environment detected
-                    result = self.run_in_venv(sample_path, extractor)
+                    r = self.run_in_venv(sample_path, extractor)
                 else:
-                    result = decoder.run(open(sample_path, "rb"), matches=yara_matches)
-                if result:
-                    results[decoder.name].update({"config": result.dict(exclude_defaults=True, exclude_none=True)})
-                elif yara_matches:
-                    # YARA rules matched, but no configuration extracted
+                    r = decoder.run(open(sample_path, "rb"), matches=yara_matches)
+
+                if not (r or yara_matches):
+                    # Nothing to report
                     continue
-                else:
-                    # No result
-                    results.pop(decoder.name, None)
+                if r:
+                    result.update({"config": r.dict(exclude_defaults=True, exclude_none=True)})
+
             except Exception as e:
                 # Add exception to results
-                results[decoder.name]["exception"] = str(e)
-                self.log.error(e)
+                result["exception"] = str(e)
+                self.log.error(f"{extractor.id}: {e}")
+            results.append(result)
         return results
 
     def run_in_venv(self, sample_path: str, extractor: Extractor) -> ExtractorModel:

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/configextractor/frameworks/mwcp.py

@@ -2,13 +2,14 @@
 
 import inspect
 from logging import Logger
+from typing import Dict, List
 
 import mwcp
 import regex
 from maco.model import ConnUsageEnum, Encryption, ExtractorModel
 from mwcp import Parser
 
-from configextractor.frameworks.base import Framework
+from configextractor.frameworks.base import Extractor, Framework
 
 IP_REGEX_ONLY = r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
 
@@ -197,53 +198,56 @@ with open("{output_path}", 'w') as fp:
 
     def validate(self, parser):
         if inspect.isclass(parser):
-            return issubclass(parser, Parser) and (parser.AUTHOR or parser.DESCRIPTION)
+            # 'DESCRIPTION' has to be implemented otherwise will raise an exception according to MWCP
+            return issubclass(parser, Parser) and parser.DESCRIPTION
+
+    def result_template(self, extractor: Extractor, yara_matches: List) -> Dict[str, str]:
+        template = super().result_template(extractor, yara_matches)
+        template.update(
+            {
+                "author": extractor.module.AUTHOR,
+                "description": extractor.module.DESCRIPTION,
+            }
+        )
+        return template
 
     def run(self, sample_path, parsers):
-        results = dict()
+        results = list()
 
         for parser, yara_matches in parsers.items():
             parser_name = MWCP.get_name(parser)
             try:
-                results[parser_name] = {
-                    "author": parser.module.AUTHOR,
-                    "description": parser.module.DESCRIPTION,
-                    "config": {},
-                }
+                result = self.result_template(parser, yara_matches)
 
-                result: dict = None
+                r: dict = None
                 if parser.venv:
-                    result = self.run_in_venv(sample_path, parser)
+                    r = self.run_in_venv(sample_path, parser)
                 else:
                     # Just run MWCP parsers directly, using the filename to fetch the class attribute from module
-                    result = mwcp.run(parser.module, data=open(sample_path, "rb").read()).as_json_dict()
+                    r = mwcp.run(parser.module, data=open(sample_path, "rb").read()).as_json_dict()
 
                 # Log any errors raised during execution
-                [self.log.error(e) for e in result["errors"]]
-                result = convert_to_MACO(result["metadata"])
-                if result or yara_matches:
-                    family = parser_name
-                    for y in yara_matches:
-                        if y.meta.get("malware"):
-                            family = y.meta["malware"]
-                            break
-
-                    result["family"] = family
-                    results[parser_name].update(
-                        {
-                            "config": ExtractorModel(**result).dict(exclude_defaults=True, exclude_none=True),
-                        }
-                    )
-
-                    if not results[parser_name]["config"]:
-                        results.pop(parser_name, None)
-                elif yara_matches:
-                    # YARA rules matched, but no configuration extracted
+                [self.log.error(e) for e in r["errors"]]
+                r = convert_to_MACO(r["metadata"])
+                if not (r or yara_matches):
+                    # Nothing of interest to report
                     continue
-                else:
-                    # No result
-                    results.pop(parser_name, None)
+
+                family = parser_name
+                for y in yara_matches:
+                    if y.meta.get("malware"):
+                        family = y.meta["malware"]
+                        break
+
+                r["family"] = family
+                result.update(
+                    {
+                        "config": ExtractorModel(**r).dict(exclude_defaults=True, exclude_none=True),
+                    }
+                )
+
             except Exception as e:
-                results[parser_name]["exception"] = str(e)
-                self.log.error(f"{parser_name}: {e}")
+                result["exception"] = str(e)
+                self.log.error(f"{parser.id}: {e}")
+            results.append(result)
         return results

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/configextractor/main.py

@@ -13,6 +13,7 @@ from typing import Dict, List, Set
 import cart
 import regex
 import yara
+
 from configextractor.frameworks import CAPE, MACO, MWCP
 from configextractor.frameworks.base import Extractor, Framework
 
@@ -34,9 +35,9 @@ class ConfigExtractor:
         }
 
         self.parsers: Dict[str, Extractor] = dict()
-        yara_rules: List[str] = list()
-        yara_rule_names: List[str] = list()
+        namespaced_yara_rules: Dict[str, List[str]] = dict()
         for parsers_dir in parsers_dirs:
+            parsers_dir = os.path.abspath(parsers_dir)
             self.log.debug("Adding directories within parser directory in case of local dependencies")
             self.log.debug(f"Adding {os.path.join(parsers_dir, os.pardir)} to PATH")
             not_py = [
@@ -132,8 +133,9 @@ class ConfigExtractor:
                                 if member.__name__ != module_name:
                                     # Account for the possibility of multiple extractor classes within the same module
                                     module_id = f"{module_name}.{member.__name__}"
-                                rules = fw_class.extract_yara_from_module(member, module_id, yara_rule_names) or []
+                                rules = fw_class.extract_yara_from_module(member)
                                 ext = Extractor(
+                                    module_id,
                                     fw_name,
                                     member,
                                     module.__file__,
@@ -142,7 +144,7 @@ class ConfigExtractor:
                                     parser_venv,
                                 )
                                 if rules:
-                                    yara_rules.extend(rules)
+                                    namespaced_yara_rules[module_id] = rules
                                 self.parsers[module_id] = ext
                                 break
                         except TypeError:
@@ -150,10 +152,6 @@ class ConfigExtractor:
                         except Exception as e:
                             self.log.error(f"{member}: {e}")
 
-                # Correct metadata in YARA rules
-                if original_dir != parsers_dir:
-                    yara_rules = [rule.replace(parsers_dir, original_dir) for rule in yara_rules]
-
             if original_dir != parsers_dir:
                 # Correct the paths to the parsers to match metadata changes
                 sys.path.remove(path_parent)
@@ -166,7 +164,7 @@ class ConfigExtractor:
                     parser_obj.root_directory = original_dir
                 shutil.rmtree(parsers_dir)
 
-        self.yara = yara.compile(source="\n".join(yara_rules))
+        self.yara = yara.compile(sources={ns: "\n".join(rules) for ns, rules in namespaced_yara_rules.items()})
         for fw_name in list(self.FRAMEWORK_LIBRARY_MAPPING.keys()):
             self.log.debug(
                 f"# of YARA-dependent parsers under {fw_name}: "
@@ -176,7 +174,6 @@ class ConfigExtractor:
                 f"# of YARA-independent parsers under {fw_name}: "
                 f"{len([p for p in self.parsers.values() if not p.rule and p.framework == fw_name])}"
             )
-        self.log.debug(f"# of YARA rules extracted from all parsers: {len(yara_rules)}")
         if parser_blocklist:
             self.log.info(f"Ignoring output from the following parsers matching: {parser_blocklist}")
 
@@ -192,10 +189,12 @@ class ConfigExtractor:
 
     def finalize(self, results: List[dict]):
         # Ensure schemes/protocol are present in HTTP configurations
-        for config in results.values():
+        for config in results:
             config = config.get("config", {})
             for network_conn in config.get("http", []):
                 network_conn.setdefault("protocol", "http")
+                # Ensure protocol is lowercased
+                network_conn["protocol"] = network_conn["protocol"].lower()
                 uri: str = network_conn.get("uri")
                 if uri and not uri.startswith(network_conn["protocol"]):
                     # Ensure URI starts with protocol
@@ -222,7 +221,7 @@ class ConfigExtractor:
             # Get YARA-dependent parsers that should run based on match
             for yara_match in self.yara.match(sample_copy.name):
                 # Retrieve relevant parser information
-                extractor = self.parsers[yara_match.meta.get("parser_module")]
+                extractor = self.parsers[yara_match.namespace]
                 if block_regex and block_regex.match(extractor.module.__name__):
                     self.log.info(f"Blocking {extractor.module.__name__} based on passed blocklist regex list")
                     continue

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0/configextractor_py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: configextractor-py
-Version: 1.0.dev0
+Version: 1.1.0
 Summary: A library for extracting malware configurations across multiple frameworks
 Description-Content-Type: text/markdown
 Requires-Dist: cart

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/configextractor_py.egg-info/SOURCES.txt

@@ -20,4 +20,11 @@ configextractor_py.egg-info/dependency_links.txt
 configextractor_py.egg-info/entry_points.txt
 configextractor_py.egg-info/requires.txt
 configextractor_py.egg-info/top_level.txt
-pipelines/publish.yaml
+pipelines/publish.yaml
+pipelines/test.yaml
+tests/requirements.txt
+tests/test_detection.py
+tests/test_run.py
+tests/test_parsers/cape.py
+tests/test_parsers/maco.py
+tests/test_parsers/mwcp.py

{configextractor-py-1.0.dev0 → configextractor-py-1.1.0}/pipelines/publish.yaml

@@ -30,16 +30,6 @@ jobs:
           ls dist
         displayName: Build
 
-      - script: |
-          set -xv  # Echo commands before they are run
-          sudo env "PATH=$PATH" python -m pip install --no-cache-dir twine
-          ls dist
-          twine upload --skip-existing --repository-url $TEST_REPOSITORY_URL dist/*
-        displayName: Deploy to Test PyPI
-        env:
-          TWINE_USERNAME: $(twineUsername)
-          TWINE_PASSWORD: $(twinePassword)
-
       - script: |
           set -xv  # Echo commands before they are run
           sudo env "PATH=$PATH" python -m pip install --no-cache-dir twine

configextractor-py-1.1.0/pipelines/test.yaml

@@ -0,0 +1,40 @@
+name: tests
+
+trigger: ["*"]
+pr: ["*"]
+
+pool:
+  vmImage: "ubuntu-20.04"
+
+jobs:
+  - job: run_test
+    strategy:
+      matrix:
+        Python3_9:
+          python.version: "3.9"
+        Python3_10:
+          python.version: "3.10"
+        Python3_11:
+          python.version: "3.11"
+        # TODO: Look at cart support
+        # Python3_12:
+        #   python.version: "3.12"
+
+    timeoutInMinutes: 10
+
+    steps:
+      - task: UsePythonVersion@0
+        displayName: Set python version
+        inputs:
+          versionSpec: "$(python.version)"
+      - script: |
+          [ ! -d "$(pwd)/tests" ] && echo "No tests found" && exit
+          [ -f $(pwd)/requirements.txt ] && sudo env "PATH=$PATH" python -m pip install -U --no-cache-dir -r $(pwd)/requirements.txt
+          [ -f $(pwd)/tests/requirements.txt ] && sudo env "PATH=$PATH" python -m pip install -U --no-cache-dir -r $(pwd)/tests/requirements.txt
+          sudo rm -rf /tmp/* /var/lib/apt/lists/* ~/.cache/pip
+        displayName: Setup environment
+      - script: |
+          [ ! -d "$(pwd)/tests" ] && echo "No tests found" && exit
+          export REPO_NAME=${BUILD_REPOSITORY_NAME##*/}
+          python -m pytest -p no:cacheprovider --durations=10 -rsx -vv
+        displayName: Test

configextractor-py-1.1.0/tests/requirements.txt

@@ -0,0 +1 @@
+pytest

configextractor-py-1.1.0/tests/test_detection.py

@@ -0,0 +1,32 @@
+import pytest
+
+from configextractor.main import ConfigExtractor
+
+
+@pytest.fixture
+def cx():
+    yield ConfigExtractor(["tests/test_parsers"])
+
+
+def test_general_detection(cx):
+    # Check to see if we actually detected any of the test parsers
+    assert cx.parsers
+
+
+def test_cape_detection(cx):
+    # Ensure the CAPE parser was detected and NOT the class wrapping a similar CAPE function signature
+    # A confusion in detection can throw off automated systems like Assemblyline
+    assert "test_parsers.cape" in cx.parsers
+    assert "test_parsers.cape.CAPEWrapper" not in cx.parsers
+
+
+def test_maco_detection(cx):
+    # Ensure the subclass was detected
+    assert "test_parsers.maco.TestMACO" in cx.parsers
+    assert "test_parsers.maco.Extractor" not in cx.parsers
+
+
+def test_mwcp_detection(cx):
+    # Ensure the subclass was detected
+    assert "test_parsers.mwcp.TestMWCP" in cx.parsers
+    assert "test_parsers.mwcp.Parser" not in cx.parsers

configextractor-py-1.1.0/tests/test_parsers/cape.py

@@ -0,0 +1,11 @@
+# Format of CAPE parsers that are detected by library
+def extract_config(data):
+    ...
+
+
+# Similar function signatures to CAPE's included in another class
+# This shouldn't be detected under the CAPE framework
+# (ie. if found under a MACO implementation, then the detected framework will be MACO)
+class CAPEWrapper:
+    def extract_config(self):
+        ...

configextractor-py-1.1.0/tests/test_parsers/maco.py

@@ -0,0 +1,6 @@
+from maco.extractor import Extractor
+
+
+# Format of MACO parsers that are detected by library
+class TestMACO(Extractor):
+    author = "cccs-rs"

configextractor-py-1.1.0/tests/test_parsers/mwcp.py

@@ -0,0 +1,6 @@
+from mwcp import Parser
+
+
+# Format of MWCP parsers that are detected by library
+class TestMWCP(Parser):
+    DESCRIPTION = "test"

configextractor-py-1.1.0/tests/test_run.py

@@ -0,0 +1,15 @@
+import pytest
+
+from configextractor.main import ConfigExtractor
+
+
+@pytest.fixture
+def cx():
+    yield ConfigExtractor(["tests/test_parsers"])
+
+
+def test_finalize_uri(cx):
+    # Bug: URIs prepended with an extra protocol because it thought it was missing because of casing difference
+    results = [{"config": {"http": [{"uri": "https://bad.com", "protocol": "HTTPS"}]}}]
+    cx.finalize(results)
+    assert results[0]["config"]["http"][0]["uri"] == "https://bad.com"

configextractor-py-1.0.dev0/configextractor/frameworks/cape.py

@@ -1,53 +0,0 @@
-# CAPE framework
-from collections import defaultdict
-from inspect import signature
-
-from maco.model import ExtractorModel
-
-from configextractor.frameworks.base import Extractor, Framework
-
-
-class CAPE(Framework):
-    @staticmethod
-    def get_classification(extractor: Extractor):
-        if hasattr(extractor.module, "TLP"):
-            return extractor.module.TLP
-        return None
-
-    def validate(self, module):
-        return hasattr(module, "extract_config") and len(signature(module.extract_config).parameters) == 1
-
-    def run(self, sample_path, parsers):
-        results = defaultdict(dict)
-        for parser, yara_matches in parsers.items():
-            # Just run CAPE parsers as-is
-            parser_name = CAPE.get_name(parser)
-            try:
-                results[parser_name].update(
-                    {
-                        "author": parser.module.AUTHOR if hasattr(parser.module, "AUTHOR") else "<MISSING_AUTHOR>",
-                        "description": parser.module.DESCRIPTION
-                        if hasattr(parser.module, "DESCRIPTION")
-                        else "<MISSING_DESCRIPTION>",
-                        "config": {},
-                    }
-                )
-                if parser.venv:
-                    raise NotImplementedError()
-                else:
-                    result = parser.module.extract_config(open(sample_path, "rb").read())
-                if result:
-                    results[parser_name].update(
-                        {"config": ExtractorModel(**result).dict(exclude_defaults=True, exclude_none=True)}
-                    )
-                elif yara_matches:
-                    # YARA rules matched, but no configuration extracted
-                    continue
-                else:
-                    # No result
-                    results.pop(parser_name, None)
-            except Exception as e:
-                results[parser_name]["exception"] = str(e)
-                self.log.error(f"{parser_name}: {e}")
-
-        return results