Features

Hash Functions

500+ Standard Hash Functions

Jacksum supports more than 500 standard algorithms including crypto and non-crypto hash functions, CRCs, and checksum. For details on all algorithms, go to Algorithms Wiki Page or the Algorithms Section of the Manpage

Customized Hash Functions

• Concatenate algorithms (e. g. ascon-hash+sha256+crc32c) to obtain a combined hash value (one value or separated values)
• The keyed-hash message authentication code (HMAC) is supported (e.g. hmac:sha256)
• Truncated output of the HMAC is supported (e. g. hmac:sha256:64)

Customized CRCs

• The "Rocksoft (tm) Model CRC Algorithm" schema (6 parameters width, poly, init, refIn, refOut, xorOut) is fully supported with a width from 1 to 64 bits
• Use an extended model (7 or 8 parameters incLen, xorLen) to specify CRCs that incorporate the length of the input data

Algorithm selection

• Select one, a few, many, or all algorithms for hash calculation, integrity verification or information gathering
• Specify algorithms manually, or filter them by name or a message digest width

Support for many platforms

Multiple Operating Systems

• Microsoft Windows (e.g. Microsoft Windows 10, and 11)
• GNU/Linux (e.g. Ubuntu)
• Unix (e.g. BSD-flavors, macOS, Solaris)
• any other operating system or architecture with an OpenJDK compatible Java Runtime Environment (JRE) or Java Development Kit (JDK)

Multiple CPU architectures

The Supported hardware architectures are dependent on the JDK/JRE. Usually the supported hardware are

• x86 64 bit (x64)
• x86 32 bit (x86)
• ARM 64 bit (AArch64, resp. M1)
• ARM 32 bit (AArch32)
• PPC 64 bit (ppc64)

No recompilation required

Since Jacksum is written entirely in Java, no recompilation is required. Just execute the .jar file using your Java Runtime Envorinment (JDK) or Java Development Kit (JDK).

Support for multi-core/multi-CPU computer systems

• Supports multi-threading on both multi-processor and multi-core computer systems

• Multiple algorithms

  • Can calculate multiple hashes simultaneously, i.e. files are read only once, and the calculation load is distributed on the available cores
  • The user can control the number of threads if multiple algorithms should run in parallel

Support for fast Solid-State-Disks (SSD)

• Supports multi-reading of files on fast SATA-SSDs, and NVME M.2-SSDs.

• Multiple files

  • Can read multiple files simultaneously, i.e. files can be read in parallel on SSDs
  • The user can control the number of threads if multiple files should be read in parallel

Use Cases

Integrity verification features

• Any algorithm Jacksum supports can be used for integrity verification purposes, including combined algorithms
• Use predefined compatibility/style files to read and write popular 3rd party format styles (GNU/Linux, BSD, SFV, FCIV, openssl, etc.)
• Perform integrity checks, and detect ok, failed, missing, and new files
• Option to include the file size for performing faster integrity checks
• Option to include modification timestamp of files for performing integrity checks also for meta data
• Options to ignore checks for hash values, file sizes and/or timestamps
• Create and use your own compatibility/style files

Find files by hashes

• Find all files that match a given hash value (find the duplicates of a file)
• Find all files that match the hash values in a precalculated hash set (e.g. find vulnerable or illegal software on a computer independent of their actual file names)
• Find all files that don't match the hash values in a precalculated hash set

Find the algorithm to a hash

• Find the algorithm that was used to calculate a checksum/CRC/hash

Input and Output

Input related features

• Recursively directory traversal

  • Processes directories recursively, and allows to limit the depth
  • Detects file system cycles and it avoids endless loops
  • Allows you to control how symbolic links on files and/or directories should be handled on all operating systems

• Input from almost any source

  • Calculates hashes from files, stdin, file lists, command line argument values on all operating systems: Windows, Linux, Unix (e.g. macOS, BSD)
  • Calculates hashes from disks, and partitions on all operating systems: Windows, Linux, Unix (e.g. macOS, BSD)
  • Calculates hashes from block devices, character devices, named pipes, sockets, and sparse files on all Unix-like operating systems
  • Calculates hashes from NTFS Alternate Data Streams (ADS) on Microsoft Windows
  • Calculates hashes from doors on Solaris

