feat: add offset

Author: Lars Kölpin-Freese

src/index.spec.ts

@@ -4,8 +4,15 @@ import {
   filetypemime,
   filetypeextension
 } from "./index";
+import * as fs from "fs";
 
 describe("Tests the public API", () => {
+  it("detects tar with offset", () => {
+    const buffer = fs.readFileSync(require.resolve("./testfiles/a.tar"));
+    const bytes = Array.prototype.slice.call(buffer, 0);
+    expect(filetypeinfo(bytes)).toHaveLength(1);
+  });
+
   it("filetypeinfo", () => {
     const bytes = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
     expect(filetypeinfo(bytes)).toHaveLength(1);

src/index.ts

@@ -1,31 +1,51 @@
 import patternTree from "./pattern-tree.snapshot";
-import { Leaf, Node } from "./model/tree";
+import { GuessedFile, Node, Tree } from "./model/tree";
+import { fromHex, toHex } from "./model/toHex";
 
-const hex = num => new Number(num).toString(16).toLowerCase();
-const toHex = num => `0x${hex(num).length === 1 ? "0" + hex(num) : hex(num)}`;
-
-export const filetypeinfo = (bytes: number[]): Leaf[] => {
+export const filetypeinfo = (bytes: number[]): GuessedFile[] => {
   let currentByteIndex = 0;
-  let guessFile = [];
-  let step: Node = patternTree;
+  let tree: Tree = patternTree;
+  let step = tree.noOffset;
+
+  for (const k of Object.keys(tree.offset)) {
+    const offset = fromHex(k);
+    const offsetExceedsFile = offset >= bytes.length;
+    if (offsetExceedsFile) {
+      continue;
+    }
+    const node = patternTree.offset[k];
+    const guessed = walkTree(offset, bytes, node);
+    if (guessed.length > 0) {
+      return guessed;
+    }
+  }
+  return walkTree(0, bytes, tree.noOffset);
+};
+
+const walkTree = (
+  index: number,
+  bytes: number[],
+  node: Node
+): GuessedFile[] => {
+  let step: Node = node;
+  let guessFile: GuessedFile[] = [];
   while (true) {
-    const currentByte = toHex(bytes[currentByteIndex]);
+    const currentByte = toHex(bytes[index]);
     if (step.bytes["?"] && !step.bytes[currentByte]) {
       step = step.bytes["?"];
     } else {
       step = step.bytes[currentByte];
     }
-
     if (!step) {
       return guessFile;
     }
     if (step && step.matches) {
       guessFile = step.matches;
     }
-    currentByteIndex += 1;
+    index += 1;
   }
-  return [];
 };
+
 export default filetypeinfo;
 
 export const filetypename = (bytes: any[]): string[] =>

src/model/pattern-tree.ts

@@ -1,9 +1,12 @@
-import { createComplexTree, createNode, Info, merge } from "./tree";
-import { Node } from "./tree";
+import { createComplexNode, createNode, Info, merge, Tree } from "./tree";
+import { toHex } from "./toHex";
 
 // https://en.wikipedia.org/wiki/List_of_file_signatures
 let fileType = new Map();
-let tree: Node | null = null;
+let tree: Tree = {
+  noOffset: null,
+  offset: {}
+};
 
 type TypeName = string;
 type Signature = string[];
@@ -16,22 +19,40 @@ const add = (
 ) => {
   fileType.set(typename, signature);
   if (offset) {
-  }
-  if (tree === null) {
-    tree = createComplexTree(
-      typename,
-      signature.map(e => e.toLowerCase()),
-      additionalInfo
-    );
+    const existing = tree.offset[toHex(offset)];
+    if (!existing) {
+      tree.offset[toHex(offset)] = createComplexNode(
+        typename,
+        signature.map(e => e.toLowerCase()),
+        additionalInfo
+      );
+    } else {
+      tree.offset[toHex(offset)] = merge(
+        createNode(
+          typename,
+          signature.map(e => e.toLowerCase()),
+          additionalInfo
+        ),
+        tree.offset[toHex(offset)]
+      );
+    }
   } else {
-    tree = merge(
-      createNode(
+    if (tree.noOffset === null) {
+      tree.noOffset = createComplexNode(
         typename,
         signature.map(e => e.toLowerCase()),
         additionalInfo
-      ),
-      tree
-    );
+      );
+    } else {
+      tree.noOffset = merge(
+        createNode(
+          typename,
+          signature.map(e => e.toLowerCase()),
+          additionalInfo
+        ),
+        tree.noOffset
+      );
+    }
   }
 };
 
@@ -657,4 +678,4 @@ add("mpeg", ["0x00", "0x00", "0x01", "0xB3"], {
 
 add("hl2demo", ["48", "4C", "32", "44", "45", "4D", "4F"]);
 
-export default (): Node | null => tree as Node | null;
+export default (): Tree | null => tree as Tree;

src/model/toHex.ts

@@ -0,0 +1,4 @@
+const hex = (num: number) => new Number(num).toString(16).toLowerCase();
+export const toHex = (num: number): string =>
+  `0x${hex(num).length === 1 ? "0" + hex(num) : hex(num)}`;
+export const fromHex = (hex: string) => new Number(hex) as number;

src/model/tree.spec.ts

@@ -1,14 +1,14 @@
-import { merge, createNode, createComplexTree } from "./tree";
+import { merge, createNode, createComplexNode } from "./tree";
 
 describe("tree", () => {
   it("Creates complex node", () => {
-    const tree = createComplexTree("mpe", ["0x00", "0x01"]);
+    const tree = createComplexNode("mpe", ["0x00", "0x01"]);
     expect(tree.bytes["0x00"].bytes["0x01"]).toHaveProperty("matches");
     expect(tree.bytes["0x00"].bytes["0x01"]["matches"][0].typename).toBe("mpe");
   });
 
   it("Merges trees", () => {
-    const tree = createComplexTree("pic", ["0x00"]);
+    const tree = createComplexNode("pic", ["0x00"]);
     const dba = createNode("dba", ["0x00", "0x01", "0x02", "0x03"]);
     const merged = merge(dba, tree);
     expect(merged.bytes["0x00"].matches[0].typename).toBe("pic");
@@ -19,14 +19,14 @@ describe("tree", () => {
   });
 
   it("Merges overlapping", () => {
-    const tree = createComplexTree("pic", ["0x00"]);
+    const tree = createComplexNode("pic", ["0x00"]);
     const dba = createNode("pif", ["0x00"]);
     const merged = merge(dba, tree);
     expect(merged.bytes["0x00"].matches).toHaveLength(2);
   });
 
   it("Merges deep overlapping", () => {
-    const gifA = createComplexTree(
+    const gifA = createComplexNode(
       "gif",
       ["0x47", "0x49", "0x46", "0x38", "0x37", "0x61"],
       { mime: "image/gif", extension: "gif" }
@@ -43,7 +43,6 @@ describe("tree", () => {
     );
     const mergeA = merge(gifB, gifA);
     const mergeB = merge(gifC, mergeA);
-    console.log(JSON.stringify(mergeB));
     expect(
       mergeB.bytes["0x47"].bytes["0x49"].bytes["0x46"].bytes["0x38"].bytes[
         "0x37"

src/model/tree.ts

@@ -7,7 +7,7 @@ export type NewNode = PathlessNewNode & {
   bytes: string[];
 };
 
-export type Leaf = Info & {
+export type GuessedFile = Info & {
   typename: string;
 };
 
@@ -17,13 +17,18 @@ export type Info = {
 };
 
 export type Node = {
-  matches?: Leaf[];
+  matches?: GuessedFile[];
   bytes: {
     [nextbyte: string]: Node;
   };
 };
 
-const toLeaf = (leaf: PathlessNewNode): Leaf => ({
+export type Tree = {
+  noOffset: Node | null;
+  offset: { [offsetByte: string]: Node };
+};
+
+const toLeaf = (leaf: PathlessNewNode): GuessedFile => ({
   typename: leaf.typename,
   mime: leaf.info.mime,
   extension: leaf.info.extension
@@ -66,7 +71,7 @@ export const merge = (node: NewNode, tree: Node): Node => {
   if (!tree.bytes[currentByte]) {
     tree.bytes[currentByte] = {
       ...tree.bytes[currentByte],
-      ...createComplexTree(node.typename, path, node.info)
+      ...createComplexNode(node.typename, path, node.info)
     };
   }
   return tree;
@@ -80,7 +85,7 @@ export const createNode = (
   return { typename, bytes, info: info ? info : {} };
 };
 
-export const createComplexTree = (
+export const createComplexNode = (
   typename: string,
   bytes: string[],
   info?: Info
@@ -102,6 +107,6 @@ export const createComplexTree = (
       bytes: {}
     };
   }
-  obj.bytes[currentKey] = createComplexTree(typename, path, info);
+  obj.bytes[currentKey] = createComplexNode(typename, path, info);
   return obj;
 };