node-red-contrib-knx-ultimate 4.0.7 → 4.0.9

package/CHANGELOG.md

@@ -6,6 +6,10 @@
 
 # CHANGELOG
 
+**Version 4.0.9** - September 2025<br/>
+- KNX Config node: now the ethernet interface is automatically selected, based on the KNX Gateway's IP subnet.<br/>
+- Added the details of keyring in clear text, when the loglevel is set to "debug".<br/>
+
 **Version 4.0.7** - September 2025<br/>
 - Fixed an issue where some secure fields were missing when creating a new config-node.<br/>
 - HUE Light: enhanced the Homeassistant export yaml.<br/>

package/nodes/commonFunctions.js

@@ -299,21 +299,21 @@ module.exports = (RED) => {
             try {
                 const oiFaces = oOS.networkInterfaces();
                 Object.keys(oiFaces).forEach((ifname) => {
-                    // Interface with single IP
-                    if (Object.keys(oiFaces[ifname]).length === 1) {
-                        if (Object.keys(oiFaces[ifname])[0].internal === false) {
-                            jListInterfaces.push({
-                                name: ifname,
-                                address: Object.keys(oiFaces[ifname])[0].address,
-                            });
-                        }
-                    } else {
-                        let sAddresses = "";
-                        oiFaces[ifname].forEach((iface) => {
-                            if (iface.internal === false) sAddresses += `+${iface.address}`;
-                        });
-                        if (sAddresses !== "") jListInterfaces.push({ name: ifname, address: sAddresses });
-                    }
+                    const ifaceEntries = Array.isArray(oiFaces[ifname]) ? oiFaces[ifname] : [];
+                    const externalEntries = ifaceEntries.filter((iface) => iface && iface.internal === false);
+                    if (externalEntries.length === 0) return;
+                    const addresses = externalEntries.map((iface) => ({
+                        address: iface.address,
+                        family: iface.family,
+                        netmask: iface.netmask,
+                        cidr: iface.cidr || null,
+                    }));
+                    const displayAddress = addresses.map((entry) => entry.address).join(", ");
+                    jListInterfaces.push({
+                        name: ifname,
+                        address: displayAddress,
+                        addresses,
+                    });
                 });
             } catch (error) { }
             res.json(jListInterfaces);

package/nodes/knxUltimate-config.html

@@ -140,6 +140,43 @@
                 return first >= 224 && first <= 239;
             }
 
+            const NETMASK_BIT_LOOKUP = (() => {
+                const lookup = new Array(256);
+                for (let i = 0; i < 256; i++) {
+                    let bits = 0;
+                    let value = i;
+                    while (value > 0) {
+                        bits += value & 1;
+                        value >>= 1;
+                    }
+                    lookup[i] = bits;
+                }
+                return lookup;
+            })();
+
+            function countNetmaskBits(maskOctets) {
+                if (!Array.isArray(maskOctets) || maskOctets.length !== 4) return 0;
+                let total = 0;
+                for (let i = 0; i < 4; i++) {
+                    const oct = maskOctets[i];
+                    if (!Number.isInteger(oct) || oct < 0 || oct > 255) return 0;
+                    total += NETMASK_BIT_LOOKUP[oct];
+                }
+                return total;
+            }
+
+            function computeIPv4NetworkKey(ipOctets, maskOctets) {
+                if (!Array.isArray(ipOctets) || ipOctets.length !== 4 || !Array.isArray(maskOctets) || maskOctets.length !== 4) return null;
+                const parts = [];
+                for (let i = 0; i < 4; i++) {
+                    const ipVal = ipOctets[i];
+                    const maskVal = maskOctets[i];
+                    if (!Number.isInteger(ipVal) || ipVal < 0 || ipVal > 255 || !Number.isInteger(maskVal) || maskVal < 0 || maskVal > 255) return null;
+                    parts.push(ipVal & maskVal);
+                }
+                return parts.join('.');
+            }
+
             function normalizeTunnelIAValue(value) {
                 if (typeof value !== 'string') return '';
                 const trimmed = value.trim();
@@ -499,6 +536,7 @@
                     } catch (e) { }
                     const phys = `${prefix}.${rnd}`;
                     $("#node-config-input-physAddr").val(phys);
+                    autoSelectEthernetInterfaceForHost({ force: true });
                     blinkBackgroundArray(["#node-config-input-host", "#node-config-input-port", "#node-config-input-name", "#node-config-input-physAddr"]);
                     return false;
                 },
