jonelo logo
separator


Home
   News
   Search
Private
   Über mich...
   Wer war Nepomuk?
   USA Travel Tips
Java Software
   BigAl
   Jacksum
   Jarfix
   NumericalChameleon
   Sugar
   FAQ
Poetry
   Angst
   Dummheit
   Der Hamster
   Der Moment
   Die Briefmarke
   Heißer Sand
   Weihnachten
Kontakt
   E-Mail
   Gästebuch
   Impressum

disclaimer
[Description] [Features] [Copyright] [Requirements] [Download] [Installation] [FAQ] [Manual] [History] [Contact] [Links]

Jacksum  1.7.0

a free and platform independent Open Source project
since 2002

für Deutsch bitte hier klicken

Description:

Jacksum is a free and platform independent software for computing and verifying checksums, CRCs and message digests (known as hash values and fingerprints). "Jacksum" is a synthetic word made of JAva and ChecKSUM.

Jacksum supports 58 popular algorithms (Adler32, BSD sum, Bzip2's CRC-32, POSIX cksum, CRC-8, CRC-16, CRC-24, CRC-32 (FCS-32), CRC-64, ELF-32, eMule/eDonkey, FCS-16, GOST R 34.11-94, HAS-160, HAVAL (3/4/5 passes, 128/160/192/224/256 bits), MD2, MD4, MD5, MPEG-2's CRC-32, RIPEMD-128, RIPEMD-160, RIPEMD-256, RIPEMD-320, SHA-0, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, Tiger-128, Tiger-160, Tiger, Tiger2, Tiger Tree Hash, Tiger2 Tree Hash, Unix System V sum, sum8, sum16, sum24, sum32, Whirlpool-0, Whirlpool-1, Whirlpool and xor8).

Jacksum supports the "Rocksoft (tm) Model CRC Algorithm", it can calculate customized CRC algorithms and it supports the combination of multiple algorithms.

Jacksum has opened it's source code and it is released under the terms of the GNU GPL. Jacksum is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.

Jacksum is platform independent, because it is written entirely in the Java programming language, the software runs on any platform having a Java Runtime Environment.

Jacksum has multiple interfaces. It can be used on the command line, at your file browser/manager, and it can be found as engine also in many other software projects.

Read what people around the world think about Jacksum ...
 

Purpose:
With Jacksum you can check if a filetransfer was successful. If you download software or huge files, like CD-images (so called iso files)  from the internet, often there is a checksum or a hashcode provided. With Jacksum you can calculate such a checksum or hashcode from your local copy. If both checksequences are identical you know that the filetransfer was successful.

As Jacksum reads each byte of a file, you can check if all files are still readable on your CD-ROMs and DVDs.

As Jacksum supports recursively file processing, you can compare two directory trees. Therefore you will be able to verify, if your copies or backups are identical with the original source, even if you don't have access to both trees at the same time (compare two DVDs with just one drive for example).

Jacksum can assist you if you want to perform an unidirectional sync of two directory trees, even if they are on two different computer without a connection in between.

As Jacksum supports a platform independent and compatible file format, it helps you to verify data integrity of burned data on CD-ROMs or DVDs even after many years and even if you will have changed your Operating System.

Jacksum can help you to create incremental backups.

If you are a developer, Jacksum can help you to create patches for your customers.

You can use Jacksum for intrusion detection, because Jacksum can check whether and what files have been changed or deleted on your system. Jacksum can not only check the content of each file you want, but also the file timestamps.

Use Jacksum for website content change detection, so get informed if something has changed on your favorite website (can be useful if the website has no announcement-mail-alias).

For detailed information please read section FAQ.
 

Features:
Really free software:

  • It is really Free Software, it runs also on entirely free platforms and therefore it is listed also at the Free Software Foundation directory
  • It is OSI Certified Open Source software
  • It is free of charge, it costs nothing, if you have some money left, please give it to a human helper organization
  • It is free of advertisement, but you can tell your friends about Jacksum
  • It is free of expirations, you can use it at any time, and for ever
  • It is free of registration, but I'm happy if you write a few words to jonelo@jonelo.de just for feedback
Multi-Platform support:
  • It is platform independent (100 % Java), so you can run it on all common operating systems, such as Windows (95/98/ME/NT/2000/2003/XP/Vista), Linux (Debian, Fedora, Gentoo, JDS, Knoppix, Linspire, Red Hat, Slackware, SUSE, Turbolinux, Mandriva, Ubuntu, etc.), Unix (BSD, HP-UX, Mac OS X/PPC, Mac OS X/x86, Solaris/SPARC, Solaris/x86, etc.) or any other operating system (e.g. OS/2) with a Java Runtime Environment (JRE). Do you want to live with your current operating system for ever?
  • Keeps compatibility with JRE 1.3.1, but takes all the advantages of JRE 1.4.2, JRE 5.0 or JRE 6 if available, runs also on entirely free platforms with latest versions of gij or kaffe
  • Runs on both 32 and 64 bit systems. Yes, Jacksum is 64 bit ready, you just need a 64 bit JRE.
  • It is large file aware, it can process filesizes up to 8 Exabytes (= 8,000,000,000 Gigabytes), presupposed your operating system respectively your file system is large file aware, too.
  • As it has a commandline interface, Jacksum can be used in cronjobs and autostart environments
  • It is aware of special files like FIFOs and symbolic links on Linux/Unix and system folders on Windows
  • Works with the SendTo-feature on Windows Explorer, KDE Konqueror and Gnome Nautilus
