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

bbot/core/helpers/process.py

@@ -1,17 +1,12 @@
 import logging
 import traceback
 import threading
-import multiprocessing
 from multiprocessing.context import SpawnProcess
 
 from .misc import in_exception_chain
 
 
-current_process = multiprocessing.current_process()
-
-
 class BBOTThread(threading.Thread):
-
     default_name = "default bbot thread"
 
     def __init__(self, *args, **kwargs):
@@ -28,7 +23,6 @@ class BBOTThread(threading.Thread):
 
 
 class BBOTProcess(SpawnProcess):
-
     default_name = "bbot process pool"
 
     def __init__(self, *args, **kwargs):
@@ -57,17 +51,3 @@ class BBOTProcess(SpawnProcess):
             if not in_exception_chain(e, (KeyboardInterrupt,)):
                 log.warning(f"Error in {self.name}: {e}")
             log.trace(traceback.format_exc())
-
-
-if current_process.name == "MainProcess":
-    # if this is the main bbot process, set the logger and queue for the first time
-    from bbot.core import CORE
-    from functools import partialmethod
-
-    BBOTProcess.__init__ = partialmethod(
-        BBOTProcess.__init__, log_level=CORE.logger.log_level, log_queue=CORE.logger.queue
-    )
-
-# this makes our process class the default for process pools, etc.
-mp_context = multiprocessing.get_context("spawn")
-mp_context.Process = BBOTProcess

bbot/core/helpers/regex.py

