@infrascan/aws-cloudfront-scanner/dist/index.mjs

Infrascan scanner definition for AWS Cloudfront

// src/generated/client.ts
import { CloudFrontClient } from "@aws-sdk/client-cloudfront";
import debug from "debug";
var clientDebug = debug("cloudfront:client");
function getClient(credentials, context, retryStrategy) {
  clientDebug("Creating instance with context", context);
  return new CloudFrontClient({
    credentials,
    region: context.region,
    retryStrategy
  });
}

// src/generated/getters.ts
import {
  CloudFrontServiceException,
  ListDistributionsCommand
} from "@aws-sdk/client-cloudfront";
import debug2 from "debug";
async function ListDistributions(client, stateConnector, context) {
  const getterDebug = debug2("cloudfront:ListDistributions");
  const state = [];
  getterDebug("ListDistributions");
  const preparedParams = {};
  try {
    const cmd = new ListDistributionsCommand(preparedParams);
    const result = await client.send(cmd);
    state.push({
      _metadata: {
        account: context.account,
        region: context.region,
        timestamp: Date.now()
      },
      _parameters: preparedParams,
      _result: result
    });
  } catch (err) {
    if (err instanceof CloudFrontServiceException) {
      if (err?.$retryable) {
        console.log("Encountered retryable error", err);
      } else {
        console.log("Encountered unretryable error", err);
      }
    } else {
      console.log("Encountered unexpected error", err);
    }
  }
  getterDebug("Recording state");
  await stateConnector.onServiceScanCompleteCallback(
    context.account,
    context.region,
    "CloudFront",
    "ListDistributions",
    state
  );
}

// src/graph.ts
import { evaluateSelector } from "@infrascan/core";
var CloudfrontDistributionEntity = {
  version: "0.1.0",
  debugLabel: "cloudfront",
  provider: "aws",
  command: "ListDistributions",
  category: "cloudfront",
  subcategory: "distribution",
  nodeType: "cloudfront-distribution",
  selector: "CloudFront|ListDistributions|[]",
  getState(state, context) {
    return evaluateSelector(
      context.account,
      context.region,
      CloudfrontDistributionEntity.selector,
      state
    );
  },
  translate(val) {
    return (val._result.DistributionList?.Items ?? []).map(
      (distribution) => Object.assign(distribution, {
        $metadata: val._metadata,
        $parameters: val._parameters
      })
    );
  },
  components: {
    $metadata(val) {
      return {
        version: CloudfrontDistributionEntity.version,
        timestamp: val.$metadata.timestamp
      };
    },
    $graph(val) {
      return {
        id: val.ARN,
        label: val.DomainName,
        nodeType: CloudfrontDistributionEntity.nodeType,
        parent: val.$metadata.account
      };
    },
    $source(val) {
      return {
        command: CloudfrontDistributionEntity.command,
        parameters: val.$parameters
      };
    },
    dns(val) {
      const domains = [val.DomainName];
      if (val.Aliases?.Items == null) {
        return { domains };
      }
      return {
        domains: domains.concat(val.Aliases.Items)
      };
    },
    tenant(val) {
      return {
        tenantId: val.$metadata.account,
        provider: CloudfrontDistributionEntity.provider,
        partition: val.$metadata.partition
      };
    },
    resource(val) {
      return {
        id: val.ARN,
        name: val.DomainName,
        category: CloudfrontDistributionEntity.category,
        subcategory: CloudfrontDistributionEntity.subcategory,
        description: val.Comment
      };
    },
    distribution(val) {
      return {
        originGroups: val.OriginGroups?.Items,
        cacheBehaviours: val.CacheBehaviors?.Items,
        defaultCacheBehaviour: val.DefaultCacheBehavior
      };
    }
  }
};

// src/edges.ts
import { formatEdge, formatS3NodeId } from "@infrascan/core";
import { minimatch } from "minimatch";
async function generateEdgesForS3BackedDistributions(connector) {
  const cloudfrontS3Edges = [];
  const cloudfrontDistributionsState = await connector.getGlobalStateForServiceFunction(
    "CloudFront",
    "ListDistributions"
  );
  const cloudfrontDistributions = cloudfrontDistributionsState.flatMap(({ _result }) => _result.DistributionList?.Items).filter((distribution) => distribution != null);
  const S3State = await connector.getGlobalStateForServiceFunction("S3", "ListBuckets");
  for (const distribution of cloudfrontDistributions) {
    if (!distribution?.ARN) {
      continue;
    }
    const distributionItems = distribution?.Origins?.Items;
    distributionItems?.forEach((distributionOrigin) => {
      const hasS3Domain = distributionOrigin?.DomainName?.endsWith(".s3.amazonaws.com") || minimatch(distributionOrigin?.DomainName ?? "", "*.s3.*.amazonaws.com");
      if (!hasS3Domain) {
        console.log(
          distributionOrigin?.DomainName,
          minimatch(
            distributionOrigin?.DomainName ?? "",
            "*.s3.*.amazonaws.com"
          )
        );
        return;
      }
      const bucketName = distributionOrigin?.DomainName?.split(
        "."
      ).shift();
      const relevantS3Bucket = S3State.find(
        ({ _result }) => _result.Buckets?.find((bucket) => bucket.Name)
      );
      if (relevantS3Bucket) {
        const distroTarget = {
          name: `${bucketName} Distribution`,
          target: formatS3NodeId(bucketName)
        };
        cloudfrontS3Edges.push(
          formatEdge(distribution?.ARN, distroTarget)
        );
      }
    });
  }
  return cloudfrontS3Edges;
}
async function getEdges(connector) {
  return generateEdgesForS3BackedDistributions(connector);
}

// src/index.ts
var CloudFrontScanner = {
  provider: "aws",
  service: "cloudfront",
  key: "CloudFront",
  getClient,
  callPerRegion: true,
  getters: [ListDistributions],
  getEdges,
  entities: [CloudfrontDistributionEntity]
};
var index_default = CloudFrontScanner;
export {
  index_default as default
};