snyk 1.782.0 → 1.783.0

package/dist/cli/64.index.js

@@ -172481,6 +172481,8 @@ function getColorBySeverity(severity) {
             return chalk.yellowBright;
         case 'high':
             return chalk.redBright;
+        case 'critical':
+            return chalk.magentaBright;
         default:
             return chalk.whiteBright;
     }
@@ -172673,185 +172675,6 @@ exports.display = display;
 
 /***/ }),
 
-/***/ 82635:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getDubHashSignature = void 0;
-// This module implements the "double hash" signature specification described in docs/signature_specification.md
-const crypto = __webpack_require__(76417);
-const binary_1 = __webpack_require__(75766);
-const hashAlgorithm = 'md5';
-const regex = /=/g;
-var LineEndingFormat;
-(function (LineEndingFormat) {
-    LineEndingFormat[LineEndingFormat["LINUX"] = 0] = "LINUX";
-    LineEndingFormat[LineEndingFormat["WINDOWS"] = 1] = "WINDOWS";
-    LineEndingFormat[LineEndingFormat["UNKNOWN"] = 2] = "UNKNOWN";
-})(LineEndingFormat || (LineEndingFormat = {}));
-const CR = 0x0d;
-const LF = 0x0a;
-function getDubHashSignature(filePath, fileContents, getAltHash = false) {
-    // Unless getAltHash is true, we only need a single hash, AKA the "half double hash".
-    if (!getAltHash) {
-        return {
-            path: filePath,
-            hashes_ffm: [
-                {
-                    data: getSingleDigest(fileContents),
-                    format: 1,
-                },
-            ],
-        };
-    }
-    const [digest1, digest2] = getDubHashDigests(fileContents, binary_1.isBinary(fileContents));
-    if (!digest1)
-        throw Error(`Failed to generate hash of ${filePath}`);
-    if (digest1 && !digest2) {
-        return {
-            path: filePath,
-            hashes_ffm: [
-                {
-                    data: digest1,
-                    format: 1,
-                },
-            ],
-        };
-    }
-    return {
-        path: filePath,
-        hashes_ffm: [
-            {
-                data: digest1,
-                format: 1,
-            },
-            {
-                data: digest2,
-                format: 1,
-            },
-        ],
-    };
-}
-exports.getDubHashSignature = getDubHashSignature;
-function getDubHashDigests(fileContents, isBinary) {
-    // If the file is binary, you only produce one hash
-    // If the file does not have line endings, you treat it like a binary file
-    // If the LF character is not found, the line endings are UNKNOWN, and we produce only one hash.
-    const lineEndingFormat = detectLineEndingFormat(fileContents);
-    if (isBinary ||
-        !hasLineEndings(fileContents) ||
-        lineEndingFormat === LineEndingFormat.UNKNOWN) {
-        return [getSingleDigest(fileContents), null];
-    }
-    // NB: You MUST calculate the digest for the original file and store it, since transformLineEndings
-    // will modify fileContents buffer.
-    const digestForOriginal = getSingleDigest(fileContents);
-    const transformedFile = transformLineEndings(fileContents, lineEndingFormat);
-    return [digestForOriginal, getSingleDigest(transformedFile)];
-}
-function hasLineEndings(fileContents) {
-    const lineEndingBytes = new Uint8Array([LF, CR]);
-    for (let readIndex = 0; readIndex < fileContents.length; readIndex++) {
-        if (lineEndingBytes.includes(fileContents[readIndex])) {
-            return true;
-        }
-    }
-    return false;
-}
-function detectLineEndingFormat(fileContents) {
-    for (let readIndex = 0; readIndex < fileContents.length; readIndex++) {
-        if (fileContents[readIndex] !== LF) {
-            continue;
-        }
-        // If the first character in the file is LF (0x0a), the file is of type LINUX.
-        if (readIndex === 0) {
-            return LineEndingFormat.LINUX;
-        }
-        // If the file has a LF character (0x0a), check if the previous character is 0x0d (CR),
-        // then the newline type is WINDOWS
-        if (fileContents[readIndex - 1] === CR) {
-            return LineEndingFormat.WINDOWS;
-        }
-        return LineEndingFormat.LINUX;
-    }
-    // If the LF character is not found, the line endings are UNKNOWN.
-    return LineEndingFormat.UNKNOWN;
-}
-function transformLinuxToWindows(fileContents) {
-    // In worst case, file is all 0x0a bytes, so we need to allocate double the memory
-    const transformedFile = Buffer.alloc(2 * fileContents.length);
-    let writeIndex = 0;
-    for (let readIndex = 0; readIndex < fileContents.length; readIndex++) {
-        // if byte is CR (0x0d), do not write byte
-        if (fileContents[readIndex] === CR) {
-            continue;
-        }
-        // if byte is LF and targetLineEndingFormat is WINDOWS, write CR (0x0d) LF (0x0a)
-        // NB1: Check for targetLineEndingFormat === LineEndingFormat.WINDOWS is obviously not necessary here,
-        // NB2: LineEndingFormat.UNKOWN is also not possible here, due to early return in getDubHashDigests
-        if (fileContents[readIndex] === LF) {
-            transformedFile[writeIndex] = CR;
-            transformedFile[writeIndex + 1] = LF;
-            writeIndex += 2;
-            continue;
-        }
-        // else: write byte
-        transformedFile[writeIndex] = fileContents[readIndex];
-        writeIndex++;
-    }
-    return transformedFile.slice(0, writeIndex);
-}
-function transformWindowsToLinux(fileContents) {
-    let writeIndex = 0;
-    for (let readIndex = 0; readIndex < fileContents.length; readIndex++) {
-        // if byte is CR (0x0d), do not write byte
-        if (fileContents[readIndex] === CR) {
-            continue;
-        }
-        // if byte is LF (0x0a): if target line ending is UNIX, write LF (0x0a)
-        // NB1: Check for targetLineEndingFormat === LineEndingFormat.WINDOWS is obviously not necessary here,
-        // NB2: LineEndingFormat.UNKOWN is also not possible here, due to early return in getDubHashDigests
-        if (fileContents[readIndex] === LF) {
-            if (readIndex !== writeIndex)
-                fileContents[writeIndex] = LF;
-            writeIndex++;
-            continue;
-        }
-        // else: write byte
-        if (readIndex !== writeIndex)
-            fileContents[writeIndex] = fileContents[readIndex];
-        writeIndex++;
-    }
-    return fileContents.slice(0, writeIndex);
-}
-function transformLineEndings(fileContents, lineEndingFormat) {
-    const targetLineEndingFormat = lineEndingFormat === LineEndingFormat.LINUX
-        ? LineEndingFormat.WINDOWS
-        : LineEndingFormat.LINUX;
-    if (targetLineEndingFormat === LineEndingFormat.WINDOWS)
-        return transformLinuxToWindows(fileContents);
-    if (targetLineEndingFormat === LineEndingFormat.LINUX)
-        return transformWindowsToLinux(fileContents);
-    // This line is unreachable, but Typescript doesn't know it because of LineEndingFormat.UNKNOWN.
-    return Buffer.from('');
-}
-function getSingleDigest(fileContents) {
-    if (hashAlgorithm == 'md5') {
-        const hash = crypto.createHash(hashAlgorithm).update(fileContents);
-        return hash.digest('base64').replace(regex, '');
-    }
-    else {
-        // Placeholder for other planned hash algorithms, e.g. xxhash
-        // return xxhash.hash64(fileContents, 0xcafebabe).digest();
-        return '';
-    }
-}
-//# sourceMappingURL=dubhash.js.map
-
-/***/ }),
-
 /***/ 75933:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -172936,6 +172759,62 @@ exports.getTarget = getTarget;
 
 /***/ }),
 
