NAME
    Jacksum (JAva ChecKSUM)
 

VERSION
    1.7.0
 

SYNOPSIS
    java -cp jacksum.jar Jacksum [options]... [file]...
    or
    java -jar jacksum.jar [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 parameter is 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 file is character "-", read
                  from standard input.
 

    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+"
                  Seit 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
                  your JVM vendor and usually they provide a 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       check 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. 
                  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 a
                  recursively traversal. If this option is set, symbolic
                  links to directories will be ignored. The option will be
                  ignored under Windows.
                  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).
                  since Jacksum 1.4.0
                  Works also with multiple files or directories to find
                  duplicates. In this case all findings are printed out.
                  The sequence can be specified case sensitive or case 
                  insensitive, except if the Base 64 encoding (by -E) has
                  been specified.
                  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)

                  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"
                  since Jacksum 1.0.0, see also -V

    -F format     format. Set a customizable output format to overwrite the
                  default.

                    #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 (")

                  since Jacksum 1.5.0, if not other specified,
                  see also -a, -E, -g, -G, -p, -P, -s, -t, -x, -X

    -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.
                 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.
                  since Jacksum 1.6.0, see also -E, -g, -x und -X

    -h [lang]     print help, valid codes for "lang" are "en" or "de", default
       [section]  is "en"; valid values for "section" are strings like
                  headers or options. See section EXAMPLES for more information.
                  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 string.
                  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.
                  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.
                  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.
                  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.
                  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 other side of the coin it will be much easier to
                  sort or grep the lines with corresponding programs.
                  since Jacksum 1.4.0, see also -F, -P, -r and -w

    -P char       path char. By default the system-dependent default 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.
                  since Jacksum 1.5.0, see also -F und -p

    -q [type:]seq process a sequence quickly and quit the program.
                  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.
                  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)
                  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
                  since Jacksum 1.0.0, see also -F

    -S            summary. It calculates just one checksum value. All files,
                  the directory structures, the filenames and timestamps
                  (if requested) are part of that checksum. See also -w.
                  since Jacksum 1.5.0, see also -r und -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 (")

                  since Jacksum 1.6.0, see also -F

    -u file       ugly, undesirable, unforeseen, uninvited. Any error messages
                  of the program go 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.
                  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.
                  since Jacksum 1.6.0, see also -u, -o and -O

    -v           version. Prints the product version and exits
                  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 the word called "default", control is
                  set to "details,warnings,nosummary"
                  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.
                  since Jacksum 1.6.0, see also -r and -S

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

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

    The following algorithms are supported:

    adler32       algorithm:   Adler32 [java.util.zip.Adler32]
    adler-32      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           algorithm:   BSD checksum algorithm
    bsdsum        length:      16 bits
    sumbsd        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

    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

    crc8          algorithm:   CRC-8 
    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)

    crc16         algorithm:   CRC-16 (ARC)
    crc-16        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.

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

    crc24         algorithm:   CRC-24
    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         algorithm:   CRC-32 [java.util.zip.CRC32]
    crc-32        length:      32 bits
    fcs32         type:        crc:32,04C11DB7,FFFFFFFF,true,true,FFFFFFFF
    fcs-32        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   algorithm:   CRC-32 (Bzip2)
    crc-32_bzip-2 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   algorithm:   CRC-32 (MPEG-2)
    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

    crc64         algorithm:   CRC-64
    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           algorithm:   ELF
    elf32         length:      32 bits
    elf-32        type:        hash
                  since:       Jacksum 1.5.0
                  comment:     hash function used in the Unix ELF (Executable
                               and Linkable Format) for object files.

    ed2k          algorithm:   eMule/eDonkey
    emule         length:      128 bits
    edonkey       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        algoritm:    HAS-160 [gnu.crypto.hash.Has160 (jonelo)]
    has-160       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         algorithm:   Haval [gnu.crypto.hash.Haval]
    haval_<b>_<r> 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           algorithm:   MD2 [gnu.crypto.hash.MD2]
    md2sum        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 edu
                               purposes.

    md4           algorithm:   MD4 [gnu.crypto.hash.MD4]
    md4sum        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 edu
                               purposes.

    md5           algorithm:   MD5 [java.security.MessageDigest]
    md5sum        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)

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

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

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

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

    sha0          algorithm:   SHA-0 [gnu.crypto.hash.Sha0 (jonelo)]
    sha-0         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           algorithm:   SHA-1 [java.security.MessageDigest]
    sha1          length:      160 bits
    sha-1         type:        hash, 1995
    sha160        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        algorithm:   SHA-224 [gnu.crypto.hash.Sha224 (jonelo)]
    sha-224       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        algorithm:   SHA-256 [java.security.MessageDigest]
    sha-256       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        algorithm:   SHA-384 [java.security.MessageDigest]
    sha-384       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.

    sha512        algorithm:   SHA-512 [java.security.MessageDigest]
    sha-512       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          algorithm:   Sum 8
    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         algorithm:   Sum 16
    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         algorithm:   Sum 24
    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         algorithm:   Sum 32
    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          algorithm:   UNIX System V checksum algorithm
    sysvsum       length:      16 bits
    sumsysv       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      algorithm:   Tiger 128 [gnu.crypto.hash.Tiger160 (by jonelo)]
    tiger-128     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      algorithm:   Tiger 160 [gnu.crypto.hash.Tiger160 (by jonelo)]
    tiger-160     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         algorithm:   Tiger [gnu.crypto.hash.Tiger]
    tiger192      length:      192 bits
    tiger-192     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

    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    algorithm:   Whirlpool-0 [gnu.crypto.hash.Whirlpool (jonelo)]
    whirlpool-0   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    algorithm:   Whirlpool-1 [gnu.crypto.hash.Whirlpool]
    whirlpool-1   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     algorithm:   Whirlpool [gnu.crypto.hash.Whirlpool (jonelo)]
    whirlpool2    length:      512 bits
    whirlpool-2   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          algorithm:   Exclusive-Or
    xor-8         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.
 

    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" *
        calcualtes 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
    mailto: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
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 

Download

Highlights

The Team

The long list of contributors can always be found in the latest download package and in the copyright section. The founder and lead for this project is Johann N. Löfflmann from Germany. Since 2002 he has been working with very talented people all around the world in order to improve Jacksum further.

OSI certified
Get Java Software