Falcon Container

The Falcon Container service collection provides operations for managing container security. Download and manage export jobs, check prevention policies, retrieve image assessment reports, manage registry credentials, and handle container image scan inventories.

Language	Last Update
Python	v1.6.1
PowerShell	v2.2.9
Go	v0.20.0
TypeScript	v0.6.0
Rust	v0.7.0
Ruby	v1.2.0

Operation	Description
DownloadExportFile `download_export_file`	Download an export file.
ReadExportJobs `read_export_jobs`	Read export jobs entities.
LaunchExportJob `launch_export_job`	Launch an export job of a Container Security resource. Maximum of 1 job in progress per resource.
QueryExportJobs `query_export_jobs`	Query export jobs entities.
PolicyChecks `check_prevention_policies`	Perform policy checks against container configurations.
GetReportByReference `get_report_by_reference`	Retrieve a report by its reference.
GetReportByScanID `get_report_by_id`	Retrieve a report by scan ID.
GetCombinedImages `get_combined_images`	Retrieve registry entities identified by the customer ID.
GetCredentials `get_credentials`	Gets the registry credentials.
GetImageAssessmentReport `get_assessment`	Retrieve an assessment report for an image by specifying repository and tag.
HeadImageScanInventory `get_scan_headers`	Get headers for POST request for image scan inventory.
DeleteImageDetails `delete_image_details`	Delete image details from the CrowdStrike registry.
ImageMatchesPolicy `image_matches_policy`	Check if an image matches a policy by specifying repository and tag.
PostImageScanInventory `scan_inventory`	Post image scan inventory.
ReadImageVulnerabilities `read_image_vulnerabilities`	Retrieve an assessment report for an image by specifying repository and tag.
ReadRegistryEntities `read_registry_entities`	Retrieve registry entities associated with the client ID.
ReadRegistryEntitiesByUUID `read_registry_entities_by_uuid`	Retrieve registry entities associated with a specific UUID.
DeleteRegistryEntities `delete_registry_entities`	Delete registry entities by UUID.
CreateRegistryEntities `create_registry_entities`	Create registry entities using the provided detail.
UpdateRegistryEntities `update_registry_entities`	Update the registry entity, as identified by the entity UUID, using the provided details.

DownloadExportFile

Download an export file.

GET /container-security/entities/exports/files/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 download_export_file

Parameters

Name	Type	Data type	Description
id	query	string or list of strings	Export Job ID.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

