penguins-eggs 10.1.0 → 25.7.7

package/dist/dhcpd-proxy/lib/sprintf.js

@@ -0,0 +1,130 @@
+/**
+ * sprintf.ts
+ *
+ * Converted to a pure, strictly-typed TypeScript module.
+ */
+export default function sprintf(format, ...args) {
+    let i = 0;
+    const regex = /%%|%(\d+\$)?([-+'#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
+    const pad = (str, len, chr, leftJustify) => {
+        const padding = str.length >= len ? "" : Array(1 + len - str.length).join(chr || ' ');
+        return leftJustify ? str + padding : padding + str;
+    };
+    const justify = (value, prefix, leftJustify, minWidth, zeroPad, customPadChar) => {
+        const diff = minWidth - value.length;
+        if (diff > 0) {
+            if (leftJustify || !zeroPad) {
+                value = pad(value, minWidth, customPadChar || ' ', leftJustify);
+            }
+            else {
+                value =
+                    value.slice(0, prefix.length) +
+                        pad("", diff, "0", true) +
+                        value.slice(prefix.length);
+            }
+        }
+        return value;
+    };
+    const formatBaseX = (value, base, prefix, leftJustify, minWidth, precision, zeroPad) => {
+        const number = value >>> 0;
+        let p = (prefix && number && { 2: "0b", 8: "0", 16: "0x" }[base]) || "";
+        let val = p + pad(number.toString(base), precision || 0, "0", false);
+        return justify(val, p, leftJustify, minWidth, zeroPad);
+    };
+    const formatString = (value, leftJustify, minWidth, precision, zeroPad, customPadChar) => {
+        if (precision !== null && precision !== undefined) {
+            value = value.slice(0, precision);
+        }
+        return justify(value, "", leftJustify, minWidth, zeroPad, customPadChar);
+    };
+    const doFormat = (substring, valueIndex, flags, minWidthStr, _, // Explicitly type the unused parameter
+    precisionStr, type) => {
+        if (substring === "%%") {
+            return "%";
+        }
+        let leftJustify = false;
+        let positivePrefix = "";
+        let zeroPad = false;
+        let prefixBaseX = false;
+        let customPadChar = " ";
+        for (let j = 0; flags && j < flags.length; j++) {
+            switch (flags.charAt(j)) {
+                case " ":
+                    positivePrefix = " ";
+                    break;
+                case "+":
+                    positivePrefix = "+";
+                    break;
+                case "-":
+                    leftJustify = true;
+                    break;
+                case "'":
+                    customPadChar = flags.charAt(j + 1);
+                    break;
+                case "0":
+                    zeroPad = true;
+                    break;
+                case "#":
+                    prefixBaseX = true;
+                    break;
+            }
+        }
+        let minWidth = minWidthStr ? +minWidthStr : 0;
+        if (minWidthStr === "*") {
+            minWidth = +args[i++];
+        }
+        else if (minWidthStr?.charAt(0) === "*") {
+            minWidth = +args[parseInt(minWidthStr.slice(1, -1)) - 1];
+        }
+        if (minWidth < 0) {
+            minWidth = -minWidth;
+            leftJustify = true;
+        }
+        if (!isFinite(minWidth)) {
+            throw new Error("sprintf: (minimum-)width must be finite");
+        }
+        let precision = precisionStr ? +precisionStr : undefined;
+        if (precisionStr === "*") {
+            precision = +args[i++];
+        }
+        else if (precisionStr?.charAt(0) === "*") {
+            precision = +args[parseInt(precisionStr.slice(1, -1)) - 1];
+        }
+        if (precision === undefined) {
+            precision = "fFeE".indexOf(type) > -1 ? 6 : type === "d" ? 0 : undefined;
+        }
+        let value = valueIndex ? args[parseInt(valueIndex.slice(0, -1)) - 1] : args[i++];
+        switch (type) {
+            case "s": return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
+            case "c": return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
+            case "b": return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case "o": return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case "x": return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case "X": return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
+            case "u": return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case "i":
+            case "d": {
+                const number = +value | 0;
+                const prefix = number < 0 ? "-" : positivePrefix;
+                const val = prefix + pad(String(Math.abs(number)), precision || 0, "0", false);
+                return justify(val, prefix, leftJustify, minWidth, zeroPad);
+            }
+            case "e":
+            case "E":
+            case "f":
+            case "F":
+            case "g":
+            case "G": {
+                const number = +value;
+                const prefix = number < 0 ? "-" : positivePrefix;
+                const method = ["toExponential", "toFixed", "toPrecision"]["efg".indexOf(type.toLowerCase())];
+                const textTransform = ["toString", "toUpperCase"]["eEfFgG".indexOf(type) % 2];
+                const val = prefix + Math.abs(number)[method](precision);
+                return justify(val, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
+            }
+            default:
+                return substring;
+        }
+    };
+    return format.replace(regex, doFormat);
+}

package/dist/dhcpd-proxy/lib/utils.d.ts

@@ -0,0 +1,126 @@
+/**
+ * util.ts
+ *
+ * used in dhcpd
+ *
+ */
+/**
+ *
+ * @param _buffer
+ * @param byteArray
+ * @param offset
+ * @returns
+ */
+export declare const writeBytes: (_buffer: any, byteArray: any, offset: number) => undefined;
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export declare function writeInt32(_buffer: any, integer: number, offset: number): number;
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export declare function writeInt16(_buffer: any, integer: number, offset: number): number;
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export declare function writeInt8(_buffer: any, integer: number, offset: number): number;
+/**
+ *
+ * @param _buffer
+ * @param length
+ * @param copy
+ * @param offset
+ * @returns
+ */
+export declare function readBytes(_buffer: any, length: number, copy: any, offset: number): any;
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export declare function readInt32(_buffer: any, offset: number): number;
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export declare function readInt16(_buffer: any, offset: number): number;
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export declare function readInt8(_buffer: any, offset: number): any;
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export declare function readString(buf: any): string;
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export declare function readHex(buf: any): string;
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export declare function readHexAddress(buf: any): string;
+/**
+ *
+ * @param buffer
+ * @param offset
+ * @returns
+ */
+export declare function readIp(buffer: any, offset: number): string | undefined;
+/**
+ *
+ * @param buffer
+ * @returns
+ */
+export declare function readMacAddress(buffer: any): string;
+/**
+ *
+ * @param buf
+ * @param num
+ * @param offsetHours
+ * @param offset
+ * @returns
+ */
+export declare function writeTimeOffset(buf: any, num: any, offsetHours: any, offset: number): number;
+/**
+ *
+ * @param buf
+ * @param num
+ * @param ip
+ * @param offset
+ * @returns
+ */
+export declare function writeIp(buf: any, num: string, ip: any, offset: number): number;
+/**
+ *
+ * @param buf
+ * @param num
+ * @param hostname
+ * @param offset
+ * @returns
+ */
+export declare function writeString(buf: any, num: string, hostname: string, offset: number): number;

package/dist/dhcpd-proxy/lib/utils.js

@@ -0,0 +1,255 @@
+/**
+ * util.ts
+ *
+ * used in dhcpd
+ *
+ */
+import sprintf from "./sprintf.js";
+/**
+ *
+ * @param _buffer
+ * @param byteArray
+ * @param offset
+ * @returns
+ */
+export const writeBytes = (_buffer, byteArray, offset) => {
+    let _bytesWritten = 0;
+    let i = 0;
+    while (i < byteArray.length) {
+        _buffer[offset++] = byteArray[i];
+        i++;
+    }
+    if (offset > _bytesWritten) {
+        _bytesWritten = offset;
+    }
+    return this;
+};
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt32(_buffer, integer, offset) {
+    _buffer[offset++] = integer >>> 24;
+    _buffer[offset++] = integer >>> 16;
+    _buffer[offset++] = integer >>> 8;
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt16(_buffer, integer, offset) {
+    _buffer[offset++] = integer >>> 8;
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt8(_buffer, integer, offset) {
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param length
+ * @param copy
+ * @param offset
+ * @returns
+ */
+export function readBytes(_buffer, length, copy, offset) {
+    let bufCopy;
+    if (copy) {
+        bufCopy = new Buffer(length);
+        _buffer.copy(bufCopy, 0, offset, (offset += length));
+        return bufCopy;
+    }
+    else {
+        return _buffer.slice(offset, (offset += length));
+    }
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt32(_buffer, offset) {
+    return ((_buffer[offset++] << 24) |
+        (_buffer[offset++] << 16) |
+        (_buffer[offset++] << 8) |
+        _buffer[offset++]);
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt16(_buffer, offset) {
+    return (_buffer[offset++] << 8) | _buffer[offset++];
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt8(_buffer, offset) {
+    return _buffer[offset++];
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readString(buf) {
+    let j, s;
+    s = "";
+    j = 0;
+    while (j < buf.length) {
+        s += String.fromCharCode(buf[j]);
+        j++;
+    }
+    return s;
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readHex(buf) {
+    let j, s;
+    s = "";
+    j = 0;
+    while (j < buf.length) {
+        // check was b not buf
+        s += sprintf("%02x", buf[j]);
+        j++;
+    }
+    return s;
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readHexAddress(buf) {
+    let j, s;
+    s = [];
+    j = 0;
+    while (j < buf.length) {
+        s.push(sprintf("%02d", buf[j]));
+        j++;
+    }
+    return s.join(":");
+}
+/**
+ *
+ * @param buffer
+ * @param offset
+ * @returns
+ */
+export function readIp(buffer, offset) {
+    let stop;
+    if (offset === null) {
+        offset = 0;
+    }
+    if (offset > buffer.length) {
+        return undefined;
+    }
+    if (0 === buffer.readUInt8(offset)) {
+        return undefined;
+    }
+    else {
+        stop = offset + 4;
+        return (function () {
+            const _results = [];
+            while (offset < stop) {
+                _results.push(buffer.readUInt8(offset++));
+            }
+            return _results;
+        })().join(".");
+    }
+}
+/**
+ *
+ * @param buffer
+ * @returns
+ */
+export function readMacAddress(buffer) {
+    let byte;
+    return (function () {
+        let _i, _len;
+        const _results = [];
+        for (_i = 0, _len = buffer.length; _i < _len; _i++) {
+            byte = buffer[_i];
+            _results.push((byte + 0x100).toString(16).substr(-2));
+        }
+        return _results;
+    })().join(":");
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param offsetHours
+ * @param offset
+ * @returns
+ */
+export function writeTimeOffset(buf, num, offsetHours, offset) {
+    buf[offset++] = 0;
+    return offset;
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param ip
+ * @param offset
+ * @returns
+ */
+export function writeIp(buf, num, ip, offset) {
+    buf[offset++] = num;
+    buf[offset++] = 4;
+    if ((typeof ip !== "string" && !(ip instanceof String)) ||
+        ip.indexOf(".") === -1) {
+        ip = "0.0.0.0";
+    }
+    ip.split(".").forEach(function (item) {
+        buf[offset++] = item;
+    });
+    return offset;
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param hostname
+ * @param offset
+ * @returns
+ */
+export function writeString(buf, num, hostname, offset) {
+    let charArr;
+    charArr = hostname.split("");
+    buf[offset++] = num;
+    buf[offset++] = charArr.length;
+    charArr.forEach(function (chr) {
+        // charCodeAt(index: number): number
+        //buf[offset++] = chr.charCodeAt() original
+        buf[offset++] = chr.charCodeAt(0);
+    });
+    return offset;
+}

package/dist/dhcpd-proxy/simple-proxy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * simple-proxy.ts
+ * Un proxy DHCP minimale che agisce come un mini-server DHCP completo
+ * solo per i client PXE, per aggirare le protezioni di rete.
+ */
+import type { IDhcpOptions } from '../dhcpd-proxy//interfaces/i-pxe.js';
+/**
+ * La nostra unica funzione. Prende le opzioni e avvia il proxy.
+ * @param options Le opzioni di configurazione PXE
+ */
+export declare function startSimpleProxy(options: IDhcpOptions): void;

package/dist/dhcpd-proxy/simple-proxy.js

@@ -0,0 +1,118 @@
+/**
+ * simple-proxy.ts
+ * Un proxy DHCP minimale che agisce come un mini-server DHCP completo
+ * solo per i client PXE, per aggirare le protezioni di rete.
+ */
+import { createSocket } from 'dgram';
+import ansis from 'ansis';
+import { Packet } from '../dhcpd-proxy/classes/packet.js';
+import { DhcpMessageType } from '../dhcpd-proxy//lib/packet/message-types.js';
+// Un semplice Map in memoria per tracciare gli IP offerti
+const offeredIPs = new Map();
+/**
+ * La nostra unica funzione. Prende le opzioni e avvia il proxy.
+ * @param options Le opzioni di configurazione PXE
+ */
+export function startSimpleProxy(options) {
+    const socket = createSocket({ type: 'udp4', reuseAddr: true });
+    socket.on('error', (err) => {
+        console.error(ansis.red.bold(`ERRORE SOCKET: ${err.stack}`));
+        socket.close();
+    });
+    socket.on('listening', () => {
+        const address = socket.address();
+        socket.setBroadcast(true);
+        console.log(ansis.green.inverse(`\n Proxy DHCP listening su ${address.address}:${address.port}. CTRL-C to end!\n`));
+    });
+    socket.on('message', (buffer, rinfo) => {
+        try {
+            const packet = Packet.fromBuffer(buffer);
+            packet.remote = rinfo;
+            const messageType = packet.options[53] || 0;
+            if (packet.op === 1 && messageType === DhcpMessageType.DHCPDISCOVER) {
+                handleDiscover(packet, options);
+            }
+            else if (packet.op === 1 && messageType === DhcpMessageType.DHCPREQUEST) {
+                handleRequest(packet, options);
+            }
+        }
+        catch (err) {
+            // Ignoriamo errori di parsing
+        }
+    });
+    socket.bind(67, '0.0.0.0');
+    // --- Funzioni Helper Interne ---
+    function setBootFilename(packet, opts) {
+        const isIpxe = packet.options[77] && packet.options[77].toString().includes('iPXE');
+        const arch = packet.options[93] || packet.options[60];
+        const isUefi64 = arch && (String(arch).includes('00007') || String(arch).includes('00009'));
+        // LOGICA DI ASSEGNAZIONE PRECISA
+        if (isIpxe && isUefi64) {
+            // CASO 1: Il client è iPXE e anche UEFI. Offriamo lo script!
+            console.log(ansis.magenta.bold(`<- Rilevato client iPXE su UEFI! Offro script autoexec...`));
+            return `http://${opts.host}/autoexec.ipxe`;
+        }
+        else if (isUefi64) {
+            // CASO 2: Il client è UEFI ma non è ancora iPXE. Offriamo il bootloader iPXE per UEFI.
+            return opts.efi64_filename;
+        }
+        else {
+            // CASO 3: Il client è BIOS. Offriamo il bootloader iPXE per BIOS.
+            // (Aggiunta logica per altri tipi di architettura se necessario)
+            return opts.bios_filename;
+        }
+    }
+    function handleDiscover(packet, opts) {
+        console.log(ansis.blue.bold(`\n-> DISCOVER Ricevuto`));
+        console.log(ansis.dim(`   └─ Da MAC: ${ansis.white(packet.chaddr)}`));
+        if (packet.options[60]?.includes('PXEClient')) {
+            console.log(ansis.cyan.bold(`<- Rilevato PXEClient! Preparo un'offerta completa...`));
+            const offerPacket = new Packet(packet);
+            offerPacket.op = 2; // BOOTREPLY
+            const ipParts = opts.host.split('.');
+            ipParts[3] = (parseInt(ipParts[3]) + 10).toString();
+            const offeredIp = ipParts.join('.');
+            offeredIPs.set(packet.chaddr, offeredIp);
+            offerPacket.yiaddr = offeredIp;
+            offerPacket.siaddr = opts.tftpserver;
+            offerPacket.options[53] = DhcpMessageType.DHCPOFFER;
+            offerPacket.options[54] = opts.host;
+            // Imposta il filename usando la nuova funzione logica
+            offerPacket.fname = setBootFilename(packet, opts);
+            console.log(ansis.dim(`   ├─ Offro IP: ${ansis.green(offeredIp)}`));
+            console.log(ansis.dim(`   ├─ Next-Server: ${ansis.white(offerPacket.siaddr)}`));
+            console.log(ansis.dim(`   └─ Filename: ${ansis.white(offerPacket.fname)}`));
+            send(offerPacket, opts.broadcast, 68);
+        }
+    }
+    function handleRequest(packet, opts) {
+        const offeredIp = offeredIPs.get(packet.chaddr);
+        if (!offeredIp || (packet.options[50] && packet.options[50] !== offeredIp)) {
+            return;
+        }
+        console.log(ansis.yellow.bold(`-> REQUEST per la nostra offerta ricevuto!`));
+        console.log(ansis.dim(`   └─ Da MAC: ${ansis.white(packet.chaddr)}`));
+        const ackPacket = new Packet(packet);
+        ackPacket.op = 2;
+        ackPacket.yiaddr = offeredIp;
+        ackPacket.siaddr = opts.tftpserver;
+        ackPacket.options[53] = DhcpMessageType.DHCPACK;
+        ackPacket.options[54] = opts.host;
+        // Imposta il filename usando la stessa logica
+        ackPacket.fname = setBootFilename(packet, opts);
+        console.log(ansis.cyan.bold(`<- Invio ACK finale...`));
+        send(ackPacket, opts.broadcast, 68);
+    }
+    function send(packet, ip, port) {
+        const buffer = packet.toBuffer();
+        const typeName = DhcpMessageType[packet.options[53]] || 'UNKNOWN';
+        socket.send(buffer, 0, buffer.length, port, ip, (err, bytes) => {
+            if (err) {
+                console.error(ansis.red.bold(`[PROXY-ERROR] Errore invio ${typeName}:`), err);
+            }
+            else {
+                console.log(ansis.green(`   ✔︎ ${typeName} inviata a ${ip}:${port} (${bytes} bytes)`));
+            }
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ./src/index.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * ./src/index.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export { run } from '@oclif/core';

package/dist/interfaces/i-addons.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ./src/interfaces/i-addons.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export interface IAddons {
+    adapt: boolean;
+    pve: boolean;
+    rsupport: boolean;
+}

package/dist/interfaces/i-addons.js

@@ -0,0 +1,8 @@
+/**
+ * ./src/interfaces/i-addons.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export {};

package/dist/interfaces/i-analyze.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ./src/interfaces/i-analyze.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class IAnalyze {
+    gecos: string;
+    gid: string;
+    home: string;
+    login: string;
+    password: string;
+    shell: string;
+    size: number;
+    uid: string;
+}