cartography 0.102.0rc1__py3-none-any.whl → 0.103.0__py3-none-any.whl

cartography/models/tailscale/device.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class TailscaleDeviceNodeProperties(CartographyNodeProperties):
+    # We use nodeId because the old property `id` is deprecated
+    id: PropertyRef = PropertyRef("nodeId")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    name: PropertyRef = PropertyRef("name")
+    hostname: PropertyRef = PropertyRef("hostname")
+    client_version: PropertyRef = PropertyRef("clientVersion")
+    update_available: PropertyRef = PropertyRef("updateAvailable")
+    os: PropertyRef = PropertyRef("os")
+    created: PropertyRef = PropertyRef("created")
+    last_seen: PropertyRef = PropertyRef("lastSeen")
+    key_expiry_disabled: PropertyRef = PropertyRef("keyExpiryDisabled")
+    expires: PropertyRef = PropertyRef("expires")
+    authorized: PropertyRef = PropertyRef("authorized")
+    is_external: PropertyRef = PropertyRef("isExternal")
+    node_key: PropertyRef = PropertyRef("nodeKey")
+    blocks_incoming_connections: PropertyRef = PropertyRef("blocksIncomingConnections")
+    client_connectivity_endpoints: PropertyRef = PropertyRef(
+        "clientConnectivity.endpoints"
+    )
+    client_connectivity_mapping_varies_by_dest_ip: PropertyRef = PropertyRef(
+        "clientConnectivity.mappingVariesByDestIP"
+    )
+    tailnet_lock_error: PropertyRef = PropertyRef("tailnetLockError")
+    tailnet_lock_key: PropertyRef = PropertyRef("tailnetLockKey")
+    posture_identity_serial_numbers: PropertyRef = PropertyRef(
+        "postureIdentity.serialNumbers"
+    )
+    posture_identity_disabled: PropertyRef = PropertyRef("postureIdentity.disabled")
+
+
+@dataclass(frozen=True)
+class TailscaleDeviceToTailnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleTailnet)-[:RESOURCE]->(:TailscaleDevice)
+class TailscaleDeviceToTailnetRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleTailnet"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("org", set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: TailscaleDeviceToTailnetRelProperties = (
+        TailscaleDeviceToTailnetRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleDeviceToUserRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleUser)-[:OWNS]->(:TailscaleDevice)
+class TailscaleDeviceToUserRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleUser"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"login_name": PropertyRef("user")},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "OWNS"
+    properties: TailscaleDeviceToUserRelProperties = (
+        TailscaleDeviceToUserRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleDeviceSchema(CartographyNodeSchema):
+    label: str = "TailscaleDevice"
+    properties: TailscaleDeviceNodeProperties = TailscaleDeviceNodeProperties()
+    sub_resource_relationship: TailscaleDeviceToTailnetRel = (
+        TailscaleDeviceToTailnetRel()
+    )
+    other_relationships = OtherRelationships(
+        [
+            TailscaleDeviceToUserRel(),
+        ]
+    )

cartography/models/tailscale/group.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class TailscaleGroupNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("id")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    name: PropertyRef = PropertyRef("name")
+
+
+@dataclass(frozen=True)
+class TailscaleGroupToTailnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleTailnet)-[:RESOURCE]->(:TailscaleGroup)
+class TailscaleGroupToTailnetRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleTailnet"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("org", set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: TailscaleGroupToTailnetRelProperties = (
+        TailscaleGroupToTailnetRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleGroupToUserRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleUser)-[:MEMBER_OF]->(:TailscaleGroup)
+class TailscaleGroupToUserRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleUser"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"login_name": PropertyRef("members", one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "MEMBER_OF"
+    properties: TailscaleGroupToUserRelProperties = TailscaleGroupToUserRelProperties()
+
+
+@dataclass(frozen=True)
+class TailscaleGroupToGroupRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleGroup)-[:MEMBER_OF]->(:TailscaleGroup)
+class TailscaleGroupToGroupRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleGroup"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("sub_groups", one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "MEMBER_OF"
+    properties: TailscaleGroupToGroupRelProperties = (
+        TailscaleGroupToGroupRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleGroupSchema(CartographyNodeSchema):
+    label: str = "TailscaleGroup"
+    properties: TailscaleGroupNodeProperties = TailscaleGroupNodeProperties()
+    sub_resource_relationship: TailscaleGroupToTailnetRel = TailscaleGroupToTailnetRel()
+    other_relationships = OtherRelationships(
+        [
+            TailscaleGroupToGroupRel(),
+            TailscaleGroupToUserRel(),
+        ]
+    )

cartography/models/tailscale/postureintegration.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class TailscalePostureIntegrationNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("id")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    provider: PropertyRef = PropertyRef("provider")
+    cloud_id: PropertyRef = PropertyRef("cloudId")
+    client_id: PropertyRef = PropertyRef("clientId")
+    tenant_id: PropertyRef = PropertyRef("tenantId")
+    config_updated: PropertyRef = PropertyRef("configUpdated")
+    status_last_sync: PropertyRef = PropertyRef("status.lastSync")
+    status_error: PropertyRef = PropertyRef("status.error")
+    status_provider_host_count: PropertyRef = PropertyRef("status.providerHostCount")
+    status_matched_count: PropertyRef = PropertyRef("status.matchedCount")
+    status_possible_matched_count: PropertyRef = PropertyRef(
+        "status.possibleMatchedCount"
+    )
+
+
+@dataclass(frozen=True)
+class TailscalePostureIntegrationToTailnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleTailnet)-[:RESOURCE]->(:TailscalePostureIntegration)
+class TailscalePostureIntegrationToTailnetRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleTailnet"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("org", set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: TailscalePostureIntegrationToTailnetRelProperties = (
+        TailscalePostureIntegrationToTailnetRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscalePostureIntegrationSchema(CartographyNodeSchema):
+    label: str = "TailscalePostureIntegration"
+    properties: TailscalePostureIntegrationNodeProperties = (
+        TailscalePostureIntegrationNodeProperties()
+    )
+    sub_resource_relationship: TailscalePostureIntegrationToTailnetRel = (
+        TailscalePostureIntegrationToTailnetRel()
+    )

