> For the complete documentation index, see [llms.txt](https://docs.stepsecurity.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.stepsecurity.io/workspace/threat-center.md).

# Threat Center

{% hint style="warning" %}
Available for **Enterprise** Tier only
{% endhint %}

The Threat Center in StepSecurity is your central view into all supply chain compromises detected by StepSecurity. It provides a real-time feed of active incidents alongside historical records, making it easier to track, investigate, and respond.

For background on the intelligence powering the Threat Center, [see our blog post](https://www.stepsecurity.io/blog/introducing-stepsecurity-threat-intelligence-real-time-supply-chain-attack-alerts-for-your-siem).

### Accessing the Threat Center

#### Step 1: Open the StepSecurity Dashboard

* From the left-hand menu, click Threat Center. The page displays a list of active threats, marked with a red Active badge, along with historical incidents that include their start and close times.

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2FWWYDEqUjjTZEmDmoSMjw%2FScreenshot%202026-08-18%20at%2008.53.58.png?alt=media&amp;token=9ffb4e74-0903-4aca-83d1-bce45c79f94f" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
You can also open the Threat Center directly by clicking the 🔔 **New Threats** notification in the dashboard header
{% endhint %}

#### **Step 2: Open an incident**

* Click **View Details** on any incident to open its page. The page shows:
  * The incident title, its **Active** badge while the incident is ongoing, severity, ecosystem, and start time
  * A description of the compromise
  * Where the incident affects you, if it does
  * The full incident details, including affected packages or Actions and recommended remediation step

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2FW2SSsEaH7odeJAvbE9Z3%2FScreenshot%202026-05-13%20at%2014.29.36.png?alt=media&amp;token=7b585c9c-4942-4dea-80fc-915346bc911d" alt=""><figcaption></figcaption></figure>

### Identifying threats that affect you

Not every incident in the Threat Center touches your organization. StepSecurity evaluates each incident against your environment and flags the ones you are exposed to, so you can focus remediation on what actually applies to you. An incident is treated as affecting you when StepSecurity finds either of the following:

* A **matched component**: a compromised package or Action from the incident is present in your environment. StepSecurity looks in:
  * **Pull requests:** the compromised version is introduced in an open pull request.
  * **Default branch:** the compromised version is on the repository's default branch, such as `main`.
  * **Workflow runs:** a compromised Action was used in one of your GitHub Actions workflow runs.
  * **Developer machines:** the compromised package is installed on a developer machine monitored by Dev Machine Guard.
* A **matched IOC**: an indicator of compromise from the incident, such as a malicious network endpoint, was observed in your Harden-Runner runtime data.

#### **Filter by exposure**

At the top of the Threat Center, tabs control which incidents are shown:

* **All:** every incident StepSecurity has published, with a count of the total.
* **Affecting You:** only the incidents that still need action from you, with a count of how many currently apply to you.
* **Remediated:** the incidents where you have remediated every finding. An incident moves here from **Affecting You** once all of its findings are remediated, and moves back if any finding reappears.

Incidents that affect you also carry a red **You are affected** badge next to the title.

{% hint style="info" %}
The red **Active** badge always describes the incident itself: the attack campaign is ongoing. Remediating your findings leaves this badge unchanged. Your own remediation progress is shown on the incident page.
{% endhint %}

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2F64CJDNwQkqiHlVzUA5Xd%2FScreenshot%202026-11-16%20at%2013.17.46.png?alt=media&amp;token=8de12cfd-793a-45b3-994b-966da1b9de31" alt=""><figcaption></figcaption></figure>

#### **Reviewing an affected incident**

Open an affected incident to see exactly where and how you are exposed. A summary banner at the top reports the scope of your exposure and your remediation progress.

The right side of the banner shows how many findings are in components and how many are in indicators of compromise (IOCs).

{% hint style="info" %}
**What counts as a finding:** A finding is one thing you can remediate, such as one compromised package in one repository's open pull requests, or one package version on one developer machine. A finding can appear as more than one row. For example, a package installed in three projects on the same machine is one finding shown as three rows. All counts on the incident page count findings, and remediating a finding updates all of its rows.
{% endhint %}

What you see depends on your access. If you have tenant-wide access, the Threat Center shows findings across all of your organizations and developer machines, even when you open it from an organization. If you have access to a single organization, you see only that organization's findings.

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2FiYl4E9U24cOF8H7Sj1CU%2FScreenshot%202026-11-16%20at%2013.20.10.png?alt=media&amp;token=9d912ca0-aba5-4784-82dc-bbb1a8872aae" alt=""><figcaption></figcaption></figure>

#### **Matched components**

The **Matched components** section lists every place a compromised package or Action was found, in a table. Times are shown in Greenwich Mean Time (GMT).

| Column                  | Description                                                                                                                                                                                                                                                           |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Package**             | The compromised package or Action, its ecosystem (for example, npm), and the matched version.                                                                                                                                                                         |
| **Where**               | The repository and pull requests, branch, workflow run, or developer machine where it was found. All open pull requests in a repository that bring in the same compromised package are grouped on one row, for example **7 pull requests**, and count as one finding. |
| **Source**              | An icon for where the match came from: pull request, default branch, workflow run, or developer machine. Hover over it to see the name.                                                                                                                               |
| **Status**              | **Active**, **Reappeared**, or **Remediated**.                                                                                                                                                                                                                        |
| **Remediated by**       | The user who last marked the finding remediated.                                                                                                                                                                                                                      |
| **Remediated at (GMT)** | When the finding was last marked remediated.                                                                                                                                                                                                                          |
| **Comment**             | The remediation comment, if any.                                                                                                                                                                                                                                      |

Expand a row to see its full details. For pull requests this lists every pull request in the row, with its number and title, author, date, matched version, head commit, and affected files (for example, `package-lock.json`). Marking the row remediated covers all of its pull requests. For a developer machine it includes the device, project path, and install path.

Use the row menu (**⋮**) to remediate the finding or to open where it was found (**Open pull request**, **Open branch**, **Open run**, or **Open device**).

Above the table you can:

* Switch between **All**, **Active**, and **Remediated** findings. Each tab shows a count.
* Search by repository, pull request, run, or device.
* Filter by **Source** and, on the tenant-wide view, by **Organization**.

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2FSoTAaPqwWXp1wSG56Q1y%2FScreenshot%202026-11-16%20at%2013.27.42.png?alt=media&amp;token=5ae514c4-cc95-4724-b8ee-314d99b61b7f" alt=""><figcaption></figcaption></figure>

#### **Matched IOCs**

The **Matched IOCs** section lists indicators of compromise from the incident that were observed in your Harden-Runner runtime data, in a table:

| Column                                                              | Description                                                                        |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| **Indicator**                                                       | The IOC, for example a malicious network endpoint.                                 |
| **Type**                                                            | The kind of IOC, for example **Call to IOC Endpoint**.                             |
| **Where**                                                           | The organization or repository, and for a single run, the workflow and run number. |
| **Last seen (GMT)**                                                 | When the IOC was last observed, and the total number of calls.                     |
| **Status**, **Remediated by**, **Remediated at (GMT)**, **Comment** | Same as for matched components.                                                    |

Expand a row to see the endpoint, when it was first and last seen, the total number of calls, and a per-run breakdown under **Endpoint observations** listing the repository, workflow, job, and run for each observed call. This lets you trace an IOC back to the exact workflow run that contacted it.

The same **All**, **Active**, and **Remediated** tabs, search, and **Organization** filter are available.

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2FV8KgUYSzJVUEfCTwrPqT%2FScreenshot%202026-11-16%20at%2013.27.54.png?alt=media&amp;token=541d958d-2267-45af-b106-886ac0abe68e" alt=""><figcaption></figcaption></figure>

#### Remediating findings

Once you have fixed a finding, for example by removing the compromised package, closing the pull request, or blocking the endpoint, mark it remediated in the Threat Center. StepSecurity keeps tracking it and tells you if the threat comes back.

Each finding has one of three statuses:

* **Active:** the finding needs action. New findings start here.
* **Remediated:** you marked the finding remediated.
* **Reappeared:** you marked the finding remediated, and StepSecurity saw the threat again afterwards. The time it was seen again is shown under the status. Reappeared findings are listed under the **Active** tab, because they need action again.

{% hint style="info" %}
Changing the status of findings requires a role with **Read & write** access to the **Threat Center** permission, under **OSS Package Security**. Every change is recorded in the audit logs.
{% endhint %}

**Mark a finding remediated**

* Open the row menu (**⋮**) on the finding and click **Mark remediated**.
* Optionally add a comment of up to 200 characters, for example "Removed the package and rotated the exposed tokens".
* Click **Mark remediated**.

StepSecurity records who remediated the finding and when. If the finding has more than one row, the dialog tells you how many rows will be updated.

**Remediate all findings**

Click **Remediate all** above a table to mark every active finding in the current view remediated at once. The button shows how many findings it will remediate, and respects the tab, search, and filters you have applied. Existing comments are kept.

**Edit or clear a comment**

On a remediated finding, open the row menu (**⋮**) and click **Edit comment**. Change the comment, or clear the box to remove it, and click **Save**. Editing a comment keeps the original remediating user and time.

**Move a finding back to Active**

If you marked a finding remediated by mistake, open the row menu (**⋮**) and click **Mark as active**, then confirm. The finding moves back to **Active** and its comment is kept. Moving a finding back to **Active** sends no notification.

**When a remediated finding reappears**

After you remediate a finding, StepSecurity keeps checking for it. The finding moves to **Reappeared** when the threat is seen again after your remediation, for example:

* **Pull request:** a pull request in the row is updated and still contains the compromised version, or a new pull request in the same repository brings in the same package.
* **Default branch:** a later scan of the default branch still finds the compromised version, or it is added back.
* **Workflow run:** a new workflow run uses the compromised Action again.
* **IOC:** the endpoint is contacted again after your remediation.
* **Developer machine:** the device still reports the compromised package in a scan collected after your remediation.

When a finding reappears, StepSecurity sends a notification through your configured channels, with the incident title prefixed by **Reappeared:**. Your original comment, remediating user, and remediation time are kept, so you can see what was done before.

### Notifications and Integrations

Threat Center incidents are delivered through your existing StepSecurity notification channels, so your team is informed immediately:

* Slack
* Email
* AWS S3
* Webhook

Whether you are notified about every incident or only about incidents that affect your organization is controlled by your **threat intel notification granularity**:

* **All threat intel incidents:** every incident, whether or not you are affected.
* **Affected packages:** only incidents where a compromised package matches your dependencies by name.
* **Exact version only:** only incidents where you use the exact compromised version.

Configure notification granularity and channels at the organization level or tenant-wide.

You are also notified when a finding you remediated reappears. These notifications use the same channels and settings, and their title starts with **Reappeared**.

Because alerts are integrated with your existing systems, you can automate the response process. For example, you can configure your SIEM so that when a new Threat Center event is raised, an on-call engineer is automatically paged.

See an example detection event [here](https://docs.stepsecurity.io/administration/admin-console/integrations/sample-detection-events.md#threat-intelligence)

### Querying Threat Intelligence via API

StepSecurity exposes threat intelligence in two ways: per incident, scoped to your organization, and as a full per-ecosystem feed of every compromised package StepSecurity is tracking. You can also track remediation of your findings through the API.

#### **Compromised components for a single incident**

You can retrieve the compromised Open Source Software (OSS) components for a specific Threat Center incident programmatically through the StepSecurity API. This is useful for feeding incident data into your own tooling, automating triage, or correlating compromised packages against your dependency inventory.

The endpoint returns all compromised components tied to an incident, including the package ecosystem, affected version, severity, verification status, and a description of the threat.

```
GET /github/{owner}/threat-intel/incidents/{incidentId}/compromised-components
```

The request takes your GitHub organization (`owner`) and the unique incident identifier (`incidentId`) as path parameters, and requires a valid StepSecurity API token.

<figure><img src="https://754495266-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQJRZY4cfEeY3I7DXTOCp%2Fuploads%2F7v7FJg7Kbv2o2b89HVvt%2FScreenshot%202026-06-05%20at%2018.31.53.png?alt=media&amp;token=f8964b1c-e59c-4ea3-944a-ffa427a20fd1" alt=""><figcaption></figcaption></figure>

**Example Response**

```json
{
  "compromised_components": [
    {
      "type": "npm",
      "component_name": "malicious-pkg",
      "version": "1.2.3",
      "incident_group_id": "ig-001",
      "description": "Package contains malicious code that exfiltrates credentials",
      "severity": "critical",
      "verified": true,
      "added_at": "2024-01-15T10:00:00Z",
      "threat_intel_id": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
    }
  ]
}
```

{% hint style="info" %}
The per-incident endpoint returns only the components attached to that one incident. To export every compromised package StepSecurity is tracking, including packages that are not linked to a Threat Center incident, use the per-ecosystem feed below.
{% endhint %}

#### **Remediation status and actions**

The incident endpoint returns where an incident affects you, including the remediation state of each matched row:

```
GET /github/{owner}/threat-intel/incidents/{incidentId}
```

In the response, `am_i_affected` contains `matched_components` and `matched_identifiers` (IOCs). Each matched row carries these remediation fields:

| Field           | Description                                                                                                          |
| --------------- | -------------------------------------------------------------------------------------------------------------------- |
| `finding_key`   | Identifies the finding. Use it with the remediate and reopen endpoints. Rows of the same finding share the same key. |
| `status`        | `open`, `remediated`, or `reappeared`. A row with no status is open.                                                 |
| `comment`       | The latest remediation comment.                                                                                      |
| `remediated_by` | The user who last marked the row remediated.                                                                         |
| `remediated_at` | When the row was last marked remediated.                                                                             |
| `reappeared_at` | When the threat was last seen again after a remediation.                                                             |

`am_i_affected.remediation_summary` gives counts of your matched rows by status (`total`, `open`, `remediated`, `reappeared`) and `fully_remediated`, which is `true` when every row is remediated.

To mark findings remediated, send their finding keys:

```
POST /github/{owner}/threat-intel/incidents/{incidentId}/remediate
```

```json
{
  "finding_keys": ["3f2a9c1e5b7d4e8a9c217d4e5f6a8b90"],
  "comment": "Removed the package and rotated the exposed tokens"
}
```

* `finding_keys` is required, with at most 1000 keys per request.
* `comment` is optional, up to 200 characters. Without a comment, each finding keeps its existing comment.
* To edit only the comment of findings that are already remediated, add `"comment_only": true`. The comment is then set exactly as sent (an empty comment clears it), and the remediating user and time are kept. Findings that are not remediated are left unchanged and listed in `skipped`.

To move findings marked remediated by mistake back to open:

```
POST /github/{owner}/threat-intel/incidents/{incidentId}/reopen
```

```json
{
  "finding_keys": ["3f2a9c1e5b7d4e8a9c217d4e5f6a8b90"]
}
```

Findings that are not remediated are skipped, so repeating a request changes nothing. Reopening sends no reappeared notification.

Both endpoints require **Read & write** access to Threat Center. They return `404` when the incident has no findings for you or none of the keys match, and `409` when the findings changed while saving, in which case retry the request.

{% hint style="info" %}
The organization endpoints above cover that organization's findings. To include findings on developer machines and across all of your organizations, use the tenant-wide endpoints `POST /application/customers/{customer}/threat-intel/incidents/{incidentId}/remediate` and `.../reopen`, which take the same request body.
{% endhint %}

#### **Full list of compromised packages per ecosystem**

To export everything StepSecurity is tracking, rather than the components of one incident, use the per-ecosystem compromised packages feed. Each endpoint returns the complete list of compromised package versions for one ecosystem, combining Threat Center incidents with compromises reported by external advisory sources such as OSV. The feed is refreshed about every 15 minutes. This is the feed to use when you want to load StepSecurity threat intelligence into your own SIEM, artifact registry policy, or dependency scanner.

```
GET https://agent.api.stepsecurity.io/v1/application/packages/{ecosystem}/compromised
```

Supported values for `{ecosystem}`:

| `npm`       | npm                  |
| ----------- | -------------------- |
| `pypi`      | PyPI                 |
| `cargo`     | crates.io            |
| `packagist` | Packagist (Composer) |
| `go`        | Go modules           |
| `maven`     | Maven Central        |
| `nuget`     | NuGet                |

Some ecosystems were added to tracking recently and may return an empty `packages` array until compromises are recorded.

Requesting an unsupported ecosystem returns HTTP 400 with `{"error": "unsupported ecosystem: <value>"}`.

Responses can be large (the PyPI feed is several hundred kilobytes, and npm is larger). Send `Accept-Encoding: gzip` so the response is compressed in transit. Standard HTTP clients decompress it automatically.

```bash
curl -sS --compressed \
  https://agent.api.stepsecurity.io/v1/application/packages/pypi/compromised
```

**Example Response**

```json
{
  "packages": [
    {
      "type": "pypi",
      "component_name_version": "aiassistcore#0.1.2",
      "component_name": "aiassistcore",
      "version": "0.1.2",
      "description": "Malicious code in aiassistcore (PyPI)",
      "added_at": "2026-08-25T09:48:44Z",
      "threat_intel_id": "oss-compromised-uncategorized"
    }
  ]
}
```

| Field                    | Description                                                                                                                                                        |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `type`                   | Ecosystem of the package, matching the `{ecosystem}` value in the request.                                                                                         |
| `component_name`         | Package name as published in the registry.                                                                                                                         |
| `version`                | Compromised version. A value of `*` means all published versions are compromised.                                                                                  |
| `component_name_version` | `component_name` and `version` joined with `#`, useful as a stable lookup key.                                                                                     |
| `description`            | Summary of the compromise.                                                                                                                                         |
| `added_at`               | When the entry was added to the feed (UTC).                                                                                                                        |
| `threat_intel_id`        | Identifier of the Threat Center incident the package is linked to. Packages that are not linked to a Threat Center incident carry `oss-compromised-uncategorized`. |

The response may include additional fields that are used internally and are subject to change. Build integrations on the fields listed above.

Entries are appended as new compromises are confirmed. Poll the feed on a schedule and diff on `component_name_version` to pick up new entries.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.stepsecurity.io/workspace/threat-center.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
