bbot 2.0.1.4720rc0__py3-none-any.whl → 2.3.0.5397rc0__py3-none-any.whl

bbot/test/test_step_2/module_tests/test_module_gowitness.py

@@ -27,8 +27,8 @@ class TestGowitness(ModuleTestBase):
             "headers": {"Server": "Apache/2.4.41 (Ubuntu)"},
         }
         module_test.set_expect_requests(respond_args=respond_args)
-        request_args = dict(uri="/blacklanternsecurity")
-        respond_args = dict(response_data="""blacklanternsecurity github <a data-bem""")
+        request_args = {"uri": "/blacklanternsecurity"}
+        respond_args = {"response_data": """blacklanternsecurity github <a data-bem"""}
         module_test.set_expect_requests(request_args, respond_args)
 
         # monkeypatch social
@@ -45,7 +45,7 @@ class TestGowitness(ModuleTestBase):
         webscreenshots = [e for e in events if e.type == "WEBSCREENSHOT"]
         assert webscreenshots, "failed to raise WEBSCREENSHOT events"
         assert not any(
-            ["blob" in e.data for e in webscreenshots]
+            "blob" in e.data for e in webscreenshots
         ), "blob was included in WEBSCREENSHOT data when it shouldn't have been"
 
         screenshots_path = self.home_dir / "scans" / module_test.scan.name / "gowitness" / "screenshots"
@@ -102,5 +102,5 @@ class TestGoWitnessWithBlob(TestGowitness):
         webscreenshots = [e for e in events if e.type == "WEBSCREENSHOT"]
         assert webscreenshots, "failed to raise WEBSCREENSHOT events"
         assert all(
-            ["blob" in e.data and e.data["blob"] for e in webscreenshots]
+            "blob" in e.data and e.data["blob"] for e in webscreenshots
         ), "blob not found in WEBSCREENSHOT data"

bbot/test/test_step_2/module_tests/test_module_host_header.py

@@ -31,7 +31,7 @@ class TestHost_Header(ModuleTestBase):
         if subdomain_tag_overrides:
             return Response(f"Alive, host is: {subdomain_tag}.{self.fake_host}", status=200)
 
-        return Response(f"Alive, host is: defaulthost.com", status=200)
+        return Response("Alive, host is: defaulthost.com", status=200)
 
     async def setup_before_prep(self, module_test):
         self.interactsh_mock_instance = module_test.mock_interactsh("host_header")

bbot/test/test_step_2/module_tests/test_module_http.py

@@ -48,10 +48,10 @@ class TestHTTP(ModuleTestBase):
         )
 
     def check(self, module_test, events):
-        assert self.got_event == True
-        assert self.headers_correct == True
-        assert self.method_correct == True
-        assert self.url_correct == True
+        assert self.got_event is True
+        assert self.headers_correct is True
+        assert self.method_correct is True
+        assert self.url_correct is True
 
 
 class TestHTTPSIEMFriendly(TestHTTP):

bbot/test/test_step_2/module_tests/test_module_httpx.py

@@ -1,8 +1,10 @@
 from .base import ModuleTestBase
 
 
