node-red-contrib-meshtastic-advanced 1.0.0

package/dist/nodes/decrypt/decrypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decrypt.js","sources":["../../../src/nodes/decrypt/decrypt.ts"],"sourcesContent":["/**\n * Meshtastic Decrypt Node\n * Decrypts encrypted Meshtastic packets (both channel PSK and direct message PKC)\n */\n\nimport type { Node, NodeDef, NodeInitializer } from 'node-red';\nimport { Protobuf } from '@meshtastic/protobufs';\nimport {\n  decryptChannelMessage,\n  decryptDirectMessage,\n  deriveSharedSecret,\n  parseKey,\n  parsePrivateKey,\n  parsePublicKey,\n  isDefaultKey,\n  decodeServiceEnvelope,\n  decodeData,\n  MeshtasticDecryptError,\n  validateNodeNumber,\n  validatePacketId,\n  ensureBuffer,\n} from '../../lib';\n\ninterface DecryptConfig extends NodeDef {\n  name: string;\n  mode: 'auto' | 'channel' | 'dm';\n  keyFormat: 'base64' | 'hex';\n  outputFormat: 'buffer' | 'object';\n}\n\ninterface DecryptCredentials {\n  channelKey?: string;\n  privateKey?: string;\n  publicKeys?: string; // JSON string of nodeNum -> publicKey mapping\n}\n\nconst nodeInit: NodeInitializer = (RED): void => {\n  function DecryptNodeConstructor(this: Node, config: DecryptConfig): void {\n    RED.nodes.createNode(this, config);\n    const node = this;\n\n    // Get credentials\n    const credentials = RED.nodes.getCredentials(config.id) as DecryptCredentials | undefined;\n\n    // Parse channel key if provided\n    let channelKey: Buffer | null = null;\n    if (credentials?.channelKey) {\n      try {\n        channelKey = parseKey(credentials.channelKey, config.keyFormat || 'base64');\n\n        // Warn if using default key\n        if (isDefaultKey(channelKey)) {\n          node.warn(\n            'Using default Meshtastic encryption key (AQ==). ' +\n            'This is INSECURE and should only be used for testing. ' +\n            'Please configure a secure channel key.'\n          );\n        }\n      } catch (error) {\n        node.error(`Invalid channel key: ${error instanceof Error ? error.message : String(error)}`);\n        channelKey = null;\n      }\n    }\n\n    // Parse private key if provided\n    let privateKey: Buffer | null = null;\n    if (credentials?.privateKey) {\n      try {\n        privateKey = parsePrivateKey(credentials.privateKey, config.keyFormat || 'base64');\n      } catch (error) {\n        node.error(`Invalid private key: ${error instanceof Error ? error.message : String(error)}`);\n        privateKey = null;\n      }\n    }\n\n    // Parse public keys mapping if provided\n    let publicKeysMap: Map<number, Buffer> = new Map();\n    if (credentials?.publicKeys) {\n      try {\n        const publicKeysObj = JSON.parse(credentials.publicKeys);\n        for (const [nodeNumStr, keyStr] of Object.entries(publicKeysObj)) {\n          const nodeNum = parseInt(nodeNumStr, 10);\n          const publicKey = parsePublicKey(keyStr as string, config.keyFormat || 'base64');\n          publicKeysMap.set(nodeNum, publicKey);\n        }\n      } catch (error) {\n        node.error(`Invalid public keys mapping: ${error instanceof Error ? error.message : String(error)}`);\n      }\n    }\n\n    node.on('input', (msg: any, send, done) => {\n      try {\n        // Validate input\n        if (!Buffer.isBuffer(msg.payload) && !(msg.payload instanceof Uint8Array)) {\n          throw new Error('Input payload must be a Buffer or Uint8Array');\n        }\n\n        // Decode ServiceEnvelope\n        const envelope = decodeServiceEnvelope(ensureBuffer(msg.payload));\n\n        if (!envelope.packet) {\n          throw new Error('No packet in ServiceEnvelope');\n        }\n\n        const packet = envelope.packet;\n\n        // Check if packet is encrypted\n        if (packet.payloadVariant.case !== 'encrypted') {\n          node.warn('Packet is not encrypted, passing through without decryption');\n\n          const output = {\n            ...msg,\n            payload: config.outputFormat === 'object' ? envelope : ensureBuffer(msg.payload),\n            _meshtastic: {\n              encrypted: false,\n              from: packet.from,\n              to: packet.to,\n              channel: packet.channel,\n              packetId: packet.id,\n            },\n          };\n\n          send(output);\n          done();\n          return;\n        }\n\n        // Extract encrypted data\n        const encryptedData = ensureBuffer(packet.payloadVariant.value);\n\n        // Validate required fields\n        validateNodeNumber(packet.from, 'from');\n        validatePacketId(packet.id, 'packetId');\n\n        let decryptedData: Buffer;\n        let usedMode: 'channel' | 'dm';\n\n        // Determine encryption mode\n        const mode = config.mode || 'auto';\n\n        // Check for PKI encryption flag (if it exists in the packet)\n        // Note: pkiEncrypted flag may not be present in all implementations\n        const isPkiEncrypted = (packet as any).pkiEncrypted === true;\n\n        if (mode === 'auto') {\n          // Auto-detect: try PKC if flag is set, otherwise use channel\n          if (isPkiEncrypted) {\n            usedMode = 'dm';\n          } else {\n            usedMode = 'channel';\n          }\n        } else {\n          usedMode = mode;\n        }\n\n        // Decrypt based on mode\n        if (usedMode === 'dm') {\n          // Direct Message (PKC) decryption\n          if (!privateKey) {\n            throw new MeshtasticDecryptError('Direct message decryption requires a private key');\n          }\n\n          // Get sender's public key\n          const senderPublicKey = publicKeysMap.get(packet.from);\n          if (!senderPublicKey) {\n            throw new MeshtasticDecryptError(\n              `No public key found for sender node ${packet.from}. ` +\n              `Configure the sender's public key in the node settings.`\n            );\n          }\n\n          // Derive shared secret\n          const sharedSecret = deriveSharedSecret(privateKey, senderPublicKey);\n\n          // Extract nonce and auth tag from packet\n          // Note: The exact format depends on Meshtastic implementation\n          // This is a simplified version - actual implementation may need adjustment\n          const nonceLength = 12;\n          const authTagLength = 16;\n\n          if (encryptedData.length < nonceLength + authTagLength) {\n            throw new MeshtasticDecryptError('Encrypted data too short for DM decryption');\n          }\n\n          const nonce = encryptedData.subarray(0, nonceLength);\n          const ciphertext = encryptedData.subarray(nonceLength, -authTagLength);\n          const authTag = encryptedData.subarray(-authTagLength);\n\n          // Decrypt\n          decryptedData = decryptDirectMessage(ciphertext, sharedSecret, nonce, authTag);\n        } else {\n          // Channel (PSK) decryption\n          if (!channelKey) {\n            throw new MeshtasticDecryptError('Channel decryption requires a channel key');\n          }\n\n          decryptedData = decryptChannelMessage(\n            encryptedData,\n            channelKey,\n            packet.from,\n            packet.id\n          );\n        }\n\n        // Decode decrypted data as Data protobuf\n        const decodedData = decodeData(decryptedData);\n\n        // Update packet with decrypted data\n        const decryptedEnvelope: Protobuf.Mqtt.ServiceEnvelope = {\n          ...envelope,\n          packet: {\n            ...packet,\n            payloadVariant: {\n              case: 'decoded',\n              value: decodedData,\n            },\n          },\n        };\n\n        // Prepare output\n        const output = {\n          ...msg,\n          payload: config.outputFormat === 'object'\n            ? decryptedEnvelope\n            : ensureBuffer(Protobuf.Mqtt.ServiceEnvelope.toBinary(decryptedEnvelope)),\n          _meshtastic: {\n            encrypted: false,\n            decryptedWith: usedMode,\n            from: packet.from,\n            to: packet.to,\n            channel: packet.channel,\n            packetId: packet.id,\n          },\n        };\n\n        send(output);\n        done();\n      } catch (error) {\n        const errorMsg = error instanceof Error ? error.message : String(error);\n        node.error(`Decryption failed: ${errorMsg}`, msg);\n        done(error instanceof Error ? error : new Error(errorMsg));\n      }\n    });\n  }\n\n  RED.nodes.registerType('meshtastic-decrypt', DecryptNodeConstructor, {\n    credentials: {\n      channelKey: { type: 'password' },\n      privateKey: { type: 'password' },\n      publicKeys: { type: 'password' },\n    },\n  });\n};\n\nexport default nodeInit;\n"],"names":["parseKey","isDefaultKey","parsePrivateKey","parsePublicKey","decodeServiceEnvelope","ensureBuffer","output","validateNodeNumber","validatePacketId","MeshtasticDecryptError","deriveSharedSecret","decryptDirectMessage","decryptChannelMessage","decodeData","Protobuf"],"mappings":"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"}

package/dist/nodes/encode/encode.html

@@ -0,0 +1,143 @@
+<script type="text/javascript">
+    RED.nodes.registerType('meshtastic-encode', {
+        category: 'meshtastic',
+        color: '#3FADD7',
+        defaults: {
+            name: { value: '' },
+            defaultTo: { value: 4294967295 }, // BROADCAST_ADDR
+            defaultChannel: { value: 0 },
+            defaultHopLimit: { value: 3 },
+            outputFormat: { value: 'object' },
+            outputType: { value: 'envelope' }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'parser-json.svg',
+        label: function() {
+            return this.name || 'meshtastic-encode';
+        },
+        paletteLabel: 'encode'
+    });
+</script>
+
+<script type="text/html" data-template-name="meshtastic-encode">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-defaultTo"><i class="fa fa-bullseye"></i> Default To</label>
+        <input type="number" id="node-input-defaultTo" placeholder="4294967295 (broadcast)">
+        <div class="form-tips">
+            Destination node number. 4294967295 (0xFFFFFFFF) for broadcast.
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-defaultChannel"><i class="fa fa-sitemap"></i> Default Channel</label>
+        <input type="number" id="node-input-defaultChannel" min="0" max="7" placeholder="0">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-defaultHopLimit"><i class="fa fa-share-alt"></i> Default Hop Limit</label>
+        <input type="number" id="node-input-defaultHopLimit" min="0" max="7" placeholder="3">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-outputType"><i class="fa fa-cube"></i> Output Type</label>
+        <select id="node-input-outputType">
+            <option value="envelope">ServiceEnvelope (full packet)</option>
+            <option value="data">Data only (for custom wrapping)</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-outputFormat"><i class="fa fa-file-o"></i> Output Format</label>
+        <select id="node-input-outputFormat">
+            <option value="object">Object</option>
+            <option value="buffer">Buffer (binary)</option>
+        </select>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="meshtastic-encode">
+    <p>Encodes JSON messages to Meshtastic protobuf format.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>Object containing message to encode</dd>
+        <dt>payload.portNum <span class="property-type">string | number</span></dt>
+        <dd>Message type (e.g., "TEXT_MESSAGE_APP" or 1)</dd>
+        <dt>payload.message <span class="property-type">any</span></dt>
+        <dd>Message data (type depends on portNum)</dd>
+        <dt class="optional">payload.to <span class="property-type">number</span></dt>
+        <dd>Destination node (default: broadcast)</dd>
+        <dt class="optional">payload.channel <span class="property-type">number</span></dt>
+        <dd>Channel index 0-7 (default: 0)</dd>
+        <dt class="optional">payload.from <span class="property-type">number</span></dt>
+        <dd>Source node (default: 0, set by encrypt node)</dd>
+        <dt class="optional">payload.wantAck <span class="property-type">boolean</span></dt>
+        <dd>Request acknowledgment (default: false)</dd>
+        <dt class="optional">payload.hopLimit <span class="property-type">number</span></dt>
+        <dd>Max hops 0-7 (default: 3)</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer | Object</span></dt>
+        <dd>Encoded protobuf (Data or ServiceEnvelope)</dd>
+        <dt>_meshtastic <span class="property-type">object</span></dt>
+        <dd>Metadata about encoding</dd>
+    </dl>
+
+    <h3>Details</h3>
+    <p>This node encodes JSON messages into Meshtastic protobuf format.</p>
+
+    <h4>Supported Message Types</h4>
+    <ul>
+        <li><b>TEXT_MESSAGE_APP</b>: Text string</li>
+        <li><b>POSITION_APP</b>: Position object with lat/lon/altitude</li>
+        <li><b>NODEINFO_APP</b>: User object with id/longName/shortName</li>
+        <li><b>TELEMETRY_APP</b>: Telemetry object</li>
+        <li><b>ADMIN_APP</b>: Admin command object</li>
+        <li>And more...</li>
+    </ul>
+
+    <h4>Output Type</h4>
+    <p><b>ServiceEnvelope</b>: Full packet ready for encryption or transmission.</p>
+    <p><b>Data only</b>: Just the encoded Data protobuf for custom processing.</p>
+
+    <h4>Default Values</h4>
+    <p>Configure default values for to, channel, and hopLimit. These can be overridden per message.</p>
+
+    <h3>Example Input</h3>
+    <pre>
+{
+  portNum: "TEXT_MESSAGE_APP",
+  message: "Hello, mesh!",
+  to: 123456,  // or 4294967295 for broadcast
+  channel: 0,
+  wantAck: false
+}
+    </pre>
+
+    <h3>Example Input (Position)</h3>
+    <pre>
+{
+  portNum: "POSITION_APP",
+  message: {
+    latitudeI: 378524200,  // 37.8524200 * 1e7
+    longitudeI: -1223964700, // -122.3964700 * 1e7
+    altitude: 15,
+    time: 1234567890
+  }
+}
+    </pre>
+
+    <h3>References</h3>
+    <ul>
+        <li><a href="https://meshtastic.org/docs/development/reference/protobufs/">Meshtastic Protobufs</a></li>
+    </ul>
+</script>

package/dist/nodes/encode/encode.js

@@ -0,0 +1,94 @@
+"use strict";
+require("crypto");
+const decoder = require("../../decoder-BvBAtm2U.js");
+const encoder = require("../../encoder-DU3wTIEA.js");
+const messageTypes = require("../../message-types-FA26fPjF.js");
+const validation = require("../../validation-BegQyBSh.js");
+const nodeInit = (RED) => {
+  function EncodeNodeConstructor(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.on("input", (msg, send, done) => {
+      try {
+        if (!msg.payload || typeof msg.payload !== "object") {
+          throw new Error("Input payload must be an object");
+        }
+        const input = msg.payload;
+        if (!input.portNum && input.portNum !== 0) {
+          throw new decoder.MeshtasticEncodeError("portNum is required in payload");
+        }
+        const portNum = encoder.parsePortNum(input.portNum);
+        const portNumName = decoder.getPortNumName(portNum);
+        if (input.message === void 0 && input.message !== null) {
+          throw new decoder.MeshtasticEncodeError("message is required in payload");
+        }
+        const encodedPayload = encoder.encodeMessageByPortNum(portNum, input.message);
+        const data = encoder.createDataPayload(portNum, encodedPayload, {
+          wantResponse: input.wantResponse,
+          requestId: input.requestId,
+          emoji: input.emoji
+        });
+        const outputType = config.outputType || "envelope";
+        if (outputType === "data") {
+          const output2 = {
+            ...msg,
+            payload: config.outputFormat === "object" ? data : encoder.encodeData(data),
+            _meshtastic: {
+              portNum: portNumName,
+              portNumValue: portNum,
+              encoded: true
+            }
+          };
+          send(output2);
+          done();
+          return;
+        }
+        const to = input.to ?? config.defaultTo ?? messageTypes.BROADCAST_ADDR;
+        const channel = input.channel ?? config.defaultChannel ?? 0;
+        const hopLimit = input.hopLimit ?? config.defaultHopLimit ?? 3;
+        validation.validateNodeNumber(to, "to");
+        validation.validateChannelIndex(channel, "channel");
+        validation.validateHopLimit(hopLimit, "hopLimit");
+        const from = input.from ?? 0;
+        const packetId = input.packetId;
+        const envelope = encoder.createServiceEnvelope(
+          data,
+          from,
+          to,
+          channel,
+          packetId,
+          {
+            wantAck: input.wantAck,
+            hopLimit,
+            priority: input.priority,
+            channelId: input.channelId,
+            gatewayId: input.gatewayId
+          }
+        );
+        const output = {
+          ...msg,
+          payload: config.outputFormat === "object" ? envelope : encoder.encodeServiceEnvelope(envelope),
+          _meshtastic: {
+            portNum: portNumName,
+            portNumValue: portNum,
+            from,
+            to,
+            channel,
+            hopLimit,
+            wantAck: input.wantAck ?? false,
+            encoded: true
+          }
+        };
+        send(output);
+        done();
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        node.error(`Encode failed: ${errorMsg}`, msg);
+        done(error instanceof Error ? error : new Error(errorMsg));
+      }
+    });
+  }
+  RED.nodes.registerType("meshtastic-encode", EncodeNodeConstructor);
+};
+module.exports = nodeInit;
+//# sourceMappingURL=encode.js.map

package/dist/nodes/encode/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sources":["../../../src/nodes/encode/encode.ts"],"sourcesContent":["/**\n * Meshtastic Encode Node\n * Encodes JSON messages to Meshtastic protobuf payloads\n */\n\nimport type { Node, NodeDef, NodeInitializer } from 'node-red';\nimport { Protobuf } from '@meshtastic/protobufs';\nimport {\n  encodeMessageByPortNum,\n  parsePortNum,\n  createDataPayload,\n  createServiceEnvelope,\n  encodeServiceEnvelope,\n  encodeData,\n  getPortNumName,\n  BROADCAST_ADDR,\n  MeshtasticEncodeError,\n  validateNodeNumber,\n  validateChannelIndex,\n  validateHopLimit,\n} from '../../lib';\n\ninterface EncodeConfig extends NodeDef {\n  name: string;\n  defaultTo: number;\n  defaultChannel: number;\n  defaultHopLimit: number;\n  outputFormat: 'buffer' | 'object';\n  outputType: 'data' | 'envelope';\n}\n\nconst nodeInit: NodeInitializer = (RED): void => {\n  function EncodeNodeConstructor(this: Node, config: EncodeConfig): void {\n    RED.nodes.createNode(this, config);\n    const node = this;\n\n    node.on('input', (msg: any, send, done) => {\n      try {\n        // Validate input\n        if (!msg.payload || typeof msg.payload !== 'object') {\n          throw new Error('Input payload must be an object');\n        }\n\n        const input = msg.payload;\n\n        // Parse port number (required)\n        if (!input.portNum && input.portNum !== 0) {\n          throw new MeshtasticEncodeError('portNum is required in payload');\n        }\n\n        const portNum = parsePortNum(input.portNum);\n        const portNumName = getPortNumName(portNum);\n\n        // Get message data (required)\n        if (input.message === undefined && input.message !== null) {\n          throw new MeshtasticEncodeError('message is required in payload');\n        }\n\n        // Encode the message\n        const encodedPayload = encodeMessageByPortNum(portNum, input.message);\n\n        // Create Data protobuf\n        const data = createDataPayload(portNum, encodedPayload, {\n          wantResponse: input.wantResponse,\n          requestId: input.requestId,\n          emoji: input.emoji,\n        });\n\n        // Check if we should output just Data or full ServiceEnvelope\n        const outputType = config.outputType || 'envelope';\n\n        if (outputType === 'data') {\n          // Output just the Data protobuf\n          const output = {\n            ...msg,\n            payload: config.outputFormat === 'object' ? data : encodeData(data),\n            _meshtastic: {\n              portNum: portNumName,\n              portNumValue: portNum,\n              encoded: true,\n            },\n          };\n\n          send(output);\n          done();\n          return;\n        }\n\n        // Build full ServiceEnvelope\n        // Get addressing info (from, to, channel)\n        const to = input.to ?? config.defaultTo ?? BROADCAST_ADDR;\n        const channel = input.channel ?? config.defaultChannel ?? 0;\n        const hopLimit = input.hopLimit ?? config.defaultHopLimit ?? 3;\n\n        // Validate values\n        validateNodeNumber(to, 'to');\n        validateChannelIndex(channel, 'channel');\n        validateHopLimit(hopLimit, 'hopLimit');\n\n        // from and packetId will be set during encryption or by the sender\n        const from = input.from ?? 0; // 0 = will be set later\n        const packetId = input.packetId; // undefined = will be generated\n\n        // Create ServiceEnvelope\n        const envelope = createServiceEnvelope(\n          data,\n          from,\n          to,\n          channel,\n          packetId,\n          {\n            wantAck: input.wantAck,\n            hopLimit,\n            priority: input.priority,\n            channelId: input.channelId,\n            gatewayId: input.gatewayId,\n          }\n        );\n\n        // Prepare output\n        const output = {\n          ...msg,\n          payload: config.outputFormat === 'object' ? envelope : encodeServiceEnvelope(envelope),\n          _meshtastic: {\n            portNum: portNumName,\n            portNumValue: portNum,\n            from,\n            to,\n            channel,\n            hopLimit,\n            wantAck: input.wantAck ?? false,\n            encoded: true,\n          },\n        };\n\n        send(output);\n        done();\n      } catch (error) {\n        const errorMsg = error instanceof Error ? error.message : String(error);\n        node.error(`Encode failed: ${errorMsg}`, msg);\n        done(error instanceof Error ? error : new Error(errorMsg));\n      }\n    });\n  }\n\n  RED.nodes.registerType('meshtastic-encode', EncodeNodeConstructor);\n};\n\nexport default nodeInit;\n"],"names":["MeshtasticEncodeError","parsePortNum","getPortNumName","encodeMessageByPortNum","createDataPayload","output","encodeData","BROADCAST_ADDR","validateNodeNumber","validateChannelIndex","validateHopLimit","createServiceEnvelope","encodeServiceEnvelope"],"mappings":";;;;;;AA+BA,MAAM,WAA4B,CAAC,QAAc;AAC/C,WAAS,sBAAkC,QAA4B;AACrE,QAAI,MAAM,WAAW,MAAM,MAAM;AACjC,UAAM,OAAO;AAEb,SAAK,GAAG,SAAS,CAAC,KAAU,MAAM,SAAS;AACzC,UAAI;AAEF,YAAI,CAAC,IAAI,WAAW,OAAO,IAAI,YAAY,UAAU;AACnD,gBAAM,IAAI,MAAM,iCAAiC;AAAA,QACnD;AAEA,cAAM,QAAQ,IAAI;AAGlB,YAAI,CAAC,MAAM,WAAW,MAAM,YAAY,GAAG;AACzC,gBAAM,IAAIA,QAAAA,sBAAsB,gCAAgC;AAAA,QAClE;AAEA,cAAM,UAAUC,QAAAA,aAAa,MAAM,OAAO;AAC1C,cAAM,cAAcC,QAAAA,eAAe,OAAO;AAG1C,YAAI,MAAM,YAAY,UAAa,MAAM,YAAY,MAAM;AACzD,gBAAM,IAAIF,QAAAA,sBAAsB,gCAAgC;AAAA,QAClE;AAGA,cAAM,iBAAiBG,QAAAA,uBAAuB,SAAS,MAAM,OAAO;AAGpE,cAAM,OAAOC,QAAAA,kBAAkB,SAAS,gBAAgB;AAAA,UACtD,cAAc,MAAM;AAAA,UACpB,WAAW,MAAM;AAAA,UACjB,OAAO,MAAM;AAAA,QAAA,CACd;AAGD,cAAM,aAAa,OAAO,cAAc;AAExC,YAAI,eAAe,QAAQ;AAEzB,gBAAMC,UAAS;AAAA,YACb,GAAG;AAAA,YACH,SAAS,OAAO,iBAAiB,WAAW,OAAOC,QAAAA,WAAW,IAAI;AAAA,YAClE,aAAa;AAAA,cACX,SAAS;AAAA,cACT,cAAc;AAAA,cACd,SAAS;AAAA,YAAA;AAAA,UACX;AAGF,eAAKD,OAAM;AACX,eAAA;AACA;AAAA,QACF;AAIA,cAAM,KAAK,MAAM,MAAM,OAAO,aAAaE,aAAAA;AAC3C,cAAM,UAAU,MAAM,WAAW,OAAO,kBAAkB;AAC1D,cAAM,WAAW,MAAM,YAAY,OAAO,mBAAmB;AAG7DC,mBAAAA,mBAAmB,IAAI,IAAI;AAC3BC,mBAAAA,qBAAqB,SAAS,SAAS;AACvCC,mBAAAA,iBAAiB,UAAU,UAAU;AAGrC,cAAM,OAAO,MAAM,QAAQ;AAC3B,cAAM,WAAW,MAAM;AAGvB,cAAM,WAAWC,QAAAA;AAAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,YACE,SAAS,MAAM;AAAA,YACf;AAAA,YACA,UAAU,MAAM;AAAA,YAChB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM;AAAA,UAAA;AAAA,QACnB;AAIF,cAAM,SAAS;AAAA,UACb,GAAG;AAAA,UACH,SAAS,OAAO,iBAAiB,WAAW,WAAWC,QAAAA,sBAAsB,QAAQ;AAAA,UACrF,aAAa;AAAA,YACX,SAAS;AAAA,YACT,cAAc;AAAA,YACd;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,SAAS,MAAM,WAAW;AAAA,YAC1B,SAAS;AAAA,UAAA;AAAA,QACX;AAGF,aAAK,MAAM;AACX,aAAA;AAAA,MACF,SAAS,OAAO;AACd,cAAM,WAAW,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACtE,aAAK,MAAM,kBAAkB,QAAQ,IAAI,GAAG;AAC5C,aAAK,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,QAAQ,CAAC;AAAA,MAC3D;AAAA,IACF,CAAC;AAAA,EACH;AAEA,MAAI,MAAM,aAAa,qBAAqB,qBAAqB;AACnE;;"}

package/dist/nodes/encrypt/encrypt.html

@@ -0,0 +1,164 @@
+<script type="text/javascript">
+    RED.nodes.registerType('meshtastic-encrypt', {
+        category: 'meshtastic',
+        color: '#3FADD7',
+        defaults: {
+            name: { value: '' },
+            mode: { value: 'channel' },
+            keyFormat: { value: 'base64' },
+            fromNode: { value: 0 },
+            outputFormat: { value: 'buffer' }
+        },
+        credentials: {
+            channelKey: { type: 'password' },
+            myPrivateKey: { type: 'password' },
+            myPublicKey: { type: 'password' },
+            recipientPublicKey: { type: 'password' }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'lock.svg',
+        label: function() {
+            return this.name || 'meshtastic-encrypt';
+        },
+        paletteLabel: 'encrypt'
+    });
+</script>
+
+<script type="text/html" data-template-name="meshtastic-encrypt">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-mode"><i class="fa fa-cog"></i> Mode</label>
+        <select id="node-input-mode">
+            <option value="channel">Channel (PSK)</option>
+            <option value="dm">Direct Message (PKC)</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-keyFormat"><i class="fa fa-file-code-o"></i> Key Format</label>
+        <select id="node-input-keyFormat">
+            <option value="base64">Base64</option>
+            <option value="hex">Hex</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-fromNode"><i class="fa fa-user"></i> From Node</label>
+        <input type="number" id="node-input-fromNode" placeholder="Source node number">
+        <div class="form-tips">
+            Source node number (can be overridden via msg._meshtastic.from)
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-channelKey"><i class="fa fa-key"></i> Channel Key (PSK)</label>
+        <input type="password" id="node-input-channelKey" placeholder="Base64 or hex channel key">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-myPrivateKey"><i class="fa fa-lock"></i> My Private Key</label>
+        <input type="password" id="node-input-myPrivateKey" placeholder="Your x25519 private key">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-myPublicKey"><i class="fa fa-unlock"></i> My Public Key</label>
+        <input type="password" id="node-input-myPublicKey" placeholder="Your x25519 public key">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-recipientPublicKey"><i class="fa fa-user-circle"></i> Recipient Public Key</label>
+        <input type="password" id="node-input-recipientPublicKey" placeholder="Recipient's x25519 public key">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-outputFormat"><i class="fa fa-file-o"></i> Output Format</label>
+        <select id="node-input-outputFormat">
+            <option value="buffer">Buffer (binary)</option>
+            <option value="object">Object (ServiceEnvelope)</option>
+        </select>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="meshtastic-encrypt">
+    <p>Encrypts Meshtastic payloads using either channel PSK or direct message PKC.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer | Object</span></dt>
+        <dd>Data protobuf or ServiceEnvelope to encrypt</dd>
+        <dt class="optional">_meshtastic.from <span class="property-type">number</span></dt>
+        <dd>Source node number (overrides config)</dd>
+        <dt class="optional">_meshtastic.to <span class="property-type">number</span></dt>
+        <dd>Destination node number</dd>
+        <dt class="optional">_meshtastic.channel <span class="property-type">number</span></dt>
+        <dd>Channel index</dd>
+        <dt class="optional">_meshtastic.packetId <span class="property-type">number</span></dt>
+        <dd>Packet ID (random if not provided)</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer | Object</span></dt>
+        <dd>Encrypted ServiceEnvelope</dd>
+        <dt>_meshtastic <span class="property-type">object</span></dt>
+        <dd>Metadata about encryption</dd>
+    </dl>
+
+    <h3>Details</h3>
+    <p>This node encrypts Meshtastic packets using:</p>
+    <ul>
+        <li><b>Channel encryption (PSK)</b>: AES-128/256-CTR with pre-shared key</li>
+        <li><b>Direct message encryption (PKC)</b>: x25519 + AES-256-CCM</li>
+    </ul>
+
+    <h4>Mode</h4>
+    <p><b>Channel (PSK)</b>: Encrypt for a channel using a pre-shared key. All nodes with the same key can decrypt.</p>
+    <p><b>Direct Message (PKC)</b>: Encrypt for a specific recipient using public key cryptography. Only the recipient can decrypt.</p>
+
+    <h4>Channel Encryption (PSK)</h4>
+    <p>Required:</p>
+    <ul>
+        <li><b>Channel Key</b>: 16 or 32 bytes in base64/hex</li>
+        <li><b>From Node</b>: Source node number (for nonce construction)</li>
+    </ul>
+
+    <h4>Direct Message Encryption (PKC)</h4>
+    <p>Required:</p>
+    <ul>
+        <li><b>My Private Key</b>: Your x25519 private key (32 bytes)</li>
+        <li><b>Recipient Public Key</b>: Recipient's x25519 public key (32 bytes)</li>
+        <li><b>From Node</b>: Your node number</li>
+    </ul>
+    <p>Optional:</p>
+    <ul>
+        <li><b>My Public Key</b>: Your public key (for reference)</li>
+    </ul>
+
+    <h4>From Node Number</h4>
+    <p>The source node number is required for encryption (nonce construction). It can be set:</p>
+    <ol>
+        <li>In the node configuration (From Node field)</li>
+        <li>Via <code>msg._meshtastic.from</code> (overrides config)</li>
+    </ol>
+
+    <h4>Packet ID</h4>
+    <p>A packet ID is automatically generated if not provided. For channel encryption, it's part of the nonce.</p>
+
+    <h4>Security</h4>
+    <p>All keys are stored encrypted using Node-RED's credentials system.</p>
+
+    <h3>Example Flow</h3>
+    <pre>
+[Inject] → [meshtastic-encode] → [meshtastic-encrypt] → [MQTT Out]
+    </pre>
+
+    <h3>References</h3>
+    <ul>
+        <li><a href="https://meshtastic.org/docs/overview/encryption/">Meshtastic Encryption</a></li>
+    </ul>
+</script>

package/dist/nodes/encrypt/encrypt.js

@@ -0,0 +1,199 @@
+"use strict";
+const protobufs = require("@meshtastic/protobufs");
+const crypto = require("crypto");
+const x25519 = require("../../x25519-D0dlDGB0.js");
+const decoder = require("../../decoder-BvBAtm2U.js");
+const encoder = require("../../encoder-DU3wTIEA.js");
+const validation = require("../../validation-BegQyBSh.js");
+const nodeInit = (RED) => {
+  function EncryptNodeConstructor(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const credentials = RED.nodes.getCredentials(config.id);
+    let channelKey = null;
+    if (credentials == null ? void 0 : credentials.channelKey) {
+      try {
+        channelKey = x25519.parseKey(credentials.channelKey, config.keyFormat || "base64");
+        if (x25519.isDefaultKey(channelKey)) {
+          node.warn(
+            "Using default Meshtastic encryption key (AQ==). This is INSECURE and should only be used for testing."
+          );
+        }
+      } catch (error) {
+        node.error(`Invalid channel key: ${error instanceof Error ? error.message : String(error)}`);
+        channelKey = null;
+      }
+    }
+    let myPrivateKey = null;
+    let myPublicKey = null;
+    let recipientPublicKey = null;
+    if (credentials == null ? void 0 : credentials.myPrivateKey) {
+      try {
+        myPrivateKey = x25519.parsePrivateKey(credentials.myPrivateKey, config.keyFormat || "base64");
+      } catch (error) {
+        node.error(`Invalid private key: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (credentials == null ? void 0 : credentials.myPublicKey) {
+      try {
+        myPublicKey = x25519.parsePublicKey(credentials.myPublicKey, config.keyFormat || "base64");
+      } catch (error) {
+        node.error(`Invalid public key: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (credentials == null ? void 0 : credentials.recipientPublicKey) {
+      try {
+        recipientPublicKey = x25519.parsePublicKey(credentials.recipientPublicKey, config.keyFormat || "base64");
+      } catch (error) {
+        node.error(`Invalid recipient public key: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    node.on("input", (msg, send, done) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      try {
+        let data;
+        let envelope = null;
+        let from;
+        let to;
+        let channel;
+        let packetId;
+        if (Buffer.isBuffer(msg.payload) || msg.payload instanceof Uint8Array) {
+          try {
+            data = decoder.decodeData(decoder.ensureBuffer(msg.payload));
+            from = ((_a = msg._meshtastic) == null ? void 0 : _a.from) ?? config.fromNode ?? 0;
+            to = ((_b = msg._meshtastic) == null ? void 0 : _b.to) ?? 4294967295;
+            channel = ((_c = msg._meshtastic) == null ? void 0 : _c.channel) ?? 0;
+            packetId = ((_d = msg._meshtastic) == null ? void 0 : _d.packetId) ?? crypto.randomBytes(4).readUInt32LE(0);
+          } catch {
+            envelope = decoder.decodeServiceEnvelope(decoder.ensureBuffer(msg.payload));
+            if (!envelope.packet || envelope.packet.payloadVariant.case !== "decoded") {
+              throw new Error("ServiceEnvelope must have a decoded payload");
+            }
+            data = envelope.packet.payloadVariant.value;
+            from = envelope.packet.from;
+            to = envelope.packet.to;
+            channel = envelope.packet.channel;
+            packetId = envelope.packet.id || crypto.randomBytes(4).readUInt32LE(0);
+          }
+        } else if (typeof msg.payload === "object") {
+          if (msg.payload.packet) {
+            envelope = msg.payload;
+            if (!envelope.packet || envelope.packet.payloadVariant.case !== "decoded") {
+              throw new Error("ServiceEnvelope must have a decoded payload");
+            }
+            data = envelope.packet.payloadVariant.value;
+            from = envelope.packet.from;
+            to = envelope.packet.to;
+            channel = envelope.packet.channel;
+            packetId = envelope.packet.id || crypto.randomBytes(4).readUInt32LE(0);
+          } else {
+            data = msg.payload;
+            from = ((_e = msg._meshtastic) == null ? void 0 : _e.from) ?? config.fromNode ?? 0;
+            to = ((_f = msg._meshtastic) == null ? void 0 : _f.to) ?? 4294967295;
+            channel = ((_g = msg._meshtastic) == null ? void 0 : _g.channel) ?? 0;
+            packetId = ((_h = msg._meshtastic) == null ? void 0 : _h.packetId) ?? crypto.randomBytes(4).readUInt32LE(0);
+          }
+        } else {
+          throw new Error("Input must be a Buffer, Uint8Array, Data, or ServiceEnvelope");
+        }
+        if (!from || from === 0) {
+          throw new decoder.MeshtasticEncryptError("from node number is required (set in config or msg._meshtastic.from)");
+        }
+        validation.validateNodeNumber(from, "from");
+        validation.validatePacketId(packetId, "packetId");
+        const dataBytes = decoder.ensureBuffer(encoder.encodeData(data));
+        let encryptedBytes;
+        let isPkiEncrypted = false;
+        if (config.mode === "dm") {
+          if (!myPrivateKey || !recipientPublicKey) {
+            throw new decoder.MeshtasticEncryptError("DM encryption requires myPrivateKey and recipientPublicKey");
+          }
+          const sharedSecret = x25519.deriveSharedSecret(myPrivateKey, recipientPublicKey);
+          const nonce = crypto.randomBytes(12);
+          const { ciphertext, authTag } = x25519.encryptDirectMessage(dataBytes, sharedSecret, nonce);
+          encryptedBytes = Buffer.concat([nonce, ciphertext, authTag]);
+          isPkiEncrypted = true;
+        } else {
+          if (!channelKey) {
+            throw new decoder.MeshtasticEncryptError("Channel encryption requires a channelKey");
+          }
+          encryptedBytes = x25519.encryptChannelMessage(dataBytes, channelKey, from, packetId);
+        }
+        let outputEnvelope;
+        if (envelope) {
+          outputEnvelope = {
+            ...envelope,
+            packet: {
+              ...envelope.packet,
+              from,
+              to,
+              channel,
+              id: packetId,
+              payloadVariant: {
+                case: "encrypted",
+                value: encryptedBytes
+              }
+            }
+          };
+          if (isPkiEncrypted) {
+            outputEnvelope.packet.pkiEncrypted = true;
+          }
+        } else {
+          outputEnvelope = {
+            packet: {
+              from,
+              to,
+              channel,
+              id: packetId,
+              rxTime: 0,
+              rxSnr: 0,
+              rxRssi: 0,
+              hopLimit: ((_i = msg._meshtastic) == null ? void 0 : _i.hopLimit) ?? 3,
+              wantAck: ((_j = msg._meshtastic) == null ? void 0 : _j.wantAck) ?? false,
+              priority: protobufs.Protobuf.Mesh.MeshPacket_Priority.UNSET,
+              hopStart: ((_k = msg._meshtastic) == null ? void 0 : _k.hopLimit) ?? 3,
+              payloadVariant: {
+                case: "encrypted",
+                value: encryptedBytes
+              }
+            },
+            channelId: "",
+            gatewayId: ""
+          };
+          if (isPkiEncrypted) {
+            outputEnvelope.packet.pkiEncrypted = true;
+          }
+        }
+        const output = {
+          ...msg,
+          payload: config.outputFormat === "object" ? outputEnvelope : encoder.encodeServiceEnvelope(outputEnvelope),
+          _meshtastic: {
+            encrypted: true,
+            encryptedWith: config.mode,
+            isPkiEncrypted,
+            from,
+            to,
+            channel,
+            packetId
+          }
+        };
+        send(output);
+        done();
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        node.error(`Encryption failed: ${errorMsg}`, msg);
+        done(error instanceof Error ? error : new Error(errorMsg));
+      }
+    });
+  }
+  RED.nodes.registerType("meshtastic-encrypt", EncryptNodeConstructor, {
+    credentials: {
+      channelKey: { type: "password" },
+      myPrivateKey: { type: "password" },
+      myPublicKey: { type: "password" },
+      recipientPublicKey: { type: "password" }
+    }
+  });
+};
+module.exports = nodeInit;
+//# sourceMappingURL=encrypt.js.map