+/***/ 42099:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.computeUHash = exports.computeSingleHash = exports.getHashSignature = void 0;
+const crypto = __webpack_require__(76417);
+const binary_1 = __webpack_require__(75766);
+const format_1 = __webpack_require__(72600);
+var DigestFormat;
+(function (DigestFormat) {
+    DigestFormat["BASE64"] = "base64";
+    DigestFormat["HEX"] = "hex";
+})(DigestFormat || (DigestFormat = {}));
+var HashAlgorithm;
+(function (HashAlgorithm) {
+    HashAlgorithm["MD5"] = "md5";
+    HashAlgorithm["OTHER"] = "other";
+})(HashAlgorithm || (HashAlgorithm = {}));
+const usedHashAlgorithm = HashAlgorithm.MD5;
+async function getHashSignature(path, content) {
+    const hashes = await Promise.all([
+        computeSingleHash(content),
+        computeUHash(content),
+    ]);
+    return {
+        path: path,
+        size: content.length,
+        hashes_ffm: hashes,
+    };
+}
+exports.getHashSignature = getHashSignature;
+async function computeSingleHash(content) {
+    const hash = crypto.createHash(usedHashAlgorithm).update(content);
+    const base64Digest = hash.digest(DigestFormat.BASE64).replace(/=/g, '');
+    return {
+        data: base64Digest,
+        format: 1,
+    };
+}
+exports.computeSingleHash = computeSingleHash;
+async function computeUHash(content) {
+    const file = binary_1.isBinary(content) ? content : format_1.removeWhitespaces(content);
+    const hash = crypto.createHash(usedHashAlgorithm).update(file);
+    const hexDigest = hash.digest(DigestFormat.HEX).slice(0, 24);
+    return {
+        data: hexDigest,
+        format: 3,
+    };
+}
+exports.computeUHash = computeUHash;
+//# sourceMappingURL=hash.js.map
+
+/***/ }),
+
 /***/ 96957:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -172978,7 +172857,7 @@ async function scan(options) {
         const start = Date.now();
         const filePaths = await find_1.find(options.path);
         debug_1.debug('%d files found \n', filePaths.length);
-        const allSignatures = await signatures_1.getSignaturesByAlgorithm(filePaths);
+        const allSignatures = await signatures_1.getSignatures(filePaths);
         const filteredSignatures = allSignatures.filter((s) => {
             return s !== null;
         });
@@ -173038,115 +172917,115 @@ exports.scan = scan;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getSignaturesByAlgorithm = void 0;
+exports.getSignatures = void 0;
 const fs_1 = __webpack_require__(35747);
-const dubhash_1 = __webpack_require__(82635);
-const uhash_1 = __webpack_require__(40);
+const hash_1 = __webpack_require__(42099);
 const pMap = __webpack_require__(81334);
 const { readFile } = fs_1.promises;
-async function getSignaturesByAlgorithm(filePaths, hashType = 'dubhash') {
-    if (hashType !== 'dubhash' && hashType !== 'uhash') {
-        throw new Error(`Unsupported hashType ${hashType}`);
-    }
-    let signatureMapperToBeUsed = getDubHashSignatureMapper;
-    if (hashType === 'uhash') {
-        signatureMapperToBeUsed = getUHashSignatureMapper;
-    }
-    return await pMap(filePaths, signatureMapperToBeUsed, { concurrency: 20 });
-}
-exports.getSignaturesByAlgorithm = getSignaturesByAlgorithm;
-async function getDubHashSignatureMapper(filePath) {
-    const fileContents = await readFile(filePath);
-    if (fileContents.length === 0)
-        return null;
-    return dubhash_1.getDubHashSignature(filePath, fileContents);
-}
-async function getUHashSignatureMapper(filePath) {
-    const fileContents = await readFile(filePath);
-    if (fileContents.length === 0)
-        return null;
-    return uhash_1.getUhashSignature(filePath, fileContents);
+async function getSignatures(paths) {
+    return pMap(paths, async (path) => {
+        const content = await readFile(path);
+        return content.length > 0 ? await hash_1.getHashSignature(path, content) : null;
+    }, { concurrency: 20 });
 }
+exports.getSignatures = getSignatures;
 //# sourceMappingURL=signatures.js.map
 
 /***/ }),
 