@@ -552,40 +590,120 @@
                 });
             } catch (e) { }
 
+            const $knxEthInterfaceSelect = $("#node-config-input-KNXEthInterface");
+            const $knxEthInterfaceManualRow = $("#divKNXEthInterfaceManuallyInput");
+            const $knxEthInterfaceManualInput = $("#node-config-input-KNXEthInterfaceManuallyInput");
+            let ethernetInterfaces = [];
+            let suppressInterfaceSelectionChange = false;
+            let userLockedInterfaceSelection = false;
 
-            $("#node-config-input-KNXEthInterface").append($("<option></option>")
-                .attr("value", "Auto")
-                .text(node._('knxUltimate-config.properties.iface_auto'))
-            );
-            $("#node-config-input-KNXEthInterface").append($("<option></option>")
-                .attr("value", "Manual")
-                .text(node._('knxUltimate-config.properties.iface_manual'))
-            );
-
-            $.getJSON('knxUltimateETHInterfaces', (data) => {
-                data.sort().forEach(iFace => {
-                    $("#node-config-input-KNXEthInterface").append($("<option></option>")
-                        .attr("value", iFace.name)
-                        .text(iFace.name + " (" + iFace.address + ")")
-                    )
-                });
-                $("#node-config-input-KNXEthInterface").val(typeof node.KNXEthInterface === "undefined" ? "Auto" : node.KNXEthInterface)
-                if (node.KNXEthInterface === "Manual") {
-                    // Show input
-                    $("#divKNXEthInterfaceManuallyInput").show();
+            function updateEthernetManualVisibility(value) {
+                if (value === 'Manual') {
+                    $knxEthInterfaceManualRow.show();
                 } else {
-                    $("#divKNXEthInterfaceManuallyInput").hide()
+                    $knxEthInterfaceManualRow.hide();
                 }
+            }
 
-                $("#node-config-input-KNXEthInterface").on('change', function () {
-                    if ($("#node-config-input-KNXEthInterface").val() === "Manual") {
-                        // Show input
-                        $("#divKNXEthInterfaceManuallyInput").show();
-                    } else {
-                        // Hide input
-                        $("#divKNXEthInterfaceManuallyInput").hide()
+            function setEthernetInterfaceSelection(value, triggerChange) {
+                const finalValue = value || 'Auto';
+                if ($knxEthInterfaceSelect.val() === finalValue) {
+                    if (triggerChange) {
+                        suppressInterfaceSelectionChange = true;
+                        $knxEthInterfaceSelect.trigger('change');
+                        suppressInterfaceSelectionChange = false;
                     }
+                    return;
+                }
+                suppressInterfaceSelectionChange = true;
+                $knxEthInterfaceSelect.val(finalValue);
+                if (triggerChange) {
+                    $knxEthInterfaceSelect.trigger('change');
+                }
+                suppressInterfaceSelectionChange = false;
+            }
+
+            function findEthernetInterfaceMatch(ipOctets) {
+                if (!Array.isArray(ipOctets) || ethernetInterfaces.length === 0) return null;
+                let bestMatch = null;
+                let bestMaskBits = -1;
+                ethernetInterfaces.forEach((iface) => {
+                    const entries = Array.isArray(iface.addresses) ? iface.addresses : [];
+                    entries.forEach((entry) => {
+                        if (!entry || entry.family !== 'IPv4') return;
+                        const ifaceOctets = parseIPv4Address(entry.address);
+                        const maskOctets = parseIPv4Address(entry.netmask || '');
+                        if (!ifaceOctets || !maskOctets) return;
+                        const ifaceNetwork = computeIPv4NetworkKey(ifaceOctets, maskOctets);
+                        const hostNetwork = computeIPv4NetworkKey(ipOctets, maskOctets);
+                        if (!ifaceNetwork || !hostNetwork || ifaceNetwork !== hostNetwork) return;
+                        const maskBits = countNetmaskBits(maskOctets);
+                        if (maskBits > bestMaskBits) {
+                            bestMaskBits = maskBits;
+                            bestMatch = iface;
+                        }
+                    });
                 });
+                return bestMatch;
+            }
+
+            function autoSelectEthernetInterfaceForHost(options = {}) {
+                const { force } = options;
+                if (!force && userLockedInterfaceSelection) return;
+                const hostValue = String($("#node-config-input-host").val() || '').trim();
+                const hostOctets = parseIPv4Address(hostValue);
+                if (!hostOctets || isMulticastIPv4(hostOctets)) return;
+                const match = findEthernetInterfaceMatch(hostOctets);
+                if (!match || !match.name) return;
+                if ($knxEthInterfaceSelect.val() === match.name) return;
+                setEthernetInterfaceSelection(match.name, true);
+            }
+
+            $knxEthInterfaceSelect.empty()
+                .append($("<option></option>")
+                    .attr("value", "Auto")
+                    .text(node._('knxUltimate-config.properties.iface_auto')))
+                .append($("<option></option>")
+                    .attr("value", "Manual")
+                    .text(node._('knxUltimate-config.properties.iface_manual')));
+
+            $knxEthInterfaceManualInput.val(typeof node.KNXEthInterfaceManuallyInput === "undefined" ? "" : node.KNXEthInterfaceManuallyInput);
+
+            $knxEthInterfaceSelect.on('change', function () {
+                const value = $knxEthInterfaceSelect.val();
+                updateEthernetManualVisibility(value);
+                if (!suppressInterfaceSelectionChange) {
+                    userLockedInterfaceSelection = !!value && value !== 'Auto';
+                }
+            });
+
+            $.getJSON('knxUltimateETHInterfaces', (data) => {
+                ethernetInterfaces = Array.isArray(data) ? data.slice() : [];
+                ethernetInterfaces.sort((a, b) => {
+                    const nameA = (a && a.name) ? String(a.name) : '';
+                    const nameB = (b && b.name) ? String(b.name) : '';
+                    return nameA.localeCompare(nameB);
+                });
+                $knxEthInterfaceSelect.find('option').filter(function () {
+                    const val = $(this).val();
+                    return val !== 'Auto' && val !== 'Manual';
+                }).remove();
+                ethernetInterfaces.forEach((iFace) => {
+                    if (!iFace || !iFace.name) return;
+                    const labelAddress = (typeof iFace.address === 'string' && iFace.address.length > 0) ? iFace.address : '';
+                    const displayText = labelAddress ? `${iFace.name} (${labelAddress})` : iFace.name;
+                    const $opt = $("<option></option>")
+                        .attr("value", iFace.name)
+                        .text(displayText);
+                    $opt.data('iface', iFace);
+                    $knxEthInterfaceSelect.append($opt);
+                });
+                const initialValue = (typeof node.KNXEthInterface === "undefined") ? "Auto" : node.KNXEthInterface;
+                userLockedInterfaceSelection = initialValue !== 'Auto';
+                setEthernetInterfaceSelection(initialValue, true);
+                if (!userLockedInterfaceSelection) {
+                    autoSelectEthernetInterfaceForHost({ force: true });
+                }
             });
 
             // Abilita manualmente la lista dei protocolli quando l'utente modifica l'IP a mano
@@ -633,6 +751,7 @@
                             if (octets && !isMulticastIPv4(octets)) enforceProtocolFromIP();
                         }
                     } catch (e) { }
+                    autoSelectEthernetInterfaceForHost();
                 });
             } catch (e) { }
 
@@ -767,7 +886,7 @@
         margin-bottom: 6px;
     }
 
