Skip to content
Prev Previous commit
Next Next commit
fix(node): keep /api/v1/ipfs/pins out of the CID resolver's per-IP fl…
…ood brake

Follow-up to #134: the previous reordering put `/api/v1/ipfs/pins` and
`/ipfs/{cid}` under the same `rate_limit_by_ip` + `IpRateLimiter` layer
stack, so both routes shared the resolver's flood brake bucket. That
bucket is documented as the once-per-request brake for `GET /ipfs/{cid}`
because the resolver can drive bounded-but-expensive repo walks. The
pin listing is a single `list_pinned_cids()` call and has no reason to
share the bucket. Sharing meant /ipfs/{cid} traffic could exhaust the
bucket and 429 the pins endpoint, and signed pin polling could exhaust
the bucket and 429 legitimate CID reads.

Compose `ipfs_routes` from two sub-routers with independent policies,
then merge:
  * `/ipfs/{cid}` keeps `optional_signature` + `rate_limit_by_ip` + the
    `IpRateLimiter` extension. Same behavior as before #134.
  * `/api/v1/ipfs/pins` gets only `optional_signature`. Auth-required
    (handler denies with 401), but no rate limit — it has nothing to
    flood.

Two new `build_router` regressions exercise the bucket independence
through `TrustedProxy::XForwardedFor`:
  * 5 signed pin requests against a size-2 CID bucket all 200, then a
    `/ipfs/{cid}` from the same IP also 200 (pins did not debit the
    bucket).
  * A `/ipfs/{cid}` exhausts a size-1 CID bucket (200, then 429), then
    a signed pin from the same IP is 200 (the bucket does not gate
    pins).

All 65 tests in `server::tests::` + `test_support::tests::ipfs_*`
still pass, including the existing 429 tests for the CID resolver.
  • Loading branch information
Gravirei committed Aug 29, 2026
commit 8dd745e98b40a021021cdaa0807a413570da3720
43 changes: 28 additions & 15 deletions crates/gitlawb-node/src/server.rs
Original file line number Diff line number Diff line change
Expand Up @@ -210,29 +210,42 @@ pub fn build_router(state: AppState) -> Router {
.layer(axum::Extension(push_limiter));

// ── IPFS content-addressed retrieval and pin listing ──────────────────
// `/ipfs/{cid}` carries `optional_signature` so `get_by_cid` sees the caller
// identity and can apply per-repo visibility (#110); anonymous callers stay
// anonymous and still read genuinely public content. `/api/v1/ipfs/pins`
// now carries the same `optional_signature` layer: the handler rejects
// requests without a verified `AuthenticatedDid`, so unsigned callers are
// denied (anonymous enumeration closed; #121). `/ipfs/{cid}` also carries a
// per-IP flood brake: it is anon-reachable and each request can drive a
// full-history git walk, so the per-IP rate limiter is the outermost layer
// (rejects a flood before the walk-admission work), mirroring the
// push/create routers. The extension MUST be attached or rate_limit_by_ip
// is a silent no-op. Axum layers only cover routes added before them, so
// both `/ipfs/{cid}` and `/api/v1/ipfs/pins` are built first and the auth +
// rate-limit layers are applied to the merged result.
// Two independent sub-routers, then merged. They share a URL prefix family
// but have separate rate-limit policies and must not share a bucket.
//
// `/ipfs/{cid}` (CID resolver): carries `optional_signature` so `get_by_cid`
// sees the caller identity and can apply per-repo visibility (#110); anon
// callers stay anonymous and still read genuinely public content. The
// per-IP flood brake is layered on because the resolver is anon-reachable
// and each request can drive a full-history git walk — the brake is the
// outermost layer (rejects a flood before the walk-admission work), mirroring
// the push/create routers. The `IpRateLimiter` extension MUST be attached
// or `rate_limit_by_ip` is a silent no-op.
//
// `/api/v1/ipfs/pins` (pin listing): now carries `optional_signature` only
// (#121). The handler rejects requests without a verified `AuthenticatedDid`
// with 401. It does NOT carry the CID flood brake — `list_pins` is a single
// `list_pinned_cids()` call, no walk, and routing pins through the resolver's
// bucket would let `/ipfs/{cid}` traffic exhaust the bucket and 429 the
// pins endpoint, or let signed pin polling exhaust the bucket for legitimate
// CID reads. The two surfaces have separate availability contracts.
//
// Both sub-routers are built first with their own layer sets, then merged.
// This is the structure the prior routing guidance called for and the
// earlier 429 test for `/ipfs/{cid}` (test_support.rs) assumes.
let ipfs_limiter = rate_limit::IpRateLimiter {
limiter: state.ipfs_rate_limiter.clone(),
trust: state.push_limiter_trust,
};
let ipfs_routes = Router::new()
let ipfs_cid_routes = Router::new()
.route("/ipfs/{cid}", get(ipfs::get_by_cid))
.merge(Router::new().route("/api/v1/ipfs/pins", get(ipfs::list_pins)))
.layer(middleware::from_fn(auth::optional_signature))
.layer(middleware::from_fn(rate_limit::rate_limit_by_ip))
.layer(axum::Extension(ipfs_limiter));
let ipfs_pins_routes = Router::new()
.route("/api/v1/ipfs/pins", get(ipfs::list_pins))
.layer(middleware::from_fn(auth::optional_signature));
let ipfs_routes = ipfs_cid_routes.merge(ipfs_pins_routes);

// ── Arweave permanent anchors ──────────────────────────────────────────
// `list_anchors` rejects callers without a verified `AuthenticatedDid`, so
Expand Down
175 changes: 175 additions & 0 deletions crates/gitlawb-node/src/test_support.rs
Original file line number Diff line number Diff line change
Expand Up @@ -13766,6 +13766,181 @@ mod tests {
);
}