-/***/ 40:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 75766:
+/***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getUhashSignature = void 0;
-// This module implements the "uhash" signature specification described in docs/signature_specification.md
-const crypto = __webpack_require__(76417);
-const binary_1 = __webpack_require__(75766);
-const hashAlgorithm = 'md5';
-const Utf8Bom = Buffer.from(new Uint8Array([0xef, 0xbb, 0xbf]));
-function getUhashSignature(filePath, fileContents) {
-    const digest = getUhashDigest(fileContents, binary_1.isBinary(fileContents));
-    const data = digest.slice(0, 24);
-    return {
-        path: filePath,
-        hashes_ffm: [
-            {
-                data,
-                format: 3,
-            },
-        ],
-    };
-}
-exports.getUhashSignature = getUhashSignature;
-function getUhashDigest(fileContents, isBinary) {
-    if (hashAlgorithm !== 'md5') {
-        // placeholder for non-md5 hashing algorithm, e.g. xxhash
-        throw new Error(`hashAlgorithm ${hashAlgorithm} is not supported`);
-    }
-    const file = isBinary ? fileContents : removeUnwantedBytes(fileContents);
-    const hash = crypto.createHash(hashAlgorithm).update(file);
-    return hash.digest('hex');
-}
-function removeUnwantedBytes(fileBuffer) {
-    const startingIndex = isUtf8BomPresent(fileBuffer) ? 3 : 0;
-    return removeWhitespaceBytewise(fileBuffer, startingIndex);
-}
-function isUtf8BomPresent(fileBuffer) {
-    if (fileBuffer.length < 3)
-        return false;
-    return Utf8Bom.compare(fileBuffer.subarray(0, 3)) === 0;
-}
-function includeChar(c) {
-    return (c > 0x20 ||
-        (c != 0x20 && c != 0x0d && c != 0x0a && c != 0x09 && c != 0x0b && c != 0x0c));
-}
-function removeWhitespaceBytewise(fileBuffer, startingIndex) {
-    let writeIndex = 0;
-    for (let readIndex = startingIndex; readIndex < fileBuffer.length; readIndex++) {
-        const c = fileBuffer[readIndex];
-        if (includeChar(c)) {
-            fileBuffer[writeIndex] = c;
-            writeIndex++;
-        }
-    }
-    return fileBuffer.slice(0, writeIndex);
+exports.isBinary = void 0;
+function isBinary(content) {
+    return content.includes(0);
 }
-//# sourceMappingURL=uhash.js.map
+exports.isBinary = isBinary;
+//# sourceMappingURL=binary.js.map
 
 /***/ }),
 
