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