cartography 0.106.0rc1__py3-none-any.whl → 0.107.0__py3-none-any.whl

cartography/intel/airbyte/util.py

@@ -0,0 +1,122 @@
+import logging
+import time
+from typing import Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+# Connect and read timeouts of 60 seconds each; see https://requests.readthedocs.io/en/master/user/advanced/#timeouts
+_TIMEOUT = (60, 60)
+
+
+class AirbyteClient:
+    """A client for interacting with the Airbyte API.
+    This client handles authentication and provides methods to make GET requests to the Airbyte API.
+    It automatically handles pagination for GET requests that return multiple pages of data.
+    """
+
+    def __init__(self, base_url: str, client_id: str, client_secret: str) -> None:
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self.base_url = base_url
+        self._access_token_expiry: int | None = None
+        self._session = requests.Session()
+
+    def get(self, uri: str, params: dict | None = None, offset: int = 0) -> list[dict]:
+        """Make a GET request to the Airbyte API.
+        This method handles authentication and pagination.
+        Args:
+            uri (str): The URI to make the GET request to.
+            params (dict | None): Optional parameters to include in the request.
+            offset (int): The offset for pagination, defaults to 0.
+        Returns:
+            list[dict]: A list of dictionaries containing the data from the response.
+        """
+        self.authenticate()
+        if params is None:
+            params_with_pagination = {}
+        else:
+            params_with_pagination = params.copy()
+        params_with_pagination["offset"] = offset
+        response = self._session.get(
+            f"{self.base_url}{uri}", params=params_with_pagination, timeout=_TIMEOUT
+        )
+        response.raise_for_status()
+        data = response.json().get("data")
+        if response.json().get("next", "") != "":
+            data.extend(
+                self.get(
+                    uri,
+                    params=params,
+                    offset=offset + len(data),
+                )
+            )
+        return data
+
+    def authenticate(self) -> None:
+        """Authenticate with the Airbyte API using client credentials.
+        This method checks if the access token is still valid and renews it if necessary.
+        If the access token is expired or not set, it will make a request to obtain a new access token.
+        """
+        if self._access_token_expiry and self._access_token_expiry >= time.time():
+            return
+        self._session.headers.pop("Authorization", None)
+        payload = {
+            "grant-type": "client_credentials",
+            "client_id": self._client_id,
+            "client_secret": self._client_secret,
+        }
+        response = self._session.post(
+            f"{self.base_url}/applications/token", json=payload, timeout=_TIMEOUT
+        )
+        response.raise_for_status()
+        data = response.json()
+        self._session.headers["Authorization"] = (
+            f"Bearer {data.get('access_token', '')}"
+        )
+        token_expiry = data.get("expires_in", 0)
+        self._access_token_expiry = time.time() + token_expiry
+        logger.debug("Access token renewed, expires in %s seconds.", token_expiry)
+
+
+def normalize_airbyte_config(config: dict[str, Any]) -> dict[str, Any]:
+    """Normalize the Airbyte configuration dictionary.
+    This function takes a configuration dictionary and normalizes it by mapping keys to a standard set of keys.
+    This is useful for ensuring consistency across different configurations, and will allow to connect to existing nodes.
+    Args:
+        config (dict[str, Any]): The configuration dictionary to normalize.
+    Returns:
+        dict[str, Any]: A normalized configuration dictionary with standardized keys.
+    """
+    normalized_config = {}
+    for key in config:
+        if key in ("host", "port", "name", "region", "endpoint", "account", ""):
+            normalized_config[key] = config[key]
+        elif key in ("aws_region_name", "region_name", "s3_bucket_region"):
+            normalized_config["region"] = config[key]
+        elif key in ("queue_url", "url", "s3_endpoint"):
+            normalized_config["endpoint"] = config[key]
+        elif key in ("azure_blob_storage_account_name", "storage_account_name"):
+            normalized_config["account"] = config[key]
+        elif key in (
+            "azure_blob_storage_container_name",
+            "bucket",
+            "database",
+            "s3_bucket_name",
+        ):
+            normalized_config["name"] = config[key]
+    return normalized_config
+
+
+def list_to_string(lst: list[str]) -> str | None:
+    """Convert a list of strings to a comma-separated string."""
+    if len(lst) == 0:
+        return None
+    # Sublist
+    formated_list: list[str] = []
+    for item in lst:
+        if isinstance(item, list):
+            formated_list.append("|".join(item))
+        else:
+            formated_list.append(str(item))
+    return ",".join(formated_list)

