feat(harfanglab): HarfangLab EDR integration (71 analyst commands)

Endpoint management & isolation, policy assignment, IOC & whitelist (threat
intelligence), security-event triage, telemetry hunting (processes, network,
DNS, authentications, event logs, binaries), hash threat hunting, and forensic
collection jobs (pipes, prefetch, run keys, scheduled tasks, drivers, services,
processes, network, sessions, WMI, IOC scan, artifacts, RAM dump) plus their
result-retrieval commands. Script-based (urllib, INTEGRATION_SECRETS/INPUTS
contract; Authorization: Token header). Platform-specific XSOAR mirroring/fetch
commands intentionally excluded.

integrations/harfanglab/manifest.yaml

@@ -0,0 +1,700 @@
+id: harfanglab
+name: HarfangLab EDR
+version: 1.0.0
+description: "HarfangLab EDR — endpoint detection & response: endpoint enrichment, isolation, threat-intelligence (IOC/whitelist), telemetry hunting and forensic collection jobs."
+changelog: "1.0.0 — Initial release: endpoint/agent management, isolation, policy assignment, IOC & whitelist management, security-event triage, telemetry hunting (processes, network, DNS, authentications, binaries, event logs), threat hunting by hash, and forensic collection jobs (pipes, prefetch, run keys, scheduled tasks, drivers, services, processes, network, sessions, WMI, IOC scan, artifacts, RAM dump) with their result retrieval commands. Compatible with HarfangLab EDR 2.13.7+."
+category: endpoint
+
+# Per-instance configuration. Scripts use <url> as the API base and call /api/... paths.
+config_schema:
+  properties:
+    url:
+      type: string
+      description: HarfangLab EDR Manager URL, e.g. https://my-edr.example.com
+    api_token:
+      type: string
+      description: API key (HarfangLab EDR → user settings → API key)
+      x-soar-sensitive: true
+  required:
+    - url
+    - api_token
+
+# Documented for reference; the bundled scripts build the header themselves
+# (Authorization: Token <token>).
+auth:
+  - id: apitoken
+    type: api_key
+    in: header
+    name: Authorization
+    value_template: "Token {{secret}}"
+    secret_field: api_token
+
+commands:
+  # ── Endpoints / agents ────────────────────────────────────────────────────
+  - id: get_endpoint_info
+    name: Get endpoint info
+    description: Get endpoint (agent) information by agent ID.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: endpoint_search
+    name: Endpoint search
+    description: Search endpoints (agents) by hostname.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Hostname to filter agents by" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: isolate_endpoint
+    name: Isolate endpoint
+    description: Network-isolate an endpoint (agent) by agent ID.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: deisolate_endpoint
+    name: Deisolate endpoint
+    description: Remove network isolation from an endpoint (agent) by agent ID.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: assign_policy_to_agent
+    name: Assign policy to agent
+    description: Assign a security policy to an agent by policy name and agent ID.
+    inputs_schema:
+      properties:
+        policy: { type: string, description: "Name of the policy to assign" }
+        agentid: { type: string, description: "Agent unique identifier to assign the policy to" }
+      required: [policy, agentid]
+    outputs_schema: { properties: {} }
+
+  # ── Threat intelligence: whitelists ───────────────────────────────────────
+  - id: whitelist_search
+    name: Search whitelists
+    description: Search threat-intelligence whitelists by keyword.
+    inputs_schema:
+      properties:
+        keyword: { type: string, description: "Keyword to search" }
+        provided_by_hlab: { type: boolean, description: "Search HarfangLab-provided whitelists" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: whitelist_add
+    name: Add whitelist
+    description: Create a threat-intelligence whitelist rule with an initial criterion.
+    inputs_schema:
+      properties:
+        comment: { type: string, description: "Whitelist comment" }
+        target: { type: string, description: "Whitelist target (e.g. all)" }
+        sigma_rule_id: { type: string, description: "Associated sigma rule id" }
+        field: { type: string, description: "Criterion field" }
+        case_insensitive: { type: boolean, description: "Match field value case-insensitively" }
+        operator: { type: string, description: "Criterion operator (e.g. eq)" }
+        value: { type: string, description: "Criterion value" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: whitelist_add_criterion
+    name: Add whitelist criterion
+    description: Append a criterion to an existing whitelist rule.
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Whitelist rule id" }
+        field: { type: string, description: "Criterion field" }
+        case_insensitive: { type: boolean, description: "Match field value case-insensitively" }
+        operator: { type: string, description: "Criterion operator (e.g. eq)" }
+        value: { type: string, description: "Criterion value" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: whitelist_delete
+    name: Delete whitelist
+    description: Delete a threat-intelligence whitelist rule by id.
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Whitelist rule id" }
+      required: [id]
+    outputs_schema: { properties: {} }
+
+  # ── Threat intelligence: IOCs ─────────────────────────────────────────────
+  - id: add_ioc_to_source
+    name: Add IOC to source
+    description: Add an IOC to a named IOC source if it does not already exist.
+    inputs_schema:
+      properties:
+        ioc_value: { type: string, description: "IOC value" }
+        ioc_type: { type: string, description: "IOC type" }
+        ioc_comment: { type: string, description: "IOC comment" }
+        ioc_status: { type: string, description: "IOC status (e.g. testing, detection, blocking)" }
+        source_name: { type: string, description: "IOC source name" }
+      required: [ioc_value, ioc_type, ioc_status, source_name]
+    outputs_schema: { properties: {} }
+  - id: delete_ioc_from_source
+    name: Delete IOC from source
+    description: Remove an IOC from a named IOC source if it exists.
+    inputs_schema:
+      properties:
+        ioc_value: { type: string, description: "IOC value" }
+        source_name: { type: string, description: "IOC source name" }
+      required: [ioc_value, source_name]
+    outputs_schema: { properties: {} }
+
+  # ── Security events ───────────────────────────────────────────────────────
+  - id: change_security_event_status
+    name: Change security event status
+    description: "Change the status of a security event (New, Investigating, False Positive, Closed)."
+    inputs_schema:
+      properties:
+        security_event_id: { type: string, description: "Security event ID" }
+        status: { type: string, description: "New | Investigating | False Positive | Closed" }
+      required: [security_event_id, status]
+    outputs_schema: { properties: {} }
+
+  # ── Generic / utility ─────────────────────────────────────────────────────
+  - id: api_call
+    name: API call
+    description: "Perform a generic authenticated call to the HarfangLab API."
+    inputs_schema:
+      properties:
+        api_method: { type: string, description: "HTTP method (GET, POST, PUT, DELETE, PATCH)" }
+        api_endpoint: { type: string, description: "API endpoint path beginning with /api/" }
+        parameters: { type: string, description: "Query string parameters in key=value&key=value form" }
+        data: { type: string, description: "JSON-encoded request body" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_process_graph
+    name: Telemetry process graph
+    description: "Retrieve the process graph for a telemetry process UUID."
+    inputs_schema:
+      properties:
+        process_uuid: { type: string, description: "Telemetry process UUID" }
+      required: [process_uuid]
+    outputs_schema: { properties: {} }
+
+  # ── Threat hunting by hash ────────────────────────────────────────────────
+  - id: hunt_search_hash
+    name: Hunt search hash
+    description: "Search the data explorer for a file hash."
+    inputs_schema:
+      properties:
+        hash: { type: string, description: "File hash to search for" }
+      required: [hash]
+    outputs_schema: { properties: {} }
+  - id: hunt_search_running_process_hash
+    name: Hunt search running process by hash
+    description: "Hunt for currently running processes matching a SHA-256 hash."
+    inputs_schema:
+      properties:
+        hash: { type: string, description: "SHA-256 hash to search for" }
+      required: [hash]
+    outputs_schema: { properties: {} }
+  - id: hunt_search_runned_process_hash
+    name: Hunt search runned process by hash
+    description: "Search process telemetry for executions matching a SHA-256 hash."
+    inputs_schema:
+      properties:
+        hash: { type: string, description: "SHA-256 hash to search for" }
+      required: [hash]
+    outputs_schema: { properties: {} }
+
+  # ── Telemetry ─────────────────────────────────────────────────────────────
+  - id: telemetry_processes
+    name: Telemetry — processes
+    description: Search process telemetry.
+    inputs_schema:
+      properties:
+        hash: { type: string, description: "File hash (md5, sha1 or sha256)" }
+        hostname: { type: string, description: "Endpoint hostname" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_dns
+    name: Telemetry — DNS resolution
+    description: Search DNS resolution telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        requested_name: { type: string, description: "Requested DNS name" }
+        query_type: { type: string, description: "DNS query type" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_network
+    name: Telemetry — network
+    description: Search network connection telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        source_address: { type: string, description: "Source IP address" }
+        source_port: { type: number, description: "Source port" }
+        destination_address: { type: string, description: "Destination IP address" }
+        destination_port: { type: number, description: "Destination port" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_eventlog
+    name: Telemetry — event log
+    description: Search Windows full event log telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        event_id: { type: number, description: "Windows event ID" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_binary
+    name: Telemetry — binary
+    description: Search binary telemetry.
+    inputs_schema:
+      properties:
+        hash: { type: string, description: "File hash (md5, sha1 or sha256)" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_authentication_windows
+    name: Telemetry — Windows authentication
+    description: Search Windows authentication telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        source_address: { type: string, description: "Source IP address" }
+        success: { type: boolean, description: "Authentication success" }
+        source_username: { type: string, description: "Source username" }
+        target_username: { type: string, description: "Target username" }
+        logon_title: { type: string, description: "Windows logon title" }
+        logon_type: { type: number, description: "Windows logon type" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_authentication_linux
+    name: Telemetry — Linux authentication
+    description: Search Linux authentication telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        source_address: { type: string, description: "Source IP address" }
+        success: { type: boolean, description: "Authentication success" }
+        source_username: { type: string, description: "Source username" }
+        target_username: { type: string, description: "Target username" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_authentication_macos
+    name: Telemetry — macOS authentication
+    description: Search macOS authentication telemetry.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        source_address: { type: string, description: "Source IP address" }
+        success: { type: boolean, description: "Authentication success" }
+        source_username: { type: string, description: "Source username" }
+        target_username: { type: string, description: "Target username" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max elements (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: telemetry_authentication_users
+    name: Telemetry — top authenticating users
+    description: Rank users by authentication attempts across Windows, Linux and macOS.
+    inputs_schema:
+      properties:
+        hostname: { type: string, description: "Endpoint hostname" }
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        limit: { type: number, description: "Max users to return (default 3)" }
+      required: [hostname]
+    outputs_schema: { properties: {} }
+
+  # ── Collection jobs ───────────────────────────────────────────────────────
+  - id: job_pipelist
+    name: Job — list pipes
+    description: Start a job to list named pipes on a host (Windows).
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_prefetchlist
+    name: Job — list prefetch
+    description: Start a job to collect Windows prefetch files on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_runkeylist
+    name: Job — list run keys
+    description: Start a job to collect registry run keys (hives) on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_scheduledtasklist
+    name: Job — list scheduled tasks
+    description: Start a job to list scheduled tasks on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_driverlist
+    name: Job — list drivers
+    description: Start a job to list loaded drivers on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_servicelist
+    name: Job — list services
+    description: Start a job to collect services from registry hives on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_processlist
+    name: Job — list processes
+    description: Start a job to list running processes with signature info on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_networkconnectionlist
+    name: Job — list network connections
+    description: Start a job to list processes with their active network connections on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_networksharelist
+    name: Job — list network shares
+    description: Start a job to list network shares on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_sessionlist
+    name: Job — list sessions
+    description: Start a job to list active user sessions on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_persistencelist
+    name: Job — list persistence
+    description: Start a job to scan for persistence mechanisms on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_startuplist
+    name: Job — list startup files
+    description: Start a job to list startup files on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_wmilist
+    name: Job — list WMI
+    description: Start a job to collect WMI persistence artifacts on a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_ioc
+    name: Job — IOC scan
+    description: Start an IOC scan job on a host using filename, filepath, hash, registry, or regex indicators.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+        filename: { type: string, description: "Filename to search for" }
+        filepath: { type: string, description: "File path to search for" }
+        hash: { type: string, description: "File hash to search for (MD5, SHA-1 or SHA-256)" }
+        search_in_path: { type: string, description: "Restrict the search to this path" }
+        filesize: { type: string, description: "File size in bytes associated with the filename indicator" }
+        hash_filesize: { type: string, description: "File size in bytes associated with the hash indicator" }
+        registry: { type: string, description: "Registry key or value to search for" }
+        filepath_regex: { type: string, description: "Regular expression to match file paths" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_info
+    name: Job — get job info
+    description: Retrieve information for one or more jobs by their identifiers.
+    inputs_schema:
+      properties:
+        ids: { type: string, description: "Comma-separated list of job IDs to retrieve" }
+      required: [ids]
+    outputs_schema: { properties: {} }
+
+  # ── Forensic artifact collection jobs ─────────────────────────────────────
+  - id: job_artifact_mft
+    name: Job — collect MFT
+    description: Start a job to collect the NTFS Master File Table (MFT) from a host (Windows).
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_hives
+    name: Job — collect registry hives
+    description: Start a job to collect the Windows registry hives from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_evtx
+    name: Job — collect event logs
+    description: Start a job to collect the Windows event logs (EVTX) from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_logs
+    name: Job — collect system logs
+    description: Start a job to collect the system logs from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_filesystem
+    name: Job — collect filesystem listing
+    description: Start a job to collect the filesystem listing from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_all
+    name: Job — collect all raw evidence
+    description: Start a job to collect all raw forensic evidence (hives, event logs, MFT, prefetch, USN journal, logs, filesystem) from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_ramdump
+    name: Job — dump RAM
+    description: Start a job to capture a full memory (RAM) dump from a host.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+      required: [agent_id]
+    outputs_schema: { properties: {} }
+  - id: job_artifact_downloadfile
+    name: Job — download file
+    description: Start a job to download a specific file from a host by its full path.
+    inputs_schema:
+      properties:
+        agent_id: { type: string, description: "Agent unique identifier from the HarfangLab EDR Manager" }
+        filename: { type: string, description: "Full path of the file to download from the host" }
+      required: [agent_id, filename]
+    outputs_schema: { properties: {} }
+
+  # ── Job results (hunting) ─────────────────────────────────────────────────
+  - id: result_pipelist
+    name: Result — pipes
+    description: Get a host's list of named pipes from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_prefetchlist
+    name: Result — prefetch
+    description: Get a host's prefetch entries from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_runkeylist
+    name: Result — run keys
+    description: Get a host's registry run keys from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_scheduledtasklist
+    name: Result — scheduled tasks
+    description: Get a host's scheduled tasks from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_driverlist
+    name: Result — drivers
+    description: Get a host's list of drivers from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_servicelist
+    name: Result — services
+    description: Get a host's list of services from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_processlist
+    name: Result — processes
+    description: Get a host's list of running processes from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_networkconnectionlist
+    name: Result — network connections
+    description: Get a host's network connections from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_networksharelist
+    name: Result — network shares
+    description: Get a host's list of network shares from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_sessionlist
+    name: Result — sessions
+    description: Get a host's list of user sessions from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_persistencelist
+    name: Result — persistence
+    description: Get a host's persistence files from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_startuplist
+    name: Result — startup items
+    description: Get a host's startup items from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_wmilist
+    name: Result — WMI
+    description: Get a host's WMI persistence entries from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_ioc
+    name: Result — IOC matches
+    description: Get a host's IOC matches from a job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+
+  # ── Job results (forensic artifacts) ──────────────────────────────────────
+  - id: result_artifact_mft
+    name: Result — MFT artifact
+    description: Get the MFT download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_hives
+    name: Result — Registry hives artifact
+    description: Get the Windows registry hive download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_evtx
+    name: Result — EVTX artifact
+    description: Get the Windows event log (EVTX) download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_logs
+    name: Result — Linux logs artifact
+    description: Get the Linux system log download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_filesystem
+    name: Result — Filesystem artifact
+    description: Get the filesystem listing download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_all
+    name: Result — All artifacts
+    description: Get the download links for all collected artifacts from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_downloadfile
+    name: Result — Downloaded file artifact
+    description: Get the download link for a file retrieved by a download-file job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }
+  - id: result_artifact_ramdump
+    name: Result — RAM dump artifact
+    description: Get the memory (RAM) dump download links from a collection job result.
+    inputs_schema:
+      properties:
+        job_id: { type: string, description: "Job ID returned by the matching artifact job command" }
+      required: [job_id]
+    outputs_schema: { properties: {} }

integrations/harfanglab/scripts/add_ioc_to_source.py

@@ -0,0 +1,72 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    source_name = inputs.get("source_name")
+    ioc_value = inputs.get("ioc_value")
+    ioc_type = inputs.get("ioc_type")
+    ioc_status = inputs.get("ioc_status")
+
+    sources = request("GET", base + "/api/data/threat_intelligence/IOCSource/" + qs({"search": source_name}), headers)
+    sid = None
+    for s in sources.get("results", []):
+        if s.get("name") == source_name:
+            sid = s.get("id")
+
+    existing = request("GET", base + "/api/data/threat_intelligence/IOCRule/" + qs({"source_id": sid, "search": ioc_value}), headers)
+    if existing.get("count", 0) > 0:
+        print(json.dumps({"message": "IOC " + str(ioc_value) + " already exists in source " + str(source_name)}))
+        return
+
+    testing_status = "in_progress" if ioc_status == "testing" else None
+    body = {
+        "type": ioc_type,
+        "value": ioc_value,
+        "comment": inputs.get("ioc_comment", ""),
+        "source_id": sid,
+        "hl_status": ioc_status,
+        "hl_local_testing_status": testing_status,
+    }
+    out = request("POST", base + "/api/data/threat_intelligence/IOCRule/", headers, body)
+    print(json.dumps(out))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/api_call.py

@@ -0,0 +1,60 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    method = str(inputs.get("api_method", "GET")).upper()
+    endpoint = inputs.get("api_endpoint", "/api/version")
+    params = {}
+    raw = inputs.get("parameters")
+    if raw:
+        for tok in str(raw).split("&"):
+            kv = tok.split("=", 1)
+            if len(kv) == 2:
+                params[kv[0]] = kv[1]
+    body = None
+    if inputs.get("data"):
+        body = json.loads(inputs.get("data"))
+    url = base + endpoint + qs(params)
+    print(json.dumps(request(method, url, headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/assign_policy_to_agent.py

@@ -0,0 +1,59 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    policy = inputs.get("policy")
+    agentid = inputs.get("agentid")
+    res = request("GET", base + "/api/data/endpoint/Policy/" + qs({"search": policy}), headers)
+    pid = None
+    for p in res.get("results", []):
+        if p.get("name") == policy:
+            pid = p.get("id")
+            break
+    if pid is not None:
+        out = request("POST", base + "/api/data/endpoint/Policy/" + str(pid) + "/add_agents/", headers, {"agent_ids": [agentid]})
+        print(json.dumps({"message": "Policy " + str(policy) + " assigned to agent " + str(agentid), "result": out}))
+    else:
+        print(json.dumps({"error": "Unknown policy " + str(policy)}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/change_security_event_status.py

@@ -0,0 +1,60 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    eid = inputs.get("security_event_id")
+    status = str(inputs.get("status", "")).lower()
+    m = {
+        "new": "new",
+        "investigating": "investigating",
+        "false positive": "false_positive",
+        "closed": "closed",
+    }
+    new_status = m.get(status, status)
+    ids = eid if isinstance(eid, list) else [eid]
+    body = {"ids": ids, "new_status": new_status}
+    url = base + "/api/data/alert/alert/Alert/tag/"
+    result = request("POST", url, headers, body)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/deisolate_endpoint.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/endpoint/Agent/" + str(inputs.get("agent_id")) + "/deisolate/"
+    result = request("POST", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/delete_ioc_from_source.py

@@ -0,0 +1,61 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    source_name = inputs.get("source_name")
+    ioc_value = inputs.get("ioc_value")
+
+    sources = request("GET", base + "/api/data/threat_intelligence/IOCSource/" + qs({"search": source_name}), headers)
+    sid = None
+    for s in sources.get("results", []):
+        if s.get("name") == source_name:
+            sid = s.get("id")
+
+    existing = request("GET", base + "/api/data/threat_intelligence/IOCRule/" + qs({"source_id": sid, "search": ioc_value}), headers)
+    if existing.get("count", 0) > 0:
+        ioc_id = str(existing["results"][0]["id"])
+        request("DELETE", base + "/api/data/threat_intelligence/IOCRule/" + ioc_id + "/", headers)
+        print(json.dumps({"message": "IOC " + str(ioc_value) + " removed from source " + str(source_name)}))
+    else:
+        print(json.dumps({"message": "IOC " + str(ioc_value) + " does not exist in source " + str(source_name)}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/endpoint_search.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/endpoint/Agent/" + qs({"hostname": inputs.get("hostname"), "limit": 10000, "offset": 0})
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/get_endpoint_info.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/endpoint/Agent/" + str(inputs.get("agent_id")) + "/"
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/hunt_search_hash.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/search/Search/explorer_with_list/" + qs({"values": inputs.get("hash"), "type": "hash"})
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/hunt_search_runned_process_hash.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/telemetry/Processes/" + qs({"hashes.sha256": inputs.get("hash")})
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/hunt_search_running_process_hash.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/investigation/hunting/Process/" + qs({"binaryinfo.binaryinfo.sha256": inputs.get("hash")})
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/isolate_endpoint.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/endpoint/Agent/" + str(inputs.get("agent_id")) + "/isolate/"
+    result = request("POST", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_all.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": True, "evt": True, "mft": True, "prefetch": True, "usn": True, "logs": True, "fs": True}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_downloadfile.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "downloadFile", "params": {"filename": inputs.get("filename")}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_evtx.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": False, "evt": True, "mft": False, "prefetch": False, "usn": False, "logs": False, "fs": False}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_filesystem.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": False, "evt": False, "mft": False, "prefetch": False, "usn": False, "logs": False, "fs": True}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_hives.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": True, "evt": False, "mft": False, "prefetch": False, "usn": False, "logs": False, "fs": False}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_logs.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": False, "evt": False, "mft": False, "prefetch": False, "usn": False, "logs": True, "fs": False}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_mft.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "collectRAWEvidences", "params": {"hives": False, "evt": False, "mft": True, "prefetch": False, "usn": False, "logs": False, "fs": False}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_artifact_ramdump.py

@@ -0,0 +1,50 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "targets": {"agents": [inputs.get("agent_id")]},
+        "actions": [{"value": "memoryDumper", "params": {}}],
+    }
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_driverlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getLoadedDriverList", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_info.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    out = []
+    for jid in csv(inputs.get("ids")):
+        out.append(request("GET", base + "/api/data/Job/" + jid, headers))
+    print(json.dumps(out))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_ioc.py

@@ -0,0 +1,66 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    size = None
+    if inputs.get("filesize"):
+        size = int(inputs.get("filesize"))
+    elif inputs.get("hash_filesize"):
+        size = int(inputs.get("hash_filesize"))
+    values = []
+    if inputs.get("filename"):
+        values.append({"global": False, "size": size, "type": "filename", "value": inputs.get("filename")})
+    if inputs.get("filepath"):
+        values.append({"global": False, "type": "filepath", "value": inputs.get("filepath")})
+    if inputs.get("hash"):
+        values.append({"global": False, "size": size, "type": "hash", "value": inputs.get("hash")})
+    if inputs.get("registry"):
+        values.append({"global": False, "type": "registry", "value": inputs.get("registry")})
+    if inputs.get("filepath_regex"):
+        values.append({"global": False, "type": "regex", "value": inputs.get("filepath_regex")})
+    if values and inputs.get("search_in_path"):
+        values.append({"global": True, "type": "path", "value": inputs.get("search_in_path")})
+    PARAMS = {"values": values}
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "IOCScan", "params": PARAMS}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_networkconnectionlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getProcessList", "params": {"getConnectionsList": True, "getHandlesList": False, "getSignaturesInfo": True}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_networksharelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getNetworkShare", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_persistencelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "persistanceScanner", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_pipelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getPipeList", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_prefetchlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getPrefetch", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_processlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getProcessList", "params": {"getConnectionsList": False, "getHandlesList": False, "getSignaturesInfo": True}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_runkeylist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getHives", "params": {"bSystemHives": True, "bUsersHives": True, "bWantSlowPlugins": False}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_scheduledtasklist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getScheduledTasks", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_servicelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getHives", "params": {"bSystemHives": True, "bUsersHives": True, "bWantSlowPlugins": False}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_sessionlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getSessions", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_startuplist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getStartupFileList", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/job_wmilist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {"targets": {"agents": [inputs.get("agent_id")]}, "actions": [{"value": "getWMI", "params": {}}]}
+    print(json.dumps(request("POST", base + "/api/data/Job/", headers, body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_all.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_downloadfile.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_evtx.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_filesystem.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_hives.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_logs.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_mft.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_artifact_ramdump.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/artefact/Artefact/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_driverlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Driver/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_ioc.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/ioc/IOC/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_networkconnectionlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Process/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_networksharelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/NetworkShare/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_persistencelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/PersistanceFile/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_pipelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Pipe/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_prefetchlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Prefetch/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_processlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Process/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_runkeylist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/RunKey/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_scheduledtasklist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/ScheduledTaskXML/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_servicelist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Service/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_sessionlist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Session/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_startuplist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Startup/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/result_wmilist.py

@@ -0,0 +1,47 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    url = base + "/api/data/investigation/hunting/Wmi/" + qs({"limit": 10000, "job_id": inputs.get("job_id")})
+    print(json.dumps(request("GET", url, headers)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_authentication_linux.py

@@ -0,0 +1,58 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "source_address": inputs.get("source_address"),
+        "success": inputs.get("success"),
+        "source_username": inputs.get("source_username"),
+        "target_username": inputs.get("target_username"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/authentication/AuthenticationLinux/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_authentication_macos.py

@@ -0,0 +1,58 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "source_address": inputs.get("source_address"),
+        "success": inputs.get("success"),
+        "source_username": inputs.get("source_username"),
+        "target_username": inputs.get("target_username"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/authentication/AuthenticationMacos/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_authentication_users.py

@@ -0,0 +1,70 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    hostname = inputs.get("hostname")
+    fd = inputs.get("from_date")
+    td = inputs.get("to_date")
+    limit = int(inputs.get("limit") or 3)
+    counts = {}
+    for (system, path, extra) in [
+        ("windows", "/api/data/telemetry/authentication/AuthenticationWindows/", {"windows.logon_type": 2}),
+        ("linux", "/api/data/telemetry/authentication/AuthenticationLinux/", {}),
+        ("macos", "/api/data/telemetry/authentication/AuthenticationMacos/", {}),
+    ]:
+        params = {
+            "agent.hostname": hostname,
+            "@event_create_date__gte": fd,
+            "@event_create_date__lte": td,
+        }
+        params.update(extra)
+        data = request("GET", base + path + qs(params), headers)
+        for a in data.get("results", []):
+            u = a.get("target_username")
+            if u:
+                counts[(system, u)] = counts.get((system, u), 0) + 1
+    ranked = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)
+    out = [{"Username": u, "System": s, "Authentication attempts": c} for (s, u), c in ranked[:limit]]
+    print(json.dumps(out))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_authentication_windows.py

@@ -0,0 +1,60 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "source_address": inputs.get("source_address"),
+        "success": inputs.get("success"),
+        "source_username": inputs.get("source_username"),
+        "target_username": inputs.get("target_username"),
+        "windows.logon_title": inputs.get("logon_title"),
+        "windows.logon_type": inputs.get("logon_type"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/authentication/AuthenticationWindows/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_binary.py

@@ -0,0 +1,59 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    def hash_param(h):
+        n = len(h or "")
+        t = "sha256" if n == 64 else "sha1" if n == 40 else "md5" if n == 32 else None
+        return {("hashes." + t): h} if t else {}
+
+    params = {
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    params.update(hash_param(inputs.get("hash")))
+    result = request("GET", base + "/api/data/telemetry/Binary/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_dns.py

@@ -0,0 +1,56 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "requested_name": inputs.get("requested_name"),
+        "query_type": inputs.get("query_type"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/DNSResolution/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_eventlog.py

@@ -0,0 +1,55 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "event_id": inputs.get("event_id"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/FullEventLog/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_network.py

@@ -0,0 +1,58 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "saddr": inputs.get("source_address"),
+        "sport": inputs.get("source_port"),
+        "daddr": inputs.get("destination_address"),
+        "dport": inputs.get("destination_port"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    result = request("GET", base + "/api/data/telemetry/Network/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_process_graph.py

@@ -0,0 +1,49 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    # === per-command logic ===
+    url = base + "/api/data/telemetry/Processes/" + str(inputs.get("process_uuid")) + "/graph/"
+    result = request("GET", url, headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/telemetry_processes.py

@@ -0,0 +1,60 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    def hash_param(h):
+        n = len(h or "")
+        t = "sha256" if n == 64 else "sha1" if n == 40 else "md5" if n == 32 else None
+        return {("hashes." + t): h} if t else {}
+
+    params = {
+        "agent.hostname": inputs.get("hostname"),
+        "@event_create_date__gte": inputs.get("from_date"),
+        "@event_create_date__lte": inputs.get("to_date"),
+        "limit": int(inputs.get("limit") or 100),
+    }
+    params.update(hash_param(inputs.get("hash")))
+    result = request("GET", base + "/api/data/telemetry/Processes/" + qs(params), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/whitelist_add.py

@@ -0,0 +1,58 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    body = {
+        "comment": inputs.get("comment"),
+        "sigma_rule_id": inputs.get("sigma_rule_id", ""),
+        "target": inputs.get("target", "all"),
+        "criteria": [{
+            "case_insensitive": inputs.get("case_insensitive", True),
+            "field": inputs.get("field"),
+            "operator": inputs.get("operator", "eq"),
+            "value": inputs.get("value"),
+        }],
+    }
+    result = request("POST", base + "/api/data/threat_intelligence/WhitelistRule/", headers, body)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/whitelist_add_criterion.py

@@ -0,0 +1,56 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    wid = str(inputs.get("id"))
+    url = base + "/api/data/threat_intelligence/WhitelistRule/" + wid + "/"
+    data = request("GET", url, headers)
+    data.setdefault("criteria", []).append({
+        "case_insensitive": inputs.get("case_insensitive", True),
+        "field": inputs.get("field"),
+        "operator": inputs.get("operator", "eq"),
+        "value": inputs.get("value"),
+    })
+    out = request("PUT", url, headers, data)
+    print(json.dumps(out))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/whitelist_delete.py

@@ -0,0 +1,48 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    wid = str(inputs.get("id"))
+    request("DELETE", base + "/api/data/threat_intelligence/WhitelistRule/" + wid + "/", headers)
+    print(json.dumps({"message": "Whitelist " + wid + " deleted"}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/harfanglab/scripts/whitelist_search.py

@@ -0,0 +1,53 @@
+import json, os, sys, urllib.request, urllib.parse, urllib.error
+
+
+def request(method, url, headers, body=None):
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        raw = resp.read()
+        return json.loads(raw) if raw else {}
+
+
+def qs(params):
+    clean = {}
+    for k, v in params.items():
+        if v is None or v == "" or v == []:
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        clean[k] = v
+    return ("?" + urllib.parse.urlencode(clean)) if clean else ""
+
+
+def csv(v):
+    return [x.strip() for x in str(v or "").split(",") if x.strip()]
+
+
+def main():
+    secrets = json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    base = secrets.get("url", "").rstrip("/")
+    headers = {
+        "Authorization": "Token " + secrets.get("api_token", ""),
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+    result = request("GET", base + "/api/data/threat_intelligence/WhitelistRule/" + qs({
+        "offset": 0,
+        "limit": 100,
+        "search": inputs.get("keyword"),
+        "ordering": "-last_update",
+        "provided_by_hlab": inputs.get("provided_by_hlab", False),
+    }), headers)
+    print(json.dumps(result))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)