cartography/models/tailscale/tag.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class TailscaleTagNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("id")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    name: PropertyRef = PropertyRef("name")
+
+
+@dataclass(frozen=True)
+class TailscaleTagToTailnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleTailnet)-[:RESOURCE]->(:TailscaleTag)
+class TailscaleTagToTailnetRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleTailnet"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("org", set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: TailscaleTagToTailnetRelProperties = (
+        TailscaleTagToTailnetRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleTagToUserRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleUser)-[:OWNS]->(:TailscaleTag)
+class TailscaleTagToUserRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleUser"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"login_name": PropertyRef("owners", one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "OWNS"
+    properties: TailscaleTagToUserRelProperties = TailscaleTagToUserRelProperties()
+
+
+@dataclass(frozen=True)
+class TailscaleTagToGroupRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleGroup)-[:OWNS]->(:TailscaleTag)
+class TailscaleTagToGroupRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleGroup"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("group_owners", one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "OWNS"
+    properties: TailscaleTagToGroupRelProperties = TailscaleTagToGroupRelProperties()
+
+
+@dataclass(frozen=True)
+class TailscaleTagToDeviceRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleDevice)-[:TAGGED]->(:TailscaleTag)
+class TailscaleTagToDeviceRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleDevice"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("devices", one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "TAGGED"
+    properties: TailscaleTagToDeviceRelProperties = TailscaleTagToDeviceRelProperties()
+
+
+@dataclass(frozen=True)
+class TailscaleTagSchema(CartographyNodeSchema):
+    label: str = "TailscaleTag"
+    properties: TailscaleTagNodeProperties = TailscaleTagNodeProperties()
+    sub_resource_relationship: TailscaleTagToTailnetRel = TailscaleTagToTailnetRel()
+    other_relationships = OtherRelationships(
+        [
+            TailscaleTagToGroupRel(),
+            TailscaleTagToUserRel(),
+            TailscaleTagToDeviceRel(),
+        ]
+    )