cartography/intel/airbyte/workspaces.py

@@ -0,0 +1,63 @@
+import logging
+from typing import Any
+from typing import Dict
+from typing import List
+
+import neo4j
+
+from cartography.client.core.tx import load
+from cartography.graph.job import GraphJob
+from cartography.intel.airbyte.util import AirbyteClient
+from cartography.models.airbyte.workspace import AirbyteWorkspaceSchema
+from cartography.util import timeit
+
+logger = logging.getLogger(__name__)
+
+
+@timeit
+def sync(
+    neo4j_session: neo4j.Session,
+    api_session: AirbyteClient,
+    org_id: str,
+    common_job_parameters: Dict[str, Any],
+) -> List[Dict[str, Any]]:
+    workspaces = get(api_session, org_id)
+    load_workspaces(
+        neo4j_session, workspaces, org_id, common_job_parameters["UPDATE_TAG"]
+    )
+    cleanup(neo4j_session, common_job_parameters)
+    return workspaces
+
+
+@timeit
+def get(
+    api_session: AirbyteClient,
+    org_id: str,
+) -> List[Dict[str, Any]]:
+    return api_session.get("/workspaces", params={"organizationId": org_id})
+
+
+@timeit
+def load_workspaces(
+    neo4j_session: neo4j.Session,
+    data: List[Dict[str, Any]],
+    org_id: str,
+    update_tag: int,
+) -> None:
+    logger.info("Loading %d Airbyte Workspaces into Neo4j.", len(data))
+    load(
+        neo4j_session,
+        AirbyteWorkspaceSchema(),
+        data,
+        lastupdated=update_tag,
+        ORG_ID=org_id,
+    )
+
+
+@timeit
+def cleanup(
+    neo4j_session: neo4j.Session, common_job_parameters: Dict[str, Any]
+) -> None:
+    GraphJob.from_node_schema(AirbyteWorkspaceSchema(), common_job_parameters).run(
+        neo4j_session
+    )

cartography/intel/aws/__init__.py

@@ -310,6 +310,7 @@ def start_aws_ingestion(neo4j_session: neo4j.Session, config: Config) -> None:
     common_job_parameters = {
         "UPDATE_TAG": config.update_tag,
         "permission_relationships_file": config.permission_relationships_file,
+        "aws_cloudtrail_management_events_lookback_hours": config.aws_cloudtrail_management_events_lookback_hours,
     }
     try:
         boto3_session = boto3.Session()

cartography/intel/aws/cloudtrail_management_events.py