/// #134 R2 (split buckets): signed `/api/v1/ipfs/pins` polling must NOT debit
/// the CID resolver's per-IP flood brake. The pre-fix composition merged
/// pins under the same router as `/ipfs/{cid}`, so every signed pin
/// request consumed a token from `ipfs_rate_limiter` and a flood of pinned
/// traffic could 429 legitimate CID reads. RED before the split (pins
/// debited the bucket): a flood of pins followed by a CID request → 429
/// on the CID. GREEN after the split: the CID bucket is untouched.
#[sqlx::test]
async fn ipfs_pins_do_not_debit_the_cid_bucket(pool: PgPool) {
use gitlawb_core::http_sig::sign_request;
use gitlawb_core::identity::Keypair;
let kp = Keypair::generate();
let owner_did = kp.did().to_string();
let slug = owner_did.replace([':', '/'], "_");
let short = owner_did.split(':').next_back().unwrap().to_string();
let mut state = test_state(pool).await;
// Bucket size 2: any third /ipfs/{cid} request from the same IP would
// 429 if the bucket were touched by the preceding pin requests.
state.ipfs_rate_limiter = crate::rate_limit::RateLimiter::new(2, Duration::from_secs(3600));
state.ipfs_work_rate_limiter =
crate::rate_limit::RateLimiter::new(600, Duration::from_secs(3600));
state.push_limiter_trust = crate::rate_limit::TrustedProxy::XForwardedFor;

// Seed a public, walk-free CID so /ipfs/{cid} serves cheaply. This
// matters because the proof half of the test fires a real CID request
// and needs the route bucket to be the only thing that can 429 it.
let fx = seed_cid_repos(&slug, &short, &["pinsdebit"]);
let bare = std::path::PathBuf::from("/tmp")
.join(&slug)
.join("pinsdebit.git");
let repo = seed_repo(&owner_did, "pinsdebit");
state.db.create_repo(&repo).await.expect("seed repo");
let cid = pin_cid_for(&bare, &fx.public_oid, &state.db).await;

let router = crate::server::build_router(state);
let peer_ip = "203.0.113.50";

// Five signed pin requests — more than the bucket — all must 200 (the
// pins route has no rate limit; the bucket only charges /ipfs/{cid}).
let pins_path = "/api/v1/ipfs/pins";
let pins_signed = sign_request(&kp, "GET", pins_path, b"");
for i in 0..5 {
let req = Request::builder()
.method(Method::GET)
.uri(pins_path)
.header("content-digest", &pins_signed.content_digest)
.header("signature-input", &pins_signed.signature_input)
.header("signature", &pins_signed.signature)
.header("x-forwarded-for", peer_ip)
.body(Body::empty())
.unwrap();
let resp = router.clone().oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::OK,
"pin request {i} must not be rate-limited even though the CID bucket is size 2"
);
}