@@ -41,7 +41,7 @@ class RegexHelper:
         """
         if not isinstance(compiled_regexes, dict):
             raise ValueError('compiled_regexes must be a dictionary like this: {"regex_name": <compiled_regex>}')
-        for k, v in compiled_regexes.items():
+        for v in compiled_regexes.values():
             self.ensure_compiled_regex(v)
 
         tasks = {}

bbot/core/helpers/regexes.py

@@ -23,7 +23,7 @@ num_regex = re.compile(r"\d+")
 _ipv4_regex = r"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}"
 ipv4_regex = re.compile(_ipv4_regex, re.I)
 
-# IPv6 is complicated, so we have accomodate alternative patterns,
+# IPv6 is complicated, so we have accommodate alternative patterns,
 # :(:[A-F0-9]{1,4}){1,7} == ::1, ::ffff:1
 # ([A-F0-9]{1,4}:){1,7}: == 2001::, 2001:db8::, 2001:db8:0:1:2:3::
 # ([A-F0-9]{1,4}:){1,6}:([A-F0-9]{1,4}) == 2001::1, 2001:db8::1, 2001:db8:0:1:2:3::1
@@ -36,11 +36,12 @@ _ip_range_regexes = (
     _ipv4_regex + r"\/[0-9]{1,2}",
     _ipv6_regex + r"\/[0-9]{1,3}",
 )
-ip_range_regexes = list(re.compile(r, re.I) for r in _ip_range_regexes)
+ip_range_regexes = [re.compile(r, re.I) for r in _ip_range_regexes]
 
 # dns names with periods
 _dns_name_regex = r"(?:\w(?:[\w-]{0,100}\w)?\.)+(?:[xX][nN]--)?[^\W_]{1,63}\.?"
-dns_name_regex = re.compile(_dns_name_regex, re.I)
+dns_name_extraction_regex = re.compile(_dns_name_regex, re.I)
+dns_name_validation_regex = re.compile(r"^" + _dns_name_regex + r"$", re.I)
 
 # dns names without periods
 _hostname_regex = r"(?!\w*\.\w+)\w(?:[\w-]{0,100}\w)?"
@@ -54,20 +55,23 @@ ptr_regex = re.compile(_ptr_regex)
 # uuid regex
 _uuid_regex = r"[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}"
 uuid_regex = re.compile(_uuid_regex, re.I)
+# event uuid regex
+_event_uuid_regex = r"[0-9A-Z_]+:[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}"
+event_uuid_regex = re.compile(_event_uuid_regex, re.I)
 
 _open_port_regexes = (
     _dns_name_regex + r":[0-9]{1,5}",
     _hostname_regex + r":[0-9]{1,5}",
     r"\[" + _ipv6_regex + r"\]:[0-9]{1,5}",
 )
-open_port_regexes = list(re.compile(r, re.I) for r in _open_port_regexes)
+open_port_regexes = [re.compile(r, re.I) for r in _open_port_regexes]
 
 _url_regexes = (
     r"https?://" + _dns_name_regex + r"(?::[0-9]{1,5})?(?:(?:/|\?).*)?",
     r"https?://" + _hostname_regex + r"(?::[0-9]{1,5})?(?:(?:/|\?).*)?",
     r"https?://\[" + _ipv6_regex + r"\](?::[0-9]{1,5})?(?:(?:/|\?).*)?",
 )
-url_regexes = list(re.compile(r, re.I) for r in _url_regexes)
+url_regexes = [re.compile(r, re.I) for r in _url_regexes]
 
 _double_slash_regex = r"/{2,}"
 double_slash_regex = re.compile(_double_slash_regex)
@@ -114,7 +118,7 @@ event_type_regexes = OrderedDict(
 scan_name_regex = re.compile(r"[a-z]{3,20}_[a-z]{3,20}")
 
 
-# For use with excavate paramaters extractor
+# For use with excavate parameters extractor
 input_tag_regex = re.compile(
     r"<input[^>]+?name=[\"\']?([\.$\w]+)[\"\']?(?:[^>]*?value=[\"\']([=+\/\w]*)[\"\'])?[^>]*>"
 )
@@ -152,3 +156,5 @@ extract_host_regex = re.compile(_extract_host_regex, re.I)
 # for use in recursive_decode()
 encoded_regex = re.compile(r"%[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\[ntrbv]")
 backslash_regex = re.compile(r"(?P<slashes>\\+)(?P<char>[ntrvb])")
+
+uuid_regex = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")

bbot/core/helpers/validators.py

@@ -132,7 +132,7 @@ def validate_host(host: Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]
 @validator
 def validate_severity(severity: str):
     severity = str(severity).strip().upper()
-    if not severity in ("UNKNOWN", "INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"):
+    if severity not in ("UNKNOWN", "INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"):
         raise ValueError(f"Invalid severity: {severity}")
     return severity
 
@@ -299,7 +299,6 @@ def is_email(email):
 
 
 class Validators:
-
     def __init__(self, parent_helper):
         self.parent_helper = parent_helper
 

bbot/core/helpers/web/client.py

@@ -56,7 +56,7 @@ class BBOTAsyncClient(httpx.AsyncClient):
 
         # timeout
         http_timeout = self._web_config.get("http_timeout", 20)
-        if not "timeout" in kwargs:
+        if "timeout" not in kwargs:
             kwargs["timeout"] = http_timeout
 
         # headers

bbot/core/helpers/web/engine.py

@@ -14,7 +14,6 @@ log = logging.getLogger("bbot.core.helpers.web.engine")
 
 
 class HTTPEngine(EngineServer):
-
     CMDS = {
         0: "request",
         1: "request_batch",
@@ -138,7 +137,7 @@ class HTTPEngine(EngineServer):
         if max_size is not None:
             max_size = human_to_bytes(max_size)
         kwargs["follow_redirects"] = follow_redirects
-        if not "method" in kwargs:
+        if "method" not in kwargs:
             kwargs["method"] = "GET"
         try:
             total_size = 0

bbot/core/helpers/web/web.py

@@ -1,7 +1,5 @@
-import re
 import logging
 import warnings
-import traceback
 from pathlib import Path
 from bs4 import BeautifulSoup
 
@@ -21,7 +19,6 @@ log = logging.getLogger("bbot.core.helpers.web")
 
 
 class WebHelper(EngineClient):
-
     SERVER_CLASS = HTTPEngine
     ERROR_CLASS = WebError
 
@@ -60,7 +57,7 @@ class WebHelper(EngineClient):
         self.ssl_verify = self.config.get("ssl_verify", False)
         engine_debug = self.config.get("engine", {}).get("debug", False)
         super().__init__(
-            server_kwargs={"config": self.config, "target": self.parent_helper.preset.target.radix_only},
+            server_kwargs={"config": self.config, "target": self.parent_helper.preset.target.minimal},
             debug=engine_debug,
         )
 
@@ -264,7 +261,7 @@ class WebHelper(EngineClient):
         """
         if not path:
             raise WordlistError(f"Invalid wordlist: {path}")
