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