Network Scan Scans

Operations for the Network Scan Scans service collection.

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

Table of Contents

Operation	Description
aggregate_scansMixin0 aggregate_scans	Returns “scans” aggregations
get_scans get_scans	Get “scans” by their IDs
create_scans create_scans	Create “scans” using provided specifications
delete_scans delete_scans	Delete “scans” by their IDs
update_scans update_scans	Update “scans” using provided specifications
query_scansMixin0 query_scans	Get “scans IDs” by filter

---

aggregate_scansMixin0

Returns “scans” aggregations

POST /netscan/aggregates/scans/GET/v1

Scope Network Scan: READ Consumes · Produces application/json

PEP 8 aggregate_scans

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload as JSON formatted dictionary.
date_ranges	body	array
exclude	body	string
extended_bounds	body	object
field	body	string
filter	body	string
filters_spec	body	object
from	body	integer
include	body	string
interval	body	string
max_doc_count	body	integer
min_doc_count	body	integer
missing	body	string
name	body	string
percents	body	array
q	body	string
ranges	body	array
size	body	integer
sort	body	string
sub_aggregates	body	array
time_zone	body	string
type	body	string

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

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

response = falcon.aggregate_scans(date_ranges=[{"key": "value"}],
                                  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=[{"key": "value"}],
                                  size=integer,
                                  sort="string",
                                  sub_aggregates=[{"key": "value"}],
                                  time_zone="string",
                                  type="string")
print(response)

Operation ID

from falconpy import NetworkScanScans

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

response = falcon.aggregate_scansMixin0(date_ranges=[{"key": "value"}],
                                        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=[{"key": "value"}],
                                        size=integer,
                                        sort="string",
                                        sub_aggregates=[{"key": "value"}],
                                        time_zone="string",
                                        type="string")
print(response)

