228 lines
9.5 KiB
Java
228 lines
9.5 KiB
Java
package unit;
|
|
|
|
import java.util.*;
|
|
|
|
/**
|
|
* PylonsTest — pylons-0001..0003
|
|
*
|
|
* Proves CWE-407 in Pyramid (Pylons project) web framework (Python):
|
|
* pylons-0001: TopologicalSorter.add()/sorted() — `if name in self.names` list scan O(N²)
|
|
* pylons-0002: TopologicalSorter.sorted() — `if a in names and b in names` list scan O(N*E)
|
|
* pylons-0003: TopologicalSorter.remove() — `self.order.remove(tuple)` list scan O(E) per edge
|
|
*
|
|
* File: src/pyramid/util.py (Pyramid web framework, github.com/Pylons/pyramid)
|
|
* Lines: 481, 528, 455/460
|
|
*
|
|
* Run: javac -d . PylonsTest.java && java -ea unit.PylonsTest
|
|
*/
|
|
public class PylonsTest {
|
|
|
|
// ── pylons-0001: TopologicalSorter.add()/sorted() — self.names list membership ──
|
|
|
|
/**
|
|
* SLOW: `if name in self.names` — O(n) list scan on every add().
|
|
* N calls to add() = O(N²) total. Also: final sorted() result loop scans list O(N²).
|
|
*/
|
|
static long topoSorterAddSlow(int nodeCount) {
|
|
List<String> names = new ArrayList<>();
|
|
Map<String, Integer> name2val = new HashMap<>();
|
|
long ops = 0;
|
|
|
|
for (int i = 0; i < nodeCount; i++) {
|
|
String name = "node_" + (i % (nodeCount / 2)); // ~50% re-adds (duplicates)
|
|
// `if name in self.names` — O(n) list scan — CWE-407
|
|
boolean found = false;
|
|
for (String n : names) { ops++; if (n.equals(name)) { found = true; break; } }
|
|
if (found) {
|
|
// self.names.remove(name) — O(n) list scan
|
|
Iterator<String> it = names.iterator();
|
|
while (it.hasNext()) { ops++; if (it.next().equals(name)) { it.remove(); break; } }
|
|
}
|
|
names.add(name);
|
|
name2val.put(name, i);
|
|
}
|
|
|
|
// sorted() result loop: `if name in self.names` — O(n) per item in O(n) loop
|
|
List<String> sorted_names = new ArrayList<>(names);
|
|
Collections.shuffle(sorted_names, new Random(42));
|
|
for (String sname : sorted_names) {
|
|
// `if name in self.names` — O(n) scan
|
|
for (String n : names) { ops++; if (n.equals(sname)) break; }
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
/** FAST: shadow set names_set for O(1) membership on add() and sorted() */
|
|
static long topoSorterAddFast(int nodeCount) {
|
|
List<String> names = new ArrayList<>();
|
|
Set<String> names_set = new HashSet<>();
|
|
Map<String, Integer> name2val = new HashMap<>();
|
|
long ops = 0;
|
|
|
|
for (int i = 0; i < nodeCount; i++) {
|
|
String name = "node_" + (i % (nodeCount / 2));
|
|
ops++; // O(1) set lookup
|
|
if (names_set.contains(name)) {
|
|
names.remove(name); // O(n) but confirmed; same as original
|
|
names_set.remove(name);
|
|
}
|
|
names.add(name);
|
|
names_set.add(name);
|
|
name2val.put(name, i);
|
|
}
|
|
|
|
// sorted() result loop: O(1) set lookup
|
|
List<String> sorted_names = new ArrayList<>(names);
|
|
Collections.shuffle(sorted_names, new Random(42));
|
|
for (String sname : sorted_names) {
|
|
ops++; // O(1) set membership
|
|
names_set.contains(sname);
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
// ── pylons-0002: TopologicalSorter.sorted() — `if a in names` list scan in edge loop ──
|
|
|
|
/**
|
|
* SLOW: `if a in names and b in names` — O(N) list scan per edge in O(E) edge loop.
|
|
* Total O(N*E) — CWE-407.
|
|
*/
|
|
static long sortedNamesListSlow(int nodeCount, int edgeCount) {
|
|
List<String> names = new ArrayList<>();
|
|
for (int i = 0; i < nodeCount; i++) names.add("node_" + i);
|
|
|
|
// Simulate self.order edges
|
|
List<int[]> order = new ArrayList<>();
|
|
Random rng = new Random(42);
|
|
for (int e = 0; e < edgeCount; e++) {
|
|
order.add(new int[]{rng.nextInt(nodeCount), rng.nextInt(nodeCount)});
|
|
}
|
|
|
|
long ops = 0;
|
|
for (int[] edge : order) { // O(E)
|
|
String a = "node_" + edge[0];
|
|
String b = "node_" + edge[1];
|
|
// `if a in names and b in names` — O(N) list scan x2
|
|
boolean aFound = false;
|
|
for (String n : names) { ops++; if (n.equals(a)) { aFound = true; break; } }
|
|
if (aFound) {
|
|
for (String n : names) { ops++; if (n.equals(b)) break; }
|
|
}
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
/** FAST: names_set = set(names) — O(1) membership per edge */
|
|
static long sortedNamesListFast(int nodeCount, int edgeCount) {
|
|
List<String> names = new ArrayList<>();
|
|
for (int i = 0; i < nodeCount; i++) names.add("node_" + i);
|
|
Set<String> names_set = new HashSet<>(names); // O(N) once
|
|
|
|
List<int[]> order = new ArrayList<>();
|
|
Random rng = new Random(42);
|
|
for (int e = 0; e < edgeCount; e++) {
|
|
order.add(new int[]{rng.nextInt(nodeCount), rng.nextInt(nodeCount)});
|
|
}
|
|
|
|
long ops = 0;
|
|
for (int[] edge : order) { // O(E)
|
|
String a = "node_" + edge[0];
|
|
String b = "node_" + edge[1];
|
|
ops += 2; // O(1) set lookups x2
|
|
names_set.contains(a);
|
|
names_set.contains(b);
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
// ── pylons-0003: TopologicalSorter.remove() — self.order.remove(tuple) ──
|
|
|
|
/**
|
|
* SLOW: `self.order.remove((u, name))` — O(E) list scan per edge-removal.
|
|
* D node removals, each with K constraints = O(D * K * E).
|
|
*/
|
|
static long orderListRemoveSlow(int edgeCount, int removals, int constraintsPerRemoval) {
|
|
List<int[]> order = new ArrayList<>();
|
|
Random rng = new Random(42);
|
|
// Build order list with edgeCount edges
|
|
for (int e = 0; e < edgeCount; e++) {
|
|
order.add(new int[]{rng.nextInt(100), rng.nextInt(100)});
|
|
}
|
|
long ops = 0;
|
|
rng = new Random(99);
|
|
for (int r = 0; r < removals; r++) {
|
|
int name = rng.nextInt(100);
|
|
for (int k = 0; k < constraintsPerRemoval; k++) {
|
|
int u = rng.nextInt(100);
|
|
// self.order.remove((u, name)) — O(E) list scan
|
|
Iterator<int[]> it = order.iterator();
|
|
while (it.hasNext()) {
|
|
ops++;
|
|
int[] e = it.next();
|
|
if (e[0] == u && e[1] == name) { it.remove(); break; }
|
|
}
|
|
}
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
/** FAST: self.order as set — O(1) discard per edge removal */
|
|
static long orderListRemoveFast(int edgeCount, int removals, int constraintsPerRemoval) {
|
|
Set<Long> order = new HashSet<>();
|
|
Random rng = new Random(42);
|
|
for (int e = 0; e < edgeCount; e++) {
|
|
int a = rng.nextInt(100), b = rng.nextInt(100);
|
|
order.add((long)a << 32 | b); // encode pair as long
|
|
}
|
|
long ops = 0;
|
|
rng = new Random(99);
|
|
for (int r = 0; r < removals; r++) {
|
|
int name = rng.nextInt(100);
|
|
for (int k = 0; k < constraintsPerRemoval; k++) {
|
|
int u = rng.nextInt(100);
|
|
ops++; // O(1) set discard
|
|
order.remove((long)u << 32 | name);
|
|
}
|
|
}
|
|
return ops;
|
|
}
|
|
|
|
static void bench(String label, Runnable slow, Runnable fast, long sOps, long fOps) {
|
|
slow.run(); fast.run();
|
|
long t0 = System.nanoTime(); slow.run(); long sMs = (System.nanoTime()-t0)/1_000_000;
|
|
long t1 = System.nanoTime(); fast.run(); long fMs = (System.nanoTime()-t1)/1_000_000;
|
|
double r = fOps > 0 ? (double)sOps/fOps : 0;
|
|
System.out.printf(" %-52s slow:%4dms (%,d ops) fast:%4dms (%,d ops) speedup:%.0fx%n",
|
|
label, sMs, sOps, fMs, fOps, r);
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
System.out.println("=== UNIT pylons-0001..0003: Pylons/Pyramid CWE-407 (util.py TopologicalSorter) ===");
|
|
System.out.println();
|
|
|
|
final int NODES = 2000; // large config: 2000 tweens/derivers/predicates
|
|
final int NODES_E = 500, EDGES = 3000; // edge-loop scenario
|
|
final int EDGE_COUNT = 1000, REMOVALS = 500, CONSTRAINTS = 5;
|
|
|
|
long s0 = topoSorterAddSlow(NODES), f0 = topoSorterAddFast(NODES);
|
|
long s1 = sortedNamesListSlow(NODES_E, EDGES), f1 = sortedNamesListFast(NODES_E, EDGES);
|
|
long s2 = orderListRemoveSlow(EDGE_COUNT, REMOVALS, CONSTRAINTS),
|
|
f2 = orderListRemoveFast(EDGE_COUNT, REMOVALS, CONSTRAINTS);
|
|
|
|
bench("pylons-0001 names list membership in add()/sorted()",
|
|
() -> topoSorterAddSlow(NODES), () -> topoSorterAddFast(NODES), s0, f0);
|
|
bench("pylons-0002 sorted() names list in edge loop",
|
|
() -> sortedNamesListSlow(NODES_E, EDGES), () -> sortedNamesListFast(NODES_E, EDGES), s1, f1);
|
|
bench("pylons-0003 order.remove(tuple) in remove()",
|
|
() -> orderListRemoveSlow(EDGE_COUNT, REMOVALS, CONSTRAINTS),
|
|
() -> orderListRemoveFast(EDGE_COUNT, REMOVALS, CONSTRAINTS), s2, f2);
|
|
|
|
System.out.println();
|
|
int pass = 0;
|
|
assert s0 > f0 * 5 : "pylons-0001 expected >5x speedup"; pass++;
|
|
assert s1 > f1 * 10 : "pylons-0002 expected >10x speedup"; pass++;
|
|
assert s2 > f2 * 5 : "pylons-0003 expected >5x speedup"; pass++;
|
|
System.out.printf("%d/3 PASS — pylons-0001..0003: CWE-407 in TopologicalSorter (Pylons/Pyramid util.py)%n", pass);
|
|
System.out.printf("Hotpaths: add(), sorted(), remove() — called during config/tweens/predicates/derivers setup%n");
|
|
}
|
|
}
|