@miraj181/ipingyou 1.0.1 → 2.0.0

package/src/lib/cleanup.js

@@ -20,6 +20,17 @@ let _revokeUID = null;
 /** @type {string|null} — Broker URL for revocation */
 let _brokerUrl = null;
 
+/** @type {Array<() => Promise<void>|void>} — Custom cleanup hooks */
+const _cleanupHooks = [];
+
+/**
+ * Register a custom cleanup hook to run on shutdown.
+ * @param {() => Promise<void>|void} hook
+ */
+export function addCleanupHook(hook) {
+  _cleanupHooks.push(hook);
+}
+
 /**
  * Register a spawned child PID for tracking.
  * @param {number} pid
@@ -80,6 +91,15 @@ export async function cleanupAll() {
   await Promise.allSettled(kills);
   trackedPIDs.clear();
 
+  // Run custom cleanup hooks
+  for (const hook of _cleanupHooks) {
+    try {
+      await hook();
+    } catch (err) {
+      console.error(chalk.red(`     Cleanup hook failed: ${err.message}`));
+    }
+  }
+
   // Revoke UID from broker
   if (_revokeUID && _brokerUrl) {
     try {
@@ -129,3 +149,61 @@ export function installShutdownHandlers() {
 export function getTrackedCount() {
   return trackedPIDs.size;
 }
+
+/**
+ * Execute Panic Mode (Self-Destruct)
+ * Wipes all configs, keys, and forcefully kills associated processes.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execaCommand } from 'execa';
+
+export async function executePanicMode() {
+  console.log(chalk.bold.red('\n  🚨 INITIATING SECURELINK PANIC MODE 🚨\n'));
+  
+  // 1. Force kill all cloudflared & ipingyou processes
+  console.log(chalk.dim('  [1/4] Terminating all tunnel and host processes...'));
+  try {
+    if (process.platform === 'win32') {
+      await execaCommand('taskkill /F /IM cloudflared.exe', { reject: false });
+      await execaCommand('taskkill /F /IM sshd.exe', { reject: false });
+    } else {
+      await execaCommand('pkill -9 -f cloudflared', { reject: false });
+      await execaCommand('pkill -9 -f "sshd:.*@"', { reject: false });
+    }
+  } catch {}
+
+  // 2. Delete configuration and aliases
+  console.log(chalk.dim('  [2/4] Wiping configuration files...'));
+  const configPath = path.join(os.homedir(), '.ipingyou', 'config.json');
+  try {
+    if (fs.existsSync(configPath)) {
+      fs.unlinkSync(configPath);
+    }
+    const configDir = path.join(os.homedir(), '.ipingyou');
+    if (fs.existsSync(configDir)) {
+      fs.rmSync(configDir, { recursive: true, force: true });
+    }
+  } catch {}
+
+  // 3. Delete ephemeral keys and temp files
+  console.log(chalk.dim('  [3/4] Purging ephemeral keys and temporary files...'));
+  try {
+    const tmpDir = os.tmpdir();
+    const files = fs.readdirSync(tmpDir);
+    for (const file of files) {
+      if (file.startsWith('ipingyou_')) {
+        fs.unlinkSync(path.join(tmpDir, file));
+      }
+    }
+  } catch {}
+
+  // 4. Scrub SSH authorized_keys if we know we injected
+  // Note: We don't want to wipe the user's whole authorized_keys, but if we have a hook, we could.
+  // We'll skip scraping the actual file here unless we know the exact comment.
+  console.log(chalk.dim('  [4/4] Finalizing cleanup...'));
+
+  console.log(chalk.bold.green('\n  ✅ Panic Mode Complete. All traces removed.\n'));
+  process.exit(0);
+}

package/src/lib/config.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.ipingyou');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureConfig() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ aliases: {}, settings: {} }, null, 2));
+  }
+}
+
+export function getConfig() {
+  ensureConfig();
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return { aliases: {}, settings: {} };
+  }
+}
+
+export function saveConfig(config) {
+  ensureConfig();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function saveAlias(aliasName, data) {
+  const config = getConfig();
+  if (!config.aliases) config.aliases = {};
+  config.aliases[aliasName] = data;
+  saveConfig(config);
+}
+
+export function getAlias(aliasName) {
+  const config = getConfig();
+  return config.aliases?.[aliasName] || null;
+}

package/src/lib/crypto.js

@@ -9,43 +9,52 @@
 
 import crypto from 'node:crypto';
 
-const DEFAULT_HEX_KEY = 'b374a26d71590483815c467a99623e1b7db95f269c2889279a32c4530fc4159f';
-
 /**
- * Get the encryption key as a Buffer.
- * Reads from env var SECRET_KEY, falls back to the default dev key.
+ * Derive a 256-bit encryption key from a password and salt using PBKDF2.
+ * @param {string} password 
+ * @param {Buffer} salt 
+ * @returns {Buffer}
  */
-export function getKey() {
-  const hex = process.env.SECRET_KEY || DEFAULT_HEX_KEY;
-  return Buffer.from(hex, 'hex');
+export function deriveKey(password, salt) {
+  // Use 100,000 iterations for strong security
+  return crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
 }
 
 /**
- * Encrypt a plaintext string with AES-256-CBC.
+ * Encrypt a plaintext string with AES-256-CBC using a password.
  * @param {string} plaintext
- * @returns {{ iv: string, ciphertext: string }}
+ * @param {string} password
+ * @returns {{ iv: string, ciphertext: string, salt: string }}
  */
-export function encrypt(plaintext) {
-  const key = getKey();
+export function encrypt(plaintext, password) {
+  const salt = crypto.randomBytes(16);
+  const key = deriveKey(password, salt);
   const iv = crypto.randomBytes(16);
+  
   const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
   let enc = cipher.update(plaintext, 'utf8', 'base64');
   enc += cipher.final('base64');
+  
   return {
     iv: iv.toString('hex'),
     ciphertext: enc,
+    salt: salt.toString('hex')
   };
 }
 
 /**
- * Decrypt a ciphertext with AES-256-CBC.
+ * Decrypt a ciphertext with AES-256-CBC using a password and salt.
  * @param {string} ivHex  — 32-char hex IV
  * @param {string} cipherBase64
+ * @param {string} password
+ * @param {string} saltHex
  * @returns {string}
  */
-export function decrypt(ivHex, cipherBase64) {
-  const key = getKey();
+export function decrypt(ivHex, cipherBase64, password, saltHex) {
+  const salt = Buffer.from(saltHex, 'hex');
+  const key = deriveKey(password, salt);
   const iv = Buffer.from(ivHex, 'hex');
+  
   const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
   let dec = decipher.update(cipherBase64, 'base64', 'utf8');
   dec += decipher.final('utf8');