Release Notes

Jacksum Next Release TBD

Updated documentation
- added docs/USE_CASES.md and its German translation docs/USE_CASES_de.md, a task oriented
  cookbook: while docs/EXAMPLES.md is organized by feature ("what does this option do"),
  USE_CASES.md is organized by goal ("I want to solve this problem")

Jacksum 4.0.0, August 22, 2026

Compatibility changes
- requires a JRE/JDK that is compatible with Java 21 LTS and later, OpenJDK 25 LTS or later is recommended
- the formation of an HMAC with algorithms of the ascon family is no longer possible, because there is no
  standard-compliant parameterization according to HMAC for sponge-based hash functions
  (RFC 2104 / FIPS 198-1); in general, an HMAC cannot be formed if the block size of the underlying hash
  function is smaller than its digest size
- a truncated HMAC (hmac::) returns different values now if is not a multiple of 8,
  because the surplus bits are zeroed as documented, see also the bug fixes below; "hmac:sha256:155"
  for example no longer returns the same value as "hmac:sha256:160"
- prng returns different values for files now, because the values that have been returned so far were
  wrong, see also the bug fixes below; the initial value of the algorithm was dropped while a file was
  being prepared, so "jacksum -a prng " calculated with an initial value of 0 rather than with
  the documented 0x811c9dc5 and therefore did not even agree with "jacksum -a prng -q " on
  the same data; files of any size are affected, as are all customized definitions (prng:init=...)
  whose initial value is not 0; aststrsum (aka ast, strsum) is not affected, because its initial
  value is 0 anyway
- fletcher16 returns different values for input larger than 64 KiB now, because the values that have
  been returned so far were wrong, see also the bug fixes below; input up to 64 KiB is read in one
  single block and was therefore never affected
- sum64 returns different values now, because the values that have been returned so far were wrong,
  see also the bug fixes below; only input whose sum of all byte values reaches 2^32 is affected,
  which is impossible for files smaller than 16,843,010 bytes (approx. 16 MiB, a file filled with
  0xFF bytes only), and in practice the difference starts at approx. 32 MiB for uniformly
  distributed binary data and even later for text files
- the style openssl-dgst now follows the names of OpenSSL 3.x and later; the style openssl111-dgst has been
  added in order to get the traditional OpenSSL 1.1.1 behavior
API changes
- added the API methods JacksumAPI.getBrokenState() and JacksumAPI.getBrokenDescription() so that
  programs that use Jacksum as a library can determine whether an algorithm is broken; if many
  algorithms are queried, JacksumAPI.preloadBrokenStates() builds a cache for all subsequent queries
