diodejs 0.1.6 → 0.2.0

package/README.md

@@ -117,15 +117,23 @@ async function main() {
   
     // Multiple or single port binding with configuration object
     const portsConfig = {
-      3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" },
-      3003: { targetPort: 443, deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2" } // Works with or without 0x prefix
+      3002: { 
+        targetPort: 80, 
+        deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tls" // Optional - defaults to TLS if not specified
+      },
+      3003: { 
+        targetPort: 443, 
+        deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tcp" // Can be "tls", "tcp", or "udp"
+      }
     };
     
     const portForward = new BindPort(connection, portsConfig);
     portForward.bind();
     
-    // You can also dynamically add and remove ports
-    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    // You can also dynamically add ports with protocol specification
+    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2", "udp");
     portForward.removePort(3003);
 }
 
@@ -144,7 +152,7 @@ async function main() {
     const connection = new DiodeConnection(host, port, keyLocation);
     await connection.connect();
   
-    // Legacy method - single port binding
+    // Legacy method - single port binding (defaults to TLS protocol)
     const portForward = new BindPort(connection, 3002, 80, "5365baf29cb7ab58de588dfc448913cb609283e2");
     portForward.bind();
 }
@@ -249,13 +257,15 @@ main();
   New Constructor:
   - `new BindPort(connection, portsConfig)`
     - `connection` (DiodeConnection): An instance of `DiodeConnection`.
-    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with `targetPort` and `deviceIdHex`.
-      Example: `{ 3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" } }`
-      Note: deviceIdHex can be provided with or without the '0x' prefix.
+    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with:
+      - `targetPort` (number): The target port on the device.
+      - `deviceIdHex` (string): The device ID in hexadecimal format (with or without '0x' prefix).
+      - `protocol` (string, optional): The protocol to use ("tls", "tcp", or "udp"). Defaults to "tls".
 
 - **Methods**:
   - `bind()`: Binds all configured local ports to their target ports on the devices.
-  - `addPort(localPort, targetPort, deviceIdHex)`: Adds a new port binding configuration. deviceIdHex can include '0x' prefix.
+  - `addPort(localPort, targetPort, deviceIdHex, protocol)`: Adds a new port binding configuration.
+    - `protocol` (string, optional): The protocol to use. Can be "tls", "tcp", or "udp". Defaults to "tls".
   - `removePort(localPort)`: Removes a port binding configuration.
   - `bindSinglePort(localPort)`: Binds a single local port to its target.
   - `closeAllServers()`: Closes all active server instances.

package/bindPort.js

@@ -1,8 +1,45 @@
 const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
 const { Buffer } = require('buffer');
+const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
 const logger = require('./logger');
 
+// Custom Duplex stream to handle the Diode connection
+class DiodeSocket extends Duplex {
+  constructor(ref, rpc) {
+    super();
+    this.ref = ref;
+    this.rpc = rpc;
+    this.destroyed = false;
+  }
+
+  _write(chunk, encoding, callback) {
+    // Send data to the remote device via portSend
+    this.rpc.portSend(this.ref, chunk)
+      .then(() => callback())
+      .catch((err) => callback(err));
+  }
+
+  _read(size) {
+    // No need to implement this method for our use case
+  }
+
+  // Method to push data received from the remote device
+  pushData(data) {
+    if (!this.destroyed) {
+      this.push(data);
+    }
+  }
+
+  _destroy(err, callback) {
+    this.destroyed = true;
+    this.push(null);
+    callback(err);
+  }
+}
+
 class BindPort {
   constructor(connection, localPortOrPortsConfig, targetPort, deviceIdHex) {
     this.connection = connection;
@@ -12,7 +49,8 @@ class BindPort {
       this.portsConfig = {
         [localPortOrPortsConfig]: { 
           targetPort, 
-          deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+          deviceIdHex: this._stripHexPrefix(deviceIdHex),
+          protocol: 'tls' // Default protocol is tls
         }
       };
     } else {
@@ -20,10 +58,17 @@ class BindPort {
       this.portsConfig = localPortOrPortsConfig || {};
       
       // Strip 0x prefix from all deviceIdHex values in portsConfig
+      // And ensure protocol is specified (default to tls)
       for (const port in this.portsConfig) {
         if (this.portsConfig[port].deviceIdHex) {
           this.portsConfig[port].deviceIdHex = this._stripHexPrefix(this.portsConfig[port].deviceIdHex);
         }
+        // Set default protocol if not provided
+        if (!this.portsConfig[port].protocol) {
+          this.portsConfig[port].protocol = 'tls';
+        }
+        // Ensure protocol is uppercase
+        this.portsConfig[port].protocol = this.portsConfig[port].protocol.toLowerCase();
       }
     }
     
@@ -45,7 +90,6 @@ class BindPort {
   _setupMessageListener() {
     // Listen for data events from the device
     this.connection.on('unsolicited', (message) => {
-      // message is [messageId, [messageType, ...]]
       const [messageIdRaw, messageContent] = message;
       const messageTypeRaw = messageContent[0];
       const messageType = Buffer.from(messageTypeRaw).toString('utf8');
@@ -60,7 +104,13 @@ class BindPort {
         // Find the associated client socket from connection
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
-          clientSocket.write(data);
+          if (clientSocket.diodeSocket) {
+            // If it's a DiodeSocket, push data to it so tls can process
+            clientSocket.diodeSocket.pushData(data);
+          } else {
+            // Otherwise write directly to the socket
+            clientSocket.write(data);
+          }
         } else {
           const connectionInfo = this.connection.getConnection(dataRef);
           if (connectionInfo) {
@@ -76,6 +126,9 @@ class BindPort {
         // Close the associated client socket
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
+          if (clientSocket.diodeSocket) {
+            clientSocket.diodeSocket._destroy(null, () => {});
+          }
           clientSocket.end();
           this.connection.deleteClientSocket(dataRef);
           logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
@@ -100,7 +153,7 @@ class BindPort {
     });
   }
 
-  addPort(localPort, targetPort, deviceIdHex) {
+  addPort(localPort, targetPort, deviceIdHex, protocol = 'tls') {
     if (this.servers.has(localPort)) {
       logger.warn(`Port ${localPort} is already bound`);
       return false;
@@ -108,7 +161,8 @@ class BindPort {
     
     this.portsConfig[localPort] = { 
       targetPort, 
-      deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+      deviceIdHex: this._stripHexPrefix(deviceIdHex),
+      protocol: protocol.toLowerCase()
     };
     
     this.bindSinglePort(localPort);
@@ -151,70 +205,191 @@ class BindPort {
       return false;
     }
     
-    const { targetPort, deviceIdHex } = config;
+    const { targetPort, deviceIdHex, protocol = 'tls' } = config;
     const deviceId = Buffer.from(deviceIdHex, 'hex');
     
-    // Set up local server
-    const server = net.createServer(async (clientSocket) => {
-      logger.info(`Client connected to local server on port ${localPort}`);
-
-      // Open a new port on the device for this client
-      let ref;
-      try {
-        ref = await this.rpc.portOpen(deviceId, targetPort, 'rw');
+    // Format the target port with protocol prefix for the remote connection
+    const formattedTargetPort = `${protocol}:${targetPort}`;
+    logger.info(`Binding local port ${localPort} to remote ${formattedTargetPort}`);
+    
+    // For udp protocol, use udp server
+    if (protocol === 'udp') {
+      const server = dgram.createSocket('udp4');
+      
+      server.on('listening', () => {
+        logger.info(`udp server listening on port ${localPort} forwarding to device port ${targetPort}`);
+      });
+      
+      server.on('message', async (data, rinfo) => {
+        // Open a new port on the device if this is a new client
+        const clientKey = `${rinfo.address}:${rinfo.port}`;
+        let ref = server.clientRefs && server.clientRefs[clientKey];
+        
         if (!ref) {
-          logger.error(`Error opening port ${targetPort} on deviceId: ${deviceIdHex}`);
-          clientSocket.destroy();
-          return;
-        } else {
-          logger.info(`Port ${targetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          try {
+            ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+            if (!ref) {
+              logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+              return;
+            } else {
+              logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for udp client ${clientKey}`);
+              if (!server.clientRefs) server.clientRefs = {};
+              server.clientRefs[clientKey] = ref;
+              
+              // Store the client info
+              this.connection.addClientSocket(ref, {
+                address: rinfo.address,
+                port: rinfo.port,
+                protocol: 'udp',
+                write: (data) => {
+                  server.send(data, rinfo.port, rinfo.address);
+                }
+              });
+            }
+          } catch (error) {
+            logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+            return;
+          }
         }
-      } catch (error) {
-        logger.error(`Error opening port ${targetPort} on device: ${error}`);
-        clientSocket.destroy();
-        return;
-      }
-
-      // Store the client socket with the ref using connection's method
-      this.connection.addClientSocket(ref, clientSocket);
-
-      // When data is received from the client, send it to the device
-      clientSocket.on('data', async (data) => {
+        
+        // Send data to the device
         try {
           await this.rpc.portSend(ref, data);
         } catch (error) {
-          logger.error(`Error sending data to device: ${error}`);
-          clientSocket.destroy();
+          logger.error(`Error sending udp data to device: ${error}`);
         }
       });
+      
+      server.on('error', (err) => {
+        logger.error(`udp Server error: ${err}`);
+      });
+      
+      server.bind(localPort);
+      this.servers.set(parseInt(localPort), server);
+    } else {
+      // For TCP and tls protocols, use TCP server locally
+      const server = net.createServer(async (clientSocket) => {
+        logger.info(`Client connected to local server on port ${localPort}`);
 
-      // Handle client socket closure
-      clientSocket.on('end', async () => {
-        logger.info('Client disconnected');
-        if (ref && this.connection.hasClientSocket(ref)) {
+        // Open a new port on the device for this client
+        let ref;
+        try {
+          ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+          if (!ref) {
+            logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+            clientSocket.destroy();
+            return;
+          } else {
+            logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          }
+        } catch (error) {
+          logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+          clientSocket.destroy();
+          return;
+        }
+
+        if (protocol === 'tls') {
+          // For tls protocol, create a proper tls connection
           try {
-            await this.rpc.portClose(ref);
-            logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
-            this.connection.deleteClientSocket(ref);
+            // Create a DiodeSocket to handle communication with the device
+            const diodeSocket = new DiodeSocket(ref, this.rpc);
+            
+            // Get the device certificate for tls
+            const certPem = this.connection.getDeviceCertificate();
+            if (!certPem) {
+              throw new Error('No device certificate available');
+            }
+            
+            // Setup tls options for client mode
+            const tlsOptions = {
+              cert: certPem,
+              key: certPem,
+              rejectUnauthorized: false,
+              ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+              ecdhCurve: 'secp256k1',
+              minVersion: 'TLSv1.2',
+              maxVersion: 'TLSv1.2',
+            };
+            
+            // Create tls socket as client (not server)
+            const tlsSocket = tls.connect({
+              socket: diodeSocket,
+              ...tlsOptions
+            }, () => {
+              logger.info(`tls connection established to device ${deviceIdHex}`);
+            });
+            
+            // Pipe data between the client socket and the tls socket
+            tlsSocket.pipe(clientSocket).pipe(tlsSocket);
+            
+            // Handle tls socket errors
+            tlsSocket.on('error', (err) => {
+              logger.error(`tls Socket error: ${err}`);
+              clientSocket.destroy();
+            });
+            
+            // Store reference to the diodeSocket so we can push data to it
+            const socketWrapper = {
+              diodeSocket,
+              tlsSocket,
+              end: () => {
+                tlsSocket.end();
+                diodeSocket._destroy(null, () => {});
+              }
+            };
+            
+            // Store the socket wrapper
+            this.connection.addClientSocket(ref, socketWrapper);
+            
           } catch (error) {
-            logger.error(`Error closing port on device: ${error}`);
+            logger.error(`Error setting up tls connection: ${error}`);
+            clientSocket.destroy();
+            return;
           }
         } else {
-          logger.warn('Ref is invalid or no longer in clientSockets.');
+          // For TCP protocol, just use the raw socket
+          this.connection.addClientSocket(ref, clientSocket);
+          
+          // Handle data from client to device
+          clientSocket.on('data', async (data) => {
+            try {
+              await this.rpc.portSend(ref, data);
+            } catch (error) {
+              logger.error(`Error sending data to device: ${error}`);
+              clientSocket.destroy();
+            }
+          });
         }
-      });
 
-      // Handle client socket errors
-      clientSocket.on('error', (err) => {
-        logger.error('Client socket error:', err);
+        // Handle client socket closure (common for all protocols)
+        clientSocket.on('end', async () => {
+          logger.info('Client disconnected');
+          if (ref && this.connection.hasClientSocket(ref)) {
+            try {
+              await this.rpc.portClose(ref);
+              logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
+              this.connection.deleteClientSocket(ref);
+            } catch (error) {
+              logger.error(`Error closing port on device: ${error}`);
+            }
+          } else {
+            logger.warn('Ref is invalid or no longer in clientSockets.');
+          }
+        });
+
+        // Handle client socket errors
+        clientSocket.on('error', (err) => {
+          logger.error(`Client socket error: ${err}`);
+        });
       });
-    });
 
-    server.listen(localPort, () => {
-      logger.info(`Local server listening on port ${localPort} forwarding to device port ${targetPort}`);
-    });
+      server.listen(localPort, () => {
+        logger.info(`Local server listening on port ${localPort} forwarding to device ${protocol} port ${targetPort}`);
+      });
+      
+      this.servers.set(parseInt(localPort), server);
+    }
     
-    this.servers.set(parseInt(localPort), server);
     return true;
   }
 

package/examples/portForwardTest.js

@@ -9,8 +9,8 @@ async function main() {
     await connection.connect();
   
     const portForward = new BindPort(connection, {
-        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039" },
-        3004: { targetPort: 443, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" }
+        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", protocol: "tcp" },
+        3004: { targetPort: 8081, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2", protocol: "tls" }
       });
     portForward.bind();
 
@@ -23,7 +23,7 @@ async function main() {
     // after 10 seconds, add port 3003 back
     setTimeout(() => {
         console.log("Adding port 3003 back");
-        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039");
+        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", "tcp");
     }, 10000);
     
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {

package/publishPort.js

@@ -254,7 +254,7 @@ class PublishPort extends EventEmitter {
     // Create a DiodeSocket instance
     const diodeSocket = new DiodeSocket(ref, this.rpc);
 
-    certPem = this.connection.getDeviceCertificate();
+    const certPem = this.connection.getDeviceCertificate();
 
     // TLS options with your server's certificate and key
     const tlsOptions = {