• Character sets, Unicode and BOM support

  • Full Unicode file name support for input files
  • Allows you to specify the character set for input files: GB18030, UTF-8, UTF-16, UTF-16BE, UTF-16LE, UTF-32, UTF-32BE, UTF-32LE, etc.
  • Ignores an optional Byte-Order-Mark (BOM) from the input if a BOM is allowed, but not required by the selected charset

• Correctness of file handling

  • Handles special characters in filenames correctly (e.g. if a filename on Linux ends with a space or if a filename contains backslashes or newline characters)
  • Handles allowed max. length of filenames properly (e.g. 255 max. characters for a filename on Microsoft Windows NTFS file systems)
  • Handles allowed max. length of paths properly (e.g. 32,767 max. characters for the entire path on Microsoft Windows NTFS file systems)
  • It is large file aware, it can process file sizes up to 8 Exbibytes (= 8,000,000,000 Gibibytes), presupposed your operating system respectively your file system is large file aware, too.

Output related features

• Predefined standard formats

  • Output can occur in predefined standard formats (BSD-, GNU/Linux-, openssl-, and Solaris style, SFV, and FCIV)
  • supports GNU file name escaping

• User defined formats

  • Use comprehensive format options to get the output you need
  • Create your own format and define a compatibility file to be able to read your own format again
  • Create ed2k-links, magnet-links, Solaris' pkgmap format
  • To represent hash values, one of 16 encodings can be selected:
    • binary
    • decimal
    • octal
    • hex (lower- and uppercase), bytes can also be grouped and separated for easier readability
    • Base16
    • Base32 (with and without padding)
    • Base32hex (with and without padding)
    • Base64 (with and without padding)
    • Base64url (with and without padding)
    • BubbleBabble
    • z-base-32
    • z85
  • Many different charsets are supported in order to write localized filenames properly (see also options --charset-stdout, --charset-stderr, and --charset-output-file, --charset-error-file).
  • Paths can be customized. See also options -P, --no-path, --path-relative-to, and --path-absolute.
  • Timestamps can be customized. Predefined formats for timestamps such as ISO8601 or Unixtime are available.

• Character sets, Unicode, and BOM support

  • Full Unicode file name support for output files
  • Allows you to specify the character set for output files: GB18030, UTF-8, UTF-16, UTF-16BE, UTF-16LE, UTF-32, UTF-32BE, UTF-32LE, etc.
  • Adds an optional Byte-Order-Mark (BOM) to the output if a BOM is allowed, but not required by the selected charset

Support for 3rd party Software

I/O

• Use predefined compatibility files to read and write popular 3rd party format styles in order to interact with other tools (GNU/Linux, BSD, SFV, FCIV, openssl, etc.)

CLI (interaction with other tools)

• Jacksum can be used in cronjobs and/or autostart environments
• Works with the SendTo-feature on many file browsers on all major operating systems (e.g. macOS Finder, Microsoft Windows Explorer, Gnome Nautilus, KDE Konqueror, ROX Filer, etc.)
• Jacksum returns an exit status which is dependent on the result of the calculation/verification process, so you can use Jacksum in scripts and batches and control the code flow in your own scripts

API

• Jacksum supports a Java API and you can use it for your own programs
• the GUI of Jacksum called HashGarten uses the API

Learner support

• Investigate ploynomials of CRCs
• Investigate the avalance effect on all algorithms
• Specify your preferred level of verbosity
• Obtain details for each algorithm, including comprehensive compatibility lists
• 10000+ lines of manpage

Developer support

• Entire source code has been opened, is hosted on GitHub, and accessible using git
• The project has been mavenized with a pom.xml which makes it easy to work in your preferred IDE
• Jacksum provides an API, so you can incorporate Jacksum in your own projects
• Javadoc is available
• Jacksum keeps compatibility with JDK 11, but it takes all the advantages of JDK 11+ if available

Quality, Mature and Stable

• The author was working for Sun Microsystems and Oracle to support Java and he is SCJP, SCJD, and OCP certified
• Testcases to test new releases and find regressions with the CLI are available