@miraj181/ipingyou 2.0.5 → 2.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraj181/ipingyou",
-  "version": "2.0.5",
+  "version": "2.0.8",
   "description": "SecureLink-CLI — Secure peer-to-peer remote access via SSH & Cloudflare Tunnels",
   "main": "src/cli.js",
   "bin": {
@@ -9,13 +9,14 @@
   },
   "files": [
     "src/cli.js",
+    "src/server.js",
     "src/lib/",
     "src/modes/",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "start": "node src/cli.js",
+    "start": "node src/server.js",
     "dev:cli": "node src/cli.js",
     "prepublishOnly": "node -e \"require('fs').accessSync('LICENSE')\" && node src/cli.js --help"
   },
@@ -50,7 +51,10 @@
     "open": "^11.0.0",
     "ora": "^8.1.1",
     "tree-kill": "^1.2.2",
-    "ws": "^8.20.1"
+    "ws": "^8.20.1",
+    "express": "^4.19.2",
+    "express-rate-limit": "^7.3.1",
+    "helmet": "^7.1.0"
   },
   "devDependencies": {
     "nodemon": "^3.1.4"
@@ -59,4 +63,4 @@
     "node": ">=18.0.0"
   },
   "type": "module"
-}
+}

package/src/lib/chat.js

@@ -190,6 +190,7 @@ const HTML_CONTENT = `
       input.focus();
       
       const encPayload = await encryptPayload({ type: 'join', sender: username });
+      ws.send(JSON.stringify({ type: 'join_event', username })); // Send unencrypted name for sidebar
       ws.send(JSON.stringify({ type: 'e2e', payload: encPayload }));
     };
 
@@ -291,8 +292,8 @@ export async function startChatServer(onClose) {
             // E2E messages just get forwarded to all clients
             broadcastMsg(data);
           } else if (data.type === 'join_event') {
-             // For updating participant count dynamically if we wanted to extract sender, 
-             // but since E2E hides sender, we rely on connection count
+            clients.set(ws, data.username || `User_${Math.floor(Math.random()*1000)}`);
+            broadcastState();
           } else if (data.type === 'host_close') {
             broadcastMsg({ type: 'close' });
             server.close();
@@ -304,18 +305,11 @@ export async function startChatServer(onClose) {
       });
 
       ws.on('close', () => {
-        // Since we can't read the encrypted username, we just update state
         clients.delete(ws);
         broadcastState();
       });
     });
 
-    // When connection opens, just assign a generic ID to count them
-    wss.on('connection', (ws) => {
-      clients.set(ws, `User_${Math.floor(Math.random()*1000)}`);
-      broadcastState();
-    });
-
     server.listen(0, '127.0.0.1', () => {
       const port = server.address().port;
       resolve({ port, server });

package/src/modes/client.js

@@ -124,14 +124,14 @@ async function resolveUID(uid, password, silent = false) {
     }
 
     if (!payloadConfig.url.startsWith('https://')) {
-      spinner.fail('Decrypted data is not a valid tunnel URL (incorrect password)');
+      if (spinner) spinner.fail('Decrypted data is not a valid tunnel URL (incorrect password)');
       return null;
     }
 
-    spinner.succeed(`Resolved: ${chalk.dim(payloadConfig.url)} ${chalk.green('[decrypted locally]')}`);
+    if (spinner) spinner.succeed(`Resolved: ${chalk.dim(payloadConfig.url)} ${chalk.green('[decrypted locally]')}`);
     return payloadConfig;
   } catch (err) {
-    spinner.fail(`Broker lookup failed: ${err.message}`);
+    if (spinner) spinner.fail(`Broker lookup failed: ${err.message}`);
     return null;
   }
 }

package/src/modes/host.js

@@ -449,14 +449,12 @@ async function hostDashboard(uid, tunnelUrl, password, serviceConfig, tunnelProc
         }
 
         case 'exit':
-          clearInterval(monitorInterval);
           if (tunnelProcess) tunnelProcess.kill();
           if (chatTunnelProcess) chatTunnelProcess.kill();
           if (global.privateBrokerInstance) global.privateBrokerInstance.kill();
           return;
       }
     } catch (err) {
-      clearInterval(monitorInterval);
       throw err;
     }
   };

package/src/server.js

@@ -0,0 +1,263 @@
+/**
+ * ============================================================
+ *  SecureLink-CLI — Central Broker Server
+ * ============================================================
+ *  A lightweight REST relay that pairs hosts and clients via
+ *  temporary UIDs.  The broker is a DUMB PIPE — it stores and
+ *  returns encrypted blobs without ever seeing plaintext.
+ *  Encryption/decryption happens ONLY on the CLI side.
+ * ============================================================
+ */
+
+import express from 'express';
+import rateLimit from 'express-rate-limit';
+import helmet from 'helmet';
+
+const app = express();
+
+// ─── Process-Level Error Handling ────────────────────────────
+process.on('uncaughtException', (err) => {
+  console.error('💥 Uncaught Exception:', err.message);
+  if (err.stack) console.error(err.stack);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('💥 Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+// ─── Basic Security Headers ──────────────────────────────────
+app.use(helmet());
+app.use(express.json({ limit: '10kb' })); // Limit JSON payload size to prevent payload-based DoS
+
+// ─── Rate Limiters ───────────────────────────────────────────
+// Trust proxy is required if the server is behind a reverse proxy (like Render, Heroku, Cloudflare)
+app.set('trust proxy', 1);
+
+// General rate limiter for all requests (100 reqs per 15 minutes per IP)
+const generalLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  message: { error: 'Too many requests from this IP, please try again after 15 minutes.' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+app.use(generalLimiter);
+
+// Stricter rate limiter for registration/revocation endpoints (e.g. 20 reqs per 15 mins)
+const strictLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 20,
+  message: { error: 'Too many registration/revocation requests. Please try again later.' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+// ─── Active Defense & IP Blacklisting (IDS) ──────────────────
+const ipViolations = new Map(); // ip → violation_count
+const blacklistedIPs = new Set();
+const VIOLATION_THRESHOLD = 5; // Block IP after 5 malicious requests
+
+app.use((req, res, next) => {
+  const ip = req.ip || req.connection.remoteAddress;
+  if (blacklistedIPs.has(ip)) {
+    console.warn(`🛡️  Dropped traffic from blacklisted IP: ${ip}`);
+    return res.status(403).json({ error: 'Your IP has been banned due to suspicious activity.' });
+  }
+  next();
+});
+
+function recordViolation(req) {
+  const ip = req.ip || req.connection.remoteAddress;
+  const count = (ipViolations.get(ip) || 0) + 1;
+  ipViolations.set(ip, count);
+  console.warn(`🚨 Violation recorded for IP ${ip} (${count}/${VIOLATION_THRESHOLD})`);
+  
+  if (count >= VIOLATION_THRESHOLD) {
+    blacklistedIPs.add(ip);
+    console.error(`💥 HACKING DETECTED: Auto-banned IP ${ip} to defend server.`);
+  }
+}
+
+// ─── In-memory store — auto-expire after TTL ─────────────────
+const TTL_MS = 60 * 60 * 1000; // 1 hour
+const store = new Map(); // uid → { iv, ciphertext, salt, createdAt, clients: [] }
+
+function pruneExpired() {
+  const now = Date.now();
+  for (const [uid, entry] of store) {
+    if (now - entry.createdAt > TTL_MS) {
+      store.delete(uid);
+      console.log(`🗑️  Expired UID: ${uid}`);
+    }
+  }
+}
+
+// Run pruning every 5 minutes
+setInterval(pruneExpired, 5 * 60 * 1000);
+
+// ─── Routes ──────────────────────────────────────────────────
+
+// Health
+app.get('/health', (_req, res) => {
+  res.json({ status: 'ok', uptime: process.uptime(), activeUIDs: store.size });
+});
+
+/**
+ * POST /register
+ * Body: { uid: string, iv: string, ciphertext: string, salt: string }
+ *
+ * The broker receives an ALREADY-ENCRYPTED blob from the host CLI.
+ * It never decrypts — just stores the { iv, ciphertext } pair.
+ */
+app.post('/register', strictLimiter, (req, res) => {
+  try {
+    const { uid, iv, ciphertext, salt } = req.body;
+
+    if (!uid || !iv || !ciphertext || !salt) {
+      recordViolation(req);
+      return res.status(400).json({ error: 'Missing uid, iv, ciphertext, or salt' });
+    }
+
+    if (typeof uid !== 'string' || uid.length < 6 || uid.length > 16) {
+      recordViolation(req);
+      return res.status(400).json({ error: 'Invalid UID format (6-16 chars)' });
+    }
+
+    // Validate IV format — must be 32 hex chars (16 bytes)
+    if (!/^[a-f0-9]{32}$/i.test(iv)) {
+      recordViolation(req);
+      return res.status(400).json({ error: 'Invalid IV format (expected 32 hex chars)' });
+    }
+
+    // Validate ciphertext is non-empty base64
+    if (typeof ciphertext !== 'string' || ciphertext.length === 0) {
+      recordViolation(req);
+      return res.status(400).json({ error: 'Invalid ciphertext' });
+    }
+
+    // Store the encrypted blob as-is — broker NEVER decrypts
+    store.set(uid, {
+      iv,
+      ciphertext,
+      salt,
+      createdAt: Date.now(),
+      clients: []
+    });
+
+    console.log(`✅ [${new Date().toLocaleTimeString()}] Registered UID: ${uid} (encrypted, ${ciphertext.length} bytes)`);
+    res.json({ status: 'registered', uid, expiresIn: '1 hour' });
+  } catch (err) {
+    console.error('❌ Register error:', err.message);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+/**
+ * GET /resolve/:uid
+ * Returns the ENCRYPTED blob { iv, ciphertext } for a given UID.
+ * The client CLI decrypts it locally — the broker never sees plaintext.
+ */
+app.get('/resolve/:uid', (req, res) => {
+  try {
+    const { uid } = req.params;
+    const entry = store.get(uid);
+
+    if (!entry) {
+      // Don't strictly record a violation for one typo, but repeated 404s will be caught by rate limiter
+      return res.status(404).json({ error: 'UID not found or expired' });
+    }
+
+    // Check TTL
+    if (Date.now() - entry.createdAt > TTL_MS) {
+      store.delete(uid);
+      return res.status(410).json({ error: 'UID expired' });
+    }
+
+    console.log(`🔍 [${new Date().toLocaleTimeString()}] Resolved UID: ${uid} (returning encrypted blob)`);
+
+    // Return encrypted blob — client decrypts
+    res.json({ uid, iv: entry.iv, ciphertext: entry.ciphertext, salt: entry.salt });
+  } catch (err) {
+    console.error('❌ Resolve error:', err.message);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+/**
+ * POST /client-info/:uid
+ * Clients securely post their encrypted hardware telemetry.
+ */
+app.post('/client-info/:uid', generalLimiter, (req, res) => {
+  try {
+    const { uid } = req.params;
+    const { iv, ciphertext, salt } = req.body;
+    
+    const entry = store.get(uid);
+    if (!entry) return res.status(404).json({ error: 'UID not found' });
+    if (!iv || !ciphertext || !salt) return res.status(400).json({ error: 'Missing encrypted telemetry payload' });
+
+    entry.clients.push({ iv, ciphertext, salt, seenAt: Date.now() });
+    
+    // Keep max 50 recent client pings to prevent memory leaks
+    if (entry.clients.length > 50) entry.clients.shift();
+
+    res.json({ status: 'ok' });
+  } catch (err) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+/**
+ * GET /clients/:uid
+ * Host retrieves all securely encrypted client telemetry blobs.
+ */
+app.get('/clients/:uid', generalLimiter, (req, res) => {
+  try {
+    const { uid } = req.params;
+    const entry = store.get(uid);
+    
+    if (!entry) return res.status(404).json({ error: 'UID not found' });
+
+    res.json({ clients: entry.clients });
+  } catch (err) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+/**
+ * DELETE /revoke/:uid
+ * Allows host to explicitly remove their UID before expiry.
+ */
+app.delete('/revoke/:uid', strictLimiter, (req, res) => {
+  const { uid } = req.params;
+  const existed = store.delete(uid);
+  console.log(`🚫 [${new Date().toLocaleTimeString()}] Revoked UID: ${uid} (existed: ${existed})`);
+  res.json({ status: existed ? 'revoked' : 'not_found' });
+});
+
+// ─── Global Error Handler ────────────────────────────────────
+app.use((err, req, res, next) => {
+  console.error('❌ Express Error:', err.message);
+  if (err.stack) console.error(err.stack);
+  res.status(err.status || 500).json({ error: 'Internal Server Error' });
+});
+
+// ─── Launch ──────────────────────────────────────────────────
+// Render injects PORT; locally we use BROKER_PORT; fallback 4000
+const PORT = process.env.PORT || process.env.BROKER_PORT || 4000;
+const HOST = process.env.HOST || '0.0.0.0';
+
+app.listen(PORT, HOST, () => {
+  console.log('');
+  console.log('  ╔══════════════════════════════════════════╗');
+  console.log('  ║   🔗  SecureLink Broker — Active         ║');
+  console.log(`  ║   📡  Port: ${String(PORT).padEnd(29)}║`);
+  console.log('  ║   🔒  Zero-Knowledge Encrypted Store     ║');
+  console.log('  ║   ⏱️   TTL: 1 hour per UID                ║');
+  console.log('  ║   🚫  Broker NEVER sees plaintext        ║');
+  console.log('  ╚══════════════════════════════════════════╝');
+  console.log('');
+});
+
+export default app;