-        if not "cache_hrs" in kwargs:
+        if "cache_hrs" not in kwargs:
             kwargs["cache_hrs"] = 720
         if self.parent_helper.is_url(path):
             filename = await self.download(str(path), **kwargs)
@@ -288,66 +285,6 @@ class WebHelper(EngineClient):
                     f.write(line)
             return truncated_filename
 
-    async def api_page_iter(self, url, page_size=100, json=True, next_key=None, **requests_kwargs):
-        """
-        An asynchronous generator function for iterating through paginated API data.
-
-        This function continuously makes requests to a specified API URL, incrementing the page number
-        or applying a custom pagination function, and yields the received data one page at a time.
-        It is well-suited for APIs that provide paginated results.
-
-        Args:
-            url (str): The initial API URL. Can contain placeholders for 'page', 'page_size', and 'offset'.
-            page_size (int, optional): The number of items per page. Defaults to 100.
-            json (bool, optional): If True, attempts to deserialize the response content to a JSON object. Defaults to True.
-            next_key (callable, optional): A function that takes the last page's data and returns the URL for the next page. Defaults to None.
-            **requests_kwargs: Arbitrary keyword arguments that will be forwarded to the HTTP request function.
-
-        Yields:
-            dict or httpx.Response: If 'json' is True, yields a dictionary containing the parsed JSON data. Otherwise, yields the raw HTTP response.
-
-        Note:
-            The loop will continue indefinitely unless manually stopped. Make sure to break out of the loop once the last page has been received.
-
-        Examples:
-            >>> agen = api_page_iter('https://api.example.com/data?page={page}&page_size={page_size}')
-            >>> try:
-            >>>     async for page in agen:
-            >>>         subdomains = page["subdomains"]
-            >>>         self.hugesuccess(subdomains)
-            >>>         if not subdomains:
-            >>>             break
-            >>> finally:
-            >>>     agen.aclose()
-        """
-        page = 1
-        offset = 0
-        result = None
-        while 1:
-            if result and callable(next_key):
-                try:
-                    new_url = next_key(result)
-                except Exception as e:
-                    log.debug(f"Failed to extract next page of results from {url}: {e}")
-                    log.debug(traceback.format_exc())
-            else:
-                new_url = url.format(page=page, page_size=page_size, offset=offset)
-            result = await self.request(new_url, **requests_kwargs)
-            if result is None:
-                log.verbose(f"api_page_iter() got no response for {url}")
-                break
-            try:
-                if json:
-                    result = result.json()
-                yield result
-            except Exception:
-                log.warning(f'Error in api_page_iter() for url: "{new_url}"')
-                log.trace(traceback.format_exc())
-                break
-            finally:
-                offset += page_size
-                page += 1
-
     async def curl(self, *args, **kwargs):
         """
         An asynchronous function that runs a cURL command with specified arguments and options.
@@ -413,7 +350,7 @@ class WebHelper(EngineClient):
                     headers[hk] = hv
 
             # add the timeout
-            if not "timeout" in kwargs:
+            if "timeout" not in kwargs:
                 timeout = http_timeout
 
             curl_command.append("-m")
@@ -514,7 +451,7 @@ class WebHelper(EngineClient):
             Perform an html parse of the 'markup' argument and return a soup instance
 
             >>> email_type = soup.find(type="email")
-            Searches the soup instance for all occurances of the passed in argument
+            Searches the soup instance for all occurrences of the passed in argument
         """
         try:
             soup = BeautifulSoup(
@@ -525,53 +462,6 @@ class WebHelper(EngineClient):
             log.debug(f"Error parsing beautifulsoup: {e}")
             return False
 
-    user_keywords = [re.compile(r, re.I) for r in ["user", "login", "email"]]
-    pass_keywords = [re.compile(r, re.I) for r in ["pass"]]
-
-    def is_login_page(self, html):
-        """
-        TODO: convert this into an excavate YARA rule
-
-        Determines if the provided HTML content contains a login page.
-
-        This function parses the HTML to search for forms with input fields typically used for
-        authentication. If it identifies password fields or a combination of username and password
-        fields, it returns True.
-
-        Args:
-            html (str): The HTML content to analyze.
-
-        Returns:
-            bool: True if the HTML contains a login page, otherwise False.
-
-        Examples:
-            >>> is_login_page('<form><input type="text" name="username"><input type="password" name="password"></form>')
-            True
-
-            >>> is_login_page('<form><input type="text" name="search"></form>')
-            False
-        """
-        try:
-            soup = BeautifulSoup(html, "html.parser")
-        except Exception as e:
-            log.debug(f"Error parsing html: {e}")
-            return False
-
-        forms = soup.find_all("form")
-
-        # first, check for obvious password fields
-        for form in forms:
-            if form.find_all("input", {"type": "password"}):
-                return True
-
-        # next, check for forms that have both a user-like and password-like field
-        for form in forms:
-            user_fields = sum(bool(form.find_all("input", {"name": r})) for r in self.user_keywords)
-            pass_fields = sum(bool(form.find_all("input", {"name": r})) for r in self.pass_keywords)
-            if user_fields and pass_fields:
-                return True
-        return False
-
     def response_to_json(self, response):
         """
         Convert web response to JSON object, similar to the output of `httpx -irr -json`

bbot/core/helpers/wordcloud.py

@@ -111,7 +111,7 @@ class WordCloud(dict):
         results = set()
         for word in words:
             h = hash(word)
-            if not h in results:
+            if h not in results:
                 results.add(h)
                 yield (word,)
         if numbers > 0:
@@ -119,7 +119,7 @@ class WordCloud(dict):
                 for word in words:
                     for number_mutation in self.get_number_mutations(word, n=numbers, padding=number_padding):
                         h = hash(number_mutation)
-                        if not h in results:
+                        if h not in results:
                             results.add(h)
                             yield (number_mutation,)
         for word in words:
@@ -322,7 +322,7 @@ class WordCloud(dict):
 
     @property
     def default_filename(self):
-        return self.parent_helper.preset.scan.home / f"wordcloud.tsv"
+        return self.parent_helper.preset.scan.home / "wordcloud.tsv"
 
     def save(self, filename=None, limit=None):
         """
@@ -357,7 +357,7 @@ class WordCloud(dict):
                 log.debug(f"Saved word cloud ({len(self):,} words) to {filename}")
                 return True, filename
             else:
-                log.debug(f"No words to save")
+                log.debug("No words to save")
         except Exception as e:
             import traceback
 
@@ -421,7 +421,7 @@ class Mutator(dict):
     def mutate(self, word, max_mutations=None, mutations=None):
         if mutations is None:
             mutations = self.top_mutations(max_mutations)
-        for mutation, count in mutations.items():
+        for mutation in mutations.keys():
             ret = []
             for s in mutation:
                 if s is not None:

bbot/core/modules.py

@@ -153,7 +153,7 @@ class ModuleLoader:
                 else:
                     log.debug(f"Preloading {module_name} from disk")
                     if module_dir.name == "modules":
-                        namespace = f"bbot.modules"
+                        namespace = "bbot.modules"
                     else:
                         namespace = f"bbot.modules.{module_dir.name}"
                     try:
@@ -235,7 +235,7 @@ class ModuleLoader:
         return self.__preloaded
 
     def get_recursive_dirs(self, *dirs):
-        dirs = set(Path(d).resolve() for d in dirs)
+        dirs = {Path(d).resolve() for d in dirs}
         for d in list(dirs):
             if not d.is_dir():
                 continue
@@ -337,77 +337,77 @@ class ModuleLoader:
             # look for classes
             if type(root_element) == ast.ClassDef:
                 for class_attr in root_element.body:
-
                     # class attributes that are dictionaries
                     if type(class_attr) == ast.Assign and type(class_attr.value) == ast.Dict:
                         # module options
-                        if any([target.id == "options" for target in class_attr.targets]):
+                        if any(target.id == "options" for target in class_attr.targets):
                             config.update(ast.literal_eval(class_attr.value))
                         # module options
-                        elif any([target.id == "options_desc" for target in class_attr.targets]):
+                        elif any(target.id == "options_desc" for target in class_attr.targets):
                             options_desc.update(ast.literal_eval(class_attr.value))
                         # module metadata
-                        elif any([target.id == "meta" for target in class_attr.targets]):
+                        elif any(target.id == "meta" for target in class_attr.targets):
                             meta = ast.literal_eval(class_attr.value)
 
                     # class attributes that are lists
                     if type(class_attr) == ast.Assign and type(class_attr.value) == ast.List:
                         # flags
-                        if any([target.id == "flags" for target in class_attr.targets]):
+                        if any(target.id == "flags" for target in class_attr.targets):
                             for flag in class_attr.value.elts:
                                 if type(flag.value) == str:
                                     flags.add(flag.value)
                         # watched events
-                        elif any([target.id == "watched_events" for target in class_attr.targets]):
+                        elif any(target.id == "watched_events" for target in class_attr.targets):
                             for event_type in class_attr.value.elts:
                                 if type(event_type.value) == str:
                                     watched_events.add(event_type.value)
                         # produced events
-                        elif any([target.id == "produced_events" for target in class_attr.targets]):
+                        elif any(target.id == "produced_events" for target in class_attr.targets):
                             for event_type in class_attr.value.elts:
                                 if type(event_type.value) == str:
                                     produced_events.add(event_type.value)
 
                         # bbot module dependencies
-                        elif any([target.id == "deps_modules" for target in class_attr.targets]):
+                        elif any(target.id == "deps_modules" for target in class_attr.targets):
                             for dep_module in class_attr.value.elts:
                                 if type(dep_module.value) == str:
                                     deps_modules.add(dep_module.value)
                         # python dependencies
-                        elif any([target.id == "deps_pip" for target in class_attr.targets]):
+                        elif any(target.id == "deps_pip" for target in class_attr.targets):
                             for dep_pip in class_attr.value.elts:
                                 if type(dep_pip.value) == str:
                                     deps_pip.append(dep_pip.value)
-                        elif any([target.id == "deps_pip_constraints" for target in class_attr.targets]):
+                        elif any(target.id == "deps_pip_constraints" for target in class_attr.targets):
                             for dep_pip in class_attr.value.elts:
                                 if type(dep_pip.value) == str:
                                     deps_pip_constraints.append(dep_pip.value)
                         # apt dependencies
-                        elif any([target.id == "deps_apt" for target in class_attr.targets]):
+                        elif any(target.id == "deps_apt" for target in class_attr.targets):
                             for dep_apt in class_attr.value.elts:
                                 if type(dep_apt.value) == str:
                                     deps_apt.append(dep_apt.value)
                         # bash dependencies
-                        elif any([target.id == "deps_shell" for target in class_attr.targets]):
+                        elif any(target.id == "deps_shell" for target in class_attr.targets):
                             for dep_shell in class_attr.value.elts:
                                 deps_shell.append(ast.literal_eval(dep_shell))
                         # ansible playbook
-                        elif any([target.id == "deps_ansible" for target in class_attr.targets]):
+                        elif any(target.id == "deps_ansible" for target in class_attr.targets):
                             ansible_tasks = ast.literal_eval(class_attr.value)
                         # shared/common module dependencies
-                        elif any([target.id == "deps_common" for target in class_attr.targets]):
+                        elif any(target.id == "deps_common" for target in class_attr.targets):
                             for dep_common in class_attr.value.elts:
                                 if type(dep_common.value) == str:
                                     deps_common.append(dep_common.value)
 
         for task in ansible_tasks:
-            if not "become" in task:
+            if "become" not in task:
                 task["become"] = False
             # don't sudo brew
-            elif os_platform() == "darwin" and ("package" in task and task.get("become", False) == True):
+            elif os_platform() == "darwin" and ("package" in task and task.get("become", False) is True):
                 task["become"] = False
 
         preloaded_data = {
+            "path": str(module_file.resolve()),
             "watched_events": sorted(watched_events),
             "produced_events": sorted(produced_events),
             "flags": sorted(flags),
@@ -436,8 +436,8 @@ class ModuleLoader:
                     f'Error while preloading module "{module_file}": No shared dependency named "{dep_common}" (choices: {common_choices})'
                 )
         for ansible_task in ansible_task_list:
-            if any(x == True for x in search_dict_by_key("become", ansible_task)) or any(
-                x == True for x in search_dict_by_key("ansible_become", ansible_tasks)
+            if any(x is True for x in search_dict_by_key("become", ansible_task)) or any(
+                x is True for x in search_dict_by_key("ansible_become", ansible_tasks)
             ):
                 preloaded_data["sudo"] = True
         return preloaded_data
@@ -467,14 +467,23 @@ class ModuleLoader:
             >>> isinstance(module, object)
             True
         """
-        namespace = self._preloaded[module_name]["namespace"]
-        import_path = f"{namespace}.{module_name}"
-        module_variables = importlib.import_module(import_path, "bbot")
+        preloaded = self._preloaded[module_name]
+        namespace = preloaded["namespace"]
+        try:
+            module_path = preloaded["path"]
+        except KeyError:
+            module_path = preloaded["cache_key"][0]
+        full_namespace = f"{namespace}.{module_name}"
+
+        spec = importlib.util.spec_from_file_location(full_namespace, module_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[full_namespace] = module
+        spec.loader.exec_module(module)
 
         # for every top-level variable in the .py file
-        for variable in module_variables.__dict__.keys():
+        for variable in module.__dict__.keys():
             # get its value
-            value = getattr(module_variables, variable)
+            value = getattr(module, variable)
             with suppress(AttributeError):
                 # if it has watched_events and produced_events
                 if all(
@@ -531,7 +540,7 @@ class ModuleLoader:
                     with suppress(KeyError):
                         choices.remove(modname)
                     if event_type not in resolve_choices:
-                        resolve_choices[event_type] = dict()
+                        resolve_choices[event_type] = {}
                     deps = resolve_choices[event_type]
                     self.add_or_create(deps, "required_by", modname)
                     for c in choices:
@@ -630,7 +639,7 @@ class ModuleLoader:
     def modules_options_table(self, modules=None, mod_type=None):
         table = []
         header = ["Config Option", "Type", "Description", "Default"]
-        for module_name, module_options in self.modules_options(modules, mod_type).items():
+        for module_options in self.modules_options(modules, mod_type).values():
             table += module_options
         return make_table(table, header)
 

bbot/core/multiprocess.py

@@ -0,0 +1,58 @@
+import os
+import atexit
+from contextlib import suppress
+
+
+class SharedInterpreterState:
+    """
+    A class to track the primary BBOT process.
+
+    Used to prevent spawning multiple unwanted processes with multiprocessing.
+    """
+
+    def __init__(self):
+        self.main_process_var_name = "_BBOT_MAIN_PID"
+        self.scan_process_var_name = "_BBOT_SCAN_PID"
+        atexit.register(self.cleanup)
+
+    @property
+    def is_main_process(self):
+        is_main_process = self.main_pid == os.getpid()
+        return is_main_process
+
+    @property
+    def is_scan_process(self):
+        is_scan_process = os.getpid() == self.scan_pid
+        return is_scan_process
+
+    @property
+    def main_pid(self):
+        main_pid = int(os.environ.get(self.main_process_var_name, 0))
+        if main_pid == 0:
+            main_pid = os.getpid()
+            # if main PID is not set, set it to the current PID
+            os.environ[self.main_process_var_name] = str(main_pid)
+        return main_pid
+
+    @property
+    def scan_pid(self):
+        scan_pid = int(os.environ.get(self.scan_process_var_name, 0))
+        if scan_pid == 0:
+            scan_pid = os.getpid()
+            # if scan PID is not set, set it to the current PID
+            os.environ[self.scan_process_var_name] = str(scan_pid)
+        return scan_pid
+
+    def update_scan_pid(self):
+        os.environ[self.scan_process_var_name] = str(os.getpid())
+
+    def cleanup(self):
+        with suppress(Exception):
+            if self.is_main_process:
+                with suppress(KeyError):
+                    del os.environ[self.main_process_var_name]
+                with suppress(KeyError):
+                    del os.environ[self.scan_process_var_name]
+
+
+SHARED_INTERPRETER_STATE = SharedInterpreterState()