xpl-core 0.3.0__tar.gz

xpl_core-0.3.0/LICENSE

@@ -0,0 +1,123 @@
+# XPL-Suite Security Research License (XSRL) v1.0
+
+Copyright (c) 2024-2026 Andre Henrike de Oliveira (@mrhenrike) / Uniao Geek
+All rights reserved.
+
+## 1. Definitions
+
+- "Software" means the source code, documentation, binaries, scripts, configuration
+  files, and any other materials included in this repository.
+- "Author" means the original copyright holder: Andre Henrike de Oliveira (@mrhenrike).
+- "Original Repository" means the source repository hosted at
+  https://github.com/mrhenrike/xpl-core from which the Software originates.
+- "Upstream Credits" means the authors and licenses of third-party components,
+  libraries, or code referenced in the Software, as documented in source file headers,
+  CREDITS files, or README attribution sections.
+- "Authorized Security Testing" means penetration testing, vulnerability assessment,
+  red team exercises, purple team exercises, security auditing, or similar activities
+  conducted with explicit written permission from the owner of the target system(s).
+
+## 2. Grant of Rights
+
+Subject to the terms and conditions of this License, the Author grants you a
+non-exclusive, worldwide, royalty-free license to:
+
+a) **Use** the Software for educational purposes, academic research, security studies,
+   and Authorized Security Testing;
+b) **Copy and reproduce** the Software;
+c) **Modify** the Software and create derivative works;
+d) **Fork** the Software and maintain independent copies;
+e) **Distribute** the Software and derivative works, provided all conditions in
+   Section 3 are met.
+
+## 3. Conditions
+
+Any use, copy, modification, fork, or distribution of the Software must comply with
+ALL of the following conditions:
+
+### 3.1 Attribution
+
+a) You must retain the Author's original copyright notice and attribution in all
+   copies and derivative works.
+b) You must retain all Upstream Credits, including but not limited to: original author
+   names, license notices, and attribution statements of third-party code used as a
+   base or reference for the Software.
+c) Modified files must carry a prominent notice stating that you changed the files and
+   the date of any change.
+d) Derivative works must include a clear statement identifying the original Software
+   and its Author.
+e) Any copy, fork, or derivative work must include a visible reference to the Original
+   Repository URL (https://github.com/mrhenrike/xpl-core) in the project's
+   README or equivalent documentation, so that users can trace the Software back to
+   its source.
+f) The Author's name and credits must not be removed, obscured, or replaced in any
+   copy, fork, or derivative work. The Author must remain credited as the original
+   creator in all circumstances.
+
+### 3.2 Same License
+
+a) Any distribution of the Software or derivative works must be under this same
+   License (XSRL v1.0).
+b) You may not apply any additional restrictions or alternative license terms to the
+   Software or derivative works.
+c) You may not sublicense the Software under different terms.
+
+### 3.3 Non-Commercial Use Only
+
+a) The Software may not be used, in whole or in part, for commercial purposes.
+b) "Commercial purposes" includes but is not limited to: selling the Software or
+   derivative works, incorporating the Software into commercial products or services,
+   using the Software to generate revenue directly or indirectly, and offering the
+   Software as part of a paid service.
+c) Use in non-profit organizations, academic institutions, and personal projects is
+   permitted, provided no commercial gain is derived.
+
+### 3.4 Ethical Use Only
+
+a) The Software may only be used for:
+   - Educational purposes and academic research;
+   - Security studies, training, and skill development;
+   - Authorized Security Testing (as defined in Section 1);
+   - Capture The Flag (CTF) competitions and security labs;
+   - Defensive security, incident response, and threat analysis.
+
+b) The Software may NOT be used for:
+   - Unauthorized access to systems, networks, or data;
+   - Any activity that violates applicable laws or regulations;
+   - Malicious purposes, including but not limited to: deploying malware against
+     unauthorized targets, conducting denial-of-service attacks, unauthorized
+     surveillance, data theft, or any form of cybercrime;
+   - Targeting individuals, organizations, or infrastructure without explicit
+     authorization;
+   - Any purpose that causes harm to individuals or organizations.
+
+## 4. No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+## 5. Limitation of Liability
+
+The Author shall not be held responsible for any misuse of the Software. Users are
+solely responsible for ensuring their use of the Software complies with all applicable
+laws, regulations, and ethical standards.
+
+## 6. Termination
+
+This License and the rights granted hereunder will terminate automatically if you fail
+to comply with any of the terms and conditions of this License. Upon termination, you
+must cease all use and destroy all copies of the Software in your possession.
+
+## 7. Severability
+
+If any provision of this License is held to be unenforceable, such provision shall be
+reformed only to the extent necessary to make it enforceable, and the remaining
+provisions shall continue in full force and effect.
+
+---
+
+SPDX-License-Identifier: LicenseRef-XSRL-1.0

