diff --git a/README.md b/README.md index d35e6f69a3c23093f28f7fc2d76fc690155e5d26..b4d6dd2b43355326f8937b1dbdceb214c2c2a35a 100644 --- a/README.md +++ b/README.md @@ -27,15 +27,15 @@ size_categories: - n<1K --- - - + + # nr-bundles-public -A curated, multi-modal dataset of blockchain validator infrastructure under attack and benign workloads. **690 bundles** across **19 chains and network stacks** (Aptos, Bitcoin, Cardano, casper, conflux, Cosmos, Dogecoin, Ethereum, icon, IOTA, kaspa, libp2p, Litecoin, Monero, Solana, Solana (Agave), Sui, XRP, zcash), all thirteen families in the taxonomy (twelve attack classes plus `benign`), and **128 attack primitive_ids** — including faithful wire-level reproductions of **68 publicly disclosed CVEs and security advisories** in blockchain node software. Released as the public sample of NullRabbit's bundle corpus, which underpins [NullRabbit Labs'](https://huggingface.co/NullRabbit) ML research on autonomous defence for decentralised networks. +A curated, multi-modal dataset of blockchain validator infrastructure under attack and benign workloads. **706 bundles** across **20 chains and network stacks** (Aptos, Bitcoin, Cardano, casper, conflux, Cosmos, Dogecoin, Ethereum, ic, icon, IOTA, kaspa, libp2p, Litecoin, Monero, Solana, Solana (Agave), Sui, XRP, zcash), all thirteen families in the taxonomy (twelve attack classes plus `benign`), and **132 attack primitive_ids** — including faithful wire-level reproductions of **68 publicly disclosed CVEs and security advisories** in blockchain node software. Released as the public sample of NullRabbit's bundle corpus, which underpins [NullRabbit Labs'](https://huggingface.co/NullRabbit) ML research on autonomous defence for decentralised networks. ## What this dataset is @@ -92,7 +92,7 @@ These are **validator / node-software** vulnerability classes only. On-chain con ## What's included -**690 bundles total: 683 attack, 7 benign.** By provenance class: **268 `original`** (NullRabbit's own disclosed findings, each with a published operator advisory), **31 legacy-sample** (the 2026-05-13 Solana/Sui curation), and **391 `public-cve-replication`** (faithful reproductions of already-public CVEs / advisories). The raw `packets.pcap` is dropped from every bundle (`BundleFiles.packets_pcap=False`); no pre-termination pcap variant is retained. +**706 bundles total: 699 attack, 7 benign.** By provenance class: **284 `original`** (NullRabbit's own disclosed findings, each with a published operator advisory), **31 legacy-sample** (the 2026-05-13 Solana/Sui curation), and **391 `public-cve-replication`** (faithful reproductions of already-public CVEs / advisories). The raw `packets.pcap` is dropped from every bundle (`BundleFiles.packets_pcap=False`); no pre-termination pcap variant is retained. The `Pcap modality` column in the tables below specifies which network-layer file is present on disk per bundle: `pre-term TLS` means `pcap_pre_termination.pcap` is retained (encrypted TLS frames; IP/TCP headers visible); `none` means the raw `packets.pcap` was dropped and no pre-term variant exists (`BundleFiles.packets_pcap=False` in the manifest). diff --git a/crp_0162b76bc2ad49f0/app.parquet b/crp_0162b76bc2ad49f0/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_0162b76bc2ad49f0/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_0162b76bc2ad49f0/host.parquet b/crp_0162b76bc2ad49f0/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_0162b76bc2ad49f0/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_0162b76bc2ad49f0/manifest.json b/crp_0162b76bc2ad49f0/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..8b48901b8ea775d391e83cd74af3f0dfff4d33f3 --- /dev/null +++ b/crp_0162b76bc2ad49f0/manifest.json @@ -0,0 +1,91 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_0162b76bc2ad49f0", + "attack_id": "atk_0162b76bc2ad49f0", + "genome_id": "8e339a1e0bd2f5ab", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_quic_halfopen_pin", + "posture": "distributed", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_quic_halfopen_pin_distributed_N500_r2", + "target_env": "ic-quic-transport", + "generation_method": "hand", + "started_at": "2026-07-09T15:34:18.022797Z", + "ended_at": "2026-07-09T15:34:20.838140Z", + "attack_parameters": { + "posture": "distributed", + "rep": 2, + "layer": "ic-quic-transport", + "attack_family_label": "quic_halfopen_pin", + "target_port": 56905, + "quic_port_prod": 4100, + "conns": 500, + "initial_datagram_bytes": 1200, + "crypto_declared_len": 4096, + "crypto_body_bytes": 200, + "distinct_scid_per_conn": true, + "first_byte_hex": "c3", + "quic_version": "00000001", + "per_ip_udp_cap": false, + "retry_address_validation": false, + "mtls_post_handshake": true, + "pace_s": 0.0, + "hold_s": 2.0, + "measured_rss_delta_mib_at_n": 25.5, + "measured_kib_per_conn_at_n": 128.0, + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "initials_attempted": 500, + "initials_sent": 500, + "distinct_scids": 500, + "bind_fail": 0, + "distinct_src_ips": 8, + "bytes_per_initial": 1200, + "bytes_sent_total": 600000 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_quic_halfopen": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/p2p/quic_transport/src/connection_manager.rs: the accept loop spawns every inbound QUIC Initial into an UNBOUNDED `inbound_connecting` JoinSet with `EndpointConfig::default()` (no Retry / no address validation) and NO per-source-IP UDP pre-handshake budget (`max_simultaneous_connections_per_ip_address` is TCP-only). The mTLS NodeId allow-list is enforced only AFTER the per-connection quinn/rustls state is committed, so certificate trust does not mitigate the pre-handshake pin.", + "source_note": "IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN.", + "class": "quic-halfopen-pin", + "source_class": "original", + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC quic_transport truncated-CRYPTO half-open QUIC Initial flood. IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN." +} diff --git a/crp_0162b76bc2ad49f0/protocol.parquet b/crp_0162b76bc2ad49f0/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_0162b76bc2ad49f0/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_0162b76bc2ad49f0/responses.parquet b/crp_0162b76bc2ad49f0/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_0162b76bc2ad49f0/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_0162b76bc2ad49f0/vectors.parquet b/crp_0162b76bc2ad49f0/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_0162b76bc2ad49f0/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_08607f4eb32f46db/app.parquet b/crp_08607f4eb32f46db/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_08607f4eb32f46db/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_08607f4eb32f46db/host.parquet b/crp_08607f4eb32f46db/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_08607f4eb32f46db/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_08607f4eb32f46db/manifest.json b/crp_08607f4eb32f46db/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..28a8042bf9ae8255fd1bc7153762ee49fd6c6f8f --- /dev/null +++ b/crp_08607f4eb32f46db/manifest.json @@ -0,0 +1,88 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_08607f4eb32f46db", + "attack_id": "atk_08607f4eb32f46db", + "genome_id": "740715e12c40a69d", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_xnet_concurrency_cap", + "posture": "low-volume", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_xnet_concurrency_cap_low-volume_p5_r0", + "target_env": "ic-xnet", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:25.789843Z", + "ended_at": "2026-07-09T15:32:28.592938Z", + "attack_parameters": { + "posture": "low-volume", + "rep": 0, + "layer": "ic-xnet-http", + "attack_family_label": "concurrency_cap_exhaustion", + "endpoint": "xnet stream pull", + "xnet_path": "/api/v1/stream/tdb26-jop6k-aogll-7ltgs-eruif-6kk7m-qbrjb-kux3o-r52nv-og6ef-mae?msg_begin=0&witness_begin=0&byte_limit=18446744073709551615", + "http_method": "GET", + "xnet_max_concurrent": 4, + "holders": 4, + "probes": 5, + "hold_s": 2.0, + "probe_pace_s": 0.0, + "holder_body_len": 532, + "byte_limit_query": 18446744073709551615, + "non_blocking_try_acquire": true, + "per_nodeid_rate_limit": false, + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_5th_request_immediate": true, + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_holder_body_len": 532, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All, lib.rs:261)", + "measured_byte_limit_unbounded": "byte_limit.unwrap_or(usize::MAX) (certified_slice_pool.rs:405)", + "measured_attacker_conns_to_saturate": 4, + "measured_severity": "MEDIUM", + "holders_fired": 4, + "probes_fired": 5, + "probe_503_count": 5, + "probe_200_count": 0, + "probe_other_count": 0, + "server_acquired_200": 4, + "server_rejected_503": 5, + "distinct_src_ips": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_xnet_concurrency_cap": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/http_endpoints/xnet/src/lib.rs:54 (const XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS: usize = 4), :156-168 (try_acquire_owned() NON-BLOCKING; overflow returns 503 body \"Queue full\" immediately, no queue), :214 (Semaphore::new(XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS)), :261 (tls.server_config(SomeOrAllNodes::All) admits ANY registered IC node); compounds with rs/xnet/payload_builder/src/certified_slice_pool.rs:405 (byte_limit.unwrap_or(usize::MAX), no clamp on the byte_limit query param).", + "source_note": "IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP.", + "class": "concurrency-cap-exhaustion", + "source_class": "original", + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All)", + "measured_byte_limit_unbounded": "usize::MAX (certified_slice_pool.rs:405)", + "measured_severity": "MEDIUM", + "source_anchors": "lib.rs:54,156-168,214,261; certified_slice_pool.rs:405", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC xnet 4-permit concurrency-cap exhaustion -> 503 'Queue full'. IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP." +} diff --git a/crp_08607f4eb32f46db/protocol.parquet b/crp_08607f4eb32f46db/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_08607f4eb32f46db/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_08607f4eb32f46db/responses.parquet b/crp_08607f4eb32f46db/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_08607f4eb32f46db/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_08607f4eb32f46db/vectors.parquet b/crp_08607f4eb32f46db/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_08607f4eb32f46db/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_0ca1b1ef67184f3c/app.parquet b/crp_0ca1b1ef67184f3c/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_0ca1b1ef67184f3c/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_0ca1b1ef67184f3c/host.parquet b/crp_0ca1b1ef67184f3c/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_0ca1b1ef67184f3c/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_0ca1b1ef67184f3c/manifest.json b/crp_0ca1b1ef67184f3c/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..8c501bbc99b052d912f732069a8b7895b7ff40dc --- /dev/null +++ b/crp_0ca1b1ef67184f3c/manifest.json @@ -0,0 +1,91 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_0ca1b1ef67184f3c", + "attack_id": "atk_0ca1b1ef67184f3c", + "genome_id": "7def912a4225e6bf", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_quic_halfopen_pin", + "posture": "saturating", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_quic_halfopen_pin_saturating_N1000_r1", + "target_env": "ic-quic-transport", + "generation_method": "hand", + "started_at": "2026-07-09T15:34:15.074153Z", + "ended_at": "2026-07-09T15:34:17.899321Z", + "attack_parameters": { + "posture": "saturating", + "rep": 1, + "layer": "ic-quic-transport", + "attack_family_label": "quic_halfopen_pin", + "target_port": 51386, + "quic_port_prod": 4100, + "conns": 1000, + "initial_datagram_bytes": 1200, + "crypto_declared_len": 4096, + "crypto_body_bytes": 200, + "distinct_scid_per_conn": true, + "first_byte_hex": "c3", + "quic_version": "00000001", + "per_ip_udp_cap": false, + "retry_address_validation": false, + "mtls_post_handshake": true, + "pace_s": 0.0, + "hold_s": 2.0, + "measured_rss_delta_mib_at_n": 129.0, + "measured_kib_per_conn_at_n": 132.0, + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "initials_attempted": 1000, + "initials_sent": 1000, + "distinct_scids": 1000, + "bind_fail": 0, + "distinct_src_ips": 1, + "bytes_per_initial": 1200, + "bytes_sent_total": 1200000 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_quic_halfopen": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/p2p/quic_transport/src/connection_manager.rs: the accept loop spawns every inbound QUIC Initial into an UNBOUNDED `inbound_connecting` JoinSet with `EndpointConfig::default()` (no Retry / no address validation) and NO per-source-IP UDP pre-handshake budget (`max_simultaneous_connections_per_ip_address` is TCP-only). The mTLS NodeId allow-list is enforced only AFTER the per-connection quinn/rustls state is committed, so certificate trust does not mitigate the pre-handshake pin.", + "source_note": "IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN.", + "class": "quic-halfopen-pin", + "source_class": "original", + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC quic_transport truncated-CRYPTO half-open QUIC Initial flood. IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN." +} diff --git a/crp_0ca1b1ef67184f3c/protocol.parquet b/crp_0ca1b1ef67184f3c/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_0ca1b1ef67184f3c/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_0ca1b1ef67184f3c/responses.parquet b/crp_0ca1b1ef67184f3c/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_0ca1b1ef67184f3c/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_0ca1b1ef67184f3c/vectors.parquet b/crp_0ca1b1ef67184f3c/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_0ca1b1ef67184f3c/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_2af3593c5c854c88/app.parquet b/crp_2af3593c5c854c88/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_2af3593c5c854c88/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_2af3593c5c854c88/host.parquet b/crp_2af3593c5c854c88/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_2af3593c5c854c88/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_2af3593c5c854c88/manifest.json b/crp_2af3593c5c854c88/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..1634d1d1af034a96ea4cf89db0ce7cf1047c2ea6 --- /dev/null +++ b/crp_2af3593c5c854c88/manifest.json @@ -0,0 +1,84 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_2af3593c5c854c88", + "attack_id": "atk_2af3593c5c854c88", + "genome_id": "19f098f8133c606e", + "assessment_id": null, + "family_id": "memory_amp", + "primitive_id": "ic_orchestrator_cup_body_bomb", + "posture": "saturating", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_orchestrator_cup_body_bomb_saturating_r1", + "target_env": "ic-orchestrator-cup-http1", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:11.015602Z", + "ended_at": "2026-07-09T15:32:11.828720Z", + "attack_parameters": { + "posture": "saturating", + "rep": 1, + "layer": "ic-orchestrator-http1", + "method": "GET", + "path": "/_/catch_up_package", + "attack_family_label": "http_body_bomb", + "transfer_encoding": "chunked", + "chunk_size_bytes": 1048576, + "pace_s": 0.0, + "n_flows": 1, + "request_bytes": 138, + "response_bytes_wire_per_flow": 25165824, + "response_bytes_wire_total": 25165824, + "amp_ratio_wire": 182361.0, + "response_wire_capped": true, + "no_http_body_util_limited": true, + "only_bound_is_timeout": true, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "faithful_ceiling_bytes_this_posture": 42949672960, + "response_bytes_read_total": 25166148, + "flows_completed": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_cup_body_bomb": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "dfinity/ic rs/orchestrator/src/catch_up_package_provider.rs:343-372 (timeout(self.backoff, res.into_body().collect()) \u2014 no http_body_util::Limited byte cap; secondary site rs/canister_client/src/http_client.rs:302)", + "source_note": "IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement.", + "class": "measured-memory-amplification", + "source_class": "original", + "attack_family_label": "http_body_bomb", + "measured_request_bytes": 138, + "measured_response_bytes": 42949672960, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_server_streamed_bytes_30s": 72048076390, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC orchestrator CUP body-bomb. IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement." +} diff --git a/crp_2af3593c5c854c88/protocol.parquet b/crp_2af3593c5c854c88/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_2af3593c5c854c88/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_2af3593c5c854c88/responses.parquet b/crp_2af3593c5c854c88/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_2af3593c5c854c88/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_2af3593c5c854c88/vectors.parquet b/crp_2af3593c5c854c88/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_2af3593c5c854c88/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_35e825bd25f44f66/app.parquet b/crp_35e825bd25f44f66/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_35e825bd25f44f66/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_35e825bd25f44f66/host.parquet b/crp_35e825bd25f44f66/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_35e825bd25f44f66/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_35e825bd25f44f66/manifest.json b/crp_35e825bd25f44f66/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..1bbb7d97f6edca48c012269dd182517ea26c848d --- /dev/null +++ b/crp_35e825bd25f44f66/manifest.json @@ -0,0 +1,88 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_35e825bd25f44f66", + "attack_id": "atk_35e825bd25f44f66", + "genome_id": "00cdf7a25c172242", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_xnet_concurrency_cap", + "posture": "distributed", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_xnet_concurrency_cap_distributed_p20_r2", + "target_env": "ic-xnet", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:31.883388Z", + "ended_at": "2026-07-09T15:32:34.686138Z", + "attack_parameters": { + "posture": "distributed", + "rep": 2, + "layer": "ic-xnet-http", + "attack_family_label": "concurrency_cap_exhaustion", + "endpoint": "xnet stream pull", + "xnet_path": "/api/v1/stream/tdb26-jop6k-aogll-7ltgs-eruif-6kk7m-qbrjb-kux3o-r52nv-og6ef-mae?msg_begin=0&witness_begin=0&byte_limit=18446744073709551615", + "http_method": "GET", + "xnet_max_concurrent": 4, + "holders": 4, + "probes": 20, + "hold_s": 2.0, + "probe_pace_s": 0.0, + "holder_body_len": 532, + "byte_limit_query": 18446744073709551615, + "non_blocking_try_acquire": true, + "per_nodeid_rate_limit": false, + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_5th_request_immediate": true, + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_holder_body_len": 532, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All, lib.rs:261)", + "measured_byte_limit_unbounded": "byte_limit.unwrap_or(usize::MAX) (certified_slice_pool.rs:405)", + "measured_attacker_conns_to_saturate": 4, + "measured_severity": "MEDIUM", + "holders_fired": 4, + "probes_fired": 20, + "probe_503_count": 20, + "probe_200_count": 0, + "probe_other_count": 0, + "server_acquired_200": 4, + "server_rejected_503": 20, + "distinct_src_ips": 8 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_xnet_concurrency_cap": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/http_endpoints/xnet/src/lib.rs:54 (const XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS: usize = 4), :156-168 (try_acquire_owned() NON-BLOCKING; overflow returns 503 body \"Queue full\" immediately, no queue), :214 (Semaphore::new(XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS)), :261 (tls.server_config(SomeOrAllNodes::All) admits ANY registered IC node); compounds with rs/xnet/payload_builder/src/certified_slice_pool.rs:405 (byte_limit.unwrap_or(usize::MAX), no clamp on the byte_limit query param).", + "source_note": "IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP.", + "class": "concurrency-cap-exhaustion", + "source_class": "original", + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All)", + "measured_byte_limit_unbounded": "usize::MAX (certified_slice_pool.rs:405)", + "measured_severity": "MEDIUM", + "source_anchors": "lib.rs:54,156-168,214,261; certified_slice_pool.rs:405", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC xnet 4-permit concurrency-cap exhaustion -> 503 'Queue full'. IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP." +} diff --git a/crp_35e825bd25f44f66/protocol.parquet b/crp_35e825bd25f44f66/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_35e825bd25f44f66/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_35e825bd25f44f66/responses.parquet b/crp_35e825bd25f44f66/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_35e825bd25f44f66/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_35e825bd25f44f66/vectors.parquet b/crp_35e825bd25f44f66/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_35e825bd25f44f66/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_3d7746a453fc4b6a/app.parquet b/crp_3d7746a453fc4b6a/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_3d7746a453fc4b6a/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_3d7746a453fc4b6a/host.parquet b/crp_3d7746a453fc4b6a/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_3d7746a453fc4b6a/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_3d7746a453fc4b6a/manifest.json b/crp_3d7746a453fc4b6a/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..be30343e7f035397bf33edfaaef9182655d7ad80 --- /dev/null +++ b/crp_3d7746a453fc4b6a/manifest.json @@ -0,0 +1,85 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_3d7746a453fc4b6a", + "attack_id": "atk_3d7746a453fc4b6a", + "genome_id": "6a8e0987b48d3120", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_ingress_pool_quota_miskey", + "posture": "distributed", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_ingress_pool_quota_miskey_distributed_N800_r2", + "target_env": "ic-ingress-http", + "generation_method": "hand", + "started_at": "2026-07-09T15:33:14.015718Z", + "ended_at": "2026-07-09T15:33:14.827430Z", + "attack_parameters": { + "posture": "distributed", + "rep": 2, + "layer": "ic-ingress-http", + "attack_family_label": "ingress_quota_flood", + "request_flood_family": "request_flood", + "endpoint": "/api/v2/canister/rrkah-fqaaa-aaaaa-aaaaq-cai/call", + "canister_id": "rrkah-fqaaa-aaaaa-aaaaq-cai", + "method": "POST", + "target_port": 43265, + "posts": 800, + "body_bytes": 250, + "ingress_pool_max_count": 10000, + "ingress_pool_max_bytes": 100000000, + "quota_keyed_on": "carrier_node_id", + "quota_should_key_on": "signing_principal", + "pace_s": 0.0, + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_on_state_change_ms": 200, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_msg_bytes": 250, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "posts_attempted": 800, + "posts_sent": 800, + "accepted_202": 800, + "bind_fail": 0, + "distinct_src_ips": 8, + "connections_used": 8, + "req_bytes": 393, + "bytes_sent_total": 314400 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_ingress_quota_flood": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 ingress-pool per-NodeId quota mis-key: HTTP-arriving ingress is inserted with node_id = self.node_id (the carrier replica's OWN NodeId) at rs/http_endpoints/public/src/call.rs:391 (self.node_id set call.rs:104), not the signing principal; the per-peer quota exceeds_limit() then gates one SHARED bucket (rs/artifact_pool/src/ingress_pool.rs:226-232, prod caps ingress_pool_max_count=10000 / ingress_pool_max_bytes=100000000 in rs/ic_os/config/tool/templates/ic.json5.template:49-50), and RemoveFromUnvalidated (rs/ingress_manager/src/ingress_handler.rs:60-76) purges ALL unvalidated ingress for that peer. The IC team's own stale TODO acknowledges the mis-key: rs/interfaces/src/ingress_pool.rs:22-25.", + "source_note": "IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY.", + "class": "ingress-quota-flood", + "source_class": "original", + "request_flood_family": "request_flood", + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC ingress-pool per-NodeId quota mis-key flood. IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY." +} diff --git a/crp_3d7746a453fc4b6a/protocol.parquet b/crp_3d7746a453fc4b6a/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_3d7746a453fc4b6a/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_3d7746a453fc4b6a/responses.parquet b/crp_3d7746a453fc4b6a/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_3d7746a453fc4b6a/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_3d7746a453fc4b6a/vectors.parquet b/crp_3d7746a453fc4b6a/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_3d7746a453fc4b6a/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_4c9486a4dddb453f/app.parquet b/crp_4c9486a4dddb453f/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_4c9486a4dddb453f/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_4c9486a4dddb453f/host.parquet b/crp_4c9486a4dddb453f/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_4c9486a4dddb453f/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_4c9486a4dddb453f/manifest.json b/crp_4c9486a4dddb453f/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..5facfa90c4dab5ea001b51e57bd9f0ebd5c7e76e --- /dev/null +++ b/crp_4c9486a4dddb453f/manifest.json @@ -0,0 +1,84 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_4c9486a4dddb453f", + "attack_id": "atk_4c9486a4dddb453f", + "genome_id": "c37c6f09e25d4b02", + "assessment_id": null, + "family_id": "memory_amp", + "primitive_id": "ic_orchestrator_cup_body_bomb", + "posture": "mimicry", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_orchestrator_cup_body_bomb_mimicry_r3", + "target_env": "ic-orchestrator-cup-http1", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:12.842438Z", + "ended_at": "2026-07-09T15:32:14.048168Z", + "attack_parameters": { + "posture": "mimicry", + "rep": 3, + "layer": "ic-orchestrator-http1", + "method": "GET", + "path": "/_/catch_up_package", + "attack_family_label": "http_body_bomb", + "transfer_encoding": "chunked", + "chunk_size_bytes": 65536, + "pace_s": 0.003, + "n_flows": 1, + "request_bytes": 138, + "response_bytes_wire_per_flow": 8388608, + "response_bytes_wire_total": 8388608, + "amp_ratio_wire": 60787.0, + "response_wire_capped": true, + "no_http_body_util_limited": true, + "only_bound_is_timeout": true, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "faithful_ceiling_bytes_this_posture": 42949672960, + "response_bytes_read_total": 8389844, + "flows_completed": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_cup_body_bomb": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "dfinity/ic rs/orchestrator/src/catch_up_package_provider.rs:343-372 (timeout(self.backoff, res.into_body().collect()) \u2014 no http_body_util::Limited byte cap; secondary site rs/canister_client/src/http_client.rs:302)", + "source_note": "IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement.", + "class": "measured-memory-amplification", + "source_class": "original", + "attack_family_label": "http_body_bomb", + "measured_request_bytes": 138, + "measured_response_bytes": 42949672960, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_server_streamed_bytes_30s": 72048076390, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC orchestrator CUP body-bomb. IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement." +} diff --git a/crp_4c9486a4dddb453f/protocol.parquet b/crp_4c9486a4dddb453f/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_4c9486a4dddb453f/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_4c9486a4dddb453f/responses.parquet b/crp_4c9486a4dddb453f/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_4c9486a4dddb453f/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_4c9486a4dddb453f/vectors.parquet b/crp_4c9486a4dddb453f/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_4c9486a4dddb453f/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_4c9cd93657b042b9/app.parquet b/crp_4c9cd93657b042b9/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_4c9cd93657b042b9/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_4c9cd93657b042b9/host.parquet b/crp_4c9cd93657b042b9/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_4c9cd93657b042b9/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_4c9cd93657b042b9/manifest.json b/crp_4c9cd93657b042b9/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..bf88eccd132bd4867f030d8bf4703a2b6d16ee2d --- /dev/null +++ b/crp_4c9cd93657b042b9/manifest.json @@ -0,0 +1,85 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_4c9cd93657b042b9", + "attack_id": "atk_4c9cd93657b042b9", + "genome_id": "e5efec0a7eb0407c", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_ingress_pool_quota_miskey", + "posture": "mimicry", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_ingress_pool_quota_miskey_mimicry_N300_r3", + "target_env": "ic-ingress-http", + "generation_method": "hand", + "started_at": "2026-07-09T15:33:14.898680Z", + "ended_at": "2026-07-09T15:33:16.931639Z", + "attack_parameters": { + "posture": "mimicry", + "rep": 3, + "layer": "ic-ingress-http", + "attack_family_label": "ingress_quota_flood", + "request_flood_family": "request_flood", + "endpoint": "/api/v2/canister/rrkah-fqaaa-aaaaa-aaaaq-cai/call", + "canister_id": "rrkah-fqaaa-aaaaa-aaaaq-cai", + "method": "POST", + "target_port": 38599, + "posts": 300, + "body_bytes": 250, + "ingress_pool_max_count": 10000, + "ingress_pool_max_bytes": 100000000, + "quota_keyed_on": "carrier_node_id", + "quota_should_key_on": "signing_principal", + "pace_s": 0.004, + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_on_state_change_ms": 200, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_msg_bytes": 250, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "posts_attempted": 300, + "posts_sent": 300, + "accepted_202": 300, + "bind_fail": 0, + "distinct_src_ips": 1, + "connections_used": 1, + "req_bytes": 393, + "bytes_sent_total": 117900 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_ingress_quota_flood": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 ingress-pool per-NodeId quota mis-key: HTTP-arriving ingress is inserted with node_id = self.node_id (the carrier replica's OWN NodeId) at rs/http_endpoints/public/src/call.rs:391 (self.node_id set call.rs:104), not the signing principal; the per-peer quota exceeds_limit() then gates one SHARED bucket (rs/artifact_pool/src/ingress_pool.rs:226-232, prod caps ingress_pool_max_count=10000 / ingress_pool_max_bytes=100000000 in rs/ic_os/config/tool/templates/ic.json5.template:49-50), and RemoveFromUnvalidated (rs/ingress_manager/src/ingress_handler.rs:60-76) purges ALL unvalidated ingress for that peer. The IC team's own stale TODO acknowledges the mis-key: rs/interfaces/src/ingress_pool.rs:22-25.", + "source_note": "IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY.", + "class": "ingress-quota-flood", + "source_class": "original", + "request_flood_family": "request_flood", + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC ingress-pool per-NodeId quota mis-key flood. IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY." +} diff --git a/crp_4c9cd93657b042b9/protocol.parquet b/crp_4c9cd93657b042b9/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_4c9cd93657b042b9/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_4c9cd93657b042b9/responses.parquet b/crp_4c9cd93657b042b9/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_4c9cd93657b042b9/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_4c9cd93657b042b9/vectors.parquet b/crp_4c9cd93657b042b9/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_4c9cd93657b042b9/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_5528b7b247e447bc/app.parquet b/crp_5528b7b247e447bc/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_5528b7b247e447bc/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_5528b7b247e447bc/host.parquet b/crp_5528b7b247e447bc/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_5528b7b247e447bc/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_5528b7b247e447bc/manifest.json b/crp_5528b7b247e447bc/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..b9f2085eb6300145b6fe8fee78e0ff8b5d3f42dd --- /dev/null +++ b/crp_5528b7b247e447bc/manifest.json @@ -0,0 +1,84 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_5528b7b247e447bc", + "attack_id": "atk_5528b7b247e447bc", + "genome_id": "e3606c366881f739", + "assessment_id": null, + "family_id": "memory_amp", + "primitive_id": "ic_orchestrator_cup_body_bomb", + "posture": "low-volume", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_orchestrator_cup_body_bomb_low-volume_r0", + "target_env": "ic-orchestrator-cup-http1", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:09.845939Z", + "ended_at": "2026-07-09T15:32:10.653124Z", + "attack_parameters": { + "posture": "low-volume", + "rep": 0, + "layer": "ic-orchestrator-http1", + "method": "GET", + "path": "/_/catch_up_package", + "attack_family_label": "http_body_bomb", + "transfer_encoding": "chunked", + "chunk_size_bytes": 1048576, + "pace_s": 0.0, + "n_flows": 1, + "request_bytes": 138, + "response_bytes_wire_per_flow": 8388608, + "response_bytes_wire_total": 8388608, + "amp_ratio_wire": 60787.0, + "response_wire_capped": true, + "no_http_body_util_limited": true, + "only_bound_is_timeout": true, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "faithful_ceiling_bytes_this_posture": 42949672960, + "response_bytes_read_total": 8388772, + "flows_completed": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_cup_body_bomb": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "dfinity/ic rs/orchestrator/src/catch_up_package_provider.rs:343-372 (timeout(self.backoff, res.into_body().collect()) \u2014 no http_body_util::Limited byte cap; secondary site rs/canister_client/src/http_client.rs:302)", + "source_note": "IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement.", + "class": "measured-memory-amplification", + "source_class": "original", + "attack_family_label": "http_body_bomb", + "measured_request_bytes": 138, + "measured_response_bytes": 42949672960, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_server_streamed_bytes_30s": 72048076390, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC orchestrator CUP body-bomb. IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement." +} diff --git a/crp_5528b7b247e447bc/protocol.parquet b/crp_5528b7b247e447bc/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_5528b7b247e447bc/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_5528b7b247e447bc/responses.parquet b/crp_5528b7b247e447bc/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_5528b7b247e447bc/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_5528b7b247e447bc/vectors.parquet b/crp_5528b7b247e447bc/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_5528b7b247e447bc/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_632d29e7c0004a91/app.parquet b/crp_632d29e7c0004a91/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_632d29e7c0004a91/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_632d29e7c0004a91/host.parquet b/crp_632d29e7c0004a91/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_632d29e7c0004a91/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_632d29e7c0004a91/manifest.json b/crp_632d29e7c0004a91/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..e9c8d5df6dbeebe25565462d6919ed88ed873446 --- /dev/null +++ b/crp_632d29e7c0004a91/manifest.json @@ -0,0 +1,84 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_632d29e7c0004a91", + "attack_id": "atk_632d29e7c0004a91", + "genome_id": "7b848b5e8942eb4c", + "assessment_id": null, + "family_id": "memory_amp", + "primitive_id": "ic_orchestrator_cup_body_bomb", + "posture": "distributed", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_orchestrator_cup_body_bomb_distributed_r2", + "target_env": "ic-orchestrator-cup-http1", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:11.957162Z", + "ended_at": "2026-07-09T15:32:12.769733Z", + "attack_parameters": { + "posture": "distributed", + "rep": 2, + "layer": "ic-orchestrator-http1", + "method": "GET", + "path": "/_/catch_up_package", + "attack_family_label": "http_body_bomb", + "transfer_encoding": "chunked", + "chunk_size_bytes": 1048576, + "pace_s": 0.0, + "n_flows": 4, + "request_bytes": 138, + "response_bytes_wire_per_flow": 6291456, + "response_bytes_wire_total": 25165824, + "amp_ratio_wire": 45590.3, + "response_wire_capped": true, + "no_http_body_util_limited": true, + "only_bound_is_timeout": true, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "faithful_ceiling_bytes_this_posture": 171798691840, + "response_bytes_read_total": 25166400, + "flows_completed": 4 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_cup_body_bomb": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "dfinity/ic rs/orchestrator/src/catch_up_package_provider.rs:343-372 (timeout(self.backoff, res.into_body().collect()) \u2014 no http_body_util::Limited byte cap; secondary site rs/canister_client/src/http_client.rs:302)", + "source_note": "IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement.", + "class": "measured-memory-amplification", + "source_class": "original", + "attack_family_label": "http_body_bomb", + "measured_request_bytes": 138, + "measured_response_bytes": 42949672960, + "measured_window_s": 30, + "measured_heap_pin_bytes_30s_window": 42949672960, + "measured_peak_rss_bytes": 58948426137, + "measured_server_streamed_bytes_30s": 72048076390, + "measured_heap_to_byte_ratio": 1.0, + "measured_prod_1gbps_bytes_per_req": 4026531840, + "measured_prod_10gbps_bytes_per_req": 40265318400, + "measured_backoff_doubles_per_round": true, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC orchestrator CUP body-bomb. IC orchestrator CUP body-bomb: the CUP-pull response path calls res.into_body().collect() bounded only by timeout(self.backoff, ...) \u2014 TIME not BYTES \u2014 with no http_body_util::Limited wrapper. A malicious subnet replica answers a CUP-pull GET with an unbounded chunked-transfer body; the requesting orchestrator accumulates the whole stream into a Collected heap buffer. Measured (hyper 1.x probe, 2026-05-26): +40 GB heap pin in one 30 s backoff window, peak RSS 54.9 GB, heap-to-bytes ratio ~1:1. Prod translation @ 30 s: 3.75 GB/req (1 Gbps) to 37.5 GB/req (10 Gbps); backoff doubles per failed round (30s->60s->120s). HIGH measured, subnet-internal reach. chains/ic/findings/IC_N2_CUP_BODY_BOMB; NullRabbit measurement." +} diff --git a/crp_632d29e7c0004a91/protocol.parquet b/crp_632d29e7c0004a91/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_632d29e7c0004a91/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_632d29e7c0004a91/responses.parquet b/crp_632d29e7c0004a91/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_632d29e7c0004a91/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_632d29e7c0004a91/vectors.parquet b/crp_632d29e7c0004a91/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_632d29e7c0004a91/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_8855ad184d6e4a79/app.parquet b/crp_8855ad184d6e4a79/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_8855ad184d6e4a79/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_8855ad184d6e4a79/host.parquet b/crp_8855ad184d6e4a79/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_8855ad184d6e4a79/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_8855ad184d6e4a79/manifest.json b/crp_8855ad184d6e4a79/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..5e79c5f0204966c6159eef22879dbc247a4a7d8e --- /dev/null +++ b/crp_8855ad184d6e4a79/manifest.json @@ -0,0 +1,91 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_8855ad184d6e4a79", + "attack_id": "atk_8855ad184d6e4a79", + "genome_id": "e969436dfb87b67f", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_quic_halfopen_pin", + "posture": "mimicry", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_quic_halfopen_pin_mimicry_N300_r3", + "target_env": "ic-quic-transport", + "generation_method": "hand", + "started_at": "2026-07-09T15:34:20.911194Z", + "ended_at": "2026-07-09T15:34:24.941794Z", + "attack_parameters": { + "posture": "mimicry", + "rep": 3, + "layer": "ic-quic-transport", + "attack_family_label": "quic_halfopen_pin", + "target_port": 33342, + "quic_port_prod": 4100, + "conns": 300, + "initial_datagram_bytes": 1200, + "crypto_declared_len": 4096, + "crypto_body_bytes": 200, + "distinct_scid_per_conn": true, + "first_byte_hex": "c3", + "quic_version": "00000001", + "per_ip_udp_cap": false, + "retry_address_validation": false, + "mtls_post_handshake": true, + "pace_s": 0.004, + "hold_s": 2.0, + "measured_rss_delta_mib_at_n": 25.5, + "measured_kib_per_conn_at_n": 128.0, + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "initials_attempted": 300, + "initials_sent": 300, + "distinct_scids": 300, + "bind_fail": 0, + "distinct_src_ips": 1, + "bytes_per_initial": 1200, + "bytes_sent_total": 360000 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_quic_halfopen": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/p2p/quic_transport/src/connection_manager.rs: the accept loop spawns every inbound QUIC Initial into an UNBOUNDED `inbound_connecting` JoinSet with `EndpointConfig::default()` (no Retry / no address validation) and NO per-source-IP UDP pre-handshake budget (`max_simultaneous_connections_per_ip_address` is TCP-only). The mTLS NodeId allow-list is enforced only AFTER the per-connection quinn/rustls state is committed, so certificate trust does not mitigate the pre-handshake pin.", + "source_note": "IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN.", + "class": "quic-halfopen-pin", + "source_class": "original", + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC quic_transport truncated-CRYPTO half-open QUIC Initial flood. IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN." +} diff --git a/crp_8855ad184d6e4a79/protocol.parquet b/crp_8855ad184d6e4a79/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_8855ad184d6e4a79/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_8855ad184d6e4a79/responses.parquet b/crp_8855ad184d6e4a79/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_8855ad184d6e4a79/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_8855ad184d6e4a79/vectors.parquet b/crp_8855ad184d6e4a79/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_8855ad184d6e4a79/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_9ee7605bc76c4f97/app.parquet b/crp_9ee7605bc76c4f97/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_9ee7605bc76c4f97/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_9ee7605bc76c4f97/host.parquet b/crp_9ee7605bc76c4f97/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_9ee7605bc76c4f97/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_9ee7605bc76c4f97/manifest.json b/crp_9ee7605bc76c4f97/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..23007f77c84a07d6a18fdcce8e62d711ce227c6a --- /dev/null +++ b/crp_9ee7605bc76c4f97/manifest.json @@ -0,0 +1,88 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_9ee7605bc76c4f97", + "attack_id": "atk_9ee7605bc76c4f97", + "genome_id": "4513d4d12a3f5a6b", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_xnet_concurrency_cap", + "posture": "mimicry", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_xnet_concurrency_cap_mimicry_p20_r3", + "target_env": "ic-xnet", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:34.757973Z", + "ended_at": "2026-07-09T15:32:37.560258Z", + "attack_parameters": { + "posture": "mimicry", + "rep": 3, + "layer": "ic-xnet-http", + "attack_family_label": "concurrency_cap_exhaustion", + "endpoint": "xnet stream pull", + "xnet_path": "/api/v1/stream/tdb26-jop6k-aogll-7ltgs-eruif-6kk7m-qbrjb-kux3o-r52nv-og6ef-mae?msg_begin=0&witness_begin=0&byte_limit=18446744073709551615", + "http_method": "GET", + "xnet_max_concurrent": 4, + "holders": 4, + "probes": 20, + "hold_s": 2.0, + "probe_pace_s": 0.02, + "holder_body_len": 532, + "byte_limit_query": 18446744073709551615, + "non_blocking_try_acquire": true, + "per_nodeid_rate_limit": false, + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_5th_request_immediate": true, + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_holder_body_len": 532, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All, lib.rs:261)", + "measured_byte_limit_unbounded": "byte_limit.unwrap_or(usize::MAX) (certified_slice_pool.rs:405)", + "measured_attacker_conns_to_saturate": 4, + "measured_severity": "MEDIUM", + "holders_fired": 4, + "probes_fired": 20, + "probe_503_count": 20, + "probe_200_count": 0, + "probe_other_count": 0, + "server_acquired_200": 4, + "server_rejected_503": 20, + "distinct_src_ips": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_xnet_concurrency_cap": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/http_endpoints/xnet/src/lib.rs:54 (const XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS: usize = 4), :156-168 (try_acquire_owned() NON-BLOCKING; overflow returns 503 body \"Queue full\" immediately, no queue), :214 (Semaphore::new(XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS)), :261 (tls.server_config(SomeOrAllNodes::All) admits ANY registered IC node); compounds with rs/xnet/payload_builder/src/certified_slice_pool.rs:405 (byte_limit.unwrap_or(usize::MAX), no clamp on the byte_limit query param).", + "source_note": "IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP.", + "class": "concurrency-cap-exhaustion", + "source_class": "original", + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All)", + "measured_byte_limit_unbounded": "usize::MAX (certified_slice_pool.rs:405)", + "measured_severity": "MEDIUM", + "source_anchors": "lib.rs:54,156-168,214,261; certified_slice_pool.rs:405", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC xnet 4-permit concurrency-cap exhaustion -> 503 'Queue full'. IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP." +} diff --git a/crp_9ee7605bc76c4f97/protocol.parquet b/crp_9ee7605bc76c4f97/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_9ee7605bc76c4f97/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_9ee7605bc76c4f97/responses.parquet b/crp_9ee7605bc76c4f97/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_9ee7605bc76c4f97/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_9ee7605bc76c4f97/vectors.parquet b/crp_9ee7605bc76c4f97/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_9ee7605bc76c4f97/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_b71d6cfe2701425b/app.parquet b/crp_b71d6cfe2701425b/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_b71d6cfe2701425b/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_b71d6cfe2701425b/host.parquet b/crp_b71d6cfe2701425b/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_b71d6cfe2701425b/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_b71d6cfe2701425b/manifest.json b/crp_b71d6cfe2701425b/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..65fa0a7fbd37786ca690f880531c7983a04018e9 --- /dev/null +++ b/crp_b71d6cfe2701425b/manifest.json @@ -0,0 +1,85 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_b71d6cfe2701425b", + "attack_id": "atk_b71d6cfe2701425b", + "genome_id": "9c0920ca028d34f9", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_ingress_pool_quota_miskey", + "posture": "saturating", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_ingress_pool_quota_miskey_saturating_N2000_r1", + "target_env": "ic-ingress-http", + "generation_method": "hand", + "started_at": "2026-07-09T15:33:13.066564Z", + "ended_at": "2026-07-09T15:33:13.891233Z", + "attack_parameters": { + "posture": "saturating", + "rep": 1, + "layer": "ic-ingress-http", + "attack_family_label": "ingress_quota_flood", + "request_flood_family": "request_flood", + "endpoint": "/api/v2/canister/rrkah-fqaaa-aaaaa-aaaaq-cai/call", + "canister_id": "rrkah-fqaaa-aaaaa-aaaaq-cai", + "method": "POST", + "target_port": 42229, + "posts": 2000, + "body_bytes": 250, + "ingress_pool_max_count": 10000, + "ingress_pool_max_bytes": 100000000, + "quota_keyed_on": "carrier_node_id", + "quota_should_key_on": "signing_principal", + "pace_s": 0.0, + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_on_state_change_ms": 200, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_msg_bytes": 250, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "posts_attempted": 2000, + "posts_sent": 2000, + "accepted_202": 2000, + "bind_fail": 0, + "distinct_src_ips": 1, + "connections_used": 1, + "req_bytes": 393, + "bytes_sent_total": 786000 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_ingress_quota_flood": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 ingress-pool per-NodeId quota mis-key: HTTP-arriving ingress is inserted with node_id = self.node_id (the carrier replica's OWN NodeId) at rs/http_endpoints/public/src/call.rs:391 (self.node_id set call.rs:104), not the signing principal; the per-peer quota exceeds_limit() then gates one SHARED bucket (rs/artifact_pool/src/ingress_pool.rs:226-232, prod caps ingress_pool_max_count=10000 / ingress_pool_max_bytes=100000000 in rs/ic_os/config/tool/templates/ic.json5.template:49-50), and RemoveFromUnvalidated (rs/ingress_manager/src/ingress_handler.rs:60-76) purges ALL unvalidated ingress for that peer. The IC team's own stale TODO acknowledges the mis-key: rs/interfaces/src/ingress_pool.rs:22-25.", + "source_note": "IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY.", + "class": "ingress-quota-flood", + "source_class": "original", + "request_flood_family": "request_flood", + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC ingress-pool per-NodeId quota mis-key flood. IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY." +} diff --git a/crp_b71d6cfe2701425b/protocol.parquet b/crp_b71d6cfe2701425b/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_b71d6cfe2701425b/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_b71d6cfe2701425b/responses.parquet b/crp_b71d6cfe2701425b/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_b71d6cfe2701425b/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_b71d6cfe2701425b/vectors.parquet b/crp_b71d6cfe2701425b/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_b71d6cfe2701425b/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_c76a21de065e4afe/app.parquet b/crp_c76a21de065e4afe/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_c76a21de065e4afe/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_c76a21de065e4afe/host.parquet b/crp_c76a21de065e4afe/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_c76a21de065e4afe/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_c76a21de065e4afe/manifest.json b/crp_c76a21de065e4afe/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..d9c6c15e185802f5eaf50baac6e24150b673b3a9 --- /dev/null +++ b/crp_c76a21de065e4afe/manifest.json @@ -0,0 +1,88 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_c76a21de065e4afe", + "attack_id": "atk_c76a21de065e4afe", + "genome_id": "5f34a78a301936db", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_xnet_concurrency_cap", + "posture": "saturating", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_xnet_concurrency_cap_saturating_p40_r1", + "target_env": "ic-xnet", + "generation_method": "hand", + "started_at": "2026-07-09T15:32:28.956891Z", + "ended_at": "2026-07-09T15:32:31.760131Z", + "attack_parameters": { + "posture": "saturating", + "rep": 1, + "layer": "ic-xnet-http", + "attack_family_label": "concurrency_cap_exhaustion", + "endpoint": "xnet stream pull", + "xnet_path": "/api/v1/stream/tdb26-jop6k-aogll-7ltgs-eruif-6kk7m-qbrjb-kux3o-r52nv-og6ef-mae?msg_begin=0&witness_begin=0&byte_limit=18446744073709551615", + "http_method": "GET", + "xnet_max_concurrent": 4, + "holders": 4, + "probes": 40, + "hold_s": 2.0, + "probe_pace_s": 0.0, + "holder_body_len": 532, + "byte_limit_query": 18446744073709551615, + "non_blocking_try_acquire": true, + "per_nodeid_rate_limit": false, + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_5th_request_immediate": true, + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_holder_body_len": 532, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All, lib.rs:261)", + "measured_byte_limit_unbounded": "byte_limit.unwrap_or(usize::MAX) (certified_slice_pool.rs:405)", + "measured_attacker_conns_to_saturate": 4, + "measured_severity": "MEDIUM", + "holders_fired": 4, + "probes_fired": 40, + "probe_503_count": 40, + "probe_200_count": 0, + "probe_other_count": 0, + "server_acquired_200": 4, + "server_rejected_503": 40, + "distinct_src_ips": 1 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_xnet_concurrency_cap": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/http_endpoints/xnet/src/lib.rs:54 (const XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS: usize = 4), :156-168 (try_acquire_owned() NON-BLOCKING; overflow returns 503 body \"Queue full\" immediately, no queue), :214 (Semaphore::new(XNET_ENDPOINT_MAX_CONCURRENT_REQUESTS)), :261 (tls.server_config(SomeOrAllNodes::All) admits ANY registered IC node); compounds with rs/xnet/payload_builder/src/certified_slice_pool.rs:405 (byte_limit.unwrap_or(usize::MAX), no clamp on the byte_limit query param).", + "source_note": "IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP.", + "class": "concurrency-cap-exhaustion", + "source_class": "original", + "measured_cap": 4, + "measured_5th_request_status": 503, + "measured_5th_request_body": "Queue full", + "measured_new_xnet_rejection_pct_while_held": 100, + "measured_reach": "any-registered-IC-node (TLS SomeOrAllNodes::All)", + "measured_byte_limit_unbounded": "usize::MAX (certified_slice_pool.rs:405)", + "measured_severity": "MEDIUM", + "source_anchors": "lib.rs:54,156-168,214,261; certified_slice_pool.rs:405", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC xnet 4-permit concurrency-cap exhaustion -> 503 'Queue full'. IC xnet endpoint concurrency-cap DoS (IC_N3_XNET_CONCURRENCY_CAP): the replica's cross-subnet xnet stream HTTP endpoint caps concurrent requests at a hard-coded 4 (lib.rs:54) enforced by a NON-BLOCKING try_acquire_owned() (lib.rs:156-168) \u2014 when all 4 permits are held, the 5th+ request returns an immediate 503 \"Queue full\" with NO queuing. TLS SomeOrAllNodes::All (lib.rs:261) admits any registered IC node, so a single host holding 4 concurrent slow xnet GETs denies 100% of new cross-subnet xnet stream pulls on that replica; each held request can be made arbitrarily slow via byte_limit=usize::MAX (certified_slice_pool.rs:405, no clamp). Measured (in-process Rust integration test on FakeStateManager w/ an encode barrier, dfinity/ic @ HEAD): 4 GETs take all permits; 5th GET -> 503 \"Queue full\" immediately; after release the 4 complete 200 + 532-byte body. MEDIUM measured; reach = any-registered-IC-node. NullRabbit measurement; chains/ic/findings/IC_N3_XNET_CONCURRENCY_CAP." +} diff --git a/crp_c76a21de065e4afe/protocol.parquet b/crp_c76a21de065e4afe/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_c76a21de065e4afe/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_c76a21de065e4afe/responses.parquet b/crp_c76a21de065e4afe/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_c76a21de065e4afe/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_c76a21de065e4afe/vectors.parquet b/crp_c76a21de065e4afe/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_c76a21de065e4afe/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_e2080b6569104e4f/app.parquet b/crp_e2080b6569104e4f/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_e2080b6569104e4f/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_e2080b6569104e4f/host.parquet b/crp_e2080b6569104e4f/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_e2080b6569104e4f/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_e2080b6569104e4f/manifest.json b/crp_e2080b6569104e4f/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..8504ad3c4aad937fdf75dd26337fa74b246e45cc --- /dev/null +++ b/crp_e2080b6569104e4f/manifest.json @@ -0,0 +1,91 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_e2080b6569104e4f", + "attack_id": "atk_e2080b6569104e4f", + "genome_id": "e5b55cd2fa621457", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_quic_halfopen_pin", + "posture": "low-volume", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_quic_halfopen_pin_low-volume_N200_r0", + "target_env": "ic-quic-transport", + "generation_method": "hand", + "started_at": "2026-07-09T15:34:11.922330Z", + "ended_at": "2026-07-09T15:34:14.728870Z", + "attack_parameters": { + "posture": "low-volume", + "rep": 0, + "layer": "ic-quic-transport", + "attack_family_label": "quic_halfopen_pin", + "target_port": 40738, + "quic_port_prod": 4100, + "conns": 200, + "initial_datagram_bytes": 1200, + "crypto_declared_len": 4096, + "crypto_body_bytes": 200, + "distinct_scid_per_conn": true, + "first_byte_hex": "c3", + "quic_version": "00000001", + "per_ip_udp_cap": false, + "retry_address_validation": false, + "mtls_post_handshake": true, + "pace_s": 0.0, + "hold_s": 2.0, + "measured_rss_delta_mib_at_n": 25.5, + "measured_kib_per_conn_at_n": 128.0, + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "initials_attempted": 200, + "initials_sent": 200, + "distinct_scids": 200, + "bind_fail": 0, + "distinct_src_ips": 1, + "bytes_per_initial": 1200, + "bytes_sent_total": 240000 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_quic_halfopen": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 rs/p2p/quic_transport/src/connection_manager.rs: the accept loop spawns every inbound QUIC Initial into an UNBOUNDED `inbound_connecting` JoinSet with `EndpointConfig::default()` (no Retry / no address validation) and NO per-source-IP UDP pre-handshake budget (`max_simultaneous_connections_per_ip_address` is TCP-only). The mTLS NodeId allow-list is enforced only AFTER the per-connection quinn/rustls state is committed, so certificate trust does not mitigate the pre-handshake pin.", + "source_note": "IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN.", + "class": "quic-halfopen-pin", + "source_class": "original", + "measured_ceiling_conns": 3000, + "measured_ceiling_rss_delta_mib": 278, + "measured_ceiling_abs_rss_mib": 420, + "measured_per_conn_kib": 100, + "measured_total_conns": 12200, + "measured_rejected_at_admission": 0, + "measured_binary": "release-2026-05-29_04-44-base", + "measured_commit": "a47e5434753752c1d2972fbc4407d14f88964285", + "measured_date": "2026-06-02", + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC quic_transport truncated-CRYPTO half-open QUIC Initial flood. IC quic_transport half-open QUIC handshake memory pin (IC_QUIC_HALFOPEN_PIN): a burst of QUIC v1 Initial packets (distinct SCID each) whose CRYPTO frame declares a large TLS handshake length (4096) but delivers a truncated ClientHello (~200 B) leaves rustls 'incomplete, waiting', so each `Connecting` future lives to the pre-handshake timeout pinning ~100 KiB/conn. No Retry (EndpointConfig::default()), no per-IP UDP cap, mTLS only after state is committed. Measured on the real replica (release-2026-05-29_04-44-base, commit a47e543, 2026-06-02): n=200 -> +25.5 MiB (~128 KiB/conn), n=1000 -> +129 MiB (~132 KiB/conn), n=3000 -> +278 MiB (abs 420 MiB, ~95 KiB/conn); across 12,200 total connections ZERO were rejected at admission. MEDIUM/5.9 (bounded only by IC's default-deny firewall + 512 GiB replica RAM, not by any transport control). NullRabbit measurement; chains/ic/findings/IC_QUIC_HALFOPEN_PIN." +} diff --git a/crp_e2080b6569104e4f/protocol.parquet b/crp_e2080b6569104e4f/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_e2080b6569104e4f/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_e2080b6569104e4f/responses.parquet b/crp_e2080b6569104e4f/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_e2080b6569104e4f/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_e2080b6569104e4f/vectors.parquet b/crp_e2080b6569104e4f/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_e2080b6569104e4f/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251 diff --git a/crp_f429f9830d1e4a64/app.parquet b/crp_f429f9830d1e4a64/app.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5c538df9bc7a2a57731e0c51939ebf996f61bc61 --- /dev/null +++ b/crp_f429f9830d1e4a64/app.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481da1c6744c62c1697ee9d78f528efa36b1fec759b70bbcfdca056a4124fc7 +size 799 diff --git a/crp_f429f9830d1e4a64/host.parquet b/crp_f429f9830d1e4a64/host.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbb8f319b03dce6f3fc161286de05cb39094daab --- /dev/null +++ b/crp_f429f9830d1e4a64/host.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc1886fd35a0399b467738294b28b397750fcbc4e58a1184074185564d56799 +size 2163 diff --git a/crp_f429f9830d1e4a64/manifest.json b/crp_f429f9830d1e4a64/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..008b9c786e676ad40d6dc9581e441ffe991a3628 --- /dev/null +++ b/crp_f429f9830d1e4a64/manifest.json @@ -0,0 +1,85 @@ +{ + "bundle_version": 3, + "shape": "v0.0", + "corpus_id": "crp_f429f9830d1e4a64", + "attack_id": "atk_f429f9830d1e4a64", + "genome_id": "a5f88d8d3039412c", + "assessment_id": null, + "family_id": "connection_exhaustion", + "primitive_id": "ic_ingress_pool_quota_miskey", + "posture": "low-volume", + "ground_truth_label": "attack", + "chain": "ic", + "run_tag": "knownclass_ic_ic_ingress_pool_quota_miskey_low-volume_N200_r0", + "target_env": "ic-ingress-http", + "generation_method": "hand", + "started_at": "2026-07-09T15:33:11.850236Z", + "ended_at": "2026-07-09T15:33:12.654828Z", + "attack_parameters": { + "posture": "low-volume", + "rep": 0, + "layer": "ic-ingress-http", + "attack_family_label": "ingress_quota_flood", + "request_flood_family": "request_flood", + "endpoint": "/api/v2/canister/rrkah-fqaaa-aaaaa-aaaaq-cai/call", + "canister_id": "rrkah-fqaaa-aaaaa-aaaaq-cai", + "method": "POST", + "target_port": 41387, + "posts": 200, + "body_bytes": 250, + "ingress_pool_max_count": 10000, + "ingress_pool_max_bytes": 100000000, + "quota_keyed_on": "carrier_node_id", + "quota_should_key_on": "signing_principal", + "pace_s": 0.0, + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_on_state_change_ms": 200, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_msg_bytes": 250, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "posts_attempted": 200, + "posts_sent": 200, + "accepted_202": 200, + "bind_fail": 0, + "distinct_src_ips": 1, + "connections_used": 1, + "req_bytes": 393, + "bytes_sent_total": 78600 + }, + "expected_detection_signature": null, + "files": { + "packets_pcap": false, + "host_parquet": false, + "app_parquet": false, + "protocol_parquet": false, + "responses_parquet": false, + "vectors_parquet": false + }, + "provenance": { + "traffic_source": "reproducer-attack", + "fidelity_class": "lab", + "target_authorisation": "self-owned", + "engagement_id": null, + "tooling": { + "known_class_ic_ingress_quota_flood": "1.0" + }, + "pcap_path_pre_termination": null, + "public_source": "https://github.com/dfinity/ic \u2014 ingress-pool per-NodeId quota mis-key: HTTP-arriving ingress is inserted with node_id = self.node_id (the carrier replica's OWN NodeId) at rs/http_endpoints/public/src/call.rs:391 (self.node_id set call.rs:104), not the signing principal; the per-peer quota exceeds_limit() then gates one SHARED bucket (rs/artifact_pool/src/ingress_pool.rs:226-232, prod caps ingress_pool_max_count=10000 / ingress_pool_max_bytes=100000000 in rs/ic_os/config/tool/templates/ic.json5.template:49-50), and RemoveFromUnvalidated (rs/ingress_manager/src/ingress_handler.rs:60-76) purges ALL unvalidated ingress for that peer. The IC team's own stale TODO acknowledges the mis-key: rs/interfaces/src/ingress_pool.rs:22-25.", + "source_note": "IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY.", + "class": "ingress-quota-flood", + "source_class": "original", + "request_flood_family": "request_flood", + "measured_trip_inserts": 10001, + "measured_trip_seconds": 0.04, + "measured_purge_pct": 100, + "measured_sustain_rate_ingress_per_s": 50000, + "measured_subnet_replicas": 40, + "measured_subnet_bandwidth_mb": 40, + "tcpdump_returncode": 0, + "capture_module": "chains._shared.capture_multimodal" + }, + "notes": "known-class repro (traffic): IC ingress-pool per-NodeId quota mis-key flood. IC ingress-pool per-NodeId quota mis-key (IC_N1_INGRESS_POOL_QUOTA_MISKEY): every HTTP-arriving ingress message buckets under the carrier replica's own NodeId instead of the signing principal (call.rs:391), so a single shared per-NodeId quota gates ALL public HTTP ingress. Submitting 10001 small signed HTTP ingress POSTs trips exceeds_limit (measured 0.04s at production caps 10000 / 100 MB); the handler's RemoveFromUnvalidated then purges 100% of legit unvalidated HTTP ingress on that replica at the next on_state_change (~200ms). PUBLIC reach; ~50k signed-ingress/s keeps a replica wiped; ~40 MB total bandwidth pins a 40-replica subnet. NullRabbit measurement; chains/ic/findings/IC_N1_INGRESS_POOL_QUOTA_MISKEY." +} diff --git a/crp_f429f9830d1e4a64/protocol.parquet b/crp_f429f9830d1e4a64/protocol.parquet new file mode 100644 index 0000000000000000000000000000000000000000..44de77e6073f68441da4408fdcdd1daf48388d78 --- /dev/null +++ b/crp_f429f9830d1e4a64/protocol.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cc978adb6fc415efd0c3dc66bd47af0dc0fe5bdcfd6129d106c1cc641e588de +size 797 diff --git a/crp_f429f9830d1e4a64/responses.parquet b/crp_f429f9830d1e4a64/responses.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf0b4e3d59317ca79e85e94c8714066e05272d76 --- /dev/null +++ b/crp_f429f9830d1e4a64/responses.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5b145951e316bd7c0e9ac9e5aa7f05ca332bc6c331ca38e4cb3e2abf2ab5e3 +size 1372 diff --git a/crp_f429f9830d1e4a64/vectors.parquet b/crp_f429f9830d1e4a64/vectors.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1023217fdf5e80644a3f8d5d0b750e2dd7f30d94 --- /dev/null +++ b/crp_f429f9830d1e4a64/vectors.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab15a2780e523a85575b39dba1d925185ecc6efbf770ccea302960bcb048e69a +size 1251