> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/overview.md).

# Dependency Firewall overview

Harness Dependency Firewall evaluates packages fetched through upstream proxy registries against security policies before they reach your supply chain.

Dependency Firewall is a security capability in Harness Artifacts that intercepts packages fetched through upstream proxy registries and evaluates them against your organization's security policies before caching them. When a developer or CI pipeline pulls a package from an external source, Dependency Firewall checks it against your configured rules and either allows the pull, issues a warning, or blocks the package entirely, before it reaches your engineers.

## How Dependency Firewall works

Dependency Firewall operates exclusively on **upstream proxy registries**. It does not evaluate artifacts pushed directly to local registries.

When a package version is fetched through a proxy for the first time, Harness evaluates it against every enforced policy set in scope. Each policy in a set carries a **fail action** that you configure when creating the policy set:

* **Error and exit**: if this policy fails, the artifact is **Blocked**.
* **Warn & continue**: if this policy fails, the artifact receives a **Warning**.

The artifact's overall verdict is the most severe result across all evaluated policies:

| Status      | What happens                                                                                                                                                                                                                          | Usable? |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| **Passed**  | All policies passed. The artifact is cached and available.                                                                                                                                                                            | Yes     |
| **Warning** | At least one Warn & continue policy failed. The artifact is cached and usable by default; the violation appears on the Violations tab. If the upstream proxy has **Quarantine on warn** enabled, the artifact is quarantined instead. | Depends |
| **Blocked** | At least one Error and exit policy failed. The artifact is not cached and cannot be pulled. An exception is required to use it.                                                                                                       | No      |

