Imported Upstream version 1.2.2-1
[packages/binwalk.git] / binwalk / magic / binwalk
1 # ----------------------------Archive Formats--------------------------------------
2
3 # POSIX tar archives
4 0       string          ustar\000               POSIX tar archive{offset-adjust:-257}
5 0       string          ustar\040\040\000       POSIX tar archive (GNU){offset-adjust:-257}
6
7 # JAR archiver (.j), this is the successor to ARJ, not Java's JAR (which is essentially ZIP)
8 0       string  \x1aJar\x1b JAR (ARJ Software, Inc.) archive data{offset-adjust:-14}
9 0       string  JARCS JAR (ARJ Software, Inc.) archive data
10
11 # ZIP compression (Greg Roelofs, c/o zip-bugs@wkuvx1.wku.edu)
12 0       string          PK\003\004      Zip
13 >6      leshort         &0x01           encrypted
14 >0      byte            x               archive data,
15 >4      byte            0x00            v0.0
16 >4      byte            0x09            at least v0.9 to extract,
17 >4      byte            0x0a            at least v1.0 to extract,
18 >4      byte            0x0b            at least v1.1 to extract,
19 >0x161  string          WINZIP          WinZIP self-extracting,
20 >4      byte            0x14
21 >>30    ubelong         !0x6d696d65     at least v2.0 to extract,
22 >18     lelong          !0
23 >>18    lelong          <0              invalid
24 >>18    lelong          x               compressed size: %d,
25 >>18    lelong          x               {jump-to-offset:%d}
26 >22     lelong          !0
27 >>22    lelong          <0              invalid
28 >>22    lelong          x               uncompressed size: %d,{extract-delay:End of Zip archive}
29 >30     string          x               {file-name:{raw-replace}}name: {raw-replace}
30 >26     leshort         x               {raw-string-length:%d}
31 >30     string          x               {raw-string:%s
32 >61     string          x               \b%s
33 >92     string          x               \b%s
34 >123    string          x               \b%s
35 >154    string          x               \b%s}
36
37 # ZIP footer
38 0       string          PK\x05\x06      End of Zip archive
39 #>10    leshort         x               number of records: %d,
40 #>12    leshort         x               size of central directory: %d
41 #>20    leshort         x               {offset-adjust:22+%d}
42 >20     leshort         >0
43 >>20    leshort         x               \b, comment: {raw-replace}
44 >>20    leshort         x               {raw-string-length:%d}
45 >>22    string          x               {raw-string:%s}
46
47 # ARJ archiver (jason@jarthur.Claremont.EDU)
48 0       leshort         0xea60          ARJ archive data,
49 >2      leshort         x               header size: %d,
50 >5      byte            <1              invalid
51 >5      byte            >16             invalid
52 >5      byte            x               version %d,
53 >6      byte            <1              invalid
54 >6      byte            >16             invalid
55 >6      byte            x               minimum version to extract: %d,
56 >8      byte            <0              invalid flags,
57 >8      byte            &0x04           multi-volume,
58 >8      byte            &0x10           slash-switched,
59 >8      byte            &0x20           backup,
60 >9      byte            <0              invalid compression method,
61 >9      byte            >4              invalid compression method,
62 >9      byte            0               compression method: stored,
63 >9      byte            1               compression method: compressed most,
64 >9      byte            2               compression method: compressed,
65 >9      byte            3               compression method: compressed faster,
66 >9      byte            4               compression method: compressed fastest,
67 >10     byte            <0              invalid file type
68 >10     byte            >4              invalid file type
69 >10     byte            0               file type: binary,
70 >10     byte            1               file type: 7-bit text,
71 >10     byte            2               file type: comment header,
72 >10     byte            3               file type: directory,
73 >10     byte            4               file type: volume label,
74 >34     byte            !0
75 >>34    string          x               {file-name:%s}
76 >>34    string          x               original name: "%s",
77 >0xC    ledate          x               original file date: %s,
78 >0x10   lelong          <0              invalid
79 >0x10   lelong          x               compressed file size: %d,
80 >0x14   lelong          <0              invalid
81 >0x14   lelong          x               uncompressed file size: %d,
82 >7      byte            0               os: MS-DOS 
83 >7      byte            1               os: PRIMOS
84 >7      byte            2               os: Unix
85 >7      byte            3               os: Amiga
86 >7      byte            4               os: Macintosh
87 >7      byte            5               os: OS/2
88 >7      byte            6               os: Apple ][ GS
89 >7      byte            7               os: Atari ST
90 >7      byte            8               os: NeXT
91 >7      byte            9               os: VAX/VMS
92 >7      byte            >9              invalid os
93 >7      byte            <0              invalid os
94
95 # RAR archiver (Greg Roelofs, newt@uchicago.edu)
96 0       string          Rar!            RAR archive data
97
98 # HPACK archiver (Peter Gutmann, pgut1@cs.aukuni.ac.nz)
99 0       string          HPAK            HPACK archive data
100
101 # JAM Archive volume format, by Dmitry.Kohmanyuk@UA.net
102 0       string          \351,\001JAM    JAM archive
103
104 # LHARC/LHA archiver (Greg Roelofs, newt@uchicago.edu)
105 0       string          -lzs-           LHa 2.x? archive data [lzs] [NSRL|LHA2]{offset-adjust:-2}
106 0       string          -lh\40-         LHa 2.x? archive data [lh ] [NSRL|LHA2]{offset-adjust:-2}
107 0       string          -lhd-           LHa 2.x? archive data [lhd] [NSRL|LHA2]{offset-adjust:-2}
108 0       string          -lh2-           LHa 2.x? archive data [lh2] [NSRL|LHA2]{offset-adjust:-2}
109 0       string          -lh3-           LHa 2.x? archive data [lh3] [NSRL|LHA2]{offset-adjust:-2}
110 0       string          -lh4-           LHa (2.x) archive data [lh4] [NSRL|LHA2]{offset-adjust:-2}
111 0       string          -lh5-           LHa (2.x) archive data [lh5] [NSRL|LHA2]{offset-adjust:-2}
112 0       string          -lh6-           LHa (2.x) archive data [lh6] [NSRL|LHA2]{offset-adjust:-2}
113 0       string          -lh7-           LHa (2.x) archive data [lh7] [NSRL|LHA2]{offset-adjust:-2}
114
115
116 # cpio archives
117 #
118 # The SVR4 "cpio(4)" hints that there are additional formats, but they
119 # are defined as "short"s; I think all the new formats are
120 # character-header formats and thus are strings, not numbers.
121 #0       string          070707          ASCII cpio archive (pre-SVR4 or odc)
122
123 0       string          070701          ASCII cpio archive (SVR4 with no CRC),
124 >110    byte            0               invalid
125 #>110   byte            !0x2F
126 #>>110  string          !TRAILER!!!     invalid
127 >110    string          x               file name: "%s"
128 >54     string          x               file size: "0x%.8s"
129 >54     string          x               {jump-to-offset:0x%.8s+112}
130
131 0       string          070702          ASCII cpio archive (SVR4 with CRC)
132 >110    byte            0               invalid
133 #>110   byte            !0x2F
134 #>>110  string          !TRAILER!!!     invalid
135 >110    string          x               file name: "%s"
136 >54     string          x               file size: "0x%.8s"
137 >54     string          x               {jump-to-offset:0x%.8s+112}
138
139
140 # HP Printer Job Language
141 # The header found on Win95 HP plot files is the "Silliest Thing possible" 
142 # (TM)
143 # Every driver puts the language at some random position, with random case
144 # (LANGUAGE and Language)
145 # For example the LaserJet 5L driver puts the "PJL ENTER LANGUAGE" in line 10
146 # From: Uwe Bonnes <bon@elektron.ikp.physik.th-darmstadt.de>
147
148 0       string          \033%-12345X@PJL        HP Printer Job Language data
149 >&0     string          >\0                     "%s"
150 >>&0    string          >\0                     "%s"
151 >>>&0   string          >\0                     "%s"
152 >>>>&0  string          >\0                     "%s"
153
154 #------------------------------------------------------------------------------
155 #
156 # RPM: file(1) magic for Red Hat Packages   Erik Troan (ewt@redhat.com)
157 #
158 0       belong          0xedabeedb      RPM
159 >4      byte            x               v%d
160 >6      beshort         0               bin
161 >6      beshort         1               src
162 >8      beshort         1               i386
163 >8      beshort         2               Alpha
164 >8      beshort         3               Sparc
165 >8      beshort         4               MIPS
166 >8      beshort         5               PowerPC
167 >8      beshort         6               68000
168 >8      beshort         7               SGI
169 >8      beshort         8               RS6000
170 >8      beshort         9               IA64
171 >8      beshort         10              Sparc64
172 >8      beshort         11              MIPSel
173 >8      beshort         12              ARM
174 >10     string          x               "%s"
175
176 # IBM AIX Backup File Format header and entry signatures
177 0       lelong  0xea6b0009      BFF volume header,
178 >4      leshort x               checksum: 0x%.4X,
179 >6      leshort <0              invalid
180 >6      leshort 0               invalid
181 >6      leshort x               volume number: %d,
182 >8      ledate  x               current date: %s,
183 >12     ledate  x               starting date: %s,
184 >20     string  x               disk name: "%s",
185 >36     string  x               file system name: "%s",
186 >52     string  x               user name: "%s"
187
188 0       leshort 0xea6b          BFF volume entry,{offset-adjust:-2}
189 >22     lelong  <0              invalid
190 >22     lelong  0               directory,
191 >22     lelong  >0
192 >>22    lelong  x               file size: %d,
193 >>54    lelong  <0              invalid
194 >>54    lelong  0               invalid
195 >>54    lelong  x               compressed size: %d,
196 >58     lelong  !0              invalid
197 >62     byte    0               invalid
198 >62     byte    !0x2e
199 >>62    byte    !0x2f           invalid
200 >62     string  x               file name: "%s
201 >92     string  x               \b%s"
202
203 0       leshort 0xea6c          BFF volume entry, compressed,{offset-adjust:-2}
204 >22     lelong  <0              invalid
205 >22     lelong  0               directory,
206 >22     lelong  >0
207 >>22    lelong  x               file size: %d,
208 >>54    lelong  <0              invalid
209 >>54    lelong  0               invalid
210 >>54    lelong  x               compressed size: %d,
211 >58     lelong  !0              invalid
212 >62     byte    0               invalid
213 >62     byte    !0x2e
214 >>62    byte    !0x2f           invalid
215 >62     string  x               file name: "%s
216 >92     string  x               \b%s"
217
218 0       leshort 0xea6d          BFF volume entry, AIXv3,{offset-adjust:-2}
219 >22     lelong  <0              invalid
220 >22     lelong  0               directory,
221 >22     lelong  >0
222 >>22    lelong  x               file size: %d,
223 >>54    lelong  <0              invalid
224 >>54    lelong  0               invalid
225 >>54    lelong  x               compressed size: %d,
226 >58     lelong  !0              invalid
227 >62     byte    0               invalid
228 >62     byte    !0x2e
229 >>62    byte    !0x2f           invalid
230 >62     string  x               file name: "%s
231 >92     string  x               \b%s"
232
233
234 #---------------------------Bootloaders--------------------------------
235
236 # CFE bootloader
237 0       string  CFE1CFE1        CFE boot loader
238 >40     string  CFE1CFE1        invalid
239
240 # U-Boot boot loader
241 0       string  U-Boot          U-Boot boot loader reference{one-of-many}
242 0       string  U-BOOT          U-Boot boot loader reference{one-of-many}
243 0       string  u-boot          U-Boot boot loader reference{one-of-many}
244
245 #------------------Compression Formats-----------------------------
246
247 # AFX compressed files (Wolfram Kleff)
248 0       string          -afx-           AFX compressed file data{offset-adjust:-2}
249
250 # bzip2
251 0       string BZh91AY&SY       bzip2 compressed data, block size = 900k
252 0       string BZh81AY&SY       bzip2 compressed data, block size = 800k
253 0       string BZh71AY&SY       bzip2 compressed data, block size = 700k
254 0       string BZh61AY&SY       bzip2 compressed data, block size = 600k
255 0       string BZh51AY&SY       bzip2 compressed data, block size = 500k
256 0       string BZh41AY&SY       bzip2 compressed data, block size = 400k
257 0       string BZh31AY&SY       bzip2 compressed data, block size = 300k
258 0       string BZh21AY&SY       bzip2 compressed data, block size = 200k
259 0       string BZh11AY&SY       bzip2 compressed data, block size = 100k
260
261 # lzop from <markus.oberhumer@jk.uni-linz.ac.at>
262 0       string          \x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a    lzop compressed data
263 >9      beshort         <0x0940
264 >>9     byte&0xf0       =0x00           - version 0.
265 >>9     beshort&0x0fff  x               \b%03x,
266 >>13    byte            1               LZO1X-1,
267 >>13    byte            2               LZO1X-1(15),
268 >>13    byte            3               LZO1X-999,
269 ## >>22 bedate          >0              last modified: %s,
270 >>14    byte            =0x00           os: MS-DOS
271 >>14    byte            =0x01           os: Amiga
272 >>14    byte            =0x02           os: VMS
273 >>14    byte            =0x03           os: Unix
274 >>14    byte            =0x05           os: Atari
275 >>14    byte            =0x06           os: OS/2
276 >>14    byte            =0x07           os: MacOS
277 >>14    byte            =0x0A           os: Tops/20
278 >>14    byte            =0x0B           os: WinNT
279 >>14    byte            =0x0E           os: Win32
280 >9      beshort         >0x0939
281 >>9     byte&0xf0       =0x00           - version 0.
282 >>9     byte&0xf0       =0x10           - version 1.
283 >>9     byte&0xf0       =0x20           - version 2.
284 >>9     beshort&0x0fff  x               \b%03x,
285 >>15    byte            1               LZO1X-1,
286 >>15    byte            2               LZO1X-1(15),
287 >>15    byte            3               LZO1X-999,
288 ## >>25 bedate          >0              last modified: %s,
289 >>17    byte            =0x00           os: MS-DOS
290 >>17    byte            =0x01           os: Amiga
291 >>17    byte            =0x02           os: VMS
292 >>17    byte            =0x03           os: Unix
293 >>17    byte            =0x05           os: Atari
294 >>17    byte            =0x06           os: OS/2
295 >>17    byte            =0x07           os: MacOS
296 >>17    byte            =0x0A           os: Tops/20
297 >>17    byte            =0x0B           os: WinNT
298 >>17    byte            =0x0E           os: Win32
299
300 # lzip  
301 0       string          LZIP            lzip compressed data
302 >4      byte            x               \b, version: %d
303
304 # LZO
305 0       string          \211LZO\000\015\012\032\012     LZO compressed data
306
307 # 7-zip archiver, from Thomas Klausner (wiz@danbala.tuwien.ac.at)
308 # http://www.7-zip.org or DOC/7zFormat.txt 
309 #
310 0       string          7z\274\257\047\034      7-zip archive data,
311 >6      byte            <0                      invalid
312 >6      byte            0                       invalid
313 >6      byte            >20                     invalid
314 >6      byte            x                       version %d
315 >7      byte            x                       \b.%d
316
317 # standard unix compress
318 #0       beshort                0x1f9d          compress'd data
319 #>2      byte&0x80       >0              block compressed
320 #>2     byte&0x1f       !16             invalid
321 #>2      byte&0x1f       x               %d bits
322
323 # http://tukaani.org/xz/xz-file-format.txt
324 0       string          \xFD\x37\x7a\x58\x5a\x00        xz compressed data
325
326 # gzip (GNU zip, not to be confused with Info-ZIP or PKWARE zip archiver)
327 #   Edited by Chris Chittleborough <cchittleborough@yahoo.com.au>, March 2002
328 #       * Original filename is only at offset 10 if "extra field" absent
329 #       * Produce shorter output - notably, only report compression methods
330 #         other than 8 ("deflate", the only method defined in RFC 1952).
331 #0       string          \037\213\x08    gzip compressed data
332 0       string          \x1f\x8b\x08    gzip compressed data
333 >3      byte            &0x01           \b, ASCII
334 >3      byte            &0x02           \b, has CRC
335 >3      byte            &0x04           \b, extra field
336 >3      byte&0xC        =0x08
337 >>10    string          x               \b{file-name:%s}
338 >>10    string          x               \b, was "%s"
339 >3      byte            &0x10           \b, has comment
340 >9      byte            =0x00           \b, from FAT filesystem (MS-DOS, OS/2, NT)
341 >9      byte            =0x01           \b, from Amiga
342 >9      byte            =0x02           \b, from VMS
343 >9      byte            =0x03           \b, from Unix
344 >9      byte            =0x04           \b, from VM/CMS
345 >9      byte            =0x05           \b, from Atari
346 >9      byte            =0x06           \b, from HPFS filesystem (OS/2, NT)
347 >9      byte            =0x07           \b, from MacOS
348 >9      byte            =0x08           \b, from Z-System
349 >9      byte            =0x09           \b, from CP/M
350 >9      byte            =0x0A           \b, from TOPS/20
351 >9      byte            =0x0B           \b, from NTFS filesystem (NT)
352 >9      byte            =0x0C           \b, from QDOS
353 >9      byte            =0x0D           \b, from Acorn RISCOS
354 #>9     byte            =0xFF           \b, from ZyNOS
355 #>9     byte            >0x0D           \b, invalid
356 #>>9    byte            x               source: 0x%.2X
357 #>9     byte            <0              \b, invalid
358 #>>9    byte            x               source: 0x%.2X
359 >3      byte            &0x20           \b, encrypted (invalid)
360 # Dates before 1992 are invalid, unless of course you're DD-WRT in which
361 # case you don't know how to set a date in your gzip files. Brilliant.
362 >4      lelong          =0              \b, NULL date:
363 >4      lelong          <0              \b, invalid date:
364 >4      lelong          >0              
365 >>4     lelong          <694224000      \b, invalid date:
366 >>4     lelong          =694224000      \b, invalid date:
367 >>4     lelong          >694224000      \b, last modified:
368 >4      ledate          x               %s
369 >4      lelong          x               \b{epoch:%d}
370 >8      byte            2               \b, max compression
371 >8      byte            4               \b, max speed
372
373 # Zlib signatures
374 # Useless until they can be further improved.
375 #0      beshort         0x789C          zlib compressed data
376 #0      beshort         0x78DA          zlib compressed data
377 #0      beshort         0x7801          zlib compressed data
378
379 # Supplementary magic data for the file(1) command to support
380 # rzip(1).  The format is described in magic(5).
381 #
382 # Copyright (C) 2003 by Andrew Tridgell.  You may do whatever you want with
383 # this file.
384 #
385 0       string          RZIP            rzip compressed data
386 >4      byte            x               - version %d
387 >5      byte            x               \b.%d
388 >6      belong          x               (%d bytes)
389
390 # New LZMA format signature
391 0       string          \xFFLZMA\x00    LZMA compressed data (new),
392 >6      byte&0x10       0               single-block stream
393 >6      byte&0x10       0x10            multi-block stream
394
395 # See lzma file for LZMA signatures
396 # Type: OpenSSL certificates/key files
397 # From: Nicolas Collignon <tsointsoin@gmail.com>
398
399 0       string  -----BEGIN\x20CERTIFICATE-----      PEM certificate
400 0       string  -----BEGIN\x20CERTIFICATE\x20REQ    PEM certificate request
401 0       string  -----BEGIN\x20RSA\x20PRIVATE        PEM RSA private key
402 0       string  -----BEGIN\x20DSA\x20PRIVATE        PEM DSA private key
403
404 # Type: OpenSSH key files
405 # From: Nicolas Collignon <tsointsoin@gmail.com>
406
407 0       string  SSH\x20PRIVATE\x20KEY   OpenSSH RSA1 private key,
408 >28     string  >\0                     version "%s"
409
410 0       string  ssh-dss\x20               OpenSSH DSA public key
411 0       string  ssh-rsa\x20               OpenSSH RSA public key
412
413 # Type: Certificates/key files in DER format
414 # From: Gert Hulselmans <hulselmansgert@gmail.com>
415 0       string  \x30\x82                Private key in DER format (PKCS#8),
416 >4      string  !\x02\x01\x00           invalid,
417 >>2     beshort x                       header length: 4, sequence length: %d
418
419 0       string  \x30\x82                Certificate in DER format (x509 v3),
420 >4      string  !\x30\x82               invalid,
421 >>2     beshort x                       header length: 4, sequence length: %d
422
423 # GnuPG
424 # The format is very similar to pgp
425 0       string          \001gpg                 GPG key trust database
426 >4      byte            x                       version %d
427
428 # Not a very useful signature
429 #0       beshort         0x9901                  GPG key public ring
430
431 # This magic is not particularly good, as the keyrings don't have true
432 # magic. Nevertheless, it covers many keyrings.
433
434 #------------------------------------------------------------------------------
435 # Mavroyanopoulos Nikos <nmav@hellug.gr>
436 # mcrypt:   file(1) magic for mcrypt 2.2.x;
437 0       string          \0m\3           mcrypt 2.5 encrypted data,
438 >4      byte            0               invalid
439 >4      string          >\0             algorithm: "%s",
440 >>&1    leshort         <1              invalid
441 >>&1    leshort         >0              keysize: %d bytes,
442 >>>&0   byte            0               invalid
443 >>>&0   string          >\0             mode: "%s",
444
445 0       string          \0m\2           mcrypt 2.2 encrypted data,
446 >3      byte            0               algorithm: blowfish-448,
447 >3      byte            1               algorithm: DES,
448 >3      byte            2               algorithm: 3DES,
449 >3      byte            3               algorithm: 3-WAY,
450 >3      byte            4               algorithm: GOST,
451 >3      byte            6               algorithm: SAFER-SK64,
452 >3      byte            7               algorithm: SAFER-SK128,
453 >3      byte            8               algorithm: CAST-128,
454 >3      byte            9               algorithm: xTEA,
455 >3      byte            10              algorithm: TWOFISH-128,
456 >3      byte            11              algorithm: RC2,
457 >3      byte            12              algorithm: TWOFISH-192,
458 >3      byte            13              algorithm: TWOFISH-256,
459 >3      byte            14              algorithm: blowfish-128,
460 >3      byte            15              algorithm: blowfish-192,
461 >3      byte            16              algorithm: blowfish-256,
462 >3      byte            100             algorithm: RC6,
463 >3      byte            101             algorithm: IDEA,
464 >3      byte            <0              invalid algorithm
465 >3      byte            >101            invalid algorithm,
466 >3      byte            >16
467 >>3     byte            <100            invalid algorithm,
468 >4      byte            0               mode: CBC,
469 >4      byte            1               mode: ECB,
470 >4      byte            2               mode: CFB,
471 >4      byte            3               mode: OFB,
472 >4      byte            4               mode: nOFB,
473 >4      byte            <0              invalid mode,
474 >4      byte            >4              invalid mode,
475 >5      byte            0               keymode: 8bit
476 >5      byte            1               keymode: 4bit
477 >5      byte            2               keymode: SHA-1 hash
478 >5      byte            3               keymode: MD5 hash
479 >5      byte            <0              invalid keymode
480 >5      byte            >3              invalid keymode
481
482 #------------------------------------------------------------------------------
483 # pgp:  file(1) magic for Pretty Good Privacy
484 #
485 #0       beshort         0x9900                  PGP key public ring
486 #0       beshort         0x9501                  PGP key security ring
487 #0       beshort         0x9500                  PGP key security ring
488 #0      beshort         0xa600                  PGP encrypted data
489 0       string          -----BEGIN\040PGP       PGP armored data,
490 >15     string          PUBLIC\040KEY\040BLOCK- public key block
491 >15     string          MESSAGE-                message
492 >15     string          SIGNED\040MESSAGE-      signed message
493 >15     string          PGP\040SIGNATURE-       signature
494
495 0       string          Salted__                OpenSSL encryption, salted,
496 >8      belong          x                       salt: 0x%X
497 >12     belong          x                       \b%X
498
499 #------------------Standard file formats------------------------------------
500
501 #------------------------------------------------------------------------------
502 # elf:  file(1) magic for ELF executables
503 #
504 # We have to check the byte order flag to see what byte order all the
505 # other stuff in the header is in.
506 #
507 # What're the correct byte orders for the nCUBE and the Fujitsu VPP500?
508 #
509 # updated by Daniel Quinlan (quinlan@yggdrasil.com)
510 0       string          \177ELF         ELF
511 >4      byte            0               invalid class
512 >4      byte            1               32-bit
513 # only for MIPS - in the future, the ABI field of e_flags should be used.
514 >>18    leshort         8
515 >>>36   lelong          &0x20           N32
516 >>18    leshort         10
517 >>>36   lelong          &0x20           N32
518 >>18    beshort         8
519 >>>36   belong          &0x20           N32
520 >>18    beshort         10
521 >>>36   belong          &0x20           N32
522 >4      byte            2               64-bit
523 >5      byte            0               invalid byte order
524 >5      byte            1               LSB
525 # The official e_machine number for MIPS is now #8, regardless of endianness.
526 # The second number (#10) will be deprecated later. For now, we still
527 # say something if #10 is encountered, but only gory details for #8.
528 >>18    leshort         8
529 # only for 32-bit
530 >>>4    byte            1
531 >>>>36  lelong&0xf0000000       0x00000000      MIPS-I
532 >>>>36  lelong&0xf0000000       0x10000000      MIPS-II
533 >>>>36  lelong&0xf0000000       0x20000000      MIPS-III
534 >>>>36  lelong&0xf0000000       0x30000000      MIPS-IV
535 >>>>36  lelong&0xf0000000       0x40000000      MIPS-V
536 >>>>36  lelong&0xf0000000       0x60000000      MIPS32
537 >>>>36  lelong&0xf0000000       0x70000000      MIPS64
538 >>>>36  lelong&0xf0000000       0x80000000      MIPS32 rel2
539 >>>>36  lelong&0xf0000000       0x90000000      MIPS64 rel2
540 # only for 64-bit
541 >>>4    byte            2
542 >>>>48  lelong&0xf0000000       0x00000000      MIPS-I
543 >>>>48  lelong&0xf0000000       0x10000000      MIPS-II
544 >>>>48  lelong&0xf0000000       0x20000000      MIPS-III
545 >>>>48  lelong&0xf0000000       0x30000000      MIPS-IV
546 >>>>48  lelong&0xf0000000       0x40000000      MIPS-V
547 >>>>48  lelong&0xf0000000       0x60000000      MIPS32
548 >>>>48  lelong&0xf0000000       0x70000000      MIPS64 
549 >>>>48  lelong&0xf0000000       0x80000000      MIPS32 rel2
550 >>>>48  lelong&0xf0000000       0x90000000      MIPS64 rel2
551 >>16    leshort         0               no file type,
552 >>16    leshort         1               relocatable,
553 >>16    leshort         2               executable,
554 >>16    leshort         3               shared object,
555 # Core handling from Peter Tobias <tobias@server.et-inf.fho-emden.de>
556 # corrections by Christian 'Dr. Disk' Hechelmann <drdisk@ds9.au.s.shuttle.de>
557 >>16    leshort         4               core file
558 # Core file detection is not reliable.
559 #>>>(0x38+0xcc) string  >\0             of '%s'
560 #>>>(0x38+0x10) lelong  >0              (signal %d),
561 >>16    leshort         &0xff00         processor-specific,
562 >>18    leshort         0               no machine,
563 >>18    leshort         1               AT&T WE32100 - invalid byte order,
564 >>18    leshort         2               SPARC - invalid byte order,
565 >>18    leshort         3               Intel 80386,
566 >>18    leshort         4               Motorola
567 >>>36   lelong          &0x01000000     68000 - invalid byte order,
568 >>>36   lelong          &0x00810000     CPU32 - invalid byte order,
569 >>>36   lelong          0               68020 - invalid byte order,
570 >>18    leshort         5               Motorola 88000 - invalid byte order,
571 >>18    leshort         6               Intel 80486,
572 >>18    leshort         7               Intel 80860,
573 >>18    leshort         8               MIPS,
574 >>18    leshort         9               Amdahl - invalid byte order,
575 >>18    leshort         10              MIPS (deprecated),
576 >>18    leshort         11              RS6000 - invalid byte order,
577 >>18    leshort         15              PA-RISC - invalid byte order,
578 >>>50   leshort         0x0214          2.0
579 >>>48   leshort         &0x0008         (LP64),
580 >>18    leshort         16              nCUBE,
581 >>18    leshort         17              Fujitsu VPP500,
582 >>18    leshort         18              SPARC32PLUS,
583 >>18    leshort         20              PowerPC,
584 >>18    leshort         22              IBM S/390,
585 >>18    leshort         36              NEC V800,
586 >>18    leshort         37              Fujitsu FR20,
587 >>18    leshort         38              TRW RH-32,
588 >>18    leshort         39              Motorola RCE,
589 >>18    leshort         40              ARM,
590 >>18    leshort         41              Alpha,
591 >>18    leshort         0xa390          IBM S/390 (obsolete),
592 >>18    leshort         42              Hitachi SH,
593 >>18    leshort         43              SPARC V9 - invalid byte order,
594 >>18    leshort         44              Siemens Tricore Embedded Processor,
595 >>18    leshort         45              Argonaut RISC Core, Argonaut Technologies Inc.,
596 >>18    leshort         46              Hitachi H8/300,
597 >>18    leshort         47              Hitachi H8/300H,
598 >>18    leshort         48              Hitachi H8S,
599 >>18    leshort         49              Hitachi H8/500,
600 >>18    leshort         50              IA-64 (Intel 64 bit architecture)
601 >>18    leshort         51              Stanford MIPS-X,
602 >>18    leshort         52              Motorola Coldfire,
603 >>18    leshort         53              Motorola M68HC12,
604 >>18    leshort         62              AMD x86-64,
605 >>18    leshort         75              Digital VAX,
606 >>18    leshort         97              NatSemi 32k,
607 >>18    leshort         0x9026          Alpha (unofficial),
608 >>20    lelong          0               invalid version
609 >>20    lelong          1               version 1
610 >>36    lelong          1               MathCoPro/FPU/MAU Required
611 >5      byte            2               MSB
612 # only for MIPS - see comment in little-endian section above.
613 >>18    beshort         8
614 # only for 32-bit
615 >>>4    byte            1
616 >>>>36  belong&0xf0000000       0x00000000      MIPS-I
617 >>>>36  belong&0xf0000000       0x10000000      MIPS-II
618 >>>>36  belong&0xf0000000       0x20000000      MIPS-III
619 >>>>36  belong&0xf0000000       0x30000000      MIPS-IV
620 >>>>36  belong&0xf0000000       0x40000000      MIPS-V
621 >>>>36  belong&0xf0000000       0x60000000      MIPS32
622 >>>>36  belong&0xf0000000       0x70000000      MIPS64
623 >>>>36  belong&0xf0000000       0x80000000      MIPS32 rel2
624 >>>>36  belong&0xf0000000       0x90000000      MIPS64 rel2
625 # only for 64-bit
626 >>>4    byte            2
627 >>>>48  belong&0xf0000000       0x00000000      MIPS-I
628 >>>>48  belong&0xf0000000       0x10000000      MIPS-II
629 >>>>48  belong&0xf0000000       0x20000000      MIPS-III
630 >>>>48  belong&0xf0000000       0x30000000      MIPS-IV
631 >>>>48  belong&0xf0000000       0x40000000      MIPS-V
632 >>>>48  belong&0xf0000000       0x60000000      MIPS32
633 >>>>48  belong&0xf0000000       0x70000000      MIPS64 
634 >>>>48  belong&0xf0000000       0x80000000      MIPS32 rel2
635 >>>>48  belong&0xf0000000       0x90000000      MIPS64 rel2
636 >>16    beshort         0               no file type,
637 >>16    beshort         1               relocatable,
638 >>16    beshort         2               executable,
639 >>16    beshort         3               shared object,
640 >>16    beshort         4               core file,
641 #>>>(0x38+0xcc) string  >\0             of '%s'
642 #>>>(0x38+0x10) belong  >0              (signal %d),
643 >>16    beshort         &0xff00         processor-specific,
644 >>18    beshort         0               no machine,
645 >>18    beshort         1               AT&T WE32100,
646 >>18    beshort         2               SPARC,
647 >>18    beshort         3               Intel 80386 - invalid byte order,
648 >>18    beshort         4               Motorola
649 >>>36   belong          &0x01000000     68000,
650 >>>36   belong          &0x00810000     CPU32,
651 >>>36   belong          0               68020,
652 >>18    beshort         5               Motorola 88000,
653 >>18    beshort         6               Intel 80486 - invalid byte order,
654 >>18    beshort         7               Intel 80860,
655 >>18    beshort         8               MIPS,
656 >>18    beshort         9               Amdahl,
657 >>18    beshort         10              MIPS (deprecated),
658 >>18    beshort         11              RS6000,
659 >>18    beshort         15              PA-RISC
660 >>>50   beshort         0x0214          2.0
661 >>>48   beshort         &0x0008         (LP64)
662 >>18    beshort         16              nCUBE,
663 >>18    beshort         17              Fujitsu VPP500,
664 >>18    beshort         18              SPARC32PLUS,
665 >>>36   belong&0xffff00 &0x000100       V8+ Required,
666 >>>36   belong&0xffff00 &0x000200       Sun UltraSPARC1 Extensions Required,
667 >>>36   belong&0xffff00 &0x000400       HaL R1 Extensions Required,
668 >>>36   belong&0xffff00 &0x000800       Sun UltraSPARC3 Extensions Required,
669 >>18    beshort         20              PowerPC or cisco 4500,
670 >>18    beshort         21              cisco 7500,
671 >>18    beshort         22              IBM S/390,
672 >>18    beshort         24              cisco SVIP,
673 >>18    beshort         25              cisco 7200,
674 >>18    beshort         36              NEC V800 or cisco 12000,
675 >>18    beshort         37              Fujitsu FR20,
676 >>18    beshort         38              TRW RH-32,
677 >>18    beshort         39              Motorola RCE,
678 >>18    beshort         40              ARM,
679 >>18    beshort         41              Alpha,
680 >>18    beshort         42              Hitachi SH,
681 >>18    beshort         43              SPARC V9,
682 >>18    beshort         44              Siemens Tricore Embedded Processor,
683 >>18    beshort         45              Argonaut RISC Core, Argonaut Technologies Inc.,
684 >>18    beshort         46              Hitachi H8/300,
685 >>18    beshort         47              Hitachi H8/300H,
686 >>18    beshort         48              Hitachi H8S,
687 >>18    beshort         49              Hitachi H8/500,
688 >>18    beshort         50              Intel Merced Processor,
689 >>18    beshort         51              Stanford MIPS-X,
690 >>18    beshort         52              Motorola Coldfire,
691 >>18    beshort         53              Motorola M68HC12,
692 >>18    beshort         73              Cray NV1,
693 >>18    beshort         75              Digital VAX,
694 >>18    beshort         97              NatSemi 32k,
695 >>18    beshort         0x9026          Alpha (unofficial),
696 >>18    beshort         0xa390          IBM S/390 (obsolete),
697 >>18    beshort         0xde3d          Ubicom32,
698 >>20    belong          0               invalid version
699 >>20    belong          1               version 1
700 >>36    belong          1               MathCoPro/FPU/MAU Required
701 # Up to now only 0, 1 and 2 are defined; I've seen a file with 0x83, it seemed
702 # like proper ELF, but extracting the string had bad results.
703 >4      byte            <0x80
704 >>8     string          >\0             ("%s")
705 >8      string          \0
706 >>7     byte            0               (SYSV)
707 >>7     byte            1               (HP-UX)
708 >>7     byte            2               (NetBSD)
709 >>7     byte            3               (GNU/Linux)
710 >>7     byte            4               (GNU/Hurd)
711 >>7     byte            5               (86Open)
712 >>7     byte            6               (Solaris)
713 >>7     byte            7               (Monterey)
714 >>7     byte            8               (IRIX)
715 >>7     byte            9               (FreeBSD)
716 >>7     byte            10              (Tru64)
717 >>7     byte            11              (Novell Modesto)
718 >>7     byte            12              (OpenBSD)
719 >>7     byte            97              (ARM)
720 >>7     byte            255             (embedded)
721
722 # XXX - according to Microsoft's spec, at an offset of 0x3c in a
723 # PE-format executable is the offset in the file of the PE header;
724 # unfortunately, that's a little-endian offset, and there's no way
725 # to specify an indirect offset with a specified byte order.
726 # So, for now, we assume the standard MS-DOS stub, which puts the
727 # PE header at 0x80 = 128.
728 #
729 # Required OS version and subsystem version were 4.0 on some NT 3.51
730 # executables built with Visual C++ 4.0, so it's not clear that
731 # they're interesting.  The user version was 0.0, but there's
732 # probably some linker directive to set it.  The linker version was
733 # 3.0, except for one ".exe" which had it as 4.20 (same damn linker!).
734 #
735 # many of the compressed formats were extraced from IDARC 1.23 source code
736 #
737
738 # Not a very useful signature...
739 #0       string  MZ     Microsoft
740 #>0x18  leshort <0x40 MS-DOS executable
741
742 0       string          MZ\0\0\0\0\0\0\0\0\0\0
743 >12     string          PE\0\0  Microsoft PE
744 >0x18   leshort         <0x40   MS-DOS executable
745 >>&18   leshort&0x2000  >0      (DLL)
746 >>&88   leshort         0       (unknown subsystem)
747 >>&88   leshort         1       (native)
748 >>&88   leshort         2       (GUI)
749 >>&88   leshort         3       (console)
750 >>&88   leshort         7       (POSIX)
751 >>&0    leshort         0x0     unknown processor
752 >>&0    leshort         0x14c   Intel 80386
753 >>&0    leshort         0x166   MIPS R4000
754 >>&0    leshort         0x184   Alpha
755 >>&0    leshort         0x268   Motorola 68000
756 >>&0    leshort         0x1f0   PowerPC
757 >>&0    leshort         0x290   PA-RISC
758 >>&18   leshort&0x0100  >0      32-bit
759 >>&18   leshort&0x1000  >0      system file
760 >>&228  lelong          >0      \b, Mono/.Net assembly
761 >>&0xf4 search/0x140 \x0\x40\x1\x0
762 >>>(&0.l+(4)) string MSCF \b, WinHKI CAB self-extracting archive
763 >30             string  Copyright\x201989-1990\x20PKWARE\x20Inc.      Self-extracting PKZIP archive
764 # Is next line correct? One might expect "Corp." not "Copr." If it is right, add a note to that effect.
765 >30             string  PKLITE\x20Copr.   Self-extracting PKZIP archive
766
767 >0x18  leshort >0x3f
768 >>(0x3c.l) string PE\0\0 PE
769 >>>(0x3c.l+25) byte             1 \b32 executable
770 >>>(0x3c.l+25) byte             2 \b32+ executable
771 # hooray, there's a DOS extender using the PE format, with a valid PE
772 # executable inside (which just prints a message and exits if run in win)
773 >>>(0x3c.l+92)  leshort         <10
774 >>>>(8.s*16) string 32STUB for MS-DOS, 32rtm DOS extender
775 >>>>(8.s*16) string !32STUB for MS Windows
776 >>>>>(0x3c.l+22)        leshort&0x2000  >0      (DLL)
777 >>>>>(0x3c.l+92)        leshort         0       (unknown subsystem)
778 >>>>>(0x3c.l+92)        leshort         1       (native)
779 >>>>>(0x3c.l+92)        leshort         2       (GUI)
780 >>>>>(0x3c.l+92)        leshort         3       (console)
781 >>>>>(0x3c.l+92)        leshort         7       (POSIX)
782 >>>(0x3c.l+92)  leshort         10      (EFI application)
783 >>>(0x3c.l+92)  leshort         11      (EFI boot service driver)
784 >>>(0x3c.l+92)  leshort         12      (EFI runtime driver)
785 >>>(0x3c.l+92)  leshort         13      (XBOX)
786 >>>(0x3c.l+4)   leshort         0x0     unknown processor
787 >>>(0x3c.l+4)   leshort         0x14c   Intel 80386
788 >>>(0x3c.l+4)   leshort         0x166   MIPS R4000
789 >>>(0x3c.l+4)   leshort         0x184   Alpha
790 >>>(0x3c.l+4)   leshort         0x268   Motorola 68000
791 >>>(0x3c.l+4)   leshort         0x1f0   PowerPC
792 >>>(0x3c.l+4)   leshort         0x290   PA-RISC
793 >>>(0x3c.l+4)   leshort         0x200   Intel Itanium
794 >>>(0x3c.l+22)  leshort&0x0100  >0      32-bit
795 >>>(0x3c.l+22)  leshort&0x1000  >0      system file
796 >>>(0x3c.l+232) lelong  >0      Mono/.Net assembly
797 >>>>(0x3c.l+0xf8)       string          UPX0 \b, UPX compressed
798 >>>>(0x3c.l+0xf8)       search/0x140    PEC2 \b, PECompact2 compressed
799 >>>>(0x3c.l+0xf8)       search/0x140    UPX2
800 >>>>>(&0x10.l+(-4))     string          PK\3\4 \b, ZIP self-extracting archive (Info-Zip)
801 >>>>(0x3c.l+0xf8)       search/0x140    .idata
802 >>>>>(&0xe.l+(-4))      string          PK\3\4 \b, ZIP self-extracting archive (Info-Zip)
803 >>>>>(&0xe.l+(-4))      string          ZZ0 \b, ZZip self-extracting archive
804 >>>>>(&0xe.l+(-4))      string          ZZ1 \b, ZZip self-extracting archive
805 >>>>(0x3c.l+0xf8)       search/0x140    .rsrc
806 >>>>>(&0x0f.l+(-4))     string          a\\\4\5 \b, WinHKI self-extracting archive
807 >>>>>(&0x0f.l+(-4))     string          Rar! \b, RAR self-extracting archive
808 >>>>>(&0x0f.l+(-4))     search/0x3000   MSCF \b, InstallShield self-extracting archive
809 >>>>>(&0x0f.l+(-4))     search/32       Nullsoft \b, Nullsoft Installer self-extracting archive
810 >>>>(0x3c.l+0xf8)       search/0x140    .data
811 >>>>>(&0x0f.l)          string          WEXTRACT \b, MS CAB-Installer self-extracting archive
812 >>>>(0x3c.l+0xf8)       search/0x140    .petite\0 \b, Petite compressed
813 >>>>>(0x3c.l+0xf7)      byte            x
814 >>>>>>(&0x104.l+(-4))   string          =!sfx! \b, ACE self-extracting archive
815 >>>>(0x3c.l+0xf8)       search/0x140    .WISE \b, WISE installer self-extracting archive
816 >>>>(0x3c.l+0xf8)       search/0x140    .dz\0\0\0 \b, Dzip self-extracting archive
817 >>>>(0x3c.l+0xf8)       search/0x140    .reloc
818 >>>>>(&0xe.l+(-4))      search/0x180    PK\3\4 \b, ZIP self-extracting archive (WinZip)
819
820 >>>>&(0x3c.l+0xf8)      search/0x100    _winzip_ \b, ZIP self-extracting archive (WinZip)
821 >>>>&(0x3c.l+0xf8)      search/0x100    SharedD \b, Microsoft Installer self-extracting archive
822 >>>>0x30                string          Inno \b, InnoSetup self-extracting archive
823
824 >>(0x3c.l) string !PE\0\0 MS-DOS executable
825
826 >>(0x3c.l)              string          NE \b, NE
827 >>>(0x3c.l+0x36)        byte            0 (unknown OS)
828 >>>(0x3c.l+0x36)        byte            1 for OS/2 1.x
829 >>>(0x3c.l+0x36)        byte            2 for MS Windows 3.x
830 >>>(0x3c.l+0x36)        byte            3 for MS-DOS
831 >>>(0x3c.l+0x36)        byte            >3 (unknown OS)
832 >>>(0x3c.l+0x36)        byte            0x81 for MS-DOS, Phar Lap DOS extender
833 >>>(0x3c.l+0x0c)        leshort&0x8003  0x8002 (DLL)
834 >>>(0x3c.l+0x0c)        leshort&0x8003  0x8001 (driver)
835 >>>&(&0x24.s-1)         string          ARJSFX \b, ARJ self-extracting archive
836 >>>(0x3c.l+0x70)        search/0x80     WinZip(R)\x20Self-Extractor \b, ZIP self-extracting archive (WinZip)
837
838 >>(0x3c.l)              string          LX\0\0 \b, LX
839 >>>(0x3c.l+0x0a)        leshort         <1 (unknown OS)
840 >>>(0x3c.l+0x0a)        leshort         1 for OS/2
841 >>>(0x3c.l+0x0a)        leshort         2 for MS Windows
842 >>>(0x3c.l+0x0a)        leshort         3 for DOS
843 >>>(0x3c.l+0x0a)        leshort         >3 (unknown OS)
844 >>>(0x3c.l+0x10)        lelong&0x28000  =0x8000 (DLL)
845 >>>(0x3c.l+0x10)        lelong&0x20000  >0 (device driver)
846 >>>(0x3c.l+0x10)        lelong&0x300    0x300 (GUI)
847 >>>(0x3c.l+0x10)        lelong&0x28300  <0x300 (console)
848 >>>(0x3c.l+0x08)        leshort         1 i80286
849 >>>(0x3c.l+0x08)        leshort         2 i80386
850 >>>(0x3c.l+0x08)        leshort         3 i80486
851 >>>(8.s*16)             string          emx \b, emx
852 >>>>&1                  string          x "%s"
853 >>>&(&0x54.l-3)         string          arjsfx \b, ARJ self-extracting archive
854
855
856
857 #------------------------------------------------------------------------------
858 # bFLT: file(1) magic for BFLT uclinux binary files
859 #
860 # From Philippe De Muyter <phdm@macqel.be>
861
862 # Additional fields added by Craig Heffner
863 #
864 0       string          bFLT            BFLT executable
865 >4      belong          <1              invalid
866 >4      belong          >4              invalid
867 >4      belong          x               version %ld, 
868 >4      belong          4
869 >8      belong          x               code offset: 0x%.8X, 
870 >12     belong          x               data segment starts at: 0x%.8X, 
871 >16     belong          x               bss segment starts at: 0x%.8X, 
872 >20     belong          x               bss segment ends at: 0x%.8X, 
873 >24     belong          x               stack size: %d bytes, 
874 >28     belong          x               relocation records start at: 0x%.8X, 
875 >32     belong          x               number of reolcation records: %d, 
876 >>36    belong&0x1      0x1             ram
877 >>36    belong&0x2      0x2             gotpic
878 >>36    belong&0x4      0x4             gzip
879 >>36    belong&0x8      0x8             gzdata
880
881
882 # Windows CE package files
883 0       string          MSCE\0\0\0\0    Microsoft WinCE installer
884 >20     lelong          0               \b, architecture-independent
885 >20     lelong          103             \b, Hitachi SH3
886 >20     lelong          104             \b, Hitachi SH4
887 >20     lelong          0xA11           \b, StrongARM
888 >20     lelong          4000            \b, MIPS R4000
889 >20     lelong          10003           \b, Hitachi SH3
890 >20     lelong          10004           \b, Hitachi SH3E
891 >20     lelong          10005           \b, Hitachi SH4
892 >20     lelong          70001           \b, ARM 7TDMI
893 >52     leshort         1               \b, 1 file
894 >52     leshort         >1              \b, %u files
895 >56     leshort         1               \b, 1 registry entry
896 >56     leshort         >1              \b, %u registry entries
897
898 #------------------------------------------------------------------------------
899 # Microsoft Xbox executables .xbe (Esa Hyytiä <ehyytia@cc.hut.fi>)
900 0       string          XBEH            XBE, Microsoft Xbox executable
901 # probabilistic checks whether signed or not
902 >0x0004 ulelong =0x0
903 >>&2    ulelong =0x0
904 >>>&2   ulelong =0x0  \b, not signed
905 >0x0004 ulelong >0
906 >>&2    ulelong >0
907 >>>&2   ulelong >0    \b, signed
908 # expect base address of 0x10000
909 >0x0104               ulelong =0x10000
910 >>(0x0118-0x0FF60)    ulelong&0x80000007  0x80000007 \b, all regions
911 >>(0x0118-0x0FF60)    ulelong&0x80000007  !0x80000007
912 >>>(0x0118-0x0FF60)   ulelong >0           (regions:
913 >>>>(0x0118-0x0FF60)  ulelong &0x00000001  NA
914 >>>>(0x0118-0x0FF60)  ulelong &0x00000002  Japan
915 >>>>(0x0118-0x0FF60)  ulelong &0x00000004  Rest_of_World
916 >>>>(0x0118-0x0FF60)  ulelong &0x80000000  Manufacturer
917 >>>(0x0118-0x0FF60)   ulelong >0           \b)
918
919 #------------------------------------------------------------------------------
920 # motorola:  file(1) magic for Motorola 68K and 88K binaries
921 #
922 # 68K
923 #
924 # These signatures are useless without further sanity checking. Disable them until 
925 # that can be implemented.
926 #0       beshort         0x0208          mc68k COFF
927 #>18     beshort         ^00000020       object
928 #>18     beshort         &00000020       executable
929 #>12     belong          >0              not stripped
930 #>168    string          .lowmem         Apple toolbox
931 #>20     beshort         0407            (impure)
932 #>20     beshort         0410            (pure)
933 #>20     beshort         0413            (demand paged)
934 #>20     beshort         0421            (standalone)
935 #0       beshort         0x0209          mc68k executable (shared)
936 #>12     belong          >0              not stripped
937 #0       beshort         0x020A          mc68k executable (shared demand paged)
938 #>12     belong          >0              not stripped
939
940
941 #------------------------------------------------------------------------------
942 # Sony Playstation executables (Adam Sjoegren <asjo@diku.dk>) :
943 0       string  PS-X\x20EXE       Sony Playstation executable
944 #  Area:
945 >113    string  x               ("%s")
946
947 #------------------------------------------------------------------------------
948 # cisco:  file(1) magic for cisco Systems routers
949 #
950 # Most cisco file-formats are covered by the generic elf code
951 0       string                  \x85\x01\x14    Cisco IOS microcode
952 >7      string                  >\0             
953 >>7     string                  x               for "%s"
954 0       string                  \x85\x01\xcb    Cisco IOS experimental microcode
955 >7      string                  >\0             
956 >>7     string                  x               for "%s"
957
958 # EST flat binary format (which isn't, but anyway)
959 # From: Mark Brown <broonie@sirena.org.uk>
960 0       string  ESTFBINR        EST flat binary
961
962 # These are not the binaries themselves, but string references to them
963 # are a strong indication that they exist elsewhere...
964 #0      string  /bin/busybox    Busybox string reference: "%s"{one-of-many}
965 #0      string /bin/sh          Shell string reference: "%s"{one-of-many}
966
967 #--------------------File Systems---------------------
968
969 # Minix filesystems - Juan Cespedes <cespedes@debian.org>
970 # These signatures are useless until they can be improved.
971 #0x410   leshort         0x137f          Minix filesystem
972 #>0x402  beshort         !0              \b, %d zones
973 #>0x1e   string          minix           \b, bootable
974 #0x410   leshort         0x138f          Minix filesystem, 30 char names
975 #0x410   leshort         0x2468          Minix filesystem, version 2
976 #0x410   leshort         0x2478          Minix filesystem, version 2, 30 char names
977 #0x410  leshort         0x4d5a          Minix filesystem, version 3
978 #0x410  leshort         0x4d6a          Minix filesystem, version 3, 30 char names
979
980 #0x410   beshort         0x137f          Minix filesystem (big endian)
981 #>0x402  beshort         !0              \b, %d zones
982 #>0x1e   string          minix           \b, bootable
983 #0x410   beshort         0x138f          Minix filesystem (big endian), 30 char names
984 #0x410   beshort         0x2468          Minix filesystem (big endian), version 2
985 #0x410   beshort         0x2478          Minix filesystem (big endian), version 2, 30 char names
986 #0x410  beshort         0x4d5a          Minix filesystem (big endian), version 3
987 #0x410  beshort         0x4d6a          Minix filesystem (big endian), version 3, 30 char names
988
989 # YAFFS
990 0       string  \x03\x00\x00\x00\x01\x00\x00\x00\xFF\xFF        YAFFS filesystem
991
992 # EFS2 file system - jojo@utulsa.edu
993 0      lelong 0x53000000       EFS2 Qualcomm filesystem super block, little endian,
994 >8     string !EFSSuper        invalid,
995 >4     leshort &1              NAND
996 >4     leshort ^1              NOR
997 >4     leshort x               version 0x%x,
998 >24    lelong  x               %d blocks,
999 >16    lelong  x               0x%x pages per block,
1000 >20    lelong  x               0x%x bytes per page
1001
1002 0      belong 0x53000000       EFS2 Qualcomm filesystem super block, big endian,
1003 >8     string !SSFErepu        invalid,
1004 >4     beshort &1              NAND
1005 >4     beshort ^1              NOR
1006 >4     beshort x               version 0x%x,
1007 >24    belong  x               %d blocks,
1008 >16    belong  x               0x%x pages per block,
1009 >20    belong  x               0x%x bytes per page
1010
1011 # TROC file system
1012 0       string  TROC            TROC filesystem,
1013 >4      lelong  x               %d file entries
1014
1015 # PFS file system
1016 0       string  PFS/            PFS filesystem,
1017 >4      string  x               version "%s",
1018 >14     leshort x               %d files
1019
1020 # MPFS file system
1021 0       string  MPFS            MPFS (Microchip) filesystem,
1022 >4      byte    x               version %d.
1023 >5      byte    x               \b%d,
1024 >6      leshort x               %d file entries
1025
1026 # cramfs filesystem - russell@coker.com.au
1027 0       lelong  0x28cd3d45      CramFS filesystem, little endian
1028 >4      lelong  <0              invalid
1029 >4      lelong  >1073741824     invalid
1030 >4      lelong  x               size %lu
1031 >8      lelong  &1              version #2
1032 >8      lelong  &2              sorted_dirs
1033 >8      lelong  &4              hole_support
1034 >32     lelong  x               CRC 0x%x,
1035 >36     lelong  x               edition %lu,
1036 >40     lelong  <0              invalid
1037 >40     lelong  x               %lu blocks,
1038 >44     lelong  <0              invalid
1039 >44     lelong  x               %lu files
1040 >4      lelong  x               {jump-to-offset:%lu}
1041 >4      lelong  x               {file-size:%lu}
1042
1043 0       belong  0x28cd3d45      CramFS filesystem, big endian
1044 >4      belong  <0              invalid
1045 >4      lelong  >536870912000   invalid
1046 >4      belong  x               size %lu
1047 >8      belong  &1              version #2
1048 >8      belong  &2              sorted_dirs
1049 >8      belong  &4              hole_support
1050 >32     belong  x               CRC 0x%x,
1051 >36     belong  x               edition %lu,
1052 >40     belong  <0              invalid
1053 >40     belong  x               %lu blocks,
1054 >44     belong  <0              invalid
1055 >44     belong  x               %lu files
1056 >4      belong  x               {jump-to-offset:%lu}
1057 >4      belong  x               {file-size:%lu}
1058
1059
1060
1061 # JFFS2 file system
1062 # If used with binwalk's smart signature feature (on by default, -S to disable)
1063 # this signature can potentially lead to missing some JFFS2 file systems if there
1064 # are multiple JFFS2 file systems in a target file and there are no other identified
1065 # files in between the JFFS2 file systems. This is an unlikely scenario however, and
1066 # the below signatures are much improved in terms of readability and accuracy in the
1067 # vast majority of real world scenarios.
1068 0               leshort 0x1985  JFFS2 filesystem, little endian
1069 >2              leshort !0xE001
1070 >>2             leshort !0xE002
1071 >>>2            leshort !0x2003
1072 >>>>2           leshort !0x2004
1073 >>>>>2          leshort !0x2006
1074 >>>>>>2         leshort !0xE008
1075 >>>>>>>2        leshort !0xE009 \b, invalid
1076 >(4.l)          leshort !0x1985         
1077 >>(4.l+1)       leshort !0x1985 
1078 >>>(4.l+2)      leshort !0x1985 
1079 >>>>(4.l+3)     leshort !0x1985
1080 >>>>>(4.l)      leshort !0xFFFF
1081 >>>>>>(4.l+1)   leshort !0xFFFF
1082 >>>>>>>(4.l+2)  leshort !0xFFFF
1083 >>>>>>>>(4.l+3) leshort !0xFFFF \b, invalid
1084 >4              lelong  0       invalid
1085 >4              lelong  <0      invalid
1086 >4              lelong  x       {one-of-many}{jump-to-offset:%d}
1087
1088 0               beshort 0x1985  JFFS2 filesystem, big endian
1089 >2              beshort !0xE001
1090 >>2             beshort !0xE002
1091 >>>2            beshort !0x2003
1092 >>>>2           beshort !0x2004
1093 >>>>>2          beshort !0x2006
1094 >>>>>>2         beshort !0xE008
1095 >>>>>>>2        beshort !0xE009 \b, invalid
1096 >(4.L)          beshort !0x1985  
1097 >>(4.L+1)       beshort !0x1985  
1098 >>>(4.L+2)      beshort !0x1985
1099 >>>>(4.L+3)     beshort !0x1985 
1100 >>>>>(4.L)      beshort !0xFFFF
1101 >>>>>>(4.L+1)   beshort !0xFFFF
1102 >>>>>>>(4.L+2)  beshort !0xFFFF
1103 >>>>>>>>(4.L+3) beshort !0xFFFF \b, invalid
1104 >4              belong  0       invalid
1105 >4              belong  <0      invalid
1106 >4              belong  x       {one-of-many}{jump-to-offset:%d}
1107
1108
1109 # Squashfs, big endian
1110 0       string  sqsh    Squashfs filesystem, big endian,
1111 >28     beshort >10     invalid
1112 >28     beshort <1      invalid
1113 >30     beshort >10     invalid
1114 >28     beshort x       version %d.
1115 >30     beshort x       \b%d,
1116 >28     beshort >3      compression:
1117 >>20    beshort 1       \bgzip,
1118 >>20    beshort 2       \blzma,
1119 >>20    beshort 3       \bgzip (non-standard type definition),
1120 >>20    beshort 4       \blzma (non-standard type definition),
1121 >>20    beshort 0       \binvalid,
1122 >>20    beshort >4      \binvalid,
1123 >28     beshort <3
1124 >>8     belong  x       size: %d bytes,
1125 >28     beshort 3
1126 >>63    bequad x        size: %lld bytes,
1127 >28     beshort >3
1128 >>40    bequad  x       size: %lld bytes,
1129 >4      belong  x       %d inodes,
1130 >28     beshort >3
1131 >>12    belong          blocksize: %d bytes,
1132 >28     beshort <2
1133 >>32    beshort x       blocksize: %d bytes,
1134 >28     beshort 2
1135 >>51    belong  x       blocksize: %d bytes,
1136 >28     beshort 3
1137 >>51    belong  x       blocksize: %d bytes,
1138 >28     beshort >3
1139 >>12    belong  x       blocksize: %d bytes,
1140 >28     beshort <4
1141 >>39    bedate  x       created: %s
1142 >28     beshort >3
1143 >>8     bedate x        created: %s
1144 >28     beshort <3
1145 >>8     belong  x       {jump-to-offset:%d}
1146 >28     beshort 3       
1147 >>63    bequad  x       {jump-to-offset:%lld}
1148 >28     beshort >3
1149 >>40    bequad  x       {jump-to-offset:%lld}
1150
1151 # Squashfs, little endian
1152 0       string  hsqs    Squashfs filesystem, little endian,
1153 >28     leshort >10     invalid
1154 >28     leshort <1      invalid
1155 >30     leshort >10     invalid
1156 >28     leshort x       version %d.
1157 >30     leshort x       \b%d,
1158 >28     leshort >3      compression:
1159 >>20    leshort 1       \bgzip,
1160 >>20    leshort 2       \blzma,
1161 >>20    leshort 3       \bgzip (non-standard type definition),
1162 >>20    leshort 4       \blzma (non-standard type definition),
1163 >>20    leshort 0       \binvalid,
1164 >>20    leshort >4      \binvalid,
1165 >28     leshort <3
1166 >>8     lelong  x       size: %d bytes,
1167 >>8     lelong  x       {file-size:%d}
1168 >28     leshort 3
1169 >>63    lequad x        size: %lld bytes,
1170 >>63    lequad x        {file-size:%lld}
1171 >28     leshort >3      
1172 >>40    lequad  x       size: %lld bytes,
1173 >>40    lequad  x       {file-size:%lld}
1174 >4      lelong  x       %d inodes,
1175 >28     leshort >3
1176 >>12    lelong          blocksize: %d bytes,
1177 >28     leshort <2
1178 >>32    leshort x       blocksize: %d bytes,
1179 >28     leshort 2
1180 >>51    lelong  x       blocksize: %d bytes,
1181 >28     leshort 3
1182 >>51    lelong  x       blocksize: %d bytes,
1183 >28     leshort >3      
1184 >>12    lelong  x       blocksize: %d bytes,
1185 >28     leshort <4
1186 >>39    ledate  x       created: %s
1187 >28     leshort >3
1188 >>8     ledate x        created: %s
1189 >28     leshort <3
1190 >>8     lelong  x       {jump-to-offset:%d}
1191 >28     leshort 3
1192 >>63    lequad x        {jump-to-offset:%lld}
1193 >28     leshort >3
1194 >>40    lequad  x       {jump-to-offset:%lld}
1195
1196 # Squashfs with LZMA compression
1197 0       string  sqlz    Squashfs filesystem, big endian, lzma compression, 
1198 >28     beshort >10     invalid
1199 >28     beshort <1      invalid
1200 >30     beshort >10     invalid
1201 >28     beshort x       version %d.
1202 >30     beshort x       \b%d,
1203 >28     beshort >3      compression:
1204 >>20    beshort 1       \bgzip,
1205 >>20    beshort 2       \blzma,
1206 >>20    beshort 3       \bgzip (non-standard type definition),
1207 >>20    beshort 4       \blzma (non-standard type definition),
1208 >>20    beshort 0       \binvalid,
1209 >>20    beshort >4      \binvalid,
1210 >28     beshort <3
1211 >>8     belong  x       size: %d bytes,
1212 >>8     belong  x       {file-size:%d}
1213 >28     beshort 3
1214 >>63    bequad x        size: %lld bytes,
1215 >>63    bequad x        {file-size:%lld}
1216 >28     beshort >3
1217 >>40    bequad  x       size: %lld bytes,
1218 >>40    bequad  x       {file-size:%lld}
1219 >4      belong  x       %d inodes,
1220 >28     beshort >3
1221 >>12    belong          blocksize: %d bytes,
1222 >28     beshort <2
1223 >>32    beshort x       blocksize: %d bytes,
1224 >28     beshort 2
1225 >>51    belong  x       blocksize: %d bytes,
1226 >28     beshort 3
1227 >>51    belong  x       blocksize: %d bytes,
1228 >28     beshort >3
1229 >>12    belong  x       blocksize: %d bytes,
1230 >28     beshort <4
1231 >>39    bedate  x       created: %s
1232 >28     beshort >3
1233 >>8     bedate x        created: %s
1234 >28     beshort <3
1235 >>8     belong  x       {jump-to-offset:%d}
1236 >28     beshort 3
1237 >>63    bequad  x       {jump-to-offset:%lld}
1238 >28     beshort >3
1239 >>40    bequad  x       {jump-to-offset:%lld}
1240
1241 # Squashfs 3.3 LZMA signature
1242 0       string  qshs    Squashfs filesystem, big endian, lzma signature,
1243 >28     beshort >10     invalid
1244 >28     beshort <1      invalid
1245 >30     beshort >10     invalid
1246 >28     beshort x       version %d.
1247 >30     beshort x       \b%d,
1248 >28     beshort >3      compression:
1249 >>20    beshort 1       \bgzip,
1250 >>20    beshort 2       \blzma,
1251 >>20    beshort 3       \bgzip (non-standard type definition),
1252 >>20    beshort 4       \blzma (non-standard type definition),
1253 >>20    beshort 0       \binvalid,
1254 >>20    beshort >4      \binvalid,
1255 >28     beshort <3
1256 >>8     belong  x       size: %d bytes,
1257 >>8     belong  x       {file-size:%d}
1258 >28     beshort 3
1259 >>63    bequad x        size: %lld bytes,
1260 >>63    bequad x        {file-size:%lld}
1261 >28     beshort >3
1262 >>40    bequad  x       size: %lld bytes,
1263 >>40    bequad  x       {file-size:%lld}
1264 >4      belong  x       %d inodes,
1265 >28     beshort >3
1266 >>12    belong          blocksize: %d bytes,
1267 >28     beshort <2
1268 >>32    beshort x       blocksize: %d bytes,
1269 >28     beshort 2
1270 >>51    belong  x       blocksize: %d bytes,
1271 >28     beshort 3
1272 >>51    belong  x       blocksize: %d bytes,
1273 >28     beshort >3
1274 >>12    belong  x       blocksize: %d bytes,
1275 >28     beshort <4
1276 >>39    bedate  x       created: %s
1277 >28     beshort >3
1278 >>8     bedate x        created: %s
1279 >28     beshort <3
1280 >>8     belong  x       {jump-to-offset:%d}
1281 >28     beshort 3
1282 >>63    bequad  x       {jump-to-offset:%lld}
1283 >28     beshort >3
1284 >>40    bequad  x       {jump-to-offset:%lld}
1285
1286 # Squashfs for DD-WRT
1287 0       string  tqsh    Squashfs filesystem, big endian, DD-WRT signature,
1288 >28     beshort >10     invalid
1289 >28     beshort <1      invalid
1290 >30     beshort >10     invalid
1291 >28     beshort x       version %d.
1292 >30     beshort x       \b%d,
1293 >28     beshort >3      compression:
1294 >>20    beshort 1       \bgzip,
1295 >>20    beshort 2       \blzma,
1296 >>20    beshort 3       \bgzip (non-standard type definition),
1297 >>20    beshort 4       \blzma (non-standard type definition),
1298 >>20    beshort 0       \binvalid,
1299 >>20    beshort >4      \binvalid,
1300 >28     beshort <3
1301 >>8     belong  x       size: %d bytes,
1302 >>8     belong  x       {file-size:%d}
1303 >28     beshort 3
1304 >>63    bequad x        size: %lld bytes,
1305 >>63    bequad x        {file-size:%lld}
1306 >28     beshort >3
1307 >>40    bequad  x       size: %lld bytes,
1308 >>40    bequad  x       {file-size:%lld}
1309 >4      belong  x       %d inodes,
1310 >28     beshort >3
1311 >>12    belong          blocksize: %d bytes,
1312 >28     beshort <2
1313 >>32    beshort x       blocksize: %d bytes,
1314 >28     beshort 2
1315 >>51    belong  x       blocksize: %d bytes,
1316 >28     beshort 3
1317 >>51    belong  x       blocksize: %d bytes,
1318 >28     beshort >3
1319 >>12    belong  x       blocksize: %d bytes,
1320 >28     beshort <4
1321 >>39    bedate  x       created: %s
1322 >28     beshort >3
1323 >>8     bedate x        created: %s
1324 >28     beshort <3
1325 >>8     belong  x       {jump-to-offset:%d}
1326 >28     beshort 3
1327 >>63    bequad  x       {jump-to-offset:%lld}
1328 >28     beshort >3
1329 >>40    bequad  x       {jump-to-offset:%lld}
1330
1331 # Squashfs for DD-WRT
1332 0       string  hsqt    Squashfs filesystem, little endian, DD-WRT signature,
1333 >28     leshort >10     invalid
1334 >28     leshort <1      invalid
1335 >30     leshort >10     invalid
1336 >28     leshort x       version %d.
1337 >30     leshort x       \b%d,
1338 >28     leshort >3      compression:
1339 >>20    leshort 1       \bgzip,
1340 >>20    leshort 2       \blzma,
1341 >>20    leshort 3       \bgzip (non-standard type definition),
1342 >>20    leshort 4       \blzma (non-standard type definition),
1343 >>20    leshort 0       \binvalid,
1344 >>20    leshort >4      \binvalid,
1345 >28     leshort <3
1346 >>8     lelong  x       size: %d bytes,
1347 >>8     lelong  x       {file-size:%d}
1348 >28     leshort 3
1349 >>63    lequad x        size: %lld bytes,
1350 >>63    lequad x        {file-size:%lld}
1351 >28     leshort >3
1352 >>40    lequad  x       size: %lld bytes,
1353 >>40    lequad  x       {file-size:%lld}
1354 >4      lelong  x       %d inodes,
1355 >28     leshort >3
1356 >>12    lelong          blocksize: %d bytes,
1357 >28     leshort <2
1358 >>32    leshort x       blocksize: %d bytes,
1359 >28     leshort 2
1360 >>51    lelong  x       blocksize: %d bytes,
1361 >28     leshort 3
1362 >>51    lelong  x       blocksize: %d bytes,
1363 >28     leshort >3
1364 >>12    lelong  x       blocksize: %d bytes,
1365 >28     leshort <4
1366 >>39    ledate  x       created: %s
1367 >28     leshort >3
1368 >>8     ledate x        created: %s
1369 >28     leshort <3
1370 >>8     lelong  x       {jump-to-offset:%d}
1371 >28     leshort 3
1372 >>63    lequad x        {jump-to-offset:%lld}
1373 >28     leshort >3
1374 >>40    lequad  x       {jump-to-offset:%lld}
1375
1376 # Non-standard Squashfs signature found on some D-Link routers
1377 0       string  shsq    Squashfs filesystem, little endian, non-standard signature, 
1378 >28     leshort >10     invalid
1379 >28     leshort <1      invalid
1380 >30     leshort >10     invalid
1381 >28     leshort x       version %d.
1382 >30     leshort x       \b%d,
1383 >28     leshort >3      compression:
1384 >>20    leshort 1       \bgzip,
1385 >>20    leshort 2       \blzma,
1386 >>20    leshort 3       \bgzip (non-standard type definition),
1387 >>20    leshort 4       \blzma (non-standard type definition),
1388 >>20    leshort 0       \binvalid,
1389 >>20    leshort >4      \binvalid,
1390 >28     leshort <3
1391 >>8     lelong  x       size: %d bytes,
1392 >>8     lelong  x       {file-size:%d}
1393 >28     leshort 3
1394 >>63    lequad x        size: %lld bytes,
1395 >>63    lequad x        {file-size:%lld}
1396 >28     leshort >3
1397 >>40    lequad  x       size: %lld bytes,
1398 >>40    lequad  x       {file-size:%lld}
1399 >4      lelong  x       %d inodes,
1400 >28     leshort >3
1401 >>12    lelong          blocksize: %d bytes,
1402 >28     leshort <2
1403 >>32    leshort x       blocksize: %d bytes,
1404 >28     leshort 2
1405 >>51    lelong  x       blocksize: %d bytes,
1406 >28     leshort 3
1407 >>51    lelong  x       blocksize: %d bytes,
1408 >28     leshort >3
1409 >>12    lelong  x       blocksize: %d bytes,
1410 >28     leshort <4
1411 >>39    ledate  x       created: %s
1412 >28     leshort >3
1413 >>8     ledate x        created: %s
1414 >28     leshort <3
1415 >>8     lelong  x       {jump-to-offset:%d}
1416 >28     leshort 3
1417 >>63    lequad x        {jump-to-offset:%lld}
1418 >28     leshort >3
1419 >>40    lequad  x       {jump-to-offset:%lld}
1420
1421 # ext2/ext3 filesystems - Andreas Dilger <adilger@dilger.ca>
1422 # ext4 filesystem - Eric Sandeen <sandeen@sandeen.net>
1423 # volume label and UUID Russell Coker
1424 # http://etbe.coker.com.au/2008/07/08/label-vs-uuid-vs-device/
1425 0   leshort         0xEF53              Linux EXT filesystem,{offset-adjust:-0x438}
1426 >2      leshort         >4              invalid state
1427 >2      leshort         3               invalid state
1428 >2      leshort         <0              invalid state
1429 >4      leshort         >3              invalid error behavior
1430 >4      leshort         <0              invalid error behavior
1431 >4      lelong          >1              invalid major revision
1432 >4  lelong              <0              invalid major revision
1433 >4  lelong          x               rev %d
1434 >6  leshort         x               \b.%d
1435 # No journal?  ext2
1436 >36  lelong          ^0x0000004      ext2 filesystem data
1437 >>2 leshort         ^0x0000001      (mounted or unclean)
1438 # Has a journal?  ext3 or ext4
1439 >36  lelong          &0x0000004
1440 #  and small INCOMPAT?
1441 >>40 lelong          <0x0000040
1442 #   and small RO_COMPAT?
1443 >>>44 lelong         <0x0000008      ext3 filesystem data
1444 #   else large RO_COMPAT?
1445 >>>44 lelong         >0x0000007      ext4 filesystem data
1446 #  else large INCOMPAT?
1447 >>40 lelong          >0x000003f      ext4 filesystem data
1448 >48  belong          x               \b, UUID=%08x
1449 >52  beshort         x               \b-%04x
1450 >54  beshort         x               \b-%04x
1451 >56  beshort         x               \b-%04x
1452 >58  belong          x               \b-%08x
1453 >60  beshort         x               \b%04x
1454 >64  string          >0              \b, volume name "%s"
1455
1456
1457 #romfs filesystems - Juan Cespedes <cespedes@debian.org>
1458 0       string  -rom1fs-\0              romfs filesystem, version 1
1459 >8      belong  >10000000               invalid
1460 >8      belong  x                       size: %d bytes,
1461 >16     string  x                       {file-name:%s}
1462 >16     string  x                       named "%s"
1463 >8      belong  x                       {file-size:%d}
1464 >8      belong  x                       {jump-to-offset:%d}
1465
1466 # Wind River MemFS file system, found in some VxWorks devices
1467 0       string  owowowowowowowowowowowowowowow          Wind River management filesystem,
1468 >30     string  !ow                                     invalid,
1469 >32     belong  1                                       compressed,
1470 >32     belong  2                                       plain text,
1471 >36     belong  x                                       %d files
1472
1473 # netboot image - Juan Cespedes <cespedes@debian.org>
1474 0       lelong                  0x1b031336L     Netboot image,
1475 >4      lelong&0xFFFFFF00       0
1476 >>4     lelong&0x100            0x000           mode 2
1477 >>4     lelong&0x100            0x100           mode 3
1478 >4      lelong&0xFFFFFF00       !0              unknown mode (invalid)
1479
1480 0       string                  WDK\x202.0\x00  WDK file system, version 2.0{offset-adjust:-18}
1481
1482 0       string          CD001                                           ISO{offset-adjust:-32769}
1483 >6144   string          !NSR0                                           9660 CD-ROM filesystem data,
1484 >6144   string          NSR0                                            UDF filesystem data,
1485 >6148   string          1                                               version 1.0,
1486 >6148   string          2                                               version 2.0,
1487 >6148   string          3                                               version 3.0
1488 >6148   byte            >0x33                                           invalid version,
1489 >6148   byte            <0x31                                           invalid version,
1490 >38     string          >\0                                             volume name: "%s",
1491 >2047   string          \000CD001\001EL\x20TORITO\x20SPECIFICATION      bootable
1492
1493
1494 #--------------------------Firmware Formats---------------------------
1495
1496 # uImage file     
1497 # From: Craig Heffner, U-Boot image.h header definitions file
1498 0       belong  0x27051956      uImage header, header size: 64 bytes,
1499 >4      belong  x               header CRC: 0x%X,
1500 >8      bedate  x               created: %s,
1501 >12     belong  x               image size: %d bytes,
1502 >16     belong  x               Data Address: 0x%X,
1503 >20     belong  x               Entry Point: 0x%X,
1504 >24     belong  x               data CRC: 0x%X,
1505 #>28    byte    x               OS type: %d,
1506 >28     byte    0               OS: invalid OS,
1507 >28     byte    1               OS: OpenBSD,
1508 >28     byte    2               OS: NetBSD,
1509 >28     byte    3               OS: FreeBSD,
1510 >28     byte    4               OS: 4.4BSD,
1511 >28     byte    5               OS: Linux,
1512 >28     byte    6               OS: SVR4,
1513 >28     byte    7               OS: Esix,
1514 >28     byte    8               OS: Solaris,
1515 >28     byte    9               OS: Irix,
1516 >28     byte    10              OS: SCO,
1517 >28     byte    11              OS: Dell,
1518 >28     byte    12              OS: NCR,
1519 >28     byte    13              OS: LynxOS,
1520 >28     byte    14              OS: VxWorks,
1521 >28     byte    15              OS: pSOS,
1522 >28     byte    16              OS: QNX,
1523 >28     byte    17              OS: Firmware,
1524 >28     byte    18              OS: RTEMS,
1525 >28     byte    19              OS: ARTOS,
1526 >28     byte    20              OS: Unity OS,
1527 #>29    byte    x               CPU arch: %d,
1528 >29     byte    0               CPU: invalid OS,
1529 >29     byte    1               CPU: Alpha,
1530 >29     byte    2               CPU: ARM,
1531 >29     byte    3               CPU: Intel x86,
1532 >29     byte    4               CPU: IA64,
1533 >29     byte    5               CPU: MIPS,
1534 >29     byte    6               CPU: MIPS 64 bit,
1535 >29     byte    7               CPU: PowerPC,
1536 >29     byte    8               CPU: IBM S390,
1537 >29     byte    9               CPU: SuperH,
1538 >29     byte    10              CPU: Sparc,
1539 >29     byte    11              CPU: Sparc 64 bit,
1540 >29     byte    12              CPU: M68K,
1541 >29     byte    13              CPU: Nios-32,
1542 >29     byte    14              CPU: MicroBlaze,
1543 >29     byte    15              CPU: Nios-II,
1544 >29     byte    16              CPU: Blackfin,
1545 >29     byte    17              CPU: AVR,
1546 >29     byte    18              CPU: STMicroelectronics ST200,
1547 #>30    byte    x               image type: %d,
1548 >30     byte    0               image type: invalid Image,
1549 >30     byte    1               image type: Standalone Program,
1550 >30     byte    2               image type: OS Kernel Image,
1551 >30     byte    3               image type: RAMDisk Image,
1552 >30     byte    4               image type: Multi-File Image,
1553 >30     byte    5               image type: Firmware Image,
1554 >30     byte    6               image type: Script file,
1555 >30     byte    7               image type: Filesystem Image,
1556 >30     byte    8               image type: Binary Flat Device Tree Blob
1557 #>31    byte    x               compression type: %d,
1558 >31     byte    0               compression type: none,
1559 >31     byte    1               compression type: gzip,
1560 >31     byte    2               compression type: bzip2,
1561 >31     byte    3               compression type: lzma,
1562 >32     string  x               image name: "%s"
1563
1564 #IMG0 header, found in VxWorks-based Mercury router firmware
1565 0       string          IMG0            IMG0 (VxWorks) header,
1566 >4      belong          x               size: %d
1567
1568 #Mediatek bootloader signature
1569 #From xp-dev.com
1570 0       string          BOOTLOADER!     Mediatek bootloader
1571
1572 #CSYS header formats
1573 0       string          CSYS\x00        CSYS header, little endian, 
1574 >8      lelong          x               size: %d
1575
1576 0       string          CSYS\x80        CSYS header, big endian,
1577 >8      belong          x               size: %d
1578
1579 # wrgg firmware image
1580 0       string          wrgg02          WRGG firmware header,
1581 >6      string          x               name: "%s",
1582 >48     string          x               root device: "%s"
1583
1584 # trx image file
1585 0       string          HDR0            TRX firmware header, little endian, header size: 28 bytes,
1586 >4      lelong          <1              invalid
1587 >4      lelong          x               image size: %d bytes,
1588 >8      lelong          x               CRC32: 0x%X
1589 >12     leshort         x               flags: 0x%X,
1590 >14     leshort         x               version: %d
1591
1592 0       string          0RDH            TRX firmware header, big endian, header size: 28 bytes,
1593 >4      belong          <1              invalid
1594 >4      belong          x               image size: %d bytes,
1595 >8      belong          x               CRC32: 0x%X
1596 >12     beshort         x               flags: 0x%X,
1597 >14     beshort         x               version: %d
1598
1599
1600 # Ubicom firmware image
1601 0       belong  0xFA320080              Ubicom firmware header,
1602 >12     belong  x                       checksum: 0x%X,
1603 >24     belong  <0                      invalid
1604 >24     belong  x                       image size: %d
1605
1606 # The ROME bootloader is used by several RealTek-based products.
1607 # Unfortunately, the magic bytes are specific to each product, so
1608 # separate signatures must be created for each one.
1609
1610 # Netgear KWGR614 ROME image
1611 0       string          G614            Realtek firmware header (ROME bootloader),
1612 >4      beshort         0xd92f          image type: KFS,
1613 >4      beshort         0xb162          image type: RDIR,
1614 >4      beshort         0xea43          image type: BOOT,
1615 >4      beshort         0x8dc9          image type: RUN,
1616 >4      beshort         0x2a05          image type: CCFG,
1617 >4      beshort         0x6ce8          image type: DCFG,
1618 >4      beshort         0xc371          image type: LOG,
1619 >6      byte            x               header version: %d,
1620 #month
1621 >10     byte            x               created: %d/
1622 #day    
1623 >12     byte            x               \b%d/
1624 #year
1625 >8      beshort         x               \b%d,
1626 >16     belong          x               image size: %d bytes,
1627 >22     byte            x               body checksum: 0x%X,
1628 >23     byte            x               header checksum: 0x%X
1629
1630 # Linksys WRT54GX ROME image
1631 0       belong          0x59a0e842      Realtek firmware header (ROME bootloader)
1632 >4      beshort         0xd92f          image type: KFS,
1633 >4      beshort         0xb162          image type: RDIR,
1634 >4      beshort         0xea43          image type: BOOT,
1635 >4      beshort         0x8dc9          image type: RUN,
1636 >4      beshort         0x2a05          image type: CCFG,
1637 >4      beshort         0x6ce8          image type: DCFG,
1638 >4      beshort         0xc371          image type: LOG,
1639 >6      byte            x               header version: %d,
1640 #month
1641 >10     byte            x               created: %d/
1642 #day    
1643 >12     byte            x               \b%d/
1644 #year
1645 >8      beshort         x               \b%d,
1646 >16     belong          x               image size: %d bytes,
1647 >22     byte            x               body checksum: 0x%X,
1648 >23     byte            x               header checksum: 0x%X
1649
1650 # PackImg tag, somtimes used as a delimiter between the kernel and rootfs in firmware images.
1651 0       string          --PaCkImGs--    PackImg section delimiter tag,
1652 # If the size in both big and little endian is greater than 512MB, consider this a false positive
1653 >16     lelong          >0x20000000
1654 >>16    belong          >0x20000000     invalid
1655 >16     lelong          <0
1656 >>16    belong          <0              invalid
1657 >16     lelong          >0
1658 >>16    lelong          x               little endian size: %d bytes;
1659 >16     belong          >0              
1660 >>16    belong          x               big endian size: %d bytes
1661
1662
1663 #------------------------------------------------------------------------------
1664 # Broadcom header format
1665 #
1666 0       string          BCRM            Broadcom header,
1667 >4      lelong          <0              invalid
1668 >4      lelong          x               number of sections: %d,
1669 >>8     lelong          18              first section type: flash
1670 >>8     lelong          19              first section type: disk
1671 >>8     lelong          21              first section type: tag
1672
1673
1674 # Berkeley Lab Checkpoint Restart (BLCR) checkpoint context files
1675 # http://ftg.lbl.gov/checkpoint
1676 0       string  Ck0\0\0R\0\0\0  BLCR
1677 >16     lelong  1       x86
1678 >16     lelong  3       alpha
1679 >16     lelong  5       x86-64
1680 >16     lelong  7       ARM
1681 >8      lelong  x       context data (little endian, version %d)
1682
1683 0       string  \0\0\0C\0\0\0R  BLCR
1684 >16     belong  2       SPARC
1685 >16     belong  4       ppc
1686 >16     belong  6       ppc64
1687 >16     belong  7       ARMEB
1688 >16     belong  8       SPARC64
1689 >8      belong  x       context data (big endian, version %d)
1690
1691 # Aculab VoIP firmware
1692 # From: Mark Brown <broonie@sirena.org.uk>
1693 0       string  VoIP\x20Startup\x20and      Aculab VoIP firmware
1694 >35     string  x       format "%s"
1695
1696 #------------------------------------------------------------------------------
1697 # HP LaserJet 1000 series downloadable firmware file
1698 0       string  \xbe\xefABCDEFGH        HP LaserJet 1000 series downloadable firmware
1699
1700 # From Albert Cahalan <acahalan@gmail.com>
1701 # really le32 operation,destination,payloadsize (but quite predictable)
1702 # 01 00 00 00 00 00 00 c0 00 02 00 00
1703 0       string          \1\0\0\0\0\0\0\300\0\2\0\0      Marvell Libertas firmware
1704
1705 #---------------------------------------------------------------------------
1706 # The following entries have been tested by Duncan Laurie <duncan@sun.com> (a
1707 # lead Sun/Cobalt developer) who agrees that they are good and worthy of
1708 # inclusion.
1709
1710 # Boot ROM images for Sun/Cobalt Linux server appliances
1711 0       string  Cobalt\x20Networks\x20Inc.\nFirmware\x20v     Paged COBALT boot rom
1712 >38     string x        V%.4s
1713
1714 # New format for Sun/Cobalt boot ROMs is annoying, it stores the version code
1715 # at the very end where file(1) can't get it.
1716 0       string CRfs     COBALT boot rom data (Flat boot rom or file system)
1717
1718 #
1719 # Motorola S-Records, from Gerd Truschinski <gt@freebsd.first.gmd.de>
1720 # Useless until forther improvements can be made to the signature.
1721 #0   string      S0          Motorola S-Record; binary data in text format
1722
1723 # --------------------------------
1724 # Microsoft Xbox data file formats
1725 0       string          XIP0            XIP, Microsoft Xbox data
1726 0       string          XTF0            XTF, Microsoft Xbox data
1727
1728 #Windows CE
1729 0       string          CECE            Windows CE RTOS{offset-adjust:-64}
1730
1731 # --------------------------------
1732 # ZynOS ROM header format
1733 # From openwrt zynos.h.
1734 0       string          SIG             ZynOS header, header size: 48 bytes,{offset-adjust:-6}
1735 #>0     belong          x               load address 0x%X,
1736 >3      byte            <0x7F           rom image type:
1737 >>3     byte            <1              invalid,
1738 >>3     byte            >7              invalid,
1739 >>3     byte            1               ROMIMG,
1740 >>3     byte            2               ROMBOOT,
1741 >>3     byte            3               BOOTEXT,
1742 >>3     byte            4               ROMBIN,
1743 >>3     byte            5               ROMDIR,
1744 >>3     byte            6               6,
1745 >>3     byte            7               ROMMAP,
1746 >3      byte            >0x7F           ram image type:
1747 >>3     byte            >0x82           invalid,
1748 >>3     byte            0x80            RAM,
1749 >>3     byte            0x81            RAMCODE,
1750 >>3     byte            0x82            RAMBOOT,
1751 >4      belong          >0x40000000     invalid
1752 >4      belong          <0              invalid
1753 >4      belong          0               invalid
1754 >4      belong          x               uncompressed size: %d,
1755 >8      belong          >0x40000000     invalid
1756 >8      belong          <0              invalid
1757 >8      belong          0               invalid
1758 >8      belong          x               compressed size: %d,
1759 >14     beshort         x               uncompressed checksum: 0x%X,
1760 >16     beshort         x               compressed checksum: 0x%X,
1761 >12     byte            x               flags: 0x%X,
1762 >12     byte            &0x40           uncompressed checksum is valid,
1763 >12     byte            &0x80           the binary is compressed,
1764 >>12    byte            &0x20           compressed checksum is valid,
1765 >35     belong          x               memory map table address: 0x%X
1766
1767 # Firmware header used by some VxWorks-based Cisco products
1768 0       string          CI032.00        Cisco VxWorks firmware header,
1769 >8      lelong          >1024           invalid
1770 >8      lelong          <0              invalid
1771 >8      lelong          x               header size: %d bytes,
1772 >32     lelong          >1024           invalid
1773 >32     lelong          <0              invalid
1774 >32     lelong          x               number of files: %d,
1775 >48     lelong          <0              invalid
1776 >48     lelong          x               image size: %d,
1777 >64     string          x               firmware version: "%s"
1778
1779 # Firmware header used by some TV's
1780 0       string          FNIB            ZBOOT firmware header, header size: 32 bytes,
1781 >8      lelong          x               load address: 0x%.8X,
1782 >12     lelong          x               start address: 0x%.8X,
1783 >16     lelong          x               checksum: 0x%.8X,
1784 >20     lelong          x               version: 0x%.8X,
1785 >24     lelong          <1              invalid
1786 >24     lelong          x               image size: %d bytes
1787
1788 # Firmware header used by several D-Link routers (and probably others)
1789 0               string  \x5e\xa3\xa4\x17        DLOB firmware header,
1790 >(7.b+12)       string  !\x5e\xa3\xa4\x17       invalid,
1791 #>>12           string  x                       %s,
1792 >(7.b+40)       string  x                       boot partition: "%s"
1793
1794 # TP-Link firmware header structure; thanks to Jonathan McGowan for reversing and documenting this format
1795 0       string          TP-LINK\x20Technologies         TP-Link firmware header,{offset-adjust:-4}
1796 #>-4    lelong          x                               header version: %d,
1797 >0x94   beshort         x                               firmware version: %d.
1798 >0x96   beshort         x                               \b%d.
1799 >0x98   beshort         x                               \b%d,
1800 >0x18   string          x                               image version: "%s",
1801 #>0x74  belong          x                               image size: %d bytes,
1802 >0x3C   belong          x                               product ID: 0x%X,
1803 >0x40   belong          x                               product version: %d,
1804 >0x70   belong          x                               kernel load address: 0x%X,
1805 >0x74   belong          x                               kernel entry point: 0x%X,
1806 >0x7C   belong          x                               kernel offset: %d,
1807 >0x80   belong          x                               kernel length: %d,
1808 >0x84   belong          x                               rootfs offset: %d,
1809 >0x88   belong          x                               rootfs length: %d,
1810 >0x8C   belong          x                               bootloader offset: %d,
1811 >0x90   belong          x                               bootloader length: %d
1812
1813 # Header format from: http://skaya.enix.org/wiki/FirmwareFormat
1814 0       string          \x36\x00\x00\x00                Broadcom 96345 firmware header, header size: 256,
1815 >4      string          !Broadcom
1816 >>4     string          !\x20\x20\x20\x20               invalid
1817 >41     beshort         !0x2020
1818 >>41    beshort         !0x0000
1819 >>>41   string          x                               firmware version: "%.4s",
1820 >45     beshort         !0x0202
1821 >>45    beshort         !0x0000
1822 >>>45   string          x                               board id: "%s",
1823 >236    belong          x                               ~CRC32 header checksum: 0x%X,
1824 >216    belong          x                               ~CRC32 data checksum: 0x%X
1825
1826 # Xerox MFP DLM signatures
1827 0       string          %%XRXbegin                      Xerox DLM firmware start of header
1828 0       string          %%OID_ATT_DLM_NAME              Xerox DLM firmware name:
1829 >19     string          x                               "%s"
1830 0       string          %%OID_ATT_DLM_VERSION           Xerox DLM firmware version:
1831 >22     string          x                               "%s"
1832 0       string          %%XRXend                        Xerox DLM firmware end of header
1833
1834 # Generic copyright signature
1835 0       string          Copyright                       Copyright string:
1836 >9      byte            0                               invalid
1837 >9      string          x                               "%s
1838 >40     string          x                               \b%s"
1839
1840 # Sercomm firmware header
1841 0       string          sErCoMm                         Sercomm firmware signature,
1842 >7      leshort         x                               version control: %d,
1843 >9      leshort         x                               download control: %d,
1844 >11     string          x                               hardware ID: "%s",
1845 >44     leshort         x                               hardware version: 0x%X,
1846 >58     leshort         x                               firmware version: 0x%X,
1847 >60     leshort         x                               starting code segment: 0x%X,
1848 >62     leshort         x                               code size: 0x%X
1849
1850 # NPK firmware header, used by Mikrotik
1851 0               belong          0x1EF1D0BA              NPK firmware header,
1852 >4              lelong          <0                      invalid
1853 >4              lelong          x                       image size: %d,
1854 >14             string          x                       image name: "%s",
1855 >(48.l+58)      string          x                       description: "%s
1856 >(48.l+121)     string          x                       \b%s"
1857
1858 # Ubiquiti firmware signatures
1859 0       string          UBNT            Ubiquiti firmware header,
1860 >0x104  belong          x               ~CRC32: 0x%X,
1861 >4      string          x               version: "%s"
1862
1863 0       string          GEOS            Ubiquiti firmware header,
1864 >0x104  belong          x               ~CRC32: 0x%X,
1865 >4      string          x               version: "%s"
1866
1867 # Too many false positives...
1868 #0      string          OPEN            Ubiquiti firmware header, third party,
1869 #>0x104 belong          x               ~CRC32: 0x%X,
1870 #>4     string          x               version: "%s"
1871
1872 0       string          PARTkernel      Ubiquiti firmware kernel partition
1873 0       string          PARTcramfs      Ubiquiti firmware CramFS partition
1874 0       string          PARTrootfs      Ubiquiti firmware rootfs partition
1875
1876 # Found in DIR-100 firmware
1877 0       string          AIH0N           AIH0N firmware header, header size: 48,
1878 >12     belong          x               size: %d,
1879 >8      belong          !0              executable code,
1880 >>8     belong          x               load address: 0x%X,
1881 >32     string          x               version: "%s"
1882
1883 0       belong          0x5EA3A417      SEAMA firmware header, big endian,
1884 >6      beshort         x               meta size: %d,
1885 >8      belong          x               size: %d
1886
1887 0       lelong          0x5EA3A417      SEAMA firmware header, little endian,
1888 >6      leshort         x               meta size: %d,
1889 >8      lelong          x               size: %d
1890
1891 0       belong          0x4D544443      NSP firmware header, big endian,
1892 >16     belong          x               header size: %d,
1893 >20     belong          x               image size: %d,
1894 >4      belong          x               kernel offset: %d,
1895 >12     belong          x               header version: %d,
1896
1897 0       lelong          0x4D544443      NSP firmware header, little endian,
1898 >16     lelong          x               header size: %d,
1899 >20     lelong          x               image size: %d,
1900 >4      lelong          x               kernel offset: %d,
1901 >12     lelong          x               header version: %d,
1902
1903 # http://www.openwiz.org/wiki/Firmware_Layout#Beyonwiz_.wrp_header_structure
1904 0       string          WizFwPkgl       Beyonwiz firmware header,
1905 >20     string          x               version: "%s"
1906
1907 0       string          BLI223WJ0       Thompson/Alcatel encoded firmware,
1908 >32     byte            x               version: %d.
1909 >33     byte            x               \b%d.
1910 >34     byte            x               \b%d.
1911 >35     byte            x               \b%d,
1912 >44     belong          x               size: %d,
1913 >48     belong          x               crc: 0x%.8X,
1914 >35     byte            x               try decryption tool from:
1915 >35     byte            x               http://download.modem-help.co.uk/mfcs-A/Alcatel/Modems/Misc/
1916
1917 # Tag Image File Format, from Daniel Quinlan (quinlan@yggdrasil.com)
1918 # The second word of TIFF files is the TIFF version number, 42, which has
1919 # never changed.  The TIFF specification recommends testing for it.
1920 0       string          MM\x00\x2a      TIFF image data, big-endian
1921 0       string          II\x2a\x00      TIFF image data, little-endian
1922
1923 # PNG [Portable Network Graphics, or "PNG's Not GIF"] images
1924 # (Greg Roelofs, newt@uchicago.edu)
1925 # (Albert Cahalan, acahalan@cs.uml.edu)
1926 #
1927 # 137 P N G \r \n ^Z \n [4-byte length] H E A D [HEAD data] [HEAD crc] ...
1928 #
1929 0       string          \x89PNG\x0d\x0a\x1a\x0a         PNG image
1930 >16     belong          x               \b, %ld x
1931 >20     belong          x               %ld,
1932 >24     byte            x               %d-bit
1933 >25     byte            0               grayscale,
1934 >25     byte            2               \b/color RGB,
1935 >25     byte            3               colormap,
1936 >25     byte            4               gray+alpha,
1937 >25     byte            6               \b/color RGBA,
1938 #>26    byte            0               deflate/32K,
1939 >28     byte            0               non-interlaced
1940 >28     byte            1               interlaced
1941
1942 # GIF
1943 0       string          GIF8            GIF image data
1944 >4      string          7a              \b, version "8%s",
1945 >4      string          9a              \b, version "8%s",
1946 >6      leshort         >0              %hd x
1947 >8      leshort         >0              %hd
1948 #>10    byte            &0x80           color mapped,
1949 #>10    byte&0x07       =0x00           2 colors
1950 #>10    byte&0x07       =0x01           4 colors
1951 #>10    byte&0x07       =0x02           8 colors
1952 #>10    byte&0x07       =0x03           16 colors
1953 #>10    byte&0x07       =0x04           32 colors
1954 #>10    byte&0x07       =0x05           64 colors
1955 #>10    byte&0x07       =0x06           128 colors
1956 #>10    byte&0x07       =0x07           256 colors
1957
1958 # PC bitmaps (OS/2, Windows BMP files)  (Greg Roelofs, newt@uchicago.edu)
1959 0       string          BM
1960 >14     leshort         12              PC bitmap, OS/2 1.x format
1961 >>18    lelong          <1              invalid
1962 >>18    lelong          >1000000        invalid
1963 >>18    leshort         x               \b, %d x
1964 >>20    lelong          <1              invalid
1965 >>20    lelong          >1000000        invalid
1966 >>20    leshort         x               %d
1967 >14     leshort         64              PC bitmap, OS/2 2.x format
1968 >>18    lelong          <1              invalid
1969 >>18    lelong          >1000000        invalid
1970 >>18    leshort         x               \b, %d x
1971 >>20    lelong          <1              invalid
1972 >>20    lelong          >1000000        invalid
1973 >>20    leshort         x               %d
1974 >14     leshort         40              PC bitmap, Windows 3.x format
1975 >>18    lelong          <1              invalid
1976 >>18    lelong          >1000000        invalid
1977 >>18    lelong          x               \b, %d x
1978 >>22    lelong          <1              invalid
1979 >>22    lelong          >1000000        invalid
1980 >>22    lelong          x               %d x
1981 >>28    lelong          <1              invalid
1982 >>28    lelong          >1000000        invalid
1983 >>28    leshort         x               %d
1984 >14     leshort         128             PC bitmap, Windows NT/2000 format
1985 >>18    lelong          >1000000        invalid
1986 >>18    lelong          <1              invalid
1987 >>18    lelong          x               \b, %d x
1988 >>22    lelong          <1              invalid
1989 >>22    lelong          >1000000        invalid
1990 >>22    lelong          x               %d x
1991 >>28    lelong          <1              invalid
1992 >>28    lelong          >1000000        invalid
1993 >>28    leshort         x               %d
1994
1995 #------------------------------------------------------------------------------
1996 # JPEG images
1997 # SunOS 5.5.1 had
1998 #
1999 #       0       string          \377\330\377\340        JPEG file
2000 #       0       string          \377\330\377\356        JPG file
2001 #
2002 # both of which turn into "JPEG image data" here.
2003 #
2004 0       belong          0xffd8ffe0      JPEG image data, JFIF standard 
2005 >6      string          !JFIF           invalid
2006 # The following added by Erik Rossen <rossen@freesurf.ch> 1999-09-06
2007 # in a vain attempt to add image size reporting for JFIF.  Note that these
2008 # tests are not fool-proof since some perfectly valid JPEGs are currently
2009 # impossible to specify in magic(4) format.
2010 # First, a little JFIF version info:
2011 >11    byte            x               \b %d.
2012 >12    byte            x               \b%02d
2013 # Next, the resolution or aspect ratio of the image:
2014 #>>13   byte            0               \b, aspect ratio
2015 #>>13   byte            1               \b, resolution (DPI)
2016 #>>13   byte            2               \b, resolution (DPCM)
2017 #>>4    beshort         x               \b, segment length %d
2018 # Next, show thumbnail info, if it exists:
2019 >18    byte            !0              \b, thumbnail %dx
2020 >>19   byte            x               \b%d
2021
2022
2023 0       belong          0xffd8ffe1      JPEG image data, EXIF standard
2024 # EXIF moved down here to avoid reporting a bogus version number,
2025 # and EXIF version number printing added.
2026 #   - Patrik R=E5dman <patrik+file-magic@iki.fi>
2027 >6      string          !Exif            invalid
2028 # Look for EXIF IFD offset in IFD 0, and then look for EXIF version tag in EXIF IFD.
2029 # All possible combinations of entries have to be enumerated, since no looping
2030 # is possible. And both endians are possible...
2031 # The combinations included below are from real-world JPEGs.
2032 # Little-endian
2033 >12    string          II
2034 # IFD 0 Entry #5:
2035 >>70   leshort         0x8769
2036 # EXIF IFD Entry #1:
2037 >>>(78.l+14)   leshort 0x9000
2038 >>>>(78.l+23)  byte    x               %c
2039 >>>>(78.l+24)  byte    x               \b.%c
2040 >>>>(78.l+25)  byte    !0x30           \b%c
2041 # IFD 0 Entry #9:
2042 >>118  leshort         0x8769
2043 # EXIF IFD Entry #3:
2044 >>>(126.l+38)  leshort 0x9000
2045 >>>>(126.l+47) byte    x               %c
2046 >>>>(126.l+48) byte    x               \b.%c
2047 >>>>(126.l+49) byte    !0x30           \b%c
2048 # IFD 0 Entry #10
2049 >>130  leshort         0x8769
2050 # EXIF IFD Entry #3:
2051 >>>(138.l+38)  leshort 0x9000
2052 >>>>(138.l+47) byte    x               %c
2053 >>>>(138.l+48) byte    x               \b.%c
2054 >>>>(138.l+49) byte    !0x30           \b%c
2055 # EXIF IFD Entry #4:
2056 >>>(138.l+50)  leshort 0x9000
2057 >>>>(138.l+59) byte    x               %c
2058 >>>>(138.l+60) byte    x               \b.%c
2059 >>>>(138.l+61) byte    !0x30           \b%c
2060 # EXIF IFD Entry #5:
2061 >>>(138.l+62)  leshort 0x9000
2062 >>>>(138.l+71) byte    x               %c
2063 >>>>(138.l+72) byte    x               \b.%c
2064 >>>>(138.l+73) byte    !0x30           \b%c
2065 # IFD 0 Entry #11
2066 >>142  leshort         0x8769
2067 # EXIF IFD Entry #3:
2068 >>>(150.l+38)  leshort 0x9000
2069 >>>>(150.l+47) byte    x               %c
2070 >>>>(150.l+48) byte    x               \b.%c
2071 >>>>(150.l+49) byte    !0x30           \b%c
2072 # EXIF IFD Entry #4:
2073 >>>(150.l+50)  leshort 0x9000
2074 >>>>(150.l+59) byte    x               %c
2075 >>>>(150.l+60) byte    x               \b.%c
2076 >>>>(150.l+61) byte    !0x30           \b%c
2077 # EXIF IFD Entry #5:
2078 >>>(150.l+62)  leshort 0x9000
2079 >>>>(150.l+71) byte    x               %c
2080 >>>>(150.l+72) byte    x               \b.%c
2081 >>>>(150.l+73) byte    !0x30           \b%c
2082 # Big-endian
2083 >12    string          MM
2084 # IFD 0 Entry #9:
2085 >>118  beshort         0x8769
2086 # EXIF IFD Entry #1:
2087 >>>(126.L+14)  beshort 0x9000
2088 >>>>(126.L+23) byte    x               %c
2089 >>>>(126.L+24) byte    x               \b.%c
2090 >>>>(126.L+25) byte    !0x30           \b%c
2091 # EXIF IFD Entry #3:
2092 >>>(126.L+38)  beshort 0x9000
2093 >>>>(126.L+47) byte    x               %c
2094 >>>>(126.L+48) byte    x               \b.%c
2095 >>>>(126.L+49) byte    !0x30           \b%c
2096 # IFD 0 Entry #10
2097 >>130  beshort         0x8769
2098 # EXIF IFD Entry #3:
2099 >>>(138.L+38)  beshort 0x9000
2100 >>>>(138.L+47) byte    x               %c
2101 >>>>(138.L+48) byte    x               \b.%c
2102 >>>>(138.L+49) byte    !0x30           \b%c
2103 # EXIF IFD Entry #5:
2104 >>>(138.L+62)  beshort 0x9000
2105 >>>>(138.L+71) byte    x               %c
2106 >>>>(138.L+72) byte    x               \b.%c
2107 >>>>(138.L+73) byte    !0x30           \b%c
2108 # IFD 0 Entry #11
2109 >>142  beshort         0x8769
2110 # EXIF IFD Entry #4:
2111 >>>(150.L+50)  beshort 0x9000
2112 >>>>(150.L+59) byte    x               %c
2113 >>>>(150.L+60) byte    x               \b.%c
2114 >>>>(150.L+61) byte    !0x30           \b%c
2115 # Here things get sticky.  We can do ONE MORE marker segment with
2116 # indirect addressing, and that's all.  It would be great if we could
2117 # do pointer arithemetic like in an assembler language.  Christos?
2118 # And if there was some sort of looping construct to do searches, plus a few
2119 # named accumulators, it would be even more effective...
2120 # At least we can show a comment if no other segments got inserted before:
2121 >(4.S+5)        byte            0xFE
2122 >>(4.S+8)       string          >\0             \b, comment: "%s"
2123 # FIXME: When we can do non-byte counted strings, we can use that to get
2124 # the string's count, and fix Debian bug #283760
2125 #>(4.S+5)       byte            0xFE            \b, comment
2126 #>>(4.S+6)      beshort         x               \b length=%d
2127 #>>(4.S+8)      string          >\0             \b, "%s"
2128 # Or, we can show the encoding type (I've included only the three most common)
2129 # and image dimensions if we are lucky and the SOFn (image segment) is here:
2130 >(4.S+5)        byte            0xC0            \b, baseline
2131 >>(4.S+6)       byte            x               \b, precision %d
2132 >>(4.S+7)       beshort         x               \b, %dx
2133 >>(4.S+9)       beshort         x               \b%d
2134 >(4.S+5)        byte            0xC1            \b, extended sequential
2135 >>(4.S+6)       byte            x               \b, precision %d
2136 >>(4.S+7)       beshort         x               \b, %dx
2137 >>(4.S+9)       beshort         x               \b%d
2138 >(4.S+5)        byte            0xC2            \b, progressive
2139 >>(4.S+6)       byte            x               \b, precision %d
2140 >>(4.S+7)       beshort         x               \b, %dx
2141 >>(4.S+9)       beshort         x               \b%d
2142 # I've commented-out quantisation table reporting.  I doubt anyone cares yet.
2143 #>(4.S+5)       byte            0xDB            \b, quantisation table
2144 #>>(4.S+6)      beshort         x               \b length=%d
2145 #>14    beshort         x               \b, %d x
2146 #>16    beshort         x               \b %d
2147
2148 0       string  M88888888888888888888888888     Binwalk logo, ASCII art (Toph){offset-adjust:-50}
2149 >27     string  !8888888888\n                   invalid
2150
2151
2152 #-------------------------Kernels-------------------------------------
2153
2154 # Linux kernel boot images, from Albert Cahalan <acahalan@cs.uml.edu>
2155 # and others such as Axel Kohlmeyer <akohlmey@rincewind.chemie.uni-ulm.de>
2156 # and Nicolás Lichtmaier <nick@debian.org>
2157 # All known start with: b8 c0 07 8e d8 b8 00 90 8e c0 b9 00 01 29 f6 29
2158 0       string          \xb8\xc0\x07\x8e\xd8\xb8\x00\x90\x8e\xc0\xb9\x00\x01\x29\xf6\x29        Linux kernel boot image
2159 >514    string          !HdrS                                                                   (invalid)
2160
2161 # Finds and prints Linux kernel strings in raw Linux kernels (output like uname -a).
2162 # Commonly found in decompressed embedded kernel binaries.
2163 0       string          Linux\ version\         Linux kernel version
2164 >14     byte            0                       invalid
2165 >14     byte            !0
2166 >>14    string          x                       "%s
2167 >>45    string          x                       \b%s"
2168
2169 # ------------------------------------------------------------------
2170 # Signature for LZMA compressed data with valid properties byte 0x40
2171 # ------------------------------------------------------------------
2172 0               string  \x40\x00\x00    LZMA compressed data, properties: 0x40,
2173
2174 # These are all the valid dictionary sizes supported by LZMA utils.
2175 >1              lelong  !65536  
2176 >>1             lelong  !131072 
2177 >>>1            lelong  !262144 
2178 >>>>1           lelong  !524288 
2179 >>>>>1          lelong  !1048576        
2180 >>>>>>1         lelong  !2097152        
2181 >>>>>>>1        lelong  !4194304        
2182 >>>>>>>>1       lelong  !8388608        
2183 >>>>>>>>>1      lelong  !16777216       
2184 >>>>>>>>>>1     lelong  !33554432       invalid
2185 >1              lelong  x               dictionary size: %d bytes,
2186
2187 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2188 # This could technically be valid, but is unlikely.
2189 >5              lequad  !-1
2190 >>5             lequad  <32             invalid
2191 >>5             lequad  >0x40000000     invalid
2192
2193 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2194 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2195 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2196 >1              lelong  65536
2197 >>5             lequad  65536           invalid
2198 >1              lelong  131072
2199 >>5             lequad  131072          invalid
2200 >1              lelong  262144
2201 >>5             lequad  262144          invalid
2202 >1              lelong  524288
2203 >>5             lequad  524288          invalid
2204 >1              lelong  1048576
2205 >>5             lequad  1048576         invalid
2206 >1              lelong  2097152
2207 >>5             lequad  2097152         invalid
2208 >1              lelong  4194304
2209 >>5             lequad  4194304         invalid
2210 >1              lelong  8388608
2211 >>5             lequad  8388608         invalid
2212 >1              lelong  16777216
2213 >>5             lequad  16777216        invalid
2214 >1              lelong  33554432
2215 >>5             lequad  33554432        invalid
2216 >5              lequad  x               uncompressed size: %lld bytes
2217
2218
2219 # ------------------------------------------------------------------
2220 # Signature for LZMA compressed data with valid properties byte 0x41
2221 # ------------------------------------------------------------------
2222 0               string  \x41\x00\x00    LZMA compressed data, properties: 0x41,
2223
2224 # These are all the valid dictionary sizes supported by LZMA utils.
2225 >1              lelong  !65536  
2226 >>1             lelong  !131072 
2227 >>>1            lelong  !262144 
2228 >>>>1           lelong  !524288 
2229 >>>>>1          lelong  !1048576        
2230 >>>>>>1         lelong  !2097152        
2231 >>>>>>>1        lelong  !4194304        
2232 >>>>>>>>1       lelong  !8388608        
2233 >>>>>>>>>1      lelong  !16777216       
2234 >>>>>>>>>>1     lelong  !33554432       invalid
2235 >1              lelong  x               dictionary size: %d bytes,
2236
2237 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2238 # This could technically be valid, but is unlikely.
2239 >5              lequad  !-1
2240 >>5             lequad  <32             invalid
2241 >>5             lequad  >0x40000000     invalid
2242
2243 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2244 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2245 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2246 >1              lelong  65536
2247 >>5             lequad  65536           invalid
2248 >1              lelong  131072
2249 >>5             lequad  131072          invalid
2250 >1              lelong  262144
2251 >>5             lequad  262144          invalid
2252 >1              lelong  524288
2253 >>5             lequad  524288          invalid
2254 >1              lelong  1048576
2255 >>5             lequad  1048576         invalid
2256 >1              lelong  2097152
2257 >>5             lequad  2097152         invalid
2258 >1              lelong  4194304
2259 >>5             lequad  4194304         invalid
2260 >1              lelong  8388608
2261 >>5             lequad  8388608         invalid
2262 >1              lelong  16777216
2263 >>5             lequad  16777216        invalid
2264 >1              lelong  33554432
2265 >>5             lequad  33554432        invalid
2266 >5              lequad  x               uncompressed size: %lld bytes
2267
2268
2269 # ------------------------------------------------------------------
2270 # Signature for LZMA compressed data with valid properties byte 0x48
2271 # ------------------------------------------------------------------
2272 0               string  \x48\x00\x00    LZMA compressed data, properties: 0x48,
2273
2274 # These are all the valid dictionary sizes supported by LZMA utils.
2275 >1              lelong  !65536  
2276 >>1             lelong  !131072 
2277 >>>1            lelong  !262144 
2278 >>>>1           lelong  !524288 
2279 >>>>>1          lelong  !1048576        
2280 >>>>>>1         lelong  !2097152        
2281 >>>>>>>1        lelong  !4194304        
2282 >>>>>>>>1       lelong  !8388608        
2283 >>>>>>>>>1      lelong  !16777216       
2284 >>>>>>>>>>1     lelong  !33554432       invalid
2285 >1              lelong  x               dictionary size: %d bytes,
2286
2287 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2288 # This could technically be valid, but is unlikely.
2289 >5              lequad  !-1
2290 >>5             lequad  <32             invalid
2291 >>5             lequad  >0x40000000     invalid
2292
2293 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2294 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2295 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2296 >1              lelong  65536
2297 >>5             lequad  65536           invalid
2298 >1              lelong  131072
2299 >>5             lequad  131072          invalid
2300 >1              lelong  262144
2301 >>5             lequad  262144          invalid
2302 >1              lelong  524288
2303 >>5             lequad  524288          invalid
2304 >1              lelong  1048576
2305 >>5             lequad  1048576         invalid
2306 >1              lelong  2097152
2307 >>5             lequad  2097152         invalid
2308 >1              lelong  4194304
2309 >>5             lequad  4194304         invalid
2310 >1              lelong  8388608
2311 >>5             lequad  8388608         invalid
2312 >1              lelong  16777216
2313 >>5             lequad  16777216        invalid
2314 >1              lelong  33554432
2315 >>5             lequad  33554432        invalid
2316 >5              lequad  x               uncompressed size: %lld bytes
2317
2318
2319 # ------------------------------------------------------------------
2320 # Signature for LZMA compressed data with valid properties byte 0x49
2321 # ------------------------------------------------------------------
2322 0               string  \x49\x00\x00    LZMA compressed data, properties: 0x49,
2323
2324 # These are all the valid dictionary sizes supported by LZMA utils.
2325 >1              lelong  !65536  
2326 >>1             lelong  !131072 
2327 >>>1            lelong  !262144 
2328 >>>>1           lelong  !524288 
2329 >>>>>1          lelong  !1048576        
2330 >>>>>>1         lelong  !2097152        
2331 >>>>>>>1        lelong  !4194304        
2332 >>>>>>>>1       lelong  !8388608        
2333 >>>>>>>>>1      lelong  !16777216       
2334 >>>>>>>>>>1     lelong  !33554432       invalid
2335 >1              lelong  x               dictionary size: %d bytes,
2336
2337 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2338 # This could technically be valid, but is unlikely.
2339 >5              lequad  !-1
2340 >>5             lequad  <32             invalid
2341 >>5             lequad  >0x40000000     invalid
2342
2343 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2344 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2345 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2346 >1              lelong  65536
2347 >>5             lequad  65536           invalid
2348 >1              lelong  131072
2349 >>5             lequad  131072          invalid
2350 >1              lelong  262144
2351 >>5             lequad  262144          invalid
2352 >1              lelong  524288
2353 >>5             lequad  524288          invalid
2354 >1              lelong  1048576
2355 >>5             lequad  1048576         invalid
2356 >1              lelong  2097152
2357 >>5             lequad  2097152         invalid
2358 >1              lelong  4194304
2359 >>5             lequad  4194304         invalid
2360 >1              lelong  8388608
2361 >>5             lequad  8388608         invalid
2362 >1              lelong  16777216
2363 >>5             lequad  16777216        invalid
2364 >1              lelong  33554432
2365 >>5             lequad  33554432        invalid
2366 >5              lequad  x               uncompressed size: %lld bytes
2367
2368
2369 # ------------------------------------------------------------------
2370 # Signature for LZMA compressed data with valid properties byte 0x51
2371 # ------------------------------------------------------------------
2372 0               string  \x51\x00\x00    LZMA compressed data, properties: 0x51,
2373
2374 # These are all the valid dictionary sizes supported by LZMA utils.
2375 >1              lelong  !65536  
2376 >>1             lelong  !131072 
2377 >>>1            lelong  !262144 
2378 >>>>1           lelong  !524288 
2379 >>>>>1          lelong  !1048576        
2380 >>>>>>1         lelong  !2097152        
2381 >>>>>>>1        lelong  !4194304        
2382 >>>>>>>>1       lelong  !8388608        
2383 >>>>>>>>>1      lelong  !16777216       
2384 >>>>>>>>>>1     lelong  !33554432       invalid
2385 >1              lelong  x               dictionary size: %d bytes,
2386
2387 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2388 # This could technically be valid, but is unlikely.
2389 >5              lequad  !-1
2390 >>5             lequad  <32             invalid
2391 >>5             lequad  >0x40000000     invalid
2392
2393 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2394 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2395 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2396 >1              lelong  65536
2397 >>5             lequad  65536           invalid
2398 >1              lelong  131072
2399 >>5             lequad  131072          invalid
2400 >1              lelong  262144
2401 >>5             lequad  262144          invalid
2402 >1              lelong  524288
2403 >>5             lequad  524288          invalid
2404 >1              lelong  1048576
2405 >>5             lequad  1048576         invalid
2406 >1              lelong  2097152
2407 >>5             lequad  2097152         invalid
2408 >1              lelong  4194304
2409 >>5             lequad  4194304         invalid
2410 >1              lelong  8388608
2411 >>5             lequad  8388608         invalid
2412 >1              lelong  16777216
2413 >>5             lequad  16777216        invalid
2414 >1              lelong  33554432
2415 >>5             lequad  33554432        invalid
2416 >5              lequad  x               uncompressed size: %lld bytes
2417
2418
2419 # ------------------------------------------------------------------
2420 # Signature for LZMA compressed data with valid properties byte 0x5A
2421 # ------------------------------------------------------------------
2422 0               string  \x5A\x00\x00    LZMA compressed data, properties: 0x5A,
2423
2424 # These are all the valid dictionary sizes supported by LZMA utils.
2425 >1              lelong  !65536  
2426 >>1             lelong  !131072 
2427 >>>1            lelong  !262144 
2428 >>>>1           lelong  !524288 
2429 >>>>>1          lelong  !1048576        
2430 >>>>>>1         lelong  !2097152        
2431 >>>>>>>1        lelong  !4194304        
2432 >>>>>>>>1       lelong  !8388608        
2433 >>>>>>>>>1      lelong  !16777216       
2434 >>>>>>>>>>1     lelong  !33554432       invalid
2435 >1              lelong  x               dictionary size: %d bytes,
2436
2437 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2438 # This could technically be valid, but is unlikely.
2439 >5              lequad  !-1
2440 >>5             lequad  <32             invalid
2441 >>5             lequad  >0x40000000     invalid
2442
2443 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2444 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2445 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2446 >1              lelong  65536
2447 >>5             lequad  65536           invalid
2448 >1              lelong  131072
2449 >>5             lequad  131072          invalid
2450 >1              lelong  262144
2451 >>5             lequad  262144          invalid
2452 >1              lelong  524288
2453 >>5             lequad  524288          invalid
2454 >1              lelong  1048576
2455 >>5             lequad  1048576         invalid
2456 >1              lelong  2097152
2457 >>5             lequad  2097152         invalid
2458 >1              lelong  4194304
2459 >>5             lequad  4194304         invalid
2460 >1              lelong  8388608
2461 >>5             lequad  8388608         invalid
2462 >1              lelong  16777216
2463 >>5             lequad  16777216        invalid
2464 >1              lelong  33554432
2465 >>5             lequad  33554432        invalid
2466 >5              lequad  x               uncompressed size: %lld bytes
2467
2468
2469 # ------------------------------------------------------------------
2470 # Signature for LZMA compressed data with valid properties byte 0x5B
2471 # ------------------------------------------------------------------
2472 0               string  \x5B\x00\x00    LZMA compressed data, properties: 0x5B,
2473
2474 # These are all the valid dictionary sizes supported by LZMA utils.
2475 >1              lelong  !65536  
2476 >>1             lelong  !131072 
2477 >>>1            lelong  !262144 
2478 >>>>1           lelong  !524288 
2479 >>>>>1          lelong  !1048576        
2480 >>>>>>1         lelong  !2097152        
2481 >>>>>>>1        lelong  !4194304        
2482 >>>>>>>>1       lelong  !8388608        
2483 >>>>>>>>>1      lelong  !16777216       
2484 >>>>>>>>>>1     lelong  !33554432       invalid
2485 >1              lelong  x               dictionary size: %d bytes,
2486
2487 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2488 # This could technically be valid, but is unlikely.
2489 >5              lequad  !-1
2490 >>5             lequad  <32             invalid
2491 >>5             lequad  >0x40000000     invalid
2492
2493 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2494 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2495 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2496 >1              lelong  65536
2497 >>5             lequad  65536           invalid
2498 >1              lelong  131072
2499 >>5             lequad  131072          invalid
2500 >1              lelong  262144
2501 >>5             lequad  262144          invalid
2502 >1              lelong  524288
2503 >>5             lequad  524288          invalid
2504 >1              lelong  1048576
2505 >>5             lequad  1048576         invalid
2506 >1              lelong  2097152
2507 >>5             lequad  2097152         invalid
2508 >1              lelong  4194304
2509 >>5             lequad  4194304         invalid
2510 >1              lelong  8388608
2511 >>5             lequad  8388608         invalid
2512 >1              lelong  16777216
2513 >>5             lequad  16777216        invalid
2514 >1              lelong  33554432
2515 >>5             lequad  33554432        invalid
2516 >5              lequad  x               uncompressed size: %lld bytes
2517
2518
2519 # ------------------------------------------------------------------
2520 # Signature for LZMA compressed data with valid properties byte 0x5C
2521 # ------------------------------------------------------------------
2522 0               string  \x5C\x00\x00    LZMA compressed data, properties: 0x5C,
2523
2524 # These are all the valid dictionary sizes supported by LZMA utils.
2525 >1              lelong  !65536  
2526 >>1             lelong  !131072 
2527 >>>1            lelong  !262144 
2528 >>>>1           lelong  !524288 
2529 >>>>>1          lelong  !1048576        
2530 >>>>>>1         lelong  !2097152        
2531 >>>>>>>1        lelong  !4194304        
2532 >>>>>>>>1       lelong  !8388608        
2533 >>>>>>>>>1      lelong  !16777216       
2534 >>>>>>>>>>1     lelong  !33554432       invalid
2535 >1              lelong  x               dictionary size: %d bytes,
2536
2537 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2538 # This could technically be valid, but is unlikely.
2539 >5              lequad  !-1
2540 >>5             lequad  <32             invalid
2541 >>5             lequad  >0x40000000     invalid
2542
2543 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2544 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2545 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2546 >1              lelong  65536
2547 >>5             lequad  65536           invalid
2548 >1              lelong  131072
2549 >>5             lequad  131072          invalid
2550 >1              lelong  262144
2551 >>5             lequad  262144          invalid
2552 >1              lelong  524288
2553 >>5             lequad  524288          invalid
2554 >1              lelong  1048576
2555 >>5             lequad  1048576         invalid
2556 >1              lelong  2097152
2557 >>5             lequad  2097152         invalid
2558 >1              lelong  4194304
2559 >>5             lequad  4194304         invalid
2560 >1              lelong  8388608
2561 >>5             lequad  8388608         invalid
2562 >1              lelong  16777216
2563 >>5             lequad  16777216        invalid
2564 >1              lelong  33554432
2565 >>5             lequad  33554432        invalid
2566 >5              lequad  x               uncompressed size: %lld bytes
2567
2568
2569 # ------------------------------------------------------------------
2570 # Signature for LZMA compressed data with valid properties byte 0x5D
2571 # ------------------------------------------------------------------
2572 0               string  \x5D\x00\x00    LZMA compressed data, properties: 0x5D,
2573
2574 # These are all the valid dictionary sizes supported by LZMA utils.
2575 >1              lelong  !65536  
2576 >>1             lelong  !131072 
2577 >>>1            lelong  !262144 
2578 >>>>1           lelong  !524288 
2579 >>>>>1          lelong  !1048576        
2580 >>>>>>1         lelong  !2097152        
2581 >>>>>>>1        lelong  !4194304        
2582 >>>>>>>>1       lelong  !8388608        
2583 >>>>>>>>>1      lelong  !16777216       
2584 >>>>>>>>>>1     lelong  !33554432       invalid
2585 >1              lelong  x               dictionary size: %d bytes,
2586
2587 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2588 # This could technically be valid, but is unlikely.
2589 >5              lequad  !-1
2590 >>5             lequad  <32             invalid
2591 >>5             lequad  >0x40000000     invalid
2592
2593 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2594 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2595 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2596 >1              lelong  65536
2597 >>5             lequad  65536           invalid
2598 >1              lelong  131072
2599 >>5             lequad  131072          invalid
2600 >1              lelong  262144
2601 >>5             lequad  262144          invalid
2602 >1              lelong  524288
2603 >>5             lequad  524288          invalid
2604 >1              lelong  1048576
2605 >>5             lequad  1048576         invalid
2606 >1              lelong  2097152
2607 >>5             lequad  2097152         invalid
2608 >1              lelong  4194304
2609 >>5             lequad  4194304         invalid
2610 >1              lelong  8388608
2611 >>5             lequad  8388608         invalid
2612 >1              lelong  16777216
2613 >>5             lequad  16777216        invalid
2614 >1              lelong  33554432
2615 >>5             lequad  33554432        invalid
2616 >5              lequad  x               uncompressed size: %lld bytes
2617
2618
2619 # ------------------------------------------------------------------
2620 # Signature for LZMA compressed data with valid properties byte 0x5E
2621 # ------------------------------------------------------------------
2622 0               string  \x5E\x00\x00    LZMA compressed data, properties: 0x5E,
2623
2624 # These are all the valid dictionary sizes supported by LZMA utils.
2625 >1              lelong  !65536  
2626 >>1             lelong  !131072 
2627 >>>1            lelong  !262144 
2628 >>>>1           lelong  !524288 
2629 >>>>>1          lelong  !1048576        
2630 >>>>>>1         lelong  !2097152        
2631 >>>>>>>1        lelong  !4194304        
2632 >>>>>>>>1       lelong  !8388608        
2633 >>>>>>>>>1      lelong  !16777216       
2634 >>>>>>>>>>1     lelong  !33554432       invalid
2635 >1              lelong  x               dictionary size: %d bytes,
2636
2637 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2638 # This could technically be valid, but is unlikely.
2639 >5              lequad  !-1
2640 >>5             lequad  <32             invalid
2641 >>5             lequad  >0x40000000     invalid
2642
2643 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2644 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2645 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2646 >1              lelong  65536
2647 >>5             lequad  65536           invalid
2648 >1              lelong  131072
2649 >>5             lequad  131072          invalid
2650 >1              lelong  262144
2651 >>5             lequad  262144          invalid
2652 >1              lelong  524288
2653 >>5             lequad  524288          invalid
2654 >1              lelong  1048576
2655 >>5             lequad  1048576         invalid
2656 >1              lelong  2097152
2657 >>5             lequad  2097152         invalid
2658 >1              lelong  4194304
2659 >>5             lequad  4194304         invalid
2660 >1              lelong  8388608
2661 >>5             lequad  8388608         invalid
2662 >1              lelong  16777216
2663 >>5             lequad  16777216        invalid
2664 >1              lelong  33554432
2665 >>5             lequad  33554432        invalid
2666 >5              lequad  x               uncompressed size: %lld bytes
2667
2668
2669 # ------------------------------------------------------------------
2670 # Signature for LZMA compressed data with valid properties byte 0x63
2671 # ------------------------------------------------------------------
2672 0               string  \x63\x00\x00    LZMA compressed data, properties: 0x63,
2673
2674 # These are all the valid dictionary sizes supported by LZMA utils.
2675 >1              lelong  !65536  
2676 >>1             lelong  !131072 
2677 >>>1            lelong  !262144 
2678 >>>>1           lelong  !524288 
2679 >>>>>1          lelong  !1048576        
2680 >>>>>>1         lelong  !2097152        
2681 >>>>>>>1        lelong  !4194304        
2682 >>>>>>>>1       lelong  !8388608        
2683 >>>>>>>>>1      lelong  !16777216       
2684 >>>>>>>>>>1     lelong  !33554432       invalid
2685 >1              lelong  x               dictionary size: %d bytes,
2686
2687 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2688 # This could technically be valid, but is unlikely.
2689 >5              lequad  !-1
2690 >>5             lequad  <32             invalid
2691 >>5             lequad  >0x40000000     invalid
2692
2693 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2694 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2695 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2696 >1              lelong  65536
2697 >>5             lequad  65536           invalid
2698 >1              lelong  131072
2699 >>5             lequad  131072          invalid
2700 >1              lelong  262144
2701 >>5             lequad  262144          invalid
2702 >1              lelong  524288
2703 >>5             lequad  524288          invalid
2704 >1              lelong  1048576
2705 >>5             lequad  1048576         invalid
2706 >1              lelong  2097152
2707 >>5             lequad  2097152         invalid
2708 >1              lelong  4194304
2709 >>5             lequad  4194304         invalid
2710 >1              lelong  8388608
2711 >>5             lequad  8388608         invalid
2712 >1              lelong  16777216
2713 >>5             lequad  16777216        invalid
2714 >1              lelong  33554432
2715 >>5             lequad  33554432        invalid
2716 >5              lequad  x               uncompressed size: %lld bytes
2717
2718
2719 # ------------------------------------------------------------------
2720 # Signature for LZMA compressed data with valid properties byte 0x64
2721 # ------------------------------------------------------------------
2722 0               string  \x64\x00\x00    LZMA compressed data, properties: 0x64,
2723
2724 # These are all the valid dictionary sizes supported by LZMA utils.
2725 >1              lelong  !65536  
2726 >>1             lelong  !131072 
2727 >>>1            lelong  !262144 
2728 >>>>1           lelong  !524288 
2729 >>>>>1          lelong  !1048576        
2730 >>>>>>1         lelong  !2097152        
2731 >>>>>>>1        lelong  !4194304        
2732 >>>>>>>>1       lelong  !8388608        
2733 >>>>>>>>>1      lelong  !16777216       
2734 >>>>>>>>>>1     lelong  !33554432       invalid
2735 >1              lelong  x               dictionary size: %d bytes,
2736
2737 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2738 # This could technically be valid, but is unlikely.
2739 >5              lequad  !-1
2740 >>5             lequad  <32             invalid
2741 >>5             lequad  >0x40000000     invalid
2742
2743 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2744 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2745 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2746 >1              lelong  65536
2747 >>5             lequad  65536           invalid
2748 >1              lelong  131072
2749 >>5             lequad  131072          invalid
2750 >1              lelong  262144
2751 >>5             lequad  262144          invalid
2752 >1              lelong  524288
2753 >>5             lequad  524288          invalid
2754 >1              lelong  1048576
2755 >>5             lequad  1048576         invalid
2756 >1              lelong  2097152
2757 >>5             lequad  2097152         invalid
2758 >1              lelong  4194304
2759 >>5             lequad  4194304         invalid
2760 >1              lelong  8388608
2761 >>5             lequad  8388608         invalid
2762 >1              lelong  16777216
2763 >>5             lequad  16777216        invalid
2764 >1              lelong  33554432
2765 >>5             lequad  33554432        invalid
2766 >5              lequad  x               uncompressed size: %lld bytes
2767
2768
2769 # ------------------------------------------------------------------
2770 # Signature for LZMA compressed data with valid properties byte 0x65
2771 # ------------------------------------------------------------------
2772 0               string  \x65\x00\x00    LZMA compressed data, properties: 0x65,
2773
2774 # These are all the valid dictionary sizes supported by LZMA utils.
2775 >1              lelong  !65536  
2776 >>1             lelong  !131072 
2777 >>>1            lelong  !262144 
2778 >>>>1           lelong  !524288 
2779 >>>>>1          lelong  !1048576        
2780 >>>>>>1         lelong  !2097152        
2781 >>>>>>>1        lelong  !4194304        
2782 >>>>>>>>1       lelong  !8388608        
2783 >>>>>>>>>1      lelong  !16777216       
2784 >>>>>>>>>>1     lelong  !33554432       invalid
2785 >1              lelong  x               dictionary size: %d bytes,
2786
2787 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2788 # This could technically be valid, but is unlikely.
2789 >5              lequad  !-1
2790 >>5             lequad  <32             invalid
2791 >>5             lequad  >0x40000000     invalid
2792
2793 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2794 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2795 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2796 >1              lelong  65536
2797 >>5             lequad  65536           invalid
2798 >1              lelong  131072
2799 >>5             lequad  131072          invalid
2800 >1              lelong  262144
2801 >>5             lequad  262144          invalid
2802 >1              lelong  524288
2803 >>5             lequad  524288          invalid
2804 >1              lelong  1048576
2805 >>5             lequad  1048576         invalid
2806 >1              lelong  2097152
2807 >>5             lequad  2097152         invalid
2808 >1              lelong  4194304
2809 >>5             lequad  4194304         invalid
2810 >1              lelong  8388608
2811 >>5             lequad  8388608         invalid
2812 >1              lelong  16777216
2813 >>5             lequad  16777216        invalid
2814 >1              lelong  33554432
2815 >>5             lequad  33554432        invalid
2816 >5              lequad  x               uncompressed size: %lld bytes
2817
2818
2819 # ------------------------------------------------------------------
2820 # Signature for LZMA compressed data with valid properties byte 0x66
2821 # ------------------------------------------------------------------
2822 0               string  \x66\x00\x00    LZMA compressed data, properties: 0x66,
2823
2824 # These are all the valid dictionary sizes supported by LZMA utils.
2825 >1              lelong  !65536  
2826 >>1             lelong  !131072 
2827 >>>1            lelong  !262144 
2828 >>>>1           lelong  !524288 
2829 >>>>>1          lelong  !1048576        
2830 >>>>>>1         lelong  !2097152        
2831 >>>>>>>1        lelong  !4194304        
2832 >>>>>>>>1       lelong  !8388608        
2833 >>>>>>>>>1      lelong  !16777216       
2834 >>>>>>>>>>1     lelong  !33554432       invalid
2835 >1              lelong  x               dictionary size: %d bytes,
2836
2837 # Assume that a valid size will be greater than 32 bytes and less than 1GB (a value of -1 IS valid).
2838 # This could technically be valid, but is unlikely.
2839 >5              lequad  !-1
2840 >>5             lequad  <32             invalid
2841 >>5             lequad  >0x40000000     invalid
2842
2843 # These are not 100%. The uncompressed size could be exactly the same as the dicionary size, but it is unlikely.
2844 # Since most false positives are the result of repeating sequences of bytes (such as executable instructions),
2845 # marking matches with the same uncompressed and dictionary sizes as invalid eliminates much of these false positives.
2846 >1              lelong  65536