-class TestHTTPX(ModuleTestBase):
+class TestHTTPXBase(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/url", "127.0.0.1:8888"]
+    module_name = "httpx"
+    modules_overrides = ["httpx", "excavate"]
     config_overrides = {"modules": {"httpx": {"store_responses": True}}}
 
     # HTML for a page with a login form
@@ -29,11 +31,11 @@ class TestHTTPX(ModuleTestBase):
 </html>"""
 
     async def setup_after_prep(self, module_test):
-        request_args = dict(uri="/", headers={"test": "header"})
-        respond_args = dict(response_data=self.html_without_login)
+        request_args = {"uri": "/", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_without_login}
         module_test.set_expect_requests(request_args, respond_args)
-        request_args = dict(uri="/url", headers={"test": "header"})
-        respond_args = dict(response_data=self.html_with_login)
+        request_args = {"uri": "/url", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_with_login}
         module_test.set_expect_requests(request_args, respond_args)
 
     def check(self, module_test, events):
@@ -42,7 +44,7 @@ class TestHTTPX(ModuleTestBase):
         for e in events:
             if e.type == "HTTP_RESPONSE":
                 if e.data["path"] == "/":
-                    assert not "login-page" in e.tags
+                    assert "login-page" not in e.tags
                     open_port = True
                 elif e.data["path"] == "/url":
                     assert "login-page" in e.tags
@@ -122,8 +124,8 @@ class TestHTTPX_URLBlacklist(ModuleTestBase):
         assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/"])
         assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/test.aspx"])
         assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/test.txt"])
-        assert not any([e for e in events if "URL" in e.type and ".svg" in e.data])
-        assert not any([e for e in events if "URL" in e.type and ".woff" in e.data])
+        assert not any(e for e in events if "URL" in e.type and ".svg" in e.data)
+        assert not any(e for e in events if "URL" in e.type and ".woff" in e.data)
 
 
 class TestHTTPX_querystring_removed(ModuleTestBase):

bbot/test/test_step_2/module_tests/test_module_hunterio.py

@@ -2,7 +2,7 @@ from .base import ModuleTestBase
 
 
 class TestHunterio(ModuleTestBase):
-    config_overrides = {"modules": {"hunterio": {"api_key": "asdf"}}}
+    config_overrides = {"modules": {"hunterio": {"api_key": ["asdf", "1234", "4321", "fdsa"]}}}
 
     async def setup_before_prep(self, module_test):
         module_test.httpx_mock.add_response(
@@ -17,7 +17,7 @@ class TestHunterio(ModuleTestBase):
                     "reset_date": "1917-05-23",
                     "team_id": 1234,
                     "calls": {
-                        "_deprecation_notice": "Sums the searches and the verifications, giving an unprecise look of the available requests",
+                        "_deprecation_notice": "Sums the searches and the verifications, giving an imprecise look of the available requests",
                         "used": 999,
                         "available": 2000,
                     },
@@ -29,7 +29,7 @@ class TestHunterio(ModuleTestBase):
             },
         )
         module_test.httpx_mock.add_response(
-            url="https://api.hunter.io/v2/domain-search?domain=blacklanternsecurity.com&api_key=asdf&limit=100&offset=0",
+            url="https://api.hunter.io/v2/domain-search?domain=blacklanternsecurity.com&api_key=fdsa&limit=100&offset=0",
             json={
                 "data": {
                     "domain": "blacklanternsecurity.com",
@@ -91,6 +91,70 @@ class TestHunterio(ModuleTestBase):
                 },
             },
         )
+        module_test.httpx_mock.add_response(
+            url="https://api.hunter.io/v2/domain-search?domain=blacklanternsecurity.com&api_key=4321&limit=100&offset=100",
+            json={
+                "data": {
+                    "domain": "blacklanternsecurity.com",
+                    "disposable": False,
+                    "webmail": False,
+                    "accept_all": False,
+                    "pattern": "{first}",
+                    "organization": "Black Lantern Security",
+                    "description": None,
+                    "twitter": None,
+                    "facebook": None,
+                    "linkedin": "https://linkedin.com/company/black-lantern-security",
+                    "instagram": None,
+                    "youtube": None,
+                    "technologies": ["jekyll", "nginx"],
+                    "country": "US",
+                    "state": "CA",
+                    "city": "Night City",
+                    "postal_code": "12345",
+                    "street": "123 Any St",
+                    "emails": [
+                        {
+                            "value": "fdsa@blacklanternsecurity.com",
+                            "type": "generic",
+                            "confidence": 77,
+                            "sources": [
+                                {
+                                    "domain": "blacklanternsecurity.com",
+                                    "uri": "http://blacklanternsecurity.com",
+                                    "extracted_on": "2021-06-09",
+                                    "last_seen_on": "2023-03-21",
+                                    "still_on_page": True,
+                                }
+                            ],
+                            "first_name": None,
+                            "last_name": None,
+                            "position": None,
+                            "seniority": None,
+                            "department": "support",
+                            "linkedin": None,
+                            "twitter": None,
+                            "phone_number": None,
+                            "verification": {"date": None, "status": None},
+                        }
+                    ],
+                    "linked_domains": [],
+                },
+                "meta": {
+                    "results": 1,
+                    "limit": 100,
+                    "offset": 0,
+                    "params": {
+                        "domain": "blacklanternsecurity.com",
+                        "company": None,
+                        "type": None,
+                        "seniority": None,
+                        "department": None,
+                    },
+                },
+            },
+        )
 
     def check(self, module_test, events):
-        assert any(e.data == "asdf@blacklanternsecurity.com" for e in events), "Failed to detect email"
+        assert any(e.data == "asdf@blacklanternsecurity.com" for e in events), "Failed to detect email #1"
+        assert any(e.data == "fdsa@blacklanternsecurity.com" for e in events), "Failed to detect email #2"

bbot/test/test_step_2/module_tests/test_module_jadx.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from bbot.core.helpers.libmagic import get_magic_info
+from bbot.test.test_step_2.module_tests.base import ModuleTestBase, tempapkfile
+
+
+class TestJadx(ModuleTestBase):
+    modules_overrides = ["apkpure", "google_playstore", "speculate", "jadx"]
+    apk_file = tempapkfile()
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.99"]}})
+        module_test.httpx_mock.add_response(
+            url="https://play.google.com/store/search?q=blacklanternsecurity&c=apps",
+            text="""<!DOCTYPE html>
+            <html>
+            <head>
+            <title>"blacklanternsecurity" - Android Apps on Google Play</title>
+            </head>
+            <body>
+            <a href="/store/apps/details?id=com.bbot.test&pcampaignid=dontmatchme&pli=1"/>
+            </body>
+            </html>""",
+        )
+        module_test.httpx_mock.add_response(
+            url="https://play.google.com/store/apps/details?id=com.bbot.test",
+            text="""<!DOCTYPE html>
+            <html>
+            <head>
+            <title>BBOT</title>
+            </head>
+            <body>
+            <meta name="appstore:developer_url" content="https://www.blacklanternsecurity.com">
+            </div>
+            </div>
+            </body>
+            </html>""",
+        )
+        module_test.httpx_mock.add_response(
+            url="https://d.apkpure.com/b/XAPK/com.bbot.test?version=latest",
+            content=self.apk_file,
+            headers={
+                "Content-Type": "application/vnd.android.package-archive",
+                "Content-Disposition": "attachment; filename=com.bbot.test.apk",
+            },
+        )
+
+    def check(self, module_test, events):
+        filesystem_events = [e for e in events if e.type == "FILESYSTEM"]
+        apk_event = [e for e in filesystem_events if "file" in e.tags]
+        extension, mime_type, description, confidence = get_magic_info(apk_event[0].data["path"])
+        assert description == "Android Application Package", f"Downloaded file was detected as {description}"
+        extract_event = [e for e in filesystem_events if "folder" in e.tags]
+        assert 1 == len(extract_event), "Failed to extract apk"
+        extract_path = Path(extract_event[0].data["path"])
+        assert extract_path.is_dir(), "Destination apk doesn't exist"

bbot/test/test_step_2/module_tests/test_module_json.py

@@ -9,6 +9,9 @@ class TestJSON(ModuleTestBase):
         dns_data = "blacklanternsecurity.com"
         context_data = f"Scan {module_test.scan.name} seeded with DNS_NAME: blacklanternsecurity.com"
 
+        scan_event = [e for e in events if e.type == "SCAN"][0]
+        dns_event = [e for e in events if e.type == "DNS_NAME"][0]
+
         # json events
         txt_file = module_test.scan.home / "output.json"
         lines = list(module_test.scan.helpers.read_file(txt_file))
@@ -16,30 +19,40 @@ class TestJSON(ModuleTestBase):
         json_events = [json.loads(line) for line in lines]
         scan_json = [e for e in json_events if e["type"] == "SCAN"]
         dns_json = [e for e in json_events if e["type"] == "DNS_NAME"]
-        assert len(scan_json) == 1
+        assert len(scan_json) == 2
         assert len(dns_json) == 1
-        scan_json = scan_json[0]
         dns_json = dns_json[0]
-        assert scan_json["data"]["name"] == module_test.scan.name
-        assert scan_json["data"]["id"] == module_test.scan.id
-        assert scan_json["data"]["target"]["seeds"] == ["blacklanternsecurity.com"]
-        assert scan_json["data"]["target"]["whitelist"] == ["blacklanternsecurity.com"]
+        scan = scan_json[0]
+        assert scan["data"]["name"] == module_test.scan.name
+        assert scan["data"]["id"] == module_test.scan.id
+        assert scan["id"] == module_test.scan.id
+        assert scan["uuid"] == str(module_test.scan.root_event.uuid)
+        assert scan["parent_uuid"] == str(module_test.scan.root_event.uuid)
+        assert scan["data"]["target"]["seeds"] == ["blacklanternsecurity.com"]
+        assert scan["data"]["target"]["whitelist"] == ["blacklanternsecurity.com"]
         assert dns_json["data"] == dns_data
+        assert dns_json["id"] == str(dns_event.id)
+        assert dns_json["uuid"] == str(dns_event.uuid)
+        assert dns_json["parent_uuid"] == str(module_test.scan.root_event.uuid)
         assert dns_json["discovery_context"] == context_data
         assert dns_json["discovery_path"] == [context_data]
-        assert dns_json["parent_chain"] == ["DNS_NAME:1e57014aa7b0715bca68e4f597204fc4e1e851fc"]
+        assert dns_json["parent_chain"] == [dns_json["uuid"]]
 
         # event objects reconstructed from json
-        scan_reconstructed = event_from_json(scan_json)
+        scan_reconstructed = event_from_json(scan_json[0])
         dns_reconstructed = event_from_json(dns_json)
         assert scan_reconstructed.data["name"] == module_test.scan.name
         assert scan_reconstructed.data["id"] == module_test.scan.id
+        assert scan_reconstructed.uuid == scan_event.uuid
+        assert scan_reconstructed.parent_uuid == scan_event.uuid
         assert scan_reconstructed.data["target"]["seeds"] == ["blacklanternsecurity.com"]
         assert scan_reconstructed.data["target"]["whitelist"] == ["blacklanternsecurity.com"]
         assert dns_reconstructed.data == dns_data
+        assert dns_reconstructed.uuid == dns_event.uuid
+        assert dns_reconstructed.parent_uuid == module_test.scan.root_event.uuid
         assert dns_reconstructed.discovery_context == context_data
         assert dns_reconstructed.discovery_path == [context_data]
-        assert dns_reconstructed.parent_chain == ["DNS_NAME:1e57014aa7b0715bca68e4f597204fc4e1e851fc"]
+        assert dns_reconstructed.parent_chain == [dns_json["uuid"]]
 
 
 class TestJSONSIEMFriendly(ModuleTestBase):

bbot/test/test_step_2/module_tests/test_module_leakix.py

@@ -6,12 +6,12 @@ class TestLeakIX(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         module_test.httpx_mock.add_response(
-            url="https://leakix.net/host/1.2.3.4.5",
+            url="https://leakix.net/host/1.1.1.1",
             match_headers={"api-key": "asdf"},
             json={"title": "Not Found", "description": "Host not found"},
         )
         module_test.httpx_mock.add_response(
-            url=f"https://leakix.net/api/subdomains/blacklanternsecurity.com",
+            url="https://leakix.net/api/subdomains/blacklanternsecurity.com",
             match_headers={"api-key": "asdf"},
             json=[
                 {
@@ -31,7 +31,11 @@ class TestLeakIX_NoAPIKey(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         module_test.httpx_mock.add_response(
-            url=f"https://leakix.net/api/subdomains/blacklanternsecurity.com",
+            url="https://leakix.net/host/1.1.1.1",
+            json={"title": "Not Found", "description": "Host not found"},
+        )
+        module_test.httpx_mock.add_response(
+            url="https://leakix.net/api/subdomains/blacklanternsecurity.com",
             json=[
                 {
                     "subdomain": "asdf.blacklanternsecurity.com",

bbot/test/test_step_2/module_tests/test_module_mysql.py

@@ -0,0 +1,76 @@
+import asyncio
+import time
+
+from .base import ModuleTestBase
+
+
+class TestMySQL(ModuleTestBase):
+    targets = ["evilcorp.com"]
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        process = await asyncio.create_subprocess_exec(
+            "docker",
+            "run",
+            "--name",
+            "bbot-test-mysql",
+            "--rm",
+            "-e",
+            "MYSQL_ROOT_PASSWORD=bbotislife",
+            "-e",
+            "MYSQL_DATABASE=bbot",
+            "-p",
+            "3306:3306",
+            "-d",
+            "mysql",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        import aiomysql
+
+        # wait for the container to start
+        start_time = time.time()
+        while True:
+            try:
+                conn = await aiomysql.connect(user="root", password="bbotislife", db="bbot", host="localhost")
+                conn.close()
+                break
+            except Exception as e:
+                if time.time() - start_time > 60:  # timeout after 60 seconds
+                    self.log.error("MySQL server did not start in time.")
+                    raise e
+                await asyncio.sleep(1)
+
+        if process.returncode != 0:
+            self.log.error(f"Failed to start MySQL server: {stderr.decode()}")
+
+    async def check(self, module_test, events):
+        import aiomysql
+
+        # Connect to the MySQL database
+        conn = await aiomysql.connect(user="root", password="bbotislife", db="bbot", host="localhost")
+
+        try:
+            async with conn.cursor() as cur:
+                await cur.execute("SELECT * FROM event")
+                events = await cur.fetchall()
+                assert len(events) == 3, "No events found in MySQL database"
+
+                await cur.execute("SELECT * FROM scan")
+                scans = await cur.fetchall()
+                assert len(scans) == 1, "No scans found in MySQL database"
+
+                await cur.execute("SELECT * FROM target")
+                targets = await cur.fetchall()
+                assert len(targets) == 1, "No targets found in MySQL database"
+        finally:
+            conn.close()
+            process = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-mysql", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode != 0:
+                raise Exception(f"Failed to stop MySQL server: {stderr.decode()}")

bbot/test/test_step_2/module_tests/test_module_myssl.py

@@ -5,7 +5,7 @@ class TestMySSL(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
         module_test.httpx_mock.add_response(
-            url=f"https://myssl.com/api/v1/discover_sub_domain?domain=blacklanternsecurity.com",
+            url="https://myssl.com/api/v1/discover_sub_domain?domain=blacklanternsecurity.com",
             json={
                 "code": 0,
                 "data": [

bbot/test/test_step_2/module_tests/test_module_neo4j.py

@@ -41,4 +41,4 @@ class TestNeo4j(ModuleTestBase):
         module_test.monkeypatch.setattr("neo4j.AsyncGraphDatabase.driver", MockDriver)
 
     def check(self, module_test, events):
-        assert self.neo4j_used == True
+        assert self.neo4j_used is True

bbot/test/test_step_2/module_tests/test_module_newsletters.py

@@ -33,11 +33,11 @@ class TestNewsletters(ModuleTestBase):
     """
 
     async def setup_after_prep(self, module_test):
-        request_args = dict(uri="/found", headers={"test": "header"})
-        respond_args = dict(response_data=self.html_with_newsletter)
+        request_args = {"uri": "/found", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_with_newsletter}
         module_test.set_expect_requests(request_args, respond_args)
-        request_args = dict(uri="/missing", headers={"test": "header"})
-        respond_args = dict(response_data=self.html_without_newsletter)
+        request_args = {"uri": "/missing", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_without_newsletter}
         module_test.set_expect_requests(request_args, respond_args)
 
     def check(self, module_test, events):
@@ -53,5 +53,5 @@ class TestNewsletters(ModuleTestBase):
                 # Verify Negative Result (should skip this statement if correct)
                 elif event.data["url"] == self.missing_tgt:
                     missing = False
-        assert found, f"NEWSLETTER 'Found' Error - Expect status of True but got False"
-        assert missing, f"NEWSLETTER 'Missing' Error - Expect status of True but got False"
+        assert found, "NEWSLETTER 'Found' Error - Expect status of True but got False"
+        assert missing, "NEWSLETTER 'Missing' Error - Expect status of True but got False"

bbot/test/test_step_2/module_tests/test_module_ntlm.py

@@ -7,16 +7,16 @@ class TestNTLM(ModuleTestBase):
     config_overrides = {"modules": {"ntlm": {"try_all": True}}}
 
     async def setup_after_prep(self, module_test):
-        request_args = dict(uri="/", headers={"test": "header"})
+        request_args = {"uri": "/", "headers": {"test": "header"}}
         module_test.set_expect_requests(request_args, {})
-        request_args = dict(
-            uri="/oab/", headers={"Authorization": "NTLM TlRMTVNTUAABAAAAl4II4gAAAAAAAAAAAAAAAAAAAAAKAGFKAAAADw=="}
-        )
-        respond_args = dict(
-            headers={
+        request_args = {
+            "uri": "/oab/", "headers": {"Authorization": "NTLM TlRMTVNTUAABAAAAl4II4gAAAAAAAAAAAAAAAAAAAAAKAGFKAAAADw=="}
+        }
+        respond_args = {
+            "headers": {
                 "WWW-Authenticate": "NTLM TlRMTVNTUAACAAAABgAGADgAAAAVgoni89aZT4Q0mH0AAAAAAAAAAHYAdgA+AAAABgGxHQAAAA9WAE4ATwACAAYAVgBOAE8AAQAKAEUAWABDADAAMQAEABIAdgBuAG8ALgBsAG8AYwBhAGwAAwAeAEUAWABDADAAMQAuAHYAbgBvAC4AbABvAGMAYQBsAAUAEgB2AG4AbwAuAGwAbwBjAGEAbAAHAAgAXxo0p/6L2QEAAAAA"
             }
-        )
+        }
         module_test.set_expect_requests(request_args, respond_args)
 
     def check(self, module_test, events):

bbot/test/test_step_2/module_tests/test_module_oauth.py

@@ -167,7 +167,7 @@ class TestOAUTH(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"evilcorp.com": {"A": ["127.0.0.1"]}})
         module_test.httpx_mock.add_response(
-            url=f"https://login.microsoftonline.com/getuserrealm.srf?login=test@evilcorp.com",
+            url="https://login.microsoftonline.com/getuserrealm.srf?login=test@evilcorp.com",
             json=Azure_Realm.response_json,
         )
         module_test.httpx_mock.add_response(

bbot/test/test_step_2/module_tests/test_module_otx.py

@@ -4,7 +4,7 @@ from .base import ModuleTestBase
 class TestOTX(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.httpx_mock.add_response(
-            url=f"https://otx.alienvault.com/api/v1/indicators/domain/blacklanternsecurity.com/passive_dns",
+            url="https://otx.alienvault.com/api/v1/indicators/domain/blacklanternsecurity.com/passive_dns",
             json={
                 "passive_dns": [
                     {

bbot/test/test_step_2/module_tests/test_module_paramminer_cookies.py

@@ -28,7 +28,7 @@ class TestParamminer_Cookies(Paramminer_Headers):
         module_test.monkeypatch.setattr(
             helper.HttpCompare, "gen_cache_buster", lambda *args, **kwargs: {"AAAAAA": "1"}
         )
-        expect_args = dict(headers={"Cookie": "admincookie=AAAAAAAAAAAAAA"})
+        expect_args = {"headers": {"Cookie": "admincookie=AAAAAAAAAAAAAA"}}
         respond_args = {"response_data": self.cookies_body_match}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
@@ -36,7 +36,6 @@ class TestParamminer_Cookies(Paramminer_Headers):
         module_test.set_expect_requests(respond_args=respond_args)
 
     def check(self, module_test, events):
-
         found_reflected_cookie = False
         false_positive_match = False
 

bbot/test/test_step_2/module_tests/test_module_paramminer_getparams.py

@@ -89,7 +89,6 @@ class TestParamminer_Getparams_boring_off(TestParamminer_Getparams):
         module_test.set_expect_requests(respond_args=respond_args)
 
     def check(self, module_test, events):
-
         emitted_boring_parameter = False
         for e in events:
             if e.type == "WEB_PARAMETER":
@@ -106,7 +105,6 @@ class TestParamminer_Getparams_boring_on(TestParamminer_Getparams_boring_off):
     }
 
     def check(self, module_test, events):
-
         emitted_boring_parameter = False
 
         for e in events:
@@ -160,15 +158,12 @@ class TestParamminer_Getparams_finish(Paramminer_Headers):
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-
         excavate_extracted_web_parameter = False
         found_hidden_getparam_recycled = False
         emitted_excavate_paramminer_duplicate = False
 
         for e in events:
-
             if e.type == "WEB_PARAMETER":
-
                 if (
                     "http://127.0.0.1:8888/test2.php" in e.data["url"]
                     and "HTTP Extracted Parameter [abcd1234] (HTML Tags Submodule)" in e.data["description"]
@@ -213,7 +208,6 @@ class TestParamminer_Getparams_xmlspeculative(Paramminer_Headers):
     """
 
     async def setup_after_prep(self, module_test):
-
         module_test.scan.modules["paramminer_getparams"].rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
         module_test.monkeypatch.setattr(
             helper.HttpCompare, "gen_cache_buster", lambda *args, **kwargs: {"AAAAAA": "1"}

bbot/test/test_step_2/module_tests/test_module_paramminer_headers.py

@@ -31,7 +31,7 @@ class Paramminer_Headers(ModuleTestBase):
         module_test.monkeypatch.setattr(
             helper.HttpCompare, "gen_cache_buster", lambda *args, **kwargs: {"AAAAAA": "1"}
         )
-        expect_args = dict(headers={"tracestate": "AAAAAAAAAAAAAA"})
+        expect_args = {"headers": {"tracestate": "AAAAAAAAAAAAAA"}}
         respond_args = {"response_data": self.headers_body_match}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
@@ -39,7 +39,6 @@ class Paramminer_Headers(ModuleTestBase):
         module_test.set_expect_requests(respond_args=respond_args)
 
     def check(self, module_test, events):
-
         found_reflected_header = False
         false_positive_match = False
 
@@ -60,7 +59,6 @@ class TestParamminer_Headers(Paramminer_Headers):
 
 
 class TestParamminer_Headers_noreflection(Paramminer_Headers):
-
     found_nonreflected_header = False
 
     headers_body_match = """
@@ -82,7 +80,6 @@ class TestParamminer_Headers_noreflection(Paramminer_Headers):
 
 
 class TestParamminer_Headers_extract(Paramminer_Headers):
-
     modules_overrides = ["httpx", "paramminer_headers", "excavate"]
     config_overrides = {
         "modules": {
@@ -115,7 +112,7 @@ class TestParamminer_Headers_extract(Paramminer_Headers):
         module_test.monkeypatch.setattr(
             helper.HttpCompare, "gen_cache_buster", lambda *args, **kwargs: {"AAAAAA": "1"}
         )
-        expect_args = dict(headers={"foo": "AAAAAAAAAAAAAA"})
+        expect_args = {"headers": {"foo": "AAAAAAAAAAAAAA"}}
         respond_args = {"response_data": self.headers_body_match}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
@@ -123,7 +120,6 @@ class TestParamminer_Headers_extract(Paramminer_Headers):
         module_test.set_expect_requests(respond_args=respond_args)
 
     def check(self, module_test, events):
-
         excavate_extracted_web_parameter = False
         used_recycled_parameter = False
 
@@ -139,17 +135,14 @@ class TestParamminer_Headers_extract(Paramminer_Headers):
 
 
 class TestParamminer_Headers_extract_norecycle(TestParamminer_Headers_extract):
-
     modules_overrides = ["httpx", "excavate"]
     config_overrides = {}
 
     async def setup_after_prep(self, module_test):
-
         respond_args = {"response_data": self.headers_body}
         module_test.set_expect_requests(respond_args=respond_args)
 
     def check(self, module_test, events):
-
         excavate_extracted_web_parameter = False
 
         for e in events: