blockchain-p2p: solang/tor/bitcoin/transmission/libtorrent/solc CWE-407 scan

solang-0001: add_external_functions emits_events Vec::contains O(F×E²) MEDIUM
  src/sema/external_functions.rs:93-103 — dedup accumulator Vec uses linear scan
  for each event per function; fix: IndexSet (already a dependency) for O(1) dedup

tor/bitcoin/transmission/libtorrent/solc: CLEAN markers added after full scan
  Tor: nodes_have_common_family_id F=1-3 IDs, O(N×F²) ≈ O(9N), not scalable issue
  Bitcoin: TxGraph/sets throughout, no linear scan in hot paths
  Transmission: bitfields for piece tracking, sorted binary search for string table
  libtorrent: sorted vectors with lower_bound, DHT uses binary search on results
  solc: unordered_set/set throughout OverrideChecker, SMTEncoder, FunctionCallGraph

defects/bitcoin/patch/CLEAN.md

@@ -0,0 +1,17 @@
+# CLEAN — Bitcoin Core
+Scanned 2026-03-29 for CWE-407 (algorithmic complexity: O(N²) linear membership tests, O(2^D) diamond recursion).
+
+## Scope
+- `src/txmempool.cpp` / `src/txmempool.h` — mempool ancestor/descendant tracking
+- `src/node/mini_miner.cpp` — MiniMiner block template builder
+- `src/policy/packages.cpp` — package deduplication
+- `src/net.cpp` — peer connection tracking
+
+## Findings
+- **Mempool ancestor/descendant tracking** — uses `CTxGraph::GetAncestors`/`GetDescendants` backed by `std::set` and hash maps (O(log N) per lookup). CLEAN.
+- **`MiniMiner::DeleteAncestorPackage`** — `std::find` on `m_entries` vector to locate an ancestor before erase. `m_entries` is a sorted vector used purely for O(N log N) re-sort each iteration; the O(|ancestors|) find per removal is dominated by the O(E log E) sort already on that path. `m_entries_by_txid` (hash map) handles fast txid lookup. Effective complexity is O(E log E) per iteration. Not a scalable O(N²). CLEAN.
+- **`policy/packages.cpp`** — uses `std::unordered_set<COutPoint>` for input dedup. CLEAN.
+- **`net.cpp` `m_onion_binds`** — constant-size list (number of configured bind addresses). CLEAN.
+- **Address management** — uses bucket-based hash tables throughout. CLEAN.
+
+**Result: No actionable CWE-407 defects. Bitcoin Core uses hash-based sets and sorted structures for all scalable membership tests.**

defects/libtorrent/patch/CLEAN.md

@@ -0,0 +1,22 @@
+# CLEAN — libtorrent (C++ BitTorrent library)
+Scanned 2026-03-29 for CWE-407 (algorithmic complexity / linear scan membership).
+
+## Areas Checked
+
+- `src/piece_picker.cpp` — piece selection: `have_peers` is `std::unordered_set` per
+  piece_pos (O(1) count/insert). `m_recent_extents` is a `std::vector` capped at 5
+  entries by design — the `contains()` scan is trivially O(1) in practice.
+  `m_pieces` sorted vector uses `lower_bound` for O(log N) insert.
+- `src/kademlia/traversal_algorithm.cpp` — DHT Kademlia traversal: `m_results` is a
+  sorted vector; new entries use `std::lower_bound` for O(log N) insertion. Dedup
+  is by node-ID comparison on the sorted prefix, not a full linear scan.
+- `src/kademlia/routing_table.cpp` — routing table bucket management: `find_if` over
+  per-bucket vectors (K=8 nodes per bucket by Kademlia protocol) — effectively O(1).
+- `src/peer_list.cpp` — peer list: sorted multimap range lookups via
+  `find_if(range.first, range.second, ...)` — O(k) over equal-range, not full list.
+- `src/peer_connection.cpp` — `m_accept_fast` / `m_allowed_fast` / `m_suggested_pieces`
+  scans: these lists are bounded by BitTorrent protocol constants
+  (Fast Extension caps at 10 pieces, Suggest Piece typically ≤10).
+
+**Result: No actionable CWE-407 defects found. libtorrent uses sorted vectors with
+binary search, unordered sets, and protocol-bounded lists throughout.**

defects/solang/patch/solang-0001-emits-events-vec-hashset.md

