peer-term 1.2.11 → 1.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-term",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "license": "MIT",
   "description": "Share your terminal instantly using a 6-digit code. Encrypted. No config.",
   "keywords": [

package/src/index.js

@@ -22,6 +22,7 @@
 import * as dotenv from 'dotenv';
 import os from 'os';
 import fs from 'fs';
+import crypto from 'crypto';
 import path from 'path';
 import net from 'net';
 import readline from 'readline';
@@ -338,6 +339,7 @@ class Session {
     // Local TCP viewer (new terminal window)
     this.viewerServer = null;
     this.viewerSocket = null;
+    this.viewerToken = null;   // Random nonce for viewer auth
   }
 
   log(msg) {
@@ -368,25 +370,54 @@ class Session {
 
   async _completeKeyExchange(clientPublicKeyBase64) {
     if (!this.keyPair || !this.hostPublicKeyBase64) return;
+    if (typeof clientPublicKeyBase64 !== 'string' || clientPublicKeyBase64.length === 0) {
+      this._rejectProtocolMessage('Invalid key-exchange public key');
+      return;
+    }
 
-    this.logDebug('Deriving shared secret...');
-    this.clientPublicKeyBase64 = clientPublicKeyBase64;
+    try {
+      this.logDebug('Deriving shared secret...');
+      this.clientPublicKeyBase64 = clientPublicKeyBase64;
+
+      const peerPublicKey = await importPublicKey(clientPublicKeyBase64);
+      this.sharedKey = await deriveSharedKey(this.keyPair.privateKey, peerPublicKey);
+
+      if (this.secureMode) {
+        this.securityFingerprint = await fingerprintPublicKeys(
+          this.code,
+          this.hostPublicKeyBase64,
+          this.clientPublicKeyBase64
+        );
+        this.fingerprintAuthorized = false;
+        this._printFingerprintAuthorization();
+      } else {
+        this.fingerprintAuthorized = true;
+        await this._activateSecureSession();
+      }
+    } catch (err) {
+      this._rejectProtocolMessage(`Invalid key exchange: ${err.message}`);
+    }
+  }
 
-    const peerPublicKey = await importPublicKey(clientPublicKeyBase64);
-    this.sharedKey = await deriveSharedKey(this.keyPair.privateKey, peerPublicKey);
+  _rejectProtocolMessage(reason) {
+    this.log(`Protocol error: ${reason}`);
+    this.isClientConnected = false;
+    this.awaitingRejoin = false;
+    this.sharedKey = null;
+    this.keyPair = null;
+    this.hostPublicKeyBase64 = null;
+    this.clientPublicKeyBase64 = null;
+    this.securityFingerprint = null;
+    this.fingerprintAuthorized = false;
+    this.stopHeartbeat();
+    this._cleanupWebRTC();
+    this.destroy();
+  }
 
-    if (this.secureMode) {
-      this.securityFingerprint = await fingerprintPublicKeys(
-        this.code,
-        this.hostPublicKeyBase64,
-        this.clientPublicKeyBase64
-      );
-      this.fingerprintAuthorized = false;
-      this._printFingerprintAuthorization();
-    } else {
-      this.fingerprintAuthorized = true;
-      await this._activateSecureSession();
-    }
+  _handleMessageError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    this.log(`Protocol handler error: ${message}`);
+    this.destroy();
   }
 
   _printFingerprintAuthorization() {
@@ -481,6 +512,7 @@ class Session {
       });
 
       this.ws.on('message', async (raw) => {
+        try {
         let msg;
         try {
           msg = JSON.parse(raw.toString());
@@ -488,6 +520,10 @@ class Session {
           this.log('Invalid message from relay');
           return;
         }
+        if (!msg || typeof msg.type !== 'string') {
+          this._rejectProtocolMessage('Malformed relay message');
+          return;
+        }
 
         switch (msg.type) {
           case 'code': {
@@ -614,6 +650,9 @@ class Session {
             break;
           }
         }
+        } catch (err) {
+          this._handleMessageError(err);
+        }
       });
 
       this.ws.on('close', () => {
@@ -782,6 +821,9 @@ class Session {
   }
 
   _startViewerServer() {
+    // Generate a random nonce for viewer authentication
+    this.viewerToken = crypto.randomBytes(16).toString('hex');
+
     this.viewerServer = net.createServer((socket) => {
       // Close any existing viewer connection before accepting a new one
       if (this.viewerSocket) {
@@ -789,66 +831,119 @@ class Session {
         this.viewerSocket.removeAllListeners();
         try { this.viewerSocket.destroy(); } catch {}
       }
-      this.viewerSocket = socket;
-      this.log('Host viewer connected.');
-
-      let recvBuf = '';
-
-      socket.on('data', (data) => {
-        const chunk = data.toString();
-        
-        // Control messages start with \x00{
-        if (recvBuf.length > 0 || chunk.startsWith('\x00{')) {
-          recvBuf += chunk;
-          let newlineIdx;
-          while ((newlineIdx = recvBuf.indexOf('\n')) !== -1) {
-            const line = recvBuf.slice(0, newlineIdx).trim();
-            recvBuf = recvBuf.slice(newlineIdx + 1);
-            
-            if (line.startsWith('\x00')) {
-              try {
-                const msg = JSON.parse(line.slice(1));
-                if (msg.type === 'resize' && 
-                    Number.isInteger(msg.cols) && msg.cols > 0 && 
-                    Number.isInteger(msg.rows) && msg.rows > 0 && 
-                    this.ptyProcess) {
-                  this.ptyProcess.resize(msg.cols, msg.rows);
-                  this._sendResize(msg.cols, msg.rows);
-                  this.logDebug(`Viewer resized to ${msg.cols}x${msg.rows}`);
-                }
-              } catch {}
-            } else if (this.ptyProcess) {
-               this.ptyProcess.write(line + '\n');
-            }
-          }
-          // Flush any non-control data left in the buffer
-          if (recvBuf.length > 0 && !recvBuf.startsWith('\x00')) {
-             if (this.ptyProcess) this.ptyProcess.write(recvBuf);
-             recvBuf = '';
+
+      // ── Token authentication gate ──────────────────────────────────
+      // The first data packet must be the viewer token followed by a newline.
+      // Reject the connection if no valid token arrives within 2 seconds.
+      let authenticated = false;
+      let authBuf = '';
+
+      const authTimeout = setTimeout(() => {
+        if (!authenticated) {
+          this.logDebug('Viewer auth timeout — closing connection.');
+          try { socket.destroy(); } catch {}
+        }
+      }, 2000);
+
+      const onAuthData = (data) => {
+        authBuf += data.toString();
+        const newlineIdx = authBuf.indexOf('\n');
+        if (newlineIdx === -1) {
+          // Accumulated too much data without a newline — reject
+          if (authBuf.length > 256) {
+            clearTimeout(authTimeout);
+            this.logDebug('Viewer auth buffer overflow — closing connection.');
+            try { socket.destroy(); } catch {}
           }
           return;
         }
 
-        // Host keystrokes → PTY (host always has access)
-        if (this.ptyProcess) {
-          this.ptyProcess.write(data);
+        const token = authBuf.slice(0, newlineIdx).trim();
+        const remaining = authBuf.slice(newlineIdx + 1);
+        clearTimeout(authTimeout);
+        socket.removeListener('data', onAuthData);
+
+        if (token !== this.viewerToken) {
+          this.logDebug('Viewer auth failed — wrong token.');
+          try { socket.destroy(); } catch {}
+          return;
         }
-      });
 
-      socket.on('close', () => {
-        this.viewerSocket = null;
-        this.logDebug('Host viewer disconnected.');
-      });
+        // Authenticated — promote to active viewer
+        authenticated = true;
+        this.viewerSocket = socket;
+        this.log('Host viewer connected (authenticated).');
+
+        // Install the real data handler
+        let recvBuf = '';
+
+        // Process any leftover data that arrived after the token line
+        if (remaining.length > 0) {
+          handleViewerData(remaining);
+        }
+
+        socket.on('data', (chunk) => handleViewerData(chunk.toString()));
+
+        const handleViewerData = (chunk) => {
+          // Control messages start with \x00{
+          if (recvBuf.length > 0 || chunk.startsWith('\x00{')) {
+            recvBuf += chunk;
+            let nlIdx;
+            while ((nlIdx = recvBuf.indexOf('\n')) !== -1) {
+              const line = recvBuf.slice(0, nlIdx).trim();
+              recvBuf = recvBuf.slice(nlIdx + 1);
+
+              if (line.startsWith('\x00')) {
+                try {
+                  const msg = JSON.parse(line.slice(1));
+                  if (msg.type === 'resize' &&
+                      Number.isInteger(msg.cols) && msg.cols > 0 &&
+                      Number.isInteger(msg.rows) && msg.rows > 0 &&
+                      this.ptyProcess) {
+                    this.ptyProcess.resize(msg.cols, msg.rows);
+                    this._sendResize(msg.cols, msg.rows);
+                    this.logDebug(`Viewer resized to ${msg.cols}x${msg.rows}`);
+                  }
+                } catch {}
+              } else if (this.ptyProcess) {
+                 this.ptyProcess.write(line + '\n');
+              }
+            }
+            // Flush any non-control data left in the buffer
+            if (recvBuf.length > 0 && !recvBuf.startsWith('\x00')) {
+               if (this.ptyProcess) this.ptyProcess.write(recvBuf);
+               recvBuf = '';
+            }
+            return;
+          }
+
+          // Host keystrokes → PTY (host always has access)
+          if (this.ptyProcess) {
+            this.ptyProcess.write(chunk);
+          }
+        };
+
+        socket.on('close', () => {
+          this.viewerSocket = null;
+          this.logDebug('Host viewer disconnected.');
+        });
+
+        socket.on('error', () => {
+          this.viewerSocket = null;
+        });
+      };
+
+      socket.on('data', onAuthData);
 
       socket.on('error', () => {
-        this.viewerSocket = null;
+        clearTimeout(authTimeout);
       });
     });
 
     this.viewerServer.listen(0, '127.0.0.1', () => {
       const port = this.viewerServer.address().port;
       this.logDebug(`Viewer server on port ${port}`);
-      this._openViewerTerminal(port);
+      this._openViewerTerminal(port, this.viewerToken);
     });
 
     this.viewerServer.on('error', (err) => {
@@ -857,7 +952,7 @@ class Session {
     });
   }
 
-  _openViewerTerminal(port) {
+  _openViewerTerminal(port, token) {
     if (!/^[A-Za-z0-9_-]+$/.test(this.code)) {
       this.log('Invalid session code format. Aborting viewer terminal.');
       return;
@@ -867,12 +962,12 @@ class Session {
     const platform = os.platform();
 
     if (platform === 'win32') {
-      cpExec(`start "PeerTerm - ${this.code}" cmd /c node "${viewerScript}" ${port} ${this.code}`);
+      cpExec(`start "PeerTerm - ${this.code}" cmd /c node "${viewerScript}" ${port} ${this.code} ${token}`);
     } else if (platform === 'darwin') {
-      cpExec(`osascript -e 'tell app "Terminal" to do script "node \"${viewerScript}\" ${port} ${this.code}"'`);
+      cpExec(`osascript -e 'tell app "Terminal" to do script "node \"${viewerScript}\" ${port} ${this.code} ${token}"'`);
     } else {
       // Linux: try common terminal emulators
-      cpExec(`x-terminal-emulator -e "node '${viewerScript}' ${port} ${this.code}" 2>/dev/null || gnome-terminal -- node "${viewerScript}" ${port} ${this.code} 2>/dev/null || xterm -e "node '${viewerScript}' ${port} ${this.code}"`);
+      cpExec(`x-terminal-emulator -e "node '${viewerScript}' ${port} ${this.code} ${token}" 2>/dev/null || gnome-terminal -- node "${viewerScript}" ${port} ${this.code} ${token} 2>/dev/null || xterm -e "node '${viewerScript}' ${port} ${this.code} ${token}"`);
     }
     this.log('Opening terminal viewer...');
   }
@@ -910,12 +1005,17 @@ class Session {
         });
 
         newWs.on('message', async (raw) => {
+          try {
           let msg;
           try {
             msg = JSON.parse(raw.toString());
           } catch {
             return;
           }
+          if (!msg || typeof msg.type !== 'string') {
+            this._rejectProtocolMessage('Malformed relay message');
+            return;
+          }
 
           if (msg.type === 'rejoined') {
             // Success — replace the old ws with this new one
@@ -935,6 +1035,9 @@ class Session {
             this.destroy();
             try { newWs.close(); } catch {}
           }
+          } catch (err) {
+            this._handleMessageError(err);
+          }
         });
 
         newWs.on('error', () => {
@@ -970,6 +1073,7 @@ class Session {
    */
   _attachWsHandlers(newWs) {
     newWs.on('message', async (raw) => {
+      try {
       let msg;
       try {
         msg = JSON.parse(raw.toString());
@@ -977,6 +1081,10 @@ class Session {
         this.log('Invalid message from relay');
         return;
       }
+      if (!msg || typeof msg.type !== 'string') {
+        this._rejectProtocolMessage('Malformed relay message');
+        return;
+      }
 
       switch (msg.type) {
         case 'client-connected': {
@@ -1084,6 +1192,9 @@ class Session {
           break;
         }
       }
+      } catch (err) {
+        this._handleMessageError(err);
+      }
     });
 
     newWs.on('close', () => {
@@ -1414,7 +1525,6 @@ process.on('uncaughtException', (err) => {
 process.on('unhandledRejection', (reason) => {
   const err = reason instanceof Error ? reason : new Error(String(reason));
   logger.error(`Unhandled rejection: ${err.message}`, err);
-  process.exit(1);
 });
 
 // ─── Run ─────────────────────────────────────────────────────────────────────

package/src/session-viewer.js

@@ -4,14 +4,23 @@
  *
  * Opens in a new terminal window and connects to the host's PTY
  * via a local TCP socket. Gives the host a direct terminal view.
+ *
+ * Usage: session-viewer.js <port> <code> <token>
+ * The token is a random nonce generated by the host for authentication.
  */
 
 import net from 'net';
 
-const port = parseInt(process.argv[2], 10);
+const port  = parseInt(process.argv[2], 10);
+const token = process.argv[4] || '';
 
 if (!port || isNaN(port) || port < 1 || port > 65535) {
-  console.error('Usage: session-viewer.js <port>\nPort must be a number between 1 and 65535.');
+  console.error('Usage: session-viewer.js <port> <code> <token>\nPort must be a number between 1 and 65535.');
+  process.exit(1);
+}
+
+if (!token) {
+  console.error('Missing viewer token. Cannot authenticate.');
   process.exit(1);
 }
 
@@ -33,6 +42,10 @@ function formatResizeMessage(cols, rows) {
 
 const client = net.connect({ port, host: '127.0.0.1' }, () => {
   client.setTimeout(0); // Clear timeout once connected
+
+  // Send the authentication token as the very first message
+  client.write(token + '\n');
+
   // Send initial terminal size
   const cols = process.stdout.isTTY ? (process.stdout.columns || 80) : 80;
   const rows = process.stdout.isTTY ? (process.stdout.rows || 24) : 24;