// A subsequent /ipfs/{cid} request from the same IP must still serve
// 200 — the bucket was untouched by the pin traffic. (If pins had
// debited it, the bucket would be empty and the CID request would 429.)
let cid_path = format!("/ipfs/{cid}");
let cid_signed = sign_request(&kp, "GET", &cid_path, b"");
let req = Request::builder()
.method(Method::GET)
.uri(&cid_path)
.header("content-digest", cid_signed.content_digest)
.header("signature-input", cid_signed.signature_input)
.header("signature", cid_signed.signature)
.header("x-forwarded-for", peer_ip)
.body(Body::empty())
.unwrap();
let resp = router.oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::OK,
"the CID bucket must still have tokens — pin traffic did not debit it"
);
}

/// #134 R2 (split buckets, second half): an EXHAUSTED CID bucket must
/// NOT block a valid signed `/api/v1/ipfs/pins` listing. The pre-fix
/// composition routed pins through the same middleware stack, so a CID
/// flood that exhausted the bucket would 429 the pins endpoint too. RED
/// before the split: a CID request that 429s the bucket makes the next
/// pin request 429 too. GREEN after the split: pins never see this
/// bucket and remain servable.
#[sqlx::test]
async fn ipfs_pins_survive_an_exhausted_cid_bucket(pool: PgPool) {
use gitlawb_core::http_sig::sign_request;
use gitlawb_core::identity::Keypair;
let kp = Keypair::generate();
let owner_did = kp.did().to_string();
let slug = owner_did.replace([':', '/'], "_");
let short = owner_did.split(':').next_back().unwrap().to_string();
let mut state = test_state(pool).await;
// Bucket size 1: the first /ipfs/{cid} request from the IP spends the
// only token; the second is 429 (proves exhaustion).
state.ipfs_rate_limiter = crate::rate_limit::RateLimiter::new(1, Duration::from_secs(3600));
state.ipfs_work_rate_limiter =
crate::rate_limit::RateLimiter::new(600, Duration::from_secs(3600));
state.push_limiter_trust = crate::rate_limit::TrustedProxy::XForwardedFor;

let fx = seed_cid_repos(&slug, &short, &["pinsexh"]);
let bare = std::path::PathBuf::from("/tmp")
.join(&slug)
.join("pinsexh.git");
let repo = seed_repo(&owner_did, "pinsexh");
state.db.create_repo(&repo).await.expect("seed repo");
let cid = pin_cid_for(&bare, &fx.public_oid, &state.db).await;

let router = crate::server::build_router(state);
let peer_ip = "203.0.113.60";

// First /ipfs/{cid} request — debits the single CID token, serves 200.
let cid_path = format!("/ipfs/{cid}");
let cid_signed = sign_request(&kp, "GET", &cid_path, b"");
let req = Request::builder()
.method(Method::GET)
.uri(&cid_path)
.header("content-digest", cid_signed.content_digest)
.header("signature-input", cid_signed.signature_input)
.header("signature", cid_signed.signature)
.header("x-forwarded-for", peer_ip)
.body(Body::empty())
.unwrap();
let resp = router.clone().oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::OK,
"the first CID request spends the token and serves"
);

// Second /ipfs/{cid} request — bucket empty → 429 (proves the
// exhaustion is real and observable on this router). Re-sign because
// `SignedHeaders` holds owned `String`s.
let cid_signed_2 = sign_request(&kp, "GET", &cid_path, b"");
let req = Request::builder()
.method(Method::GET)
.uri(&cid_path)
.header("content-digest", cid_signed_2.content_digest)
.header("signature-input", cid_signed_2.signature_input)
.header("signature", cid_signed_2.signature)
.header("x-forwarded-for", peer_ip)
.body(Body::empty())
.unwrap();
let resp = router.clone().oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::TOO_MANY_REQUESTS,
"the second CID request from the same IP is 429 — bucket exhausted"
);

// A signed /api/v1/ipfs/pins request from the SAME IP must still
// serve 200 — pins are auth-only and never see this bucket.
let pins_path = "/api/v1/ipfs/pins";
let pins_signed = sign_request(&kp, "GET", pins_path, b"");
let req = Request::builder()
.method(Method::GET)
.uri(pins_path)
.header("content-digest", pins_signed.content_digest)
.header("signature-input", pins_signed.signature_input)
.header("signature", pins_signed.signature)
.header("x-forwarded-for", peer_ip)
.body(Body::empty())
.unwrap();
let resp = router.oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::OK,
"an exhausted CID bucket must not block a valid signed pin listing"
);
}

/// U5 (R6): the two buckets are independent — the WORK budget can be exhausted
/// (429) WITHOUT draining the ROUTE bucket. Through the production router, route
/// generous (5) but work tight (1): one request drives two legacy probes, so the
Expand Down
Loading