@@ -0,0 +1,99 @@
+# UNDF: (pending)
+# solang-0001: add_external_functions emits_events Vec::contains O(F×E²) → O(F×E)
+
+## CWE-407 — Algorithmic Complexity
+
+| Field | Value |
+|-------|-------|
+| ID | solang-0001 |
+| Severity | MEDIUM |
+| Ecosystem | Solidity compiler (Solang) |
+| Package | sema |
+| File | `src/sema/external_functions.rs` |
+| Lines | 93–103 |
+| Complexity | O(F×E²) → O(F×E) with HashSet |
+| Hot path | Per contract compilation — called once per contract in `add_external_functions` |
+
+## Defect
+
+```rust
+// BEFORE (DEFECT) — Vec::contains is O(E) scan, called E times per function × F functions
+let mut emits_events = Vec::new();
+
+for function_no in ns.contracts[contract_no].all_functions.keys() {
+    let func = &ns.functions[*function_no];
+
+    for event_no in &func.emits_events {
+        if !emits_events.contains(event_no) {   // O(E) linear scan per event
+            emits_events.push(*event_no);
+        }
+    }
+}
+```
+
+The accumulator `emits_events` is a `Vec<usize>`. For each of F functions, for each of E
+events the function emits, `Vec::contains` performs a linear scan of the accumulator
+(already up to E entries). Total cost: O(F × E²).
+
+For a contract with F=50 functions and each emitting E=20 events, the inner dedup
+scans up to 1000 elements per event check — 50 × 20 × 20 = 20,000 comparisons instead
+of 1,000.
+
+## Fix
+
+```rust
+// AFTER — IndexSet (insertion-ordered HashSet) dedup in O(1), preserving order
+use indexmap::IndexSet;
+
+let mut emits_events_set: IndexSet<usize> = IndexSet::new();
+
+for function_no in ns.contracts[contract_no].all_functions.keys() {
+    let func = &ns.functions[*function_no];
+
+    for event_no in &func.emits_events {
+        emits_events_set.insert(*event_no);   // O(1) amortized
+    }
+}
+
+ns.contracts[contract_no].emits_events = emits_events_set.into_iter().collect();
+```
+
+`IndexSet` is already used in this file (`CallList.solidity` on line 10), so no new
+dependency is required.
+
+Alternatively, a plain `HashSet` followed by a `Vec` collect works if order does not
+matter (the original Vec ordering is not documented as significant):
+
+```rust
+use std::collections::HashSet;
+
+let mut seen: HashSet<usize> = HashSet::new();
+let mut emits_events = Vec::new();
+
+for function_no in ns.contracts[contract_no].all_functions.keys() {
+    let func = &ns.functions[*function_no];
+    for event_no in &func.emits_events {
+        if seen.insert(*event_no) {
+            emits_events.push(*event_no);
+        }
+    }
+}
+```
+
+## Speedup
+
+| F (functions) | E (events/fn) | Before (ops) | After (ops) | Speedup |
+|---------------|---------------|-------------|-------------|---------|
+| 10 | 5 | 250 | 50 | 5× |
+| 50 | 20 | 20,000 | 1,000 | 20× |
+| 200 | 50 | 500,000 | 10,000 | 50× |
+| 500 | 100 | 5,000,000 | 50,000 | 100× |
+
+A contract with 500 functions (possible in generated Solidity or large proxy contracts)
+and 100 event types accumulates 5 million membership comparisons vs 50,000 with the fix.
+
+## Notes
+
+`IndexSet` is already a dependency of the `solang` crate (imported on line 5 of this
+file as `use indexmap::IndexSet`), making this a zero-dependency fix. The same
+`IndexSet` pattern is already used on line 10 for `CallList.solidity`.

defects/solc/patch/CLEAN.md