Uber

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": ["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"
    }
]

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

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/network_scan_scans"
  "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"
  type := "string"

  response, err := client.NetworkScanScans.AggregateScansMixin0(
    &network_scan_scans.AggregateScansMixin0Params{
      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: &type,
              },
            },
            TimeZone: &time_zone,
            Type: &type,
            },
          },
          TimeZone: &time_zone,
          Type: &type,
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.aggregateScansMixin0(
  [{
    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);

Rust

Examples coming soon.

Ruby

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::NetworkScanScans.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.aggregate_scans_mixin0(body)

puts response

---

get_scans

Get “scans” by their IDs

GET /netscan/entities/scans/v1

Scope Network Scan: READ Consumes · Produces application/json

PEP 8 get_scans

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	IDs of “scans” to be retrieved (Min: 1, Max: 100)

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

falcon = NetworkScanScans(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_scans(ids=id_list)
print(response)

Operation ID

from falconpy import NetworkScanScans

falcon = NetworkScanScans(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_scans(ids=id_list)
print(response)

Uber

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("get_scans",
                          ids=id_list)
print(response)

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

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

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.NetworkScanScans.GetScans(
    &network_scan_scans.GetScansParams{
      Ids: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.getScans(["ID1", "ID2", "ID3"]);  // ids

console.log(response);

Rust

use rusty_falcon::apis::quick_scan_api::get_scans;
use rusty_falcon::easy::client::FalconHandle;

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

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

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

Ruby

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::NetworkScanScans.new

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

puts response

---

create_scans

Create “scans” using provided specifications

POST /netscan/entities/scans/v1

Scope Network Scan: WRITE Consumes · Produces application/json

PEP 8 create_scans

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload as JSON formatted dictionary.
block_windows	body	object	Block Windows configuration attached to the scan
credentialed	body	boolean	Indicates if the scan is credentialed
credentials	body	object	The credentials for this scan
description	body	string	Description of the scan
fragile_device_detection	body	boolean	Indicates if the scan includes fragile-device detection
name	body	string	Name of the scan
scheduling	body	object	Scheduling configuration attached to the scan
target_asset	body	object	The target asset for this scan
target_asset_filter	body	object	The target asset filter for this scan
target_external_ip	body	object	The target external IP for this scan
target_ip	body	object	The target IP for this scan
target_type	body	string	The type of the target for this scan
template_id	body	string	Template identifier for the scan

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

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

response = falcon.create_scans(block_windows={},
                               credentialed=boolean,
                               credentials={},
                               description="string",
                               fragile_device_detection=boolean,
                               name="string",
                               scheduling={},
                               target_asset={},
                               target_asset_filter={},
                               target_external_ip={},
                               target_ip={},
                               target_type="string",
                               template_id="string")
print(response)

Operation ID

from falconpy import NetworkScanScans

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

response = falcon.create_scans(block_windows={},
                               credentialed=boolean,
                               credentials={},
                               description="string",
                               fragile_device_detection=boolean,
                               name="string",
                               scheduling={},
                               target_asset={},
                               target_asset_filter={},
                               target_external_ip={},
                               target_ip={},
                               target_type="string",
                               template_id="string")
print(response)

Uber

from falconpy import APIHarnessV2

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

body_payload = [
    {
        "block_windows": {
            "intervals": ["string"],
            "timezone": "string"
        },
        "credentialed": boolean,
        "credentials": {
            "auto_authorize_scanners": boolean,
            "ids": ["string"]
        },
        "description": "string",
        "fragile_device_detection": boolean,
        "name": "string",
        "scheduling": {
            "days_of_month": ["string"],
            "days_of_week": ["string"],
            "end_date": "string",
            "frequency": "string",
            "occurrence": "string",
            "start_date": "string",
            "start_time": "string",
            "timeout_seconds": integer,
            "timezone": "string"
        },
        "target_asset": {
            "ids": ["string"]
        },
        "target_asset_filter": {
            "fql_filter": "string"
        },
        "target_external_ip": {
            "ip_specs": ["string"]
        },
        "target_ip": {
            "ip_specs": ["string"],
            "zone_id": "string"
        },
        "target_type": "string",
        "template_id": "string"
    }
]

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

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

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

  credentialed := boolean
  description := "string"
  fragile_device_detection := boolean
  name := "string"
  target_type := "string"
  template_id := "string"

  response, err := client.NetworkScanScans.CreateScans(
    &network_scan_scans.CreateScansParams{
      Body: []*models.DomainScanCreateRequest{
        {
          BlockWindows: &struct{}{},
          Credentialed: &credentialed,
          Credentials: &struct{}{},
          Description: &description,
          FragileDeviceDetection: &fragile_device_detection,
          Name: &name,
          Scheduling: &struct{}{},
          TargetAsset: &struct{}{},
          TargetAssetFilter: &struct{}{},
          TargetExternalIp: &struct{}{},
          TargetIp: &struct{}{},
          TargetType: &target_type,
          TemplateID: &template_id,
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.createScans(
  [{
    blockWindows: {
      intervals: [{
          endTime: "string",
          startTime: "string"
        }],
      timezone: "string"
    },
    credentialed: boolean,
    credentials: {
      autoAuthorizeScanners: boolean,
      ids: []
    },
    description: "string",
    fragileDeviceDetection: boolean,
    name: "string",
    scheduling: {
      daysOfMonth: [],
      daysOfWeek: [],
      endDate: "string",
      frequency: "string",
      occurrence: "string",
      startDate: "string",
      startTime: "string",
      timeoutSeconds: integer,
      timezone: "string"
    },
    targetAsset: {
      ids: []
    },
    targetAssetFilter: {
      fqlFilter: "string"
    },
    targetExternalIp: {
      ipSpecs: []
    },
    targetIp: {
      ipSpecs: [],
      zoneId: "string"
    },
    targetType: "string",
    templateId: "string"
}]  // body
);

console.log(response);

Rust

Examples coming soon.

Ruby

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::NetworkScanScans.new

body = [Falcon::DomainScanCreateRequest.new(
  block_windows: {
    intervals: [{
        end_time: 'string',
        start_time: 'string'
      }],
    timezone: 'string'
  },
  credentialed: boolean,
  credentials: {
    auto_authorize_scanners: boolean,
    ids: []
  },
  description: 'string',
  fragile_device_detection: boolean,
  name: 'string',
  scheduling: {
    days_of_month: [],
    days_of_week: [],
    end_date: 'string',
    frequency: 'string',
    occurrence: 'string',
    start_date: 'string',
    start_time: 'string',
    timeout_seconds: integer,
    timezone: 'string'
  },
  target_asset: {
    ids: []
  },
  target_asset_filter: {
    fql_filter: 'string'
  },
  target_external_ip: {
    ip_specs: []
  },
  target_ip: {
    ip_specs: [],
    zone_id: 'string'
  },
  target_type: 'string',
  template_id: 'string'
)]

response = api.create_scans(body)

puts response

---

delete_scans

Delete “scans” by their IDs

DELETE /netscan/entities/scans/v1

Scope Network Scan: WRITE Consumes · Produces application/json

PEP 8 delete_scans

Parameters

Name	Type	Data type	Description
ids	query	string or list of strings	IDs of “scans” to be deleted (Min: 1, Max: 100)

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

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

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

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

Operation ID

from falconpy import NetworkScanScans

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

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

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

Uber

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("delete_scans",
                          ids=id_list)
print(response)

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

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

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.NetworkScanScans.DeleteScans(
    &network_scan_scans.DeleteScansParams{
      Ids: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.deleteScans(["ID1", "ID2", "ID3"]);  // ids

console.log(response);

Rust

Examples coming soon.

Ruby

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::NetworkScanScans.new

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

puts response

---

update_scans

Update “scans” using provided specifications

PATCH /netscan/entities/scans/v1

Scope Network Scan: WRITE Consumes · Produces application/json

PEP 8 update_scans

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload as JSON formatted dictionary.
block_windows	body	object	Block Windows configuration attached to the scan
credentialed	body	boolean	Indicates if the scan is credentialed
credentials	body	object	The credentials for this scan
description	body	string	Description of the scan
fragile_device_detection	body	boolean	Indicates if the scan includes fragile device detection
id	body	string	ID of the scan
name	body	string	Name of the scan
scheduling	body	object	Scheduling configuration attached to the scan
target_asset	body	object	The target asset associated with this scan
target_asset_filter	body	object	The target asset filter associated with this scan
target_external_ip	body	object	The target external IP associated with this scan
target_ip	body	object	The target IP associated with this scan
target_type	body	string	The type of the target scan
template_id	body	string	Template ID of the scan

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

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

response = falcon.update_scans(block_windows={},
                               credentialed=boolean,
                               credentials={},
                               description="string",
                               fragile_device_detection=boolean,
                               id="string",
                               name="string",
                               scheduling={},
                               target_asset={},
                               target_asset_filter={},
                               target_external_ip={},
                               target_ip={},
                               target_type="string",
                               template_id="string")
print(response)

Operation ID

from falconpy import NetworkScanScans

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

response = falcon.update_scans(block_windows={},
                               credentialed=boolean,
                               credentials={},
                               description="string",
                               fragile_device_detection=boolean,
                               id="string",
                               name="string",
                               scheduling={},
                               target_asset={},
                               target_asset_filter={},
                               target_external_ip={},
                               target_ip={},
                               target_type="string",
                               template_id="string")
print(response)

Uber

from falconpy import APIHarnessV2

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

body_payload = [
    {
        "block_windows": {
            "intervals": ["string"],
            "timezone": "string"
        },
        "credentialed": boolean,
        "credentials": {
            "auto_authorize_scanners": boolean,
            "ids": ["string"]
        },
        "description": "string",
        "fragile_device_detection": boolean,
        "id": "string",
        "name": "string",
        "scheduling": {
            "days_of_month": ["string"],
            "days_of_week": ["string"],
            "end_date": "string",
            "frequency": "string",
            "occurrence": "string",
            "start_date": "string",
            "start_time": "string",
            "timeout_seconds": integer,
            "timezone": "string"
        },
        "target_asset": {
            "ids": ["string"]
        },
        "target_asset_filter": {
            "fql_filter": "string"
        },
        "target_external_ip": {
            "ip_specs": ["string"]
        },
        "target_ip": {
            "ip_specs": ["string"],
            "zone_id": "string"
        },
        "target_type": "string",
        "template_id": "string"
    }
]

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

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

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

  credentialed := boolean
  description := "string"
  fragile_device_detection := boolean
  id := "string"
  name := "string"
  target_type := "string"
  template_id := "string"

  response, err := client.NetworkScanScans.UpdateScans(
    &network_scan_scans.UpdateScansParams{
      Body: []*models.DomainScanUpdateRequest{
        {
          BlockWindows: &struct{}{},
          Credentialed: &credentialed,
          Credentials: &struct{}{},
          Description: &description,
          FragileDeviceDetection: &fragile_device_detection,
          ID: &id,
          Name: &name,
          Scheduling: &struct{}{},
          TargetAsset: &struct{}{},
          TargetAssetFilter: &struct{}{},
          TargetExternalIp: &struct{}{},
          TargetIp: &struct{}{},
          TargetType: &target_type,
          TemplateID: &template_id,
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.updateScans(
  [{
    blockWindows: {
      intervals: [{
          endTime: "string",
          startTime: "string"
        }],
      timezone: "string"
    },
    credentialed: boolean,
    credentials: {
      autoAuthorizeScanners: boolean,
      ids: []
    },
    description: "string",
    fragileDeviceDetection: boolean,
    id: "string",
    name: "string",
    scheduling: {
      daysOfMonth: [],
      daysOfWeek: [],
      endDate: "string",
      frequency: "string",
      occurrence: "string",
      startDate: "string",
      startTime: "string",
      timeoutSeconds: integer,
      timezone: "string"
    },
    targetAsset: {
      ids: []
    },
    targetAssetFilter: {
      fqlFilter: "string"
    },
    targetExternalIp: {
      ipSpecs: []
    },
    targetIp: {
      ipSpecs: [],
      zoneId: "string"
    },
    targetType: "string",
    templateId: "string"
}]  // body
);

console.log(response);

Rust

Examples coming soon.

Ruby

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::NetworkScanScans.new

body = [Falcon::DomainScanUpdateRequest.new(
  block_windows: {
    intervals: [{
        end_time: 'string',
        start_time: 'string'
      }],
    timezone: 'string'
  },
  credentialed: boolean,
  credentials: {
    auto_authorize_scanners: boolean,
    ids: []
  },
  description: 'string',
  fragile_device_detection: boolean,
  id: 'string',
  name: 'string',
  scheduling: {
    days_of_month: [],
    days_of_week: [],
    end_date: 'string',
    frequency: 'string',
    occurrence: 'string',
    start_date: 'string',
    start_time: 'string',
    timeout_seconds: integer,
    timezone: 'string'
  },
  target_asset: {
    ids: []
  },
  target_asset_filter: {
    fql_filter: 'string'
  },
  target_external_ip: {
    ip_specs: []
  },
  target_ip: {
    ip_specs: [],
    zone_id: 'string'
  },
  target_type: 'string',
  template_id: 'string'
)]

response = api.update_scans(body)

puts response

---

query_scansMixin0

Get “scans IDs” by filter

GET /netscan/queries/scans/v1

Scope Network Scan: READ Consumes · Produces application/json

PEP 8 query_scans

Parameters

Name	Type	Data type	Description
offset	query	integer	An offset used with the limit parameter to manage pagination of results. On your first request, don’t provide an offset. On subsequent requests, add previous offset with the previous limit to continue from that place in the results
limit	query	integer	The number of “scans IDs” to return in this response (Min: 1, Max: 100, Default: 100)
sort	query	string	Sort “scans” by their properties. A single sort field is allowed
filter	query	string	Search for “scans” by providing an FQL filter

Code Examples

Python

PEP 8

from falconpy import NetworkScanScans

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

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

Operation ID

from falconpy import NetworkScanScans

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

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

Uber

from falconpy import APIHarnessV2

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

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

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

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

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 := int64(0)
  limit := int64(0)
  sort := "string"
  filter := "string"

  response, err := client.NetworkScanScans.QueryScansMixin0(
    &network_scan_scans.QueryScansMixin0Params{
      Offset: &offset,
      Limit: &limit,
      Sort: &sort,
      Filter: &filter,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

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

TypeScript

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.networkScanScans.queryScansMixin0(
  integer,  // offset
  integer,  // limit
  "string",  // sort
  "string"  // filter
);

console.log(response);

Rust

Examples coming soon.

Ruby

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::NetworkScanScans.new

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

puts response