sigcheck 1.0.1

package/dist/core/file-types/audio.d.ts

@@ -0,0 +1,12 @@
+import { FileInfo } from "../types/file-info";
+/**
+ * Audio files information with their unique signatures
+ */
+export declare class AudioTypes {
+    static AAC: FileInfo;
+    static AMR: FileInfo;
+    static FLAC: FileInfo;
+    static M4A: FileInfo;
+    static MP3: FileInfo;
+    static WAV: FileInfo;
+}

package/dist/core/file-types/audio.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioTypes = void 0;
+/**
+ * Audio files information with their unique signatures
+ */
+class AudioTypes {
+}
+exports.AudioTypes = AudioTypes;
+AudioTypes.AAC = {
+    extension: "aac",
+    mimeType: "audio/aac",
+    description: "Advanced Audio Coding (AAC) is an audio coding standard for lossy digital audio compression",
+    signatures: [
+        {
+            sequence: [0xff, 0xf1],
+            description: "MPEG-4 Advanced Audio Coding (AAC) Low Complexity (LC) audio file",
+        },
+        {
+            sequence: [0xff, 0xf9],
+            description: "MPEG-2 Advanced Audio Coding (AAC) Low Complexity (LC) audio file",
+        },
+    ],
+};
+AudioTypes.AMR = {
+    extension: "amr",
+    mimeType: "audio/amr",
+    description: "Adaptive Multi-Rate ACELP (Algebraic Code Excited Linear Prediction) Codec, commonly audio format with GSM cell phones",
+    signatures: [
+        {
+            sequence: [0x23, 0x21, 0x41, 0x4d, 0x52],
+        },
+    ],
+};
+AudioTypes.FLAC = {
+    extension: "flac",
+    mimeType: "audio/x-flac",
+    description: "Free Lossless Audio Codec file",
+    signatures: [
+        {
+            sequence: [0x66, 0x4c, 0x61, 0x43, 0x00, 0x00, 0x00, 0x22],
+        },
+    ],
+};
+AudioTypes.M4A = {
+    extension: "m4a",
+    mimeType: "audio/x-m4a",
+    description: "Apple Lossless Audio Codec file",
+    signatures: [
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x4d, 0x34, 0x41, 0x20],
+            offset: 4,
+            compatibleExtensions: ["aac"],
+        },
+    ],
+};
+AudioTypes.MP3 = {
+    extension: "mp3",
+    mimeType: "audio/mpeg",
+    description: "A digital audio file format that uses compression to reduce file size while maintaining high quality sound",
+    signatures: [
+        {
+            sequence: [0xff, 0xfb],
+            description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)",
+        },
+        {
+            sequence: [0xff, 0xf3],
+            description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)",
+        },
+        {
+            sequence: [0xff, 0xf2],
+            description: "MPEG-1 Layer 3 file without an ID3 tag or with an ID3v1 tag (which is appended at the end of the file)",
+        },
+        {
+            sequence: [0x49, 0x44, 0x33],
+            description: "MP3 file with an ID3v2 container",
+        },
+    ],
+};
+AudioTypes.WAV = {
+    extension: "wav",
+    mimeType: "audio/wav",
+    description: "Waveform Audio File Format",
+    signatures: [
+        {
+            sequence: [
+                0x52, 0x49, 0x46, 0x46, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74,
+                0x20,
+            ],
+            skippedBytes: [4, 5, 6, 7],
+        },
+    ],
+};

package/dist/core/file-types/compressed.d.ts

@@ -0,0 +1,10 @@
+import { FileInfo } from "../types/file-info";
+/**
+ * Compressed files information with their unique signatures
+ */
+export declare class CompressedTypes {
+    static _7Z: FileInfo;
+    static LZH: FileInfo;
+    static RAR: FileInfo;
+    static ZIP: FileInfo;
+}