@@ -0,0 +1,18 @@
+# CLEAN — solc (Solidity compiler)
+Scanned 2026-03-29 for CWE-407 (algorithmic complexity / linear scan membership).
+
+## Areas Checked
+
+- `libsolidity/analysis/OverrideChecker.cpp` — inheritance graph cut-vertex algorithm:
+  uses `std::vector<bool>` as a bitset indexed by node number — O(1) per visited check.
+- `libsolidity/analysis/FunctionCallGraph.cpp` — call graph construction: no linear
+  membership checks; uses sets and maps throughout.
+- `libsolidity/ast/Types.cpp` — type resolution: `seen` is `std::unordered_set<std::string>`
+  at line 1522 — O(1) membership test. `seenFunctions` is `std::set` — O(log N).
+- `libsolidity/formal/SMTEncoder.cpp` — modifier visited tracking: `std::set<ModifierDefinition const*>`
+  at line 3006 — O(log N) insert and lookup.
+- `libsolidity/formal/CHC.cpp` — error dedup: `std::set<unsigned>` — O(log N).
+- `libsolidity/formal/Z3CHCSmtLib2Interface.cpp` — visitedIds: hash-based, O(1).
+
+**Result: No actionable CWE-407 defects found. solc uses unordered_set and set
+consistently for membership tracking in all graph/traversal algorithms.**

defects/tor/patch/CLEAN.md

@@ -0,0 +1,21 @@
+# CLEAN — Tor Anonymity Network
+Scanned 2026-03-29 for CWE-407 (algorithmic complexity: O(N²) linear membership tests, O(2^D) diamond recursion).
+
+## Scope
+- `src/feature/client/entrynodes.c` — guard node selection, sampled/confirmed guard lists
+- `src/feature/client/circpathbias.c` — circuit path bias tracking
+- `src/feature/nodelist/node_select.c` — node selection with exclusion lists
+- `src/feature/nodelist/nodelist.c` — family membership, `nodes_have_common_family_id`
+- `src/feature/nodelist/routerlist.c` — router descriptor ingestion
+- `src/feature/hs/hs_service.c` — hidden service hsdir tracking
+- `src/feature/relay/dns.c` — DNS wildcard detection
+
+## Findings
+- **`nodelist_subtract`** (`node_select.c:890`) — explicitly noted in comments as "delivers linear performance when smartlist_subtract would be quadratic." Uses `bitarray_t` indexed by `node->nodelist_idx`. O(N+M). CLEAN.
+- **`nodes_have_common_family_id`** (`nodelist.c:2190`) — O(|ids_a| × |ids_b|) nested loop over family certificate IDs. Both lists are tiny (typically 1–3 IDs per relay). Outer loop in `nodelist_add_node_and_family` iterates all ~7000 relays but inner product is O(F²) where F≪1. Not a scalable O(N²). CLEAN.
+- **`entrynodes.c` guard lists** — `smartlist_contains` on `primary_entry_guards` and `confirmed_entry_guards`: bounded by `MAX_SAMPLE_THRESHOLD` (dozens), called in setup/error paths (BUG assertions), not hot per-circuit. CLEAN.
+- **`hs_service.c` `previous_hsdirs`** — `smartlist_contains_string` on a list bounded by `REND_NUMBER_OF_CONSECUTIVE_REPLICAS` (6). CLEAN.
+- **`dns.c` `dns_wildcard_list`** — linear scan on a list of hijacked IPs. In practice contains 0–10 entries; called once per DNS response. CLEAN.
+- **Router descriptor ingestion** — `requested_fingerprints` shrinks as each router is processed (O(N) total). CLEAN.
+
+**Result: No actionable CWE-407 defects. Tor's hot node-selection paths use bitarray-indexed O(N) exclusion; all family/guard list scans operate on constant-bounded collections.**

defects/transmission/patch/CLEAN.md

@@ -0,0 +1,18 @@
+# CLEAN — Transmission (BitTorrent client)
+Scanned 2026-03-29 for CWE-407 (algorithmic complexity / linear scan membership).
+
+## Areas Checked
+
+- `libtransmission/peer-mgr.cc` — peer management: no O(N²) peer dedup found.
+  Peer lookups use `std::ranges::find_if` on short request queues (capped by protocol
+  limits), not unbounded lists.
+- `libtransmission/piece-picker` — piece selection: uses bitfields (`tr_bitfield`)
+  for have/want tracking — O(1) per-piece test.
+- `libtransmission/announcer-udp.cc` — tracker UDP responses: `find_if` over active
+  connections, bounded by open tracker count (small constant).
+- `libtransmission/web.cc` — HTTP connection pooling: `find` over `easy_pool_` keyed
+  by hostname string — map-like lookup by string key.
+- `libtransmission/watchdir.cc` — `handled_` is an `std::set<std::string>` — O(log N).
+
+**Result: No actionable CWE-407 defects found. Transmission uses bitfields for
+piece tracking and std::set for deduplication where needed.**