scanoss 0.2.3

package/build/module/lib/scanner/WfpProvider/WfpCalculator/WfpCalculator.js

@@ -0,0 +1,330 @@
+import fs from 'fs';
+import { Worker } from 'worker_threads';
+import { ScannableItem } from '../../Scannable/ScannableItem';
+import { ScannerCfg } from '../../ScannerCfg';
+import { FingerprintPackage } from '../FingerprintPackage';
+import { WfpProvider } from '../WfpProvider';
+const stringWorker = `
+const { parentPort } = require('worker_threads');
+
+parentPort.on('message', async (scannableItem) => {
+
+  let fingerprint;
+  if ( scannableItem.winnowingMode === "FULL_WINNOWING") {
+    fingerprint = wfp_for_content(
+      scannableItem.content,
+      scannableItem.contentSource,
+      scannableItem.maxSizeWfp
+    );
+  } else {
+    fingerprint = wfp_only_md5(
+      scannableItem.content,
+      scannableItem.contentSource
+    );
+  }
+
+  scannableItem.fingerprint = fingerprint;
+
+  parentPort.postMessage(scannableItem);
+});
+
+
+const crypto = require('crypto');
+
+const isWin = process.platform === 'win32';
+const pathSeparator = isWin ? String.fromCharCode(92) : '/';
+
+// Winnowing configuration. DO NOT CHANGE.
+const GRAM = 30;
+const WINDOW = 64;
+
+// ASCII characters
+const ASCII_0 = 48;
+const ASCII_9 = 57;
+const ASCII_A = 65;
+const ASCII_Z = 90;
+const ASCII_a = 97;
+const ASCII_z = 122;
+const ASCII_LF = 10;
+
+function normalize(byte) {
+  if (byte < ASCII_0 || byte > ASCII_z) {
+    return 0;
+  }
+  if (byte <= ASCII_9 || byte >= ASCII_a) {
+    return byte;
+  }
+  if (byte >= ASCII_A && byte <= ASCII_Z) {
+    return byte + 32;
+  }
+  return 0;
+}
+
+function min_hex_array(array) {
+  let min = 'ffffffff';
+  for (let i = 0; i < array.length; i++) {
+    if (array[i] < min) {
+      min = array[i];
+    }
+  }
+  return min;
+}
+
+function wfp_for_content(content, contentSource, maxSize) {
+  let wfp = wfp_only_md5(content, contentSource);
+  wfp += calc_wfp(content, maxSize);
+  return wfp;
+}
+
+function wfp_only_md5(contents, contentSource) {
+  const file_md5 = crypto.createHash('md5').update(contents).digest('hex');
+  let wfp = 'file=' + String(file_md5) + ',' + String(contents.length) + ',' + String(contentSource)+ String.fromCharCode(10);
+  return wfp;
+}
+
+function calc_wfp(contents, maxSize) {
+  let gram = '';
+  const window = [];
+  let normalized = 0;
+  let line = 1;
+  let min_hash = 'ffffffff';
+  let last_hash = 'ffffffff';
+  let last_line = 0;
+  let output = '';
+  let gram_crc32 = 0;
+  let wfp = '';
+
+  for (let i = 0; i < contents.length; i++) {
+    if(wfp.length > maxSize)
+      return wfp;
+
+    const byte = contents[i];
+    if (byte == ASCII_LF) {
+      line += 1;
+      normalized = 0;
+    } else {
+      normalized = normalize(byte);
+    }
+    // Is this an useful byte?
+    if (normalized) {
+      gram += String.fromCharCode(normalized);
+
+      if (gram.length >= GRAM) {
+        gram_crc32 = crc32c_hex(gram);
+        window.push(gram_crc32);
+
+        if (window.length >= WINDOW) {
+          min_hash = min_hex_array(window);
+          if (min_hash !== last_hash) {
+            // Hashing the hash will result in a better balanced output data set
+            // as it will counter the winnowing effect which selects the "minimum"
+            // hash in each window
+            const min_hash_bytes_le = parseHexString(
+              toLittleEndianCRCHex(min_hash)
+            );
+            const crc_hex = crc32c_for_bytes_hex(min_hash_bytes_le);
+
+            if (last_line != line) {
+              if (output.length > 0) {
+                wfp += String(output) + String.fromCharCode(10);
+              }
+              output = String(line) + '=' + String(crc_hex);
+            } else {
+              output += ',' + String(crc_hex);
+            }
+            last_line = line;
+            last_hash = min_hash;
+          }
+          window.shift();
+        }
+        gram = gram.slice(1);
+      }
+    }
+  }
+  if (output.length > 0) {
+    wfp += String(output) + String.fromCharCode(10);
+  }
+
+  return wfp;
+}
+
+function parseHexString(str) {
+  const result = [];
+  while (str.length >= 2) {
+    result.push(parseInt(str.substring(0, 2), 16));
+    str = str.substring(2, str.length);
+  }
+
+  return result;
+}
+
+/**
+ *
+ * @param {string} hex
+ */
+function toLittleEndianCRCHex(hex) {
+  return (
+    hex.charAt(6) +
+    hex.charAt(7) +
+    hex.charAt(4) +
+    hex.charAt(5) +
+    hex.charAt(2) +
+    hex.charAt(3) +
+    hex.charAt(0) +
+    hex.charAt(1)
+  );
+}
+
+let CRC_TABLE = [];
+
+function makeCRCTable() {
+  let c;
+  const crcTable = [];
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[n] = c;
+  }
+  return crcTable;
+}
+
+function crc32c(str) {
+  if (CRC_TABLE.length == 0) {
+    CRC_TABLE = makeCRCTable();
+  }
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < str.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ str.charCodeAt(i)) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+}
+
+function crc32c_for_bytes(bytes) {
+  if (CRC_TABLE.length == 0) {
+    CRC_TABLE = makeCRCTable();
+  }
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < bytes.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ bytes[i]) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+}
+
+function crc32c_for_bytes_hex(bytes) {
+  return crc32c_for_bytes(bytes).toString(16).padStart(8, '0');
+}
+
+function crc32c_hex(str) {
+  return crc32c(str).toString(16).padStart(8, '0');
+}
+
+`;
+export class WfpCalculator extends WfpProvider {
+    fileList;
+    fileListIndex;
+    continue;
+    constructor(scannerCfg = new ScannerCfg()) {
+        super();
+        this.scannerCfg = scannerCfg;
+    }
+    init() {
+        super.init();
+        this.continue = true;
+        this.fileList = [];
+        this.fileListIndex = 0;
+    }
+    prepareWorker() {
+        this.worker = new Worker(stringWorker, { eval: true });
+        this.worker.on('message', async (scannableItem) => {
+            this.fingerprintPacker(scannableItem.fingerprint);
+            await this.nextStepMachine();
+        });
+    }
+    recoveryIndex() {
+        // Files: contains all files winnowed but not packed yet
+        const files = new FingerprintPackage(this.wfp, this.folderRoot).getFilesFingerprinted();
+        if (files.length) {
+            const lastFileWinnowed = files[files.length - 1];
+            let i = 0;
+            while (i <= files.length && lastFileWinnowed !== this.fileList[this.fileListIndex - i]) {
+                i += 1;
+            }
+            // If file already winnowed cannot be found in fileList emit an error.
+            if (i > files.length) {
+                this.sendError('Cannot recovery index on winnower');
+                return -1;
+            }
+            this.fileListIndex -= i;
+            if (this.fileList[this.fileListIndex] === lastFileWinnowed)
+                this.fileListIndex += 1;
+        }
+        return 0;
+    }
+    forceStopWorker() {
+        this.worker.removeAllListeners();
+        this.worker.terminate();
+    }
+    processPackedWfp(content) {
+        const fingerprint = new FingerprintPackage(content, this.folderRoot);
+        this.sendFingerprint(fingerprint);
+    }
+    async getNextScannableItem() {
+        if (this.fileListIndex >= this.fileList.length)
+            return null;
+        const path = this.fileList[this.fileListIndex];
+        const contentSource = path.replace(`${this.folderRoot}`, '');
+        const content = await fs.promises.readFile(path);
+        this.fileListIndex += 1;
+        const scannable = new ScannableItem(content, contentSource, this.winnowingMode, this.scannerCfg.WFP_FILE_MAX_SIZE);
+        return scannable;
+    }
+    async nextStepMachine() {
+        if (!this.continue)
+            return;
+        const scannableItem = await this.getNextScannableItem();
+        if (scannableItem)
+            this.worker.postMessage(scannableItem);
+        else {
+            this.finishWinnowing();
+            this.forceStopWorker();
+            this.sendLog('[ SCANNER ]: WFP Calculator finished...');
+        }
+    }
+    start(params) {
+        if (!params.fileList)
+            this.sendError('File list is required');
+        this.sendLog('[ SCANNER ]: WFP Calculator starting...');
+        this.init();
+        this.prepareWorker();
+        if (params.winnowingMode)
+            this.setWinnowingMode(params.winnowingMode);
+        this.pendingFiles = true;
+        this.folderRoot = params.folderRoot;
+        this.fileList = params.fileList;
+        this.nextStepMachine();
+    }
+    pause() {
+        this.sendLog('[ SCANNER ]: WFP Calculator paused...');
+        this.continue = false;
+    }
+    resume() {
+        this.sendLog('[ SCANNER ]: WFP Calculator resumed...');
+        this.continue = true;
+        this.recoveryIndex();
+        this.nextStepMachine();
+    }
+    stop() {
+        this.continue = false;
+        this.pendingFiles = false;
+        this.forceStopWorker();
+        this.prepareWorker();
+        this.init();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/scanner/WfpProvider/WfpProvider.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+import { EventEmitter } from "stream";
+import { ScannerCfg } from "../ScannerCfg";
+import { WinnowingMode } from "../ScannerTypes";
+import { FingerprintPackage } from "./FingerprintPackage";
+export interface IWfpProviderInput {
+    wfpPath?: string;
+    folderRoot?: string;
+    fileList?: Array<string>;
+    winnowingMode?: WinnowingMode;
+}
+export declare abstract class WfpProvider extends EventEmitter {
+    protected wfp: string;
+    protected scannerCfg: ScannerCfg;
+    protected folderRoot: string;
+    protected worker: Worker;
+    protected pendingFiles: boolean;
+    protected winnowingMode: WinnowingMode;
+    protected init(): void;
+    protected fingerprintPacker(fingerprint: string): boolean;
+    protected finishWinnowing(): void;
+    protected sendFingerprint(fingerprintPackage: FingerprintPackage): void;
+    protected sendLog(logMsg: string): void;
+    protected sendError(errorMsg: string): void;
+    protected setWinnowingMode(mode: WinnowingMode): void;
+    abstract start(params: IWfpProviderInput): void;
+    abstract stop(): void;
+    abstract pause(): void;
+    abstract resume(): void;
+    hasPendingFiles(): boolean;
+}

package/build/module/lib/scanner/WfpProvider/WfpProvider.js

@@ -0,0 +1,65 @@
+import { EventEmitter } from "stream";
+import { ScannerEvents, WinnowingMode } from "../ScannerTypes";
+import { FingerprintPackage } from "./FingerprintPackage";
+export class WfpProvider extends EventEmitter {
+    wfp;
+    scannerCfg;
+    folderRoot;
+    worker;
+    pendingFiles;
+    winnowingMode;
+    init() {
+        this.wfp = '';
+        this.folderRoot = '';
+        this.pendingFiles = false;
+        this.winnowingMode = WinnowingMode.FULL_WINNOWING;
+    }
+    // returns true if the function emitted a new fingerprint packet
+    fingerprintPacker(fingerprint) {
+        // When the fingerprint of one file is bigger than 64Kb, truncate to the last 64Kb line.
+        if (fingerprint.length > this.scannerCfg.WFP_FILE_MAX_SIZE) {
+            let truncateStringOnIndex = this.scannerCfg.WFP_FILE_MAX_SIZE;
+            let keepRemovingCharacters = true;
+            while (keepRemovingCharacters) {
+                if (fingerprint[truncateStringOnIndex] === '\n')
+                    keepRemovingCharacters = false;
+                truncateStringOnIndex -= 1;
+            }
+            truncateStringOnIndex += 1;
+            // eslint-disable-next-line no-param-reassign
+            fingerprint = fingerprint.substring(0, truncateStringOnIndex);
+            // eslint-disable-next-line no-param-reassign
+            fingerprint += '\n';
+        }
+        if (this.wfp.length + fingerprint.length >= this.scannerCfg.WFP_FILE_MAX_SIZE) {
+            this.sendFingerprint(new FingerprintPackage(this.wfp, this.folderRoot));
+            this.wfp = '';
+        }
+        this.wfp += fingerprint;
+        if (this.wfp !== fingerprint)
+            return false;
+        return true;
+    }
+    finishWinnowing() {
+        if (this.wfp.length !== 0)
+            this.sendFingerprint(new FingerprintPackage(this.wfp, this.folderRoot));
+        this.pendingFiles = false;
+        this.emit(ScannerEvents.WINNOWING_FINISHED);
+    }
+    sendFingerprint(fingerprintPackage) {
+        this.emit(ScannerEvents.WINNOWING_NEW_CONTENT, fingerprintPackage);
+    }
+    sendLog(logMsg) {
+        this.emit(ScannerEvents.WINNOWER_LOG, logMsg);
+    }
+    sendError(errorMsg) {
+        this.emit(ScannerEvents.ERROR, new Error(errorMsg));
+    }
+    setWinnowingMode(mode) {
+        this.winnowingMode = mode;
+    }
+    hasPendingFiles() {
+        return this.pendingFiles;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/scanner/WfpProvider/WfpProviderFactory.d.ts

@@ -0,0 +1,6 @@
+import { ScannerInput } from "../ScannerTypes";
+import { WfpCalculator } from "./WfpCalculator/WfpCalculator";
+import { WfpSplitter } from "./WfpSplitter/WfpSplitter";
+export declare class WfpProviderFactory {
+    static create(scannerInput: ScannerInput): WfpCalculator | WfpSplitter;
+}

package/build/module/lib/scanner/WfpProvider/WfpProviderFactory.js

@@ -0,0 +1,12 @@
+import { WfpCalculator } from "./WfpCalculator/WfpCalculator";
+import { WfpSplitter } from "./WfpSplitter/WfpSplitter";
+export class WfpProviderFactory {
+    static create(scannerInput) {
+        if (scannerInput.fileScan)
+            return new WfpCalculator();
+        if (scannerInput.wfpScan)
+            return new WfpSplitter();
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2ZwUHJvdmlkZXJGYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zY2FubmVyL1dmcFByb3ZpZGVyL1dmcFByb3ZpZGVyRmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDOUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRXhELE1BQU0sT0FBTyxrQkFBa0I7SUFFN0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxZQUEwQjtRQUN0QyxJQUFJLFlBQVksQ0FBQyxRQUFRO1lBQUUsT0FBTyxJQUFJLGFBQWEsRUFBRSxDQUFDO1FBQ3RELElBQUksWUFBWSxDQUFDLE9BQU87WUFBRSxPQUFPLElBQUksV0FBVyxFQUFFLENBQUM7UUFDbkQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBSUYifQ==

package/build/module/lib/scanner/WfpProvider/WfpSplitter/WfpSplitter.d.ts

@@ -0,0 +1,20 @@
+import { IWfpProviderInput, WfpProvider } from "../WfpProvider";
+import { ScannerCfg } from "../../ScannerCfg";
+export declare class WfpSplitter extends WfpProvider {
+    private continue;
+    private wfpStream;
+    private chunkDataRead;
+    private fingerprints;
+    private fingerprintIndex;
+    private timer;
+    constructor(scannerCfg?: ScannerCfg);
+    start(params: IWfpProviderInput): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    private sendFingerprints;
+    private stopSendFingerprints;
+    private streamBufferFlush;
+    private setStreamListeners;
+    private splitFingerprints;
+}

package/build/module/lib/scanner/WfpProvider/WfpSplitter/WfpSplitter.js

@@ -0,0 +1,93 @@
+import { WfpProvider } from "../WfpProvider";
+import fs from "fs";
+import { ScannerCfg } from "../../ScannerCfg";
+export class WfpSplitter extends WfpProvider {
+    continue;
+    wfpStream;
+    chunkDataRead;
+    fingerprints;
+    fingerprintIndex;
+    timer;
+    constructor(scannerCfg = new ScannerCfg()) {
+        super();
+        this.scannerCfg = scannerCfg;
+    }
+    start(params) {
+        this.sendLog('[ SCANNER ]: WFP Splitter starting...');
+        this.init();
+        this.pendingFiles = true;
+        this.chunkDataRead = '';
+        this.fingerprints = [];
+        this.continue = true;
+        this.fingerprintIndex = 0;
+        const wfpPath = params.wfpPath;
+        if (!wfpPath)
+            this.sendError('WFP path is not defined');
+        this.wfpStream = fs.createReadStream(wfpPath, { encoding: 'utf8' });
+        this.setStreamListeners();
+    }
+    stop() {
+        this.continue = false;
+    }
+    pause() {
+        this.sendLog('[ SCANNER ]: WFP Splitter paused...');
+        this.continue = false;
+    }
+    resume() {
+        this.sendLog('[ SCANNER ]: WFP Splitter resumed...');
+        this.continue = true;
+        this.sendFingerprints();
+        this.streamBufferFlush();
+    }
+    sendFingerprints() {
+        if (this.timer === undefined) {
+            this.timer = setInterval(() => {
+                if (this.fingerprintIndex < this.fingerprints.length && this.continue) {
+                    this.fingerprintPacker(this.fingerprints[this.fingerprintIndex]);
+                    this.fingerprintIndex++;
+                }
+                else {
+                    this.stopSendFingerprints();
+                }
+            });
+        }
+    }
+    stopSendFingerprints() {
+        clearInterval(this.timer);
+        this.timer = undefined;
+        if (this.fingerprintIndex === this.fingerprints.length) {
+            this.finishWinnowing();
+            this.sendLog('[ SCANNER ]: WFP Splitter finished...');
+        }
+    }
+    streamBufferFlush() {
+        // Use a loop to make sure we read all currently available data
+        while (this.continue && null !== (this.chunkDataRead = this.wfpStream.read(1 * 1024 * 1024))) { // Read chunks of 1MB
+            // Extract the first portion of the chunk until the first file=
+            // Then append the chunk to the last fingerprint.
+            if (!this.chunkDataRead.startsWith('file=')) {
+                const chunkOfData = this.chunkDataRead.substring(0, this.chunkDataRead.indexOf('file='));
+                this.fingerprints[this.fingerprints.length - 1] += chunkOfData;
+            }
+            this.fingerprints = [...this.fingerprints, ...this.splitFingerprints(this.chunkDataRead)];
+            this.sendFingerprints();
+        }
+    }
+    setStreamListeners() {
+        this.wfpStream.on('readable', () => {
+            this.streamBufferFlush();
+        });
+        this.wfpStream.on('end', () => { });
+    }
+    splitFingerprints(chunkOfData) {
+        const reg = /file=/g;
+        const blocksIndex = [...((chunkOfData).matchAll(reg))].map(x => x.index);
+        const fingerprints = [];
+        for (let i = 0; i < blocksIndex.length; i++) {
+            const fingerprint = chunkOfData.substring(blocksIndex[i], blocksIndex[i + 1]);
+            fingerprints.push(fingerprint);
+        }
+        return fingerprints;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/scanner/Winnower/Winnower.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { ScannableItem } from '../Scannable/ScannableItem';
+import { ScannerCfg } from '../ScannerCfg';
+import { ScannerInput, WinnowingMode } from '../ScannerTypes';
+export declare class Winnower extends EventEmitter {
+    private scannerCfg;
+    private fileList;
+    private fileListIndex;
+    private folderRoot;
+    private wfp;
+    private worker;
+    private continue;
+    private isRunning;
+    private winnowingMode;
+    private readingFromFile;
+    private winnowingExtractor;
+    constructor(scannerCfg?: ScannerCfg);
+    init(): void;
+    prepareWorker(): void;
+    recoveryIndex(): 0 | -1;
+    forceStopWorker(): void;
+    private winnowerPacker;
+    processPackedWfp(content: any): void;
+    getNextScannableItem(): Promise<ScannableItem>;
+    nextStepMachine(): Promise<void>;
+    startWinnowingFromFile(filePath: string): void;
+    private extractionProcess;
+    startWinnowing(scanInput: ScannerInput): Promise<void>;
+    private finishWinnowing;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    hasPendingFiles(): boolean;
+    setWinnowingMode(mode: WinnowingMode): void;
+}