General program features:
  • Supports 58 popular checksum algorithms including strong one-way-hash algorithms (Adler32, BSD sum, POSIX cksum, Bzip2's CRC-32, CRC-8, CRC-16, CRC-24, CRC-32 (FCS-32), CRC-64, ELF-32, eMule/eDonkey, FCS-16, GOST, HAS-160, HAVAL (3/4/5 passes, 128/160/192/224/256 bits), MD2, MD4, MD5, MPEG-2's CRC-32, RIPEMD-128, RIPEMD-160, RIPEMD-256, RIPEMD-320, SHA-0, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, Tiger-128, Tiger-160, Tiger, Tiger2, Tiger Tree Hash, Tiger2 Tree Hash, Unix System V sum, sum8, sum16, sum24, sum32, Whirlpool-0, Whirlpool-1, Whirlpool and xor8)
  • It can calculate customized CRC algorithms and it also supports the combination of multiple algorithms
  • Fully customized output is supported
  • It can calculate checksums, CRCs and hashes on both files and user input sequences (text, hexadecimal and decimal)
  • The program is mature and very stable
  • Algorithms are very fast (go ahead, and compare Jacksum's performance with similar tools)
  • Recursively file processing is supported (it operates not only on files from a specific directory, but also on files from all subdirectories of the specified directory)
  • It can verify both the content and timestamp of files
  • It helps you to find duplicates by knowing just only the checksum of a file
Compatibility and customizability:
  • By default, output is 100% compatible to Unix-standard tools such as sum, cksum, md5sum and sha1sum
  • File output format is flexible and fully customizable (add filesizes to the md5 output, create SFV files, XML data or create lists with the eDonkey-Link format for example)
  • Additionally, the .jacksum file format is supported (it is an open, platform independent and compatible file format, so you will be able to check files and timestamps against a list even after many years and even if you have changed your Operating System!)
  • Multiple Encodings (hex, BASE 16, BASE 32, BASE 64 and BubbleBabble) for all checksums, CRCs and hashes are supported
Strong community
  • Jacksum has been downloaded more than 15000 times the past 12 months
  • Jacksum has been incorporated in many other free projects
  • The Jacksum project has both a great and active community, it consists of both users and developers, all of them providing bug reports, support and feature requests, Jacksum users have brilliant ideas (see also History)
Developer support:
  • It returns an exit status which is dependent on the result of the calculation/verification process, so you can use Jacksum in scripts or batches
  • Jacksum provides an open API, so you can incorporate Jacksum in your own projects
  • Javadoc can be generated from the sources
  • Ant-script is available which is also ready for use with Netbeans


Copyright:

Jacksum 1.7.0 Copyright (C) 2002-2006
Dipl.-Inf. (FH) Johann Nepomuk Loefflmann

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. See also FAQ .
 

Requirements:

To run Jacksum, you need a Java Runtime Environment (JRE). You can obtain it for free of course. It is required to have at least the JRE version 1.4.2, but it is recommended to install the latest available JRE. If you are running Linux, Windows or Solaris go to http://www.java.com or http://java.sun.com/j2se/ . MacOS X users can go to http://www.apple.com/java to find a suitable Java Runtime Environment. Jacksum also runs on FOSS JVMs, go to http://gcc.gnu.org/java/ or http://www.kaffe.org for more information.
 

Download:
Jacksum is written entirely in Java, therefore it is platform independent and runs on all operating systems having a Java Runtime Environment.

Read the sections Requirements and Copyright . You have to read and accept the GNU General Public Licence if you want to download and use Jacksum. The file also contains all the sourcecodes.
 
jacksum-1.7.0.zip (July 30, 2006)

MD5:               f1cf99f9e2b68016668dce4c4d51d346
SHA-1:             e3d840fa7b9949003ca731c7ce3e0281c350d821
Size:              446595 bytes

Optional:
jacksum-1.7.0-windows-explorer-integration-1.1.0.zip (Oct 8, 2006)

MD5:               b32c1f78d4aac391b18656f0e28f51cf
SHA-1:             75211d14facc3f276d8c80c617c84b28f1f868c1
Size:              220951 bytes

jacksum-1.7.0-kde-konqueror-integration-1.1.0.tar.bz2 (Oct 8, 2006)

MD5:               c17c6f7ce5310e71dda8ae00ec359915
SHA-1:             2a5b89f409865ec02de3f2dd9e195ab3ec3b8de0
Size:              199349 bytes

jacksum-1.7.0-gnome-nautilus-integration-1.1.0.tar.bz2 (Oct 8, 2006)

MD5:               c17c6f7ce5310e71dda8ae00ec359915
SHA-1:             2a5b89f409865ec02de3f2dd9e195ab3ec3b8de0
Size:              199349 bytes

All optional packages above contain an installer for a specific environment as well as the the jacksum binary.
You can obtain older releases at sourceforge.net
 

Installation:

1. Go to www.java.com and install the latest Java Runtime Environment, see also Requirements.

2. Download and unzip the file called jacksum-1.7.0.zip. If you are on Windows, visit the GnuWin32 project page to obtain a free unzip tool.

   cd installdirectory
   unzip jacksum-1.7.0.zip

3. Start Jacksum in a terminal by typing

   cd installdirectory
   java -jar jacksum.jar

4. For more comfort, if you would like to start Jacksum just by typing

   jacksum

you have to modify the launch script which is part of this distribution and place it in a folder which is reachable within your PATH environment variable (see see FAQ called How do I launch Jacksum, just by typing 'jacksum').
 

FAQ:

Why should I use Jacksum rather than ...?

Your data is one of the most important things you own. Jacksum helps you to keep control of the integrity of your data and. Jacksum is very stable and reliable and it provides a lot of unique features. If you are clever, you are going to compare the features of those tools with Jacksum's feature list above and you will be able to answer the question above by your own  ;-)
 

Is there a GUI for Jacksum?

In addition to the standard command line interface, the Jacksum project supports also the integration into the famous file browsers Windows Explorer, KDE Konqueror, Gnome Nautilus and the Finder on Mac OS X.

There is more and more effort going on. Five studends from the ETH Zürich, Switzerland are working on a SWT GUI for Jacksum. In addition to the continued improvements for the file browser integration, I'm also planning to create a Swing based GUI for Jacksum.

Jacksum's primary user interface is and will be the commandline, as it provides compatibility with other popular command line tools available on Unix, like cksum, sha1sum, sum and md5sum. The commandline interface allows you also to use the tool also easily with cronjobs, in scripts, in file browsers, in web interfaces and of course in combination with pipes and other useful tools like grep, sort, uniq, tar, bzip2, gzip and zip. A GUI can't offer you those features.

Jacksum also supports a public API. It can be used by a Graphical User Interface (GUI) for example.
See also "Can I incorporate Jacksum into my project?" and "Software which incorporates Jacksum".
 

How do I launch Jacksum, just by typing "jacksum"?

Under UNIX define an alias or write a script that contains just the two lines:
#!/bin/sh
java -jar "/path to jacksum/jacksum.jar" "$@"

Make sure, that the script is reachable from the PATH and execute permissions are set correctly (man chmod).

Under Windows write a batch, it should be reachable from the PATH:
@echo off
java -jar "c:\path to jacksum\jacksum.jar" %*

The Windows Explorer Integration creates the batch above for you.

How can I use Jacksum with the Windows Explorer?

Download the file for Windows, and run the included installer. It will install the most used features of Jacksum at the Windows Explorer. During the installation also an uninstaller is created which can be used to remove the feature again. The installer and uninstaller don't touch the registry. Simply select files at the Windows Explorer, click on the right mouse button and select a Jacksum menu entry from the "Send To" menu to calculate and verify CRCs, hashes and fingerprints.


 

How can I use Jacksum with KDE Konqueror?

Download the file for Linux/Unix (KDE), and run it:

bunzip2 < jacksum-*.bz2 | tar xfv -
cd jacksum-file-browser-integration/
./jacksum-file-browser-integration.sh

The interactive script will help you to install (and uninstall) features of Jacksum at the KDE Konqueror. The screenshot below has been taken from SUSE Linux 10.

How can I use Jacksum with Gnome Nautilus?

Download the file for Linux/Unix (Gnome), and run it:

bunzip2 < jacksum-*.bz2 | tar xfv -
cd jacksum-file-browser-integration/
./jacksum-file-browser-integration.sh

The interactive script will install (and uninstall) features of Jacksum at the Gnome Nautilus. The script works on both Linux and Solaris. The screenshot below has been taken from Ubuntu Linux 5.10:


 

How can I use Jacksum with Finder under Apple Mac OS X ?

A comfortable installer is on the way for Apple users, for now you must setup it manually.

Activate the Apple built-in Script Menu using the AppleScript Utility in your AppleScript folder. See also http://www.apple.com/applescript/scriptmenu/
Use the following applescript to calculate the sha256 hash (example) from the files you select in Finder:
 
tell application "Finder"
    set theseItemsto the selection
end tell
set allFiles to ""
repeat with i from 1 to the count of theseItems
    set thisItemto(item i oftheseItems) as alias
    set thisFileto POSIX path of thisItem
    set allFilestoallFiles & " " & thisFile
end repeat
set theCommandto "jacksum -a sha256 " & allFiles & " > /tmp/jacksum.txt"
do shell script theCommand
property targetURL : "file:///tmp/jacksum.txt"
open location targetURL

Why should I use at least JRE 1.4.2 ?

Jacksum run on JRE 1.3.1 and any later release. However, if you use at least JRE 1.4.2 you will notice a faster program start and the faster algorithms SHA-256, SHA-384 and SHA-512 (those are known as SHA-2) from your JRE can be used. It is recommended to use the latest JRE. Download it from http://java.sun.com/javase. By using JRE 5.0 or JRE 6 you get even more performance for Jacksum.
 

What's the meaning of the Jacksum output?

e. g..
599770357    23560    foo.txt

The first number represents the CRC, checksum or hash. It depends on the algorithm you use (option -a) and whether you have specified the hex option (option -x, respectively option -X). The second number represents the filesize, usually in bytes. Exceptions are both algorithms BSD sum and UNIX system V sum,  they print the filesize in blocks. The filesize will be not written by any One-Way-Hash based algorithm (e. g. SHA1, MD5, etc.), because the filesize is already incorporated into the message digest. The third column (it's the second one if you have specified a One-Way-Hash based algorithm) represents the filename. The filename will not be written if the standard-input device is used.

With Jacksum 1.3.0 you have the option to print the timestamp from files. In this case an additional column appears in each line (just before the filename). The meaning of the timestamp is dependent on the format you set (option -t).

599770357    23560    20031027140042     foo.txt

Since Jacksum 1.5.0 you have the full control on the output by using the option -F.
 

Which algorithm should I use?

With option -a you can choose one of many algorithms. If you got a file from a trusted source and you only would like to know if a file transfer was successful, many algorithms can be used. However, for a really save file integrity check and verification on thousands of files on today's harddisks (see also option -c), not all algorithms are suitable in this case.

Don't use:
From a cryptographic point of view, it is recommended not to use the following algorithms, because they don't care about the arrangement of bytes in a file: sum8, sum16, sum24, sum32 and xor8. Furthermore you shouldn't use MD2 or MD4, because RSA doesn't recommend to use them anymore. SHA-0 is also weak, it was replaced by SHA-1 in year 1995.

Limited usability:
All checksum and CRC based algorithms like Adler32, BSD sum, POSIX cksum, CRC-8, CRC-16, CRC-24, CRC-32 (FCS-32), FCS-16, MPEG-2's CRC-32, CRC-64, the generic CRC and the Unix System V sum do not have the bit strength and the mathematical power to guarantee strong fingerprints for thousands of files on today's harddiscs. See also the CRC-Faker and read the article "CRC and how to Reverse it" (Link http://surf.to/anarchriz is not available anymore, use a search engine to find the doc). Viruses could be able to fake files - with a CRC based algorithm you cannot detect such intruders. Although Jacksum is able to produce SFV on demand, it is highly recommended to avoid using SFV files. They are based on CRC32 values and SFV doesn't take the filesize into account. SFV is really history.

Not really recommended:
ELF-32 is a very simple hash based algorithm and has not the bit strength for save file integrity checks, probably. The Whirlpool has been replaced two times by a new Whirpool. The algorithm eMule/eDonkey (MD4 based, but improved) would have enough bits, but even for the widely used MD5 and HAVAL_3_128 real collisions have been detected already (http://eprint.iacr.org/2004/199/) in August 2004 (with a non-brute force method). The paper also mentions collisions for the full RIPEMD-128, however the hexdump example in the doc doesn't generate a collision (while all the other examples in the doc have been verified, the RIPEMD hexdump example seems to have a typo). For an excellent example of a MD5 collision go to http://www.cits.rub.de/MD5Collisions. Note that RIPEMD-256 is as secure as RIPEMD-128 so it is also not recommended. Tiger/128 and Tiger/160 are truncated hash functions of Tiger/192. Although they seem to be save today, the non-truncated has functions are more secure.

SHA-1
In February 2005, Bruce Schneier reported an attack by Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu. The attack is outlined in a brief note by the authors. The authors assert that their attacks can find collisions in the full version of SHA-1, requiring less than 269 operations (a brute-force search would require 280). In academic cryptography, any attack that has less computational complexity than the expected time needed for brute force is considered a break. This does not, however, necessarily mean that the attack can be practically exploited. So in the real world, the SHA-1 is still secure, at least for verifying integrity. For latest cryptanalysis of SHA-1 read http://en.wikipedia.org/wiki/SHA1#Cryptanalysis_of_SHA-1.

Recommended:
From a today's cryptographic point of view (October 2006), the following one-way-hash algorithms are save to perform file integrity checks: HAVAL-{3/4/5}-{160/192/224/256}, RIPEMD-160, RIPEMD-320, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, Tiger, Tiger2 and the second revision of Whirlpool. Jacksum supports all those algorithms. Since Jacksum 1.5.0, the algorithm SHA-1 is the default.

Since Jacksum 1.7.0 you can combine multiple algorithms together. I recommend to combine at least two different techniques, a hash algorithm such as SHA-1 and a CRC such as CRC32 are a very good combination for file integrity checks. Even if a collision will be found in the future for a hash based algorithm, it is very unlikely that also a CRC returns equal values in this case.
 

Why are there alternate implementations available?

A few algorithms (adler32, crc32, md5, sha-1) are part of the standard Java API. A few others (sha-256, sha-384, sha-512) are part of a newer Java API. If  an algorithm is provided by your JRE, Jacksum is just calling the API and use the algorithm which is offered by the JRE. Some vendors of the JRE are calling native code which results usually in a good performance. But note, that this is the implementation detail of the vendor of a JRE and can be vary from vendor to vendor and from version to version. Due to several requests I also provide alternate, pure Java implementations for all of the algorithms which are usually covered by the Java API. On some systems an alternate implementation can perform much better (the MD5 for example), but this depends on the performance on your computer and on the Java Runtime Environment you use. Usually it is a good idea to use the latest JRE and rely on the performance the JRE can offer. Tests have shown that the newer your JRE, the better the performance. In some cases with the option -A you get better performance.
 

Are CRCs obsolete today ?

No, CRCs are still used in hardware, firmware, protocols, simple software installers (NSIS for example) and today's filesystems (ZFS on Solaris for example). Usually they are fast (and not so complex like one-way-hashes), and they are useful to verify a small amount of data. Furthermore, they are a very good addition to hash based algorithms. Jacksum supports the "Rocksoft (tm) Model CRC Algorithm" which makes it possible to calculate any customized CRC.
 

How is a CRC calculated ?

A lot of people were asking me this question. Well, there are some good websites explaining how CRC is working. Go to http://surf.to/anarchriz or ftp://ftp.rocksoft.com/papers/crc_v3.txt. You also might have a look at the sourcecode of Jacksum.
 

Does Jacksum support the CCITT checksum algorithm ?

Many references define the CRC-16/CCITT as

    crc:16,1021,FFFF,false,false,0

The notation "crc:width,poly,init,refIn,refOut,xorOut" is used since Jacksum 1.7.0 to specify a CRC algorithm according to the Rocksoft(TM) Model CRC Algorithm. Using the message 123456789, a CRC algorithm with the parameters above returns 0x29B1:

  jacksum -q txt:123456789 -a crc:16,1021,FFFF,false,false,0 -X
  29B1

However, other sources claim that according to the CCITT standard (see above), a message must be prepended with 16 zero bits before the calculation. This interpretation of the standard can be expressed as

    crc:16,1021,1D0F,false,false,0

Notice, that in this case only the init value is different, because using a 16 bit zero message, a CRC with the init parameter 0xFFFF returns 0x1D0F which is the init value for the alternate interpretation of the algorithm.

Using the message 123456789, a CRC algorithm with the parameters above returns 0xE5CC:

  jacksum -q txt:123456789 -a crc:16,1021,1D0F,false,false,0 -X
  E5CC

Well, it is entirely up to you to select the CCITT standard you believe ;)
Jacksum is able to calculate both algorithms (and even any other interpretation of this "standard").
 

I receive the error "java.io.IOException: Data error (cyclic redundancy check)". What does that mean?

This is an error produced by Windows (NT based) and means that Windows is not able to read files from your CD-ROM or DVD. Therefore also Jacksum can't read those files. You should copy all readable files which resides on the same media to a new CD-ROM or DVD to avoid further data loss. Under Linux you receive the error called "java.io.IOException: Input/output error" (example from Red Hat).
 

What algorihms are currently not supported by Jacksum?

There are still a lot of algorithms not (yet) supported by Jacksum. Those are called Cellhash, Boognish, DHA-256, FEAL (patented), FFT-hash, FORK-256, Panama, Snefru (broken), DSS1, MDC2 (patented), PMD-N, PMD-V, PMD-128, PMD-160, PMD-192, PMD-224, PMD-256 (korean standards, no complete english docs are available), N-Hash (patented, insecure), VEST-4, VEST-8, VEST-16, VEST-32 (patent pending), VMS/VAX checksum (very little information available), VSH. If you own sourcecode to one of those algorithms (Java sourcecode is preferred of course), please just send them to me and I will test, optimize and include them for a next release of Jacksum. Notice, that most of those "not yet supported algorithms" are not really strong, have usage restrictions due to patents and for most of them collisions have been detected or they are already broken. Nevertheless they are on my wishlist for educational and completeness purposes.
 

A friend of mine has a machine that I think is hacked/infected, but I don't have such a machine to compare it to ...

You can find all checksums of most popular UNIX and Linux operating systems at http://www.knowngoods.org
For Solaris go to http://sunsolve.sun.com/pub-cgi/fileFingerprints.pl
I haven't found such a service for Windows.
 

How do I sync two folders on two different computers?

With Jacksum, you can perform an unidirectional synchronization, e. g. if you want to sync two folders on two different computers, even without a connection in between, Jacksum can help you to solve that kind of problem. Let's imagine that you have a good and a faulty computer.

Example for Windows:
1. Change to the good folder on the good computer and execute the command
  cd good
  jacksum -a sha1 -m -r . > c:\temp\check.jacksum

2. The file called check.jacksum represents a snapshot of all files on the good computer from the good folder.
    Transfer the file called check.jacksum file to the faulty computer.

3. Change to the folder on the faulty computer and execute the command
  cd faulty
  jacksum -c c:\temp\check.jacksum -l > c:\temp\files.list

4. The file called files.list now contains a file list of differences.
    Transfer the file called files.list to the good computer.

5. Change to the good folder on the good computer again and execute the command
  cd good
  type files.list | zip -@ patch.zip

    In case you prefer .tar.bz2 rather than .zip:
  cd good
  tar cfv patch.tar -I files.list
  bzip2 -9 patch.tar

6. The file called patch.zip respectively patch.tar.bz2 contains all files from the good computer which were modified or deleted on the faulty computer. Transfer the file called patch.zip respectively patch.tar.bz2 to the faulty computer and extract the files included in the zip to the faulty folder. The faulty folder on the faulty computer become a good folder and you fixed the problem on the faulty computer.
 

How do I create a patch with Jacksum?

As being a developer you might provide a patch to your faithfully customers so they can upgrade easier. Jacksum can help you in this case.

Example for Unix/Linux:
1. Change to your new version's folder
  cd ~/newversion
  jacksum -a sha1 -f -m -r . > /tmp/check.jacksum

2. Change to your old version's folder
  cd ~/oldversion
  jacksum -c /tmp/check.jacksum -l > /tmp/files.list

3. Change to your new version's folder again and zip the original files
  cd ~/newversion
  tar cfv patch.tar -T /tmp/files.list   (GNU/Linux, Mac OS X, PC-BSD)
  tar cfv patch.tar -I /tmp/files.list   (PC-BSD, Solaris)
  bzip2 -9 patch.tar

    In case you prefer .zip rather than .tar.bz2:
  cd ~/newversion
  cat /tmp/files.list | zip -@ patch.zip (GNU/Linux, Mac OS X, Solaris)

Thanks to Girish Narang who collaborated with me on developing a patch creator solution with Ant. Download the Ant script and a corresponding property file to create patches with Jacksum and Ant.
 

It is possible to compare two directory trees or even discs?

Yes, there are multiple ways to do that. I recommend the first way.

1. Since Jacksum 1.3.0 you can use the option -c to check files against a given list, so you will exactly know which file has been modified or deleted. You create such a list with option -m. See the following example (batch file for windows). Notice, that you can also compare two directories or even discs even if they are on two different computers without a connection in between! See also How do I sync two folders on two different computers?

Example for Windows:
@echo off
:: usage: dircmp dir1 dir2
:: dir2 may be also on a different drive
set ERRORLEVEL=
if not exist %1 goto error
if not exist %2 goto error
set BACKUP=%CD%
call jacksum -a sha1 -r -f -O %TEMP%\tmp.jacksum -U nul -m -w %2
cd %1
call jacksum -c %TEMP%\tmp.jacksum
rem echo %ERRORLEVEL%
cd %BACKUP%
goto end
:error
echo direcotry does not exist
:end

2. Execute the following commands on both directories (it is important to change the directory with cd first):

cd <the directory you want to check>
jacksum -r -f -a sha1 . | jacksum -a sha1 -

If both checksums are equal, you will know, that both directories (including subdirectories) are equal.

3. Since Jacksum 1.5.0 there is the option -S to get just one checksum back. You don't need the pipe mechanism anymore.

cd <the directory you want to check>
jacksum -a sha1 -f -S -r .
 

Why do I receive different checksums with -S on two identical folders?

It makes a difference if you calculate a checksum on c:\data or d:\data for example, because Jacksum takes those differences into account. If you don't want Jacksum to incorporate the (absolute) path information you have given at the commandline, you must change the current working directory first or use option -w. I recommend to specify relative paths like "data" (if the current directory is c:\) or "." (if the current directory is c:\data) rather than "c:\data".  If you perform the calculation on d: you must use the same parameters you have used on drive c:.  See also feature request #1028816.

wrong expectation - all checksums will be different:
jacksum -a sha1 -S c:\data
jacksum -a sha1 -S d:\data
jacksum -a sha1 -S d:\backup\data

correct usage - all checksums will be equal, assumed that files and folders are really identically:

jacksum -a sha1 -S -w c:\data
jacksum -a sha1 -S -w d:\data
jacksum -a sha1 -S -w d:\backup\data

OR

c:
cd \data
jacksum -a sha1 -S .

d:
cd \data
jacksum -a sha1 -S .

cd \backup\data
jacksum -a sha1 -S .
 

Why do I receive different checksums with -S on Windows and Linux?

I have a share partition. It is formatted as FAT32 so I can access files from both Linux and Windows. If I use the option -S, I get different checksums on a particular subtree on Linux and Windows. What's wrong?

Usually this happens if you have suboptimal mount options. If your share partition is mounted as "vfat" under Linux you should also specify the mount option called "shortname". It defines the behaviour for creation and display of filenames which fit into 8+3 characters. The mount option is necessary, because the Jacksum option -S incorporates also the filenames into the checksum. For more information see also "man mount". Alternatively use the Jacksum options -m and -c to verify files in a platform- (and mount option) independent way.
 

I got bash: !": event not found

jacksum -a crc32 -q "txt:Hello World!" gives me:
bash: !": event not found

Actually this is a bash shell issue. The ! in bash has a special meaning by default, it is the history expansion character. You can reproduce it also with echo.

$ echo "!"
bash: !: event not found

$ echo "\!"
\!

$ echo \!
!

Therefore the correct usage is

jacksum -a crc32 -q "txt:Hello World"\!
472456355    12

However, this syntax is not very comfortable. Fortunately using single quotes will also solve the trouble:

$ echo '!'
!

jacksum -a crc32 -q 'txt:Hello World!'
472456355    12

See also the manpage of bash "Enclosing characters in single quotes preserves the literal value of each character whithin the quotes".
 

How can I use Jacksum for website content change detection?

Let's assume that you would like to get informed about any modifications on this web page (http://www.jonelo.de/java/jacksum).

1. Preparation: Get the web page with the command called wget, and store the web page to your hard disk by specifying a suitable name (rather than index.html) and calculate a hash from the file:
wget http://www.jonelo.de/java/jacksum/index.html -O MyFavorite
jacksum -a sha1 -m MyFavorite > websites.jacksum

2. Check frequently: Download the page again and check the web page content's checksum against the checksum you have stored previously.
wget http://www.jonelo.de/java/index.html -O MyFavorite
jacksum -c websites.jacksum
[OK]   MyFavorite

3. To fresh up the checksum in file website.jacksum, just repeat step 1 again.

As Jacksum can store multiple checksums in a .jacksum file, you can build your own website content change detection system for all your favorite websites on the net. Use scripts and cronjobs to make life easier. If your wget-download triggers a change on a webpage (a text counter for example), you will be informed about the change that you have caused. To avoid this problem, you must cut off this information from the file, before you calculate a checksum from the file (use grep -v or regular expressions for this task).
 

Can I incorporate Jacksum into my project?

Yes, but Jacksum is not "public domain", and Jacksum is not "freeware". Jacksum is free software which is compliant with the Free Software Foundation idea. Jacksum is distributed under the terms of the GNU General Public License (GPL), as published by the Free Software Foundation (FSF). If you develop a program that is linked with Jacksum, the program must be compatible with the GPL. The upcoming GPLv3 will make the GPL compatible with more open source licenses. Once the GPLv3 is public, Jacksum will be released under the terms of  the GPLv3.

However, it is against all policies, if you use Jacksum's source code, and put it in a closed source project, and/or claim it as yours. Jacksum's sources are free and must be free for ever, and you should respect this freedom. Once you have understand the advantages of openess, you have done a step to a greater world.
 

Are there any academic publications which mentions Jacksum?
Yes, and I would like to thank them very much!


Software which incorporates the latest version of Jacksum

This section includes links to software that incorporates Jacksum or can deal with .jacksum files:
Note, that there the applications below don't support all the features that the commandline offers, but they can help you to use Jacksum if you don't like the commandline :) - list updated on April 14, 2007

  • NumericalChameleon 2.0.0 (not released yet) - GNU GPL, a platform independent unit converter for the desktop, will be powered by Jacksum 1.7.0, it can compute hashes from strings
  • Jacksum File Browser Integration - http://sourceforge.net/projects/jacksum - GNU GPL, the installers from Oct 8, 2006 add Jacksum's primary features to file browsers, it is powered by Jacksum 1.7.0.
  • http://publictimestamp.org - http://publictimestamp.org - PublicTimestamp.org offers the free service to timestamp any publicly available digital document, it is powered by Jacksum 1.7.0.
  • Hasher GUI - http://sourceforge.net/projects/hashergui - GNU GPL, a Swing GUI for Jacksum, the latest version is 0.3 from Jan 30, 2007 and it is powered by Jacksum 1.7.0
Software which incorporates older version of Jacksum
  • DuMP3 - http://dump3.sourceforge.net - GNU GPL, the software finds any duplicate or similar file, the latest version 0.2.14 beta is from Dec 26, 2006, and is powered by  Jacksum 1.6.1.
  • Prevalent Digest Creator - http://www.prevalent.de -  GNU GPL, the software from Jan Kechel is powered by Jacksum 1.6.1. It provides a free service to store digests on a server - GNU GPL, the latest version 1.1.0 is from Jan 11, 2006.
  • Serversniff Hash Calculation - http://serversniff.net - Online-Tool powered by Jacksum 1.6.1 to compute hashes from strings, the latest version is from Nov 11, 2005
  • Real Public Radio Network - www.rprn.org - the software is powered by Jacksum 1.5.1. RPRN is a non-profit organization creating a networked community to support the exchange of digital audio content - the latest developer version is from May 3, 2005.
  • OntoMedia - http://www.ontomedia.de - is a multimedia management system developed by Bodo Hüsemann at the University of Muenster. It uses Jacksum 1.5.0, see also credits
  • MD5 GUI - http://sourceforge.net/projects/md5gui - the software from John Brown provides a nice GUI and is powered by Jacksum 1.5.1 (only the MD5 algorithm is from a different vendor due to historic reasons),  GNU GPL, the latest version 0.97 is from Jan 29, 2005
  • xfdu - http://sindbad.gsfc.nasa.gov/xfdu/ - xfdu stands for extensible data packaging format, and it is an implementation of the Recommendation for Space Data System Standard by the Management Council of the Consultative Committee for Space Data Systems (CCSDS) which is a departement of the National Aeronautics and Space Administration (NASA), and it uses Jacksum 1.4.0 (see also dependencies)
  • Java Mechanic - http://sourceforge.net/projects/javamechanic - the software bundles Jacksum 1.2.0, the project can be useful if you are a developer - GNU GPL, the latest version 3.0 is from April 4,  2004
  • JavaIntegrity - http://sourceforge.net/projects/javaintegrity/ - It is a commandline tool and is powered by Jacksum 1.1.0. Features from JavaIntegrity 1.1 are already covered by later Jacksum versions - GNU GPL, the latest version 1.1 is from Oct 27, 2002
  • TrID - http://mark0.net/soft-trid-e.html - Marco Pontello's file identifier for Windows knows .jacksum files
  • file - the file command on Unix/Linux can be made aware of .jacksum files, if you append the "jacksum.magic" to your /etc/magic
If you have developed software that incorporates Jacksum, and would like to have a link or a description added here, please send an e-mail to jonelo@jonelo.de
 

Do you have any code examples of using the Jacksum package in another tool?

Yes, the quintessential snippet is here:
 

   import java.io.*;
   import java.security.*;
   import jonelo.jacksum.*;
   import jonelo.jacksum.algorithm.*;
   // ...

   AbstractChecksum checksum = null;
   try {
     // select an algorithm (md5 in this case)
     checksum = JacksumAPI.getChecksumInstance("md5");
     // On some systems you get a better performance for particular
     // algorithms if you select an alternate algorithm (see also option -A)
     // checksum = JacksumAPI.getChecksumInstance("md5", true);
   } catch (NoSuchAlgorithmException nsae) {
     // algorithm doesn't exist
   }

   // updates the checksum with the content of a file
   try {
     checksum.readFile(filename);
   } catch (IOException ioe) {
     // ...
   }
   System.out.println(checksum);
 

To update the checksum with bytes or bytearrays, you can use the update methods:
 

   // reset the object for reuse (any formatting rules remain)
   checksum.reset();
   // update the checksum with a single byte
   checksum.update(abyte);
   // update the checksum with a bytearray
   checksum.update(bytearray);
   // update the checksum with the first 10 bytes in the bytearray
   checksum.update(bytearray, 0, 10);

   System.out.println(checksum);
 

To get the information what algorithms are supported, use the following snippet. If you use JSE 5.0 or above, you can use Generics to avoid the castings.
 

   Map map = JacksumAPI.getAvailableAlgorithms();
   Iterator iterator = map.entrySet().iterator();
   while (iterator.hasNext()) {
       Map.Entry entry = (Map.Entry)iterator.next();

       String description = (String)entry.getValue();
       // do something with the description
       // ...

       AbstractChecksum checksum = JacksumAPI.getChecksumInstance((String)entry.getKey());
       // do something with the checksum object
       // ...
   }
 

To control the format of the checksum only, you can perform methods on the checksum object:
 

   // checksum is printed in hex form (see also option -x)
   // example: 7d93370d5ef94450151826ca20c6e512
   checksum.setEncoding(HEX);

   // checksum is printed in uppercase hex form (see also option -X)
   // example: 7D93370D5EF94450151826CA20C6E512
   checksum.setEncoding(HEX_UPPERCASE);

   // checksum is printed in uppercase hex and grouped form (see also options -g, -G)
   // example: 7D93-370D-5EF9-4450-1518-26CA-20C6-E512
   checksum.setEncoding(HEX_UPPERCASE);
   checksum.setGrouping(2, '-');

   // checksum is printed in Base 64 form (see also option -E)
   // There is also BASE16 and BASE32
   // example: fZM3DV75RFAVGCbKIMblEg==
   checksum.setEncoding(BASE64);

   // checksum is printed in BubbleBabble form (see also option -E)
   // example: xizen-fetab-tilaz-necuh-buhyc-mynys-pemes-kunyc-daxox
   checksum.setEncoding(BUBBLEBABBLE);
 

To control the format of a complete line, you can use the format method
 

   // print the checksum, the default output format depends on the algorithm
   System.out.println(checksum);

   // print the checksum, the default output format depends on the algorithm
   checksum.setSeparator(";");
   System.out.println(checksum);

   // print the checksum value only (see also option -F)
   System.out.println(checksum.format("#CHECKSUM"));

   // print the checksum value with a customized format (see also option -F)
   System.out.println(checksum.format("<a href=\"ed2k://|file|#FILENAME|#FILESIZE|#FINGERPRINT|\">#FILENAME</a>"));
 

The examples above are expected to help you to take the first barriers. For detailed information about all possibilities you have with Jacksum, please have a look in the open source code or generate the javadoc from it.
 

What is planned for the next releases?

I still have a lot of ideas and brilliant feature requests from other people on my desk for the Jacksum project. None of those will be forgotten, but it takes time to implement, test, optimize and document them. These are the major requests which will be addressed for next releases (unsorted):

- Identify extra data (files and/or directories) that have been added to the target location during a comparison operation,
  thanks to John D. for the feature request and thanks to Dipl.-Inf. (FH) Ralf Kahrl for the reference implementation!
- a new API which can be used by both the CLI and a GUI.
  Thanks to Stephan Classen, Sibylle Dürr, Barbara Keller, Audrey Lim and Judith Rüesch
  for working on it as part of their IT-project at the ETH Zürich, Switzerland
- A Swing GUI for Jacksum (maybe a separate project)
- HMAC support for the algorithms
- Read files from a list
- Distinguish between missing files versus files that are different also if option -l is used
- CRCs with 1-7 bit length
- Filter for processing particular files only
- Performance support for boxes having multiple CPUs and/or cores
- Filesystem specific file attributes
- New algorithms
 

Manual:

If you take information from this website to Wikipedia or any other place in the web, please be fair and put at least a reference which links back to this page.
 
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
 

History:
Jacksum 1.7.0, July 30, 2006
- added a customizable CRC algorithm, now you can calculate any CRC which
  can be described by the Rocksoft Model CRC Algorithm (8 to 64 bit width),
  see also sf# 1518023 Setting of an initial value for a CRC
- support for combinable checksums, see also sf# 1210489
  (multiple hashes at the same time), thanks to synonymous2 for this feature request
- support for using all algorithms at once (-a all)
- two new algorithms are supported: crc32_bzip2, HAS-160
- support for Tiger Tree hashes (aka Merkle Hashes). Thanks to Carsten Krüger,
  Germany for the feature request and pointers to some resources
- support for new encodings (bin, dec, oct)
- support for the combination of both options -c and -w,
  Thanks to Dipl.-Inf. (FH) Ralf Kahrl, Germany for the implementation of this feature
- a small performance improvement for the whirlpool algorithms
- replaced the crc24 with a faster one by using the customizable CRC algorithm
  (the old one had also a minor bug in the parameterless constructor)
- bug fixed: -V summary does not always return reasonable values
- bug fixed: update(byte[], int, int) fails if offset is > 0 (sf # 1525183)
  This can cause problems if Jacksum is incorporated in different projects
- The bouncycastle and gnu classes have been moved to jonelo.jacksum.adapt so that
  they won't clash with different downloaded versions of the classes. Actually this
  is to avoid potential problems if a project uses both bouncycastle and Jacksum for example.
  Thanks to Alberto Rodriguez, Spain for the feature request
- documentation updated (BeOS' data integrity programs, Tru64 and year of the invention for
  many algorithms)
- tested with gij 4.0.2, JRE 1.3.1_18, 1.4.2_12, 5.0_07, 6.0-rc-b93

Jacksum 1.6.1, Nov 13, 2005
- regression bug fixed: -r does not work anymore on Linux/Unix
  Thanks to Christoph R., Germany and niku.u for the bug reports (sf# 1354426)
- bug fixed: stdout and stderr overwrite each other when stdout and stderr are equal
- bug fixed: -c and -V summary give meaningless summary
- exit status depends on the result of -c now
  Thanks to Martin Z., Germany for the feature request
- improved documentation ("exit status" and "see also" have been added)

Jacksum 1.6.0, Sep 3, 2005
- twelve new algorithms are supported: CRC-8, CRC-24, GOST R 34.11-94, SHA-0, SHA-224,
  Tiger-128, Tiger-160, Tiger2, Whirlpool-0, Whirlpool-2, RIPEMD-256, RIPEMD-320
- change: "whirlpool" refers to Whirlpool-2 now, rather than to Whirlpool-1
- support for an alternate Adler 32 implementation
- improved option -c: Jacksum can check the integrity even if a file list has
  not been created by Jacksum (or a file list without meta information)
  Thanks to Sebastian J., Germany for this feature request
- new option -w for setting the working directory
- new algorithm-code called "none" for ignoring the real content of
  the files for being able to check just against the filesize
- new algorithm-code called "read" for being able to read the file's content,
  but without doing any calculation
- new option -E for an encoding of the checksum (hex, hexup, Base 16, Base 32,
  Base 64 and BubbleBabble are supported)
- new option -g (group some bytes) for better readability of a hex checksum
- new option -G (group separator) for better readability of a hex checksum
- new option -o for redirecting the output to a file rather than the standard output,
  in this case the file is also excluded from the calculation process
- new option -O for overwriting an existing file
- new option -I for ignoring lines when checking the integrity by -c
- new option -V for a verbose output (number of processed files and dirs, processed bytes,
  number of read errors and elapsed time)
- improved option -e: works also for multiple files and directories
  for being able to find duplicates
- improved option -e: when using -e, the option -x is not necessary anymore,
  if the return value by default is hex anyway
- improved option -m: unnecessary defaults are not be written to the header anymore
- improved option -h: can show only fractions of the help file rather than
  the complete help file
- improved option -t: #SEPARATOR and #QUOTE are also replaced
  Thanks to Claudio C., Italy for the feature request
- improved option -F: #FILENAME{NAME} and #FILENAME{PATH} can be used
  Thanks to Claudio C., Italy for the feature request
- bug fixed: if calling the getHexValue() method more than once, the hash based
  algorithms return a different value; this can cause problems if Jacksum
  is used in other projects, Thanks to Bob C. for the bug report
- bug fixed: problem on Unix/Linux while checking a file list if the filename's
  last character is a colon (e. g. "Terminal 1:")
- improved documentation, added also collision files
- improved the public API (support a method to return byte[])
  Thanks to Alex G., Germany for this feature request
- improved the public API for other projects (methods getAvailableAlgorithms(),
  and equals() have been added)
- Added javadoc, Thanks to Corey Osman for this feature request
- refactored and code improvements
- tested with gij 3.2.2, Kaffe 1.1.4, JRE 1.3.1_16, 1.4.2_09, 5.0_04, 6.0-ea-b48

Jacksum 1.5.1, 2004-10-31
- regression bug fixed: when using option -l, removed files will not be printed out to the standard output anymore
  Thanks to Sabrina Rolleman, Canada for the bugreport
- sourceforge feature request #1028824 has been implemented (add homepage URI with -m)
  Thanks to Lee A. Davis for the feature request
- improved documentation
- successfully tested with JRE 5.0

Jacksum 1.5.0, 2004-08-22
- four new algorithms are supported: ed2k/eDonkey/eMule, CRC-64, ELF-32, FCS-16
  Thanks to Henrique Malheiro, Portugal for the eDonkey reference implementation
- sourceforge bug #948070 has been fixed (-c won't work if -t has been set)
  Thanks to Lee A. Davis for the bugreport
- bug fixed: Jacksum hangs if it reaches a fifo under Unix/Linux
- bug fixed: files which are used by another process can't be processed properly
- new option -d for ignoring symbolic links to directories under Unix/Linux to avoid
  enless loops in particular cases
- improved option -q to support not only hex, but also text and decimal formats
- new option -F for being able to customize the output format
  see also sourceforge feature request #968469 (show file length on MD5)
- new option -P to print out filenames with a customized separator
- lists created with -m are platform independent now, you can verify files against
  a list on Linux/Unix if the list has been created on Windows for example
- new option -S to calculate just one fingerprint (summary)
  Thanks to Berthold Kohlmann, Germany for this feature request
- sourceforege feature request #968491 has been implemented
  (Handle pre 1.5 time formats with -c), thanks to Lee A. Davis for the request
- sourceforge feature request #968487 has been implemented (list dir argument as comment)
  Thanks to Lee A. Davis for the feature request
- new option -A to specify alternate implementations of one of the following algorithms
  crc32, md5, sha-1, sha-256, sha-384, sha-512
- added alias called FCS-32 for CRC-32
- added alias called SHA-160 for SHA-1
- Java version check also for IBM's Java VM
- tested successfully with JRE 1.5 beta3

Jacksum 1.4.0, 2004-02-01
- three new algorithms are supported: Tiger, Haval and the MPEG spec of CRC-32
  Thanks to Chris Ash, Southampton, UK for suggesting this feature based
  on existing GPL code (VideoLan project)
- Haval can have both length (128, 160, 192, 224 or 256 bits) and round parameters (3 to 5)
- algorithms sha-256, sha-384 and sha-512 are also supported with JRE 1.3.1 now
- new option -p for including path info on each line when recursively
  file processing is requested, this makes it easier to sort or grep ouput lines
  Thanks to Douglas E. W. for both feature request and reference implementation
- new option -e for comparison against an expected checksum
  Thanks to Daniel Ellermann, Germany for both feature request and reference implementation
- new option -l to show a list of modified or deleted files, list can be used to feed the zip command
- exits, if parameter -t does not contain supported characters
- version check for checkfiles introduced for better compatibility
- improved comments for sourcecode called Crc16.java
- documentation updated with Mac OS X information
- requires at least JRE 1.3.1, 1.4.2 is recommended

Jacksum 1.3.0, 2003-11-02
- eight new algorithms are supported: sha-256, sha-384 and sha-512  (requires Java 1.4.2 or later),
   xor8, sum8, sum16, sum24 and sum32
- option to check files against a given list (option -c)
  Thanks to Leonardo A. Pires, Brazil for this feature request
  Thanks a lot to Christian F., London, UK for his reference implementation
- option to create meta-information (option -m); while checking against a list, you don't have to enter
   the original command line options again
- timestamps of files can be part of the output (option -t)
  Thanks to Vishwanathan Narayanan, Florida, USA for this feature request
  with the option -c you can check against both content and timestamps
- the output format of timestamps is highly configurable
- process a hex sequence quickly (option -q)
  Thanks to Jack Memishian, USA for this feature request
- bug fixed: algorithm cksum hangs, if a file is greater than 2 GB
- bug fixed: processing special file system folders, like Windows'  "System Volume Information"
  throws to a NullPointerException
- stdout and stderr are separete streams now
- Jacksum is using the GNU crypto package 1.1 (http://www.gnu.org/software/gnu-crypto/)
- documentation updated

Jacksum 1.2.0, 2003-02-16
- four new  algorithms from the GNU crypto project are supported:
  MD4, RIPEMD-128, RIPEMD-160 and Whirlpool  (http://www.gnu.org/software/classpathx/crypto)
- bug fixed: calling the getValue() method more than once for the Cksum
  class returns a different value; this can cause problems if Jacksum will be used in other projects.
  Thanks to Cary Coulter for both, bug report and fix.
- bug fixed: CRC16 does not work like the standard CRC16 generator poly X^16 + X^15 + X^2 + 1.
  Thanks to David Elfi, Argentina for both bug report and fix
- provided compatibility with free Kaffe Java VM (Java version check only for Sun's Java VM)
- option -v to get the version of Jacksum

Jacksum 1.1.2, 2003-01-19
- bug fixed: input file will not be closed: this can cause problems if Jacksum will be used in other projects.
  Thanks to Bill Kelemen for both, bug report and fix.
- faster algorithm for output of checksums in hex format
- documentation updated (Solaris 9+ has a md5 application)

Jacksum 1.1.1, 2002-11-07
- bug fixed: algorithm sysv returns invalid checksum if files are greater
  than ~9 MB. Thanks to Sunny Liu, NYC for both bug report and fix.

Jacksum 1.1.0, 2002-09-08
- options for hexadecimal checksum output (lower- and uppercase)
  Thanks to Peter Frey, Germany for this feature request
- filenames/directories will be sorted alphabetically

Jacksum 1.0.0, 2002-07-07
- initial release
- requires at least JRE 1.3.0
- eight algorithms Adler32, BSD sum, POSIX cksum, CRC-16, CRC-32, MD2, MD5,
  SHA1 and Unix System V sum are supported
- processing of subdirectories is supported
- a custom separator string can be defined
 

Contact:


Keep updated - the announcement-mail-alias:
Are you interested in hearing the latest from Jacksum? If so, it is easy to stay informed. Just subscribe to the announcement alias. It's just only me who can post messages to the list. Expect a maximum of 12 email per year.

   To subscribe to the list, send a message to:  announce-subscribe@jacksum.dev.java.net
   To remove your address from the list, send a message to: announce-unsubscribe@jacksum.dev.java.net
   View the announcements list archive: https://jacksum.dev.java.net/servlets/SummarizeList?listName=announce

Discuss with other users - the user-mail-alias:
If you have something for the wish list or if you have troulbe with Jacksum, write to this mailing list. The mailing list is a good place to discuss new ideas, features and bugs.

   To subscribe to the list, send a message to:  users-subscribe@jacksum.dev.java.net
   To remove your address from the list, send a message to: users-unsubscribe@jacksum.dev.java.net
   To write to the list, send a message to:  users@jacksum.dev.java.net

Trackers (Bug database, Support and Feature requests):
http://sourceforge.net/projects/jacksum

Private eMail:
Just drop me an email. Please be patient if you don't receive an eMail on the same day, because I take some time for each request.
 

Links where Jacksum is listed


separator
Copyright © 2000-2007 Dipl.-Inf. (FH) Johann N. Löfflmann mail icon jonelo@jonelo.de,
last update of this page: 30-Dec-2006
counter easy hit  hits at this page since 07-Jul-2001