package/dist/core/file-types/compressed.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressedTypes = void 0;
+/**
+ * Compressed files information with their unique signatures
+ */
+class CompressedTypes {
+}
+exports.CompressedTypes = CompressedTypes;
+CompressedTypes._7Z = {
+    extension: "7z",
+    mimeType: "application/x-7z-compressed",
+    description: "7-Zip compressed file",
+    signatures: [
+        {
+            sequence: [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c],
+        },
+    ],
+};
+CompressedTypes.LZH = {
+    extension: "lzh",
+    mimeType: "application/x-lzh-compressed",
+    description: "Compressed file using Lempel-Ziv and Haruyasu (LZH) compression algorithm",
+    signatures: [
+        {
+            sequence: [0x2d, 0x68, 0x6c, 0x30, 0x2d],
+            description: "Lempel Ziv Huffman archive file Method 0 (No compression)",
+            compatibleExtensions: ["lha"],
+        },
+        {
+            sequence: [0x2d, 0x68, 0x6c, 0x35, 0x2d],
+            description: "Lempel Ziv Huffman archive file Method 5 (8KiB sliding window)",
+            compatibleExtensions: ["lha"],
+        },
+    ],
+};
+CompressedTypes.RAR = {
+    extension: "rar",
+    mimeType: "application/x-rar-compressed",
+    description: "Roshal ARchive compressed archive file",
+    signatures: [
+        {
+            sequence: [0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00],
+            description: "Compressed archive v5.00 onwards",
+        },
+        {
+            sequence: [0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x01, 0x00],
+            description: "Compressed archive v1.50 onwards",
+        },
+    ],
+};
+CompressedTypes.ZIP = {
+    extension: "zip",
+    mimeType: "application/zip",
+    description: "Compressed archive file",
+    signatures: [
+        {
+            sequence: [0x57, 0x69, 0x6e, 0x5a, 0x69, 0x70],
+            offset: 29152,
+            description: "WinZip compressed archive",
+        },
+        {
+            sequence: [
+                0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x01, 0x00, 0x63, 0x00, 0x00,
+                0x00, 0x00, 0x00,
+            ],
+            description: "ZLock Pro encrypted ZIP",
+        },
+        {
+            sequence: [0x50, 0x4b, 0x4c, 0x49, 0x54, 0x45],
+            offset: 30,
+            description: "PKLITE compressed ZIP archive (see also PKZIP)",
+        },
+        {
+            sequence: [0x50, 0x4b, 0x53, 0x70, 0x58],
+            offset: 526,
+            description: "PKSFX self-extracting executable compressed file (see also PKZIP)",
+        },
+        {
+            sequence: [0x50, 0x4b, 0x03, 0x04],
+            description: "PKZIP archive file - zip file format and multiple formats based on it",
+            compatibleExtensions: [
+                "aar",
+                "apk",
+                "docx",
+                "epub",
+                "ipa",
+                "jar",
+                "kmz",
+                "maff",
+                "msix",
+                "odp",
+                "ods",
+                "odt",
+                "pk3",
+                "pk4",
+                "pptx",
+                "usdz",
+                "vsdx",
+                "xlsx",
+                "xpi",
+            ],
+        },
+        {
+            sequence: [0x50, 0x4b, 0x05, 0x06],
+            description: "PKZIP empty archive file - zip file format and multiple formats based on it",
+            compatibleExtensions: [
+                "aar",
+                "apk",
+                "docx",
+                "epub",
+                "ipa",
+                "jar",
+                "kmz",
+                "maff",
+                "msix",
+                "odp",
+                "ods",
+                "odt",
+                "pk3",
+                "pk4",
+                "pptx",
+                "usdz",
+                "vsdx",
+                "xlsx",
+                "xpi",
+            ],
+        },
+        {
+            sequence: [0x50, 0x4b, 0x07, 0x08],
+            description: "PKZIP multivolume archive file - zip file format and multiple formats based on it",
+            compatibleExtensions: [
+                "aar",
+                "apk",
+                "docx",
+                "epub",
+                "ipa",
+                "jar",
+                "kmz",
+                "maff",
+                "msix",
+                "odp",
+                "ods",
+                "odt",
+                "pk3",
+                "pk4",
+                "pptx",
+                "usdz",
+                "vsdx",
+                "xlsx",
+                "xpi",
+            ],
+        },
+    ],
+};

package/dist/core/file-types/image.d.ts

