NewApp Monitoring is liveSign up free
AgentbeamBeta
Open-source package vulnerability · npm

CVE-2026-62300: filecoin-pin: Unbounded DAG pinning can exhaust server resources

mediumCVSS 3.1 6.5GHSA-m5ph-mmg5-6w5h

The filecoin-pin pinning server, version 1.1.0 and earlier, accepts any CID through POST /pins and fetches the whole DAG with no size, rate or concurrency limit. A caller can exhaust disk, network and CPU. The listed patched version, 1.1.1, changes documentation only: the limits are still not implemented.

Published Nov 5, 2026 · Analysis Nov 5, 2026

What an attacker can do

POST /pins checks only that the body holds a valid CID, then queues the pin. _processPinInBackground runs from setTimeout with no queue or semaphore, builds a Helia node per pin, and walks the full DAG with helia.pins.add(cid). Every fetched block is written to a CAR file under carStoragePath.

Nothing caps request rate, per-user quota, DAG bytes, block count, traversal depth, time or concurrent pins. The API also accepts origins, so an attacker can point the server at their own libp2p peer that serves a very large DAG. Many concurrent requests each start independent background work.

The result is availability loss: a full disk, saturated network, CPU and memory pressure, and a failed process for other users of the daemon. The attacker needs a valid token, or no token if the server runs with ALLOW_NO_AUTH=true. By default the daemon binds to localhost and refuses to start without an access token, which limits exposure. Risk is highest when the daemon is reachable beyond localhost, when one token is shared among untrusted users, or when no-auth mode is on (CWE-400).

Who is affected

The npm package filecoin-pin at 1.1.0 and earlier. Only deployments that run the pinning server are exposed, and mostly those reachable from outside localhost or shared between users.

Check your install:

npm ls filecoin-pin

Also check how the server is started: look for ALLOW_NO_AUTH=true or --allow-no-auth, a non-localhost bind address, and whether CAR_STORAGE_PATH sits on shared or unbounded storage.

filecoin-pin

Ecosystem
npm
Affected
<= 1.1.0
Fixed in
1.1.1
Check
npm ls filecoin-pin

How to fix it

The package data lists 1.1.1 as patched:

npm install [email protected]

Read this carefully. The release notes and the linked commit 8db22b4 only change the README. They mark the server as beta and not for production, and list the controls it does not enforce: rate limits on POST /pins, per-user quotas, DAG byte, block and depth caps, a traversal timeout, a concurrency cap and filesystem quotas. Hardening is tracked upstream in issue 46.

The maintainers' operator guidance is the real mitigation: keep the default localhost bind, treat ACCESS_TOKEN as a single-tenant secret, avoid ALLOW_NO_AUTH=true outside local development, and run the daemon on bounded storage.

How to tell if you were hit

Watch carStoragePath for fast-growing or very large partial CAR files and for disk-full conditions. Check the pin list from the API for many queued pins that you did not create, particularly ones submitted with unfamiliar origins peers. Look at outbound libp2p and Bitswap traffic to peers you do not know, and for unexplained CPU or memory spikes in the pinning daemon.

Original advisory

From the GitHub Advisory Database (CC BY 4.0).

Summary

The IPFS Pinning Service API implementation accepts a caller-controlled CID through POST /pins, queues background processing, and then recursively fetches the full DAG with helia.pins.add(cid). The route and background pinning path do not enforce a request rate limit, per-user quota, maximum DAG byte count, maximum block count, traversal timeout, or concurrent pinning limit.

An authenticated caller, or an unauthenticated caller when the server is started with ALLOW_NO_AUTH=true, can submit one or more pins whose CIDs resolve to very large DAGs. The server writes fetched blocks to CAR files under carStoragePath and can consume disk, network, CPU, and libp2p resources until the process or host becomes unavailable.

Details

POST /pins validates only that the request body contains a syntactically valid CID string, then forwards it to the pin store:

  • src/filecoin-pinning-server.ts:304-342 accepts the request, parses cid with CID.parse, and calls pinStore.pin(request.user, cidObject, parsed.options).
  • src/filecoin-pin-store.ts:153-188 stores the pin as queued and schedules _processPinInBackground with setTimeout. There is no queue, semaphore, or global cap around this scheduling.
  • src/filecoin-pin-store.ts:211-217 creates a per-pin Helia node and forwards caller-supplied origins.
  • src/filecoin-pin-store.ts:260-274 walks the full DAG with for await (const pinnedCid of helia.pins.add(cid)).
  • src/create-pinning-helia.ts:47-80 creates a libp2p/Helia node with the Bitswap block broker and no application-level resource limits.
  • src/core/car/car-blockstore-base.ts:65-107 writes every fetched block and updates stats.totalSize only after writing.
  • src/core/car/car-file-backend.ts:84-93 streams blocks to the CAR writer on disk.

The Helia node created for each pin has no bootstrap or mDNS configuration (src/create-pinning-helia.ts:57). A public CID alone may therefore not be fetchable unless the node can reach a content source. In practice, the API also accepts origins, so an attacker can supply a reachable attacker-controlled libp2p origin that serves a large DAG and cause the server to retrieve it.

Impact

Successful exploitation affects availability:

  • Disk exhaustion from unbounded CAR files in carStoragePath.
  • Network exhaustion from recursive Bitswap retrieval.
  • CPU and memory pressure from concurrent libp2p/Helia pin operations.
  • Service degradation or process failure for other users of the daemon.
  • Operational cost and manual recovery burden from large partial CAR files.

The default daemon configuration reduces exposure because the server binds to localhost and refuses to start without an access token unless ALLOW_NO_AUTH=true. The finding is most significant when the daemon is exposed beyond localhost, when the token is shared across untrusted users, or when the no-auth mode is enabled.

PoC

curl -X POST "https://target.example/pins" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "cid": "CID_OF_LARGE_DAG",
    "origins": ["/ip4/203.0.113.10/tcp/4001/p2p/ATTACKER_PEER_ID"],
    "meta": { "purpose": "resource-exhaustion-validation" }
  }'

Submitting many such requests concurrently accelerates resource pressure because each request schedules independent background processing.

Credited to Kairos-T.

Questions

Does upgrading to filecoin-pin 1.1.1 remove the problem?

Not on its own. The linked commit and release notes describe documentation changes: the beta warning and the list of limits the server does not enforce. Follow the operator guidance in the README.

Can an unauthenticated user trigger it?

Only if the server runs with ALLOW_NO_AUTH=true. Otherwise the attacker needs a valid access token. The server will not start without a token unless that flag is set.

Is CVE-2026-62300 exploited in the wild?

The sources do not say so. The entry has no KEV data, and the EPSS score is 0.0025.

References

How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology