main funcions fixes

desktop-operator/node_modules/pe-library/dist/util/functions.d.ts

@@ -0,0 +1,13 @@
+/// <reference lib="dom" />
+export declare function cloneObject<T extends object>(object: Readonly<T>): T;
+export declare function cloneObject<T extends object>(object: T): T;
+export declare function createDataView(bin: ArrayBuffer | ArrayBufferView, byteOffset?: number, byteLength?: number): DataView;
+export declare function calculateCheckSumForPE(bin: ArrayBuffer, storeToBinary?: boolean): number;
+export declare function roundUp(val: number, align: number): number;
+export declare function copyBuffer(dest: ArrayBuffer | ArrayBufferView, destOffset: number, src: ArrayBuffer | ArrayBufferView, srcOffset: number, length: number): void;
+export declare function allocatePartialBinary(binBase: ArrayBuffer | ArrayBufferView, offset: number, length: number): ArrayBuffer;
+export declare function cloneToArrayBuffer(binBase: ArrayBuffer | ArrayBufferView): ArrayBuffer;
+export declare function getFixedString(view: DataView, offset: number, length: number): string;
+export declare function setFixedString(view: DataView, offset: number, length: number, text: string): void;
+export declare function binaryToString(bin: ArrayBuffer | ArrayBufferView): string;
+export declare function stringToBinary(string: string): ArrayBuffer;

desktop-operator/node_modules/pe-library/dist/util/functions.js

@@ -0,0 +1,273 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference lib='dom' />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToBinary = exports.binaryToString = exports.setFixedString = exports.getFixedString = exports.cloneToArrayBuffer = exports.allocatePartialBinary = exports.copyBuffer = exports.roundUp = exports.calculateCheckSumForPE = exports.createDataView = exports.cloneObject = void 0;
+var ImageDosHeader_js_1 = require("../format/ImageDosHeader.js");
+function cloneObject(object) {
+    var r = {};
+    Object.keys(object).forEach(function (key) {
+        r[key] = object[key];
+    });
+    return r;
+}
+exports.cloneObject = cloneObject;
+/* eslint-enable @typescript-eslint/ban-types */
+function createDataView(bin, byteOffset, byteLength) {
+    if ('buffer' in bin) {
+        var newOffset = bin.byteOffset;
+        var newLength = bin.byteLength;
+        if (typeof byteOffset !== 'undefined') {
+            newOffset += byteOffset;
+            newLength -= byteOffset;
+        }
+        if (typeof byteLength !== 'undefined') {
+            newLength = byteLength;
+        }
+        return new DataView(bin.buffer, newOffset, newLength);
+    }
+    else {
+        return new DataView(bin, byteOffset, byteLength);
+    }
+}
+exports.createDataView = createDataView;
+function calculateCheckSumForPE(bin, storeToBinary) {
+    var dosHeader = ImageDosHeader_js_1.default.from(bin);
+    var view = new DataView(bin);
+    var checkSumOffset = dosHeader.newHeaderAddress + 88;
+    var result = 0;
+    var limit = 0x100000000; // 2^32
+    var update = function (dword) {
+        result += dword;
+        if (result >= limit) {
+            result = (result % limit) + ((result / limit) | 0);
+        }
+    };
+    var len = view.byteLength;
+    var lenExtra = len % 4;
+    var lenAlign = len - lenExtra;
+    for (var i = 0; i < lenAlign; i += 4) {
+        if (i !== checkSumOffset) {
+            update(view.getUint32(i, true));
+        }
+    }
+    if (lenExtra !== 0) {
+        var extra = 0;
+        for (var i = 0; i < lenExtra; i++) {
+            extra |= view.getUint8(lenAlign + i) << ((3 - i) * 8);
+        }
+        update(extra);
+    }
+    result = (result & 0xffff) + (result >>> 16);
+    result += result >>> 16;
+    result = (result & 0xffff) + len;
+    if (storeToBinary) {
+        view.setUint32(checkSumOffset, result, true);
+    }
+    return result;
+}
+exports.calculateCheckSumForPE = calculateCheckSumForPE;
+function roundUp(val, align) {
+    return Math.floor((val + align - 1) / align) * align;
+}
+exports.roundUp = roundUp;
+function copyBuffer(dest, destOffset, src, srcOffset, length) {
+    var ua8Dest = 'buffer' in dest
+        ? new Uint8Array(dest.buffer, dest.byteOffset + (destOffset || 0), length)
+        : new Uint8Array(dest, destOffset, length);
+    var ua8Src = 'buffer' in src
+        ? new Uint8Array(src.buffer, src.byteOffset + (srcOffset || 0), length)
+        : new Uint8Array(src, srcOffset, length);
+    ua8Dest.set(ua8Src);
+}
+exports.copyBuffer = copyBuffer;
+function allocatePartialBinary(binBase, offset, length) {
+    var b = new ArrayBuffer(length);
+    copyBuffer(b, 0, binBase, offset, length);
+    return b;
+}
+exports.allocatePartialBinary = allocatePartialBinary;
+function cloneToArrayBuffer(binBase) {
+    if ('buffer' in binBase) {
+        var b = new ArrayBuffer(binBase.byteLength);
+        new Uint8Array(b).set(new Uint8Array(binBase.buffer, binBase.byteOffset, binBase.byteLength));
+        return b;
+    }
+    else {
+        var b = new ArrayBuffer(binBase.byteLength);
+        new Uint8Array(b).set(new Uint8Array(binBase));
+        return b;
+    }
+}
+exports.cloneToArrayBuffer = cloneToArrayBuffer;
+function getFixedString(view, offset, length) {
+    var actualLen = 0;
+    for (var i = 0; i < length; ++i) {
+        if (view.getUint8(offset + i) === 0) {
+            break;
+        }
+        ++actualLen;
+    }
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(view.buffer, view.byteOffset + offset, actualLen).toString('utf8');
+    }
+    else if (typeof decodeURIComponent !== 'undefined') {
+        var s = '';
+        for (var i = 0; i < actualLen; ++i) {
+            var c = view.getUint8(offset + i);
+            if (c < 16) {
+                s += '%0' + c.toString(16);
+            }
+            else {
+                s += '%' + c.toString(16);
+            }
+        }
+        return decodeURIComponent(s);
+    }
+    else {
+        var s = '';
+        for (var i = 0; i < actualLen; ++i) {
+            var c = view.getUint8(offset + i);
+            s += String.fromCharCode(c);
+        }
+        return s;
+    }
+}
+exports.getFixedString = getFixedString;
+function setFixedString(view, offset, length, text) {
+    if (typeof Buffer !== 'undefined') {
+        var u = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+        // fill by zero
+        u.set(new Uint8Array(length));
+        u.set(Buffer.from(text, 'utf8').subarray(0, length));
+    }
+    else if (typeof encodeURIComponent !== 'undefined') {
+        var s = encodeURIComponent(text);
+        for (var i = 0, j = 0; i < length; ++i) {
+            if (j >= s.length) {
+                view.setUint8(i + offset, 0);
+            }
+            else {
+                var c = s.charCodeAt(j);
+                if (c === 37) {
+                    // '%'
+                    var n = parseInt(s.substr(j + 1, 2), 16);
+                    if (typeof n === 'number' && !isNaN(n)) {
+                        view.setUint8(i + offset, n);
+                    }
+                    else {
+                        view.setUint8(i + offset, 0);
+                    }
+                    j += 3;
+                }
+                else {
+                    view.setUint8(i + offset, c);
+                }
+            }
+        }
+    }
+    else {
+        for (var i = 0, j = 0; i < length; ++i) {
+            if (j >= text.length) {
+                view.setUint8(i + offset, 0);
+            }
+            else {
+                var c = text.charCodeAt(j);
+                view.setUint8(i + offset, c & 0xff);
+            }
+        }
+    }
+}
+exports.setFixedString = setFixedString;
+function binaryToString(bin) {
+    if (typeof TextDecoder !== 'undefined') {
+        var dec = new TextDecoder();
+        return dec.decode(bin);
+    }
+    else if (typeof Buffer !== 'undefined') {
+        var b = void 0;
+        if ('buffer' in bin) {
+            b = Buffer.from(bin.buffer, bin.byteOffset, bin.byteLength);
+        }
+        else {
+            b = Buffer.from(bin);
+        }
+        return b.toString('utf8');
+    }
+    else {
+        var view = void 0;
+        if ('buffer' in bin) {
+            view = new Uint8Array(bin.buffer, bin.byteOffset, bin.byteLength);
+        }
+        else {
+            view = new Uint8Array(bin);
+        }
+        if (typeof decodeURIComponent !== 'undefined') {
+            var s = '';
+            for (var i = 0; i < view.length; ++i) {
+                var c = view[i];
+                if (c < 16) {
+                    s += '%0' + c.toString(16);
+                }
+                else {
+                    s += '%' + c.toString(16);
+                }
+            }
+            return decodeURIComponent(s);
+        }
+        else {
+            var s = '';
+            for (var i = 0; i < view.length; ++i) {
+                var c = view[i];
+                s += String.fromCharCode(c);
+            }
+            return s;
+        }
+    }
+}
+exports.binaryToString = binaryToString;
+function stringToBinary(string) {
+    if (typeof TextEncoder !== 'undefined') {
+        var enc = new TextEncoder();
+        return cloneToArrayBuffer(enc.encode(string));
+    }
+    else if (typeof Buffer !== 'undefined') {
+        return cloneToArrayBuffer(Buffer.from(string, 'utf8'));
+    }
+    else if (typeof encodeURIComponent !== 'undefined') {
+        var data = encodeURIComponent(string);
+        var len = 0;
+        for (var i = 0; i < data.length; ++len) {
+            var c = data.charCodeAt(i);
+            if (c === 37) {
+                i += 3;
+            }
+            else {
+                ++i;
+            }
+        }
+        var bin = new ArrayBuffer(len);
+        var view = new Uint8Array(bin);
+        for (var i = 0, j = 0; i < data.length; ++j) {
+            var c = data.charCodeAt(i);
+            if (c === 37) {
+                var n = parseInt(data.substring(i + 1, i + 3), 16);
+                view[j] = n;
+                i += 3;
+            }
+            else {
+                view[j] = c;
+                ++i;
+            }
+        }
+        return bin;
+    }
+    else {
+        var bin = new ArrayBuffer(string.length);
+        new Uint8Array(bin).set([].map.call(string, function (c) {
+            return c.charCodeAt(0);
+        }));
+        return bin;
+    }
+}
+exports.stringToBinary = stringToBinary;