-    #knxUltimate-config-template .form-row > label {
+    #knxUltimate-config-template .form-row>label {
         flex: 0 0 230px;
         display: flex;
         align-items: center;
@@ -775,9 +894,9 @@
         margin: 0;
     }
 
-    #knxUltimate-config-template .form-row > label + input,
-    #knxUltimate-config-template .form-row > label + select,
-    #knxUltimate-config-template .form-row > label + textarea {
+    #knxUltimate-config-template .form-row>label+input,
+    #knxUltimate-config-template .form-row>label+select,
+    #knxUltimate-config-template .form-row>label+textarea {
         flex: 1 1 auto;
     }
 
@@ -803,6 +922,27 @@
         margin-left: 230px;
     }
 
+    #knxUltimate-config-template .form-row.form-row-no-label {
+        display: block;
+    }
+
+    #knxUltimate-config-template i.fa.fa-shield {
+        color: #0f5d16;
+    }
+
+    #node-config-input-keyringFileXML-editor .monaco-editor .minimap,
+    #node-config-input-csv-editor .monaco-editor .minimap {
+        display: none !important;
+    }
+
+    #node-config-input-keyringFileXML-editor .ace_gutter {
+        display: none !important;
+    }
+
+    #node-config-input-keyringFileXML-editor .ace_scroller {
+        left: 0 !important;
+    }
+
     #knxUltimate-config-template .form-section-heading {
         margin-bottom: 12px;
     }