@@ -0,0 +1,22 @@
+import { FileInfo } from "../types/file-info";
+/**
+ * Image files information with their unique signatures
+ */
+export declare class ImageTypes {
+    static AVIF: FileInfo;
+    static BMP: FileInfo;
+    static BPG: FileInfo;
+    static CR2: FileInfo;
+    static EXR: FileInfo;
+    static GIF: FileInfo;
+    static HEIC: FileInfo;
+    static ICO: FileInfo;
+    static JPEG: FileInfo;
+    static PBM: FileInfo;
+    static PGM: FileInfo;
+    static PNG: FileInfo;
+    static PPM: FileInfo;
+    static PSD: FileInfo;
+    static TIFF: FileInfo;
+    static WEBP: FileInfo;
+}

package/dist/core/file-types/image.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageTypes = void 0;
+/**
+ * Image files information with their unique signatures
+ */
+class ImageTypes {
+}
+exports.ImageTypes = ImageTypes;
+ImageTypes.AVIF = {
+    extension: "avif",
+    mimeType: "image/avif",
+    description: "Alliance for Open Media (AOMedia) Video 1 (AV1) Image File",
+    signatures: [
+        {
+            sequence: [0x00, 0x00, 0x00],
+        },
+    ],
+};
+ImageTypes.BMP = {
+    extension: "bmp",
+    mimeType: "image/bmp",
+    description: "A bitmap format used mostly in Windows",
+    signatures: [
+        {
+            sequence: [0x42, 0x4d],
+            compatibleExtensions: ["dib"],
+        },
+    ],
+};
+ImageTypes.BPG = {
+    extension: "bpg",
+    mimeType: "image/bpg",
+    description: "Better Portable Graphics image format",
+    signatures: [
+        {
+            sequence: [0x42, 0x50, 0x47, 0xfb],
+        },
+    ],
+};
+ImageTypes.CR2 = {
+    extension: "cr2",
+    mimeType: "image/x-canon-cr2",
+    description: "Canon digital camera RAW file",
+    signatures: [
+        {
+            sequence: [0x49, 0x49, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x43, 0x52],
+        },
+    ],
+};
+ImageTypes.EXR = {
+    extension: "exr",
+    mimeType: "image/x-exr",
+    description: "OpenEXR bitmap image format",
+    signatures: [
+        {
+            sequence: [0x76, 0x2f, 0x31, 0x01],
+        },
+    ],
+};
+ImageTypes.GIF = {
+    extension: "gif",
+    mimeType: "image/gif",
+    description: "Image file encoded in the Graphics Interchange Format (GIF)",
+    signatures: [
+        {
+            sequence: [0x47, 0x49, 0x46, 0x38, 0x37, 0x61],
+        },
+        {
+            sequence: [0x47, 0x49, 0x46, 0x38, 0x39, 0x61],
+        },
+    ],
+};
+ImageTypes.HEIC = {
+    extension: "heic",
+    mimeType: "image/heic",
+    description: "A variant of the HEIF (High Efficiency Image Format) that store images on the latest Apple devices.",
+    signatures: [
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63],
+            offset: 4,
+        },
+        {
+            sequence: [0x66, 0x74, 0x79, 0x70, 0x6d],
+            offset: 4,
+        },
+    ],
+};
+ImageTypes.ICO = {
+    extension: "ico",
+    mimeType: "image/x-icon",
+    description: "Computer icon encoded in ICO file format",
+    signatures: [
+        {
+            sequence: [0x00, 0x00, 0x01, 0x00],
+            compatibleExtensions: ["spl"],
+        },
+    ],
+};
+ImageTypes.JPEG = {
+    extension: "jpeg",
+    mimeType: "image/jpeg",
+    description: "JPEG (Joint Photographic Experts Group) is a widely used lossy image compression format.",
+    signatures: [
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xe1, 0x45, 0x78, 0x69, 0x66, 0x00],
+            skippedBytes: [4, 5],
+            description: "Digital camera JPG using Exchangeable Image File Format (EXIF)",
+        },
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xe8, 0x53, 0x50, 0x49, 0x46, 0x46, 0x00],
+            skippedBytes: [4, 5],
+            description: "Still Picture Interchange File Format (SPIFF)",
+        },
+        {
+            sequence: [
+                0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00,
+                0x00,
+            ],
+            description: "JPEG raw or in the JFIF or Exif file format",
+        },
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xee],
+            description: "JPEG raw or in the JFIF or Exif file format",
+        },
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xe1, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00],
+            skippedBytes: [4, 5],
+            description: "JPEG raw or in the JFIF or Exif file format",
+        },
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xe0, 0x4a, 0x46, 0x49, 0x46, 0x00],
+            skippedBytes: [4, 5],
+            description: "JPEG/JFIF graphics file",
+            compatibleExtensions: ["jfif", "jpe"],
+        },
+        {
+            sequence: [0xff, 0xd8, 0xff, 0xe0],
+            description: "JPEG raw or in the JFIF or Exif file format",
+        },
+        {
+            sequence: [0xff, 0xd8],
+            description: "Generic JPEGimage file",
+            compatibleExtensions: ["jpe"],
+        },
+    ],
+};
+ImageTypes.PBM = {
+    extension: "pbm",
+    mimeType: "image/x-portable-bitmap",
+    description: "PBM (Portable Bitmap) is a simple monochrome bitmap image format that uses plain text ASCII characters to represent binary image data",
+    signatures: [
+        {
+            sequence: [0x50, 0x31, 0x0a],
+            description: "Portable bitmap ASCII",
+        },
+        {
+            sequence: [0x50, 0x34, 0x0a],
+            description: "Portable bitmap binary",
+        },
+    ],
+};
+ImageTypes.PGM = {
+    extension: "pgm",
+    mimeType: "image/x-portable-graymap",
+    description: "PGM (Portable Graymap) is a simple grayscale image format that uses ASCII text characters to represent binary image data.",
+    signatures: [
+        {
+            sequence: [0x50, 0x32, 0x0a],
+            description: "Portable Gray Map ASCII",
+        },
+        {
+            sequence: [0x50, 0x35, 0x0a],
+            description: "Portable Gray Map binary",
+        },
+    ],
+};
+ImageTypes.PNG = {
+    extension: "png",
+    mimeType: "image/png",
+    description: "PNG (Portable Network Graphics) is a lossless image compression format that supports a wide range of color depths and transparency and is widely used for high-quality graphics.",
+    signatures: [
+        {
+            sequence: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
+        },
+    ],
+};
+ImageTypes.PPM = {
+    extension: "ppm",
+    mimeType: "image/x-portable-pixmap",
+    description: "PPM (Portable Pixmap) is a simple color image format in the Portable Network Graphics (PNG) suite.",
+    signatures: [
+        {
+            sequence: [0x50, 0x33, 0x0a],
+            description: "Portable Pixmap ASCII",
+        },
+        {
+            sequence: [0x50, 0x36, 0x0a],
+            description: "Portable Pixmap binary",
+        },
+    ],
+};
+ImageTypes.PSD = {
+    extension: "psd",
+    mimeType: "image/vnd.adobe.photoshop",
+    description: "PSD (Photoshop Document) is an Adobe Photoshop image file format",
+    signatures: [
+        {
+            sequence: [0x38, 0x42, 0x50, 0x53],
+        },
+    ],
+};
+ImageTypes.TIFF = {
+    extension: "tiff",
+    mimeType: "image/tiff",
+    description: "TIFF is a raster image format used for high-quality scanning, publishing, and photography",
+    signatures: [
+        {
+            sequence: [0x49, 0x49, 0x2a, 0x00],
+            compatibleExtensions: ["tif"],
+        },
+        {
+            sequence: [0x4d, 0x4d, 0x00, 0x2a],
+            compatibleExtensions: ["tif"],
+        },
+        {
+            sequence: [0x49, 0x49, 0x2b, 0x00],
+            compatibleExtensions: ["tif"],
+            description: "BigTIFF files. Tagged Image File Format files > 4 GB",
+        },
+        {
+            sequence: [0x4d, 0x4d, 0x00, 0x2b],
+            compatibleExtensions: ["tif"],
+            description: "BigTIFF files. Tagged Image File Format files > 4 GB",
+        },
+    ],
+};
+ImageTypes.WEBP = {
+    extension: "webp",
+    mimeType: "image/webp",
+    description: "A modern image format that provides superior lossless and lossy compression for images on the web",
+    signatures: [
+        {
+            sequence: [0x52, 0x49, 0x46, 0x46, 0x57, 0x45, 0x42, 0x50],
+            skippedBytes: [4, 5, 6, 7],
+        },
+    ],
+};

