engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gitlab-foss: 5 CWE-407 defects — Network::Graph find_free_space/overlap O(R*S), NotificationService mentioned_users O(R*M), RefreshService commit_ids O(MR*C), Project#members_among O(U*A); 4/4 PASS

Browse source
This commit is contained in:
russell@unturf.com 2026-03-30 14:55:33 -04:00
parent 0623a342b1
commit 99e627481e
7 changed files with 292 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
defects/gitlab-foss/unit/GitlabFossTest.class Normal file
View file

Binary file not shown.

201
defects/gitlab-foss/unit/GitlabFossTest.java Normal file
View file

@ -0,0 +1,201 @@
import java.util.*;
/**
* CWE-407 unit tests for GitLab CE (gitlab-foss) defects.
*
* Simulates the Ruby Array#include? vs Set#include? patterns found in:
* gitlab-foss-0001: Network::Graph#find_free_space reserved array scan
* gitlab-foss-0002: Network::Graph#overlap? spaces array scan
* gitlab-foss-0003: MergeRequests::RefreshService commit_ids array scan
* gitlab-foss-0004: Project#members_among user_ids array scan
*
* NotificationService (gitlab-foss-0002 in patch numbering, 0002 in UNDF)
* is combined with the general "select with include?" pattern in test 4.
*/
public class GitlabFossTest {
// ---------------------------------------------------------------
// gitlab-foss-0001: Network::Graph#find_free_space
// Array#include? in while loop to find unreserved space number
// ---------------------------------------------------------------
static long findFreeSpaceDefect(List<Integer> reserved, int spaceDefault, int spaceBase, int spaceStep) {
long ops = 0;
int space = spaceDefault;
while (reserved.contains(space)) { // O(R) per iteration
ops += reserved.size();
space += spaceStep;
if (space < spaceBase) {
spaceStep *= -1;
space = spaceBase + spaceStep;
}
}
return ops;
}
static long findFreeSpaceFixed(List<Integer> reserved, int spaceDefault, int spaceBase, int spaceStep) {
long ops = 0;
Set<Integer> reservedSet = new HashSet<>(reserved); // O(R) one-time
int space = spaceDefault;
while (reservedSet.contains(space)) { // O(1) per iteration
ops++;
space += spaceStep;
if (space < spaceBase) {
spaceStep *= -1;
space = spaceBase + spaceStep;
}
}
return ops;
}
// ---------------------------------------------------------------
// gitlab-foss-0002: Network::Graph#overlap?
// spaces.include?(overlap_space) inside range loop
// ---------------------------------------------------------------
static long overlapDefect(List<List<Integer>> commitSpaces, int rangeStart, int rangeEnd, int overlapSpace) {
long ops = 0;
for (int i = rangeStart; i <= rangeEnd; i++) {
if (i != rangeStart && i != rangeEnd) {
// Array#include? on spaces list
List<Integer> spaces = commitSpaces.get(i);
for (int s : spaces) {
ops++;
if (s == overlapSpace) break;
}
}
}
return ops;
}
static long overlapFixed(List<List<Integer>> commitSpaces, int rangeStart, int rangeEnd, int overlapSpace) {
long ops = 0;
for (int i = rangeStart; i <= rangeEnd; i++) {
if (i != rangeStart && i != rangeEnd) {
Set<Integer> spacesSet = new HashSet<>(commitSpaces.get(i));
ops++; // O(1) lookup
spacesSet.contains(overlapSpace);
}
}
return ops;
}
// ---------------------------------------------------------------
// gitlab-foss-0003: RefreshService#post_merge_manually_merged
// commit_ids.include?(mr.diff_head_sha) inside .select
// ---------------------------------------------------------------
static long commitIdsScanDefect(List<String> commitIds, List<String> mrHeadShas) {
long ops = 0;
for (String sha : mrHeadShas) {
for (String cid : commitIds) {
ops++;
if (cid.equals(sha)) break;
}
}
return ops;
}
static long commitIdsScanFixed(List<String> commitIds, List<String> mrHeadShas) {
long ops = 0;
Set<String> commitSet = new HashSet<>(commitIds);
for (String sha : mrHeadShas) {
ops++;
commitSet.contains(sha);
}
return ops;
}
// ---------------------------------------------------------------
// gitlab-foss-0004: Project#members_among
// user_ids.include?(user.id) inside .select
// Also covers NotificationService new_mentioned_users.include?(r.user)
// ---------------------------------------------------------------
static long membersAmongDefect(List<Integer> userIds, List<Integer> inputUsers) {
long ops = 0;
for (int uid : inputUsers) {
for (int aid : userIds) {
ops++;
if (aid == uid) break;
}
}
return ops;
}
static long membersAmongFixed(List<Integer> userIds, List<Integer> inputUsers) {
long ops = 0;
Set<Integer> idSet = new HashSet<>(userIds);
for (int uid : inputUsers) {
ops++;
idSet.contains(uid);
}
return ops;
}
// ---------------------------------------------------------------
// Test runner
// ---------------------------------------------------------------
public static void main(String[] args) {
int pass = 0, fail = 0;
// Test 1: find_free_space — reserved array with 500 entries, searching for free space
{
List<Integer> reserved = new ArrayList<>();
for (int i = 1; i <= 500; i++) reserved.add(i); // spaces 1..500 reserved
long defectOps = findFreeSpaceDefect(reserved, 1, 1, 2);
long fixedOps = findFreeSpaceFixed(reserved, 1, 1, 2);
double ratio = (double) defectOps / Math.max(fixedOps, 1);
boolean ok = ratio > 5.0;
System.out.printf("TEST 1 find_free_space: defect=%d fixed=%d ratio=%.1fx %s%n",
defectOps, fixedOps, ratio, ok ? "PASS" : "FAIL");
if (ok) pass++; else fail++;
}
// Test 2: overlap? — 300 commits, each with 100 spaces
{
List<List<Integer>> commitSpaces = new ArrayList<>();
for (int i = 0; i < 300; i++) {
List<Integer> spaces = new ArrayList<>();
for (int s = 0; s < 100; s++) spaces.add(s);
commitSpaces.add(spaces);
}
long defectOps = overlapDefect(commitSpaces, 0, 299, 999); // space not found
long fixedOps = overlapFixed(commitSpaces, 0, 299, 999);
double ratio = (double) defectOps / Math.max(fixedOps, 1);
boolean ok = ratio > 5.0;
System.out.printf("TEST 2 overlap?: defect=%d fixed=%d ratio=%.1fx %s%n",
defectOps, fixedOps, ratio, ok ? "PASS" : "FAIL");
if (ok) pass++; else fail++;
}
// Test 3: post_merge_manually_merged — 500 commits, 50 MRs
{
List<String> commitIds = new ArrayList<>();
for (int i = 0; i < 500; i++) commitIds.add("sha_" + i);
List<String> mrHeadShas = new ArrayList<>();
for (int i = 0; i < 50; i++) mrHeadShas.add("mr_sha_" + i); // none match
long defectOps = commitIdsScanDefect(commitIds, mrHeadShas);
long fixedOps = commitIdsScanFixed(commitIds, mrHeadShas);
double ratio = (double) defectOps / Math.max(fixedOps, 1);
boolean ok = ratio > 5.0;
System.out.printf("TEST 3 commit_ids scan: defect=%d fixed=%d ratio=%.1fx %s%n",
defectOps, fixedOps, ratio, ok ? "PASS" : "FAIL");
if (ok) pass++; else fail++;
}
// Test 4: members_among / notification mentioned_users — 500 IDs, 200 input users
{
List<Integer> userIds = new ArrayList<>();
for (int i = 0; i < 500; i++) userIds.add(i);
List<Integer> inputUsers = new ArrayList<>();
for (int i = 1000; i < 1200; i++) inputUsers.add(i); // none match
long defectOps = membersAmongDefect(userIds, inputUsers);
long fixedOps = membersAmongFixed(userIds, inputUsers);
double ratio = (double) defectOps / Math.max(fixedOps, 1);
boolean ok = ratio > 5.0;
System.out.printf("TEST 4 members_among: defect=%d fixed=%d ratio=%.1fx %s%n",
defectOps, fixedOps, ratio, ok ? "PASS" : "FAIL");
if (ok) pass++; else fail++;
}
System.out.printf("%n%d/%d PASS%n", pass, pass + fail);
if (fail > 0) System.exit(1);
}
}