scanoss 0.15.6 → 0.16.0

package/build/module/cli/commands/scan.js

@@ -1,26 +1,29 @@
-import fs from 'fs';
-import { Scanner } from '../../sdk/scanner/Scanner';
-import { SbomMode, ScannerEvents, WinnowingMode, } from '../../sdk/scanner/ScannerTypes';
-import { ScannerCfg } from '../../sdk/scanner/ScannerCfg';
-import { Tree } from '../../sdk/tree/Tree';
-import cliProgress from 'cli-progress';
+import fs from "fs";
+import { Scanner } from "../../sdk/scanner/Scanner";
+import { SbomMode, ScannerEvents, WinnowingMode } from "../../sdk/scanner/ScannerTypes";
+import { ScannerCfg } from "../../sdk/scanner/ScannerCfg";
+import { Tree } from "../../sdk/tree/Tree";
+import cliProgress from "cli-progress";
 import { getProjectNameFromPath, getSettingsFilePath, isFolder } from "./helpers";
-import { DependencyScannerCfg } from '../../sdk/Dependencies/DependencyScannerCfg';
-import { DependencyScanner } from '../../sdk/Dependencies/DependencyScanner';
-import { ScanFilter } from '../../sdk/tree/Filters/ScanFilter';
-import { DependencyFilter } from '../../sdk/tree/Filters/DependencyFilter';
-import { Report } from '../../sdk/Report/Report';
-import { DataProviderManager } from '../../sdk/Report/DataLayer/DataProviderManager';
-import { ComponentDataProvider } from '../../sdk/Report/DataLayer/DataProviders/ComponentDataProvider';
-import { DependencyDataProvider } from '../../sdk/Report/DataLayer/DataProviders/DependencyDataProvider';
-import { LicenseDataProvider } from '../../sdk/Report/DataLayer/DataProviders/LicenseDataProvider';
-import { SummaryDataProvider } from '../../sdk/Report/DataLayer/DataProviders/SummaryDataProvider';
-import { DecompressionFilter } from '../../sdk/tree/Filters/DecompressionFilter';
-import { DecompressionManager } from '../../sdk/Decompress/DecompressionManager';
-import path from 'path';
-import { LicenseObligationDataProvider } from '../../sdk/Report/DataLayer/DataProviders/LicenseObligationDataProvider';
-import { CryptographyDataProvider } from '../../sdk/Report/DataLayer/DataProviders/CryptographyDataProvider';
+import { DependencyScannerCfg } from "../../sdk/Dependencies/DependencyScannerCfg";
+import { DependencyScanner } from "../../sdk/Dependencies/DependencyScanner";
+import { ScanFilter } from "../../sdk/tree/Filters/ScanFilter";
+import { DependencyFilter } from "../../sdk/tree/Filters/DependencyFilter";
+import { Report } from "../../sdk/Report/Report";
+import { DataProviderManager } from "../../sdk/Report/DataLayer/DataProviderManager";
+import { ComponentDataProvider } from "../../sdk/Report/DataLayer/DataProviders/ComponentDataProvider";
+import { DependencyDataProvider } from "../../sdk/Report/DataLayer/DataProviders/DependencyDataProvider";
+import { LicenseDataProvider } from "../../sdk/Report/DataLayer/DataProviders/LicenseDataProvider";
+import { SummaryDataProvider } from "../../sdk/Report/DataLayer/DataProviders/SummaryDataProvider";
+import { DecompressionFilter } from "../../sdk/tree/Filters/DecompressionFilter";
+import { DecompressionManager } from "../../sdk/Decompress/DecompressionManager";
+import path from "path";
+import { LicenseObligationDataProvider } from "../../sdk/Report/DataLayer/DataProviders/LicenseObligationDataProvider";
+import { CryptographyDataProvider } from "../../sdk/Report/DataLayer/DataProviders/CryptographyDataProvider";
+import { CryptoCfg } from "../../sdk/Cryptography/CryptoCfg";
+import { CryptographyScanner } from "../../sdk/Cryptography/CryptographyScanner";
 export async function scanHandler(rootPath, options) {
+    // TODO: Add flag to enable debug. False by default.  logger.enableDebug(options.debug);
     rootPath = path.resolve(rootPath);
     const pathIsFolder = await isFolder(rootPath);
     const projectName = getProjectNameFromPath(rootPath);
@@ -62,7 +65,7 @@ export async function scanHandler(rootPath, options) {
     let scannerInput = { fileList: [] };
     // SBOM Ingestion
     if (options.ignore) {
-        scannerInput.sbom = fs.readFileSync(options.ignore, 'utf-8');
+        scannerInput.sbom = fs.readFileSync(options.ignore, "utf-8");
         scannerInput.sbomMode = SbomMode.SBOM_IGNORE;
     }
     // Settings Ingestion
@@ -70,8 +73,8 @@ export async function scanHandler(rootPath, options) {
         const settingsFilePath = await getSettingsFilePath(options.settings, rootPath);
         if (settingsFilePath) {
             try {
-                scannerInput.settings = JSON.parse(fs.readFileSync(settingsFilePath, "utf-8"));
-                scannerInput.sbomMode = SbomMode.SBOM_IDENTIFY;
+                const scanossSettings = JSON.parse(fs.readFileSync(settingsFilePath, "utf-8"));
+                scannerInput.settings = scanossSettings;
             }
             catch (e) {
                 throw new Error(`SCANOSS Settings file cannot be found at: ${settingsFilePath}.`);
@@ -83,30 +86,28 @@ export async function scanHandler(rootPath, options) {
         scannerInput.engineFlags = options.flags;
     if (options.wfp)
         scannerInput.wfpPath = rootPath;
-    const wfpMode = options.hpsm
-        ? WinnowingMode.FULL_WINNOWING_HPSM
-        : WinnowingMode.FULL_WINNOWING;
+    const wfpMode = options.hpsm ? WinnowingMode.FULL_WINNOWING_HPSM : WinnowingMode.FULL_WINNOWING;
     scannerInput.winnowing = { mode: wfpMode };
     if (!options.wfp) {
         if (pathIsFolder) {
-            console.error('\nReading directory...  ');
+            console.error("\nReading directory...  ");
             const tree = new Tree(rootPath);
             tree.build();
             if (options.extract) {
-                const archives = tree.getFileList(new DecompressionFilter(''));
-                console.error('Searching archives files...');
+                const archives = tree.getFileList(new DecompressionFilter(""));
+                console.error("Searching archives files...");
                 if (archives.length) {
-                    console.error('Extracting archives...');
+                    console.error("Extracting archives...");
                     const decompressionManager = new DecompressionManager(options.extractDeep, options.extractSuffix, options.extractOverwrite);
                     await decompressionManager.decompress(archives);
-                    console.error('Reindexing files...');
+                    console.error("Reindexing files...");
                     tree.build();
                 }
                 else
-                    console.error('No archives found.');
+                    console.error("No archives found.");
             }
-            scannerInput.fileList = tree.getFileList(new ScanFilter(''));
-            dependencyInput = tree.getFileList(new DependencyFilter(''));
+            scannerInput.fileList = tree.getFileList(new ScanFilter(""));
+            dependencyInput = tree.getFileList(new DependencyFilter(""));
         }
         else {
             scannerInput.fileList = [rootPath];
@@ -114,12 +115,12 @@ export async function scanHandler(rootPath, options) {
         }
     }
     else {
-        const winnowing = fs.readFileSync(rootPath, { encoding: 'utf-8' });
+        const winnowing = fs.readFileSync(rootPath, { encoding: "utf-8" });
         scannerInput.fileList.length = [...winnowing.matchAll(/file=/g)].length;
     }
     if (!options.verbose) {
         const optBar1 = {
-            format: 'Scan Progress: [{bar}] {percentage}% | Scanned {value} files of {total}',
+            format: "Scan Progress: [{bar}] {percentage}% | Scanned {value} files of {total}",
         };
         const bar1 = new cliProgress.SingleBar(optBar1, cliProgress.Presets.shades_classic);
         bar1.start(scannerInput.fileList.length, 0);
@@ -140,25 +141,67 @@ export async function scanHandler(rootPath, options) {
     }
     //Launch parallel scanners
     const pScanner = scanner.scan([scannerInput]);
-    const [scannerResultPath, depResults] = await Promise.all([
-        pScanner,
-        pDependencyScanner,
-    ]);
-    let scannerResults = JSON.parse(await fs.promises.readFile(scannerResultPath, 'utf-8'));
+    const [scannerResultPath, depResults] = await Promise.all([pScanner, pDependencyScanner]);
+    let scannerResults = JSON.parse(await fs.promises.readFile(scannerResultPath, "utf-8"));
     //TODO Unify results.json and dependency.json. What happens with result.json that includes dependencies?
     const scannersResults = {
         scanner: scannerResults,
         ...(options.dependencies && { dependencies: depResults }),
     };
-    let scannerResultsString = JSON.stringify(scannersResults, null, 2);
-    if (options.format && options.format.toLowerCase() === 'html') {
+    let scannerResultsString = JSON.stringify(scannerResults, null, 2);
+    // Crypto
+    const resultsWithCrypto = {
+        scanner: scannerResults,
+        ...{
+            cryptography: {
+                files: [],
+                components: [],
+            },
+        },
+    };
+    if (options.cryptography) {
+        // Load rules
+        let algorithmRules = null;
+        let libraryRules = null;
+        if (options.algorithmRules)
+            algorithmRules = options.algorithmRules;
+        if (options.libraryRules)
+            libraryRules = options.libraryRules;
+        // Local Cryptography
+        const cryptoCfg = new CryptoCfg({
+            threads: 5,
+            libraryRulesPath: libraryRules,
+            algorithmRulesPath: algorithmRules,
+            apiKey: options.key,
+            proxy: options.proxy,
+        });
+        const cryptoScanner = new CryptographyScanner(cryptoCfg);
+        let localCrypto = await cryptoScanner.scanFiles(scannerInput.fileList);
+        localCrypto.fileList = localCrypto.fileList.map((c) => {
+            return { ...c, file: c.file.replace(rootPath, "") };
+        });
+        resultsWithCrypto.cryptography.files = localCrypto.fileList;
+        // Component Cryptography
+        if (options.key) {
+            let componentList = Object.values(scannersResults.scanner).flat();
+            componentList = componentList.filter((component) => component.id !== "none");
+            const cryptoRequest = {
+                purlsList: componentList.map((c) => {
+                    return { purl: c.purl[0], requirement: c.version };
+                }),
+            };
+            resultsWithCrypto.cryptography.components = await cryptoScanner.scanComponents(cryptoRequest);
+        }
+        scannerResultsString = JSON.stringify(resultsWithCrypto, null, 2);
+    }
+    if (options.format && options.format.toLowerCase() === "html") {
         const dataProviderManager = new DataProviderManager();
         dataProviderManager.addDataProvider(new ComponentDataProvider(scannersResults.scanner, scannersResults.dependencies));
         dataProviderManager.addDataProvider(new DependencyDataProvider(scannersResults.dependencies));
         dataProviderManager.addDataProvider(new LicenseDataProvider(scannersResults.scanner, scannersResults.dependencies));
         dataProviderManager.addDataProvider(new SummaryDataProvider(projectName, new Date(), scannersResults.scanner));
         dataProviderManager.addDataProvider(new LicenseObligationDataProvider(scannersResults.scanner, scannersResults.dependencies));
-        dataProviderManager.addDataProvider(new CryptographyDataProvider(null, scannersResults.scanner));
+        dataProviderManager.addDataProvider(new CryptographyDataProvider(resultsWithCrypto.cryptography.files, resultsWithCrypto.cryptography.components));
         const report = new Report(dataProviderManager);
         scannerResultsString = await report.getHTML();
     }
@@ -167,4 +210,4 @@ export async function scanHandler(rootPath, options) {
     else
         console.log(scannerResultsString);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../../../src/cli/commands/scan.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../../../src/cli/commands/scan.ts"],"names":[],"mappings":"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"}

package/build/module/sdk/Cryptography/Algorithm/Components/ComponentAlgorithmScanner.d.ts

@@ -0,0 +1,19 @@
+import { ComponentCryptographyResultCollector } from "../../Helper/ResultCollector/Component/ComponentCryptographyResultColletor";
+import { AlgorithmResponse } from "../../../Services/Grpc/CryptographyService";
+import { PurlRequest } from "../../../Services/Grpc/BaseService";
+import { BaseCryptographyScanner } from "../../BaseCryptographyScanner";
+/**
+ * Scanner for detecting cryptographic algorithms in software components.
+ * This class extends the base cryptography scanner to specifically handle
+ * component-level cryptographic algorithm detection using a remote service.
+ */
+export declare class ComponentAlgorithmScanner extends BaseCryptographyScanner<ComponentCryptographyResultCollector, PurlRequest, AlgorithmResponse> {
+    /**
+     * Scans components identified by PURL for cryptographic algorithms.
+     * This method connects to a cryptography service to retrieve algorithm
+     * information for the specified components.
+     * @param req A request containing PURL (Package URL) identifiers for components to scan.
+     * @returns {AlgorithmResponse} A promise that resolves to an AlgorithmResponse containing detected cryptographic algorithms.
+     */
+    scan(req: PurlRequest): Promise<AlgorithmResponse>;
+}

package/build/module/sdk/Cryptography/Algorithm/Components/ComponentAlgorithmScanner.js

@@ -0,0 +1,23 @@
+import { CryptographyService } from "../../../Services/Grpc/CryptographyService";
+import { BaseCryptographyScanner } from "../../BaseCryptographyScanner";
+/**
+ * Scanner for detecting cryptographic algorithms in software components.
+ * This class extends the base cryptography scanner to specifically handle
+ * component-level cryptographic algorithm detection using a remote service.
+ */
+export class ComponentAlgorithmScanner extends BaseCryptographyScanner {
+    /**
+     * Scans components identified by PURL for cryptographic algorithms.
+     * This method connects to a cryptography service to retrieve algorithm
+     * information for the specified components.
+     * @param req A request containing PURL (Package URL) identifiers for components to scan.
+     * @returns {AlgorithmResponse} A promise that resolves to an AlgorithmResponse containing detected cryptographic algorithms.
+     */
+    async scan(req) {
+        const cryptographyService = new CryptographyService(this.config.getApikey(), this.config.getProxy());
+        const results = await cryptographyService.getAlgorithms(req);
+        this.resultCollector.collectAlgorithmResults(results);
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29tcG9uZW50QWxnb3JpdGhtU2Nhbm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvQ3J5cHRvZ3JhcGh5L0FsZ29yaXRobS9Db21wb25lbnRzL0NvbXBvbmVudEFsZ29yaXRobVNjYW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUVMLG1CQUFtQixFQUNwQixNQUFNLDRDQUE0QyxDQUFDO0FBRXBELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXhFOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8seUJBQ1gsU0FBUSx1QkFHWTtJQUVwQjs7Ozs7O09BTUc7SUFDSSxLQUFLLENBQUMsSUFBSSxDQUFDLEdBQWdCO1FBQ2hDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxFQUN6RSxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDMUIsTUFBTSxPQUFPLEdBQXFCLE1BQU0sbUJBQW1CLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQy9FLElBQUksQ0FBQyxlQUFlLENBQUMsdUJBQXVCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDdEQsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztDQUNGIn0=

package/build/module/sdk/Cryptography/Algorithm/Files/AlgorithmProcessor.d.ts

@@ -0,0 +1 @@
+export declare const cryptographyAlgorithmProcessor = "\nconst { parentPort } = require('worker_threads');\nconst fs = require('fs');\n\nparentPort.on('message', async (job) => {\n\n    const MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024;\n    const { data } = job;\n    const { file, rules, cryptoMapper } = data;\n\n     const cryptoFound = new Array();\n     const stats = await fs.promises.stat(file);\n     if (stats.size > MAX_FILE_SIZE) {\n      parentPort.postMessage({ file, algorithms:[] });\n      return;\n     }\n\n      let content =  fs.readFileSync(file, 'utf-8');\n       rules.forEach((value, key) => {\n      try {\n        const matches = content.match(value);\n        if (matches) {\n          cryptoFound.push(key);\n        }\n      } catch (e){\n        console.error(e);\n      }\n    });\n    const algorithms = [];\n    cryptoFound.forEach((cf)=>{\n      algorithms.push(cryptoMapper.get(cf));\n    });\n    parentPort.postMessage({ file, algorithms });\n  });\n";

package/build/module/sdk/Cryptography/Algorithm/Files/AlgorithmProcessor.js

@@ -0,0 +1,36 @@
+export const cryptographyAlgorithmProcessor = `
+const { parentPort } = require('worker_threads');
+const fs = require('fs');
+
+parentPort.on('message', async (job) => {
+
+    const MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024;
+    const { data } = job;
+    const { file, rules, cryptoMapper } = data;
+
+     const cryptoFound = new Array();
+     const stats = await fs.promises.stat(file);
+     if (stats.size > MAX_FILE_SIZE) {
+      parentPort.postMessage({ file, algorithms:[] });
+      return;
+     }
+
+      let content =  fs.readFileSync(file, 'utf-8');
+       rules.forEach((value, key) => {
+      try {
+        const matches = content.match(value);
+        if (matches) {
+          cryptoFound.push(key);
+        }
+      } catch (e){
+        console.error(e);
+      }
+    });
+    const algorithms = [];
+    cryptoFound.forEach((cf)=>{
+      algorithms.push(cryptoMapper.get(cf));
+    });
+    parentPort.postMessage({ file, algorithms });
+  });
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWxnb3JpdGhtUHJvY2Vzc29yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3Nkay9DcnlwdG9ncmFwaHkvQWxnb3JpdGhtL0ZpbGVzL0FsZ29yaXRobVByb2Nlc3Nvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSw4QkFBOEIsR0FBRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQWtDN0MsQ0FBQyJ9

package/build/module/sdk/Cryptography/Algorithm/Files/FileAlgorithmScanner.d.ts

@@ -0,0 +1,42 @@
+import { CryptoCfg } from '../../CryptoCfg';
+import { CryptoAlgorithmJobResponse } from "../../CryptographyTypes";
+import { BaseCryptographyScanner } from "../../BaseCryptographyScanner";
+import { FileCryptographyResultCollector } from "../../Helper/ResultCollector/File/FileCryptographyResultCollector";
+/**
+ * A class responsible for scanning files for cryptographic items.
+ */
+export declare class FileAlgorithmScanner extends BaseCryptographyScanner<FileCryptographyResultCollector, Array<string>, Array<CryptoAlgorithmJobResponse>> {
+    private readonly DEFAULT_CRYPTO_ALGORITHM_RULE_FILENAME;
+    /**
+     * Constructs a new CryptographyScanner.
+     * @param cryptoCfg The cryptographic configuration.
+     * @param resultCollector cryptography results collector
+     */
+    constructor(cryptoCfg: CryptoCfg, resultCollector: FileCryptographyResultCollector);
+    /**
+     Builds a collection of cryptographic algorithm analysis jobs from an array of files.
+     This method loads cryptography rules, creates required mappers, and initializes
+     job objects for each file that will be used for crypto pattern detection.
+     @param files An array of file paths to analyze for cryptographic algorithm usage.
+     @returns A promise that resolves to an array of job objects configured for crypto analysis.
+     */
+    private buildJobs;
+    /**
+     * Scans an array of files for cryptographic items.
+     * @param files An array of file paths to scan.
+     * @returns A promise that resolves to an ILocalCryptographyResponse.
+     */
+    scan(files: Array<string>): Promise<Array<CryptoAlgorithmJobResponse>>;
+    /**
+     * Scans a folder for cryptographic items.
+     * @param path The path of the folder to scan.
+     * @returns A promise that resolves to an ILocalCryptographyResponse.
+     * @throws Error if the specified path is not a directory.
+     */
+    scanFolder(path: string): Promise<Array<CryptoAlgorithmJobResponse>>;
+    /**
+     * Loads custom cryptographic rules from a file.
+     * @returns A promise that resolves to the loaded rules.
+     */
+    private loadRules;
+}

package/build/module/sdk/Cryptography/Algorithm/Files/FileAlgorithmScanner.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import { Tree } from '../../../tree/Tree';
+import path from 'path';
+import { createCryptoKeywordMapper, getCryptoMapper } from "./Helper/Helper";
+import { Job } from "../../../Utils/Concurrency/Job";
+import { WorkerPool } from "../../../Utils/Concurrency/WorkerPool";
+import { cryptographyAlgorithmProcessor } from "./AlgorithmProcessor";
+import { BaseCryptographyScanner } from "../../BaseCryptographyScanner";
+/**
+ * A class responsible for scanning files for cryptographic items.
+ */
+export class FileAlgorithmScanner extends BaseCryptographyScanner {
+    DEFAULT_CRYPTO_ALGORITHM_RULE_FILENAME = 'scanoss-crypto-algorithm-rules.json';
+    /**
+     * Constructs a new CryptographyScanner.
+     * @param cryptoCfg The cryptographic configuration.
+     * @param resultCollector cryptography results collector
+     */
+    constructor(cryptoCfg, resultCollector) {
+        super(cryptoCfg, resultCollector);
+    }
+    /**
+     Builds a collection of cryptographic algorithm analysis jobs from an array of files.
+     This method loads cryptography rules, creates required mappers, and initializes
+     job objects for each file that will be used for crypto pattern detection.
+     @param files An array of file paths to analyze for cryptographic algorithm usage.
+     @returns A promise that resolves to an array of job objects configured for crypto analysis.
+     */
+    async buildJobs(files) {
+        const cryptographyRules = await this.loadRules(this.config.getAlgorithmRulesPath());
+        const rules = createCryptoKeywordMapper(cryptographyRules);
+        const cryptoMapper = getCryptoMapper(cryptographyRules);
+        const localCryptoJobs = [];
+        files.forEach((f) => {
+            const newJob = new Job({
+                file: f,
+                rules,
+                cryptoMapper
+            });
+            localCryptoJobs.push(newJob);
+        });
+        return localCryptoJobs;
+    }
+    /**
+     * Scans an array of files for cryptographic items.
+     * @param files An array of file paths to scan.
+     * @returns A promise that resolves to an ILocalCryptographyResponse.
+     */
+    async scan(files) {
+        const workerPool = new WorkerPool(cryptographyAlgorithmProcessor, this.config.getNumberOfThreads());
+        const jobs = await this.buildJobs(files);
+        workerPool.loadJobs(jobs);
+        const results = await workerPool.run();
+        this.resultCollector.collectAlgorithmResults(results);
+        return results;
+    }
+    /**
+     * Scans a folder for cryptographic items.
+     * @param path The path of the folder to scan.
+     * @returns A promise that resolves to an ILocalCryptographyResponse.
+     * @throws Error if the specified path is not a directory.
+     */
+    async scanFolder(path) {
+        if (!(await fs.promises.lstat(path)).isDirectory())
+            throw new Error('Specified path is not a directory');
+        const tree = new Tree(path);
+        tree.build();
+        return await this.scan(tree.getFileList());
+    }
+    /**
+     * Loads custom cryptographic rules from a file.
+     * @returns A promise that resolves to the loaded rules.
+     */
+    async loadRules(rulePath) {
+        const cryptoRulePath = rulePath ? rulePath : path.join(__dirname, '../../../../../../assets/data', this.DEFAULT_CRYPTO_ALGORITHM_RULE_FILENAME);
+        const rules = await fs.promises.readFile(cryptoRulePath, 'utf-8');
+        return JSON.parse(rules);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/sdk/Cryptography/{CryptoDef/CryptoDef.d.ts → Algorithm/Files/Helper/Helper.d.ts}

@@ -1,4 +1,4 @@
-import { CryptoAlgorithm, CryptoAlgorithmRules } from '../CryptographyTypes';
+import { CryptoAlgorithm, CryptoAlgorithmRules } from '../../../CryptographyTypes';
 /**
  * Function to create a mapping of regular expressions based on provided crypto definitions.
  * @param cryptoRulesDefinitions An array of objects containing cryptographic definitions.

package/build/module/sdk/Cryptography/{CryptoDef/CryptoDef.js → Algorithm/Files/Helper/Helper.js}

@@ -31,4 +31,4 @@ export function getCryptoMapper(cryptoDefinitions) {
     });
     return cryptoMapper;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3J5cHRvRGVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3Nkay9DcnlwdG9ncmFwaHkvQ3J5cHRvRGVmL0NyeXB0b0RlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSx5QkFBeUIsQ0FBQyxzQkFBbUQ7SUFDM0YsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQWlCLENBQUM7SUFDeEMsc0JBQXNCLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQSxFQUFFO1FBQ2hDLE1BQU0sS0FBSyxHQUFHLEVBQUUsQ0FBQztRQUNqQixDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBQyxFQUFFO1lBQ3RCLE1BQU0sV0FBVyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMscUJBQXFCLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDN0QsS0FBSyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUUxQixDQUFDLENBQUMsQ0FBQztRQUNILE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLFNBQVMsRUFBRSxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQyxDQUFDLENBQUM7SUFDSCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLGlCQUE4QztJQUMzRSxNQUFNLFlBQVksR0FBRyxJQUFJLEdBQUcsRUFBZSxDQUFDO0lBRTVDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1FBQy9CLE1BQU0sRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1FBQ2xDLGdEQUFnRDtRQUNoRCxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxTQUFTLEVBQUUsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUN6RCxDQUFDLENBQUMsQ0FBQztJQUNILE9BQU8sWUFBWSxDQUFDO0FBQ3RCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSGVscGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3Nkay9DcnlwdG9ncmFwaHkvQWxnb3JpdGhtL0ZpbGVzL0hlbHBlci9IZWxwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUseUJBQXlCLENBQUMsc0JBQW1EO0lBQzNGLE1BQU0sTUFBTSxHQUFHLElBQUksR0FBRyxFQUFpQixDQUFDO0lBQ3hDLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUEsRUFBRTtRQUNoQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7UUFDakIsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUMsRUFBRTtZQUN0QixNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsT0FBTyxDQUFDLHFCQUFxQixFQUFFLE1BQU0sQ0FBQyxDQUFDO1lBQzdELEtBQUssQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7UUFFMUIsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxTQUFTLEVBQUUsSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUMsQ0FBQyxDQUFDO0lBQ0gsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLGVBQWUsQ0FBQyxpQkFBOEM7SUFDM0UsTUFBTSxZQUFZLEdBQUcsSUFBSSxHQUFHLEVBQTJCLENBQUM7SUFFeEQsaUJBQWlCLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7UUFDL0IsTUFBTSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDbEMsZ0RBQWdEO1FBQ2hELFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLFNBQVMsRUFBRSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQ3pELENBQUMsQ0FBQyxDQUFDO0lBQ0gsT0FBTyxZQUFZLENBQUM7QUFDdEIsQ0FBQyJ9

package/build/module/sdk/Cryptography/{Scanneable → Algorithm/Files/Scanneable}/CryptoItem.d.ts

@@ -1,8 +1,8 @@
-import { CryptoAlgorithm, ICryptoItem } from '../CryptographyTypes';
+import { CryptoAlgorithm } from '../../../CryptographyTypes';
 /**
  * Represents a cryptographic item containing information about a file and cryptographic algorithms found in it.
  */
-export declare class CryptoItem implements ICryptoItem {
+export declare class CryptoItem {
     file: string;
     algorithms: Array<CryptoAlgorithm>;
     /**

package/build/module/sdk/Cryptography/{Scanneable → Algorithm/Files/Scanneable}/CryptoItem.js

@@ -34,4 +34,4 @@ export class CryptoItem {
         this.algorithms = algorithms;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3J5cHRvSXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvQ3J5cHRvZ3JhcGh5L1NjYW5uZWFibGUvQ3J5cHRvSXRlbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFVO0lBRXJCLElBQUksQ0FBUztJQUNiLFVBQVUsQ0FBeUI7SUFFbkM7OztPQUdHO0lBQ0gsWUFBWSxJQUFZO1FBQ3RCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLElBQUksQ0FBQyxVQUFVLEdBQUcsRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFFRDs7O09BR0c7SUFDSSxPQUFPO1FBQ1osT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ25CLENBQUM7SUFFRDs7O09BR0c7SUFDSSxhQUFhO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxDQUFDLFVBQWtDO1FBQ3JELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO0lBQy9CLENBQUM7Q0FFRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3J5cHRvSXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvQ3J5cHRvZ3JhcGh5L0FsZ29yaXRobS9GaWxlcy9TY2FubmVhYmxlL0NyeXB0b0l0ZW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sVUFBVTtJQUVyQixJQUFJLENBQVM7SUFDYixVQUFVLENBQXlCO0lBRW5DOzs7T0FHRztJQUNILFlBQVksSUFBWTtRQUN0QixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsVUFBVSxHQUFHLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYTtRQUNsQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDekIsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGFBQWEsQ0FBQyxVQUFrQztRQUNyRCxJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztJQUMvQixDQUFDO0NBRUYifQ==

package/build/module/sdk/Cryptography/BaseCryptographyScanner.d.ts

@@ -0,0 +1,25 @@
+import { CryptoCfg } from "./CryptoCfg";
+/**
+ * Abstract base class for cryptography scanners.
+ * Provides common functionality for different types of cryptography scanners.
+ * @template C Type of result collector
+ * @template I Type of input to be scanned
+ * @template R Type of returned scan result
+ */
+export declare abstract class BaseCryptographyScanner<C, I, R> {
+    protected config: CryptoCfg;
+    protected resultCollector: C;
+    /**
+     * Creates a new instance of a cryptography scanner.
+     * @param cfg Configuration settings for the scanner.
+     * @param cryptoResultCollector Collector for storing scan results.
+     */
+    constructor(cfg: CryptoCfg, cryptoResultCollector: C);
+    /**
+     * Scans the provided input for cryptographic items.
+     * This method must be implemented by derived classes.
+     * @param files Input to be scanned.
+     * @returns A promise that resolves to the scan result.
+     */
+    abstract scan(files: I): Promise<R>;
+}

package/build/module/sdk/Cryptography/BaseCryptographyScanner.js

@@ -0,0 +1,21 @@
+/**
+ * Abstract base class for cryptography scanners.
+ * Provides common functionality for different types of cryptography scanners.
+ * @template C Type of result collector
+ * @template I Type of input to be scanned
+ * @template R Type of returned scan result
+ */
+export class BaseCryptographyScanner {
+    config;
+    resultCollector;
+    /**
+     * Creates a new instance of a cryptography scanner.
+     * @param cfg Configuration settings for the scanner.
+     * @param cryptoResultCollector Collector for storing scan results.
+     */
+    constructor(cfg, cryptoResultCollector) {
+        this.config = cfg;
+        this.resultCollector = cryptoResultCollector;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZUNyeXB0b2dyYXBoeVNjYW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2RrL0NyeXB0b2dyYXBoeS9CYXNlQ3J5cHRvZ3JhcGh5U2Nhbm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQWdCLHVCQUF1QjtJQUVqQyxNQUFNLENBQVk7SUFFbEIsZUFBZSxDQUFJO0lBRTdCOzs7O09BSUc7SUFDSCxZQUFZLEdBQWMsRUFBRSxxQkFBd0I7UUFDbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxHQUFHLENBQUM7UUFDbEIsSUFBSSxDQUFDLGVBQWUsR0FBRyxxQkFBcUIsQ0FBQztJQUMvQyxDQUFDO0NBU0YifQ==

package/build/module/sdk/Cryptography/CryptoCfg.d.ts

@@ -3,22 +3,49 @@
  */
 export declare class CryptoCfg {
     private readonly DEFAULT_THREADS;
-    private readonly rulesPath;
+    private readonly algorithmRulesPath;
+    private readonly libraryRulesPath;
     private readonly threads;
+    protected readonly apiKey: string;
+    protected readonly proxy: string;
     /**
      * Creates an instance of CryptoCfg.
      * @param {Object} cfg - Configuration object.
      * @param {number} [cfg.threads=5] - The number of threads to use. Defaults to 5 if not provided.
      * @param {string} [cfg.rulesPath] - Optional. Path to the cryptography rules file.
+     * @param {string} [cfg.apiKey] - Optional. SCANOSS API Key.
+     * @param {string} [cfg.proxy] - Optional. proxy.
      */
     constructor(cfg: {
-        threads: number;
-        rulesPath: string;
+        threads?: number;
+        algorithmRulesPath?: string;
+        libraryRulesPath?: string;
+        apiKey?: string;
+        proxy?: string;
     });
     /**
-     * Gets the path to the cryptography rules file.
+     * Gets the path to the cryptography algorithm rules file.
      * @returns The path to the cryptography rules file.
      */
-    getRulesPath(): string;
+    getAlgorithmRulesPath(): string;
+    /**
+    * Gets the path to the cryptography library rules file.
+    * @returns The path to the cryptography rules file.
+    */
+    getLibraryRulesPath(): string;
+    /**
+    * Gets the number of threads to use on local crypto detection.
+    * @returns The number of threads.
+    **/
     getNumberOfThreads(): number;
+    /**
+    * Gets the API Key set.
+    * @returns The API Key.
+    **/
+    getApikey(): string;
+    /**
+    * Gets proxy.
+    * @returns proxy.
+    **/
+    getProxy(): string;
 }