On this page (7 sections)

A server-side request forgery (SSRF) flaw, tracked as CVE-2026-56712, has been published for Replicate Cog in versions through 0.23.1. According to the NVD record, an attacker who can submit prediction inputs can make the Cog process fetch attacker-chosen URLs, including internal addresses.

If you serve models with Cog, or host it for customers, this is worth checking now. The public information is thin and no fixed version is named, so this article separates what is confirmed from what is still unknown.

What happened

The advisory text says Cog does not validate URLs supplied in prediction inputs against the resolved destination host or IP before fetching them. An attacker can supply a malicious URL, or abuse HTTP redirects, in inputs declared as cog.File and cog.Path. The result is that the Cog process makes HTTP requests on the attacker's behalf, to destinations the attacker could not reach directly.

The record was published by NVD on November 9, 2026 and added to the GitHub Advisory Database on November 10, 2026. The references also include a pull request in the replicate/cog repository, a third-party repository named for the CVE and a VulnCheck advisory. The sources we have do not describe the contents of these, so we cannot say whether the pull request is the official fix.

Coverage so far is limited. The NVD entry and the GitHub advisory carry the same description, so they are one account of the issue, not two independent confirmations.

Why SSRF matters here

SSRF turns a server into a proxy. The application is trusted by the network around it, so when it can be steered to fetch an arbitrary URL, an outsider may reach services that were never meant to be public: admin interfaces, databases with no authentication, internal APIs, or cloud metadata endpoints that hand out credentials.

The advisory itself says the impact is potentially exposing sensitive internal services or credentials. Redirects make simple URL filters weaker: a URL that looks harmless at submission time can redirect to an internal address when it is fetched. That is why the advisory stresses validating the resolved destination, not just the text of the URL.

Severity: two scores, one caveat

The sources disagree on how to rate this. The CVE record lists a CVSS score of 7.8 (high). The GitHub page shows a CVSS v4 score of 6.3 (moderate), with network attack vector, low complexity, low privileges required, no user interaction, and high confidentiality impact on subsequent systems. The GitHub page also marks the advisory as unreviewed. Treat the score as a rough guide; your real risk depends on what your Cog host can reach.

Who is exposed

  • Teams exposing a Cog prediction endpoint to the internet or to many tenants, where inputs come from people you do not control.
  • Models whose predictor accepts cog.File or cog.Path inputs, since those are the input types named in the advisory.
  • Deployments where the Cog container can reach internal services, other containers, or a cloud metadata service.
  • Internal-only deployments with trusted users are lower risk, but a compromised internal client could still send crafted inputs.

Privileges required are described as low in the GitHub scoring, so assume that having any ability to call the prediction API may be enough.

How to check your exposure

Start by finding every place Cog runs and which version it is. If you installed the Cog command line tool on a machine, this prints its version; compare it with 0.23.1 (run it wherever you build or serve models):

Print the installed Cog version (run on the build or serving host)Shell
cog --version

If you serve models from container images, check which Cog version each image was built with in your build logs or Dockerfile, since the version baked in at build time is what runs in production. Then review your predictor code:

  • Search your predict signatures for cog.File and cog.Path inputs.
  • Note which endpoints are reachable from outside and who can call them.
  • Check what the container can reach on the network: internal subnets, other services, and any metadata address your cloud provides.
List predictor input types that accept URLs (run from your model repository root)Shell
grep -rnE "cog\.(File|Path)" .

What to do now

The sources name no patched release, so the priority is reducing what a forged request can reach while you watch for an official fix.

Caution. Egress and firewall changes can break model downloads or other legitimate outbound calls. Test in staging first and keep a way to roll back.
  1. Inventory every Cog deployment and record its version; treat anything at 0.23.1 or earlier as affected.
  2. Restrict who can call prediction endpoints: require authentication and avoid exposing them directly to the public internet where possible.
  3. Block outbound traffic from Cog containers to private ranges, loopback, link-local addresses and your cloud metadata service, using network policy or host firewall rules.
  4. If your cloud provider offers it, require the hardened version of its metadata service so that a simple forged request cannot read credentials.
  5. Remove credentials and secrets from the Cog host environment that the model does not need, and use narrowly scoped tokens.
  6. Where you can, put an allow-list proxy in front of outbound fetches so only approved domains are reachable.
  7. Follow the GitHub advisory and the Cog pull request for a fixed release, and upgrade once one is confirmed by the maintainers.
  8. Rotate any credential that could have been exposed if you find signs of abuse.
Tip. Filtering URL text is not enough, because redirects and DNS can change where a request ends up. Control the destination at the network layer, where the final connection is made.

Detection and monitoring

Look for the pattern SSRF leaves behind: your model server making outbound requests it normally never makes. Review egress logs and flow data from Cog hosts for connections to private IP ranges, loopback or metadata addresses. In application logs, look for prediction requests whose URL inputs point at internal hostnames, IP literals, or domains you do not recognize.

Search a request log for URL inputs pointing at private or metadata addresses (adjust the log path…Shell
grep -nE "169\.254\.169\.254|127\.0\.0\.1|localhost|10\.[0-9]+\.[0-9]+\.[0-9]+|192\.168\." /path/to/cog-access.log

This pattern is a starting point, not a complete detector; attackers can use DNS names or redirects that resolve to internal addresses. If you also run public websites, the free SSL checker and security headers checker help you review the outside-facing side, and certificate and DNS monitoring can flag unexpected changes on domains that front your model endpoints. For the broader picture of web firewalls, see what a WAF is.

What we do not know yet

  • No fixed Cog version is named in the sources.
  • Whether pull request 3225 is the official fix is not stated.
  • No active exploitation is reported, but absence of reports is not proof of safety.
  • The severity score differs between sources, and the GitHub entry is marked unreviewed.

We will treat this as an evolving story. Until a patched release is confirmed, network isolation and access control are your main defenses.

Sources

This article is based on the public sources below. Details can change as vendors and researchers publish more; check the original advisories before acting on version numbers.

  1. CVE-2026-56712 - GitHub Advisory Databasegithub.com
  2. CVE-2026-56712: Replicate Cog through 0.23.1 contains a server-side request forgery vulnerability that allows attackers to cause the Cog process to make server-side HTTP…nvd.nist.gov ·
  • SSRF
  • Replicate Cog
  • CVE-2026-56712
  • machine learning
  • containers