cartography/models/tailscale/tailnet.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+
+
+@dataclass(frozen=True)
+class TailscaleTailnetNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("org", set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    devices_approval_on: PropertyRef = PropertyRef("devicesApprovalOn")
+    devices_auto_updates_on: PropertyRef = PropertyRef("devicesAutoUpdatesOn")
+    devices_key_duration_days: PropertyRef = PropertyRef("devicesKeyDurationDays")
+    users_approval_on: PropertyRef = PropertyRef("usersApprovalOn")
+    users_role_allowed_to_join_external_tailnets: PropertyRef = PropertyRef(
+        "usersRoleAllowedToJoinExternalTailnets"
+    )
+    network_flow_logging_on: PropertyRef = PropertyRef("networkFlowLoggingOn")
+    regional_routing_on: PropertyRef = PropertyRef("regionalRoutingOn")
+    posture_identity_collection_on: PropertyRef = PropertyRef(
+        "postureIdentityCollectionOn"
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleTailnetSchema(CartographyNodeSchema):
+    label: str = "TailscaleTailnet"
+    properties: TailscaleTailnetNodeProperties = TailscaleTailnetNodeProperties()

cartography/models/tailscale/user.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class TailscaleUserNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("id")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+    display_name: PropertyRef = PropertyRef("displayName")
+    login_name: PropertyRef = PropertyRef("loginName", extra_index=True)
+    profile_pic_url: PropertyRef = PropertyRef("profilePicUrl")
+    created: PropertyRef = PropertyRef("created")
+    type: PropertyRef = PropertyRef("type")
+    role: PropertyRef = PropertyRef("role")
+    status: PropertyRef = PropertyRef("status")
+    device_count: PropertyRef = PropertyRef("deviceCount")
+    last_seen: PropertyRef = PropertyRef("lastSeen")
+    currently_connected: PropertyRef = PropertyRef("currentlyConnected")
+
+
+@dataclass(frozen=True)
+class TailscaleUserToTailnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+# (:TailscaleTailnet)-[:RESOURCE]->(:TailscaleUser)
+class TailscaleUserToTailnetRel(CartographyRelSchema):
+    target_node_label: str = "TailscaleTailnet"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("org", set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: TailscaleUserToTailnetRelProperties = (
+        TailscaleUserToTailnetRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class TailscaleUserSchema(CartographyNodeSchema):
+    label: str = "TailscaleUser"
+    properties: TailscaleUserNodeProperties = TailscaleUserNodeProperties()
+    sub_resource_relationship: TailscaleUserToTailnetRel = TailscaleUserToTailnetRel()

cartography/stats.py

@@ -17,11 +17,11 @@ class ScopedStatsClient:
 
     _client: StatsClient = None
 
-    def __init__(self, prefix: Optional[str], root: 'ScopedStatsClient'):
+    def __init__(self, prefix: Optional[str], root: "ScopedStatsClient"):
         self._scope_prefix = prefix
         self._root = root
 
-    def get_stats_client(self, scope: str) -> 'ScopedStatsClient':
+    def get_stats_client(self, scope: str) -> "ScopedStatsClient":
         """
         This method returns a new proxy to the same client
         which will prefix all calls to underlying methods with the scoped prefix
@@ -35,7 +35,7 @@ class ScopedStatsClient:
         return scoped_stats_client
 
     @staticmethod
-    def get_root_client() -> 'ScopedStatsClient':
+    def get_root_client() -> "ScopedStatsClient":
         client = ScopedStatsClient(prefix=None, root=None)  # type: ignore
         client._root = client
         return client

cartography/sync.py

@@ -1,7 +1,9 @@
 import argparse
 import logging
+import re
 import time
 from collections import OrderedDict
+from pkgutil import iter_modules
 from typing import Callable
 from typing import List
 from typing import Tuple
@@ -15,6 +17,7 @@ import cartography.intel.analysis
 import cartography.intel.aws
 import cartography.intel.azure
 import cartography.intel.bigfix
+import cartography.intel.cloudflare
 import cartography.intel.create_indexes
 import cartography.intel.crowdstrike
 import cartography.intel.cve
@@ -29,8 +32,10 @@ import cartography.intel.kubernetes
 import cartography.intel.lastpass
 import cartography.intel.oci
 import cartography.intel.okta
+import cartography.intel.openai
 import cartography.intel.semgrep
 import cartography.intel.snipeit
+import cartography.intel.tailscale
 from cartography.config import Config
 from cartography.stats import set_stats_client
 from cartography.util import STATUS_FAILURE
@@ -39,28 +44,33 @@ from cartography.util import STATUS_SUCCESS
 logger = logging.getLogger(__name__)
 
 
-TOP_LEVEL_MODULES = OrderedDict({  # preserve order so that the default sync always runs `analysis` at the very end
-    'create-indexes': cartography.intel.create_indexes.run,
-    'aws': cartography.intel.aws.start_aws_ingestion,
-    'azure': cartography.intel.azure.start_azure_ingestion,
-    'entra': cartography.intel.entra.start_entra_ingestion,
-    'crowdstrike': cartography.intel.crowdstrike.start_crowdstrike_ingestion,
-    'gcp': cartography.intel.gcp.start_gcp_ingestion,
-    'gsuite': cartography.intel.gsuite.start_gsuite_ingestion,
-    'cve': cartography.intel.cve.start_cve_ingestion,
-    'oci': cartography.intel.oci.start_oci_ingestion,
-    'okta': cartography.intel.okta.start_okta_ingestion,
-    'github': cartography.intel.github.start_github_ingestion,
-    'digitalocean': cartography.intel.digitalocean.start_digitalocean_ingestion,
-    'kandji': cartography.intel.kandji.start_kandji_ingestion,
-    'kubernetes': cartography.intel.kubernetes.start_k8s_ingestion,
-    'lastpass': cartography.intel.lastpass.start_lastpass_ingestion,
-    'bigfix': cartography.intel.bigfix.start_bigfix_ingestion,
-    'duo': cartography.intel.duo.start_duo_ingestion,
-    'semgrep': cartography.intel.semgrep.start_semgrep_ingestion,
-    'snipeit': cartography.intel.snipeit.start_snipeit_ingestion,
-    'analysis': cartography.intel.analysis.run,
-})
+TOP_LEVEL_MODULES = OrderedDict(
+    {  # preserve order so that the default sync always runs `analysis` at the very end
+        "create-indexes": cartography.intel.create_indexes.run,
+        "aws": cartography.intel.aws.start_aws_ingestion,
+        "azure": cartography.intel.azure.start_azure_ingestion,
+        "entra": cartography.intel.entra.start_entra_ingestion,
+        "cloudflare": cartography.intel.cloudflare.start_cloudflare_ingestion,
+        "crowdstrike": cartography.intel.crowdstrike.start_crowdstrike_ingestion,
+        "gcp": cartography.intel.gcp.start_gcp_ingestion,
+        "gsuite": cartography.intel.gsuite.start_gsuite_ingestion,
+        "cve": cartography.intel.cve.start_cve_ingestion,
+        "oci": cartography.intel.oci.start_oci_ingestion,
+        "okta": cartography.intel.okta.start_okta_ingestion,
+        "openai": cartography.intel.openai.start_openai_ingestion,
+        "github": cartography.intel.github.start_github_ingestion,
+        "digitalocean": cartography.intel.digitalocean.start_digitalocean_ingestion,
+        "kandji": cartography.intel.kandji.start_kandji_ingestion,
+        "kubernetes": cartography.intel.kubernetes.start_k8s_ingestion,
+        "lastpass": cartography.intel.lastpass.start_lastpass_ingestion,
+        "bigfix": cartography.intel.bigfix.start_bigfix_ingestion,
+        "duo": cartography.intel.duo.start_duo_ingestion,
+        "semgrep": cartography.intel.semgrep.start_semgrep_ingestion,
+        "snipeit": cartography.intel.snipeit.start_snipeit_ingestion,
+        "tailscale": cartography.intel.tailscale.start_tailscale_ingestion,
+        "analysis": cartography.intel.analysis.run,
+    }
+)
 
 
 class Sync:
@@ -98,7 +108,11 @@ class Sync:
         for name, func in stages:
             self.add_stage(name, func)
 
-    def run(self, neo4j_driver: neo4j.Driver, config: Union[Config, argparse.Namespace]) -> int:
+    def run(
+        self,
+        neo4j_driver: neo4j.Driver,
+        config: Union[Config, argparse.Namespace],
+    ) -> int:
         """
         Execute all stages in the sync task in sequence.
 
@@ -117,12 +131,77 @@ class Sync:
                     logger.warning("Sync interrupted during stage '%s'.", stage_name)
                     raise
                 except Exception:
-                    logger.exception("Unhandled exception during sync stage '%s'", stage_name)
+                    logger.exception(
+                        "Unhandled exception during sync stage '%s'",
+                        stage_name,
+                    )
                     raise  # TODO this should be configurable
                 logger.info("Finishing sync stage '%s'", stage_name)
         logger.info("Finishing sync with update tag '%d'", config.update_tag)
         return STATUS_SUCCESS
 
+    @classmethod
+    def list_intel_modules(cls) -> OrderedDict:
+        """
+        List all available intel modules.
+
+        This method will load all modules in the cartography.intel package and return a dictionary of their names and
+        their callable functions. The keys of the dictionary are the module names, and the values are the callable
+        functions (with `start_{module}_ingestion` pattern) that should be executed during the sync process.
+        analysis and create_indexes are loaded separately to ensure they are always available and run first
+        (for create-index) and last (for analysis).
+
+        :rtype: OrderedDict
+        :return: A dictionary of available intel modules.
+        """
+        available_modules = OrderedDict({})
+        available_modules["create-indexes"] = cartography.intel.create_indexes.run
+        callable_regex = re.compile(r"^start_(.+)_ingestion$")
+        # Load built-in modules
+        for intel_module_info in iter_modules(cartography.intel.__path__):
+            if intel_module_info.name in ("analysis", "create_indexes"):
+                continue
+            try:
+                logger.debug("Loading module: %s", intel_module_info.name)
+                intel_module = __import__(
+                    f"cartography.intel.{intel_module_info.name}",
+                    fromlist=[""],
+                )
+            except ImportError as e:
+                logger.error(
+                    "Failed to import module '%s'. Error: %s",
+                    intel_module_info.name,
+                    e,
+                )
+                continue
+            logger.debug("Loading module: %s", intel_module_info.name)
+            intel_module = __import__(
+                f"cartography.intel.{intel_module_info.name}",
+                fromlist=[""],
+            )
+            for k, v in intel_module.__dict__.items():
+                if not callable(v):
+                    continue
+                match_callable_name = callable_regex.match(k)
+                if not match_callable_name:
+                    continue
+                callable_module_name = (
+                    match_callable_name.group(1) if match_callable_name else None
+                )
+                if callable_module_name != intel_module_info.name:
+                    logger.debug(
+                        "Module name '%s' does not match intel module name '%s'.",
+                        callable_module_name,
+                        intel_module_info.name,
+                    )
+                available_modules[intel_module_info.name] = v
+        available_modules["analysis"] = cartography.intel.analysis.run
+        return available_modules
+
+
+# Used to avoid repeatedly calling Sync.list_intel_modules()
+TOP_LEVEL_MODULES = Sync.list_intel_modules()
+
 
 def run_with_config(sync: Sync, config: Union[Config, argparse.Namespace]) -> int:
     """
@@ -201,9 +280,12 @@ def build_default_sync() -> Sync:
     :return: The default cartography sync object.
     """
     sync = Sync()
-    sync.add_stages([
-        (stage_name, stage_func) for stage_name, stage_func in TOP_LEVEL_MODULES.items()
-    ])
+    sync.add_stages(
+        [
+            (stage_name, stage_func)
+            for stage_name, stage_func in TOP_LEVEL_MODULES.items()
+        ],
+    )
     return sync
 
 
@@ -214,18 +296,18 @@ def parse_and_validate_selected_modules(selected_modules: str) -> List[str]:
     :return: A validated list of module names that we will run
     """
     validated_modules: List[str] = []
-    for module in selected_modules.split(','):
+    for module in selected_modules.split(","):
         module = module.strip()
 
         if module in TOP_LEVEL_MODULES.keys():
             validated_modules.append(module)
         else:
-            valid_modules = ', '.join(TOP_LEVEL_MODULES.keys())
+            valid_modules = ", ".join(TOP_LEVEL_MODULES.keys())
             raise ValueError(
                 f'Error parsing `selected_modules`. You specified "{selected_modules}". '
-                f'Please check that your string is formatted properly. '
+                f"Please check that your string is formatted properly. "
                 f'Example valid input looks like "aws,gcp,analysis" or "azure, oci, crowdstrike". '
-                f'Our full list of valid values is: {valid_modules}.',
+                f"Our full list of valid values is: {valid_modules}.",
             )
     return validated_modules