with open("output_file", "wb") as save_file:
    response = falcon.download_export_file(id="string", stream=boolean)
    save_file.write(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

with open("output_file", "wb") as save_file:
    response = falcon.DownloadExportFile(id="string", stream=boolean)
    save_file.write(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

with open("output_file", "wb") as save_file:
    response = falcon.command("DownloadExportFile",
                              id="string")
    save_file.write(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainerImage.DownloadExportFile(
    &falcon_container_image.DownloadExportFileParams{
      ID: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.downloadExportFile("string");  // id

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::download_export_file;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = download_export_file(
        &falcon.cfg,  // configuration
        "string",  // id
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.download_export_file('string')

puts response

ReadExportJobs

Read export jobs entities.

GET /container-security/entities/exports/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 read_export_jobs

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	Export Job IDs to read. Allowed up to 100 IDs per request.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.read_export_jobs(ids=id_list)
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.ReadExportJobs(ids=id_list)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("ReadExportJobs",
                          ids=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainerImage.ReadExportJobs(
    &falcon_container_image.ReadExportJobsParams{
      Ids: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.readExportJobs(["ID1", "ID2", "ID3"]);  // ids

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::read_export_jobs;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = read_export_jobs(
        &falcon.cfg,  // configuration
        vec!["string".to_string()],  // ids
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.read_export_jobs(['ID1', 'ID2', 'ID3'])

puts response

LaunchExportJob

Launch an export job of a Container Security resource. Maximum of 1 job in progress per resource.

POST /container-security/entities/exports/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 launch_export_job

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format, not required if using other keywords.
format	body	string	Export job format.
fql	body	string	Falcon Query Language string defining the export job.
resource	body	string	Resource to run the export job against. Supported resources: `assets.clusters`, `assets.containers`, `assets.deployments`, `assets.images`, `assets.namespaces`, `assets.nodes`, `assets.pods`, `images.images-assessment-detections-expanded`, `images.images-assessment-expanded`, `images.images-assessment-vulnerabilities-expanded`, `images.images-assessment`, `images.images-detections`, `images.packages`, `images.vulnerabilities`, `investigate.container-alerts`, `investigate.drift-indicators`, `investigate.kubernetes-ioms`, `investigate.runtime-detections`, `investigate.unidentified-containers`, and `policies.exclusions`.
sort	body	string	Falcon Query Language sort string defining the sort used for the export.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.launch_export_job(expand_vulnerabilities=boolean,
                                    format="string",
                                    fql="string",
                                    resource="string",
                                    sort="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.LaunchExportJob(expand_vulnerabilities=boolean,
                                  format="string",
                                  fql="string",
                                  resource="string",
                                  sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "expand_vulnerabilities": boolean,
    "format": "string",
    "fql": "string",
    "resource": "string",
    "sort": "string"
}

response = falcon.command("LaunchExportJob", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  expand_vulnerabilities := boolean
  format := "string"
  fql := "string"
  resource := "string"
  sort := "string"

  response, err := client.FalconContainerImage.LaunchExportJob(
    &falcon_container_image.LaunchExportJobParams{
      Body: &models.ExportsLaunchExportRequest{
        ExpandVulnerabilities: &expand_vulnerabilities,
        Format: &format,
        Fql: &fql,
        Resource: &resource,
        Sort: &sort,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.launchExportJob(
  {
    expandVulnerabilities: boolean,
    format: "string",
    fql: "string",
    resource: "string",
    sort: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::launch_export_job;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::ExportsLaunchExportRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = ExportsLaunchExportRequest {
        format: Some("string".to_string()),
        resource: Some("string".to_string()),
        sort: Some("string".to_string()),
        ..Default::default()
    };

    let response = launch_export_job(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

body = {
  expand_vulnerabilities: boolean,
  format: 'string',
  fql: 'string',
  resource: 'string',
  sort: 'string'
}

response = api.launch_export_job(body)

puts response

QueryExportJobs

Query export jobs entities.

GET /container-security/queries/exports/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 query_export_jobs

Parameters

Name	Type	Data type	Description
filter	query	string	Filter exports using a query in Falcon Query Language (FQL). Only the last 100 jobs are returned. Supported filter fields: `resource` and `status`.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.query_export_jobs(filter="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.QueryExportJobs(filter="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("QueryExportJobs",
                          filter="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"

  response, err := client.FalconContainerImage.QueryExportJobs(
    &falcon_container_image.QueryExportJobsParams{
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.queryExportJobs("string");  // filter

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::query_export_jobs;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = query_export_jobs(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.query_export_jobs(filter: 'string')

puts response

GetCombinedImages

Get image assessment results by providing an FQL filter and paging details.

GET /container-security/combined/image-assessment/images/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_combined_images

Parameters

Name	Type	Data type	Description
offset	query	integer	The offset to start retrieving records from.
parameters	query	dictionary	Full query string parameters payload in JSON format.
limit	query	integer	The maximum records to return. [1-100]
sort	query	string	The property to sort by (e.g. status.desc or hostname.asc).
filter	query	string	Filter images using a query in Falcon Query Language (FQL). Supported filters: `container_running_status`, `cve_id`, `first_seen`, `registry`, `repository`, `tag`, `vulnerability_severity`.

Code Examples

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_combined_images(filter="string",
                                      limit=integer,
                                      offset=integer,
                                      sort="string")
print(response)

from falconpy import ContainerImages

falcon = ContainerImages(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.GetCombinedImages(filter="string",
                                    limit=integer,
                                    offset=integer,
                                    sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetCombinedImages",
                          filter="string",
                          sort="string",
                          limit=integer,
                          offset=integer)
print(response)

Get-FalconContainerAssessment -Filter "string" `
  -Sort "string" `
  -Limit integer `
  -Offset integer

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/container_images"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  filter := "string"
  sort := "string"
  limit := int64(0)
  offset := int64(0)

  response, err := client.ContainerImages.GetCombinedImages(
    &container_images.GetCombinedImagesParams{
      Filter: &filter,
      Sort: &sort,
      Limit: &limit,
      Offset: &offset,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.containerImages.getCombinedImages(
  "string",  // filter
  "string",  // sort
  integer,  // limit
  integer  // offset
);

console.log(response);

use rusty_falcon::apis::container_images_api::get_combined_images;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_combined_images(
        &falcon.cfg,  // configuration
        Some("string"),  // filter
        Some("string"),  // sort
        Some(integer),  // limit
        Some(integer),  // offset
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ContainerImages.new

response = api.get_combined_images(filter: 'string',
                                   sort: 'string',
                                   limit: integer,
                                   offset: integer)

puts response

GetCredentials

Gets the registry credentials.

GET /container-security/entities/image-registry-credentials/v1

Scope Falcon Container: READ Consumes · Produces application/json

PEP 8 get_credentials

No keywords or arguments accepted.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_credentials()
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.GetCredentials()
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetCredentials")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainer.GetCredentials(
    &falcon_container.GetCredentialsParams{
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainer.getCredentials();

console.log(response);

use rusty_falcon::apis::falcon_container_api::get_credentials;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_credentials(&falcon.cfg).await.expect("API call failed");  // configuration

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainer.new

response = api.get_credentials

puts response

GetImageAssessmentReport

Retrieve an assessment report for an image by specifying image ID and digest or repository and tag.

GET /reports

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_assessment

Parameters

Name	Type	Data type	Description
image_id	query	string	Image ID of the image assessed. Must be provided in conjuction with `digest`.
digest	query	string	Hash digest of the image assessed. Must be provided in conjuction with `image_id`.
parameters	query	dictionary	Full query string parameters payload in JSON format.
repository	query	string	Repository where the image resides. Must be provided in conjuction with `tag`.
tag	query	string	Tag used for the image assessed. Must be provided in conjuction with `repository`.

If both sets of parameters are provided within the same request, image_id and digest take precedence.

Code Examples

Examples coming soon.

HeadImageScanInventory

Get headers for POST request for image scan inventory.

HEAD /image-assessment/entities/image-inventory/v1

Scope Falcon Container: READ Consumes · Produces application/json

PEP 8 get_scan_headers

This operation does not accept any parameters.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_scan_headers()
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.HeadImageScanInventory()
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("HeadImageScanInventory")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainerImage.HeadImageScanInventory(
    &falcon_container_image.HeadImageScanInventoryParams{
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.headImageScanInventory();

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::head_image_scan_inventory;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = head_image_scan_inventory(&falcon.cfg).await.expect("API call failed");  // configuration

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.head_image_scan_inventory

puts response

DeleteImageDetails

Delete image details from the CrowdStrike registry.

DELETE /images/{}

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 delete_image_details

Parameters

Name	Type	Data type	Description
image_id	path	string	ID of the image to delete details for.

Code Examples

Examples coming soon.

ImageMatchesPolicy

Check if an image matches a policy by specifying repository and tag.

GET /policy-checks

Consumes · Produces application/json

PEP 8 image_matches_policy

Parameters

Name	Type	Data type	Description
parameters	query	dictionary	Full query string parameters payload in JSON format.
repository	query	string	Repository where the image resides.
tag	query	string	Tag used for the image assessed.

Code Examples

Examples coming soon.

PostImageScanInventory

Post image scan inventory.

POST /image-assessment/entities/image-inventory/v1

Scope Falcon Container: READ Consumes · Produces application/json

PEP 8 scan_inventory

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
agent_uuid	body	string	Agent UUID.
agent_version	body	string	Agent version.
agent_version_hash	body	string	Agent version hash.
cluster_id	body	string	Cluster ID.
cluster_name	body	string	Cluster Name.
container_id	body	string	Container ID.
ephemeral_scan	body	boolean	Flag indicating if this is an ephemeral scan.
helm_version	body	string	Helm version used.
high_entropy_strings	body	array	List of high entropy string dictionaries.
host_ip	body	string	Host IP address.
host_name	body	string	Host name.
inventory	body	dictionary	Complete inventory detail as a dictionary.
original_image_name	body	string	Name of the original image.
pod_id	body	string	Pod ID.
pod_name	body	string	Pod name.
pod_namespace	body	string	Pod namespace.
runmode	body	string	Run mode.
runtime_type	body	string	Type of runtime used.
scan_request	body	dictionary	Requested scan in dictionary format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

high_entropy_strings = [
    {
        "layer_hash": "string",
        "layer_index": integer,
        "path": "string",
        "strings": [
            {
                "hash": "string",
                "line": integer,
                "name": "string",
                "regex_name": "string",
                "string": "string"
            }
        ]
    }
]

inventory = {
    "application_packages": [
        {
            "libraries": ["string"],
            "type": integer
        }
    ],
    "config": {
        "architecture": "string",
        "author": "string",
        "config": {},
        "created": "string",
        "history": ["string"],
        "os": "string",
        "os.features": ["string"],
        "os.version": "string",
        "rootfs": {},
        "variant": "string"
    },
    "config_info": {
        "cmd": ["string"],
        "entrypoint": ["string"],
        "env": ["string"],
        "exposed_ports": {},
        "labels": {},
        "stop_signal": "string",
        "user": "string",
        "volumes": {},
        "working_dir": "string"
    },
    "elfbinaries": [
        {
            "details": {},
            "hash": "string",
            "layer_hash": "string",
            "layer_index": integer,
            "malicious": boolean,
            "path": "string",
            "permissions": "string",
            "size": integer
        }
    ],
    "image_info": {
        "architecture": "string",
        "created_at": "string",
        "digest": "string",
        "id": "string",
        "index_digest": "string",
        "registry": "string",
        "repository": "string",
        "size": integer,
        "tag": "string",
        "config_s3_key": "string",
        "manifest_s3_key": "string",
        "scan_request_s3_key": "string",
        "source": "string"
    },
    "inventory_engine_info": {
        "cwppscanner_version": "string",
        "collected_at": "string",
        "engine_version": "string",
        "malware_metadata": {}
    },
    "layers": [
        {
            "created_at": "string",
            "created_by": "string",
            "digest": "string",
            "size": integer,
            "layer_inventory_s3_key": "string",
            "layer_reference_key": "string",
            "layer_reference_type": integer,
            "type": integer
        }
    ],
    "mlmodels": [
        {
            "details": {},
            "detection_name": "string",
            "hash": "string",
            "layer_hash": "string",
            "layer_index": integer,
            "malicious": boolean,
            "path": "string",
            "size": integer
        }
    ],
    "manifest": {
        "annotations": {},
        "artifact_type": "string",
        "config": {},
        "layers": ["string"],
        "media_type": "string",
        "schema_version": integer,
        "subject": {}
    },
    "osinfo": {
        "name": "string",
        "version": "string"
    },
    "packages": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "major_version": "string",
            "package_hash": "string",
            "package_provider": "string",
            "package_source": "string",
            "product": "string",
            "software_architecture": "string",
            "status": "string",
            "vendor": "string"
        }
    ],
    "ai_related": boolean,
    "high_entropy_s3_file_exists": boolean,
    "interesting_strings": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "path": "string",
            "strings": ["string"]
        }
    ],
    "whiteout_files": ["string"]
}

scan_request = {
    "config": {
        "architecture": "string",
        "author": "string",
        "config": {},
        "created": "string",
        "history": ["string"],
        "os": "string",
        "os.features": ["string"],
        "os.version": "string",
        "rootfs": {},
        "variant": "string"
    },
    "config_info": {
        "cmd": ["string"],
        "entrypoint": ["string"],
        "env": ["string"],
        "exposed_ports": {},
        "labels": {},
        "stop_signal": "string",
        "user": "string",
        "volumes": {},
        "working_dir": "string"
    },
    "image_info": {
        "architecture": "string",
        "created_at": "string",
        "digest": "string",
        "id": "string",
        "index_digest": "string",
        "registry": "string",
        "repository": "string",
        "size": integer,
        "tag": "string",
        "config_s3_key": "string",
        "manifest_s3_key": "string",
        "scan_request_s3_key": "string",
        "source": "string"
    },
    "image_metadata": {
        "image_metadata_config_s3_key": "string",
        "image_metadata_high_entropy_strings_s3_key": "string",
        "image_metadata_image_inventory_s3_key": "string",
        "image_metadata_image_inventory_s3_path": "string",
        "image_metadata_manifest_s3_key": "string",
        "image_metadata_scan_report_s3_key": "string"
    },
    "layers": [
        {
            "created_at": "string",
            "created_by": "string",
            "digest": "string",
            "size": integer,
            "layer_inventory_s3_key": "string",
            "layer_reference_key": "string",
            "layer_reference_type": integer,
            "type": integer
        }
    ],
    "manifest": {
        "annotations": {},
        "artifact_type": "string",
        "config": {},
        "layers": ["string"],
        "media_type": "string",
        "schema_version": integer,
        "subject": {}
    },
    "scan_info": {
        "correlation_uuid": "string",
        "requested_at": "string",
        "scan_uuid": "string",
        "user_uuid": "string",
        "username": "string",
        "cid": "string"
    },
    "high_entropy_strings_s3_key": "string",
    "image_inventory_s3_key": "string",
    "layer_inventory_s3_key": "string",
    "scan_report_s3_key": "string",
    "scan_request_s3_key": "string"
}

response = falcon.scan_inventory(agent_uuid="string",
                                 agent_version="string",
                                 agent_version_hash="string",
                                 cluster_id="string",
                                 cluster_name="string",
                                 container_id="string",
                                 ephemeral_scan=boolean,
                                 helm_version="string",
                                 high_entropy_strings=high_entropy_strings,
                                 host_ip="string",
                                 host_name="string",
                                 inventory=inventory,
                                 original_image_name="string",
                                 pod_id="string",
                                 pod_name="string",
                                 pod_namespace="string",
                                 runmode="string",
                                 runtime_type="string",
                                 scan_request=scan_request)
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

high_entropy_strings = [
    {
        "layer_hash": "string",
        "layer_index": integer,
        "path": "string",
        "strings": [
            {
                "hash": "string",
                "line": integer,
                "name": "string",
                "regex_name": "string",
                "string": "string"
            }
        ]
    }
]

inventory = {
    "application_packages": [
        {
            "libraries": ["string"],
            "type": integer
        }
    ],
    "config": {
        "architecture": "string",
        "author": "string",
        "config": {},
        "created": "string",
        "history": ["string"],
        "os": "string",
        "os.features": ["string"],
        "os.version": "string",
        "rootfs": {},
        "variant": "string"
    },
    "config_info": {
        "cmd": ["string"],
        "entrypoint": ["string"],
        "env": ["string"],
        "exposed_ports": {},
        "labels": {},
        "stop_signal": "string",
        "user": "string",
        "volumes": {},
        "working_dir": "string"
    },
    "elfbinaries": [
        {
            "details": {},
            "hash": "string",
            "layer_hash": "string",
            "layer_index": integer,
            "malicious": boolean,
            "path": "string",
            "permissions": "string",
            "size": integer
        }
    ],
    "image_info": {
        "architecture": "string",
        "created_at": "string",
        "digest": "string",
        "id": "string",
        "index_digest": "string",
        "registry": "string",
        "repository": "string",
        "size": integer,
        "tag": "string",
        "config_s3_key": "string",
        "manifest_s3_key": "string",
        "scan_request_s3_key": "string",
        "source": "string"
    },
    "inventory_engine_info": {
        "cwppscanner_version": "string",
        "collected_at": "string",
        "engine_version": "string",
        "malware_metadata": {}
    },
    "layers": [
        {
            "created_at": "string",
            "created_by": "string",
            "digest": "string",
            "size": integer,
            "layer_inventory_s3_key": "string",
            "layer_reference_key": "string",
            "layer_reference_type": integer,
            "type": integer
        }
    ],
    "mlmodels": [
        {
            "details": {},
            "detection_name": "string",
            "hash": "string",
            "layer_hash": "string",
            "layer_index": integer,
            "malicious": boolean,
            "path": "string",
            "size": integer
        }
    ],
    "manifest": {
        "annotations": {},
        "artifact_type": "string",
        "config": {},
        "layers": ["string"],
        "media_type": "string",
        "schema_version": integer,
        "subject": {}
    },
    "osinfo": {
        "name": "string",
        "version": "string"
    },
    "packages": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "major_version": "string",
            "package_hash": "string",
            "package_provider": "string",
            "package_source": "string",
            "product": "string",
            "software_architecture": "string",
            "status": "string",
            "vendor": "string"
        }
    ],
    "ai_related": boolean,
    "high_entropy_s3_file_exists": boolean,
    "interesting_strings": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "path": "string",
            "strings": ["string"]
        }
    ],
    "whiteout_files": ["string"]
}

scan_request = {
    "config": {
        "architecture": "string",
        "author": "string",
        "config": {},
        "created": "string",
        "history": ["string"],
        "os": "string",
        "os.features": ["string"],
        "os.version": "string",
        "rootfs": {},
        "variant": "string"
    },
    "config_info": {
        "cmd": ["string"],
        "entrypoint": ["string"],
        "env": ["string"],
        "exposed_ports": {},
        "labels": {},
        "stop_signal": "string",
        "user": "string",
        "volumes": {},
        "working_dir": "string"
    },
    "image_info": {
        "architecture": "string",
        "created_at": "string",
        "digest": "string",
        "id": "string",
        "index_digest": "string",
        "registry": "string",
        "repository": "string",
        "size": integer,
        "tag": "string",
        "config_s3_key": "string",
        "manifest_s3_key": "string",
        "scan_request_s3_key": "string",
        "source": "string"
    },
    "image_metadata": {
        "image_metadata_config_s3_key": "string",
        "image_metadata_high_entropy_strings_s3_key": "string",
        "image_metadata_image_inventory_s3_key": "string",
        "image_metadata_image_inventory_s3_path": "string",
        "image_metadata_manifest_s3_key": "string",
        "image_metadata_scan_report_s3_key": "string"
    },
    "layers": [
        {
            "created_at": "string",
            "created_by": "string",
            "digest": "string",
            "size": integer,
            "layer_inventory_s3_key": "string",
            "layer_reference_key": "string",
            "layer_reference_type": integer,
            "type": integer
        }
    ],
    "manifest": {
        "annotations": {},
        "artifact_type": "string",
        "config": {},
        "layers": ["string"],
        "media_type": "string",
        "schema_version": integer,
        "subject": {}
    },
    "scan_info": {
        "correlation_uuid": "string",
        "requested_at": "string",
        "scan_uuid": "string",
        "user_uuid": "string",
        "username": "string",
        "cid": "string"
    },
    "high_entropy_strings_s3_key": "string",
    "image_inventory_s3_key": "string",
    "layer_inventory_s3_key": "string",
    "scan_report_s3_key": "string",
    "scan_request_s3_key": "string"
}

response = falcon.PostImageScanInventory(agent_uuid="string",
                                         agent_version="string",
                                         agent_version_hash="string",
                                         cluster_id="string",
                                         cluster_name="string",
                                         container_id="string",
                                         ephemeral_scan=boolean,
                                         helm_version="string",
                                         high_entropy_strings=high_entropy_strings,
                                         host_ip="string",
                                         host_name="string",
                                         inventory=inventory,
                                         original_image_name="string",
                                         pod_id="string",
                                         pod_name="string",
                                         pod_namespace="string",
                                         runmode="string",
                                         runtime_type="string",
                                         scan_request=scan_request)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "agent_uuid": "string",
    "agent_version": "string",
    "agent_version_hash": "string",
    "cluster_id": "string",
    "cluster_name": "string",
    "container_id": "string",
    "ephemeral_scan": boolean,
    "helm_version": "string",
    "high_entropy_strings": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "path": "string",
            "strings": [
                {
                    "hash": "string",
                    "line": integer,
                    "name": "string",
                    "regex_name": "string",
                    "string": "string"
                }
            ]
        }
    ],
    "host_ip": "string",
    "host_name": "string",
    "inventory": {
        "application_packages": [
            {
                "libraries": ["string"],
                "type": integer
            }
        ],
        "config": {
            "architecture": "string",
            "author": "string",
            "config": {},
            "created": "string",
            "history": ["string"],
            "os": "string",
            "os.features": ["string"],
            "os.version": "string",
            "rootfs": {},
            "variant": "string"
        },
        "config_info": {
            "cmd": ["string"],
            "entrypoint": ["string"],
            "env": ["string"],
            "exposed_ports": {},
            "labels": {},
            "stop_signal": "string",
            "user": "string",
            "volumes": {},
            "working_dir": "string"
        },
        "elfbinaries": [
            {
                "details": {},
                "hash": "string",
                "layer_hash": "string",
                "layer_index": integer,
                "malicious": boolean,
                "path": "string",
                "permissions": "string",
                "size": integer
            }
        ],
        "image_info": {
            "architecture": "string",
            "created_at": "string",
            "digest": "string",
            "id": "string",
            "index_digest": "string",
            "registry": "string",
            "repository": "string",
            "size": integer,
            "tag": "string",
            "config_s3_key": "string",
            "manifest_s3_key": "string",
            "scan_request_s3_key": "string",
            "source": "string"
        },
        "inventory_engine_info": {
            "cwppscanner_version": "string",
            "collected_at": "string",
            "engine_version": "string",
            "malware_metadata": {}
        },
        "layers": [
            {
                "created_at": "string",
                "created_by": "string",
                "digest": "string",
                "size": integer,
                "layer_inventory_s3_key": "string",
                "layer_reference_key": "string",
                "layer_reference_type": integer,
                "type": integer
            }
        ],
        "mlmodels": [
            {
                "details": {},
                "detection_name": "string",
                "hash": "string",
                "layer_hash": "string",
                "layer_index": integer,
                "malicious": boolean,
                "path": "string",
                "size": integer
            }
        ],
        "manifest": {
            "annotations": {},
            "artifact_type": "string",
            "config": {},
            "layers": ["string"],
            "media_type": "string",
            "schema_version": integer,
            "subject": {}
        },
        "osinfo": {
            "name": "string",
            "version": "string"
        },
        "packages": [
            {
                "layer_hash": "string",
                "layer_index": integer,
                "major_version": "string",
                "package_hash": "string",
                "package_provider": "string",
                "package_source": "string",
                "product": "string",
                "software_architecture": "string",
                "status": "string",
                "vendor": "string"
            }
        ],
        "ai_related": boolean,
        "high_entropy_s3_file_exists": boolean,
        "interesting_strings": [
            {
                "layer_hash": "string",
                "layer_index": integer,
                "path": "string",
                "strings": ["string"]
            }
        ],
        "whiteout_files": ["string"]
    },
    "original_image_name": "string",
    "pod_id": "string",
    "pod_name": "string",
    "pod_namespace": "string",
    "runmode": "string",
    "runtime_type": "string",
    "scan_request": {
        "config": {
            "architecture": "string",
            "author": "string",
            "config": {},
            "created": "string",
            "history": ["string"],
            "os": "string",
            "os.features": ["string"],
            "os.version": "string",
            "rootfs": {},
            "variant": "string"
        },
        "config_info": {
            "cmd": ["string"],
            "entrypoint": ["string"],
            "env": ["string"],
            "exposed_ports": {},
            "labels": {},
            "stop_signal": "string",
            "user": "string",
            "volumes": {},
            "working_dir": "string"
        },
        "image_info": {
            "architecture": "string",
            "created_at": "string",
            "digest": "string",
            "id": "string",
            "index_digest": "string",
            "registry": "string",
            "repository": "string",
            "size": integer,
            "tag": "string",
            "config_s3_key": "string",
            "manifest_s3_key": "string",
            "scan_request_s3_key": "string",
            "source": "string"
        },
        "image_metadata": {
            "image_metadata_config_s3_key": "string",
            "image_metadata_high_entropy_strings_s3_key": "string",
            "image_metadata_image_inventory_s3_key": "string",
            "image_metadata_image_inventory_s3_path": "string",
            "image_metadata_manifest_s3_key": "string",
            "image_metadata_scan_report_s3_key": "string"
        },
        "layers": [
            {
                "created_at": "string",
                "created_by": "string",
                "digest": "string",
                "size": integer,
                "layer_inventory_s3_key": "string",
                "layer_reference_key": "string",
                "layer_reference_type": integer,
                "type": integer
            }
        ],
        "manifest": {
            "annotations": {},
            "artifact_type": "string",
            "config": {},
            "layers": ["string"],
            "media_type": "string",
            "schema_version": integer,
            "subject": {}
        },
        "scan_info": {
            "correlation_uuid": "string",
            "requested_at": "string",
            "scan_uuid": "string",
            "user_uuid": "string",
            "username": "string",
            "cid": "string"
        },
        "high_entropy_strings_s3_key": "string",
        "image_inventory_s3_key": "string",
        "layer_inventory_s3_key": "string",
        "scan_report_s3_key": "string",
        "scan_request_s3_key": "string"
    }
}

response = falcon.command("PostImageScanInventory", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  agent_uuid := "string"
  agent_version := "string"
  agent_version_hash := "string"
  cluster_id := "string"
  cluster_name := "string"
  container_id := "string"
  ephemeral_scan := boolean
  helm_version := "string"
  LayerHash := "string"
  LayerIndex := integer
  Path := "string"
  Hash := "string"
  Line := integer
  Name := "string"
  RegexName := "string"
  String := "string"
  host_ip := "string"
  host_name := "string"
  original_image_name := "string"
  pod_id := "string"
  pod_name := "string"
  pod_namespace := "string"
  runmode := "string"
  runtime_type := "string"

  response, err := client.FalconContainerImage.PostImageScanInventory(
    &falcon_container_image.PostImageScanInventoryParams{
      Body: &models.ModelsInventoryScanRequestType{
        AgentUuid: &agent_uuid,
        AgentVersion: &agent_version,
        AgentVersionHash: &agent_version_hash,
        ClusterID: &cluster_id,
        ClusterName: &cluster_name,
        ContainerID: &container_id,
        EphemeralScan: &ephemeral_scan,
        HelmVersion: &helm_version,
        HighEntropyStrings: []interface{}{
          {
          Layerhash: &LayerHash,
          Layerindex: &LayerIndex,
          Path: &Path,
          Strings: []interface{}{
            {
            Hash: &Hash,
            Line: &Line,
            Name: &Name,
            Regexname: &RegexName,
            String: &String,
            },
          },
          },
        },
        HostIp: &host_ip,
        HostName: &host_name,
        Inventory: &struct{}{},
        OriginalImageName: &original_image_name,
        PodID: &pod_id,
        PodName: &pod_name,
        PodNamespace: &pod_namespace,
        Runmode: &runmode,
        RuntimeType: &runtime_type,
        ScanRequest: &struct{}{},
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.postImageScanInventory(
  {
    agentUuid: "string",
    agentVersion: "string",
    agentVersionHash: "string",
    clusterId: "string",
    clusterName: "string",
    containerId: "string",
    ephemeralScan: boolean,
    helmVersion: "string",
    highEntropyStrings: [{
        LayerHash: "string",
        LayerIndex: integer,
        Path: "string",
        Strings: [{
            Hash: "string",
            Line: integer,
            Name: "string",
            RegexName: "string",
            String: "string"
          }]
      }],
    hostIp: "string",
    hostName: "string",
    inventory: {
      ApplicationPackages: [{
          libraries: [],
          type: integer
        }],
      Config: {
        architecture: "string",
        author: "string",
        config: {},
        created: "string",
        history: [],
        os: "string",
        os.features: [],
        os.version: "string",
        rootfs: {},
        variant: "string"
      },
      ConfigInfo: {
        Cmd: [],
        Entrypoint: [],
        Env: [],
        ExposedPorts: {},
        Labels: {},
        StopSignal: "string",
        User: "string",
        Volumes: {},
        WorkingDir: "string"
      },
      ELFBinaries: [{
          Details: {},
          Hash: "string",
          LayerHash: "string",
          LayerIndex: integer,
          Malicious: boolean,
          Path: "string",
          Permissions: "string",
          Size: integer
        }],
      ImageInfo: {
        Architecture: "string",
        CreatedAt: "string",
        Digest: "string",
        ID: "string",
        IndexDigest: "string",
        Registry: "string",
        Repository: "string",
        Size: integer,
        Tag: "string",
        configS3Key: "string",
        manifestS3Key: "string",
        scanRequestS3Key: "string",
        source: "string"
      },
      InventoryEngineInfo: {
        CWPPScannerVersion: "string",
        CollectedAt: "string",
        EngineVersion: "string",
        MalwareMetadata: {}
      },
      Layers: [{
          CreatedAt: "string",
          CreatedBy: "string",
          Digest: "string",
          Size: integer,
          layerInventoryS3Key: "string",
          layerReferenceKey: "string",
          layerReferenceType: integer,
          type: integer
        }],
      MLModels: [{
          Details: {},
          DetectionName: "string",
          Hash: "string",
          LayerHash: "string",
          LayerIndex: integer,
          Malicious: boolean,
          Path: "string",
          Size: integer
        }],
      Manifest: {
        annotations: {},
        artifactType: "string",
        config: {},
        layers: [],
        mediaType: "string",
        schemaVersion: integer,
        subject: {}
      },
      OSInfo: {
        Name: "string",
        Version: "string"
      },
      Packages: [{
          LayerHash: "string",
          LayerIndex: integer,
          MajorVersion: "string",
          PackageHash: "string",
          PackageProvider: "string",
          PackageSource: "string",
          Product: "string",
          SoftwareArchitecture: "string",
          Status: "string",
          Vendor: "string"
        }],
      aiRelated: boolean,
      highEntropyS3FileExists: boolean,
      interestingStrings: [{
          LayerHash: "string",
          LayerIndex: integer,
          Path: "string",
          Strings: []
        }],
      whiteoutFiles: []
    },
    originalImageName: "string",
    podId: "string",
    podName: "string",
    podNamespace: "string",
    runmode: "string",
    runtimeType: "string",
    scanRequest: {
      Config: {
        architecture: "string",
        author: "string",
        config: {},
        created: "string",
        history: [],
        os: "string",
        os.features: [],
        os.version: "string",
        rootfs: {},
        variant: "string"
      },
      ConfigInfo: {
        Cmd: [],
        Entrypoint: [],
        Env: [],
        ExposedPorts: {},
        Labels: {},
        StopSignal: "string",
        User: "string",
        Volumes: {},
        WorkingDir: "string"
      },
      ImageInfo: {
        Architecture: "string",
        CreatedAt: "string",
        Digest: "string",
        ID: "string",
        IndexDigest: "string",
        Registry: "string",
        Repository: "string",
        Size: integer,
        Tag: "string",
        configS3Key: "string",
        manifestS3Key: "string",
        scanRequestS3Key: "string",
        source: "string"
      },
      ImageMetadata: {
        imageMetadataConfigS3Key: "string",
        imageMetadataHighEntropyStringsS3Key: "string",
        imageMetadataImageInventoryS3Key: "string",
        imageMetadataImageInventoryS3Path: "string",
        imageMetadataManifestS3Key: "string",
        imageMetadataScanReportS3Key: "string"
      },
      Layers: [{
          CreatedAt: "string",
          CreatedBy: "string",
          Digest: "string",
          Size: integer,
          layerInventoryS3Key: "string",
          layerReferenceKey: "string",
          layerReferenceType: integer,
          type: integer
        }],
      Manifest: {
        annotations: {},
        artifactType: "string",
        config: {},
        layers: [],
        mediaType: "string",
        schemaVersion: integer,
        subject: {}
      },
      ScanInfo: {
        CorrelationUUID: "string",
        RequestedAt: "string",
        ScanUUID: "string",
        UserUUID: "string",
        Username: "string",
        cid: "string"
      },
      highEntropyStringsS3Key: "string",
      imageInventoryS3Key: "string",
      layerInventoryS3Key: "string",
      scanReportS3Key: "string",
      scanRequestS3Key: "string"
    }
}  // body
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::post_image_scan_inventory;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::ModelsInventoryScanRequestType;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = ModelsInventoryScanRequestType {
        agent_uuid: Some("string".to_string()),
        agent_version: Some("string".to_string()),
        agent_version_hash: Some("string".to_string()),
        cluster_id: Some("string".to_string()),
        cluster_name: Some("string".to_string()),
        helm_version: Some("string".to_string()),
        host_ip: Some("string".to_string()),
        host_name: Some("string".to_string()),
        inventory: Default::default(),
        original_image_name: Some("string".to_string()),
        runmode: Some("string".to_string()),
        scan_request: Default::default(),
        ..Default::default()
    };

    let response = post_image_scan_inventory(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

body = Falcon::ModelsInventoryScanRequestType.new(
  agent_uuid: 'string',
  agent_version: 'string',
  agent_version_hash: 'string',
  cluster_id: 'string',
  cluster_name: 'string',
  container_id: 'string',
  ephemeral_scan: boolean,
  helm_version: 'string',
  high_entropy_strings: [{
      LayerHash: 'string',
      LayerIndex: integer,
      Path: 'string',
      Strings: [{
          Hash: 'string',
          Line: integer,
          Name: 'string',
          RegexName: 'string',
          String: 'string'
        }]
    }],
  host_ip: 'string',
  host_name: 'string',
  inventory: {
    ApplicationPackages: [{
        libraries: [],
        type: integer
      }],
    Config: {
      architecture: 'string',
      author: 'string',
      config: {},
      created: 'string',
      history: [],
      os: 'string',
      os.features: [],
      os.version: 'string',
      rootfs: {},
      variant: 'string'
    },
    ConfigInfo: {
      Cmd: [],
      Entrypoint: [],
      Env: [],
      ExposedPorts: {},
      Labels: {},
      StopSignal: 'string',
      User: 'string',
      Volumes: {},
      WorkingDir: 'string'
    },
    ELFBinaries: [{
        Details: {},
        Hash: 'string',
        LayerHash: 'string',
        LayerIndex: integer,
        Malicious: boolean,
        Path: 'string',
        Permissions: 'string',
        Size: integer
      }],
    ImageInfo: {
      Architecture: 'string',
      CreatedAt: 'string',
      Digest: 'string',
      ID: 'string',
      IndexDigest: 'string',
      Registry: 'string',
      Repository: 'string',
      Size: integer,
      Tag: 'string',
      config_s3_key: 'string',
      manifest_s3_key: 'string',
      scan_request_s3_key: 'string',
      source: 'string'
    },
    InventoryEngineInfo: {
      CWPPScannerVersion: 'string',
      CollectedAt: 'string',
      EngineVersion: 'string',
      MalwareMetadata: {}
    },
    Layers: [{
        CreatedAt: 'string',
        CreatedBy: 'string',
        Digest: 'string',
        Size: integer,
        layer_inventory_s3_key: 'string',
        layer_reference_key: 'string',
        layer_reference_type: integer,
        type: integer
      }],
    MLModels: [{
        Details: {},
        DetectionName: 'string',
        Hash: 'string',
        LayerHash: 'string',
        LayerIndex: integer,
        Malicious: boolean,
        Path: 'string',
        Size: integer
      }],
    Manifest: {
      annotations: {},
      artifactType: 'string',
      config: {},
      layers: [],
      mediaType: 'string',
      schemaVersion: integer,
      subject: {}
    },
    OSInfo: {
      Name: 'string',
      Version: 'string'
    },
    Packages: [{
        LayerHash: 'string',
        LayerIndex: integer,
        MajorVersion: 'string',
        PackageHash: 'string',
        PackageProvider: 'string',
        PackageSource: 'string',
        Product: 'string',
        SoftwareArchitecture: 'string',
        Status: 'string',
        Vendor: 'string'
      }],
    ai_related: boolean,
    high_entropy_s3_file_exists: boolean,
    interesting_strings: [{
        LayerHash: 'string',
        LayerIndex: integer,
        Path: 'string',
        Strings: []
      }],
    whiteout_files: []
  },
  original_image_name: 'string',
  pod_id: 'string',
  pod_name: 'string',
  pod_namespace: 'string',
  runmode: 'string',
  runtime_type: 'string',
  scan_request: {
    Config: {
      architecture: 'string',
      author: 'string',
      config: {},
      created: 'string',
      history: [],
      os: 'string',
      os.features: [],
      os.version: 'string',
      rootfs: {},
      variant: 'string'
    },
    ConfigInfo: {
      Cmd: [],
      Entrypoint: [],
      Env: [],
      ExposedPorts: {},
      Labels: {},
      StopSignal: 'string',
      User: 'string',
      Volumes: {},
      WorkingDir: 'string'
    },
    ImageInfo: {
      Architecture: 'string',
      CreatedAt: 'string',
      Digest: 'string',
      ID: 'string',
      IndexDigest: 'string',
      Registry: 'string',
      Repository: 'string',
      Size: integer,
      Tag: 'string',
      config_s3_key: 'string',
      manifest_s3_key: 'string',
      scan_request_s3_key: 'string',
      source: 'string'
    },
    ImageMetadata: {
      image_metadata_config_s3_key: 'string',
      image_metadata_high_entropy_strings_s3_key: 'string',
      image_metadata_image_inventory_s3_key: 'string',
      image_metadata_image_inventory_s3_path: 'string',
      image_metadata_manifest_s3_key: 'string',
      image_metadata_scan_report_s3_key: 'string'
    },
    Layers: [{
        CreatedAt: 'string',
        CreatedBy: 'string',
        Digest: 'string',
        Size: integer,
        layer_inventory_s3_key: 'string',
        layer_reference_key: 'string',
        layer_reference_type: integer,
        type: integer
      }],
    Manifest: {
      annotations: {},
      artifactType: 'string',
      config: {},
      layers: [],
      mediaType: 'string',
      schemaVersion: integer,
      subject: {}
    },
    ScanInfo: {
      CorrelationUUID: 'string',
      RequestedAt: 'string',
      ScanUUID: 'string',
      UserUUID: 'string',
      Username: 'string',
      cid: 'string'
    },
    high_entropy_strings_s3_key: 'string',
    image_inventory_s3_key: 'string',
    layer_inventory_s3_key: 'string',
    scan_report_s3_key: 'string',
    scan_request_s3_key: 'string'
  }
)

response = api.post_image_scan_inventory(body)

puts response

ReadImageVulnerabilities

Retrieve known vulnerabilities by specifying repository and tag.

POST /image-assessment/combined/vulnerability-lookups/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 read_image_vulnerabilities

Parameters

Name	Type	Data type	Description
applicationPackages	body	list of dictionaries	List of application packages for the image.
body	body	dictionary	Full body payload in JSON format, not required if using other keywords.
osversion	body	string	Operating system version for the image to be read.
packages	body	list of dictionaries	List of packages to review.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

application_packages = [
    {
        "libraries": [
            {
                "hash": "string",
                "layer_hash": "string",
                "layer_index": integer,
                "license": "string",
                "name": "string",
                "path": "string",
                "version": "string",
                "ai_related": boolean
            }
        ],
        "type": integer
    }
]

packages = [
    {
        "layer_hash": "string",
        "layer_index": integer,
        "major_version": "string",
        "package_hash": "string",
        "package_provider": "string",
        "package_source": "string",
        "product": "string",
        "software_architecture": "string",
        "status": "string",
        "vendor": "string"
    }
]

response = falcon.read_image_vulnerabilities(application_packages=application_packages,
                                             osversion="string",
                                             packages=packages)
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

application_packages = [
    {
        "libraries": [
            {
                "hash": "string",
                "layer_hash": "string",
                "layer_index": integer,
                "license": "string",
                "name": "string",
                "path": "string",
                "version": "string",
                "ai_related": boolean
            }
        ],
        "type": integer
    }
]

packages = [
    {
        "layer_hash": "string",
        "layer_index": integer,
        "major_version": "string",
        "package_hash": "string",
        "package_provider": "string",
        "package_source": "string",
        "product": "string",
        "software_architecture": "string",
        "status": "string",
        "vendor": "string"
    }
]

response = falcon.ReadImageVulnerabilities(application_packages=application_packages,
                                           osversion="string",
                                           packages=packages)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "application_packages": [
        {
            "libraries": [
                {
                    "hash": "string",
                    "layer_hash": "string",
                    "layer_index": integer,
                    "license": "string",
                    "name": "string",
                    "path": "string",
                    "version": "string",
                    "ai_related": boolean
                }
            ],
            "type": integer
        }
    ],
    "osversion": "string",
    "packages": [
        {
            "layer_hash": "string",
            "layer_index": integer,
            "major_version": "string",
            "package_hash": "string",
            "package_provider": "string",
            "package_source": "string",
            "product": "string",
            "software_architecture": "string",
            "status": "string",
            "vendor": "string"
        }
    ]
}

response = falcon.command("ReadImageVulnerabilities", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_cli"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  Hash := "string"
  LayerHash := "string"
  LayerIndex := integer
  License := "string"
  Name := "string"
  Path := "string"
  Version := "string"
  ai_related := boolean
  type := integer
  osversion := "string"
  MajorVersion := "string"
  PackageHash := "string"
  PackageProvider := "string"
  PackageSource := "string"
  Product := "string"
  SoftwareArchitecture := "string"
  Status := "string"
  Vendor := "string"

  response, err := client.FalconContainerCli.ReadImageVulnerabilities(
    &falcon_container_cli.ReadImageVulnerabilitiesParams{
      Body: &models.APIImageLookupRequest{
        Applicationpackages: []interface{}{
          {
          Libraries: []interface{}{
            {
            Hash: &Hash,
            Layerhash: &LayerHash,
            Layerindex: &LayerIndex,
            License: &License,
            Name: &Name,
            Path: &Path,
            Version: &Version,
            AiRelated: &ai_related,
            },
          },
          Type: &type,
          },
        },
        Osversion: &osversion,
        Packages: []interface{}{
          {
          Layerhash: &LayerHash,
          Layerindex: &LayerIndex,
          Majorversion: &MajorVersion,
          Packagehash: &PackageHash,
          Packageprovider: &PackageProvider,
          Packagesource: &PackageSource,
          Product: &Product,
          Softwarearchitecture: &SoftwareArchitecture,
          Status: &Status,
          Vendor: &Vendor,
          },
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerCli.readImageVulnerabilities(
  {
    applicationPackages: [{
        libraries: [{
            Hash: "string",
            LayerHash: "string",
            LayerIndex: integer,
            License: "string",
            Name: "string",
            Path: "string",
            Version: "string",
            aiRelated: boolean
          }],
        type: integer
      }],
    osversion: "string",
    packages: [{
        LayerHash: "string",
        LayerIndex: integer,
        MajorVersion: "string",
        PackageHash: "string",
        PackageProvider: "string",
        PackageSource: "string",
        Product: "string",
        SoftwareArchitecture: "string",
        Status: "string",
        Vendor: "string"
      }]
}  // body
);

console.log(response);

use rusty_falcon::apis::falcon_container_cli_api::read_image_vulnerabilities;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::ApiImageLookupRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = ApiImageLookupRequest {
        osversion: Some("string".to_string()),
        packages: vec![PackageInfoType {
            layer_index: Some(integer),
            ..Default::default()
        }],
        ..Default::default()
    };

    let response = read_image_vulnerabilities(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerCli.new

body = Falcon::ApiImageLookupRequest.new(
  applicationPackages: [{
      libraries: [{
          Hash: 'string',
          LayerHash: 'string',
          LayerIndex: integer,
          License: 'string',
          Name: 'string',
          Path: 'string',
          Version: 'string',
          ai_related: boolean
        }],
      type: integer
    }],
  osversion: 'string',
  packages: [{
      LayerHash: 'string',
      LayerIndex: integer,
      MajorVersion: 'string',
      PackageHash: 'string',
      PackageProvider: 'string',
      PackageSource: 'string',
      Product: 'string',
      SoftwareArchitecture: 'string',
      Status: 'string',
      Vendor: 'string'
    }]
)

response = api.read_image_vulnerabilities(body)

puts response

ReadRegistryEntities

Retrieve registry entities associated with the client ID.

GET /container-security/queries/registries/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 read_registry_entities

Parameters

Name	Type	Data type	Description
limit	query	integer	Total number of records to return in the response.
offset	query	integer	Starting position within the overall recordset to return results.
parameters	query	dictionary	Full query string parameters payload in JSON format.
sort	query	string	FQL formatted string to use to sort returned results.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.read_registry_entities(limit=integer,
                                         offset=integer,
                                         sort="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.ReadRegistryEntities(limit=integer,
                                       offset=integer,
                                       sort="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ReadRegistryEntities",
                          limit=integer,
                          offset=integer,
                          sort="string")
print(response)

Get-FalconContainerRegistry -Sort "string" `
  -Limit integer `
  -Offset integer

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  limit := int64(0)
  offset := int64(0)
  sort := "string"

  response, err := client.FalconContainerImage.ReadRegistryEntities(
    &falcon_container_image.ReadRegistryEntitiesParams{
      Limit: &limit,
      Offset: &offset,
      Sort: &sort,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.readRegistryEntities(
  integer,  // limit
  integer,  // offset
  "string"  // sort
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::read_registry_entities;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = read_registry_entities(
        &falcon.cfg,  // configuration
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // sort
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.read_registry_entities(limit: integer,
                                      offset: integer,
                                      sort: 'string')

puts response

ReadRegistryEntitiesByUUID

Retrieve registry entities associated with a specific UUID.

GET /container-security/entities/registries/v1

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 read_registry_entities_by_uuid

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	Registry entity UUIDs to retrieve.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.read_registry_entities_by_uuid(ids="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.ReadRegistryEntitiesByUUID(ids="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ReadRegistryEntitiesByUUID",
                          ids="string")
print(response)

Get-FalconContainerRegistry -Id "string"

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainerImage.ReadRegistryEntitiesByUUID(
    &falcon_container_image.ReadRegistryEntitiesByUUIDParams{
      Ids: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.readRegistryEntitiesByUUID("string");  // ids

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::read_registry_entities_by_uuid;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = read_registry_entities_by_uuid(
        &falcon.cfg,  // configuration
        "string",  // ids
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.read_registry_entities_by_uuid('string')

puts response

DeleteRegistryEntities

Delete registry entities by UUID.

DELETE /container-security/entities/registries/v1

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 delete_registry_entities

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	Registry entity UUIDs to delete.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.delete_registry_entities(ids="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.DeleteRegistryEntities(ids="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("DeleteRegistryEntities",
                          ids="string")
print(response)

Remove-FalconContainerRegistry -Id "string"

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.FalconContainerImage.DeleteRegistryEntities(
    &falcon_container_image.DeleteRegistryEntitiesParams{
      Ids: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.deleteRegistryEntities("string");  // ids

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::delete_registry_entities;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = delete_registry_entities(
        &falcon.cfg,  // configuration
        "string",  // ids
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.delete_registry_entities('string')

puts response

CreateRegistryEntities

Create registry entities using the provided detail.

POST /container-security/entities/registries/v1

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 create_registry_entities

Parameters

Name	Type	Data type	Description
aws_iam_role	body (credential)	string	Container registry username (AWS ECR).
aws_external_id	body (credential)	string	Container registry password (AWS ECR).
body	body	dictionary	Full body payload in JSON format, not required if using other keywords.
compartment_ids	body (credential)	list of strings	Compartment IDs (OCR (Oracle)).
credential_type	body (credential)	string	Credential type (GitHub, GitLab).
domain_url	body (credential)	string	Domain URL (GitHub, GitLab).
password	body (credential)	string	Container registry password.
project_id	body (credential)	string	Cloud Project ID (GAR, GCR (Google)).
scope_name	body (credential)	string	Scope name (GAR, GCR (Google), OCR (Oracle)).
service_account_json	body (credential)	dictionary	GAR / GCR credential dictionary. Keys: `client_email`, `client_id`, `private_key`, `private_key_id`, `project_id`, `type`.
type	body	string	The type of registry (e.g., `acr`, `artifactory`, `docker`, `dockerhub`, `ecr`, `gar`, `gcr`, `github`, `gitlab`, `harbor`, `icr`, `nexus`, `openshift`, `oracle`, `quay.io`). Required.
url	body	string	The URL used to log in to the registry. Required.
url_uniqueness_key	body	string	The registry URL alias.
user_defined_alias	body	string	A user-friendly name for the registry.
username	body (credential)	string	Container registry username.

Required Credential Values by Registry

Registry	Type	Required credential values
Amazon Elastic Container Registry	`ecr`	`aws_iam_role`, `aws_external_id`
Docker Hub	`dockerhub`	`password` (access token), `username`
Docker Registry v2	`docker`	`password` (API Key), `username` (account ID)
GitHub	`github`	`credential_type`, `domain_url`, `password` (personal access token), `username`
GitLab Cloud	`gitlab`	`credential_type`, `domain_url`, `password` (personal access token), `username`
GitLab On-prem	`gitlab`	`credential_type` (set to `PAT`), `domain_url`, `password` (personal access token), `username`
Google Artifact Registry	`gar`	`project_id`, `scope_name`, `service_account_json`
Google Container Registry	`gcr`	`project_id`, `service_account_json`
IBM Cloud	`icr`	`password`, `username`
JFrog Artifactory	`artifactory`	`password` (API Key), `username` (account ID)
Microsoft Azure Container Registry	`acr`	`password` (API Key), `username` (account ID)
Oracle Container Registry	`oracle`	`compartment_ids`, `password`, `scope_name`, `username` (tenancy email)
Red Hat OpenShift	`openshift`	`password` (API Key), `username` (account ID)
Sonatype Nexus	`nexus`	`password` (API Key), `username` (account ID)
Quay.io (Red Hat)	`quay.io`	`password` (API Key), `username` (account ID)
VMWare Harbor	`harbor`	`password`, `username`

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

credential = {
    "details": {}
}

response = falcon.create_registry_entities(credential=credential,
                                           type="string",
                                           url="string",
                                           url_uniqueness_key="string",
                                           user_defined_alias="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

credential = {
    "details": {}
}

response = falcon.CreateRegistryEntities(credential=credential,
                                         type="string",
                                         url="string",
                                         url_uniqueness_key="string",
                                         user_defined_alias="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "credential": {
        "details": {}
    },
    "type": "string",
    "url": "string",
    "url_uniqueness_key": "string",
    "user_defined_alias": "string"
}

response = falcon.command("CreateRegistryEntities", body=body_payload)
print(response)

New-FalconContainerRegistry -Name "string" `
  -Type "string" `
  -Url "string" `
  -Credential @{}

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  type := "string"
  url := "string"
  url_uniqueness_key := "string"
  user_defined_alias := "string"

  response, err := client.FalconContainerImage.CreateRegistryEntities(
    &falcon_container_image.CreateRegistryEntitiesParams{
      Body: &models.RegistryassessmentExternalRegistryPayload{
        Credential: &struct{}{},
        Type: &type,
        URL: &url,
        UrlUniquenessKey: &url_uniqueness_key,
        UserDefinedAlias: &user_defined_alias,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.createRegistryEntities(
  {
    credential: {
      details: {}
    },
    type: "string",
    url: "string",
    urlUniquenessKey: "string",
    userDefinedAlias: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::create_registry_entities;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::RegistryassessmentExternalRegistryPayload;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = RegistryassessmentExternalRegistryPayload {
        credential: Default::default(),
        type: Some("string".to_string()),
        url: Some("string".to_string()),
        ..Default::default()
    };

    let response = create_registry_entities(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

body = Falcon::RegistryassessmentExternalRegistryPayload.new(
  credential: {
    details: {}
  },
  type: 'string',
  url: 'string',
  url_uniqueness_key: 'string',
  user_defined_alias: 'string'
)

response = api.create_registry_entities(body)

puts response

UpdateRegistryEntities

Update the registry entity, as identified by the entity UUID, using the provided details.

PATCH /container-security/entities/registries/v1

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 update_registry_entities

Parameters

Same parameters as CreateRegistryEntities plus:

Name	Type	Data type	Description
id	body	string	Container registry record UUID.
state	body	string	Container registry state: `pause` or `resume`.

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

credential = {
    "details": {},
    "type": "string"
}

response = falcon.update_registry_entities(credential=credential,
                                           state="string",
                                           user_defined_alias="string",
                                           id="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

credential = {
    "details": {},
    "type": "string"
}

response = falcon.UpdateRegistryEntities(credential=credential,
                                         state="string",
                                         user_defined_alias="string",
                                         id="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "credential": {
        "details": {},
        "type": "string"
    },
    "state": "string",
    "user_defined_alias": "string"
}

response = falcon.command("UpdateRegistryEntities",
                          id="string",
                          body=body_payload)
print(response)

Edit-FalconContainerRegistry -Id "string"

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  state := "string"
  user_defined_alias := "string"

  response, err := client.FalconContainerImage.UpdateRegistryEntities(
    &falcon_container_image.UpdateRegistryEntitiesParams{
      Body: &models.RegistryassessmentExternalRegistryPatchPayload{
        Credential: &struct{}{},
        State: &state,
        UserDefinedAlias: &user_defined_alias,
      },
      ID: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.updateRegistryEntities(
  "string",  // id
  {  // body
      credential: {
        details: {},
        type: "string"
      },
      state: "string",
      userDefinedAlias: "string"
  }
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::update_registry_entities;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::RegistryassessmentExternalRegistryPatchPayload;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = RegistryassessmentExternalRegistryPatchPayload {
        credential: Default::default(),
        ..Default::default()
    };

    let response = update_registry_entities(
        &falcon.cfg,  // configuration
        "string",  // id
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

body = Falcon::RegistryassessmentExternalRegistryPatchPayload.new(
  credential: {
    details: {},
    type: 'string'
  },
  state: 'string',
  user_defined_alias: 'string'
)

response = api.update_registry_entities(body, 'string')

puts response

PolicyChecks

Check image prevention policies

GET /image-assessment/entities/policy-checks/v2

Scope Falcon Container Image: WRITE Consumes · Produces application/json

PEP 8 check_prevention_policies

Parameters

Name	Type	Data type	Description
registry	query	string	Image Registry
repository	query	string	Image Repository
tag	query	string	Image Tag
parameters	query	dictionary	Full query string parameters payload in JSON format

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.check_prevention_policies(registry="string",
                                            repository="string",
                                            tag="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.PolicyChecks(registry="string",
                               repository="string",
                               tag="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("PolicyChecks",
                          registry="string",
                          repository="string",
                          tag="string",
                          architecture="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  registry := "string"
  architecture := "string"

  response, err := client.FalconContainerImage.PolicyChecks(
    &falcon_container_image.PolicyChecksParams{
      Registry: &registry,
      Repository: "string",
      Tag: "string",
      Architecture: &architecture,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.policyChecks(
  "string",  // repository
  "string",  // tag
  "string",  // registry
  "string"  // architecture
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::policy_checks;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = policy_checks(
        &falcon.cfg,  // configuration
        "string",  // repository
        "string",  // tag
        Some("string"),  // registry
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.policy_checks('string', 'string')

puts response

GetReportByReference

Get image assessment scan report by image reference (v2)

GET /image-assessment/entities/reports/v2

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_report_by_reference

Parameters

Name	Type	Data type	Description
registry	query	string	Image Registry
repository	query	string	Image Repository
tag	query	string	Image Tag
image_id	query	string	Image ID
digest	query	string	Image digest
report_format	query	string	Specify image-assessment scan report format
parameters	query	dictionary	Full query string parameters payload in JSON format

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_report_by_reference(registry="string",
                                          repository="string",
                                          tag="string",
                                          image_id="string",
                                          digest="string",
                                          report_format="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.GetReportByReference(registry="string",
                                       repository="string",
                                       tag="string",
                                       image_id="string",
                                       digest="string",
                                       report_format="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetReportByReference",
                          registry="string",
                          repository="string",
                          tag="string",
                          image_id="string",
                          digest="string",
                          architecture="string",
                          report_format="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  registry := "string"
  repository := "string"
  tag := "string"
  imageID := "string"
  digest := "string"
  architecture := "string"
  reportFormat := "string"

  response, err := client.FalconContainerImage.GetReportByReference(
    &falcon_container_image.GetReportByReferenceParams{
      Registry: &registry,
      Repository: &repository,
      Tag: &tag,
      ImageID: &imageID,
      Digest: &digest,
      Architecture: &architecture,
      ReportFormat: &reportFormat,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.getReportByReference(
  "string",  // registry
  "string",  // repository
  "string",  // tag
  "string",  // imageId
  "string",  // digest
  "string",  // architecture
  "string"  // reportFormat
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::get_report_by_reference;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_report_by_reference(
        &falcon.cfg,  // configuration
        Some("string"),  // registry
        Some("string"),  // repository
        Some("string"),  // tag
        Some("string"),  // image_id
        Some("string"),  // digest
        Some("string"),  // report_format
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.get_report_by_reference(registry: 'string',
                                       repository: 'string',
                                       tag: 'string',
                                       image_id: 'string',
                                       digest: 'string',
                                       architecture: 'string',
                                       report_format: 'string')

puts response

GetReportByScanID

Get image assessment scan report by scan UUID (v2)

GET /image-assessment/entities/reports/v2/{uuid}

Scope Falcon Container Image: READ Consumes · Produces application/json

PEP 8 get_report_by_id

Parameters

Name	Type	Data type	Description
uuid	path	string	Scan UUID
report_format	query	string	Specify image-assessment scan report format
parameters	query	dictionary	Full query string parameters payload in JSON format

Code Examples

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.get_report_by_id(uuid="string", report_format="string")
print(response)

from falconpy import FalconContainer

falcon = FalconContainer(client_id=CLIENT_ID,
                         client_secret=CLIENT_SECRET
                         )

response = falcon.GetReportByScanID(uuid="string", report_format="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetReportByScanID",
                          uuid="string",
                          report_format="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/falcon_container_image"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  reportFormat := "string"

  response, err := client.FalconContainerImage.GetReportByScanID(
    &falcon_container_image.GetReportByScanIDParams{
      UUID: "string",
      ReportFormat: &reportFormat,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.falconContainerImage.getReportByScanID(
  "string",  // uuid
  "string"  // reportFormat
);

console.log(response);

use rusty_falcon::apis::falcon_container_image_api::get_report_by_scan_id;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_report_by_scan_id(
        &falcon.cfg,  // configuration
        "string",  // uuid
        Some("string"),  // report_format
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::FalconContainerImage.new

response = api.get_report_by_scan_id('string')

puts response

Falcon Container

Table of Contents

DownloadExportFile

Parameters

Code Examples

ReadExportJobs

Parameters

Code Examples

LaunchExportJob

Parameters

Code Examples

QueryExportJobs

Parameters

Code Examples

GetCombinedImages

Parameters

Code Examples

GetCredentials

Code Examples

GetImageAssessmentReport

Parameters

Code Examples

HeadImageScanInventory

Code Examples

DeleteImageDetails

Parameters

Code Examples

ImageMatchesPolicy

Parameters

Code Examples

PostImageScanInventory

Parameters

Code Examples

ReadImageVulnerabilities

Parameters

Code Examples

ReadRegistryEntities

Parameters

Code Examples

ReadRegistryEntitiesByUUID

Parameters

Code Examples

DeleteRegistryEntities

Parameters

Code Examples

CreateRegistryEntities

Parameters

Required Credential Values by Registry

Code Examples

UpdateRegistryEntities

Parameters

Code Examples

PolicyChecks

Parameters

Code Examples

GetReportByReference

Parameters

Code Examples

GetReportByScanID

Parameters

Code Examples