-/***/ 75766:
+/***/ 72600:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isBinary = void 0;
-function isBinary(fileBuffer) {
-    // The spec defines a binary file as anything containing a null byte
-    return fileBuffer.includes(0);
+exports.removeWhitespaces = exports.removeWhitespaceBytewise = exports.isNotWhiteSpace = exports.isUtf8BomPresent = void 0;
+const Utf8Bom = Buffer.from(new Uint8Array([0xef, 0xbb, 0xbf]));
+const asciiChars = {
+    space: 0x20,
+    carriageReturn: 0x0d,
+    newLine: 0x0a,
+    horizontalTab: 0x09,
+    verticalTab: 0x0b,
+    newPage: 0x0c,
+};
+/**
+ * Check if the UTF-8 BOM is present in the first three bytes
+ *
+ * @param {FileContent} content
+ * @returns {boolean}
+ */
+function isUtf8BomPresent(content) {
+    if (content.length < 3) {
+        return false;
+    }
+    return Utf8Bom.compare(content.subarray(0, 3)) === 0;
 }
-exports.isBinary = isBinary;
-//# sourceMappingURL=binary.js.map
+exports.isUtf8BomPresent = isUtf8BomPresent;
+/**
+ * Check if char is not whitespace
+ *
+ * @param {number} char
+ * @returns {boolean}
+ */
+function isNotWhiteSpace(char) {
+    return (char > asciiChars.space ||
+        (char != asciiChars.space &&
+            char != asciiChars.carriageReturn &&
+            char != asciiChars.newLine &&
+            char != asciiChars.horizontalTab &&
+            char != asciiChars.verticalTab &&
+            char != asciiChars.newPage));
+}
+exports.isNotWhiteSpace = isNotWhiteSpace;
+/**
+ * Remove whitespaces from the file
+ *
+ * @param {FileContent} content
+ * @param {number} startingIndex
+ * @returns {FileContent}
+ */
+function removeWhitespaceBytewise(content, startingIndex) {
+    let writeIndex = 0;
+    for (let readIndex = startingIndex; readIndex < content.length; readIndex++) {
+        const c = content[readIndex];
+        if (isNotWhiteSpace(c)) {
+            content[writeIndex] = c;
+            writeIndex++;
+        }
+    }
+    return content.slice(0, writeIndex);
+}
+exports.removeWhitespaceBytewise = removeWhitespaceBytewise;
+/**
+ * Remove unwanted bytes from the file
+ *
+ * If it is UTF-8 BOM we start parsing the file content from index 3
+ *
+ * @param {FileContent} content
+ * @returns {FileContent}
+ */
+function removeWhitespaces(content) {
+    const startingIndex = isUtf8BomPresent(content) ? 3 : 0;
+    return removeWhitespaceBytewise(content, startingIndex);
+}
+exports.removeWhitespaces = removeWhitespaces;
+//# sourceMappingURL=format.js.map
 
 /***/ }),