- the method Parameters.checked() has got an overload called
  Parameters.checked(boolean setupStreams) which allows a caller to validate the parameters without setting
  up the output and error streams (requested by HashGarten, issue #12); the parameterless method
  keeps its behavior
New algorithms
- 97 new algorithms (including their different lengths) have been added;
  Jacksum now supports 586 algorithms!
- added belt-hash, the hash function of the Belarusian national standard STB 34.101.31
- added Romulus-H v1.3 (romulush); it is one of the finalists of the Lightweight Cryptography
  Competition held by NIST
- added Fugue 2.0 (fugue2-[224,256,384,512]), the tweak of Fugue that IBM published in April 2012
  after the NIST SHA-3 competition had ended. The new Fugue 2.0 code also provides an alternate
  implementation (option -A) of the original Fugue, i.e. of fugue[224,256,384,512]
- added 5 algorithm families (resp. 21 algorithms) from round 2 of the NIST SHA-3 competition:
  - BlueMidnightWish-[224,256,384,512]
  - SIMD-[224,256,384,512]
  - CubeHash-[224,256,384,512]
  - Hamsi-[224,256,384,512]
  - Shabal-[192,224,256,384,512]
- added 2 algorithms from round 1 of the NIS SHA-3 competition:
  - MD6 (md6-8 to md6-512, in steps of 8)
  - Edon-R (edonr-[224,256,384,512])
- added 2 CRCs
  - CRC-64 (NVM Express 64b CRC), called crc64_nvme
  - CRC-32 (Go Koopman), called crc32_go-koopman (issue #35)
New options
- --exact, it makes the help search (-h ) match exactly rather than by prefix, so that
  options such as "-" and "--" can be looked up at all, e.g. jacksum --exact -h - prints the
  description of the option "-" only, while jacksum -h - prints all options;
  if an exact search is unsuccessful, the exit code is 1
- --ignore-hashes, it ignores the hash values that are stored in a check file during a check (-c)
- --ignore-sizes, it ignores the file sizes that are stored in a check file during a check (-c)
- --ignore-timestamps, it ignores the timestamps that are stored in a check file during a check (-c)
- --no-header, it suppresses the header that is activated by the styles which print one
Improvements on existing features
- new styles
  - full
  - without-hashes
  - without-timestamps
  - without-sizes
  - sizes-and-names
  - timestamps-and-names
  - hash data base (hdb) style, which is used by ClamAV's sigtool
  - openssl111-dgst (aliases openssl111 and openssl111-tagged), which prints the format of
    "openssl dgst" with the algorithm names of OpenSSL 1.1.1 and earlier, while the style
    openssl-dgst follows the names of OpenSSL 3.x and later (SHA256 vs. SHA2-256 for example).
    Both styles read the output of any OpenSSL version. There is no style for the untagged
    format (openssl dgst -r) of OpenSSL 1.1.1, because that format does not contain an
    algorithm name at all.
- new timestamp formats
  - default-utc
  - iso8601utc, with the alias iso-utc
  - added the alias iso for the existing format iso8601
- extended the strict check mode (option --check-strict)
  - in strict check mode, all files must pass the verification process, and no files must have been
    added or removed
  - added strict check output to the verification summary
  - the exit code follows --check-strict
- added more algorithm investigation info
  - added a new section called "Security:" to the output of --info, it contains the entry "broken:" which
    tells whether the selected algorithm is considered broken; the value is one of "yes", "no", "partly",
    "depends", or "n/a"; the information is read from Jacksum's documentation which remains the single
    source of truth for it
  - added the keywords "details" and "nodetails" to the option -V/--verbose; "details" makes --info print
    the explanation of the value of "broken:" in addition to the value itself, and it is part of "all"
  - added avalanche effect info to the algorithm info
  - allowed option -q to specify the sequence for the avalanche calculation
  - also added reversed and Koopman representations for the reciprocal polynomial representation if --info
    is set for a CRC
- added troubleshooting features
  - added Java Heap Info if the option --info has been set
- new sequence types for the options -q and -k
  - z-base-32, e.g. "jacksum -q z-base-32:cfz8g75fqeog1h3ygo3y"; so far z-base-32 was supported
    for the output (-E z-base-32) only
  - bubblebabble, e.g. "jacksum -q bubblebabble:xesef-disof-gytuf-katof-movif-baxux"; so far
    BubbleBabble was supported for the output (-E bb) only; the decoder verifies the redundancy
    that is part of the BubbleBabble encoding, so invalid strings are rejected rather than
    being decoded to arbitrary bytes; as a consequence the option -e can compare a BubbleBabble
    encoded hash value byte-wise now
- improved the diagnostics
  - a file whose name starts with the comment string (by default "#", ";" for the style sfv) produces
    a line that is treated as a comment while the list is being read back, so such a file is silently
    skipped during a check, and the check passes although the file has never been verified. Jacksum now
    warns while it writes such a line, and it points to the option -I, which can change that string. The
    styles files-only and sfv are affected, because they put the file name at the beginning of a line.
  - options that a style overrules are reported consistently now: an encoding that has been set by -E
    is ignored by every style (the styles define the encoding of the hash value), which was the only
    case that has been silently ignored so far, while -a, -t, -F, --filesize, and
    --gnu-filename-escaping have always been reported
  - the combination of "-a none" and a style that stores hash values (e.g. bsd) writes lines with an
    empty hash value; that is now reported. In check mode the combination stays silent, because it is
    a valid way to check the properties that are left, e.g. the existence of the files.
  - if a style stores the algorithm name in the file (bsd, solaris-digest-v, openssl-dgst,
    openssl111-dgst) and that name belongs to an algorithm other than the selected one, all files were
    reported as FAILED, as if they had been altered. Jacksum now names the cause, e.g. 'The file has
    been created with the algorithm "SHA256", but the algorithm "sha3-256" has been selected.'
    A name that Jacksum cannot resolve is not reported, because tools spell the very same algorithm
    differently, e.g. SHA256 (OpenSSL 1.1.1), SHA2-256 (OpenSSL 3.x), and sha256 (Solaris).
- improved the usability
  - hash values that are read by the options -c, -e, and -w are compared without respecting upper and
    lower case now, unless the encoding that has been selected by -E has a case-sensitive alphabet
    (base64, base64-nopadding, base64url, base64url-nopadding, and z85); so far only the options -q,
    -e (in quick mode), and --string-list have been tolerant, see also the bug fixes below
  - allowed option -e for --string-list
  - if an option has been used with an invalid or a missing parameter, the help that is printed
    before the error message now covers exactly that option rather than all options that share
    the same prefix
  - the message that is printed if a help search was unsuccessful is now localized, it follows
    the language that has been selected by -h [language], e.g. jacksum -h de xyz
- improved the customization
  - compatibility (style) files understand a new optional property called formatter.leadingHeader in
    order to prepend a custom text to the header that is printed by --header
Bug fixes
- concurrency (options --threads-hashing and --threads-reading)
  - issue #30: a java.lang.OutOfMemoryError (e.g. in "Thread-0" or "pool-1-thread-4") can occur if the
    producer is much faster than the consumer threads
  - issue #49: An unexpected exception in the output consumer aborts the run silently with exit code 0
  - a read error on a file (e.g. a locked file such as NTUSER.DAT on Microsoft Windows) that was hashed
    with multiple algorithms (--threads-hashing) could be reported as a success with a partially computed,
    i.e. wrong, hash value. Such errors are now reliably detected and reported.
  - an unexpected exception while hashing (--threads-hashing) could be silently swallowed and a partially
    computed hash returned as if it were correct, or it could deadlock the process on large files. Errors
    are now propagated and no longer silently ignored.
  - during a parallel directory walk (--threads-reading) an unexpected exception on a single file could
    make that file silently disappear from the output while the run still reported success. Such files are
    now reported as an error.
  - a crash in the file producer, or an interruption of the hashing engine, could leave the parallel
    directory walk (--threads-reading) hanging forever instead of terminating. Termination is now
    guaranteed.
  - the parallel directory walk (--threads-reading) busy-waited for its worker pool to finish, needlessly
    keeping one CPU core at 100%. It now waits without spinning.
  - a short read that is not the end of the file is no longer misinterpreted as the last block, which could
    truncate a hash or block the reader.
- verification, parsing, and output
  - issue #32: --header not working using --quick
  - issue #36: if multiple algorithms have been selected and file size is not wanted, Jacksum does not
    find valid entries
  - issue #37: parser does not find valid entries if algorithm "none" (no hashing) has been selected
  - issue #38: if hash values are not wanted by the user, there should be no leading separator character
    left in the output
  - issue #40: output style for BSD is not 100% compatible for the cases sha512/224, sha512/256, and
    skein-512-512
  - issue #48: -c: entries for standard input () are never verified - reported as NEW, exit code 0
  - issue #50: -c: a check file that lists the same file under two path spellings can mask a mismatch
  - issue #51: -c combined with --check-line: the statistics of the check file are overwritten and the
    entry bypasses the duplicate detection
  - issue #52: --check-strict combined with --list-filter other than all exits with 2 silently, after
    the whole verification has been done
  - issue #53: -c: every error on an entry of the check file is reported as MISSING, even if the file
    exists; such a file gets the new status ERROR now, see also --list-filter error
  - issue #54: -c: the status output does not escape file names, so a file name with a newline breaks
    the output
  - issue #55: The default parser accepts almost any line, so --check-strict never detects an improperly
    formatted line
  - issue #56: -c reports FAILED for sum_bsd, sum_sysv, and sum_minix, because their block count is
    compared against the file size
  - issue #57: -c on a coreutils check file without --style gnu-linux reports every entry as MISSING
    without any hint
  - option --list-filter default is documented, but it is rejected as an invalid parameter
  - the options --wanted-list and -e are silently ignored if -c resp. --check-line is specified as well,
    because both jobs cannot be performed by one run; the combination is rejected with a parameter
    error now
  - records with the same comments in wanted list files are no longer ignored. While ignoring duplicate
    file names in check files makes sense for the option --check-file, that setting is suboptimal if the
    option --wanted-list is used, because file names are treated as comments in wanted lists.
  - hash values were compared case sensitively by the options -c, -w, and by -e in combination with
    files, although the documentation of -e promises a tolerant comparison for all encodings but Base64,
    and although the options -q and --string-list have always been tolerant. As a consequence a check
    file in SFV format that stores its CRCs in lower case was reported as FAILED although all hash values
    matched (the SFV parser accepts both cases on purpose), and a wanted list (-w) that stores its hash
    values in upper case, as many hash lists do, did not match a single file.
  - the options -g and -G (grouped hash values) could be combined with -c and -w, but grouped hash values
    cannot be parsed: the first group was taken as the whole hash value and the remaining groups became
    part of the file name, so all files were reported as MISSING rather than OK or FAILED. Both
    combinations are rejected with a parameter error now.
  - the default output format appended the separator (by default a blank) even if there was no
    file name at all, so a line ended with a trailing blank if a sequence was hashed by the
    option -q, e.g. "jacksum -q txt:abc -a sha1"; the same happened for an empty line while the
    option --string-list was being used; if the file name is empty, neither the file name nor the
    separator in front of it is written now
- styles (options -C/--compat/--style)
  - the styles bsd, openssl-dgst, and solaris-digest-v printed algorithm names that no tool of
    the respective platform uses, because the canonical names of the SHA-1/SHA-2 family in Jacksum
    contain a hyphen: "SHA-256 (file) = ..." instead of "SHA256 (file) = ..." for example, so the
    output of Jacksum was rejected by the tools that it claims to be compatible with, e.g.
    "shasum -a 256 --check" answered "no properly formatted SHA checksum lines found". The output of
    the style bsd is now identical to the output of md5, shasum --tag, and sha256sum --tag, and
    the output of the style solaris-digest-v follows the algorithm names of "digest -v" on Solaris.
    Reading files that have been created by those tools was not affected.
  - the style openssl-dgst now follows the algorithm names of OpenSSL 3.x and later, so its output is
    identical to the output of "openssl dgst" again, both for hash functions and for HMACs.
    OpenSSL 3.0 has renamed many digests, e.g. SHA256 became SHA2-256, BLAKE2b512 became
    BLAKE2B-512, and RIPEMD160 became RIPEMD-160; OpenSSL 4.0 kept those names. Two mappings for
    HMACs (hmac:sha512-224 and hmac:sha512-256) were never in effect, because they did not use
    the canonical algorithm names of Jacksum.
  - a compatibility file (option -C) with a group position that is not covered by its regular
    expression (e.g. parser.regexp.filenamePos=9 while the regular expression has two groups only)
    terminated Jacksum with an uncaught java.lang.IndexOutOfBoundsException and a stack trace
    while a file was being parsed; such a file is now rejected with an error message that names the
    property. A position that is not an integer is reported with a proper error message as well.
- escape sequences
  - issue #46: fixed four bugs in the interpretation of escape sequences, they affected the
    options -q txtf:, -k txtf:, -s, -c, and --file-list; the interpretation happens in one single
    pass now, and it is no longer implemented multiple times
- encodings (option -E) and encoded output (option -F)
  - the option -F could not be used at all with the algorithms sum_bsd and crc16_minix, because their
    default encoding is an internal one that is not user selectable, and the formatter tried to resolve
    it by its name; "jacksum -a sum_bsd -F "#HASH" " for example exited with
    "Encoding "dec_fixed_size_with_leading_zeros" is unknown."
  - the token #SEQUENCE is encoded with the default encoding of the algorithm if -E has not been set;
    for sum_bsd and crc16_minix that encoding is a fixed-size decimal encoding of two bytes, which
    cannot represent a sequence of an arbitrary length; the decimal encoding is used for such data now
  - a #SEQUENCE token in a format string could exit Jacksum with a NullPointerException if there was no
    sequence at all (option -q not set) and an encoding other than hex was selected, e.g.
    "jacksum -a sha256 -E base32 -F "#SEQUENCE" "
  - the option -E was locale dependent: in a Turkish locale "-E BIN" was rejected with
    "Encoding "BIN" is unknown.", because the encoding name was lowercased with the default locale
    rather than with a fixed one; the same applied to the type of the option -q, e.g. "-q BIN:1010"
  - Encoding.toString() returned names that the option -E does not accept, e.g. "hex_uppercase" or
    "zbase32"; every encoding has got a canonical code now (public API: Encoding.getCode()), which is
    also what Encoding.toString() and Encoding.encoding2String() return; the latter no longer depends
    on the iteration order of a hash map, so an encoding with more than one name (e.g. hex and
    hex-lowercase) always maps back to its canonical code
  - a z-base-32 encoded string with invalid characters was decoded to arbitrary bytes rather than being
    rejected, because the sentinel of the decoding table was compared as a signed value
    (net.loefflmann.sugar.encodings.ZBase32, public API)
  - a Z85 encoded string could contain a group of five characters that does not encode four bytes
    (its value exceeds 2^32-1, e.g. "#####"); such a group was decoded to wrong bytes rather than being
    rejected, e.g. "jacksum -a none -q z85:'#####' -F "#SEQUENCE{hex}""
  - decoding an empty Z85 string reported a character that is not part of the alphabet of Z85, although
    there was no character at all; an empty string decodes to an empty byte array now
  - the encodings bin, dec, and oct returned "0" rather than an empty string for an empty byte array,
    unlike all other encodings (public API)
- base32 and base32hex decoding (options -q and -k)
  - issue #47: an unpadded base32 or base32hex encoded string was only accepted if its length
    happened to be a multiple of 5, because the decoder decided between padded and unpadded input
    by testing the length against 5 instead of the Base32 group size of 8; as a consequence
    Jacksum could not read back its own base32-nopadding output, e.g. "-q base32:YDPMV7Q" was
    rejected while "-q base32:YDPMV7Q=" worked
  - an invalid base32 or base32hex string could terminate Jacksum with an uncaught
    java.lang.ArrayIndexOutOfBoundsException instead of an error message, e.g.
    "-q base32:========"; such strings are reported as invalid now
- timestamps
  - the token #TIMESTAMP was not replaced at all if the data did not come from a file: the literal
    string "#TIMESTAMP" occurred in the output for standard input, e.g. with the styles full,
    without-hashes, without-sizes, and timestamps-and-names, and the resulting line could even start
    with the comment character, which means that such a line was silently ignored while it was being
    read back. For a sequence (-q) the token was replaced by the epoch (1970-01-01). The token is now
    replaced by an empty string if no timestamp is available.
  - the default output format printed the epoch (1970-01-01) as the timestamp if -t was set and the
    data did not come from a file, e.g. "jacksum -a sha1 -t default -q txt:abc" or
    "jacksum -a sha1 -t default --string-list "; no timestamp (and no separator for it) is
    written now if no timestamp is available, which is the behavior of the token #TIMESTAMP as well
  - the warning "A sequence (-q) has been specified, timestamp (-t) will be ignored." did not tell
    the truth, because the timestamp format was kept and the epoch was printed; the timestamp format
    is actually being discarded now, as it has always been the case for standard input
  - both warnings about an ignored option -t (the one for a sequence and the one for standard input)
    were also printed if -t had not been set at all, but the timestamp format came from a style
    (-C/--style), e.g. "jacksum -q txt:abc -a sha1 --style full"; Jacksum keeps track of whether the
    timestamp format has been set by the user now, so such a warning is only printed if the user
    has actually specified -t
  - a timestamp format (-t) that contains a space produced lines that could not be parsed, because the
    timestamp cannot be told apart from the fields that follow it; all files were reported as MISSING.
    Such a format is now rejected with a parameter error if it is combined with -c resp. -w. None of
    the predefined formats is affected.
- algorithms
  - sum64 was truncated to 32 bits and behaved like sum32, because getValue() reduced the accumulator
    modulo 2^32 twice ((value mod 2^32) mod 2^32) instead of keeping the full 64-bit value; the upper
    32 bits of the result were always zero. sum64 now returns the correct 64-bit sum (the Java long
    already wraps modulo 2^64); see also the compatibility changes above for the input sizes
    that are affected by the changed values.
  - keccak-384 was not recognized as an alias
  - a few CRC algorithms (e.g. fcs16, fcs32, crc32c, crc32_mpeg2, crc64) do not print the Jacksum CRC
    definition code if --info has been requested
  - issue #45: the expected eDonkey test vector hash in the code comments was wrong
  - fletcher16 restarted its two running sums on every call of update() instead of continuing them, so
    any input that does not arrive in one single block was calculated wrongly. Files are read in blocks
    of 64 KiB, so every file larger than that got a wrong value, and so did all input from standard
    input. A sequence (-q) and files up to 64 KiB were not affected. See also the compatibility
    changes above.
  - the algorithms below did not restore their full initial state in reset(). Jacksum resets an
    algorithm before it reads a file, so the effects were visible on the command line as well, and
    programs that use Jacksum as a library and reuse an instance were affected in any case.
    - prng did not restore the initial value of the algorithm, it set the value to 0 instead. All
      customized definitions (prng:init=...) whose initial value is not 0 are affected as well.
      See also the compatibility changes above.
    - cksum_minix did not reset the counter that substitutes an intermediate value of zero, so a
      second calculation with the same instance could return a wrong hash value
    - sum_bsd, sum_minix, and xxhash32 did not reset the number of bytes that have been processed,
      so the file size that is part of their output (#FILESIZE) kept growing from one calculation
      to the next
  - the algorithms below did not handle an update() that does not start at offset 0, or that only
    partially fills their internal block buffer. Jacksum reads files in blocks of 64 KiB, which is a
    multiple of every block size in question, so hashing a file was never affected; input from
    standard input, where a read may return fewer bytes than requested, and programs that use Jacksum
    as a library were affected.
    - tree:tiger and tree:tiger2 (TigerTree) did not hash the bytes that complete a partially filled
      1024 byte block: those bytes were copied into the buffer, but the buffer was then hashed up to
      its old fill mark only, so the hash value was silently wrong. An update() that supplied fewer
      bytes than the block still needed read beyond the end of the input array and terminated with a
      java.lang.ArrayIndexOutOfBoundsException.
    - blake2bp determined the free space of its input buffer against 1024 bytes, although the buffer
      is 512 bytes long (PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES), so an update() that completed a
      partially filled buffer terminated with a java.lang.ArrayIndexOutOfBoundsException. blake2sp
      was not affected, because for its parameters both terms happen to be equal.
    - the LSH family (lsh-256-[224,256] and lsh-512-[224,256,384,512]) determined the free space of
      its block buffer from the length of the incoming data rather than from the fill mark of the
      buffer, so the value went negative as soon as more than one block arrived at once and the
      buffer was already partially filled; such an update() terminated with a
      java.lang.ArrayIndexOutOfBoundsException
    - blake3 passed the length of the data where java.util.Arrays.copyOfRange() expects an end index,
      so an update() with an offset other than 0 hashed the wrong bytes or terminated with a
      java.lang.IllegalArgumentException
    - crc82_darc ignored the offset that was passed to update() and always started at the beginning
      of the array
  - the option -A (alternative implementation) aborted with the parameter error "There is no
    alternate implementation available." and exit code 2 for the FNV algorithms with a width of
    128, 256, 512, and 1024 bits (fnv-0_, fnv-1_, and fnv-1a_*, 12 algorithms), because their
    selectors signalled a missing alternative by throwing an exception rather than by returning
    null. For every other algorithm without an alternative implementation -A is ignored, as it is
    documented, and the standard implementation is used; that is what happens for those 12
    algorithms now as well.
- HMAC
  - improved the HMAC constraint: if blocksize < digestsize an HMAC cannot be calculated; that is the
    case for all ascon algorithms, for example
  - a truncated HMAC (hmac::) did not zero the surplus bits if is not a multiple of 8,
    although the documentation says so, because the number of surplus bits was never calculated and the
    masking code was therefore unreachable; "hmac:sha256:155" for example returned the same value as
    "hmac:sha256:160", see also the compatibility changes above
  - an HMAC without a key is rejected now: "-a hmac:" without the option -k exits with an error message
    that asks for the option -k, rather than with an unspecific error
  - the prompt is "Password: " twice if both options -k password and -q password have been specified
    (e.g. "jacksum -q password -a hmac:sha256 -k password"), the prompt for the key is now
    "Key (echo off): " to distinguish the input
  - HMAC does not implement the reset() method correctly, which means that the same hash of the first
    calculation is always returned
Improved performance
- the output of --header is buffered and printed at once rather than line by line
- significant performance improvement for all FNV-0/FNV-1/FNV-1a with a width of 128, 256, 512, and 1024
  bits by replacing the BigInteger arithmetic with fixed-width arithmetic on a long array
  (approx. 5x faster for 1024 bits)
- performance improvement for aststrsum (aka ast, strsum) by hoisting the hash state and parameters into
  local variables and switching the inner update loop to 32-bit int arithmetic, which removes the per-byte
  64-bit mask from the critical path (approx. 20% faster); the computed hash values are unchanged
Updated documentation
- issue #16: provided a German help file
- added German translations of the documentation under docs/: algorithms.html,
  examples.html, features.html, and JACKSUM_HACKS.md. They keep the structure and the anchors of
  their English counterparts (ALGORITHMS.md, EXAMPLES.md, FEATURES.md, JACKSUM_HACKS), so
  both language versions can be maintained in parallel; all commands and program output in
  the examples are unchanged.
- reworked README.md: corrected all outdated facts, moved the detailed examples,
  the algorithm list, the feature list, and Jacksum Hacks to docs/.
- added docs/ALGORITHM_SELECTION_GUIDE.md and its German translation
  docs/algorithm_selection_guide.html, a guide that answers which algorithm to pick for a given
  purpose, e.g. in order to hash thousands of files for a later trustworthy integrity verification.
  It explains the concepts (hash function, hash value, CRC, avalanche effect, collision and preimage
  resistance, Merkle-Damgard vs. sponge, length extension), how to decide between a CRC, a classic
  checksum and a cryptographic hash function, when an algorithm counts as broken and why even a
  broken one can still be used as an HMAC, how much public cryptanalysis a design has received,
  when concatenating algorithms (-a +) is worthwhile, which algorithms should no
  longer be used at all, and why the choice can be limited by the tools of the operating system on
  which the check list has to be verified later. Every statement is backed by Jacksum itself, so
  the guide doubles as a tour of "-a --info --verbose details", "-h ", "-a all -l",
  and "--hmacs".
- issue #41: the option -p is no longer supported, but the documentation still referenced it
- corrected two alphabets in the description of the option -E in the manpage:
  - the table of the BubbleBabble alphabet was a leftover of the Base64 table; it now documents the six
    vowels, the 16 consonants, the delimiter x, and the separator that BubbleBabble actually uses
  - the last row of the z-base-32 alphabet said "30 - 31: 6 7" (a copy of the row of Base32), while
    z-base-32 uses "6 9" for the values 30 and 31
- documented for the options -c, -e, -g, -G, and -w that hash values are compared without respecting
  upper and lower case unless the alphabet of the encoding is case sensitive, and that grouped hash
  values (-g, -G) cannot be verified
- documented for the option -I and for the styles files-only and sfv that a file whose name starts
  with the comment string cannot be verified later, because its line is treated as a comment while
  the list is being read back
- documented for the option -t that a timestamp is only available if the data comes from a file, and
  that a format containing a space cannot be combined with -c resp. -w; corrected the examples of the
  styles openssl-dgst and solaris-digest-v, which showed algorithm names that Jacksum no longer
  prints, and documented that the style openssl-dgst follows the algorithm names of OpenSSL 3.x and
  later
- added info about the usage of the internal state value for verification of test vectors submitted for
  the NIST competition in the manpage for skein-256.
- corrected the list of algorithms that have an alternative implementation in the description of the
  option -A: it named 13 algorithms, while Jacksum actually provides an alternative implementation
  for 28 of them; crc16, crc32_fddi, crc32c, fnv-0_32, fnv-0_64, fnv-1_32, fnv-1_64, fnv-1a_32,
  fnv-1a_64, fugue224, fugue256, fugue384, fugue512, sha-512/224, and sha-512/256 were missing.
  It is documented now as well that -A is ignored for an algorithm that has no alternative
  implementation.
- added the "Go API" and Homebrew to the compatibility lists
- reworked the "broken" field of all cryptographic algorithms in the manpage. Instead
  of a bare "yes" or "no" each entry now states which security property is affected (collision, preimage,
  second-preimage resistance, or the use in a MAC), whether an attack is theoretical or practical, the
  year, and a reference. Sponge constructions and truncated variants now also document whether they are
  susceptible to length-extension attacks.
- reviewed the "published" field and the "comment" text of all algorithms in the ALGORITHMS
  section of the manpage against primary sources and fixed mistakes.

Jacksum 3.7.0, Aug 26, 2023

new features:
- added HMAC support
  - extended option -a to understand HMAC definitions, including optional truncations
  - added option -k, and alias --key to specify the secret for HMACs
  - added option --hmacs to print all hash functions that work with HMAC
  - allowed option --info for gathering HMAC info to print HMAC parameters such as
    - the underlying cryptographic hash
    - a specified truncation in both bits and bytes
    - how many bits a truncated length should have at least
    - whether a specified truncated length follows the RFC recommendation
    - how many bytes a specified key should have at least
    - whether the specified key follows the RFC recommendation wrt key length
    - whether the specified key will be hashed
- added string hashing support
  - added option --string-list to calculate hash values from strings stored in text files
  - added options --string-list-charset, and alias --charset-string-list
  - added option --ignore-empty-lines
  - added formatter alias #MESSAGE for #FILENAME
- added console input mode
  - added password mode, and readline mode for option -q (and -k)
  - added option --charset-console, and alias --console-charset
- added encodings
  - added encoding Z85 for option -E (without a limit on the length of the input)
  - added support for oct, Base32, Base32hex, Base64, Base64url, and Z85 to option -q
- added option --output-file-replace-tokens
bug fixes:
- NPE if filename is null and -F is set (e.g. 'jacksum -a none -F "#SEQUENCE" -q txt:')
- NPE can occur if both -a none and -E without -F have been set
- #FILENAME is not replaced in if both "-F " and "-q file:" have been used
- aliases blake2sp-256 and blake2bp-512 are not accessible
- regression: "jacksum -a all:blake -l" returns "blake2sp-256 is an unknown algorithm" due to missing alias
- crc32_mpeg2 didn't reveal the poly representations by specifying --info
improved performance:
- performance for algorithm info output (-a [--list] --info)
updated documentation:
- added description and encoding tables for the most common encodings (see "jacksum -h -E")

Jacksum 3.6.0, April 16, 2023

new algorithms:
- added all finalists that support hashing of the NIST Lightweight Cryptography competition (2019–2023)
  from a bouncy castle pre-release:
  - ascon-hash, ascon-hasha, ascon-xof, and ascon-xofa
  - esch256, and esch384
  - photon-beetle
  - xoodyak - with a contribution fix by jonelo (https://github.com/bcgit/bc-java/pull/1362)
- added blake2sp, and blake2bp (issue #4) - the Java implementation (fixed width single threaded) is done by
  pre-release bouncy castle code with a contribution fix for blake2sp by jonelo
  (https://github.com/bcgit/bc-java/issues/1363 and 1364)
- added 32 bit PRNG based checksums which are known from Solaris 11 Express, OmniOS, SmartOS, and Tribblix:
  - PRNG hash
  - AST strsum PRNG hash
- alternate implementation for blake3 provided by bouncy castle, the existing primary implementation still remains the
  primary, because it is slightly faster.
updates:
- significant performance improvement for all FNV-0/FNV-1/FNV-1a with a width of 64 bits
- minor performance improvements for all FNV-0/FNV-1/FNV-1a with a bit width > 64 bits
- documentation: added OpenIndiana to the compatibility lists.
bug fixes:
- CommonHashStatistics.java was not added to the repo which avoided the compilation
- fixed the grammar bugs in the manpage by using OpenAI's grammar correction

Jacksum 3.5.0, Jan 7, 2023

new algorithms:
- replaced own CRC engine by the BSD 3-clause licenced CRC engine java-crc 1.0.3 from S&K Software Development Ltd.,
  New Zealand (https://github.com/snksoft/java-crc) in order to benefit from the extra [1..7] CRC bit widths.
- added CRC-82/DARC with aliases crc82, crc82_darc, crc-82, crc-82_darc
  (translated to Java from C-code that was written by Mark Adler)
- added PHP's variants on Tiger called "tiger192,4", "tiger160,4", and "tiger128,4"
  by adjusting Bouncy Castle's TigerDigest slightly.
- added legacy sum64
new features:
- make option --file-list recognizing GNU filename escaping
- added "files-only" style with GNU filename escaping feature enabled in order to generate file lists
  that can be fed to Jacksum again
- added "hexhashes-only" style to read and write files that contain hash values only (for -w)
- added option alias called --match-filter for option --wanted-list-filter
- added option alias called --expect for option --expect-hash
- improved --info for CRCs:
  - added the polynomial representations: normal, reversed, and Koopman
  - added the reciprocal polynomial for CRCs
  - added binary and hex for each poly representation
  - added polynomial representations and CRC parameters also for optimized CRC implementations
updates:
- improved documentation:
  - added ISO-3309 notes on CRC-64
  - added Wolfram's Hash function to the compatibility lists
- updated Jacksum's crc-catalogue by Greg Cook's catalogue of parametrised CRC algorithms
  with CRC-8/HITAG, CRC-16/M17, and CRC-32/MEF. Also added CRC-64/JONES, and CRC-64/REDIS.
- updated bundled bouncycastle version to 1.71 (digests only), but baked out the regression that was
  introduced by issue # 1036 in the Kangaroo class (the constructor parameter is now ignored completely
  in bouncy castle :-/)
bug fixes:
- github issue #22: Statistics are all zero if --check-line has been set
- github issue #24: Regression: Jacksum 3.0.0 to 3.4.0 hangs while trying to read NTUSER.DAT on Microsoft Windows
  if more than one algo has been selected
- correctness of check file shows "NaN %" in the statistics if there is no entry at all in the check file
- updated serialversionUID in the Parameters class, because members have changed in Jacksum 3.4.0
- jacksum -h exit does not print the entire exit status section
- option --match-filter match,nomatch doesn't work like --match-filter all
- be not equal-tolerant for any BASE64* encoding

Jacksum 3.4.0, June 19, 2022

new features:
- features in this release are mostly around GitHub issue #10
- added option -w resp. --wanted-list to find files that match hashes in a precalculated list
- added option --wanted-list-charset and alias --charset-wanted-list to specify the charset for
  the "wanted list"-file
- added option --wanted-list-filter in order to filter the output produced by -w,
  allows both positive and negative matching
- documented operating modes to the help file
bug fixes:
- sm3 not returned by calling "jacksum -a all -l"
- if "--file-list " and "--format #FILENAME{path}" is set, a NPE is thrown if the parent of a file in the list is null
- false positives during -c: files are found as NEW more than once if the specified file references have different relative paths
  to the same file

Jacksum 3.3.0, April 23, 2022

new features:
- added option --threads-hashing to control the number of threads if multiple
  algorithms should run in parallel
- added option --threads-reading to control the number of threads if multiple
  files should be read in parallel
- added option --path-relative-to-entry
  (required for the integration at the Windows Explorer's SendTo-menu)
- added option --filesize to control whether the file size should be added or not
- added option --gnu-filename-escaping to tag the lines where file names have been escaped (default, linux, and bsd styles)
- parse escaped file names that have been tagged in default, linux and bsd verification files
- added format token #BINTAG to tag binary mode in verification files with a Linux style produced on Microsoft Windows
- added format token #ESCAPETAG to tag lines where the file name has been escaped using the GNU file name escaping feature
- added format tokens #ALGONAMES, #ALGONAMES{uppercase}, and #ALGONAMES{lowercase} to print algorithm names
  separated by a comma if multiple algorithms have been selected
- added format tokens #HASHES, #HASHES{} to print hashes separated by comma if multiple algorithms have been selected
- added public API calls to allow requesting info from the build-in help
performance:
- the option --threads-reading is set to 1 by default to avoid performance degradation
  for hashing files stored on non-SSD-media such as HDDs or CD-ROMs
- faster output of the build-in help by using memory buffering before printing
- improved initial values for HashMap constructors
bug fixes:
- fixed: if ")" is part of a file name (e.g. "file (1).txt", the regexp in the bsd, solaris-tagged,
  solaris-untagged, and openssl compat files don't detect the filename
- fixed: if a path cannot be relativized by --path-relative-to it should not print
  stacktrace, but simply return the non-relativized path (e.g. if both paths have a different roots
  on Microsoft Windows).
- fixed: normalize paths if --path-relative-to is set to avoid false positives during verification
- fixed: option --path-relative-to is not taken into account if --compat has been set
- fixed: --header's invocation arg need to be quoted if arg starts with a # sign
- fixed: if Jacksum is being called by its API, the invocation args should be printed
  from the actual parameter object values, and not from the CLI parameters
- fixed: wrong help section is printed out in case of user errors with --file-list-format
- fixed: slightly wrong error message if concurrent path options have been set
- fixed: algorithms with a numeric parameter (e.g. haval__) cannot be found
  by the build-in help function if fully expessed (e.g. jacksum -h haval_256_5)

Jacksum 3.2.0, March 5, 2022

new features
- the default parser takes option -s into account (GitHub issue #9)
- added option --header
- added --path-relative-to to print paths relative to another path
  (required for the File Browser Integration on Windows)
- added --path-absolute to print absolute paths
- added --no-path to omit the path
- added encodings base64-nopadding, and base64url-nopadding
performance improvements
- since Java 9+ supports a fast CRC32c, it became the primary implementation for crc32c
- improved initial values for HashMap constructors
minor improvements (comfort)
- added aliases rg32, rg-32, and rg64, rg-64 for radiogatun (GitHub issue #14)
- added alias called --style for the option --compat
- added alias --absolute for --path-absolute
- added alias --relative-to for --path-relative-to
- improved error handling for the algorithm parameter
- reformatted help
bug fixes
- fixed: on Linux during integrity checking, don't replace the back slash file separator for filenames,
  because on Linux it is allowed to have backslashes in filenames (GitHub issue #17)
- fixed: wrong hashSize in GNU-Crypto's whirlpool 0-arguments constructor
  (and all whirlpool derived implementations) (GitHub issue #19)
- fixed: -F "#HASH{}" and -F "#HASH{,}" does not work if just only one algorithm
  has been selected
- fixed: typo in manpage (bitwidth for RIPEMD 320)

Jacksum 3.1.0, Nov 1, 2021

new features:
- allow Jacksum to read from all Windows files types on Microsoft Windows including
  disks, partitions, RAM disks, the nul-device, and NTFS Alternate Data Streams (ADS) on both files and directories
- allow Jacksum to read from all file types on Unix-like operating systems including
  block devices, character devices, named pipes (FIFOs), sockets, and doors (Solaris only)
- added option called --scan-ntfs-ads to let Jacksum scan for NTFS Alternate Data Streams (ADS)
  during recursively directory traversal on Microsoft Windows
- added option called --scan-all-unix-file-types to let Jacksum scan for all Unix file types
- added option called --bom for adding a Byte-Order Mark (BOM) to the output if a charset has been specified where a BOM
  is optional (charsets GB18030, UTF-8, UTF-16BE, UTF-16LE, UTF-32LE, and UTF-32BE)
- added option -q file: (GitHub issue #12)
- added z-base-32 encoding for hash value representation
minor improvements:
- improved check mode statistics: added number of improperly lines, and number of ignored lines
- improved the style of the short help to see everything even on terminals with 24-rows
- improved the manpage: added the hash function tools that are supported by BusyBox
minor bug fixes:
- fixed: don't follow symlinks to block devices, character devices, named pipes, sockets,
  or doors if -f (regular files only) has been set.
- fixed: duplicate filenames in the checkfile leads to a misleading output,
  the latest duplicate filename in a checkfile should win, and all previous duplicate filenames should be ignored
- fixed the manpage: PowerShell applet Get-FileHash has also RIPEMD160

Jacksum 3.0.1, Oct 4, 2021

added minor features
- added algorithm aliases crc32_jamcrc and crc-32_jamcrc for crc32_ubi
- added algo aliases sha512t224, sha512t256, skein256, skein512, and skein1024
- added compat aliases called linux-tagged and linux-untagged (for bsd and linux)
- added compat files called solaris-tagged and solaris-untagged
- added format aliases #ALGONAME{lowercase} and #ALGONAME{,lowercase}
improved build-in help
- 'jacksum -h parameters', 'jacksum -h options', and 'jacksum -h algorithms'
  show the corresponding section entirely
- fixed: jacksum -h examples shows only the first 3 example sections, it should show all example sections
- added info to the manpage about "cksum -a " which exists starting with the GNU Core Utilities 9.0
- added KeccakSum compatibility info to the help file
- fixed some typos in the help file
bugs fixed
- fixed: regression: files that have been specified by -o,-O and -u,-U are hashed, but they shouldn't
- fixed: if both errorFile and outputFile are set to the same file, their paths must be normalized before comparisons
- fixed: a NPE is thrown if a non-compatibility file is given by option -C
- fixed: the syntax version of the compatibility files should be checked before processing
- fixed: compat files bsd, linux, and openssl should use line separator \n on Microsoft Windows,
  otherwise md5sum, sha1sum, etc. on GNU/Linux cannot read Jacksum's output
- fixed: typo in compat files linux and openssl which results in wrong stdin names
- fixed: Jacksum does not print 100% compatible output by using tagged compat files (bsd, and openssl)
- fixed: Jacksum does not parse 100% compatible output by using tagged compat files (bsd, and openssl)
- fixed: speed rank info is calculated wrongly (check with jacksum -a all --list --info)
- fixed: format "#HASH{0,}" and -F "#CHECKSUM{i,}" don't work if the user
  has selected one algorithm only
- fixed: crc32c can be used normal, but it is missing in the --list output
- fixed: remove the lab-remnant hex-camelcase from the code
- fixed: a potential mem leak in the Blake3 implementation
- fixed: don't print a warning about implicitly set format if we have set -C and we are in check mode

Jacksum 3.0.0, Sep 4, 2021

Algorithms

new algorithms
- 408 new algorithms (including different sizes) have been added
- SHA-3 winner of the NIS SHA-3 competition (FIPS 202)
  - SHA3-224, SHA3-256, SHA3-384, SHA3-512 provided by the OpenJDK 9+ resp.
    by bouncycastle (bc) as an alternative implementation or if Java < 9 is being used
  - SHAKE128, SHAKE256 (provided by bc)
- completion of the SHA-2 family definitions (FIS 180-4):
  - SHA-512/224, SHA-512/256 provided by the OpenJDK 9+ resp.
    by bc as an alternative implementation or if Java < 9 is being used
- national standards
  - Kupyna256, Kupyna384, Kupyna512 (Ukraine standard)
  - LSH (Korean Standard): LSH-256-224, LSH-256-256, LSH-512-224, LSH-512-256, and
    LSH-512-384, LSH-512-512
  - SM3 (Chinese standard, provided by bc)
  - Streebog-256, Streebog-512 (Russian standard GOST R 34.11-2012, provided by bc)
- other modern cryptographic hash functions
  - BLAKE3 (announced in 2020)
  - BLAKE2s, BLAKE2b (both with support for arbitrary output)
  - KangarooTwelve (K12) and MarsupilamiFourteen (M14)
  - RadioGatun[32], Radiogatun[64] (provided by Project PNRT SAPHIR)
- all SHA-3 finalists (round 3) of the NIST SHA-3 competition
  - BLAKE-224, BLAKE-256, BLAKE-384, BLAKE-512 (provided by Project PNRT SAPHIR)
  - Groestl-224, Groestl-256, Groestl-384, Groestl-512 (provided by Project PNRT SAPHIR)
  - JH (224, 256, 384 and 512 bits) (provided by Project PNRT SAPHIR)
  - Keccak (224, 256, 384 and 512 bits) (provided by bc)
  - Skein256, Skein512, Skein1024 (provided by bc) with support for arbitrary output
- three algorithms from round 2 of the NIST SHA-3 competition
  - ECHO-[224,256,348,512]
  - Fugue-[224,256,348,512]
  - Luffa-[224,256,348,512]
- proposals from the NIST crypto workshops before the SHA-3 competition
  - FORK-256, DHA-256, VSH-1024
- legacy algorithm support
  - PANAMA (provided by Project PNRT SAPHIR)
  - MDC2 (the U.S. Patent 4,908,861 expired on August 28, 2007)
    Thanks to Stefan Palme, Germany for the MDC2 implementation from his
    HBCI4Java project (LGPL)
  - GOST also with init parameters as suggested by the Crypto-Pro company
  - FNV-0, FNV-1 and FNV-1a
    (for each algorithm: 32, 64, 128, 256, 512 and 1024 bits) (provided by jonelo)
  - Minix' crc and Minix' cksum, and sum before Minix 3.2.1 (provided by jonelo)
  - Plan 9' sum (FDDI CRC) (provided by jonelo)
  - PHP's crc32 (provided by jonelo)
  - CRC32c (iSCSI) (provided by jonelo)
  - Bob Jenkins' One-at-a-Time hash (joaat32, provided by jonelo)
  - Fletcher-16 (provided by jonelo)
  - sum40, sum48, sum56 (provided by jonelo)
  - CRC64 (ECMA 182) (provided by jonelo)
  - CRC64 (.xz and prog lang GO, const ECMA) (provided by jonelo)
  - CRC64 (prog lang GO, const ISO) (provided by jonelo)
  - XXH32 (provided by Apache Commons Codec 1.15)
bug fixes
- change request sf# 1693872: Decrease the memory requirement of the
  TigerTree class, Thanks to Oleg Dyakun for the feature request
- bug fixed: a checksum can be returned in a negative format if the
  customizable CRC has a width of 64 bit
Performance

new features
- added multi processor/multi core support for parallel hashing of many files
- added multi processor/multi core support for parallel hashing of many algorithms
  Thanks to Federico Tello Gentile, Argentina for both the feature request
  and the implementation
bug fixes
- change request: for the CrcGeneric update method: moved an if-condition outside the loop
- change request: inline the update method for the loops
  Thanks to Federico Tello Gentile, Argentina for the feature request
- MD2 from the JRE is used by default if available, pure Java implementation of MD2
  on demand (-A), thanks to Federico Tello Gentile, Argentina for the feature request
Data integrity verification

new features
- added option --compat in order to parse data that has been produced by 3rd party apps
- added compatibility files/parsers for BSD-, FCIV-, Linux-, SFV-, and OpenSSL files
- possibility to create own compatibility files
- added option --charset-check-file in order to specify the charset for the check file
- added BOM awareness for check files
- can detect not only OK, FAILED, and MISSING files, but also NEW files
- added option --check-line in order to check just one line
- added option --check-strict in order to exit nonzero if one or more input line is invalid
- added option --list-filter to show ok, failed, missing, and/or new files
Formats and Encodings

new features
- added new Encodings: base32_nopad, base32hex, base32hex_nopad, base64url
- unixtime can be selected for the timestamp format
- Option -q bin in order to support binary input (zeros and ones),
  comma and space delimited values are supported
- Option -q txtf in order to support UTF-8 formatted text including
  interpretation of escape sequences (\n, \r, \t, ", ', \ and \xHH)
- the alias called #DIGEST has been added to the format options
- the alias called #LENGTH has been added to the format options
- added #CHECKSUM{i,e} to the format options in order to specify
  a particular encoding for the CHECKSUM{i}
- added #SEQUENCE to the format options
- added #SEQUENCE{e} to the format options in order to specify
  a particular encoding for the SEQUENCE
- Option -q hex also supports comma and space delimited values
- Option -q dec also supports space delimited values
- Option -t iso8601 in order to produce ISO 8601 compatible timestamps
bug fixes
- bug fixed: padding for base32 is not appended when it should (see RFC 4648)
  Thanks to Dr. Richard B. Kreckel, Germany for both the bug report
  (it has been fixed by replacing the existing class)

Command Line Interface

new features
- added an algorithm finder: if you know both the input and the output you can search for the
algorithm that can produce the output by brute force
(that can be useful for determining unknown CRC algorithm parameters)
- more than one directory can be specified on the command line for a
recursive tree traversal
- option -a enhancement: select algorithms by a search string or a bit width
- you can limit the depth of the recursion by specifying a depth
- added -L in order read files from a predefined list
- in addition to the "Rocksoft (tm) Model CRC Algorithm" schema,
the Generic CRC can be parameterized to include the (optional xor'ed)
length to the CRC in order to describe algorithms such as the POSIX
cksum or the FDDI CRC
- extended option -V in order to print out details of algorithms
(e.g. polynomial as a math expression for all CRCs)
- improved option -V to enable/disable errors as well
- each dash-option has got a dash-dash-option as well
- added the double dash-option in order to signify the end of command options
- added --info option to get info about the program, for the selected algorithms or
the compatibility file
- added options --charset-check-file, --charset-file-list, --charset-error-file,
--charset-output-file, --charset-stdout, and --charset-stderr in order to specify
the charset for various I/O objects
- Shortcut option -8 or --utf8 can be used to set UTF-8 character set for both stdout and stderr

bug fixes
- change requests sf# 1532748: read binary rather than text from standard input
and sf# 2842138: Incorrect output for data provided by stdin
Thanks to gsteele0000 and r_a_llo for the change requests
(unexpected suboptimal behavior was documented, though)

Documentation

new features and improvements
- updated availability of checksum/hash tools/algorithms on
  BeOS, FreeBSD, HP-UX, GNU/Linux, Mac OS X, Solaris, and Windows
- added availability of checksum/hash tools/algorithms on
  7z, Angstrom, DragonFly BSD, CentOS, FreeDOS, GNU/Hurd, gpg, IBM AIX,
  Java, Kali Linux, LibreSSL, macOS, Minix, MS-DOS, NetBSD, NexStep,
  PHP, Plan 9, Python, and OpenSSL (phew, that were a lot of VMs and tests ;-)
- added more examples for learning Jacksum
- redesigned the help page
bug fixes
- bug fixed: "-h license" does not print anything
- bug fixed: -h prints help sections for both uppercase and lowercase option,
  but should only print the expected help section
Internal/API

new features and improvements
- feature request sf# 1602248: support for NIO byte buffers,
  Thanks to Moritz Ringler, Germany for the feature request
- the code structure has been significantly redesigned and refactored
  in order to restore the maintainability of Jacksum for new requirements
replacements
- replaced the existing Base64 implementation (public domain) with the one
  from the Java Standard SE 8+ API
- replaced the existing Base32 implementation (public domain) with the Base32
  implemenation from www.dnsjava.org (2-clause BSD license)
Compatibility changes

changes
- requires a JRE/JDK that is compatible with Java 11 or later, OpenJDK 11+ is recommended
- released under the terms of the GNU GPLv3 or later
- the default algorithm is now SHA3-256 and not SHA-1 anymore
- by default, data is read from standard input in binary mode
- by default, recursively operation is active for folders, by default depth is unlimited
- if -r is specified explicitly, also a depth has to be specified
- redirection to a file by -u, -U, -o, and -O uses UTF-8 rather than the default
  shell character set in order to support Unicode characters for filenames/folders
  Thanks to Rajmund, UK for the feature request and code suggestion
- option -l enables the list view in general, for filtering verification results use --list-filter
- option "-t default" defaults to a format that also includes the milliseconds
deletions
- options -m, -p, -S, -w have been removed
- the Jacksum class in the default package has been removed
- Java version check has been removed
- German translation for option -h has been removed (at least for now)

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-11-06

regression bug fixed: when option -l is used, 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 if -m is used)
Thanks to Lee A. Davis for the feature request
improved documentation

Jacksum 1.5.0, 2004-08-08

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 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 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+ can have 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 public release
requires at least JRE 1.3.0
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

Release Notes

Eigenschaften

Links