package/dist/core/file-types/index.d.ts

@@ -0,0 +1,109 @@
+import { DetectedFileInfo } from "../interfaces/dto";
+import { FileInfo, FileSignature } from "../types";
+export declare const FILE_TYPES_REQUIRED_ADDITIONAL_CHECK: Array<string>;
+/**
+ * A class hold all supported file typs with their unique signatures
+ */
+export declare class FileTypes {
+    static AAC: FileInfo;
+    static AMR: FileInfo;
+    static FLAC: FileInfo;
+    static M4A: FileInfo;
+    static MP3: FileInfo;
+    static WAV: FileInfo;
+    static AVIF: FileInfo;
+    static BMP: FileInfo;
+    static BPG: FileInfo;
+    static CR2: FileInfo;
+    static EXR: FileInfo;
+    static GIF: FileInfo;
+    static HEIC: FileInfo;
+    static ICO: FileInfo;
+    static JPEG: FileInfo;
+    static PBM: FileInfo;
+    static PGM: FileInfo;
+    static PNG: FileInfo;
+    static PPM: FileInfo;
+    static PSD: FileInfo;
+    static TIFF: FileInfo;
+    static WEBP: FileInfo;
+    static AVI: FileInfo;
+    static FLV: FileInfo;
+    static M4V: FileInfo;
+    static MKV: FileInfo;
+    static MOV: FileInfo;
+    static MP4: FileInfo;
+    static OGG: FileInfo;
+    static SWF: FileInfo;
+    static WEBM: FileInfo;
+    static _7Z: FileInfo;
+    static LZH: FileInfo;
+    static RAR: FileInfo;
+    static ZIP: FileInfo;
+    static BLEND: FileInfo;
+    static DOC: FileInfo;
+    static ELF: FileInfo;
+    static EXE: FileInfo;
+    static INDD: FileInfo;
+    static MACHO: FileInfo;
+    static ORC: FileInfo;
+    static PARQUET: FileInfo;
+    static PCAP: FileInfo;
+    static PDF: FileInfo;
+    static PS: FileInfo;
+    static RTF: FileInfo;
+    static SQLITE: FileInfo;
+    static STL: FileInfo;
+    static TTF: FileInfo;
+    /**
+     * Receive information on a file type by its property name from FileTypes class
+     *
+     * @param propertyName Property name from FileTypes class
+     *
+     * @returns {FileInfo} File type information
+     */
+    static getInfoByName(propertyName: string): FileInfo;
+    /**
+     * Receive an array of file type signatures by its property name from FileTypes class
+     *
+     * @param propertyName Property name from FileTypes class
+     *
+     * @returns {Array<FileSignature>} All unique signatures with their information
+     */
+    static getSignaturesByName(propertyName: string): Array<FileSignature>;
+    /**
+     * Determine if a valid signature exist in a file chunk
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param acceptedSignatures Valid signatures to search for in fileChunk
+     *
+     * @returns {boolean} True if found a valid signature inside the chunk, otherwise false
+     */
+    static detectSignature(fileChunk: Array<number>, acceptedSignatures: Array<FileSignature>): FileSignature | undefined;
+    /**
+     * Perfomrs an additional check for detected file types by their unique structure
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param detectedFiles A list of detected files
+     * @returns {string | undefined} File type extension if found, otherwise undefined
+     */
+    static detectTypeByAdditionalCheck(fileChunk: Array<number>, detectedFiles: Array<DetectedFileInfo | FileInfo>): string | undefined;
+    /**
+     * Determine if a file chunk contains a valid signature and return the file signature if exist
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param acceptedSignatures Valid signatures to search for in fileChunk
+     *
+     * @returns {FileSignature | undefined } FileSignature if found a valid signature, otherwise undefined
+     */
+    static detectbBySignatures(fileChunk: Array<number>, acceptedSignatures: Array<FileSignature>): FileSignature | undefined;
+    /**
+     * Determine if file content contains a valid signature of a required type
+     *
+     * @param fileChunk A chunk from the beginning of a file content, represents in array of numbers
+     * @param type The file type to match against
+     *
+     * @returns {boolean} True if found a signature of the type in file content, otherwise false
+     */
+    static checkByFileType(fileChunk: Array<number>, type: string): boolean;
+}