{% hint style="warning" %}
Scanning runs asynchronously. On the very first pull of a new version, the download completes before scanning finishes. Subsequent pulls of the same version correctly reflect the evaluated verdict. Go to [Staging-registry pattern](#use-a-staging-registry-to-close-the-first-pull-window) to eliminate this gap in production environments.
{% endhint %}

## Supported formats

Dependency Firewall works with non-OCI upstream proxy registries. OCI-based registries (Docker, Helm OCI) do not generate violations.

<details>

<summary>View supported formats</summary>

* Maven
* npm
* PyPI
* NuGet
* Cargo
* Go modules
* RPM
* PHP Composer

</details>

## The Dependency Firewall module

In the navigation menu, select **Dependency Firewall** to access two tabs.

### Violations tab

The Violations tab is the central view of every policy violation detected across your upstream proxies.

Three summary cards at the top show:

* **Total violations**: combined count of Blocked and Warning verdicts
* **Blocked violations**: packages that are not cached and cannot be used
* **Warning violations**: packages that triggered at least one warn policy

Use the **Registries** and **Package Types** filter dropdowns, or the search box, to narrow the list to a specific ecosystem or registry.

Go to [View and triage violations](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/view-and-triage-violations.md) for a full walkthrough.

### Exceptions tab

The Exceptions tab shows every exception request at the current scope and its lifecycle state. Summary cards show counts for Approved, Rejected, Pending, and Expired exceptions.

When a developer needs temporary access to a blocked or warned package, they submit a request from the Violations tab. An approver reviews it from the Exceptions tab and approves or rejects it.

Go to [Request an exception](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/request-an-exception.md) and [Manage exceptions](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/manage-exceptions.md) for the full workflow.

## Policies and policy sets

Dependency Firewall uses Harness Policy as Code. A **policy set** groups one or more policies and assigns a fail action to each. When an artifact is evaluated, every enforced policy set in scope is applied.

Harness provides five built-in policy templates for Dependency Firewall:

| Template              | What it blocks or flags                                                                                       |
| --------------------- | ------------------------------------------------------------------------------------------------------------- |
| **Malicious Package** | Packages identified as intentionally harmful in Harness threat intelligence (refreshed every 4 hours)         |
| **CVSS Threshold**    | Common Vulnerability Scoring System (CVSS). Packages with CVE scores above a configurable severity threshold  |
| **OSS Risk Level**    | Open Source Software (OSS). Packages with poor maintenance health, end-of-life status, or high aggregate risk |
| **License Policy**    | Packages whose license is not in your allowed list or is on your blocked list                                 |
| **Package Age**       | Package versions published within a configurable cooldown window                                              |

Go to [Built-in policy templates](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/built-in-policy-templates.md) for detection methodology, recommended thresholds, and how to combine templates in a single policy set.

To create a policy set, go to **Account Settings > Policies** and create a policy set with entity type **Upstream Proxy**. For a step-by-step walkthrough, go to [Harness governance quickstart](https://developer.harness.io/harness-platform/use-harness-platform/governance/policy-as-code/harness-governance-quickstart) (Classic documentation).

## Best practices

### Use a staging registry to close the first-pull window

Because scanning is asynchronous, a first-time pull completes before evaluation finishes. That version is available for the duration of scanning. To protect production environments from this gap:

1. Create a **staging upstream proxy** for non-production builds. Route CI pipelines that pull new dependency versions through it.
2. Monitor the Violations tab on the staging proxy. Allow versions to accumulate a Passed verdict.
3. Use [Copy a version](https://developer.harness.io/artifact-registry/3.0/artifacts/copy-a-version.md) to promote Passed versions to a **production upstream proxy**.
4. Route production builds and deployments through the production proxy only. No version reaches production before clearing all policy checks.

### Layer your policies

A single policy set can contain policies with different fail actions, letting you combine hard enforcement on critical risks with visibility-only tracking on lower-severity signals. A common production setup:

| Policy             | Fail action     | Rationale                                     |
| ------------------ | --------------- | --------------------------------------------- |
| Malicious Package  | Error and exit  | Zero tolerance for known attacks              |
| CVSS Threshold 9.0 | Error and exit  | Block critical vulnerabilities                |
| CVSS Threshold 7.0 | Warn & continue | Surface high-severity issues without blocking |
| License Policy     | Error and exit  | Compliance requirement                        |
| Package Age 7 days | Warn & continue | Flag newly published packages                 |
| OSS Risk Level 70  | Warn & continue | Awareness of risky or unmaintained packages   |

## Troubleshooting

<details>

<summary>Dependency Firewall is enabled but no violations appear on the Violations tab</summary>

Dependency Firewall evaluates packages only when they are fetched through an upstream proxy for the first time. If all packages in your project are already cached, no new evaluations run. Pull a package version that has not been cached yet, and confirm that at least one policy set with entity type Upstream Proxy is enforced within the scope of your proxy registry.

</details>

<details>

<summary>A pipeline fails with HTTP 403 but the package does not appear on the Violations tab</summary>

A 403 can come from an authentication issue rather than a firewall block. Verify that the identity token used in the pipeline has download access to the upstream proxy registry. If authentication is correct, confirm that Dependency Firewall is enabled on the specific upstream proxy your pipeline is configured to use.

</details>

<details>

<summary>Does Dependency Firewall require a separate Security Testing Orchestration (STO) or Supply Chain Security (SCS) license?</summary>

No. Dependency Firewall is included with Harness Artifacts and does not require a Security Testing Orchestration or Supply Chain Security license.

</details>

<details>

<summary>Can I audit dependencies before they hit the firewall?</summary>

Yes. Run `hc registry fw audit --file <manifest-or-lockfile> --registry <registry-name>` to evaluate dependencies locally or in CI before a pipeline installs them. Go to the [CLI reference](https://developer.harness.io/artifact-registry/3.0/reference/cli.md) for command syntax and examples.

</details>

## Next steps

* To enable Dependency Firewall for an upstream proxy, go to [Enable Dependency Firewall](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/enable-dependency-firewall.md).
* For a reference on all five built-in templates, go to [Built-in policy templates](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/built-in-policy-templates.md).
* To assign policies to a registry, go to [Configure policy sets](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/configure-policy-sets.md).

{% @harness-feedback/feedback %}