@@ -856,9 +996,9 @@
         <div id="SecureKNX" style="margin: 5px 5px 5px 5px;" >
             <p>
                 <div class="form-row">
-                    <i class="fa fa-youtube"></i>
+                    <i style="color:red" class="fa fa-youtube"></i>
                     <a href="https://youtu.be/OpR7ZQTlMRU" target="_blank">
-                        <span data-i18n="knxUltimate-config.ets.youtubeKeyring"></span>
+                    <span data-i18n="knxUltimate-config.ets.youtubeKeyring"></span>
                     </a>
                 </div>
                 <div class="form-row">
@@ -870,8 +1010,7 @@
                     </select>
                 </div>
                 <div id="secureKeyringFields">
-                <div class="form-row">
-                    <label for="node-config-input-keyringFileXML"><span data-i18n="knxUltimate-config.ets.keyring_file"></span></label>
+                <div class="form-row form-row-no-label">
                     <div id="node-config-input-keyringFileXML-editor" class="node-text-editor" style="height:200px; min-height:140px; width:100%"></div>
                     <input type="hidden" id="node-config-input-keyringFileXML" data-i18n="[placeholder]knxUltimate-config.ets.keyring" />
                 </div>
@@ -1016,9 +1155,6 @@
                     <div class="form-row">
                         <span data-i18n="knxUltimate-config.ets.description"></span>
                     </div>
-                    <div class="form-row">
-                        <span style="color:red" data-i18n="[html]knxUltimate-config.ets.instruction"></span>
-                    </div>
                     <div class="form-row">
                         <span style="color:red" data-i18n="[html]knxUltimate-config.ets.youtube"></span>
                     </div>

package/nodes/knxUltimate-config.js

@@ -6,6 +6,7 @@
 const fs = require("fs");
 const path = require("path");
 const net = require("net");
+const os = require("os");
 const _ = require("lodash");
 const knx = require("knxultimate");
 // 2025-09: Use KNXUltimate built-in keyring for KNX Secure validation
@@ -61,6 +62,128 @@ const toConcattedSubtypes = (acc, baseType) => {
 };
 // ####################
 