@@ -0,0 +1,364 @@
+import json
+import logging
+from datetime import datetime
+from datetime import timedelta
+from typing import Any
+from typing import Dict
+from typing import List
+
+import boto3
+import neo4j
+
+from cartography.client.core.tx import load_matchlinks
+from cartography.graph.job import GraphJob
+from cartography.intel.aws.ec2.util import get_botocore_config
+from cartography.models.aws.cloudtrail.management_events import AssumedRoleMatchLink
+from cartography.util import aws_handle_regions
+from cartography.util import timeit
+
+logger = logging.getLogger(__name__)
+
+
+@timeit
+@aws_handle_regions
+def get_assume_role_events(
+    boto3_session: boto3.Session, region: str, lookback_hours: int
+) -> List[Dict[str, Any]]:
+    """
+    Fetch CloudTrail AssumeRole events from the specified time period.
+
+    Focuses specifically on standard AssumeRole events, excluding SAML and WebIdentity variants.
+
+    :type boto3_session: boto3.Session
+    :param boto3_session: The boto3 session to use for API calls
+    :type region: str
+    :param region: The AWS region to fetch events from
+    :type lookback_hours: int
+    :param lookback_hours: Number of hours back to retrieve events from
+    :rtype: List[Dict[str, Any]]
+    :return: List of CloudTrail AssumeRole events
+    """
+    client = boto3_session.client(
+        "cloudtrail", region_name=region, config=get_botocore_config()
+    )
+
+    # Calculate time range
+    end_time = datetime.utcnow()
+    start_time = end_time - timedelta(hours=lookback_hours)
+
+    logger.info(
+        f"Fetching CloudTrail AssumeRole events for region '{region}' "
+        f"from {start_time} to {end_time} ({lookback_hours} hours)"
+    )
+
+    paginator = client.get_paginator("lookup_events")
+
+    page_iterator = paginator.paginate(
+        LookupAttributes=[
+            {"AttributeKey": "EventName", "AttributeValue": "AssumeRole"}
+        ],
+        StartTime=start_time,
+        EndTime=end_time,
+        PaginationConfig={
+            "MaxItems": 10000,  # Reasonable limit to prevent excessive API calls
+            "PageSize": 50,  # CloudTrail API limit per page
+        },
+    )
+
+    all_events = []
+    for page in page_iterator:
+        all_events.extend(page.get("Events", []))
+
+    logger.info(f"Retrieved {len(all_events)} AssumeRole events from region '{region}'")
+
+    return all_events
+
+
+@timeit
+def transform_assume_role_events_to_role_assumptions(
+    events: List[Dict[str, Any]],
+    region: str,
+    current_aws_account_id: str,
+) -> List[Dict[str, Any]]:
+    """
+    Transform raw CloudTrail AssumeRole events into aggregated role assumption relationships.
+
+    Focuses specifically on standard AssumeRole events, providing optimized processing
+    for the most common role assumption scenario.
+
+    This function performs the complete transformation pipeline:
+    1. Extract role assumption events from CloudTrail AssumeRole data
+    2. Aggregate events by (source_principal, destination_principal) pairs
+    3. Return aggregated relationships ready for loading
+
+    :type events: List[Dict[str, Any]]
+    :param events: List of raw CloudTrail AssumeRole events from lookup_events API
+    :type region: str
+    :param region: The AWS region where events were retrieved from
+    :type current_aws_account_id: str
+    :param current_aws_account_id: The AWS account ID being synced
+    :rtype: List[Dict[str, Any]]
+    :return: List of aggregated role assumption relationships ready for loading
+    """
+    aggregated: Dict[tuple, Dict[str, Any]] = {}
+    logger.info(
+        f"Transforming {len(events)} CloudTrail AssumeRole events to role assumptions for region '{region}'"
+    )
+
+    for event in events:
+
+        cloudtrail_event = json.loads(event["CloudTrailEvent"])
+
+        if cloudtrail_event.get("userIdentity", {}).get("arn"):
+            source_principal = cloudtrail_event["userIdentity"]["arn"]
+            destination_principal = cloudtrail_event["requestParameters"]["roleArn"]
+        else:
+            logger.debug(
+                f"Skipping CloudTrail AssumeRole event due to missing UserIdentity.arn. Event: {event.get('EventId', 'unknown')}"
+            )
+            continue
+
+        destination_principal = cloudtrail_event["requestParameters"]["roleArn"]
+
+        normalized_source_principal = _convert_assumed_role_arn_to_role_arn(
+            source_principal
+        )
+        normalized_destination_principal = _convert_assumed_role_arn_to_role_arn(
+            destination_principal
+        )
+        event_time = event.get("EventTime")
+
+        key = (normalized_source_principal, normalized_destination_principal)
+
+        if key in aggregated:
+            aggregated[key]["times_used"] += 1
+            aggregated[key]["assume_role_count"] += 1  # All events are AssumeRole
+            # Handle None values safely for time comparisons
+            if event_time:
+                existing_first = aggregated[key]["first_seen_in_time_window"]
+                existing_last = aggregated[key]["last_used"]
+
+                if existing_first is None or event_time < existing_first:
+                    aggregated[key]["first_seen_in_time_window"] = event_time
+                if existing_last is None or event_time > existing_last:
+                    aggregated[key]["last_used"] = event_time
+        else:
+            aggregated[key] = {
+                "source_principal_arn": normalized_source_principal,
+                "destination_principal_arn": normalized_destination_principal,
+                "times_used": 1,
+                "first_seen_in_time_window": event_time,
+                "last_used": event_time,
+                "event_types": ["AssumeRole"],
+                "assume_role_count": 1,
+                "saml_count": 0,
+                "web_identity_count": 0,
+            }
+
+    return list(aggregated.values())
+
+
+@timeit
+def load_role_assumptions(
+    neo4j_session: neo4j.Session,
+    aggregated_role_assumptions: List[Dict[str, Any]],
+    current_aws_account_id: str,
+    aws_update_tag: int,
+) -> None:
+    """
+    Load aggregated role assumption relationships into Neo4j using MatchLink pattern.
+
+    Creates direct ASSUMED_ROLE relationships with aggregated properties:
+    (AWSUser|AWSRole|AWSPrincipal)-[:ASSUMED_ROLE {lastused, times_used, first_seen_in_time_window, last_seen}]->(AWSRole)
+
+    Assumes that both source principals and destination roles already exist in the graph.
+
+    :type neo4j_session: neo4j.Session
+    :param neo4j_session: The Neo4j session to use for database operations
+    :type aggregated_role_assumptions: List[Dict[str, Any]]
+    :param aggregated_role_assumptions: List of aggregated role assumption relationships from transform function
+    :type current_aws_account_id: str
+    :param current_aws_account_id: The AWS account ID being synced
+    :type aws_update_tag: int
+    :param aws_update_tag: Timestamp tag for tracking data freshness
+    :rtype: None
+    """
+    # Use MatchLink to create relationships between existing nodes
+    matchlink_schema = AssumedRoleMatchLink()
+
+    load_matchlinks(
+        neo4j_session,
+        matchlink_schema,
+        aggregated_role_assumptions,
+        lastupdated=aws_update_tag,
+        _sub_resource_label="AWSAccount",
+        _sub_resource_id=current_aws_account_id,
+    )
+
+    logger.info(
+        f"Successfully loaded {len(aggregated_role_assumptions)} role assumption relationships"
+    )
+
+
+def _convert_assumed_role_arn_to_role_arn(assumed_role_arn: str) -> str:
+    """
+    Convert an assumed role ARN to the original role ARN.
+
+    Example:
+    Input:  "arn:aws:sts::123456789012:assumed-role/MyRole/session-name"
+    Output: "arn:aws:iam::123456789012:role/MyRole"
+    """
+
+    # Split the ARN into parts
+    arn_parts = assumed_role_arn.split(":")
+    if len(arn_parts) >= 6 and arn_parts[2] == "sts" and "assumed-role" in arn_parts[5]:
+        # Extract account ID and role name
+        account_id = arn_parts[4]
+        resource_part = arn_parts[5]  # "assumed-role/MyRole/session-name"
+        role_name = resource_part.split("/")[1]  # Extract "MyRole"
+
+        # Construct the IAM role ARN
+        return f"arn:aws:iam::{account_id}:role/{role_name}"
+
+    # Return original ARN if conversion fails
+    return assumed_role_arn
+
+
+@timeit
+def cleanup(
+    neo4j_session: neo4j.Session, current_aws_account_id: str, update_tag: int
+) -> None:
+    """
+    Run CloudTrail management events cleanup job to remove stale ASSUMED_ROLE relationships.
+
+    :type neo4j_session: neo4j.Session
+    :param neo4j_session: The Neo4j session to use for database operations
+    :type current_aws_account_id: str
+    :param current_aws_account_id: The AWS account ID being synced
+    :type update_tag: int
+    :param update_tag: Timestamp tag for tracking data freshness
+    :rtype: None
+    """
+    logger.info("Running CloudTrail management events cleanup job.")
+
+    matchlink_schema = AssumedRoleMatchLink()
+    cleanup_job = GraphJob.from_matchlink(
+        matchlink_schema,
+        "AWSAccount",
+        current_aws_account_id,
+        update_tag,
+    )
+    cleanup_job.run(neo4j_session)
+
+
+@timeit
+def sync_assume_role_events(
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict[str, Any],
+) -> None:
+    """
+    Sync CloudTrail management events to create ASSUMED_ROLE relationships.
+
+    This function orchestrates the complete process:
+    1. Fetch CloudTrail management events region by region
+    2. Transform events into role assumption records per region
+    3. Load role assumption relationships into Neo4j for each region
+    4. Run cleanup after processing all regions
+
+    The resulting graph contains direct relationships like:
+    (AWSUser|AWSRole|AWSPrincipal)-[:ASSUMED_ROLE {times_used, first_seen_in_time_window, last_used, lastused}]->(AWSRole)
+
+    :type neo4j_session: neo4j.Session
+    :param neo4j_session: The Neo4j session
+    :type boto3_session: boto3.Session
+    :param boto3_session: The boto3 session to use for API calls
+    :type regions: List[str]
+    :param regions: List of AWS regions to sync
+    :type current_aws_account_id: str
+    :param current_aws_account_id: The AWS account ID being synced
+    :type aws_update_tag: int
+    :param aws_update_tag: Timestamp tag for tracking data freshness
+    :rtype: None
+    """
+    # Extract lookback hours from common_job_parameters (set by CLI parameter)
+    lookback_hours = common_job_parameters.get(
+        "aws_cloudtrail_management_events_lookback_hours"
+    )
+
+    if not lookback_hours:
+        logger.info(
+            "CloudTrail management events sync skipped - no lookback period specified"
+        )
+        return
+
+    logger.info(
+        f"Syncing {len(regions)} regions with {lookback_hours} hour lookback period"
+    )
+
+    total_role_assumptions = 0
+
+    # Process events region by region
+    for region in regions:
+        logger.info(f"Processing CloudTrail events for region {region}")
+
+        # Process AssumeRole events specifically
+        logger.info(f"Fetching AssumeRole events specifically for region {region}")
+        assume_role_events = get_assume_role_events(
+            boto3_session=boto3_session,
+            region=region,
+            lookback_hours=lookback_hours,
+        )
+
+        # Transform AssumeRole events to role assumptions
+        assume_role_assumptions = transform_assume_role_events_to_role_assumptions(
+            events=assume_role_events,
+            region=region,
+            current_aws_account_id=current_aws_account_id,
+        )
+
+        # Load AssumeRole assumptions for this region
+        load_role_assumptions(
+            neo4j_session=neo4j_session,
+            aggregated_role_assumptions=assume_role_assumptions,
+            current_aws_account_id=current_aws_account_id,
+            aws_update_tag=update_tag,
+        )
+        total_role_assumptions += len(assume_role_assumptions)
+        logger.info(
+            f"Loaded {len(assume_role_assumptions)} AssumeRole assumptions for region {region}"
+        )
+
+    # Run cleanup for stale relationships after processing all regions
+    cleanup(neo4j_session, current_aws_account_id, update_tag)
+
+    logger.info(
+        f"CloudTrail management events sync completed successfully. "
+        f"Processed {total_role_assumptions} total role assumption events across {len(regions)} regions."
+    )
+
+
+# Main sync function for when we decide to add more event types
+@timeit
+def sync(
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict[str, Any],
+) -> None:
+    """
+    Main sync function for CloudTrail management events.
+    """
+    sync_assume_role_events(
+        neo4j_session=neo4j_session,
+        boto3_session=boto3_session,
+        regions=regions,
+        current_aws_account_id=current_aws_account_id,
+        update_tag=update_tag,
+        common_job_parameters=common_job_parameters,
+    )

