@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scripts/tgz-integrity.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const zlib = require("zlib");
+const { MANIFEST_PATH, canonicalJson, manifestPayload } = require("../lib/licensing/package-integrity");
+const { decodePrivateKey } = require("./package-integrity");
+
+function readText(buffer, offset, length) { return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0.*$/, "").trim(); }
+function readOctal(buffer, offset, length) { const value = readText(buffer, offset, length).replace(/\s/g, ""); return value ? Number.parseInt(value, 8) : 0; }
+
+function readTarEntries(tgz) {
+    const tar = zlib.gunzipSync(tgz);
+    const entries = [];
+    for (let offset = 0; offset + 512 <= tar.length;) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every(function (byte) { return byte === 0; })) break;
+        const name = readText(header, 0, 100);
+        const prefix = readText(header, 345, 155);
+        const fullName = prefix ? prefix + "/" + name : name;
+        const size = readOctal(header, 124, 12);
+        const type = readText(header, 156, 1) || "0";
+        const contentStart = offset + 512;
+        const contentEnd = contentStart + size;
+        if (contentEnd > tar.length) throw new Error("truncated tar entry: " + fullName);
+        if (!["x", "g", "L", "K"].includes(type)) entries.push({ name: fullName.replace(/^\.\//, ""), type, mode: readOctal(header, 100, 8), mtime: readOctal(header, 136, 12), data: Buffer.from(tar.subarray(contentStart, contentEnd)) });
+        offset = contentStart + Math.ceil(size / 512) * 512;
+    }
+    return entries;
+}
+
+function writeText(buffer, offset, length, value) { buffer.write(String(value).slice(0, length), offset, length, "utf8"); }
+function writeOctal(buffer, offset, length, value) { writeText(buffer, offset, length, Math.max(0, value).toString(8).padStart(length - 1, "0") + "\0"); }
+function tarHeader(entry) {
+    const header = Buffer.alloc(512);
+    const lastSlash = entry.name.lastIndexOf("/");
+    const usePrefix = Buffer.byteLength(entry.name) > 100 && lastSlash > 0;
+    const name = usePrefix ? entry.name.slice(lastSlash + 1) : entry.name;
+    const prefix = usePrefix ? entry.name.slice(0, lastSlash) : "";
+    if (Buffer.byteLength(name) > 100 || Buffer.byteLength(prefix) > 155) throw new Error("tar path too long: " + entry.name);
+    writeText(header, 0, 100, name); writeOctal(header, 100, 8, entry.mode || 0o644); writeOctal(header, 108, 8, 0); writeOctal(header, 116, 8, 0);
+    writeOctal(header, 124, 12, entry.data.length); writeOctal(header, 136, 12, entry.mtime || 0); header.fill(0x20, 148, 156);
+    writeText(header, 156, 1, entry.type || "0"); writeText(header, 257, 6, "ustar\0"); writeText(header, 263, 2, "00"); writeText(header, 265, 32, "root"); writeText(header, 297, 32, "root"); writeText(header, 345, 155, prefix);
+    const checksum = header.reduce(function (sum, byte) { return sum + byte; }, 0); writeText(header, 148, 8, checksum.toString(8).padStart(6, "0") + "\0 ");
+    return header;
+}
+function writeTar(entries) {
+    const parts = [];
+    entries.forEach(function (entry) { parts.push(tarHeader(entry), entry.data); const padding = (512 - (entry.data.length % 512)) % 512; if (padding) parts.push(Buffer.alloc(padding)); });
+    parts.push(Buffer.alloc(1024)); return Buffer.concat(parts);
+}
+
+function protectedEntry(entry) {
+    if (!entry.name.startsWith("package/") || entry.name === "package/" + MANIFEST_PATH) return false;
+    const relative = entry.name.slice("package/".length);
+    return relative === "package.json" || relative === "lib/licensing/public-key.pem" || /\.(?:js|html)$/.test(relative);
+}
+
+function signTgzIntegrity(archivePath, privateKeyValue, keyId) {
+    const entries = readTarEntries(fs.readFileSync(archivePath)).filter(function (entry) { return entry.name !== "package/" + MANIFEST_PATH; });
+    const packageEntry = entries.find(function (entry) { return entry.name === "package/package.json"; });
+    if (!packageEntry) throw new Error("archive has no package/package.json: " + archivePath);
+    const packageJson = JSON.parse(packageEntry.data.toString("utf8"));
+    const files = entries.filter(protectedEntry).map(function (entry) {
+        return { path: entry.name.slice("package/".length), sha256: crypto.createHash("sha256").update(entry.data).digest("hex"), size: entry.data.length };
+    }).sort(function (a, b) { return a.path.localeCompare(b.path); });
+    const manifest = { algorithm: "sha256", files, keyId: keyId || "v1", package: { name: String(packageJson.name || ""), version: String(packageJson.version || "") }, schemaVersion: 1, signatureAlgorithm: "Ed25519" };
+    const signature = crypto.sign(null, Buffer.from(canonicalJson(manifestPayload(manifest))), decodePrivateKey(privateKeyValue)).toString("base64url");
+    entries.push({ name: "package/" + MANIFEST_PATH, type: "0", mode: 0o644, mtime: 0, data: Buffer.from(JSON.stringify(Object.assign({}, manifest, { signature }), null, 2) + "\n") });
+    fs.writeFileSync(archivePath, zlib.gzipSync(writeTar(entries), { level: 9 }));
+    return manifest;
+}
+
+module.exports = { readTarEntries, signTgzIntegrity, writeTar };

package/sma-read/lib/sunspec-core.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const MAX_READ_REGISTERS = 120;
+const MAX_MODELS = 256;
+const BASE_CANDIDATES = [39999, 40000, 40001, 40002, 40199, 40200, 40201, 40202];
+
+async function readHolding(client, addr, len) {
+    const start = Number(addr);
+    const count = Number(len);
+    if (!Number.isInteger(start) || start < 0 || start > 0xffff) {
+        throw new Error("Invalid Modbus start address: " + addr);
+    }
+    if (!Number.isInteger(count) || count < 1 || start + count > 0x10000) {
+        throw new Error("Invalid Modbus register count: " + len);
+    }
+    const data = [];
+    for (let offset = 0; offset < count;) {
+        const size = Math.min(MAX_READ_REGISTERS, count - offset);
+        const response = await client.readHoldingRegisters(start + offset, size);
+        if (!response || !Array.isArray(response.data) || response.data.length !== size) {
+            throw new Error("Incomplete Modbus response at register " + (start + offset));
+        }
+        data.push.apply(data, response.data);
+        offset += size;
+    }
+    return { data: data };
+}
+
+async function findBase(client) {
+    for (const base of BASE_CANDIDATES) {
+        try {
+            const response = await readHolding(client, base, 2);
+            const text = response.data.map(function (word) {
+                return String.fromCharCode((word >> 8) & 0xff) + String.fromCharCode(word & 0xff);
+            }).join("");
+            if (text === "SunS") return base;
+        } catch (error) {
+            // Continue with the next standard offset candidate.
+        }
+    }
+    throw new Error("SunSpec not found");
+}
+
+async function scanModelDescriptors(client, base) {
+    const descriptors = [];
+    let addr = base + 2;
+    while (true) {
+        if (descriptors.length >= MAX_MODELS || addr < 0 || addr > 0xfffd) {
+            throw new Error("Invalid or unterminated SunSpec model table");
+        }
+        const header = await readHolding(client, addr, 2);
+        const modelId = header.data[0];
+        const len = header.data[1];
+        if (modelId === 0xffff) break;
+        if (!Number.isInteger(len) || len < 1 || addr + 2 + len > 0x10000) {
+            throw new Error("Invalid SunSpec model length " + len + " for model " + modelId);
+        }
+        descriptors.push({ model_id: modelId, addr: addr, len: len });
+        addr += 2 + len;
+    }
+    return descriptors;
+}
+
+async function readModelsByDescriptors(client, descriptors) {
+    const models = [];
+    for (const descriptor of descriptors) {
+        const response = await readHolding(client, descriptor.addr + 2, descriptor.len);
+        models.push({
+            model_id: descriptor.model_id,
+            addr: descriptor.addr,
+            len: descriptor.len,
+            raw: response.data
+        });
+    }
+    return models;
+}
+
+module.exports = {
+    readHolding,
+    findBase,
+    scanModelDescriptors,
+    readModelsByDescriptors
+};