whitepaper: 312 sites / 151 ecosystems — wave2+3 defect tables and PDF rebuild

Add 88 new defect entries to HIGH and MEDIUM tables:
  HIGH: mysql-0001/0002, mariadb-0001, redis-0001/0002, valkey-0001/0002, openvpn-0001,
        vlc-0001, prometheus-0001, otel-collector-0001, cockroachdb-0001..0004,
        tidb-0001..0008, kubernetes-0001/0002, go-0001, kotlin-0002, scala-0001,
        allegro5-0001, sdl2-0001, grafana-0001, clickhouse-0001, duckdb-0001,
        mongodb-0001, envoy-0001, istio-0001, cilium-0001, linkerd2-0001,
        linux-0001/0002/0003, tor-0002/0003, curl-0001, julia-0001, lua-0001,
        perl5-0001, nats-0001, spring-0003/0004, tomcat-0001, onos-0002, odl-0002

  MEDIUM: helm-0001, mariadb-0002, openssl-0001/0002, memcached-0001,
          cassandra-0001..0004, flink-0001, storm-0001/0002, zookeeper-0001..0003,
          pip-0001, gradle-0001, nginx-0001, haproxy-0001, caddy-0001, varnish-0001,
          ffmpeg-0001, gstreamer-0001, raylib-0001, love2d-0001, php-0001/0002,
          r-source-0001, cpython-0002, ruby-0001, rabbitmq-0003/0004, activemq-0001,
          ovs-0001, onos-0003, odl-0002, jetty-0001

PDF: 976K

defects/onos/unit/OnosRoleInfoTest.java

@@ -0,0 +1,112 @@
+package unit;
+
+/**
+ * CWE-407 unit test: ONOS RoleInfo.backups() ImmutableList.contains()
+ * Defect: ImmutableList<NodeId>.contains() O(n) on every mastership role event
+ * Fix:    ImmutableSet<NodeId>.contains() O(1)
+ *
+ * slow(): ImmutableList.contains() — scanned linearly per call
+ * fast(): ImmutableSet.contains()  — O(1) hash lookup per call
+ * Assert: slowOps > fastOps * 5   (C=100 cluster nodes → ~5000 vs ~100 ops)
+ */
+public class OnosRoleInfoTest {
+
+    static class NodeId {
+        final String id;
+        static long slowEqCalls = 0;
+        static long fastEqCalls = 0;
+        final boolean instrumented;
+
+        NodeId(String id, boolean instrumented) {
+            this.id = id;
+            this.instrumented = instrumented;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (instrumented) slowEqCalls++;
+            if (!(o instanceof NodeId)) return false;
+            return id.equals(((NodeId) o).id);
+        }
+
+        @Override
+        public int hashCode() {
+            return id.hashCode();
+        }
+    }
+
+    static class NodeIdFast {
+        final String id;
+
+        NodeIdFast(String id) { this.id = id; }
+
+        @Override
+        public boolean equals(Object o) {
+            NodeId.fastEqCalls++;
+            if (!(o instanceof NodeIdFast)) return false;
+            return id.equals(((NodeIdFast) o).id);
+        }
+
+        @Override
+        public int hashCode() {
+            return id.hashCode();
+        }
+    }
+
+    /** Slow: ImmutableList — O(n) contains per lookup, called D*C times (D devices, C controllers). */
+    static long slow(int clusterSize, int lookups) {
+        java.util.List<NodeId> backups = new java.util.ArrayList<>();
+        for (int i = 1; i < clusterSize; i++) {
+            backups.add(new NodeId("node-" + i, true));
+        }
+        com.google.common.collect.ImmutableList<NodeId> immList =
+            com.google.common.collect.ImmutableList.copyOf(backups);
+
+        NodeId.slowEqCalls = 0;
+        NodeId target = new NodeId("node-" + (clusterSize - 1), false);
+        for (int i = 0; i < lookups; i++) {
+            boolean found = false;
+            for (NodeId n : immList) {
+                if (n.equals(target)) { found = true; break; }
+            }
+        }
+        return NodeId.slowEqCalls;
+    }
+
+    /** Fast: ImmutableSet — O(1) contains per lookup. */
+    static long fast(int clusterSize, int lookups) {
+        java.util.Set<NodeIdFast> backups = new java.util.HashSet<>();
+        for (int i = 1; i < clusterSize; i++) {
+            backups.add(new NodeIdFast("node-" + i));
+        }
+        com.google.common.collect.ImmutableSet<NodeIdFast> immSet =
+            com.google.common.collect.ImmutableSet.copyOf(backups);
+
+        NodeId.fastEqCalls = 0;
+        NodeIdFast target = new NodeIdFast("node-" + (clusterSize - 1));
+        for (int i = 0; i < lookups; i++) {
+            immSet.contains(target);
+        }
+        return NodeId.fastEqCalls;
+    }
+
+    public static void main(String[] args) {
+        int C = 50;    // cluster size
+        int D = 100;   // number of device role events
+        int MULTIPLIER = 5;
+
+        long sOps = slow(C, D);
+        long fOps = fast(C, D);
+
+        System.out.println("C=" + C + " nodes, D=" + D + " events");
+        System.out.println("slow (ImmutableList.contains): " + sOps + " equals() calls");
+        System.out.println("fast (ImmutableSet.contains):  " + fOps + " equals() calls");
+
+        if (sOps > fOps * MULTIPLIER) {
+            System.out.println("1/1 PASS (slow=" + sOps + " > fast*" + MULTIPLIER + "=" + (fOps * MULTIPLIER) + ")");
+        } else {
+            System.out.println("1/1 FAIL (slow=" + sOps + " not > fast*" + MULTIPLIER + "=" + (fOps * MULTIPLIER) + ")");
+            System.exit(1);
+        }
+    }
+}