Class ScanIngress

bbot/scanner/manager.py:8–168

This is always the first intercept module in the chain, responsible for basic scope checks It has its own incoming queue, but will also pull events from modules' outgoing queues

class ScanIngress(BaseInterceptModule):
    """
    This is always the first intercept module in the chain, responsible for basic scope checks

    It has its own incoming queue, but will also pull events from modules' outgoing queues
    """

    watched_events = ["*"]
    # accept all events regardless of scope distance
    scope_distance_modifier = None
    _name = "_scan_ingress"
    _qsize = -1

    @property
    def priority(self):
        # we are the highest priority
        return -99

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._module_priority_weights = None
        self._non_intercept_modules = None
        # track incoming duplicates module-by-module (for `suppress_dupes` attribute of modules)
        self.incoming_dup_tracker = set()

    async def init_events(self, event_seeds=None):
        """
        Initializes events by seeding the scanner with target events and distributing them for further processing.

        Notes:
            - This method populates the event queue with initial target events.
            - It also marks the Scan object as finished with initialization by setting `_finished_init` to True.
        """
        async with (
            self.scan._acatch(self.init_events, unhandled_is_critical=True),
            self._task_counter.count(self.init_events),
        ):
            if event_seeds is None:
                event_seeds = self.scan.target.seeds.event_seeds
            root_event = self.scan.root_event
            event_seeds = sorted(event_seeds, key=lambda e: (host_size_key(str(e.host)), e.data))
            # queue root scan event
            await self.queue_event(root_event, {})
            target_module = self.scan._make_dummy_module(name="TARGET", _type="TARGET")
            # queue each target in turn
            for event_seed in event_seeds:
                event = self.scan.make_event(
                    event_seed.data,
                    event_seed.type,
                    parent=root_event,
                    module=target_module,
                    context=f"Scan {self.scan.name} seeded with " + "{event.type}: {event.data}",
                    tags=["target"],
                )
                self.verbose(f"Target: {event}")
                # don't fill up the queue with too many events
                while self.incoming_event_queue.qsize() > 100:
                    await asyncio.sleep(0.2)