+const BIT_COUNT_TABLE = Array.from({ length: 256 }, (_, value) => {
+  let count = 0;
+  let temp = value;
+  while (temp) {
+    temp &= temp - 1;
+    count++;
+  }
+  return count;
+});
+
+const parseIPv4Address = (str) => {
+  if (typeof str !== "string") return null;
+  const parts = str.trim().split('.');
+  if (parts.length !== 4) return null;
+  const octets = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!/^\d+$/.test(part)) return null;
+    const value = Number(part);
+    if (!Number.isInteger(value) || value < 0 || value > 255) return null;
+    octets.push(value);
+  }
+  return octets;
+};
+
+const countNetmaskBits = (maskOctets) => {
+  if (!Array.isArray(maskOctets) || maskOctets.length !== 4) return 0;
+  let total = 0;
+  for (let i = 0; i < 4; i++) {
+    const oct = maskOctets[i];
+    if (!Number.isInteger(oct) || oct < 0 || oct > 255) return 0;
+    total += BIT_COUNT_TABLE[oct];
+  }
+  return total;
+};
+
+const computeIPv4NetworkKey = (ipOctets, maskOctets) => {
+  if (!Array.isArray(ipOctets) || ipOctets.length !== 4 || !Array.isArray(maskOctets) || maskOctets.length !== 4) return null;
+  const result = [];
+  for (let i = 0; i < 4; i++) {
+    const ipVal = ipOctets[i];
+    const maskVal = maskOctets[i];
+    if (!Number.isInteger(ipVal) || ipVal < 0 || ipVal > 255 || !Number.isInteger(maskVal) || maskVal < 0 || maskVal > 255) return null;
+    result.push(ipVal & maskVal);
+  }
+  return result.join('.');
+};
+
+const buildNetmaskOctetsFromPrefix = (prefix) => {
+  if (!Number.isInteger(prefix) || prefix < 0 || prefix > 32) return null;
+  const octets = [0, 0, 0, 0];
+  let remaining = prefix;
+  for (let i = 0; i < 4; i++) {
+    const bits = Math.max(0, Math.min(remaining, 8));
+    octets[i] = bits === 0 ? 0 : ((0xff << (8 - bits)) & 0xff);
+    remaining -= bits;
+  }
+  return octets;
+};
+
+const deriveNetmaskOctets = (iface) => {
+  if (!iface) return null;
+  const netmask = typeof iface.netmask === "string" && iface.netmask.trim() !== "" ? iface.netmask : null;
+  if (netmask) {
+    const octets = parseIPv4Address(netmask);
+    if (octets) return octets;
+  }
+  if (typeof iface.cidr === "string" && iface.cidr.includes('/')) {
+    const parts = iface.cidr.split('/');
+    if (parts.length === 2) {
+      const prefix = Number(parts[1]);
+      const octets = buildNetmaskOctetsFromPrefix(prefix);
+      if (octets) return octets;
+    }
+  }
+  return null;
+};
+
+const isMulticastIPv4 = (octets) => {
+  if (!Array.isArray(octets) || octets.length !== 4) return false;
+  const first = octets[0];
+  return first >= 224 && first <= 239;
+};
+
+const findAutoEthernetInterface = (targetIP) => {
+  const targetOctets = parseIPv4Address(targetIP);
+  if (!targetOctets || isMulticastIPv4(targetOctets)) return null;
+  const interfaces = os.networkInterfaces();
+  if (!interfaces || typeof interfaces !== "object") return null;
+
+  let bestMatch = null;
+  let bestMaskBits = -1;
+
+  Object.keys(interfaces).forEach((ifname) => {
+    const entries = Array.isArray(interfaces[ifname]) ? interfaces[ifname] : [];
+    entries.forEach((entry) => {
+      if (!entry || entry.internal) return;
+      const family = entry.family === 'IPv4' || entry.family === 4;
+      if (!family) return;
+      const ifaceOctets = parseIPv4Address(entry.address);
+      if (!ifaceOctets) return;
+      const maskOctets = deriveNetmaskOctets(entry);
+      if (!maskOctets) return;
+      const ifaceNetwork = computeIPv4NetworkKey(ifaceOctets, maskOctets);
+      const targetNetwork = computeIPv4NetworkKey(targetOctets, maskOctets);
+      if (!ifaceNetwork || !targetNetwork || ifaceNetwork !== targetNetwork) return;
+      const maskBits = countNetmaskBits(maskOctets);
+      if (maskBits > bestMaskBits) {
+        bestMaskBits = maskBits;
+        bestMatch = {
+          name: ifname,
+          address: entry.address,
+          netmask: maskOctets.join('.'),
+          maskBits,
+        };
+      }
+    });
+  });
+
+  return bestMatch;
+};
+
 
 module.exports = (RED) => {
   function knxUltimateConfigNode(config) {
@@ -220,6 +343,141 @@ module.exports = (RED) => {
               try {
                 const kr = new Keyring();
                 await kr.load(node.keyringFileXML, node.credentials.keyringFilePassword);
+                if (node.loglevel === "debug") {
+                  try {
+                    const toIAString = (value) => {
+                      if (!value) return "";
+                      return typeof value.toString === "function" ? value.toString() : String(value);
+                    };
+                    const toBufferString = (value) => {
+                      if (!value) return "";
+                      if (Buffer.isBuffer(value)) return value.toString("hex");
+                      return String(value);
+                    };
+                    const interfaceMap = kr.getInterfaces?.();
+                    const interfaces = Array.from(interfaceMap ? interfaceMap.values() : []).map((iface) => ({
+                      type: iface.type || "",
+                      individualAddress: toIAString(iface.individualAddress),
+                      host: toIAString(iface.host),
+                      userId: typeof iface.userId === "number" ? iface.userId : "",
+                      password: iface.password || "",
+                      decryptedPassword: iface.decryptedPassword || "",
+                      authentication: iface.authentication || "",
+                      decryptedAuthentication: iface.decryptedAuthentication || "",
+                      groupAddresses: Array.from(iface.groupAddresses ? iface.groupAddresses.entries() : []).map(([ga, senders]) => ({
+                        address: ga,
+                        senders: Array.isArray(senders) ? senders.map(toIAString) : [],
+                      })),
+                    }));
+                    const backbones = (kr.getBackbones?.() || []).map((backbone) => ({
+                      multicastAddress: backbone.multicastAddress || "",
+                      latency: typeof backbone.latency === "number" ? backbone.latency : "",
+                      key: backbone.key || "",
+                      decryptedKey: toBufferString(backbone.decryptedKey),
+                    }));
+                    const groupAddressMap = kr.getGroupAddresses?.();
+                    const groupAddresses = Array.from(groupAddressMap ? groupAddressMap.values() : []).map((group) => ({
+                      address: toIAString(group.address),
+                      key: group.key || "",
+                      decryptedKey: toBufferString(group.decryptedKey),
+                    }));
+                    const deviceMap = kr.getDevices?.();
+                    const devices = Array.from(deviceMap ? deviceMap.values() : []).map((device) => ({
+                      individualAddress: toIAString(device.individualAddress),
+                      toolKey: device.toolKey || "",
+                      decryptedToolKey: toBufferString(device.decryptedToolKey),
+                      managementPassword: device.managementPassword || "",
+                      decryptedManagementPassword: device.decryptedManagementPassword || "",
+                      authentication: device.authentication || "",
+                      decryptedAuthentication: device.decryptedAuthentication || "",
+                      sequenceNumber: typeof device.sequenceNumber === "number" ? device.sequenceNumber : "",
+                      serialNumber: device.serialNumber || "",
+                    }));
+                    const lines = [];
+                    lines.push("================ KNX Secure keyring debug dump ================");
+                    lines.push(`Node: ${node.name || node.id || ""}`);
+                    lines.push(`Created By: ${kr.getCreatedBy?.() || ""}`);
+                    lines.push(`Created On: ${kr.getCreated?.() || ""}`);
+                    lines.push(`Password (node credentials): ${node.credentials?.keyringFilePassword || ""}`);
+                    lines.push("");
+
+                    lines.push("Interfaces:");
+                    if (interfaces.length === 0) {
+                      lines.push("  (none)");
+                    } else {
+                      interfaces.forEach((iface, idx) => {
+                        lines.push(`  [${idx + 1}] ${iface.individualAddress || "(unknown)"} (${iface.type || ""})`);
+                        lines.push(`       Host: ${iface.host || ""}`);
+                        lines.push(`       User ID: ${iface.userId === "" ? "" : iface.userId}`);
+                        lines.push(`       Password (encoded): ${iface.password || ""}`);
+                        lines.push(`       Password (decoded): ${iface.decryptedPassword || ""}`);
+                        lines.push(`       Authentication (encoded): ${iface.authentication || ""}`);
+                        lines.push(`       Authentication (decoded): ${iface.decryptedAuthentication || ""}`);
+                        if (!iface.groupAddresses || iface.groupAddresses.length === 0) {
+                          lines.push("       Group Addresses: (none)");
+                        } else {
+                          lines.push("       Group Addresses:");
+                          iface.groupAddresses.forEach((ga) => {
+                            const senders = ga.senders && ga.senders.length > 0 ? ga.senders.join(", ") : "(none)";
+                            lines.push(`         - ${ga.address}: senders ${senders}`);
+                          });
+                        }
+                        lines.push("");
+                      });
+                    }
+
+                    lines.push("Backbones:");
+                    if (backbones.length === 0) {
+                      lines.push("  (none)");
+                    } else {
+                      backbones.forEach((backbone, idx) => {
+                        lines.push(`  [${idx + 1}] Multicast: ${backbone.multicastAddress || ""}`);
+                        lines.push(`       Latency: ${backbone.latency === "" ? "" : backbone.latency}`);
+                        lines.push(`       Key (encoded): ${backbone.key || ""}`);
+                        lines.push(`       Key (decoded hex): ${backbone.decryptedKey || ""}`);
+                        lines.push("");
+                      });
+                    }
+
+                    lines.push("Group Addresses:");
+                    if (groupAddresses.length === 0) {
+                      lines.push("  (none)");
+                    } else {
+                      groupAddresses.forEach((group, idx) => {
+                        lines.push(`  [${idx + 1}] ${group.address || ""}`);
+                        lines.push(`       Key (encoded): ${group.key || ""}`);
+                        lines.push(`       Key (decoded hex): ${group.decryptedKey || ""}`);
+                        lines.push("");
+                      });
+                    }
+
+                    lines.push("Devices:");
+                    if (devices.length === 0) {
+                      lines.push("  (none)");
+                    } else {
+                      devices.forEach((device, idx) => {
+                        lines.push(`  [${idx + 1}] ${device.individualAddress || ""}`);
+                        lines.push(`       Tool Key (encoded): ${device.toolKey || ""}`);
+                        lines.push(`       Tool Key (decoded hex): ${device.decryptedToolKey || ""}`);
+                        lines.push(`       Management Password (encoded): ${device.managementPassword || ""}`);
+                        lines.push(`       Management Password (decoded): ${device.decryptedManagementPassword || ""}`);
+                        lines.push(`       Authentication (encoded): ${device.authentication || ""}`);
+                        lines.push(`       Authentication (decoded): ${device.decryptedAuthentication || ""}`);
+                        lines.push(`       Sequence Number: ${device.sequenceNumber === "" ? "" : device.sequenceNumber}`);
+                        lines.push(`       Serial Number: ${device.serialNumber || ""}`);
+                        lines.push("");
+                      });
+                    }
+
+                    lines.push("Raw keyring (XML/base64 as provided):");
+                    lines.push(node.keyringFileXML || "(empty)");
+                    lines.push("================ End of keyring debug dump ================");
+
+                    node.sysLogger?.debug(lines.join("\n"));
+                  } catch (dumpError) {
+                    node.sysLogger?.error("KNX Secure: unable to log keyring details: " + dumpError.message);
+                  }
+                }
                 const createdBy = kr.getCreatedBy?.() || "unknown";
                 const created = kr.getCreated?.() || "unknown";
                 RED.log.info(`KNX-Secure: Keyring validated (Created by ${createdBy} on ${created}) using node ${node.name || node.id}`);
@@ -647,11 +905,30 @@ module.exports = (RED) => {
         }
         node.knxConnectionProperties.interface = sIfaceName;
       } else {
-        // 08/10/2021 Delete the interface
+        // Remove any manual binding and try to auto-select based on subnet
         try {
           delete node.knxConnectionProperties.interface;
         } catch (error) { }
-        node.sysLogger?.info("Bind KNX Bus to interface (Auto). Node " + node.name);
+        const targetIP = node.knxConnectionProperties?.ipAddr || node.host;
+        const autoInterface = typeof targetIP === "string" ? findAutoEthernetInterface(targetIP) : null;
+        if (autoInterface && autoInterface.name) {
+          node.knxConnectionProperties.interface = autoInterface.name;
+          const maskInfo = autoInterface.netmask
+            ? autoInterface.netmask + (autoInterface.maskBits ? " (" + autoInterface.maskBits + ")" : "")
+            : (autoInterface.maskBits ? String(autoInterface.maskBits) : "mask unknown");
+          node.sysLogger?.info(
+            "Bind KNX Bus to interface (Auto) -> " +
+            autoInterface.name +
+            " (" + autoInterface.address + " " + maskInfo + ")" +
+            ". Node " + node.name,
+          );
+        } else {
+          node.sysLogger?.info(
+            "Bind KNX Bus to interface (Auto). Node " +
+            node.name +
+            (targetIP ? " - no matching local interface found for " + targetIP + "." : "."),
+          );
+        }
       }
     };
     // node.setKnxConnectionProperties(); 28/12/2021 Commented

package/nodes/knxUltimate.js

@@ -121,7 +121,8 @@ module.exports = function (RED) {
     node.inputmessage = {}; // Stores the input message to be passed through
     node.timerTTLInputMessage = null; // The stored node.inputmessage has a ttl.
     try {
-      node.sysLogger = new loggerClass({ loglevel: node.serverKNX.loglevel || 'error', setPrefix: node.type + " <" + (node.name || node.id || '') + ">" });
+      const baseLogLevel = (node.serverKNX && node.serverKNX.loglevel) ? node.serverKNX.loglevel : 'error';
+      node.sysLogger = new loggerClass({ loglevel: baseLogLevel, setPrefix: node.type + " <" + (node.name || node.id || '') + ">" });
     } catch (error) { console.log(error.stack) }
     node.sendMsgToKNXCode = config.sendMsgToKNXCode || undefined;
     node.receiveMsgFromKNXCode = config.receiveMsgFromKNXCode || undefined;