cartography/intel/aws/cloudwatch.py

@@ -9,6 +9,9 @@ import neo4j
 from cartography.client.core.tx import load
 from cartography.graph.job import GraphJob
 from cartography.intel.aws.ec2.util import get_botocore_config
+from cartography.models.aws.cloudwatch.log_metric_filter import (
+    CloudWatchLogMetricFilterSchema,
+)
 from cartography.models.aws.cloudwatch.loggroup import CloudWatchLogGroupSchema
 from cartography.util import aws_handle_regions
 from cartography.util import timeit
@@ -31,6 +34,47 @@ def get_cloudwatch_log_groups(
     return logGroups
 
 
+@timeit
+@aws_handle_regions
+def get_cloudwatch_log_metric_filters(
+    boto3_session: boto3.Session, region: str
+) -> List[Dict[str, Any]]:
+    logs_client = boto3_session.client(
+        "logs", region_name=region, config=get_botocore_config()
+    )
+    paginator = logs_client.get_paginator("describe_metric_filters")
+    metric_filters = []
+
+    for page in paginator.paginate():
+        metric_filters.extend(page.get("metricFilters", []))
+
+    return metric_filters
+
+
+def transform_metric_filters(
+    metric_filters: List[Dict[str, Any]], region: str
+) -> List[Dict[str, Any]]:
+    """
+    Transform CloudWatch log metric filter data for ingestion into Neo4j.
+    Ensures that the 'id' field is a unique combination of logGroupName and filterName.
+    """
+    transformed_filters = []
+    for filter in metric_filters:
+        transformed_filter = {
+            "id": f"{filter['logGroupName']}:{filter['filterName']}",
+            "arn": f"{filter['logGroupName']}:{filter['filterName']}",
+            "filterName": filter["filterName"],
+            "filterPattern": filter.get("filterPattern"),
+            "logGroupName": filter["logGroupName"],
+            "metricName": filter["metricTransformations"][0]["metricName"],
+            "metricNamespace": filter["metricTransformations"][0]["metricNamespace"],
+            "metricValue": filter["metricTransformations"][0]["metricValue"],
+            "Region": region,
+        }
+        transformed_filters.append(transformed_filter)
+    return transformed_filters
+
+
 @timeit
 def load_cloudwatch_log_groups(
     neo4j_session: neo4j.Session,
@@ -52,6 +96,27 @@ def load_cloudwatch_log_groups(
     )
 
 
+@timeit
+def load_cloudwatch_log_metric_filters(
+    neo4j_session: neo4j.Session,
+    data: List[Dict[str, Any]],
+    region: str,
+    current_aws_account_id: str,
+    aws_update_tag: int,
+) -> None:
+    logger.info(
+        f"Loading CloudWatch {len(data)} log metric filters for region '{region}' into graph.",
+    )
+    load(
+        neo4j_session,
+        CloudWatchLogMetricFilterSchema(),
+        data,
+        lastupdated=aws_update_tag,
+        Region=region,
+        AWS_ID=current_aws_account_id,
+    )
+
+
 @timeit
 def cleanup(
     neo4j_session: neo4j.Session,
@@ -62,6 +127,9 @@ def cleanup(
         CloudWatchLogGroupSchema(), common_job_parameters
     )
     cleanup_job.run(neo4j_session)
+    GraphJob.from_node_schema(
+        CloudWatchLogMetricFilterSchema(), common_job_parameters
+    ).run(neo4j_session)
 
 
 @timeit
@@ -90,4 +158,13 @@ def sync(
             update_tag,
         )
 
+        metric_filters = get_cloudwatch_log_metric_filters(boto3_session, region)
+        transformed_filters = transform_metric_filters(metric_filters, region)
+        load_cloudwatch_log_metric_filters(
+            neo4j_session,
+            transformed_filters,
+            region,
+            current_aws_account_id,
+            update_tag,
+        )
     cleanup(neo4j_session, common_job_parameters)