Quarantine

The Quarantine service collection provides operations for managing quarantined files. Get quarantine file metadata and aggregates, update quarantine states by ID or query, and search for quarantine file IDs using FQL filters.

Language	Last Update
Python	v1.6.5
PowerShell	v2.2.9
Go	v0.22.0
TypeScript	v0.6.0
Rust	v0.7.1
Ruby	v1.4.0

This service collection has code examples posted to the repository.

Operation	Description
ActionUpdateCount `action_update_count`	Returns count of potentially affected quarantined files for each action.
GetAggregateFiles `get_aggregate_files`	Get quarantine file aggregates as specified via json in request body.
GetQuarantineFiles `get_quarantine_files`	Get quarantine file metadata for specified ids.
QueryQuarantineFiles `query_quarantine_files`	Get quarantine file ids that match the provided filter criteria.
UpdateQfByQuery `update_quarantined_detects_by_query`	Apply quarantine file actions by query.
UpdateQuarantinedDetectsByIds `update_quarantined_detects_by_id`	Apply action by quarantine file ids

ActionUpdateCount

Returns count of potentially affected quarantined files for each action.

Method GET

Route /quarantine/aggregates/action-update-count/v1

Scope Quarantined Files: READ

PEP 8 action_update_count

Parameters

filter query · string

The filter expression that should be used to filter results. FQL syntax.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

Code Examples

from falconpy import Quarantine

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

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

from falconpy import Quarantine

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

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

from falconpy import APIHarnessV2

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

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

Test-FalconQuarantineAction -Filter "string"

package main