desktop-operator/node_modules/pe-library/dist/util/generate.d.ts

@@ -0,0 +1,5 @@
+export declare function getDosStubDataSize(): number;
+export declare function fillDosStubData(bin: ArrayBuffer | ArrayBufferView): void;
+export declare function estimateNewHeaderSize(is32Bit: boolean): number;
+export declare function fillPeHeaderEmptyData(bin: ArrayBuffer | ArrayBufferView, offset: number, totalBinSize: number, is32Bit: boolean, isDLL: boolean): void;
+export declare function makeEmptyNtExecutableBinary(is32Bit: boolean, isDLL: boolean): ArrayBuffer;

desktop-operator/node_modules/pe-library/dist/util/generate.js

@@ -0,0 +1,127 @@
+"use strict";
+// To make the binary (DOS_STUB_PROGRAM):
+// $ cd tools/dos-stub
+// $ nasm -f bin -o dos-stub.bin dos-stub.asm
+// $ node -e "console.log([].map.call(fs.readFileSync('tools/dos-stub/dos-stub.bin'), (v)=>`0x${Buffer.from([v]).toString('hex')}`).join(','))"
+//
+// NOTE: the original dos-stub.asm program and the bit code in DOS_STUB_PROGRAM are under the 0-BSD license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmptyNtExecutableBinary = exports.fillPeHeaderEmptyData = exports.estimateNewHeaderSize = exports.fillDosStubData = exports.getDosStubDataSize = void 0;
+var ImageDataDirectoryArray_js_1 = require("../format/ImageDataDirectoryArray.js");
+var ImageDosHeader_js_1 = require("../format/ImageDosHeader.js");
+var ImageFileHeader_js_1 = require("../format/ImageFileHeader.js");
+var ImageNtHeaders_js_1 = require("../format/ImageNtHeaders.js");
+var ImageOptionalHeader_js_1 = require("../format/ImageOptionalHeader.js");
+var ImageOptionalHeader64_js_1 = require("../format/ImageOptionalHeader64.js");
+var functions_js_1 = require("./functions.js");
+// fill with '0x00' to make 8-bytes alignment
+// prettier-ignore
+var DOS_STUB_PROGRAM = new Uint8Array([
+    0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x44, 0x4f,
+    0x53, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f,
+    0x72, 0x74, 0x65, 0x64, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+var DOS_STUB_SIZE = functions_js_1.roundUp(ImageDosHeader_js_1.default.size + DOS_STUB_PROGRAM.length, 0x80);
+var DEFAULT_FILE_ALIGNMENT = 512;
+function getDosStubDataSize() {
+    return DOS_STUB_SIZE;
+}
+exports.getDosStubDataSize = getDosStubDataSize;
+function fillDosStubData(bin) {
+    var dos = ImageDosHeader_js_1.default.from(bin);
+    dos.magic = ImageDosHeader_js_1.default.DEFAULT_MAGIC;
+    // last page size
+    dos.lastPageSize = DOS_STUB_SIZE % 512;
+    // total page count
+    dos.pages = Math.ceil(DOS_STUB_SIZE / 512);
+    // no relocations
+    dos.relocations = 0;
+    // header size as paragraph count (1 paragraph = 16 bytes)
+    dos.headerSizeInParagraph = Math.ceil(ImageDosHeader_js_1.default.size / 16);
+    dos.minAllocParagraphs = 0;
+    dos.maxAllocParagraphs = 0xffff;
+    dos.initialSS = 0;
+    dos.initialSP = 0x80;
+    // (no relocations, but set offset after the header)
+    dos.relocationTableAddress = ImageDosHeader_js_1.default.size;
+    dos.newHeaderAddress = DOS_STUB_SIZE;
+    functions_js_1.copyBuffer(bin, ImageDosHeader_js_1.default.size, DOS_STUB_PROGRAM, 0, DOS_STUB_PROGRAM.length);
+}
+exports.fillDosStubData = fillDosStubData;
+function estimateNewHeaderSize(is32Bit) {
+    return (
+    // magic
+    4 +
+        ImageFileHeader_js_1.default.size +
+        (is32Bit ? ImageOptionalHeader_js_1.default.size : ImageOptionalHeader64_js_1.default.size) +
+        ImageDataDirectoryArray_js_1.default.size);
+}
+exports.estimateNewHeaderSize = estimateNewHeaderSize;
+function fillPeHeaderEmptyData(bin, offset, totalBinSize, is32Bit, isDLL) {
+    var _bin;
+    var _offset;
+    if ('buffer' in bin) {
+        _bin = bin.buffer;
+        _offset = bin.byteOffset + offset;
+    }
+    else {
+        _bin = bin;
+        _offset = offset;
+    }
+    new DataView(_bin, _offset).setUint32(0, ImageNtHeaders_js_1.default.DEFAULT_SIGNATURE, true);
+    var fh = ImageFileHeader_js_1.default.from(_bin, _offset + 4);
+    fh.machine = is32Bit ? 0x14c : 0x8664;
+    fh.numberOfSections = 0; // no sections
+    fh.timeDateStamp = 0;
+    fh.pointerToSymbolTable = 0;
+    fh.numberOfSymbols = 0;
+    fh.sizeOfOptionalHeader =
+        (is32Bit ? ImageOptionalHeader_js_1.default.size : ImageOptionalHeader64_js_1.default.size) +
+            ImageDataDirectoryArray_js_1.default.size;
+    fh.characteristics = isDLL ? 0x2102 : 0x102;
+    var oh = (is32Bit ? ImageOptionalHeader_js_1.default : ImageOptionalHeader64_js_1.default).from(_bin, _offset + 4 + ImageFileHeader_js_1.default.size);
+    oh.magic = is32Bit
+        ? ImageOptionalHeader_js_1.default.DEFAULT_MAGIC
+        : ImageOptionalHeader64_js_1.default.DEFAULT_MAGIC;
+    // oh.majorLinkerVersion = 0;
+    // oh.minorLinkerVersion = 0;
+    oh.sizeOfCode = 0;
+    oh.sizeOfInitializedData = 0;
+    oh.sizeOfUninitializedData = 0;
+    oh.addressOfEntryPoint = 0;
+    oh.baseOfCode = 0x1000;
+    // oh.baseOfData = 0; // for 32bit only
+    oh.imageBase = is32Bit ? 0x1000000 : 0x180000000;
+    oh.sectionAlignment = 4096;
+    oh.fileAlignment = DEFAULT_FILE_ALIGNMENT;
+    oh.majorOperatingSystemVersion = 6;
+    oh.minorOperatingSystemVersion = 0;
+    // oh.majorImageVersion = 0;
+    // oh.minorImageVersion = 0;
+    oh.majorSubsystemVersion = 6;
+    oh.minorSubsystemVersion = 0;
+    // oh.win32VersionValue = 0;
+    oh.sizeOfHeaders = functions_js_1.roundUp(totalBinSize, oh.fileAlignment);
+    // oh.checkSum = 0;
+    oh.subsystem = 2; // IMAGE_SUBSYSTEM_WINDOWS_GUI
+    oh.dllCharacteristics =
+        (is32Bit ? 0 : 0x20) + // IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
+            0x40 + // IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
+            0x100; // IMAGE_DLLCHARACTERISTICS_NX_COMPAT
+    oh.sizeOfStackReserve = 0x100000;
+    oh.sizeOfStackCommit = 0x1000;
+    oh.sizeOfHeapReserve = 0x100000;
+    oh.sizeOfHeapCommit = 0x1000;
+    // oh.loaderFlags = 0;
+    oh.numberOfRvaAndSizes =
+        ImageDataDirectoryArray_js_1.default.size / ImageDataDirectoryArray_js_1.default.itemSize;
+}
+exports.fillPeHeaderEmptyData = fillPeHeaderEmptyData;
+function makeEmptyNtExecutableBinary(is32Bit, isDLL) {
+    var bufferSize = functions_js_1.roundUp(DOS_STUB_SIZE + estimateNewHeaderSize(is32Bit), DEFAULT_FILE_ALIGNMENT);
+    var bin = new ArrayBuffer(bufferSize);
+    fillDosStubData(bin);
+    fillPeHeaderEmptyData(bin, DOS_STUB_SIZE, bufferSize, is32Bit, isDLL);
+    return bin;
+}
+exports.makeEmptyNtExecutableBinary = makeEmptyNtExecutableBinary;