xpl_core-0.3.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: xpl-core
+Version: 0.3.0
+Summary: XPL-Suite shared schemas, policies and registry
+Author-email: Andre Henrike <safelabs.support@visioncybersecurity.com>
+License: XSRL-1.0
+Keywords: security,pentest,schema,findings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+License-File: LICENSE
+Provides-Extra: crypto
+Requires-Dist: cryptography>=42.0; extra == "crypto"
+Provides-Extra: mqtt
+Requires-Dist: paho-mqtt>=2.0; extra == "mqtt"
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: cryptography>=42.0; extra == "dev"
+Requires-Dist: paho-mqtt>=2.0; extra == "dev"
+Dynamic: license-file

xpl_core-0.3.0/README.md

@@ -0,0 +1,68 @@
+# xpl-core
+
+Shared schemas, policies, registry and canonical modules for [XPL-Suite](https://github.com/mrhenrike) forges.
+
+## Overview
+
+`xpl-core` provides the common infrastructure that all XPL-Suite offensive security forges depend on:
+
+- **Finding schema** (`xpl.finding.v1`) — standardized vulnerability finding format
+- **Shell infrastructure** — 8 transport engines (TCP, UDP, ICMP, DNS, HTTP, MQTT, Meterpreter, IWP), handler, listener, stager, session manager
+- **Credential models** — `BaseCredential`, `ADCredential`, `CloudCredential`, `NetworkCredential`
+- **SmartPool** — adaptive thread/process pool with `map_unordered` and context manager
+- **HostSession** — persistent per-host assessment tracking with `ModuleResult`
+- **ForgeConfig** — JSON-based per-forge configuration with defaults and persistence
+- **Module** and **Registry** — plugin-style module loading and dispatch
+
+## Installation
+
+```bash
+pip install xpl-core
+```
+
+Optional extras:
+
+```bash
+pip install xpl-core[crypto]   # cryptography
+pip install xpl-core[mqtt]     # paho-mqtt
+pip install xpl-core[dev]      # all dev tools
+```
+
+## Quick Start
+
+```python
+from xpl_core.credential import ADCredential, CloudCredential
+from xpl_core.pool import SmartPool, PoolStrategy
+from xpl_core.session import SessionManager, HostSession, ModuleResult
+from xpl_core.config import ForgeConfig
+
+# Credential handling
+cred = ADCredential(username="admin", nt_hash="31d6cfe0d16ae931b73c59d7e0c089c0", domain="CORP")
+print(cred.impacket_hash)
+
+# Adaptive pool
+with SmartPool(max_workers=16) as pool:
+    results = pool.map_unordered(scan_target, targets)
+
+# Session tracking
+mgr = SessionManager("/tmp/sessions")
+session = mgr.get_or_create("fw01", "10.0.0.1", vendor="Fortinet")
+session.add_result(ModuleResult(module_path="exploits/firewalls/fortigate_rce", vulnerable=True))
+mgr.save(session)
+
+# Configuration
+cfg = ForgeConfig("embedxpl", defaults={"threads": 10, "timeout": 30})
+print(cfg.get("threads"))
+```
+
+## Requirements
+
+- Python >= 3.9
+
+## License
+
+XSRL-1.0. See [LICENSE](LICENSE).
+
+## Author
+
+André Henrique ([@mrhenrike](https://github.com/mrhenrike)) | União Geek

xpl_core-0.3.0/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["setuptools>=72", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xpl-core"
+version = "0.3.0"
+description = "XPL-Suite shared schemas, policies and registry"
+license = { text = "XSRL-1.0" }
+requires-python = ">=3.9"
+authors = [
+    { name = "Andre Henrike", email = "safelabs.support@visioncybersecurity.com" }
+]
+keywords = ["security", "pentest", "schema", "findings"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Information Technology",
+    "Programming Language :: Python :: 3",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["xpl_core*"]
+
+[tool.setuptools.package-data]
+"xpl_core" = ["schemas/*.json", "py.typed"]
+
+[project.optional-dependencies]
+crypto = ["cryptography>=42.0"]
+mqtt = ["paho-mqtt>=2.0"]
+dev = [
+    "mypy>=1.11",
+    "ruff>=0.6",
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "cryptography>=42.0",
+    "paho-mqtt>=2.0",
+]
+
+[tool.mypy]
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+show_error_codes = true
+python_version = "3.9"
+
+[[tool.mypy.overrides]]
+module = ["paho.*"]
+ignore_missing_imports = true
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "SIM", "TCH", "RUF"]
+ignore = ["E501"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["xpl_core"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"

xpl_core-0.3.0/setup.cfg

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

xpl_core-0.3.0/tests/test_config.py

@@ -0,0 +1,76 @@
+"""Tests for xpl_core.config ForgeConfig."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from xpl_core.config import ForgeConfig
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class TestForgeConfig:
+    def test_defaults(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path, defaults={"threads": 10})
+        assert cfg.get("threads") == 10
+        assert cfg.get("nonexistent") is None
+        assert cfg.get("nonexistent", 42) == 42
+
+    def test_set_and_get(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path)
+        cfg.set_val("timeout", 30)
+        assert cfg.get("timeout") == 30
+
+    def test_persistence(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path)
+        cfg.set_val("key", "value")
+
+        cfg2 = ForgeConfig("test", config_dir=tmp_path)
+        assert cfg2.get("key") == "value"
+
+    def test_delete(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path)
+        cfg.set_val("key", "value")
+        assert cfg.delete("key") is True
+        assert cfg.get("key") is None
+        assert cfg.delete("nonexistent") is False
+
+    def test_reset(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path, defaults={"a": 1})
+        cfg.set_val("b", 2)
+        cfg.reset()
+        assert cfg.get("b") is None
+        assert cfg.get("a") == 1
+
+    def test_all_keys(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path, defaults={"a": 1, "c": 3})
+        cfg.set_val("b", 2)
+        assert cfg.all_keys() == ["a", "b", "c"]
+
+    def test_to_dict(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path, defaults={"a": 1})
+        cfg.set_val("b", 2)
+        cfg.set_val("a", 99)
+        d = cfg.to_dict()
+        assert d["a"] == 99
+        assert d["b"] == 2
+
+    def test_path_property(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("myforge", config_dir=tmp_path)
+        assert cfg.path == tmp_path / "myforge.json"
+
+    def test_forge_name_property(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("myforge", config_dir=tmp_path)
+        assert cfg.forge_name == "myforge"
+
+    def test_corrupted_file(self, tmp_path: Path) -> None:
+        (tmp_path / "broken.json").write_text("{bad", encoding="utf-8")
+        cfg = ForgeConfig("broken", config_dir=tmp_path)
+        assert cfg.to_dict() == {}
+
+    def test_override_default(self, tmp_path: Path) -> None:
+        cfg = ForgeConfig("test", config_dir=tmp_path, defaults={"x": "default"})
+        assert cfg.get("x") == "default"
+        cfg.set_val("x", "custom")
+        assert cfg.get("x") == "custom"

xpl_core-0.3.0/tests/test_credential.py

@@ -0,0 +1,129 @@
+"""Tests for xpl_core.credential canonical models."""
+
+from __future__ import annotations
+
+import types
+
+import pytest
+
+from xpl_core.credential import (
+    ADCredential,
+    BaseCredential,
+    CloudCredential,
+    NetworkCredential,
+)
+
+
+class TestBaseCredential:
+    def test_defaults(self) -> None:
+        c = BaseCredential()
+        assert c.username is None
+        assert c.password is None
+        assert c.has_password is False
+
+    def test_has_password(self) -> None:
+        c = BaseCredential(username="admin", password="secret")
+        assert c.has_password is True
+
+    def test_empty_password(self) -> None:
+        c = BaseCredential(username="admin", password="")
+        assert c.has_password is False
+
+    def test_masked(self) -> None:
+        c = BaseCredential(username="admin", password="secret")
+        assert c.masked() == "admin:****"
+
+    def test_masked_no_user(self) -> None:
+        c = BaseCredential()
+        assert c.masked() == "(none):(empty)"
+
+    def test_frozen(self) -> None:
+        c = BaseCredential(username="admin")
+        with pytest.raises(AttributeError):
+            c.username = "other"  # type: ignore[misc]
+
+
+class TestADCredential:
+    def test_from_args(self) -> None:
+        args = types.SimpleNamespace(
+            username="admin", password="Pass123", domain="CORP.LOCAL",
+            lm_hash="", nt_hash="abc123", aes_key="", ticket="",
+        )
+        c = ADCredential.from_args(args)
+        assert c.username == "admin"
+        assert c.domain == "CORP.LOCAL"
+        assert c.nt_hash == "abc123"
+
+    def test_from_args_missing(self) -> None:
+        args = types.SimpleNamespace()
+        c = ADCredential.from_args(args)
+        assert c.username is None
+        assert c.domain == ""
+
+    def test_has_hash(self) -> None:
+        c = ADCredential(nt_hash="abc")
+        assert c.has_hash is True
+
+    def test_no_hash(self) -> None:
+        c = ADCredential()
+        assert c.has_hash is False
+
+    def test_impacket_hash_defaults(self) -> None:
+        c = ADCredential()
+        assert c.impacket_hash == "aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0"
+
+    def test_impacket_hash_custom(self) -> None:
+        c = ADCredential(lm_hash="aaa", nt_hash="bbb")
+        assert c.impacket_hash == "aaa:bbb"
+
+    def test_inherits_base(self) -> None:
+        c = ADCredential(username="admin", password="pass")
+        assert c.has_password is True
+        assert c.masked() == "admin:****"
+
+
+class TestCloudCredential:
+    def test_masked_secret_none(self) -> None:
+        c = CloudCredential(provider="aws")
+        assert c.masked_secret == "(none)"
+
+    def test_masked_secret_short(self) -> None:
+        c = CloudCredential(provider="aws", secret_key="abc")
+        assert c.masked_secret == "****"
+
+    def test_masked_secret_long(self) -> None:
+        c = CloudCredential(provider="aws", secret_key="AKIAIOSFODNN7EXAMPLE")
+        assert c.masked_secret.startswith("AKIA")
+        assert c.masked_secret.endswith("MPLE")
+        assert "****" in c.masked_secret
+
+    def test_to_dict(self) -> None:
+        c = CloudCredential(
+            provider="aws", identity="arn:aws:iam::123:user/admin",
+            secret_key="supersecret123456", token="tok",
+        )
+        d = c.to_dict()
+        assert d["provider"] == "aws"
+        assert "supersecret" not in d["secret_key"]
+        assert d["token"] == "****"
+
+    def test_to_dict_no_token(self) -> None:
+        c = CloudCredential(provider="gcp")
+        d = c.to_dict()
+        assert d["token"] is None
+
+
+class TestNetworkCredential:
+    def test_defaults(self) -> None:
+        c = NetworkCredential()
+        assert c.has_password is False
+        assert c.tags == []
+
+    def test_masked(self) -> None:
+        c = NetworkCredential(username="admin", password="pass", protocol="ssh", port=22)
+        assert c.masked() == "admin:****@ssh:22"
+
+    def test_mutable(self) -> None:
+        c = NetworkCredential(username="admin")
+        c.password = "new"
+        assert c.has_password is True

xpl_core-0.3.0/tests/test_dispatcher.py

@@ -0,0 +1,152 @@
+"""Tests for xpl_core.dispatcher — Dispatcher and dispatch patterns."""
+
+from __future__ import annotations
+
+import types
+from unittest.mock import MagicMock
+
+import pytest
+
+from xpl_core.dispatcher import Dispatcher, DispatchError
+from xpl_core.module import BaseModule, ModuleManifest, ModuleResult, ModuleStatus, SafetyClass
+from xpl_core.registry import PluginRegistry
+
+
+class _TestModule(BaseModule):
+    @property
+    def manifest(self) -> ModuleManifest:
+        return ModuleManifest(
+            capability_id="test.dispatch.v1",
+            name="test-dispatch",
+            safety_class=SafetyClass.PASSIVE,
+        )
+
+    def run(self) -> ModuleResult:
+        return ModuleResult(status=ModuleStatus.SUCCESS, output="dispatched")
+
+
+class TestDispatcher:
+    def _make_dispatcher(self) -> Dispatcher:
+        reg = PluginRegistry()
+        reg.register("json", "stdlib", "json")
+        return Dispatcher(registry=reg)
+
+    def test_registry_property(self) -> None:
+        d = Dispatcher()
+        assert d.registry is not None
+        assert d.registry.count == 0
+
+    def test_dispatch_unknown_raises(self) -> None:
+        d = Dispatcher()
+        with pytest.raises(DispatchError, match="Unknown module"):
+            d.dispatch("fake", "nonexistent")
+
+    def test_dispatch_function_module(self) -> None:
+        fake_mod = types.ModuleType("fake_module")
+        fake_mod.MANIFEST = {  # type: ignore[attr-defined]
+            "capability_id": "test.fake.v1",
+            "name": "fake",
+            "safety_class": "PASSIVE",
+        }
+        fake_mod.run = lambda args: 0  # type: ignore[attr-defined]
+
+        reg = PluginRegistry()
+        reg.register("fake", "test", "fake_module")
+        entry = reg.get("test", "fake")
+        assert entry is not None
+        entry._loaded = fake_mod
+
+        d = Dispatcher(registry=reg)
+        result = d.dispatch("test", "fake", args=None)
+        assert result.status == ModuleStatus.SUCCESS
+
+    def test_dispatch_class_module(self) -> None:
+        class_mod = types.ModuleType("class_module")
+        class_mod.Module = _TestModule  # type: ignore[attr-defined]
+
+        reg = PluginRegistry()
+        reg.register("test-cls", "test", "class_module")
+        entry = reg.get("test", "test-cls")
+        assert entry is not None
+        entry._loaded = class_mod
+
+        d = Dispatcher(registry=reg)
+        result = d.dispatch("test", "test-cls")
+        assert result.status == ModuleStatus.SUCCESS
+        assert result.output == "dispatched"
+
+    def test_dispatch_no_run_raises(self) -> None:
+        empty_mod = types.ModuleType("empty_module")
+
+        reg = PluginRegistry()
+        reg.register("empty", "test", "empty_module")
+        entry = reg.get("test", "empty")
+        assert entry is not None
+        entry._loaded = empty_mod
+
+        d = Dispatcher(registry=reg)
+        with pytest.raises(DispatchError, match="has no BaseModule"):
+            d.dispatch("test", "empty")
+
+    def test_dispatch_args_compat(self) -> None:
+        fake_mod = types.ModuleType("compat_module")
+        fake_mod.run = lambda args: 0  # type: ignore[attr-defined]
+
+        reg = PluginRegistry()
+        reg.register("psexec", "lateral", "compat_module")
+        entry = reg.get("lateral", "psexec")
+        assert entry is not None
+        entry._loaded = fake_mod
+
+        d = Dispatcher(registry=reg)
+        args = MagicMock()
+        args.command = "lateral"
+        args.module = "psexec"
+        exit_code = d.dispatch_args(args)
+        assert exit_code == 0
+
+    def test_dispatch_args_unknown(self) -> None:
+        d = Dispatcher()
+        args = MagicMock()
+        args.command = "fake"
+        args.module = "nonexistent"
+        assert d.dispatch_args(args) == 1
+
+    def test_dispatch_args_import_error(self) -> None:
+        reg = PluginRegistry()
+        reg.register("broken", "test", "nonexistent.module.path.xyz")
+
+        d = Dispatcher(registry=reg)
+        args = MagicMock()
+        args.command = "test"
+        args.module = "broken"
+        assert d.dispatch_args(args) == 1
+
+    def test_list_commands(self) -> None:
+        reg = PluginRegistry()
+        reg.register("ldap-enum", "enum", "mod.ldap")
+        reg.register("spn-scan", "enum", "mod.spn")
+        reg.register("kerberoast", "attack", "mod.kerb")
+
+        d = Dispatcher(registry=reg)
+        cmds = d.list_commands()
+        assert "enum" in cmds
+        assert "attack" in cmds
+        assert set(cmds["enum"]) == {"ldap-enum", "spn-scan"}
+        assert cmds["attack"] == ["kerberoast"]
+
+    def test_dispatch_function_exception(self) -> None:
+        crash_mod = types.ModuleType("crash_module")
+        crash_mod.MANIFEST = {"capability_id": "crash", "name": "crash"}  # type: ignore[attr-defined]
+        crash_mod.run = lambda args: (_ for _ in ()).throw(ValueError("boom"))  # type: ignore[attr-defined]
+
+        reg = PluginRegistry()
+        reg.register("crash", "test", "crash_module")
+        entry = reg.get("test", "crash")
+        assert entry is not None
+        entry._loaded = crash_mod
+
+        d = Dispatcher(registry=reg)
+        result = d.dispatch("test", "crash", args=None)
+        assert result.status == ModuleStatus.FAILURE
+        assert "boom" in result.error