import (
  "context"
  "fmt"
  "os"

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

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.Quarantine.ActionUpdateCount(
    &quarantine.ActionUpdateCountParams{
      Filter: "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.quarantine.actionUpdateCount("string");  // filter

console.log(response);

use rusty_falcon::apis::quarantine_api::action_update_count;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = action_update_count(
        &falcon.cfg,  // configuration
        "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::Quarantine.new

response = api.action_update_count('string')

puts response

Responses

[
  {
    "buckets": [],
    "doc_count_error_upper_bound": 0,
    "hits": {},
    "name": "string",
    "sum_other_doc_count": 0
  }
]

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

GetAggregateFiles

Get quarantine file aggregates as specified via json in request body.

Method POST

Route /quarantine/aggregates/quarantined-files/GET/v1

Scope Quarantined Files: READ

PEP 8 get_aggregate_files

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

date_ranges body · array

If peforming a date range query specify the from and to date ranges. These can be in common date formats like 2019-07-18 or now.

exclude body · string

Fields to exclude.

extended_bounds body · object

field body · string

Term you want to aggregate on. If doing a date_range query, this is the date field you want to apply the date ranges to.

filter body · string

Optional filter criteria in the form of an FQL query. For more information about FQL queries, see our FQL documentation in Falcon.

filters_spec body · object

from body · integer

include body · string

Fields to include.

interval body · string

Available values (6)

`year`	`month`	`week`
`day`	`hour`	`minute`

max_doc_count body · integer

Maximum number of documents.

min_doc_count body · integer

Minimum number of documents.

missing body · string

name body · string

Scan name.

percents body · array

q body · string

FQL syntax.

ranges body · array

size body · integer

sort body · string

FQL syntax.

Available values (2)

sub_aggregates body · array

time_zone body · string

type body · string

Available values (10)

Code Examples

from falconpy import Quarantine

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

date_ranges = [
    {
        "from": "string",
        "to": "string"
    }
]

ranges = [
    {
        "From": 0,
        "To": 0
    }
]

response = falcon.get_aggregate_files(date_ranges=date_ranges,
                                      exclude="string",
                                      field="string",
                                      filter="string",
                                      from=integer,
                                      include="string",
                                      interval="string",
                                      max_doc_count=integer,
                                      min_doc_count=integer,
                                      missing="string",
                                      name="string",
                                      q="string",
                                      ranges=ranges,
                                      size=integer,
                                      sort="string",
                                      sub_aggregates=["string"],
                                      time_zone="string",
                                      type="string")
print(response)

from falconpy import Quarantine

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

date_ranges = [
    {
        "from": "string",
        "to": "string"
    }
]

ranges = [
    {
        "From": 0,
        "To": 0
    }
]

response = falcon.GetAggregateFiles(date_ranges=date_ranges,
                                    exclude="string",
                                    field="string",
                                    filter="string",
                                    from=integer,
                                    include="string",
                                    interval="string",
                                    max_doc_count=integer,
                                    min_doc_count=integer,
                                    missing="string",
                                    name="string",
                                    q="string",
                                    ranges=ranges,
                                    size=integer,
                                    sort="string",
                                    sub_aggregates=["string"],
                                    time_zone="string",
                                    type="string")
print(response)

from falconpy import APIHarnessV2

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

body_payload = {
    "date_ranges": [
        {
            "from": "string",
            "to": "string"
        }
    ],
    "exclude": "string",
    "extended_bounds": {
        "max": "string",
        "min": "string"
    },
    "field": "string",
    "filter": "string",
    "filters_spec": {
        "filters": {},
        "other_bucket": boolean,
        "other_bucket_key": "string"
    },
    "from": integer,
    "include": "string",
    "interval": "string",
    "max_doc_count": integer,
    "min_doc_count": integer,
    "missing": "string",
    "name": "string",
    "percents": ["string"],
    "q": "string",
    "ranges": [
        {
            "from": integer,
            "to": integer
        }
    ],
    "size": integer,
    "sort": "string",
    "sub_aggregates": [
        {
            "date_ranges": [
                {
                    "from": "string",
                    "to": "string"
                }
            ],
            "exclude": "string",
            "extended_bounds": {
                "max": "string",
                "min": "string"
            },
            "field": "string",
            "filter": "string",
            "filters_spec": {
                "filters": {},
                "other_bucket": boolean,
                "other_bucket_key": "string"
            },
            "from": integer,
            "include": "string",
            "interval": "string",
            "max_doc_count": integer,
            "min_doc_count": integer,
            "missing": "string",
            "name": "string",
            "percents": ["string"],
            "q": "string",
            "ranges": [
                {
                    "from": integer,
                    "to": integer
                }
            ],
            "size": integer,
            "sort": "string",
            "sub_aggregates": [
                {
                    "date_ranges": ["string"],
                    "exclude": "string",
                    "extended_bounds": {},
                    "field": "string",
                    "filter": "string",
                    "filters_spec": {},
                    "from": integer,
                    "include": "string",
                    "interval": "string",
                    "max_doc_count": integer,
                    "min_doc_count": integer,
                    "missing": "string",
                    "name": "string",
                    "percents": ["string"],
                    "q": "string",
                    "ranges": ["string"],
                    "size": integer,
                    "sort": "string",
                    "sub_aggregates": ["string"],
                    "time_zone": "string",
                    "type": "string"
                }
            ],
            "time_zone": "string",
            "type": "string"
        }
    ],
    "time_zone": "string",
    "type": "string"
}

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

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/quarantine"
  "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)
  }

  from := "string"
  to := "string"
  exclude := "string"
  field := "string"
  filter := "string"
  from := integer
  include := "string"
  interval := "string"
  max_doc_count := integer
  min_doc_count := integer
  missing := "string"
  name := "string"
  q := "string"
  From := integer
  To := integer
  size := integer
  sort := "string"
  time_zone := "string"
  typeVar := "string"

  response, err := client.Quarantine.GetAggregateFiles(
    &quarantine.GetAggregateFilesParams{
      Body: &models.MsaAggregateQueryRequest{
        DateRanges: []interface{}{
          {
          From: &from,
          To: &to,
          },
        },
        Exclude: &exclude,
        ExtendedBounds: &struct{}{},
        Field: &field,
        Filter: &filter,
        FiltersSpec: &struct{}{},
        From: &from,
        Include: &include,
        Interval: &interval,
        MaxDocCount: &max_doc_count,
        MinDocCount: &min_doc_count,
        Missing: &missing,
        Name: &name,
        Percents: []interface{}{},
        Q: &q,
        Ranges: []interface{}{
          {
          From: &From,
          To: &To,
          },
        },
        Size: &size,
        Sort: &sort,
        SubAggregates: []interface{}{
          {
          DateRanges: []interface{}{
            {
            From: &from,
            To: &to,
            },
          },
          Exclude: &exclude,
          ExtendedBounds: &struct{}{},
          Field: &field,
          Filter: &filter,
          FiltersSpec: &struct{}{},
          From: &from,
          Include: &include,
          Interval: &interval,
          MaxDocCount: &max_doc_count,
          MinDocCount: &min_doc_count,
          Missing: &missing,
          Name: &name,
          Percents: []interface{}{},
          Q: &q,
          Ranges: []interface{}{
            {
            From: &From,
            To: &To,
            },
          },
          Size: &size,
          Sort: &sort,
          SubAggregates: []interface{}{
            {
            DateRanges: []interface{}{},
            Exclude: &exclude,
            ExtendedBounds: &struct{}{},
            Field: &field,
            Filter: &filter,
            FiltersSpec: &struct{}{},
            From: &from,
            Include: &include,
            Interval: &interval,
            MaxDocCount: &max_doc_count,
            MinDocCount: &min_doc_count,
            Missing: &missing,
            Name: &name,
            Percents: []interface{}{},
            Q: &q,
            Ranges: []interface{}{},
            Size: &size,
            Sort: &sort,
            SubAggregates: []interface{}{},
            TimeZone: &time_zone,
            Type: &typeVar,
            },
          },
          TimeZone: &time_zone,
          Type: &typeVar,
          },
        },
        TimeZone: &time_zone,
        Type: &typeVar,
      },
      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.quarantine.getAggregateFiles(
  {
    dateRanges: [{
        from: "string",
        to: "string"
      }],
    exclude: "string",
    extendedBounds: {
      max: "string",
      min: "string"
    },
    field: "string",
    filter: "string",
    filtersSpec: {
      filters: {},
      otherBucket: boolean,
      otherBucketKey: "string"
    },
    from: integer,
    include: "string",
    interval: "string",
    maxDocCount: integer,
    minDocCount: integer,
    missing: "string",
    name: "string",
    percents: [],
    q: "string",
    ranges: [{
        From: integer,
        To: integer
      }],
    size: integer,
    sort: "string",
    subAggregates: [{
        dateRanges: [{
            from: "string",
            to: "string"
          }],
        exclude: "string",
        extendedBounds: {
          max: "string",
          min: "string"
        },
        field: "string",
        filter: "string",
        filtersSpec: {
          filters: {},
          otherBucket: boolean,
          otherBucketKey: "string"
        },
        from: integer,
        include: "string",
        interval: "string",
        maxDocCount: integer,
        minDocCount: integer,
        missing: "string",
        name: "string",
        percents: [],
        q: "string",
        ranges: [{
            From: integer,
            To: integer
          }],
        size: integer,
        sort: "string",
        subAggregates: [{
            dateRanges: [],
            exclude: "string",
            extendedBounds: {},
            field: "string",
            filter: "string",
            filtersSpec: {},
            from: integer,
            include: "string",
            interval: "string",
            maxDocCount: integer,
            minDocCount: integer,
            missing: "string",
            name: "string",
            percents: [],
            q: "string",
            ranges: [],
            size: integer,
            sort: "string",
            subAggregates: [],
            timeZone: "string",
            type: "string"
          }],
        timeZone: "string",
        type: "string"
      }],
    timeZone: "string",
    type: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::quarantine_api::get_aggregate_files;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::MsaAggregateQueryRequest;

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

    let body = MsaAggregateQueryRequest {
        date_ranges: vec![DateRangeSpec {
            from: Some("string".to_string()),
            to: Some("string".to_string()),
            ..Default::default()
        }],
        exclude: Some("string".to_string()),
        field: Some("string".to_string()),
        filter: Some("string".to_string()),
        filters_spec: Default::default(),
        from: Some(integer),
        include: Some("string".to_string()),
        interval: Some("string".to_string()),
        missing: Some("string".to_string()),
        name: Some("string".to_string()),
        percents: vec![],
        q: Some("string".to_string()),
        ranges: vec![RangeSpec {
            from: Some(integer),
            to: Some(integer),
            ..Default::default()
        }],
        size: Some(integer),
        sort: Some("string".to_string()),
        sub_aggregates: vec![AggregateQueryRequest {
            date_ranges: vec![DateRangeSpec {
                from: Some("string".to_string()),
                to: Some("string".to_string()),
                ..Default::default()
            }],
            exclude: Some("string".to_string()),
            field: Some("string".to_string()),
            filter: Some("string".to_string()),
            filters_spec: Default::default(),
            from: Some(integer),
            include: Some("string".to_string()),
            interval: Some("string".to_string()),
            missing: Some("string".to_string()),
            name: Some("string".to_string()),
            percents: vec![],
            q: Some("string".to_string()),
            ranges: vec![RangeSpec {
                from: Some(integer),
                to: Some(integer),
                ..Default::default()
            }],
            size: Some(integer),
            sort: Some("string".to_string()),
            sub_aggregates: vec![AggregateQueryRequest {
                date_ranges: vec![],
                exclude: Some("string".to_string()),
                field: Some("string".to_string()),
                filter: Some("string".to_string()),
                filters_spec: Default::default(),
                from: Some(integer),
                include: Some("string".to_string()),
                interval: Some("string".to_string()),
                missing: Some("string".to_string()),
                name: Some("string".to_string()),
                percents: vec![],
                q: Some("string".to_string()),
                ranges: vec![],
                size: Some(integer),
                sort: Some("string".to_string()),
                sub_aggregates: vec![],
                time_zone: Some("string".to_string()),
                type: Some("string".to_string()),
                ..Default::default()
            }],
            time_zone: Some("string".to_string()),
            type: Some("string".to_string()),
            ..Default::default()
        }],
        time_zone: Some("string".to_string()),
        type: Some("string".to_string()),
        ..Default::default()
    };

    let response = get_aggregate_files(
        &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::Quarantine.new

body = Falcon::MsaAggregateQueryRequest.new(
  date_ranges: [{
      from: 'string',
      to: 'string'
    }],
  exclude: 'string',
  extended_bounds: {
    max: 'string',
    min: 'string'
  },
  field: 'string',
  filter: 'string',
  filters_spec: {
    filters: {},
    other_bucket: boolean,
    other_bucket_key: 'string'
  },
  from: integer,
  include: 'string',
  interval: 'string',
  max_doc_count: integer,
  min_doc_count: integer,
  missing: 'string',
  name: 'string',
  percents: [],
  q: 'string',
  ranges: [{
      From: integer,
      To: integer
    }],
  size: integer,
  sort: 'string',
  sub_aggregates: [{
      date_ranges: [{
          from: 'string',
          to: 'string'
        }],
      exclude: 'string',
      extended_bounds: {
        max: 'string',
        min: 'string'
      },
      field: 'string',
      filter: 'string',
      filters_spec: {
        filters: {},
        other_bucket: boolean,
        other_bucket_key: 'string'
      },
      from: integer,
      include: 'string',
      interval: 'string',
      max_doc_count: integer,
      min_doc_count: integer,
      missing: 'string',
      name: 'string',
      percents: [],
      q: 'string',
      ranges: [{
          From: integer,
          To: integer
        }],
      size: integer,
      sort: 'string',
      sub_aggregates: [{
          date_ranges: [],
          exclude: 'string',
          extended_bounds: {},
          field: 'string',
          filter: 'string',
          filters_spec: {},
          from: integer,
          include: 'string',
          interval: 'string',
          max_doc_count: integer,
          min_doc_count: integer,
          missing: 'string',
          name: 'string',
          percents: [],
          q: 'string',
          ranges: [],
          size: integer,
          sort: 'string',
          sub_aggregates: [],
          time_zone: 'string',
          type: 'string'
        }],
      time_zone: 'string',
      type: 'string'
    }],
  time_zone: 'string',
  type: 'string'
)

response = api.get_aggregate_files(body)

puts response

Responses

[
  {
    "buckets": [],
    "doc_count_error_upper_bound": 0,
    "hits": {},
    "name": "string",
    "sum_other_doc_count": 0
  }
]

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

GetQuarantineFiles

Get quarantine file metadata for specified ids.

Method POST

Route /quarantine/entities/quarantined-files/GET/v1

Scope Quarantined Files: READ

PEP 8 get_quarantine_files

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

ids body · array

List of quarantine IDs to retrieve metadata for.

Code Examples

from falconpy import Quarantine

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

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

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

from falconpy import Quarantine

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

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

response = falcon.GetQuarantineFiles(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']

body_payload = {
    "ids": ["string"]
}

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

Get-FalconQuarantine -Id @("ID1", "ID2")

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/quarantine"
  "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)
  }

  response, err := client.Quarantine.GetQuarantineFiles(
    &quarantine.GetQuarantineFilesParams{
      Body: &models.MsaIdsRequest{
        Ids: []string{"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.quarantine.getQuarantineFiles(
  {
    ids: []
}  // body
);

console.log(response);

use rusty_falcon::apis::quarantine_api::get_quarantine_files;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::MsaIdsRequest;

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

    let body = MsaIdsRequest {
        ids: vec!["string".to_string()],
        ..Default::default()
    };

    let response = get_quarantine_files(
        &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::Quarantine.new

body = Falcon::MsaIdsRequest.new(
  ids: []
)

response = api.get_quarantine_files(body)

puts response

Responses

[
  {
    "aid": "string",
    "alert_ids": [],
    "cid": "string",
    "date_created": "string",
    "date_updated": "string",
    "detect_ids": [],
    "extracted": false,
    "hostname": "string",
    "id": "string",
    "is_on_removable_disk": false,
    "paths": [],
    "primary_module": false,
    "release_path_for_removable_media": "string",
    "sandbox_report_id": "string",
    "sandbox_report_state": "string",
    "sha256": "string",
    "state": "string",
    "username": "string"
  }
]

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

QueryQuarantineFiles

Get quarantine file ids that match the provided filter criteria.

Method GET

Route /quarantine/queries/quarantined-files/v1

Scope Quarantined Files: READ

PEP 8 query_quarantine_files

Parameters

offset query · string

Starting index of overall result set from which to return ids.

limit query · integer

Number of ids to return.

sort query · string

Possible order by fields:

Available values (7)

`hostname`	`username`	`date_updated`
`date_created`	`paths.path`	`state`
`paths.state`

filter query · string

FQL query specifying the filter parameters. Special value * means to not filter on anything. Filter term criteria:

Available values (14)

`status`	`adversary_id`	`device.device_id`
`device.country`	`device.hostname`	`behaviors.behavior_id`
`behaviors.ioc_type`	`behaviors.ioc_value`	`behaviors.username`
`behaviors.tree_root_hash`	`max_severity`	`max_confidence`
`first_behavior`	`last_behavior`

q query · string

Match phrase_prefix query criteria; included fields: _all (all filter string fields), sha256, state, paths.path, paths.state, hostname, username, date_updated, date_created.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

Code Examples

from falconpy import Quarantine

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

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

from falconpy import Quarantine

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

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

from falconpy import APIHarnessV2

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

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

Get-FalconQuarantine -Filter "string" `
  -Query "string" `
  -Sort "string" `
  -Limit integer `
  -Offset integer

package main

import (
  "context"
  "fmt"
  "os"

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

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)
  }

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

  response, err := client.Quarantine.QueryQuarantineFiles(
    &quarantine.QueryQuarantineFilesParams{
      Offset: &offset,
      Limit: &limit,
      Sort: &sort,
      Filter: &filter,
      Q: &q,
      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.quarantine.queryQuarantineFiles(
  "string",  // offset
  integer,  // limit
  "string",  // sort
  "string",  // filter
  "string"  // q
);

console.log(response);

use rusty_falcon::apis::quarantine_api::query_quarantine_files;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = query_quarantine_files(
        &falcon.cfg,  // configuration
        Some("string"),  // offset
        Some(integer),  // limit
        Some("string"),  // sort
        Some("string"),  // filter
        Some("string"),  // q
    ).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::Quarantine.new

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

puts response

Responses

[
  "string"
]

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

UpdateQfByQuery

Apply quarantine file actions by query.

Method PATCH

Route /quarantine/queries/quarantined-files/v1

Scope Quarantined Files: WRITE

PEP 8 update_quarantined_detects_by_query

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

action body · string

Action to perform against the quarantined file. Allowed values:

Available values (3)

release unrelease delete

comment body · string

Comment to list along with action taken.

filter body · string

q body · string

ids body · string or list of strings

List of quarantine IDs to perform an action on.

Code Examples

from falconpy import Quarantine

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

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

response = falcon.update_quarantined_detects_by_query(action="string",
                                                      comment="string",
                                                      ids=id_list)
print(response)

from falconpy import Quarantine

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

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

response = falcon.UpdateQfByQuery(action="string",
                                  comment="string",
                                  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']

body_payload = {
    "action": "string",
    "comment": "string",
    "filter": "string",
    "q": "string"
}

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

Invoke-FalconQuarantineAction -Action "string" `
  -Filter "string" `
  -Query "string"

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/quarantine"
  "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)
  }

  action := "string"
  comment := "string"
  filter := "string"
  q := "string"

  response, err := client.Quarantine.UpdateQfByQuery(
    &quarantine.UpdateQfByQueryParams{
      Body: &models.DomainQueriesPatchRequest{
        Action: &action,
        Comment: &comment,
        Filter: &filter,
        Q: &q,
      },
      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.quarantine.updateQfByQuery(
  {
    action: "string",
    comment: "string",
    filter: "string",
    q: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::quarantine_api::update_qf_by_query;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::DomainQueriesPatchRequest;

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

    let body = DomainQueriesPatchRequest {
        ..Default::default()
    };

    let response = update_qf_by_query(
        &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::Quarantine.new

body = Falcon::DomainQueriesPatchRequest.new(
  action: 'string',
  comment: 'string',
  filter: 'string',
  q: 'string'
)

response = api.update_qf_by_query(body)

puts response

Responses

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

UpdateQuarantinedDetectsByIds

Apply action by quarantine file ids

Method PATCH

Route /quarantine/entities/quarantined-files/v1

Scope Quarantined Files: WRITE

PEP 8 update_quarantined_detects_by_id

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

action body · string

Action to perform against the quarantined file. Allowed values:

Available values (3)

release unrelease delete

comment body · string

Comment to list along with action taken.

ids body · array

List of quarantine IDs to perform an action on.

Code Examples

from falconpy import Quarantine

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

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

response = falcon.update_quarantined_detects_by_id(action="string",
                                                   comment="string",
                                                   ids=id_list)
print(response)

from falconpy import Quarantine

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

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

response = falcon.UpdateQuarantinedDetectsByIds(action="string",
                                                comment="string",
                                                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']

body_payload = {
    "action": "string",
    "comment": "string",
    "ids": ["string"]
}

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

Invoke-FalconQuarantineAction -Action "string" -Id @("ID1", "ID2")

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/quarantine"
  "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)
  }

  action := "string"
  comment := "string"

  response, err := client.Quarantine.UpdateQuarantinedDetectsByIds(
    &quarantine.UpdateQuarantinedDetectsByIdsParams{
      Body: &models.DomainEntitiesPatchRequest{
        Action: &action,
        Comment: &comment,
        Ids: []string{"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.quarantine.updateQuarantinedDetectsByIds(
  {
    action: "string",
    comment: "string",
    ids: []
}  // body
);

console.log(response);

use rusty_falcon::apis::quarantine_api::update_quarantined_detects_by_ids;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::DomainEntitiesPatchRequest;

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

    let body = DomainEntitiesPatchRequest {
        ..Default::default()
    };

    let response = update_quarantined_detects_by_ids(
        &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::Quarantine.new

body = Falcon::DomainEntitiesPatchRequest.new(
  action: 'string',
  comment: 'string',
  ids: []
)

response = api.update_quarantined_detects_by_ids(body)

puts response

Responses

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

Quarantine

Table of Contents

ActionUpdateCount

Parameters

GetAggregateFiles

Parameters

GetQuarantineFiles

Parameters

QueryQuarantineFiles

Parameters

UpdateQfByQuery

Parameters

UpdateQuarantinedDetectsByIds

Parameters