xenial (1) jacksum.1.gz

Provided by: jacksum_1.7.0-4_all bug

NAME

       jacksum - computes checksums, CRCs and message digests

SYNOPSIS

       jacksum [OPTIONS]... [FILE]...
       java -jar /usr/share/java/jacksum.jar [OPTIONS]... [FILE]...
       java -cp /usr/share/java/jacksum.jar Jacksum [OPTIONS]... [FILE]...

DESCRIPTION

       Jacksum is a free and platform independent utility for computing and verifying checksums, CRCs and hashes
       (message digests) as well as timestamps of files. Jacksum is written entirely in Java.   A  Java  Runtime
       Environment  (JRE),  at  least  version  1.3.1  or  any equivalent JRE is required. At least JRE 1.4.2 is
       recommended.

       The following parameters are supported:

       file   a path name of a file to be checked. Wildcards are supported. They depend on  the  shell  you  are
              running.  With no file, or when the file is character "-", standard input is read.

       The following options are supported:

       -a algo
              the  algorithm, default is sha-1 since Jacksum 1.0.0, see also -A.  Algorithms can be combinded by
              the plus character, e. g.  "sha1+crc32", "bsd+crc24+xor8".  If you specify "-a all" all  supported
              algorithms  are  used,  see  also  -F. As soon as "all" or a plus character is used, the output is
              normalized with a hex checksum and a decimal filesize. Examples: "sha+", "md5+". Feature available
              since Jacksum 1.7.0, see also -A, -F.

       -A     Alternate. By default Jacksum uses algorithms provided by the Java API if available, because those
              are optimized by the JVM vendor, they usually provide  very  good  performance.   If  -A  is  set,
              Jacksum  uses  an  alternate,  pure  Java implementation of an algorithm (if available). Actually,
              Jacksum supports alternate implementations for the  following  algorithms:  adler32,  crc32,  md5,
              sha-1, sha-256, sha-384, sha-512 since Jacksum 1.5.0, see also -a.

       -c list
              checks the integrity against a given list. The list is usually a former output of Jacksum, ideally
              created with option -m. You can also check against  a  list  which  was  created  by  a  different
              application.  In  this case, you need to specify all parameters which are necessary to produce the
              same output. The parameter -F will be ignored.  To exclude files, just remove lines from the list.
              Feature available since Jacksum 1.3.0, see also -l -I and -m.

       -d     directories  (regular)  only.  Don't  follow  symbolic links on Linux/Unix. A symbolic link from a
              subfolder to a parent  folder  could  cause  endless  loops  under  Unix/Linux  while  recursively
              traversing  the  tree.  If this option is set, symbolic links to directories will be ignored. This
              option will be ignored under Windows.  Feature available since Jacksum 1.5.0, See also -r.

       -e seq expectation. A sequence for the calculation is expected.  Works with a  file,  standard  input  or
              option  -q.  Returns  OK  (exit code 0) or MISMATCH (exit code 1).  Available since Jacksum 1.4.0.
              Works also with multiple files or directories to find duplicates, in which case all  findings  are
              printed  out.   The sequence can be specified either case sensitive or case insensitive, except if
              Base 64 encoding (by -E) has been specified.  Available since Jacksum 1.6.0, see also -a, -q,  -E,
              -x and -X.

       -E encoding
              encoding. The checksum can be encoded:

              bin          Binary
              dec          Decimal
              oct          Octal
              hex          Hexadecimal in lowercase (same as -x)
              hexup        Hexadecimal in uppercase (same as -X)
              base16       Base 16 (as defined by RFC 3548)
              base32       Base 32 (as defined by RFC 3548)
              base64       Base 64 (as defined by RFC 3548)
              bb           BubbleBabble (used by OpenSSH and SSH2)

              available since Jacksum 1.6.0, see also -x and -X.

       -f     process files only, this option suppresses the messages "... Is a
              directory" and " ... Is not a regular file". Available since
              Jacksum 1.0.0, see also -V.

       -F format
              Set a customizable output format to overwrite the default.
              Available since Jacksum 1.5.0, if not other specified, see also
              -a, -E, -g, -G, -p, -P, -s, -t, -x, -X.

              #ALGONAME       will be replaced by the name of the algorithm
              #ALGONAME{i}    see also #CHECKSUM{i}
              #CHECKSUM       will be replaced by the hash, CRC or sum value
                              (depends on -a, -b, -g, -G, -x, -X)
              #CHECKSUM{i}    If the character called + has been used to
                              separate multiple algorithms at option -a, the
                              token will be replaced with the checksum. The
                              token is indexed by a number. If you use the
                              character called i rather than a number, it
                              works like an automatic index. (1.6)
              #FILENAME       will be replaced by the filename and path (depends
                              on -p and -P)
              #FILENAME{NAME} will be replaced by the filename (1.5)
              #FILENAME{PATH} will be replaced by the filepath (1.5)
              #FILESIZE       will be replaced by the filesize
              #FINGERPRINT    is an alias for #CHECKSUM
              #SEPARATOR      will be replaced by the separator which you can
                              specify with -s
              #TIMESTAMP      will be replaced by the timestamp (depends on -t)
              #QUOTE          will be replaced by one quote char (")

       -g count
              group  the  hex  output  for  the  checksum in "count" bytes for better readability. Only valid if
              encoding is hex or hexup.  Groups are separated by a blank or by the character  specified  by  -G.
              The value for count must be greater than 0. Available since Jacksum 1.6.0, see also -E, -G, -x and
              -X -G char group character. Only valid if encoding is hexadecimal and -g has been set.

       -h [lang] [section]
              print help, valid codes for "lang" are "en" or "de", default is "en"; valid values  for  "section"
              are  strings  like headers or options. See section EXAMPLES for more information.  Available since
              Jacksum 1.0.0, parameter section since Jacksum 1.6.0, see also -v.

       -I string
              ignore. While creating a list by -m or reading a list by -c, lines are ignored if they start  with
              the specified string. Available since Jacksum 1.6.0, see also -c and -m.

       -l     list.  Just  list  files  which  were modified or deleted.  In combination with -c only. Available
              since Jacksum 1.4.0, see also -c.

       -m     print metainfo. Additional lines will be printed. With the metainfo available you can check  files
              against  a given list without the need to specify a lot of commandline parameters.  Any customized
              format you can normally specify with -F are ignored. Available since Jacksum 1.3.0, see also -c.

       -o file
              output. The output of the program goes to a file rather than  the  standard  output.  The  program
              exits  with  a  warning if the file exists. The file which is specified by -o is excluded from the
              calculation process. Available since Jacksum 1.6.0, see also -O, -u and -U.

       -O file
              output. Same as -o, however an existing file will be overwritten without any warning. See also -U.
              Available since Jacksum 1.6.0, see also -o, -u and -U.

       -p     path.  Put  the  path  info  on  each  line, instead of printing a header for each directory while
              processing folders recursively (-r). With this option the output will increase, but  on  the  flip
              side it will be much easier to sort or grep the lines with corresponding programs. Available since
              Jacksum 1.4.0, see also -F, -P, -r and -w.

       -P char
              path separator. By default, the system-dependent default file name separator character is used. On
              Unix  systems  the  character  is the slash (/), on Microsoft Windows systems it is the back slash
              (\). You can change the default if a special output format for filenames (such as HTML  links)  is
              required.  Available since Jacksum 1.5.0, see also -F and -p.

       -q [type:]seq
              process  a  sequence quickly and quit the program. The type can be used to specify the type of the
              sequence (text, hexadecimal or decimal):

              txt:Example1
              hex:4578616D706C6531
              dec:69,120,97,109,112,108,101,49
              4578616D706C6531

              If type is not set, the seq is expected to be  in  hex  form.   If  type  is  set  to  "txt",  the
              platform's  default  charset  will  be  used to interpret the sequence called seq. Available since
              Jacksum 1.3.0 (hex only), type since 1.5.0.

       -r     process subdirectory recursively (without  a  file  parameter  the  current  directory  is  used).
              Available since Jacksum 1.0.0, see also -p and -w.

       -s sep a  custom  separator  string  (\t,  \n,  \r,  \", \' and \\ will be translated). The default value
              depends on the checksum algorithm. Available since Jacksum 1.0.0, see also -F.

       -S     summary. This calculates just one  checksum  value.  All  files,  the  directory  structures,  the
              filenames  and  timestamps (if requested) are part of that checksum. See also -w.  Available since
              Jacksum 1.5.0, see also -r and -w.

       -t form
              a timestamp format. Java's formatter class SimpleDateFormat will be used. Valid characters are

              G   Era designator
              y   Year
              M   Month in year
              w   Week in year
              W   Week in month
              D   Day in year
              d   Day in month
              F   Day of week in month
              E   Day in week
              a   AM/PM marker
              H   Hour in day (0-23)
              k   Hour in day (1-24)
              K   Hour in am/pm (0-11)
              h   Hour in am/pm (1-12)
              m   Minute in hour
              s   Second in minute
              S   Millisecond
              z   Time zone, general
              Z   Time zone, RFC 822

              If form is set to the word "default", timestamps will be formatted  with  "yyyyMMddHHmmss".  since
              Jacksum 1.3.0

              #SEPARATOR     will be replaced by the separator which you
                             can specify with -s
              #QUOTE         will be replaced by one quote char (")

              Available since Jacksum 1.6.0, see also -F.

       -u file
              ugly,  undesirable,  unforeseen,  uninvited.  Any error messages of the program is redirected to a
              file rather than the standard error.  The program exits if the file exists.   The  file  which  is
              specified by -u is excluded from the calculation process.  Available since Jacksum 1.6.0, see also
              -U, -o and -O.

       -U file
              ugly, undesirable, unforeseen, uninvited. Same as -u, however an existing file will be overwritten
              without any warning.  See also -O. Available since Jacksum 1.6.0, see also -u, -o and -O.

       -v     version. Prints the product version and exits. Available since Jacksum 1.2.0, see also -h.

       -V control
              verbose. Prints additional information. If -V is the only parameter it behaves like -v.  "control"
              can be one of the following keywords which must be separated by a comma:

              details  | nodetails     Errors with or without details
              warnings | nowarnings    Warnings or no warnings
              summary  | nosummary     Summary at the end or not

              If control is set to "default", control is set to  "details,warnings,nosummary".  Available  since
              Jacksum 1.6.0, see also -f and -v.

       -w     The  file  parameter (the last parameter) is intended to be the working directory.  This allows to
              create relative path names rather than absolute ones. Only  valid  if  the  file  parameter  is  a
              directory. Available since Jacksum 1.6.0, see also -r and -S.

       -x     lowercase  hex  output for the checksum, it is an alias for -E hex. Available since Jacksum 1.1.0,
              see also -E.

       -X     uppercase hex output for the checksum, it is an alias  for  -E  hexup.   Available  since  Jacksum
              1.1.0, see also -E.

       The following algorithms are supported:

              adler32, adler-32
              algorithm:
                   Adler32 [java.util.zip.Adler32]
              length:
                   32 bits
              type:
                   checksum, 1995
              since:
                   Jacksum 1.0.0 (alias "adler-32" since 1.2.0)
              comment:
                   Adler32 was invented by Mark Adler in 1995.
                   The specification for Adler32 may be found
                   in RFC 1950. Adler32 is a 32-bit extension
                   and improvement of the Fletcher algorithm,
                   used in the ITU-T X.224 / ISO 8073 standard.
                   [jonelo.jacksum.algorithm.Adler32alt] is the
                   alternate implementation and it is used if
                   option -A is specified.

              bsd, bsdsum, sumbsd
              algorithm:
                   BSD checksum algorithm
              length:
                   16 bits
              type:
                   checksum
              since:
                   Jacksum 1.0.0 (alias "bsdsum" since 1.2.0, alias
                   "sumbsd" since 1.6.0)
              comment:
                   output format is exactly like the native
                   program sum (size in 1024 byte blocks)
                   see also sysv
                   - under BeOS    it is /bin/sum [-r]
                   - under FreeBSD it is /usr/bin/sum
                     and /usr/bin/cksum -o 1
                   - under HP-UX   it is /usr/bin/sum -r
                   - under IBM AIX it is /usr/bin/sum [-r]
                   - under Linux   it is /usr/bin/sum [-r]
                   - under MacOS X it is /usr/bin/sum
                     and /usr/bin/cksum -o 1
                   - under Solaris it is /usr/ucb/sum
                   - under Windows there is no sum

              cksum
              algorithm:
                   POSIX 1003.2 CRC algorithm
              length:
                   32 bits
              type:
                   crc
              since:
                   Jacksum 1.0.0
              comment:
                   - under BeOS    it is /bin/cksum
                   - under FreeBSD it is /usr/bin/cksum
                   - under HP-UX   it is /usr/bin/cksum and
                   /usr/bin/sum -p
                   - under IBM AIX it is /usr/bin/cksum
                   - under Linux   it is /usr/bin/cksum
                   - under MacOS X it is /usr/bin/cksum
                   - under Solaris it is /usr/bin/cksum
                   - under Tru64   ist es /bin/cksum (CMD_ENV=xpg4)
                   - under Windows there is no cksum
                   The POSIX CRC cannot be described completely
                   by the Rocksoft-Model, because the algorithm
                   appends the message with its length. Without
                   this special, the code would be:
                   crc:32,04C11DB7,0,false,false,FFFFFFFF

              crc64, crc-64
              algorithm:
                   CRC-64
              length:
                   64 bits
              type:
                   crc:64,1B,0,true,true,0
              since:
                   Jacksum 1.5.0
              comment:
                   this algorithm is described in the
                   ISO 3309 standard.
                   (generator poly is x^64 + x^4 + x^3 + x + 1)

              elf, elf32, elf-32
              algorithm:
                   ELF
              length:
                   32 bits
              type:
                   hash
              since:
                   Jacksum 1.5.0
              comment:
                   hash function used in the Unix ELF (Executable
                   and Linkable Format) for object files.

              ed2k, emule, edonkey
              algorithm:
                   eMule/eDonkey
              length:
                   128 bits
              type:
                   hash
              since:
                   Jacksum 1.5.0
              comment:
                   this algorithm is used in eDonkey resp. eMule,
                   it is based on MD4, but returns different
                   fingerprints for files >= 9500 KB.

              gost
              algorithm:
                   GOST R 34.11-94
                   [org.bouncycastle.crypto.digests.GOST3411Digest]
              length:
                   256 bits
              type:
                   hash, 1994
              since:
                   Jacksum 1.6.0
              comment:
                   "GOsudarstvennyi STandard", Russian for
                   "Government Standard". Published in 1994 as
                   the Soviet Standard GOST-R-34.11-94.

              has160, has-160, has160
              algoritm:
                   HAS-160 [gnu.crypto.hash.Has160 (jonelo)]
              length:
                   160 bits
              type:
                   hash, 2000
              since:
                   Jacksum 1.7.0
              comment:
                   HAS-160 is both a cryptographic hash function and
                   a Korean TTA-Standard (Telecommunications and
                   and Technology Association).

              haval, haval_<b>_<r>
              algorithm:
                   Haval [gnu.crypto.hash.Haval]
              length:
                   128, 160, 192, 224 or 256 bits
              type:
                   hash, 1992
              since:
                   Jacksum 1.4.0
              comment:
                   Haval was invented by Yuliang Zheng, Josef
                   Pieprzyk, and Jennifer Seberry in 1992.
                   The Haval message-digest algorithm has a
                   variable output length, with variable number of
                   rounds. The output length <b> can vary from 128
                   to 256 bits in increments of 32 bits. The
                   number of rounds <r> can vary from 3 to 5. The
                   default values (just "haval") are 128 and 3.

              md2, md2sum
              algorithm:
                   MD2 [gnu.crypto.hash.MD2]
              length:
                   128 bits
              type:
                   hash, 1989
              since:
                   Jacksum 1.2.0
              comment:
                   the MD2 message digest algorithm as defined in
                   RFC 1319;
                   RSA Laboratories, in their Bulletin #4, dated
                   November 12, 1996, recommends to update
                   applications away from MD2 whenever it is
                   practical.
                   Jacksum supports MD2 for compatibility and educational
                   purposes.

              md4, md4sum
              algorithm:
                   MD4 [gnu.crypto.hash.MD4]
              length:
                   128 bits
              type:
                   hash, 1990
              since:
                   Jacksum 1.2.0
              comment:
                   the MD4 message digest algorithm as defined in
                   RFC 1320;
                   RSA Laboratories, in their Bulletin #4, dated
                   November 12, 1996, recommends that MD4 should
                   not be used.
                   Jacksum supports MD4 for compatibility and educational
                   purposes.

              md5, md5sum
              algorithm:
                   MD5 [java.security.MessageDigest]
              length:
                   128 bits
              type:
                   hash, 1991
              since:
                   Jacksum 1.0.0
              comment:
                   The MD5 message digest algorithm was designed by
                   Ronald Rivest in 1991, and it is defined in
                   RFC 1321. [gnu.crypto.hash.MD5] is the alternate
                   implementation and it will be used if you have
                   set the option -A.
                   - under BeOS    it is /bin/md5sum
                   - under FreeBSD it is /sbin/md5
                   - under HP-UX   there is no md5 or md5sum
                   - under Linux   it is /usr/bin/md5sum
                   - under MacOS X it is /usr/bin/md5
                   - under Solaris it is /usr/sbin/md5 (SUNWkeymg)
                   - under Windows there is no md5 or md5sum

              none
              algorithm:
                   none
              length:
                   0 bits
              type:
                   n/a
              since:
                   Jacksum 1.6.0
              comment:
                   Calculates no checksum, it does not read the
                   content of files, it just determines the
                   filesize (and timestamp if required)

              crc:<params>
              algorithm:
                   CRC
              length:
                   8..64 bits
              type:
                   crc
              since:
                   Jacksum 1.7.0
              comment:
                   With this generic CRC you can specify all CRC-
                   algorithms which can be described by the famous
                   "Rocksoft (tm) Model CRC Algorithm".
                   <params> must have 6 values, which must be
                   separated by a comma. Those are:
                   width,poly,init,refIn,refOut,xorOut

                   width - width of the crc, expressed in bits.
                   This is one less than the width of
                   the poly.

                   poly - the polynomial, specify as hex
                   The top bit of the poly should be
                   omitted. For example, if the poly is
                   10110, you should specify 06. An
                   important aspect of this parameter
                   is that it represents the unreflected
                   poly; the bottom bit of this parameter
                   is always the LSB of the divisor
                   during the division regardless of
                   whether the algorithm being modelled
                   is reflected.

                   init - this parameter specifies the initial
                   value of the register when the
                   algorithm starts. Specify as hex.

                   refIn - this is a boolean parameter. If it
                   is false, input bytes are processed
                   with bit 7 being treated as the most
                   significant bit (MSB) and bit 0 being
                   treated as the least significant bit.
                   If this parameter is false, each byte
                   is reflected before being processed.
                   true or false

                   refOut - this is a boolean parameter. If it is
                   set to false, the final value in the
                   register is fed into the xorOut stage
                   directly, otherwise, if this parameter
                   is true, the final register value is
                   reflected first.

                   xorOut - this value is XORed to the final
                   register value (after the refOut)
                   stage before the value is returned as
                   the official checksum, specify as hex

              read
              algorithm:
                   read
              length:
                   0 bits
              type:
                   n/a
              since:
                   Jacksum 1.6.0
              comment:
                   Calculates no checksum, but it does read the
                   content of files, it also determines the
                   filesize (and timestamp if required)

              rmd128, rmd-128, ripemd128, ripemd-128, ripe-md128
              algorithm:
                   RIPEMD-128 [gnu.crypto.hash.RipeMD128]
              length:
                   128 bits
              type:
                   hash
              since:
                   Jacksum 1.2.0 (alias rmd128/rmd-128 since 1.4.0)
              comment:
                   a message digest, see also RIPEMD-160

              rmd160, rmd-160, ripemd160, ripemd-160, ripe-md160
              algorithm:
                   RIPEMD-160 [gnu.crypto.hash.RipeMD160]
              length:
                   160 bits
              type:
                   hash, 1996
              since:
                   Jacksum 1.2.0 (alias rmd160/rmd-160 since 1.4.0)
              comment:
                   RIPEMD was developed in the framework of the
                   EU project RIPE (RACE Integrity Primitives
                   Evaluation), used by GnuPG

              rmd256, rmd-256, ripemd256, ripemd-256, ripe-md256
              algorithm:
                   RIPEMD-256 [org.bouncycastle.crypto.digests]
              length:
                   256 bits
              type:
                   hash
              since:
                   Jacksum 1.6.0
              comment:
                   a message digest, see also RIPEMD-160
                   RIPEMD-256 is as secure as RIPEMD-128

              rmd320, rmd-320, ripemd320, ripemd-320, ripe-md320
              algorithm:
                   RIPEMD-320 [org.bouncycastle.crypto.digests]
              length:
                   128 bits
              type:
                   hash
              since:
                   Jacksum 1.6.0
              comment:
                   a message digest, see also RIPEMD-160
                   RIPEMD-320 is as secure as RIPEMD-160

              sha0, sha-0
              algorithm:
                   SHA-0 [gnu.crypto.hash.Sha0 (jonelo)]
              length:
                   160 bits
              type:
                   hash, 1993
              since:
                   Jacksum 1.6.0
              comment:
                   the Secure Hash Algorithm, as defined 1993 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (FIPS PUB 180).
                   It was withdrawn by NSA shortly after
                   publication and was superseded by the revised
                   version, published in 1995 in FIPS PUB 180-1
                   and commonly referred to as "SHA-1".

              sha, sha1, sha-1, sha160, sha-160
              algorithm:
                   SHA-1 [java.security.MessageDigest]
              length:
                   160 bits
              type:
                   hash, 1995
              since:
                   Jacksum 1.0.0 (alias sha-1 since 1.2.0, alias
                   sha-160. sha160 and sha-160 since 1.5.0, default
                   algorithm since 1.5.0.
              comment:
                   the Secure Hash Algorithm, as defined 1995 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (NIST FIPS 180-1).
                   [gnu.crypto.hash.Sha160] is the alternate
                   implementation and it will be used if you have
                   specified option -A.
                   - under BeOS    there is no sha1
                   - under FreeBSD it is /sbin/sha1
                   - under HP-UX   there is no sha1
                   - under Linux   it is /usr/bin/sha1sum
                   - under MacOS X there is no sha1
                   - under Solaris there is no sha1
                   - under Windows there is no sha1

              sha224, sha-224
              algorithm:
                   SHA-224 [gnu.crypto.hash.Sha224 (jonelo)]
              length:
                   224 bits
              type:
                   hash, 2004
              since:
                   Jacksum 1.6.0
              comment:
                   the Secure Hash Algorithm, as defined 2004 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (NIST FIPS 180-2) and in RFC 3874.
                   SHA-224 is based on SHA-256, but it uses a
                   different initial value and the final hash
                   is truncated to 224 bits.

              sha256, sha-256
              algorithm:
                   SHA-256 [java.security.MessageDigest]
              length:
                   256 bits
              type:
                   hash, 2001
              since:
                   Jacksum 1.3.0
              comment:
                   the Secure Hash Algorithm, as defined 2001 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (NIST FIPS 180-2).
                   [gnu.crypto.hash.Sha256] is an alternate
                   implementation and it is used if you have a
                   JRE < 1.4.2 or if you have specified option -A.

              sha384, sha-384
              algorithm:
                   SHA-384 [java.security.MessageDigest]
              length:
                   384 bits
              type:
                   hash, 2001
              since:
                   Jacksum 1.3.0
              comment:
                   the Secure Hash Algorithm, as defined 2001 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (NIST FIPS 180-2).
                   [gnu.crypto.hash.Sha384] is an alternate
                   implementation and it is used if you have a
                   JRE < 1.4.2 or if you have specified option -A.

              crc8, crc-8
              algorithm:
                   CRC-8
              length:
                   8 bits
              type:
                   crc:8,7,0,false,false,0
              since:
                   Jacksum 1.6.0
              comment:
                   this implementation of the CRC-8 (cyclic
                   redundancy check) is used in the
                   System Management Bus (SMBus) and the
                   Free Lossless Audio Codec (FLAC) for example
                   (generator poly x^8 + x^2 + x^1 + 1)

              sha512, sha-512
              algorithm:
                   SHA-512 [java.security.MessageDigest]
              length:
                   512 bits
              type:
                   hash, 2001
              since:
                   Jacksum 1.3.0
              comment:
                   the Secure Hash Algorithm, as defined 2001 in
                   the National Institute for Standards and
                   Technology's Federal Information Processing
                   Standard (NIST FIPS 180-2).
                   [gnu.crypto.hash.Sha512] is an alternate
                   implementation and it is used if you have a
                   JRE < 1.4.2 or if you have specified option -A.

              sum8, sum-8
              algorithm:
                   Sum 8
              length:
                   8 bits
              type:
                   checksum
              since:
                   Jacksum 1.3.0
              comment:
                   value computed by adding together all values
                   in the input data stream modulo 2^8.
                   This algorithm doesn't care about the
                   arrangement of bytes.

              sum16, sum-16
              algorithm:
                   Sum 16
              length:
                   16 bits
              type:
                   checksum
              since:
                   Jacksum 1.3.0
              comment:
                   value computed by adding together all values
                   in the input data stream modulo 2^16.
                   This algorithm doesn't care about the
                   arrangement of bytes.

              sum24, sum-24
              algorithm:
                   Sum 24
              length:
                   24 bits
              type:
                   checksum
              since:
                   Jacksum 1.3.0
              comment:
                   value computed by adding together all values
                   in the input data stream modulo 2^24.
                   This algorithm doesn't care about the
                   arrangement of bytes.

              sum32, sum-32
              algorithm:
                   Sum 32
              length:
                   32 bits
              type:
                   checksum
              since:
                   Jacksum 1.3.0
              comment:
                   value computed by adding together all values
                   in the input data stream modulo 2^32.
                   This algorithm doesn't care about the
                   arrangement of bytes.

              sysv, sysvsum, sumsysv
              algorithm:
                   UNIX System V checksum algorithm
              length:
                   16 bits
              type:
                   checksum, 1985
              since:
                   Jacksum 1.2.0, alias "sumsysv" since 1.6.0
              comment:
                   output format is exactly like the properitary
                   program sum (size in 512 bytes blocks),
                   see also bsd
                   - under BeOS    it is /bin/sum -s
                   - under FreeBSD it is /usr/bin/cksum -o 2
                   - under HP-UX   it is /usr/bin/sum
                   - under Linux   it is /usr/bin/sum -s
                   - under MacOS X it is /usr/bin/cksum -o 2
                   - under Solaris it is /usr/bin/sum
                   - under Windows there is no sum

              tiger128, tiger-128
              algorithm:
                   Tiger 128 [gnu.crypto.hash.Tiger160 (by jonelo)]
              length:
                   128 bits
              type:
                   hash, 1995
              since:
                   Jacksum 1.6.0
              comment:
                   the hash value is the first 128 bits of the
                   result of Tiger-192

              tiger160, tiger-160
              algorithm:
                   Tiger 160 [gnu.crypto.hash.Tiger160 (by jonelo)]
              length:
                   160 bits
              type:
                   hash, 1995
              since:
                   Jacksum 1.6.0
              comment:
                   the hash value is the first 160 bits of the
                   result of Tiger-192

              tiger, tiger192, tiger-192
              algorithm:
                   Tiger [gnu.crypto.hash.Tiger]
              length:
                   192 bits
              type:
                   hash, 1995
              since:
                   Jacksum 1.4.0
              comment:
                   developed by Ross Anderson and Eli Biham, 1995

              tiger2
              algorithm:
                   Tiger2 [gnu.crypto.hash.Tiger2 (jonelo)]
              length:
                   192 bits
              type:
                   hash, 2005
              since:
                   Jacksum 1.6.0
              comment:
                   developed by Ross Anderson and Eli Biham, 2005

              crc16, crc-16
              algorithm:
                   CRC-16 (ARC)
              length:
                   16 bits
              type:
                   crc:16,8005,0,true,true,0
              since:
                   Jacksum 1.2.0
              comment:
                   this implementation of the CRC-16 (cyclic
                   redundancy check) is the most popular form
                   of CRC-16 algorithms
                   (generator poly x^16 + x^15 + x^2 + 1)
                   It is used by LHA, and ARC for example.

              tree:<algo>
              algorithm:
                   Hash Tree
              length:
                   dependent on the underlying algorithm
              type:
                   hash tree, 1979
              since:
                   Jacksum 1.7.0
              comment:
                   invented by Ralph Merkle, 1979. A hash tree is a
                   tree of hashes in which the leaves are hashes of
                   data blocks. By default the tree hash is encoded
                   base32. Jacksum allows to calculate the root
                   hash of the hash tree, the following agorithms
                   are supported with hash trees: tiger, tiger2
                   Tiger tree hashes are used in P2P file sharing
                   protocols and applications.

              whirlpool0, whirlpool-0
              algorithm:
                   Whirlpool-0 [gnu.crypto.hash.Whirlpool (jonelo)]
              length:
                   512 bits
              type:
                   hash, 2000
              since:
                   Jacksum 1.6.0
              comment:
                   The Whirlpool Hashing Function by Paulo S.L.M.
                   Barreto and Vincent Rijmen, 2000.
                   This is the original specification of Whirlpool
                   from 2000.

              whirlpool1, whirlpool-1
              algorithm:
                   Whirlpool-1 [gnu.crypto.hash.Whirlpool]
              length:
                   512 bits
              type:
                   hash, 2001
              since:
                   Jacksum 1.2.0
              comment:
                   The Whirlpool Hashing Function by Paulo S.L.M.
                   Barreto and Vincent Rijmen, 2001.
                   This is the first revision of the specification
                   of Whirlpool from 2001 with improved S-box
                   design:
                   "We propose renaming the original algorithm
                   Whirlpool-0 and using the term Whirlpool for
                   the final, modified version that uses the
                   improved S-box design."

              whirlpool, whirlpool2, whirlpool-2
              algorithm:
                   Whirlpool [gnu.crypto.hash.Whirlpool (jonelo)]
              length:
                   512 bits
              type:
                   hash, 2003
              since:
                   Jacksum 1.6.0
              comment:
                   The Whirlpool Hashing Function by Paulo S.L.M.
                   Barreto and Vincent Rijmen.
                   This is the second revision of the specification
                   of Whirlpool from 2003 with improved diffusion
                   matrix:
                   "Recently [March 11, 2003], Shirai and Shibutani
                   discovered a flaw in the Whirlpool diffusion
                   matrix that made its branch number suboptimal.
                   Although this flaw per se does not seem to
                   introduce an effective vulnerability, the
                   present document replaces that matrix
                   [May 24, 2003]"

              xor8, xor-8
              algorithm:
                   Exclusive-Or
              length:
                   8 bits
              type:
                   checksum
              since:
                   Jacksum 1.3.0
              comment:
                   value computed by xoring all values in the
                   input data stream.
                   This algorithm doesn't care about the
                   arrangement of bytes in a file.

              crc16_x25, crc-16_x-25, fcs16, fcs-16
              algorithm:
                   CRC-16 (Frame Checking Sequence)
              length:
                   16 bits
              type:
                   crc:16,1021,FFFF,true,true,FFFF
              since:
                   Jacksum 1.5.0 (alias _x25, _x-25 seit 1.7.0)
              comment:
                   The Frame Checking Sequence as defined in
                   RFC1331.

              crc24, crc-24
              algorithm:
                   CRC-24
              length:
                   24 bits
              type:
                   crc:24,864CFB,B704CE,false,false,0
              since:
                   Jacksum 1.6.0
              comment:
                   this implementation of the CRC-24 (cyclic
                   redundancy check) is used by Open PGP for
                   example (RFC 2440).

              crc32, crc-32, fcs32, fcs-32
              algorithm:
                   CRC-32 [java.util.zip.CRC32]
              length:
                   32 bits
              type:
                   crc:32,04C11DB7,FFFFFFFF,true,true,FFFFFFFF
              since:
                   Jacksum 1.0.0 (alias crc-32 since 1.2.0,
                   alias fcs32 and fcs-32 since 1.5.0)
              comment:
                   the standard algorithm CRC-32 (cyclic
                   redundancy check) is specified in ISO 3309,
                   ISO/IEC 13239:2002 and ITU-T V.42, and it
                   is used by PKZip, gzip, png, Ethernet, FDDI,
                   and WEP. That algorithm is also known as FCS
                   (frame checking sequence)
                   An alternate implementation is available (-A).
                   - under BeOS    there is no crc32
                   - under FreeBSD it is /usr/bin/cksum -o 3
                   - under HP-UX   there is no crc32
                   - under Linux   there is no crc32
                   - under MacOS X it is /usr/bin/cksum -o 3
                   - under Solaris there is no crc32
                   - under Windows there is no crc32

              crc32_bzip2, crc-32_bzip-2
              algorithm:
                   CRC-32 (Bzip2)
              length:
                   32 bits
              type:
                   crc:32,04C11DB7,FFFFFFFF,false,false,FFFFFFFF
              since:
                   Jacksum 1.7.0
              comment:
                   This CRC is used by bzip2

              crc32_mpeg2, crc-32_mpeg-2
              algorithm:
                   CRC-32 (MPEG-2)
              length:
                   32 bits
              type:
                   crc:32,04C11DB7,FFFFFFFF,false,false,0
              since:
                   Jacksum 1.4.0
              comment:
                   this algorithm implements the MPEG
                   specification of the CRC-32 calculation

       The output format of Jacksum:

              If you don't specify a customized format with option -F, the following format is used:

              <checksum><sep><filesize><sep>[<timestamp><sep>]<filename>

       checksum
              is a checksum, CRC or a fingerprint; output depends on options -a and -x, resp. -X

       sep    is a separator; it can be modified by -s, otherwise it depends on -a and -m

       filesize
              is  the  size  (bytes or blocks) of a file, it depends on -a, the filesize won't be written by any
              MessageDigest-algorithm

       timestamp
              is an optional timestamp of a file; timestamps can be requested with -t

       filename
              is a filename, paths can be part of the output, output depends on -p and -P.

EXIT STATUS

       0  - everthing is OK
       1  - there was at least one mismatch during the verification process
       >1 - in case of a parameter-, .jacksum- or I/O-error

EXAMPLES

       jacksum -a crc32 -q "txt:Hello World!"

            calculates a 32-bit CRC of the text "Hello World!"

       jacksum -a crc32 -q 48656C6C6F20576F726C6421

            calculates a 32-bit CRC of the hex sequence 48656C6C6F20576F726C6421 which represents "Hello World!"

       jacksum -a crc32 -x *.txt

            calculates a 32 bit CRC of all textfiles within the current folder.  The checksum will be printed in
       a hexadecimal format (-x).

       jacksum -a crc32 -f -t default .

            not  only CRCs will be printed, but also timestamps (-t) of all files within the current folder (.).
       The message "is a directory" will be suppressed (-f).

       jacksum -f -a crc:16,1021,FFFF,false,false,0 .

            a CRC with customized parameters has been used: 16 Bit, Polynomial 1021 (hex,  without  the  leading
       bit), initvalue FFFF (hex), mirror neither the input nor the output, no xor.

       jacksum -a haval_256_5 .

            calculates  a  256  bit  hash  with 5 rounds by using the haval algorithm (haval_256_5) of all files
       within the current folder (.).

       jacksum -a sha1 -s "\t" -t "EEE, MMM d, yyyy 'at' h:mm a" .

            calculates a 160 bit SHA-1 Message-Digest of all files within  the  current  folder.  The  separator
       string  (-s) is set to the tabulator char ("\t"). Timestamps of files will be printed out in a customized
       format (-t).

       jacksum -a cksum -r /mnt/share

            calculates a 32 bit CRC with the standard Unix-algorithm cksum of  all  files  /mnt/share  and  it's
       subfolders (-r)

       jacksum -a md5 -f -r -m -o list.jacksum /data

            calculates  the  Message-Digest  MD5  of all files in /data and it's subfolders (-r), furthermore it
       prints metainfo (-m) and stores output to list.jacksum, path information is stored ABSOLUTELY

       jacksum -a md5 -f -r -m -o list.jacksum -w /data

            calculates the Message-Digest MD5 of all files in /data and it's  subfolders  (-r),  furthermore  it
       prints metainfo (-m) and stores output to list.jacksum, path information is stored RELATIVELY

       jacksum -c list.jacksum

            verifies  all  checksums resp. timestamps stored in a file called list.jacksum. list.jacksum must be
       generated first with option -m

       jacksum -a md5 -f -F "#FINGERPRINT #FILESIZE #FILENAME" *

            calculates the Message-Digest MD5 of all files in  the  current  directory.  The  output  format  is
       customized, it prints also the filesize.

       jacksum -a md5 -A -V summary bigfile.iso

            Among  others it also returns the elapsed time (-V summary) which was necessary to calculate the MD5
       Hash of the file called bigfile.iso by using the alternate MD5 implementation (-A).

       jacksum -a crc32 -X -f -p -r -F "#FILENAME #CHECKSUM" -o list.sfv *

            prints CRC-32 values in the Simple File Verificator (SFV) format

       jacksum -a ed2k -f -F "ed2k://|file|#FILENAME|#FILESIZE|#FINGERPRINT|" *

            calculates the edonkey hash of all files in the current directory with a customized output format

       jacksum       -a       ed2k       -f       -P       /        -F        "<a        href=#QUOTEed2k://|file
       |#FILENAME|#FILESIZE|#FINGERPRINT|#QUOTE>#FILENAME</a>" -r .

            calculates  the  edonkey  hash  of  all  files  in  the current directory and it's subfolders with a
       customized output format (HTML)

       jacksum -a tree:tiger -F "urn:#ALGONAME:#FINGERPRINT" -q hex:

            calculates the root hash of the Tree Hash (aka Merkle Hash) with the underlying Tiger  algorithm  of
       an empty input.

       jacksum -a sha1+crc32 .

            calculates the sha1 hash and the crc32 as a combined checksum

       jacksum -a sha1+crc32 -F "#CHECKSUM{0} #CHECKSUM{1} #FILENAME" .

            calculates the sha1 hash and the crc32 as separate values

       jacksum -a all -F "#ALGONAME{i} (#FILENAME) = #CHECKSUM{i}" .

            calculates all supported algorithms on all files in a customized format

       jacksum -a all -F "#ALGONAME{i}" -q txt:

            prints names of all supported algorithms

       jacksum -h synopsis

            prints the SYNOPSIS section

       jacksum -h haval

            prints all sections containing information about haval

       jacksum -h -t

            prints all information about the timestamp option

       jacksum -h en | more

            prints the english help (use "de" for german help)

AUTHOR

       Copyright (C) 2002-2006, Dipl.-Inf. (FH) Johann N. Loefflmann <jonelo@jonelo.de>

       http://www.jonelo.de/java/jacksum/index.html

LICENSE

       This  program  is  free  software;  you  can  redistribute it and/or modify it under the terms of the GNU
       General Public License as published by the Free Software Foundation; either version 2 of the License,  or
       any later version.

       This  program  is  distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
       the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  General  Public
       License for more details.

       You  should have received a copy of the GNU General Public License with the Debian GNU/Linux distribution
       in file /usr/share/common-licenses/GPL; if not, write to the Free Software Foundation, Inc., 51  Franklin
       Street, Fifth Floor, Boston, MA 02110-1301  USA