-
Notifications
You must be signed in to change notification settings - Fork 5
Manpage
Johann N. Löfflmann edited this page Sep 8, 2021
·
9 revisions
jacksum - a data integrity software tool to master checksums, CRCs, and
message digests (hashes)
3.0.0
jacksum [option]... [file|directory]...
Overview:
Jacksum (JAva ChecKSUM) is a free and cross platform data integrity
software tool to master checksums, CRCs, and message digests (hashes).
Jacksum supports 470 fingerprinting algorithms, and takes advantage of
modern muliti-processor/multi-cores environments for parallel
computation and verification of hashes.
With Jacksum you can also find the algorithm used to calculate a
checksum/CRC/hash or find files that match a given hash value.
Both input and output are highly customizable, including charsets,
encodings, formats, and compatibility files.
Type `jacksum -h examples` and go to https://jacksum.net to learn more
about Jacksum.
Supported algorithms (standards):
* National standards of cryptographic hash functions:
SHA-1, SHA-[224,256,384,512], SHA-512/[224,256] (USA, NIST FIPS 180-4);
SHA3-[224,256,384,512], SHAKE[128,256] (USA (NIST FIPS 202);
GOST, GOST Crypto-Pro (Russia, GOST R 34.11-94); Streebog-[256,512]
(Russia, GOST R 34.11-2012); SM3 (China); Kupyna[256,384,512] (Ukraine,
DSTU 7564:2014); LSH-256-[224,256], LSH-512-[224,256,384,512] (South
Korea, KS X 3262); HAS-160 (KISA, South Korea)
* all 5 candidates from round 3 the NIST SHA-3 competition (2007-2012):
BLAKE-[224,256,348,512], Groestl-[224,256,384,512], JH[224,256,284,512]
Keccak[224,256,384,512], Skein-256-[8..256], Skein-512-[8..512],
Skein-1024-[8..1024]
* 3 candidates from round 2 of the NIST SHA-3 competition (2007-2012):
ECHO-[224,256,348,512], Fugue-[224,256,348,512], Luffa-[224,256,348,512]
* Proposals from the 2005 NIST workshops before the SHA-3 competition:
DHA-256, FORK-256, VSH-1024
* International accepted, modern strong cryptographic hash functions:
BLAKE2s-[8..256], BLAKE2b-[8..512], BLAKE3, ed2k,
HAVAL-[160,192,224,256]-[3,4,5], RadioGatun[32,64], RIPEMD[160,256,320],
Tiger2, Whirlpool
* eXtendable Output Functions (XOF) as cryptographic hash functions with
a fixed length: SHAKE128, SHAKE256, KangarooTwelve, MarsupilamiFourteen
* Broken cryptographic hash functions for education and backwards
compatibility purposes:
HAVAL-128-[3,4,5], MD2, MD4, MD5, MDC2, PANAMA, RIPEMD-128, SHA-0,
SHA-1, Tiger, Tiger/128, Tiger/160, Whirpool-0, Whirlpool-T
* Checksums that can be found in software products and operating systems:
Adler-32, cksum (Minix), cksum (Unix), ELF (Unix), Fletcher's Checksum,
FNV-0_[32,64,128,256,512,1024], FNV-1_[32,64,128,256,512,1024],
FNV-1a_[32,64,128,256,512,1024], joaat, sum (BSD Unix), sum (Minix),
sum (System V Unix), sum [8,16,24,32,40,48,56], xor8, XXH32
* CRCs that are being used in many software products and protocols:
CRC-8 (FLAC), CRC-16 (LHA/ARC), CRC-16 (Minix), FCS-16, CRC-24 (OpenPGP),
CRC-32 (FCS-32), CRC-32 (MPEG-2), CRC-32 (bzip2), CRC-32 (FDDI),
CRC-32 (UBICRC32), CRC-32 (PHP's crc32), CRC-64 (ISO 3309),
CRC-64 (ECMA-182), CRC-64 (prog lang GO, const ISO),
CRC-64 (.xz and prog lang GO, const ECMA)
Supported algorithms (customizable):
Jacksum supports the concatenating of algorithms. Simply use a + sign
in order to concatenate several algorithms together, e. g. md5+sha1.
Select all supported algorithms at once (-a all), use a filter
by specifying a string (-a all:<string>) or a bit width of the message
digest (-a all:<width>) in order to concatenate all algorithms that
matches the filter criteria.
To learn more about that subject type `jacksum -h -a`
Jacksum supports the "Rocksoft (tm) Model CRC Algorithm" which allows to
construct any of the possible CRC combinations with a [8..64] bit width.
Jacksum also extends that well known model to include the length of the
message optionally to the CRC.
To learn more about that subject type `jacksum -h crc:`
Processing performance:
Jacksum uses the computing power of multi-core processors if available.
This allows simultaneous/parallel calculation/verification of hashes
for many files. If more than one algorithm is chosen for the
calculation/verification process, Jacksum also distributes that load
across multiple cores. In that case the slowest algorithm selected
determines the minimum computation time. Any file is read only once in
any case.
Jacksum comes with pure Java implementations for all supported
algorithms. By default Jacksum checks whether an algorithm is provided
by the JRE/JDK and if it is, it uses the implementation from the
JRE/JDK, because often that gives the best performance. Because
exceptions confirm the rule, this behavior can also be disabled by
setting the -A option.
Input:
Input data can come from files, standard input stream (stdin), or
provided directly by command line arguments (see also options -,
and -q). Pointers to this data can be given by command line arguments,
by walking file trees recursively with a specific depth (-r), by file
lists (-L), or by check lists (-c). In the case of lists, many different
charsets can be selected in order to read localized, non-ASCII filenames
properly( see also options --charset-check-file, --charset-file-list).
You can specify the format of file lists by setting --file-list-format.
You can specify the format of the check file by selecting a predefined
parser or by defining your own parser (see also option --compat) so you
can process input even if it was not produced by Jacksum.
Output:
By default the output format is standardized and behaves like well known
checksum resp. cryptographic hash tools on GNU/Linux such as sum,
sha1sum, md5sum, b2sum, digest, etc. The output format can also be made
compatible to the output that other famous tools such as openssl,
or FCIV produce. Also the BSD format or legacy formats such as sfv
are supported (see option --compat).
The output can also be completely customized (see option -F). Hashes can
be encoded by 12 different encodings (see also option -E), or formatted
for easier readability (see also options -g, and -G). Filenames
and timestamps can be customized as well (see also options -P, and -t).
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).
Concluding remarks:
Jacksum selects the appropriate operating mode dependent on the options
and parameters that you set. Any operation can be cancelled at any time
by hitting Ctrl+C in the terminal.
Jacksum processes directory trees recursively by default and you can
control the walking depth by option -r. You can also set the options -f
and -d in order to disallow Jacksum to follow symlinks to files and/or
directories.
Note that not all algorithms are suitable to perform highly reliable
integrity checks. Actually Johann N. Loefflmann recommends to use
non-broken, cryptographic hash functions, because those algorithms are
designed for that purpose.
Nonetheless Jacksum will continue to support legacy algorithms as well,
because in real life they are still in use and they are also useful for
finding an algorithm by brute force if only the data and the hash are
known, and last but not least it is great for educational purposes.
Jacksum is written entirely in Java. Therefore it runs cross platform,
without the need of recompilation. A Java Runtime Environment (JRE) or
Java Development Kit (JDK) at least version 11 is required. The latest
OpenJDK is recommended.
The following parameters are supported:
files and directories
names of files and directories. You can specify as many files and
directories as you like. Wildcards are supported, but they depend
on the shell that you are using. With no parameters Jacksum reads
from the standard input.
Starting with Jacksum 3.0.0 the recursive mode is enabled by default
for directories, and you can control the depth with the -r option.
Bytes are read from the standard input in binary mode.
The following options are supported:
-a <algo> | all[:<width>|:<string>] | crc:<crc> | unknown:<width>
--algorithm <algo> | all[:<width>|:<string>] | crc:<crc> | unknown:<width>
Specifies the algorithm. Many algorithms support aliases in order
to memorize their id more easily. Since Jacksum 1.0.0, see also -A.
Starting with Jacksum 3, the default is sha3-256.
One algorithm (-a <algorithm>)
Replace <algorithm> with one of the IDs that Jacksum
understands. To see all supported algorithm IDs and their
descriptions type `jacksum -a all -l`
Note: the option -a crc:<crc> allows you to define a customized
CRC by using a parameterized model. Those customized IDs aren't
listed by the command above, but you can select and use them.
Learn more on this topic by typing `jacksum --help crc:`
Several algorithms, handpicked (-a <algo>+...):
Algorithms can be concatenated with the plus character, e. g.
"sha1+crc32", "sha512+sha3-512+blake2b-512", etc.
If at least one plus character is found in <algorithms>, the
output is normalized by a hex checksum and a decimal file size.
You can customize that behavior by using the options -E, -F, -g,
and -G. Examples: "sha1+md5+crc32", "sha3-256+"
Available since Jacksum 1.7.0
Several algorithms, filtered by bit width (-a all:<width>)
In order to use all algorithms that have a particular bit-
length, you can use "-a all:<width>" where <width> has to be a
muliple of 8 such as "all:224", "all:256", "all:888", "all:1024"
Available since Jacksum 3.0.0
Several algorithms, filtered by a string (-a all:<string>)
In order to use all algorithms that matches a particular string,
you can use "-a all:<string>" where <string> can be any string.
Algorithm IDs and Algorithm alias IDs are being searched, such
as "all:skein", "all:sha3-", "all:fnv", "all:whirlpool"
Available since Jacksum 3.0.0
All algorithms (-a all):
If you set <algorithm> to "all", all supported algorithms are
used which means that you can calculate hashes with hundreds
of algorithms by reading the input only once.
If "all" is used, the output is normalized by a hex checksum
and a decimal file size.
Find an unknown algorithm (-a unknown:<width>):
If you only know both the input and the output, and if you want
to know the algorithm that has been used to produce the output,
you can set <algorithm> to unknown:<width>. Replace
<width> with the length of the digest in bits. In that case,
all supported algorithms will be tested whether there is one
which can produce the expected output. Also a list of well known
CRCs will be checked, and finally all CRC-algorithms will be
tested by brute force (init and xorOut are set to either
all bits zero or all bits one while refIn and refOut are set to
either true or false for all potential polynomials of the given
width). Please be patient! Both options -q and -e are required
in this case.
Available since Jacksum 3.0.0, see also -V, -e, -E, -q
-A
--alternative
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, md2, md5, sha-1, sha-256, sha-384, sha-512
Available since Jacksum 1.5.0, see also -a
-c <file>
--check-file <file>
Verify (check) files against a list of hashes. The list can either
be a former output of Jacksum or an output of a different hash
application.
You have to specify at least the options -a and -E,
because Jacksum must know which algorithm and which encoding
were used when <list> was generated.
In addition to that you need to set all options that could
generate <list> again, e. g. the options -g, -G, -t, -d, -f may
become necessary as well. The option -F will be ignored.
If you have used option -F or if the output of <list> is not in the
quasi-standard output format like
<encoded/formatted hash><blank>[<blank or star>]<filename>
you can specify a parser file by using the --compat option.
The parser file must have all the definitions that are necessary
to parse <list> properly. For more information see also option -C.
If <list> is set to a single dash (-) Jacksum reads from stdin.
Use option --charset-check-file to specify the character set for
<file>.
You can use the option -I in order to ignore all lines that start
with a particular string in <list>.
To exclude files from being checked, just remove the lines from the
list. This can be done with findstr /V (on Windows) and with grep -v
(on both Linux and Unix). Example: check all files in md5.check, but
exclude any .iso files:
findstr /V .iso$ hashes.md5 | jacksum -E hex -a md5 -c -
For each file in <list> Jacksum shows the status of the file's
integrity and the filename. The status can be one of the following:
OK
the file's fingerprint hasn't changed, the checksum that has
been calculated is still the same checksum as the one that is
in stored in the <list>. If <list> also contains filesizes
and/or timestamps, filesizes and/or timestamps are being
compared as well and must match in order to return an OK.
FAILED
a mismatch beweeen the calculated checksum and the checksum
in the <list>. Usually it means that the file's content has
been changed. If <list> contains also filesizes and/or
timestamps, filesizes and/or timestamps are being compared
as well. If one of those don't match, FAILED is being
returned. In that case additional information is printed to
stderr. You can disable that additional information by
setting the option "--verbose noinfo"
MISSING
a file that is stored in <list>, but cannot be found on the
file system anymore. Usually those files have been renamed,
moved to a different location or even removed.
If you see only MISSING lines, it could mean that your
current working directory differs from the one that was
used when <list> was created. Make sure that your working
directory is set correctly.
NEW
a new file that cannot be found in the <list> but on the file
system. Usually those are the files that have been created
after the <list> was created. In order to find NEW files you
have to specify all locations that were used to generate the
<list>. This can be done by adding locations as program
arguments or with the option called --file-list.
If you want to filter the output by one or more statuses, you can
set the option --list-filter <filter>
If you don't want the status at all in the output, you can you can
set the option --list and just only the filenames are printed.
After the filenames (and by default the status for each file) have
been printed out as a separate line, a short summary with statistics
is printed out, because usually you don't want to miss that info
during a verification check. This is because the verbose control
is set to "info,warnings,summary" if option -c is set.
Set --verbose nosummary if you want to disable the summary.
If at least one mismatch is found during checksum verification,
the program returns an error code of 1.
If at least one error is found duing the process, the program
returns an error code greater than 1.
Improperly formatted lines are ignored with respect to the exit code
unless you set --check-strict.
Available with the features above since Jacksum 3.0.0,
see also the options -C, -I, --list-filter
--check-line <string>
take a <string> from the command line and treat it as the line would
come from a check file.
Available since Jacksum 3.0.0
--check-strict
When verifying integrity, if one or more input line is invalid,
exit nonzero after all warnings have been issued.
Available since Jacksum 3.0.0
-C <compatibility>
--compat <compatibilty>
Specifies the compatibilty behavior of Jacksum for both input format
and output format. Replace <compatibility> with one of the
predefined keywords bsd, fciv, linux, sfv, openssl in order
to get a predefined behavior or replace it with a file that contains
the properties that are required for a compatibilty file. To get
the properties of one of the predefined compatibility files, add
the option --info. Example: `jacksum -C bsd --info`
<compatibility> can be used for the hashing mode, the check mode
and the info mode.
hash mode:
During normal hashing of files/messages the <compatibilty>
determines the acutal output format only. The algorithm
(--algorithm), the encoding of the hash (--encoding), and the
format (--format) will be used ad defined in <compatibilty>.
If <compatibility> supports the algorithm to be specified by the
user you can set -a to get the expected output format defined
in <compatibility> but with the algorithm you want. For example,
that allows you to print sha1 hashes in the legacy sfv format.
verification/check mode:
Jacksum can not only read output that has been produced by
itself, it is also able to read output from other tools. For
being compatible with both well and not so well known tools, you
can specify one of the predefined build-in parsers or define
your own parser by providing a short property file.
In check mode (if option --check has been set), the
<compatibility> determines the parser that is used to read the
the file content properly that you can with set with -c. So
with -C you can check against a list that was created
by a different application or if you have generated a list with
Jacksum and the -F option was in use.
To specify the character set of the actual input file use the
option --charset-check-file if the input file is not stored with
the character set UTF-8.
You can also write you own parser definition, save it to a text
file and specify the location of the file with -C.
info mode:
In info mode (if option --info has been set), the properties
of the compatibility file are being printed out.
For <compatibilty> the following predefined compatibility files
are supported:
bsd
output as from the executables md5, sha1 on BSD and macOS,
but works with any algorithm that is supported by Jacksum.
Format is "#ALGONAME{uppercase} (#FILENAME) = #HASH{hex}"
If you don't specify -a, the algorithm defaults to sha3-256.
fciv
File Checksum Integrity Verifier (fciv) from Microsoft;
output as from the commands "FCIV -sha1" or "FCIV -md5" on
Microsoft Windows, but works with any algorithm that is
supported by Jacksum.
Format is "#HASH{hex} #FILENAME"
If you don't specify -a, the algorithm defaults to sha1.
linux
output as from executables md5sum, sha1sum, b2sum, etc. on
Unix and GNU/Linux, but works with any algorithm that is
supported by Jacksum.
Format is "#HASH{hex} #FILENAME"
if you don't specify -a, the algorithm defaults to sha3-256.
sfv
Simple File Verification format, usually for CRC32 only,
but works with any algorithm that is supported by Jacksum.
Format is "#FILENAME #HASH{hex-uppercase}"
If you don't specify -a, the algorithm defaults to crc32.
openssl
output as from the executable openssl, but works with any
algorithm that is supported by Jacksum.
Format is "#ALGONAME{uppercase}(#FILENAME)= #HASH{hex}"
If you don't specify -a, the algorithm defaults to sha3-256.
Available since Jacksum 3.0.0.
--charset-check-file <charset>
--check-file-charset <charset>
Specifies the charset for the file that you can specify with -c.
If you don't specify this option, UTF-8 will be used for the
check file. See also options --check-file, --check-line
and --compat.
If you have a file that was created by a redirection on
Microsoft 10, Windows PowerShell 5.1, you should set <charset> to
UTF-16le for example. The available charsets can be printed out
by `jacksum --info`.
Unicode aware charsets are
GB18030
is a Chinese government standard. If a Byte-Order Mark (BOM)
is found it will be ignored, because a BOM in GB18030 is not
required.
UTF-8
8-bit UCS Transformation Format. If a Byte-Order Mark (BOM)
is found, it will be ignored, because a BOM in UTF-8 is
not required.
UTF-16
16-bit UCS Transformation Format, byte order identified
by an optional byte-order mark, it defaults to big-endian
if there is no byte-order mark.
UTF-16BE
16-bit UCS Transformation Format, big-endian byte order.
UTF-16LE
16-bit UCS Transformation Format, little-endian byte order.
UTF-32
32-bit UCS Transformation Format, byte order identified
by an optional byte-order mark, it defaults to big-endian
if there is no byte-order mark.
UTF-32BE
32-bit UCS Transformation Format, big-endian byte order.
UTF-32LE
32-bit UCS Transformation Format, little-endian byte order.
Available since Jacksum 3.0.0.
--charset-file-list <charset>
--file-list-charset <charset>
Specifies the charset for the file that you can specify with -L.
If you don't specify this option, UTF-8 will be used for the
file list. See also --file-list or -L
Available since Jacksum 3.0.0.
--charset-error-file <charset>
--error-file-charset <charset>
Specifies the charset for the error file.
If you don't specify this option, UTF-8 will be used for the
error file. See also --error-file
Available since Jacksum 3.0.0.
--charset-output-file <charset>
--output-file-charset <charset>
Specifies the charset for the output file.
If you don't specify this option, UTF-8 will be used for the
output file. See also --output-file
Available since Jacksum 3.0.0.
--charset-stderr <charset>
--stderr-charset <charset>
Specifies the charset for the standard error stream (stderr).
If you don't specify this option, the default charset will be used
that is dependent on your shell settings.
See also --utf8
Available since Jacksum 3.0.0.
--charset-stdout <charset>
--stdout-charset <charset>
Specifies the charset for the standard output stream (stdout).
If you don't specify this option, the default charset will be used
that is dependent on your shell settings.
See also --utf8.
Available since Jacksum 3.0.0.
--copyright
prints out the copyrights and license information for all portions
of the software that Jacksum licensed.
-d
--dont-follow-symlinks-to-directories
Don't follow symbolic links on directories, that means regular
directories only. Starting with version 3, Jacksum detects file
system cycles (a symbolik link from a sub folder to a parent folder)
and skips folders that could cause an endless loop while a
recursively traversal. If you set -d, Jacksum doesn't follow any
symbolik links on directories.
Available since Jacksum 1.5.0, see also -r, -f
File system cycle detection available since Jacksum 3.0.0
-e <hash>
--expect-hash <hash>
A sequence for the calculation is expected. Works with a file,
standard input or option -q. Returns OK (exit code 0)
or MISMATCH (exit code 1).
Available since Jacksum 1.4.0
Works also with multiple files or directories in order to find
duplicates. In this case all findings are being printed out.
Note that hash collisions can occur, so select the algorithm wise
if you search for duplicates.
The sequence can be specified case sensitive or case insensitive,
except if Base64 encoding (by -E) has been specified, because
Base64 is case sensitive.
Available since Jacksum 1.6.0, see also -a, -q, -E, -x and -X
-E <encoding>
--encoding <encoding>
Both the hash value and the sequence (see also option -q) can
be encoded with the following encodings:
<encoding> description
________________________________________________________________
bin binary
dec decimal
oct octal
hex hexadecimal in lowercase chars (same as -x)
-g and -G are considered
hexup deprecated in 3.0, alias for hex-uppercase
hex-lowercase alias for hex (3.0)
hex-uppercase hexadecimal in uppercase chars (same as -X)
-g and -G are considered (3.0)
base16 Base16 (RFC 4648)
base32 Base32 (RFC 4648)
base32-nopadding Base32, no padding (RFC 4648) (3.0)
base32hex Base32hex (RFC 4648) (3.0)
base32hex-nopadding Base32hex, no padding (RFC 4648) (3.0)
base64 Base64 (RFC 4648)
base64url Base64 for URL (RFC 4648) (3.0)
bubblebabble BubbleBabble (used by OpenSSH and SSH2)
bb alias for bubblebabble
Available since Jacksum 1.6.0 if not stated otherwise,
see also -F, -g, -G, -q, -x, -X
-f
--dont-follow-symlinks-to-files
process regular files only. Don't follow symbolic links to files.
See also option -d
Available since Jacksum 3.0.0
-F <format>
--format <format>
With this option you can set a customizable output format if the
default output format does not meet your needs.
<format> can be any text. If the text contains particular tokens,
all tokens will be replaced with their corresponding values.
The following tokens are supported:
<token> description
________________________________________________________________
#ALGONAME will be replaced by the name of the
algorithm
#ALGONAME{<i>} If the character called + has been used
to separate multiple algorithms by
option -a, the token will be replaced
with the name of the algorithm. The
token is indexed by a number. If you
use the single character called i
rather than a number, it works like
an automatic index. (1.7)
#ALGONAME{uppercase} like #ALGONAME, but the name of the
algorithm appears in uppercase. (3.0)
#ALGONAME{<i>,uppercase} like #ALGONAME{i}, but the name of the
algorithm appears in uppercase. (3.0)
#HASH will be replaced by the hash, CRC or
checkum value (depends on the
options -a, -g, -G, -x, -X)
#HASH{<encoding>} The token will be replaced with the
encoded checksum. Replace <encoding>
with a supported encoding. For valid
encoding values see option -E. (1.7)
#HASH{<i>} If the character called + has been used
to separate multiple algorithms by
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.7)
#HASH{<algo>} the token will be replaced with the
hash identified by its algorithm
name. (3.0)
#HASH{<i>,<encoding>} like #HASH{<i>}, but with an explicit
encoding (3.0)
#HASH{<algo>,<encoding>} like #HASH{<algo>}, but with an
explicit encoding (3.0)
#FILENAME will be replaced by the file name and
path (depends on -P)
#FILENAME{name} will be replaced by the file name (1.6)
#FILENAME{path} will be replaced by the file path (1.6)
#FILESIZE will be replaced by the file size
#LENGTH is an alis for #FILESIZE (3.0)
#SEPARATOR will be replaced by the separator which
you can specify with -s
#SEQUENCE will be replaced by the hexadecimal
representation of the sequence which
you can specify with -q (3.0)
#SEQUENCE{<encoding>} like #SEQUENCE, but with explicit
encoding (3.0)
#TIMESTAMP will be replaced by the time stamp
(depends on -t)
#QUOTE will be replaced by one quote char (")
Aliases for #HASH are #CHECKSUM are #DIGEST, and #FINGERPRINT.
Available since Jacksum 1.5.0, if not other specified,
see also -a, -E, -g, -G, -P, -s, -t, -x, -X
-g <count>
--group-bytes <count>
group the hex output for the checksum in "count" bytes for
better readability. Only valid if encoding is hex or hexup.
Groups are separated by a blank or by the character
specified by -G. The value for count must be greater than 0.
Available since Jacksum 1.6.0, see also -E, -G, -x and -X
-G <char>
--group-bytes-separator <char>
Sets the separator for byte groups. Only valid if encoding is
hexadecimal and -g has been set.
Available since Jacksum 1.6.0, see also -E, -g, -x and -X
-h [language] [word]
--help [language] [word]
print help, valid codes for language is en; valid values for
word are strings like section headers, options or algorithms.
See section EXAMPLES for more information.
Available since Jacksum 1.0.0
parameter word since Jacksum 1.6.0
--info
Returns information and exits the program.
If -a hasn't been set it prints out
* the program name and version
* the Primary IDs and descriptions of all supported algorithms
* the number of all supported algorithms
* the default algorithm
* the number of the supported CRC combinations
* the supported character sets
* the default character set
* available processors
* and all Java system properties
If -a has been set it prints out additional information about the
selected algorithm(s):
* algorithm id
* hash length in bits and bytes
* blocksize in bits and bytes (if applicable)
* CRC implementation details (if applicable)
* whether an alternate implementation has been requested,
whether it is available and would be used
If -a has been set with multiple algorithms, and --list has been set
it prints out:
* details for each algorithm
-I <string>
--ignore-lines-starting-with-string <string>
While reading a list by -L, or -c, lines are ignored if they start
with the string.
Available since Jacksum 1.6.0, see also -c
--license
prints out the license that the project is offered under.
Available since Jacksum 3.0.0, see also --copyright
-l
--list
Enables the list view.
If option -a is set, it lists the IDs of the algorithms only.
If option -c and --list-filter is set, it lists the filenames only
without the status OK, FAILD, MISSING or NEW.
--list-filter <filter>
Filters the output that is being produced by -c.
<filter> has to bee one or more of the following keywords,
separated by a comma:
ok show OK files
failed show FAILED files
missing show MISSING files
new show NEW files
all <filter> is set to ok,failed,missing,new
default <filter> is set to all
none does not print anything (useful if you are
interested in the summary only) or if you want
to define your own filter
good <filter> is set to none,ok,new
bad <filter> ist set to none,failed,missing
Only if the filter is set to ok or failed or both, the hashing
occurs. For detecting missing or new files, hashing is not required.
Available since Jacksum 3.0.0, see also -c, and --list
-L <textfile>
--file-list <textfile>
Process <textfile> as a filelist. By default each line in the file
will be treated as a filename or foldername to be processed.
If the option --file-list-format is set to ssv, each line in the
file will be treated as multiple filenames, separated by spaces
or tabs.
If <textfile> is set to "-", standard input stream is used.
The charset UTF-8 is used to read the file unless you specify
the charset by the option --charset-file-list.
The option -L <textfile> can go in addition to file parameters.
Wildcards are not supported in the <textfile>.
Available since Jacksum 3.0.0
--file-list-format <format>
Specifies the format of the file list file. If this option is
omitted, <format> is set to list. The supported formats are:
list default. Each filename is stored in a separate line.
ssv space separated values. Each filename is separated by
one or more common space characters (a space or a
horizontal tab). A file name that contains space
characters has to be enclosed in double quotes. This is
useful if Jacksum operates in Windows' shells where
Jacksum isn't able to accept parameters resp. filenames
that contain unicode characters.
--legacy-stdin-name
Starting with Jacksum 3 the standard input stream is named
<stdin> at the output, because the single dash could also be the
name of a file or a directory. Since the characters < and > cannot
be used for filenames or directory names on most file systems,
<stdin> is a great choice for naming stdin for the output.
If you set the --legacy-stdin-name, Jacksum uses the "-" again for
naming the standard input stream for the output.
-o <file>
--output-file <file>
The output of the program goes to a file rather than the standard
output. The program exits with a warning if the file exists. The
file which is specified by -o is excluded from the calculation
process.
Available since Jacksum 1.6.0, see also -O, -u and -U
-O <file>
--output-file-overwrite <file>
Same as -o, however an existing file will be overwritten without any
warning. See also -U.
Available since Jacksum 1.6.0, see also -o, -u and -U
-P <char>
--path-separator <char>
By default the system-dependent default name separator character is
used. On Unix and GNU/Linux 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 file names is
required, for example to produce relative links for HTML pages on
Microsoft Windows.
Available since Jacksum 1.5.0, see also -F
-q [type:]seqence
--quick [type:]seqence
process a sequence quickly and quit the program. The type can be
used to specify the type of the sequence (text, formatted text,
binary, hexadecimal or decimal). If type is not set, the sequence is
expected to be in hex form.
Any of following examples (except text, non-formatted) return the
same digest of the 7 bytes input.
Decimal
dec:101,103,103,32,52,50,10
dec:"101, 103, 103, 32, 52, 50, 10"
dec:"101 103 103 32 52 50 10"
Decimal values have to be separated from each other by
comma or spaces.
Binary
bin:1100101,1100111,1100111,100000,110100,110010,1010
bin:"1100101, 1100111, 1100111, 100000, 110100, 110010,1010"
bin:"1100101 1100111 1100111 100000 110100 110010 1010"
bin:1100101011001110110011100100000001101000011001000001010
Binary values can be separated by commas or spaces,
but you do not have to, as long as it is clear,
where the 8 bit boundaries are. If necessary you have to
fill up with leading zeros as the last example illustrates.
Hexadecimal
hex:65,67,67,20,34,32,A
hex:"65, 67, 67, 20, 34, 32, A"
hex:"65 67 67 20 34 32 A"
hex:6567672034320A
6567672034320A
Hex values can be separated by commas or spaces, but you do
not have to, as long as it is clear, where the 8 bit
boundaries are. If necessary you have to fill up with
leading zeros as the last two examples illustrates.
Text, unformatted:
txt:"egg 42\n"
If type is only specified as "txt", the default character
set of the platform used to represent the sequence seq.
For unformatted text, the \n is not interpreted as one
character (Newline), but rather as two separate characters
(backslash and "n"). Accordingly, the sequence above
represents an input of 8 bytes and not 7 bytes.
Text, formatted:
txtf:"egg 42\n"
txtf:"egg 42\x0A"
If type is specified as "txtf", UTF-8 will be used to
interpret the sequence seq as formatted text.
The following escape sequences are interpreted accordingly:
\n New Line (0x0A)
\r Carriage Return (0x0D)
\t Horizontal Tab (0x09)
\" Double Quote (0x22)
\' Single Quote (0x27)
\\ Backslash (0x5C)
\xHH Hexadecimal Number (HH can become 00 to 7F)
Available since Jacksum 1.3.0 (hex only), type since 1.5.0, type bin
and txtf since Jacksum 3.0.0
-r <depth>
--recursive <depth>
process subdirectory recursively with a specific depth. The <depth>
can be "max" or a number > 0. If -r is not set at all, <depth> is
set to "max" implicitly. If -r is explicitly set, the current
working directory is used if you don't specify a file parameter.
Available since Jacksum 1.0.0.
The <depth> is available since Jacksum 3.0.0
-s <string>
--separator <string>
a custom separator string (\t, \n, \r, \", \' and \\ will be
translated). The default value depends on the checksum algorithm,
usually it is a single blank.
If you customize the separator, Jacksum may not be able to parse
the output again by default using -c. In that case you could write
your own compatibility file, see also -C.
Available since Jacksum 1.0.0, see also -F
-t <format>
--timestamp <format>
a timestamp format. Java's formatter class
SimpleDateFormat will be used. Valid characters are
G Era designator
y Year
Y Week year
M Month in year (context sensitive)
L Month in year (standalone form)
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
u Day number of week (1 = Monday, ..., 7 = Sunday)
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
X Time zone, ISO 8601
If form has been set to the word "default", timestamps are
formatted as "yyyyMMddHHmmssSSS".
Available since Jacksum 1.3.0, including milliseconds since
Jacksum 3.0.0
If form has been set to the word "unixtime", timestamps are
being formatted by the POSIX time (the number of seconds that
have elapsed since midnight (UTC), 1 January 1970).
Available since Jacksum 3.0.0
If form has been set to the word "unixtime-ms", timestamps are
being formatted by the POSIX time (the number of milliseconds that
have elapsed since midnight (UTC), 1 January 1970).
Available since Jacksum 3.0.0
If form has been set to "iso8601", timestamps are being formated
by "yyyy-MM-dd'T'HH:mm:ss.SSSXXX" in order to be compatible with
ISO 8601.
#SEPARATOR will be replaced by the separator which you
can specify with -s
#QUOTE will be replaced by one quote char (")
Available since Jacksum 1.6.0, see also -F
-8
--utf8
sets the UTF-8 charset for both stdout stream and stderr stream.
It is actually a shortcut for
--charset-stdout UTF-8
--charset-stderr UTF-8
Note that you have to change the shell's default charset as well if
your shell's default charset is not UTF-8 and you want to be
compatible with this setting. On Microsoft Windows you can change
that by changing the code page by entering: CHCP 65001
Available since Jacksum 3.0.0
-u <file>
--error-file <file>
ugly, undesirable, unforeseen, uninvited. Any error messages of the
program go to a file rather than to standard error.
The <file> is excluded from the calculation process.
The program exits if the file exists.
You can set <file> to /dev/null (on Unix and GNU/Linux) or to
nul (on Microsoft Windows) in order to ignore the output.
Available since Jacksum 1.6.0, see also -U, -o and -O
Starting with Jacksum 3.0.0 the file encoding is UTF-8
-U <file>
--error-file-overwrite <file>
ugly, undesirable, unforeseen, uninvited. Any error messages of the
program go to a file rather than to standard error.
An existing file will be overwritten without any warning.
You can set <file> to /dev/null (on Unix and GNU/Linux) or to
nul (on Microsoft Windows) in order to ignore the output.
Available since Jacksum 1.6.0, see also -u, -o and -O
Starting with Jacksum 3.0.0 the file encoding is UTF-8
-v
--version
Prints the product name and version and exits the program.
Option is available since Jacksum 1.2.0
Additional information about the copyright and license will be
printed out if verbose info output is requested.
Examples: "jacksum -v --verbose info" or "jacksum --info"
Available since Jacksum 3.0.0
-V <control set>
--verbose <control set>
<control> has to be at least one and can be more than one of the
following keywords separated by a comma:
info enable info
warnings enable warnings
errors enable errors
summary print summary at the end
noinfo disable info
nowarnings disable warnings
noerrors disable errors
nosummary don't print the summary at the end
all means info,warnings,errors,summary
default means noinfo,warnings,errors,nosummary
none means noinfo,nowarnings,noerrors,nosummary
If you don't set --verbose, Jacksum selects a suitable <control set>
dependent on the operation if performs. By default the <control set>
is set to default.
If you set one of the following options, <control set> is set to
all, because usually you don't want to miss any information for
those operations: --check-file, --check-line, and -a unknown:<width>
If you set option --version , <control set> ist set to none.
If you set option --info, <control set> is set to default again.
Available since Jacksum 1.6.0
The keywoards all and none are available since Jacksum 3.0.0
-x
--hex-lowercase
lowercase hex output for the checksum, it is an alias for -E hex
Available since Jacksum 1.1.0, see also -E
-X
--hex-uppercase
uppercase hex output for the checksum, it is an alias for -E hexup
Available since Jacksum 1.1.0, see also -E
-
a single dash is used to signify that Jacksum should read from
standard input (stdin). Bytes are read from the standard input in
binary mode. The filename is set to "<stdin>". Example:
jacksum - < your.iso
--
a double dash is used to signify the end of command options, after
which only positional arguments are accepted.
Example use: Let's say you want to get all checksums for files in
the folder called '-'. For the string '-' normally '-' will be
considered the option to read from stdin, but with '--' you can calc
checksums in that folder like this:
jacksum -- -
Available since Jacksum 3.0.0
The following algorithms are supported:
adler32, adler-32
algorithm:
Adler-32
length:
32 bits
type:
checksum
published:
1995
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. The default encoding is
decimal. Note that an Adler8, an Adler16 or an Adler64-
algorithm never have been suggested by Mark Adler.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- Haiku: -
- HP-UX: -
- IBM AIX: -
- Java: java.util.zip.Adler32
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- openSUSE: -
- OpenSSL: -
- PHP: hash("adler32", $input);
- Plan 9: -
- Python: zlib.adler32
- SCO UnixWare: -
- Solaris: -
- Tru64: -
- Windows: -
since:
Jacksum 1.0.0, alias "adler-32" since 1.2.0
implementation:
java.util.zip.Adler32 as provided by the JDK.
The alternate implementation from net.jacksum.algorithm is used
if option -A has been specified.
blake<w>, blake-<w->
algorithm:
BLAKE-<w>
length:
224, 384, 256 or 512 bits
type:
crytographic hash function
published:
12/2010
website:
https://131002.net/blake/
comment:
BLAKE is one of the five hash functions that make it in the
final round of the NIST SHA-3 competition. This is the
implementation of the submission to the third and final round
of the NIST SHA-3 competition. BLAKE has not been selected as a
base for SHA-3, but since 12/2012 there exists an extended
version called BLAKE2.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.BLAKE<w>
blake2b, blake2b-<w>, b2sum, b2sum-<w>
algorithm:
BLAKE2b
length:
freely selectable, as long as it is a multiple of 8 and not
greater than 512. If <w> is omitted, <w> is set to 512
type:
cryptographic hash function
published:
12/2012
broken:
no
website:
https://blake2.net
comment:
BLAKE2b is the successor of BLAKE-512.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/b2sum [-l <w>]
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd (GNU Coreutils 8.26+ 11/2016):
/usr/bin/b2sum [-l <w>]
- GNU/Linux (GNU Coreutils 8.26+ 11/2016):
/usr/bin/b2sum [-l <w>]
- HP-UX: -
- IBM AIX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- openSUSE: /usr/bin/b2sum [-l <w>]
- OpenSSL 1.1.0+: openssl dgst -blake2b512
- PHP: -
- Plan 9: -
- Python 3.6+: hashlib.blake2b
- Solaris: -
- Tru64: -
- Ubuntu 17.04+: /usr/bin/b2sum [-l <w>]
- Windows: -
since:
Jacksum 3.0.0
blake2s, blake2s-<w>
algorithm:
BLAKE2s
length:
freely selectable, as long as it is a multiple of 8 and not
greater than 256. If <w> is omitted, w is set to 256
type:
cryptographic hash function
published:
12/2012
broken:
no
website:
https://blake2.net
comment:
BLAKE2s is the successor of BLAKE-256.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- HP-UX: -
- IBM AIX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.0+: openssl dgst -blake2s256
- PHP: -
- Plan 9: -
- Python 3.6+: hashlib.blake2s
- Solaris: -
- Tru64: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.Blake2s
blake3, blake3-256
algorithm:
BLAKE3
length:
256 bits
type:
cryptographic hash function
published:
01/2020
broken:
no
website:
https://github.com/BLAKE3-team/BLAKE3
comment:
BLAKE3 is a single algorithm, in contrast to BLAKE and BLAKE2,
which are algorithm families with multiple variants.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- HP-UX: -
- IBM AIX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.0+: -
- PHP: -
- Plan 9: -
- Python 3.6+: -
- Solaris: -
- Tru64: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
io.github.rctcwyvrn.blake3
cksum
algorithm:
POSIX 1003.2 CRC algorithm
length:
32 bits
type:
checksum, based on CRC
comment:
The default encoding is decimal.
G(x) = x^32 + x^26 + x^23 + x^22 + x^16 + x^12 +
x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x +1
The Posix CRC cannot be described completely by the
Rocksoft-Model, because the algorithm includes the length to
the CRC. Without this special, the code would be:
crc:32,04C11DB7,0,false,false,FFFFFFFF
With the additional length parameter it can be expressed as
crc:32,04C11DB7,0,false,false,FFFFFFFF,false
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/cksum
- Angstrom: -
- BeOS: /bin/cksum
- CentOS: /bin/cksum
- DragonFly BSD: /usr/bin/cksum
- eComStation: C:\ecs\KLIBC\bin\cksum
- FreeBSD: /usr/bin/cksum
- FreeDOS: -
- GNU/Hurd: /usr/bin/cksum
- GNU/Linux: /usr/bin/cksum
- Haiku: /bin/cksum
- HP-UX: /usr/bin/cksum
/usr/bin/sum -p
- IBM AIX: /usr/bin/cksum
- Java: -
- Kali Linux: /usr/bin/cksum
- Mac OS X: /usr/bin/cksum
- macOS 10.12+: /usr/bin/cksum
- Minix 3.2.1+: /usr/bin/cksum
- MS-DOS: -
- NetBSD: /usr/bin/cksum
- NetBSD 9.2+: /usr/bin/sum -a crc
/usr/bin/cksum -a crc
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- Python: -
- SCO UnixWare: /bin/cksum
- Solaris: /usr/bin/cksum
- Solaris 11 Express:
/usr/bin/sum --method=cksum
- Tcl: crc::cksum
- Tru64: CMD_ENV=xpg4;export CMD_ENV; /bin/cksum
- Windows: -
since:
Jacksum 1.0.0
implementation:
crc:32,04C11DB7,0,false,false,FFFFFFFF,false
cksum_minix
algorithm:
cksum algorithm on Minix 3.2.0 and earlier
length:
32 bits
type:
checksum
comment:
This is the Minix cksum implementation until Minix 3.2.0.
It cannot be described by the Rocksoft-Model, because the
algorithm uses a modified update method. It also differs to the
common cksum algorithm, because it doesn't corporate the message
length into the crc and it also uses a different polynomial.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- HP-UX: -
- IBM AIX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix 3.2.0: /usr/bin/cksum
- Minix 3.2.1+: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- PHP: -
- Plan 9: -
- Python: -
- Solaris: -
- Tru64: -
- Windows: -
since:
Jacksum 3.0.0
crc:<params>
algorithm:
CRC (generic)
length:
8..64 bits
type:
CRC
comment:
With this generic CRC you can specify all CRC-algorithms which
can be described by the famous
"Rocksoft (tm) Model CRC Algorithm".
The default encoding is decimal.
<params> must have at least 6 values, which have
to be separated by a comma. The required
params 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
Normally here ends the parameter list for the "Rocksoft (tm)
Model CRC Algorithm" schema. However, the Jacksum project
supports two additional parameters which can be optionally
specified in order to take the fact into account that some
famous CRCs (such as POSIX cksum, the FDDI CRC resp. the Plan 9
sum) include the length of the file to the checksum value.
Those are the parameters which can be separated by a comma:
incLen
this is a boolean parameter. It is optional. If it is
omitted, no length is included to the CRC. If it is
set, one or more octets representing the length of the
file as a binary value, will be used to include the
length of the file to the checksum value (before the
refOut). If it is set to true, the most significant
octet of the length will be processed first to the
update method of the CRC. If it is set to false, the
least significant octet of the length will be processed
first to the update method of the CRC.
xorLen
this value is XORed to the length value before it gets
included to the CRC. Specify xorLen as hex. If xorLen
is omitted, the smallest number of octets capable of
representing the length of the file are being
processed. If xorLen is set, the exact number of bytes
are being processed that are required to store the
xorLen value.
since:
Available since Jacksum 1.7.0,
incLen and xorLen since Jacksum 3.0.0
crc8, crc-8
algorithm:
CRC-8
length:
8 bits
type:
CRC
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 is x^8 + x^2 + x^1 + 1.
The default encoding is decimal.
since:
Jacksum 1.6.0
implementation:
implementation:
8,7,0,false,false,0
crc16, crc-16
algorithm:
CRC-16 (ARC)
length:
16 bits
type:
CRC
comment:
this implementation of the CRC-16 (cyclic redundancy check) is
the most popular form of CRC-16 algorithms.
The generator poly is x^16 + x^15 + x^2 + 1.
It is used by LHA, and ARC for example.
The default encoding is decimal.
since:
Jacksum 1.2.0
implementation:
crc:16,8005,0,true,true,0
crc16_x25, crc-16_x-25, fcs16, fcs-16
algorithm:
CRC-16 (Frame Checking Sequence)
length:
16 bits
type:
CRC
comment:
The Frame Checking Sequence as defined in RFC1331.
The default encoding is decimal.
since:
Jacksum 1.5.0 (aliases _x25 and _x-25 since 1.7.0)
implementation:
crc:16,1021,FFFF,true,true,FFFF
crc16_minix, crc-16_minix
algorithm:
Minix' crc
length:
16 bits
type:
checksum
comment:
this is the Minix' crc algorithm. It cannot be entirely
described by the Rocksoft-Model, because it uses a non-standard
update method which won't be fixed due to compatibility reasons.
See also https://jacksum.net/downloads/minix-bug-151.txt
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix 1.3+: /usr/bin/crc
- MS-DOS: -
- NetBSD: -
- NextStep: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Tru64: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
based on crc:16,1021,0,false,false,0
crc24, crc-24
algorithm:
CRC-24
length:
24 bits
type:
CRC
comment:
this implementation of the CRC-24 (cyclic redundancy check) is
used by Open PGP for example (RFC 2440).
The default encoding is decimal.
since:
Jacksum 1.6.0
implementation:
crc:24,864CFB,B704CE,false,false,0
crc32, crc-32, fcs32, fcs-32
algorithm:
CRC-32
length:
32 bits
type:
CRC
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 and WEP. That algorithm is
also known as FCS (frame checking sequence).
The default encoding is decimal.
compatibility:
- 7z (hex only): 7z h -scrccrc32
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: /usr/bin/cksum -o 3
- FreeBSD: /usr/bin/cksum -o 3
- FreeDOS: \FDOS\BIN\MD5SUM /M=crc32
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: java.util.zip.CRC32
- Kali Linux: -
- Mac OS X: /usr/bin/cksum -o 3
- macOS 10.12+: /usr/bin/cksum -o 3
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("crc32b", $input);
- Plan 9: -
- PowerShell: -
- Python: zlib.crc32
- Solaris: -
- Tcl: crc::crc32
- Windows: -
since:
Jacksum 1.0.0, alias crc-32 since 1.2.0, aliases fcs32 and
fcs-32 since 1.5.0
implementation:
java.util.zip.CRC32 as provided by the JDK or
net.jacksum.algorithms.crcs.FCS32 (if option -A is set) which
basically is an optimized version of
crc:32,04C11DB7,FFFFFFFF,true,true,FFFFFFFF
crc32c, crc-32c
algorithm:
CRC-32c (iSCSI)
length:
32 bits
type:
CRC
comment:
known as "Castagnoli CRC-32", see RFC 7143, section 13.1
(Internet Small Computer System Interface (iSCSI) Protocol):
Guy Castagnoli, Stefan Braeuer, Martin Herrmann,
"Optimization of Cyclic Redundancy-Check Codes with 24 and 32
Parity Bits", IEEE Transact. on Communications, Vol. 41,
No. 6, June 1993.
The default encoding is decimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP 7.4.0+: hash("crc32c", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
crc:32,1EDC6F41,FFFFFFFF,true,true,FFFFFFFF
crc32_bzip2, crc-32_bzip-2
algorithm:
CRC-32 (bzip2)
length:
32 bits
type:
CRC
comment:
This CRC is used by bzip2. The default encoding is decimal.
since:
Jacksum 1.7.0
implementation:
crc:32,04C11DB7,FFFFFFFF,false,false,FFFFFFFF
crc32_mpeg2, crc-32_mpeg-2
algorithm:
CRC-32 (MPEG-2)
length:
32 bits
type:
CRC
comment:
this algorithm implements the MPEG specification of the CRC-32
calculation. The default encoding is decimal.
since:
Jacksum 1.4.0
implementation:
crc:32,04C11DB7,FFFFFFFF,false,false,0
crc32_php, crc-32_php
algorithm:
CRC-32 (PHP's crc32)
length:
32 bits
typ:
CRC
comment:
PHP's crc32. This is actually the CRC-32 that is also used by
bzip2, but the 4 bytes for the output are being mirrored.
Accordingly, this CRC cannot be described by the Rocksoft Model
CRC Algorithm scheme. The default encoding is decimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("crc32", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
crc:32,04C11DB7,FFFFFFFF,false,false,FFFFFFFF
using reflected bytes for the output
crc32_ubi, crc-32_ubi, ubicrc32
algorithm:
CRC-32 (UBICRC32)
length:
32 bits
type:
CRC
comment:
ubicrc32 is part of the Memory Technology Device Utilities for
Linux (mtd-utils). UBI (Latin: "where?") stands for "Unsorted
Block Images". The default encoding is decimal. Specify -E hex
in order to get the hex output that the ubicrc32
tool produces.
compatibility:
- 7z: -
- Angstrom: /usr/bin/ubicrc32
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: /usr/bin/ubicrc32
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu (+mtd-utils): /usr/sbin/ubicrc32
- Windows: -
since:
Jacksum 3.0.0
implementation:
crc:32,04C11DB7,FFFFFFFF,true,true,0
crc64, crc-64
algorithm:
CRC-64 (ISO 3309)
length:
64 bits
type:
CRC
comment:
this algorithm is described in the ISO 3309 standard and used in
HDLC. Generator poly is x^64 + x^4 + x^3 + x + 1.
The default encoding is hexadecimal.
since:
Jacksum 1.5.0
implementation:
crc:64,1B,0,true,true,0 -E hex
crc64_ecma, crc-64_ecma
algorithm:
CRC-64 (ECMA-182)
length:
64 Bits
type:
CRC
published:
1992
standard:
EMCA-182
comment:
CRC-64 as defined by the ECMA (European Computer Manufacturers
Association) in the standard ECMA-182, Annex B, page 51.
Used in DLT-1 tape cartridges, see also
https://www.ecma-international.org/publications/
files/ECMA-ST/Ecma-182.pdf
since:
Jacksum 3.0.0
implementation:
crc:64,42f0e1eba9ea3693,0,false,false,0 -E hex
crc64_go-iso, crc-64_go-iso
algorithm:
CRC-64 (programming langugae GO, const ISO)
length:
64 Bits
type:
CRC
comment:
Used in the crc64 package from the programming language GO.
See also https://golang.org/pkg/hash/crc64/
The poly is defined in ISO 3309, but for the algorithm in GO,
only the polynomial is used from the ISO 3309. The crc
parameters init, refin, refout, and xorOut are different.
since:
Jacksum 3.0.0
implementation:
crc:64,1b,ffffffffffffffff,true,true,ffffffffffffffff -E hex
crc64_xz, crc-64_xz, crc64_go-ecma, crc-64_go-ecma
algorithm:
CRC-64 (.xz, and prog lang GO, const ECMA)
length:
64 Bits
type:
CRC
comment:
Used in the .xz format. See also the xz format specification,
section 6: https://tukaani.org/xz/xz-file-format.txt
Also used in the crc64 package from the programming language GO,
const ECMA See also https://golang.org/pkg/hash/crc64/
The poly is defined in ISO 3309, but for the algorithm in GO,
only the polynomial is used from the ISO 3309. The crc
parameters init, refin, refout, and xorOut are different.
compatibility:
- 7z: 7z h -scrccrc64
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
crc:64,42f0e1eba9ea3693,ffffffffffffffff,true,true,ffffffffffffffff -E hex
dha256, dha-256
algorithm:
DHA-256
length:
256 bits
type:
cryptographic hash function
published:
11/2005
broken:
no
website:
http://www.nist.gov/hash-function (archived)
http://csrc.nist.gov/groups/ST/hash/documents/ChangD_DHA256.pdf
comment:
In response to the SHA-1 vulnerability that was announced in
Feb. 2005, NIST held a Cryptographic Hash Workshop on
Oct. 31-Nov. 1, 2005 to solicit public input on its
cryptographic hash function policy and standards. DHA-256 was
presented on Nov 1, 2005 by south korean scientists at this
first NIST Hash Workshop. The NIST conducted also a second
workshop. However, NIST did not select an algorithm immediately,
but held a public competition from 2007 to 2012
(SHA-3 Competition) to find a successor for SHA-1 and the
SHA-2 family.
since:
Jacksum 3.0.0
implementation:
de.flexiprovider.core.md.DHA256
echo<w>, echo-<w>
algorithm:
ECHO
length:
224, 384, 256 or 512 bits
type:
cryptographic hash function
published:
2008
broken:
no
wbesite:
https://crypto.orange-labs.fr/ECHO/
comment:
ECHO is one of 14 hash functions that had made it into the
second round of the NIST SHA-3 competition (2007-2012).
ECHO was submitted by France Telecom (it was rebranded as Orange
S.A. in July 2013). ECHO did not pass the final (3rd) round of
the NIST SHA-3 competition, but it is not broken.
This is the latest implementation according to
the second round of the NIST SHA-3 competition.
ECHO must not be confused with ECOH, because ECOH is also a hash
function that was submitted to the SHA-3 competition, but did
not advance to round 2.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.ECHO<w>
elf, elf32, elf-32
algorithm:
ELF
length:
32 bits
type:
hash function
comment:
hash function used in the UNIX (System V Release 4) ELF
(Executable and Linkable Format) for object files.
The default encoding is decimal.
since:
Jacksum 1.5.0
implementation:
net.jacksum.algorithm
ed2k, emule, edonkey
algorithm:
eMule/eDonkey
length:
128 bits
type:
cryptographic hash function
broken:
no
comment:
this algorithm is used in eDonkey resp. eMule, it is based on
MD4, but returns different fingerprints for files >= 9500 KB.
The default encoding is hexadecimal.
since:
Jacksum 1.5.0
implementation:
net.jacksum.algorithm
fletcher16, fletcher-16
algorithm:
Fletcher's checksum
length:
16 bits
type:
checksum
published:
01/1982
comment:
published 1982 by John G. Fletcher (1934-2012). The binary
transmitted message is divided into sections of length K, for
Fletcher-16 is K=8, so Fletcher-16 independent of the
endianness, i. e. independent from the byte order of the input
stream to of the executed hardware. The modulus of the
calculation is M and M is in this implementation set to
2^K-1=255 for K=8.
The original work of John G. Fletcher examines only the case
K=8 with modulus 255 and 256.
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.Fletcher16
fnv-0_<w>
algorithm:
FNV-0
length:
32, 64, 128, 256, 512 or 1024 bits
type:
non-cryptographic hash function
published:
1991
comment:
Fowler-Noll-Vo is a non-cryptographic hash function created by
Glenn Fowler, Landon Curt Noll, and Phong Vo.
The FNV-0 is the historic FNV algorithm that is deprecated.
The FNV-0 hashes all buffers that contain only 0 octets to a
hash value of 0. The FNV-1 and FNV-1a hash do not suffer from
this minor problem. The output width <w> can vary from 32 bits
to 1024 bits.
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.Fnv0_32 and Fnv0_n
fnv-1_<w>
algorithm:
FNV-1
length:
32, 64, 128, 256, 512 or 1024 bits
type:
non-cryptographic hash function
published:
1991
comment:
Fowler-Noll-Vo is a non-cryptographic hash function created by
Glenn Fowler, Landon Curt Noll, and Phong Vo.
The output width <w> can vary from 32 bits to 1024 bits.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP 5.4.0+: hash("fnv132", $input);
hash("fnv164", $input);
- Plan 9: -
- Solaris: -
- Windows: -
- OpenSSL: -
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.Fnv1_32 and Fnv1_n
fnv-1a_<w>
algorithm:
FNV-1a
length:
32, 64, 128, 256, 512 or 1024 bits
type:
non-cryptographic hash function
published:
1991
comment:
Fowler-Noll-Vo alternate is a non-cryptographic hash function
created by Glenn Fowler, Landon Curt Noll, and Phong Vo.
The only difference between the FNV-1a hash and the FNV-1 hash
is the order of the xor and multiply in the update method.
The output width <w> can vary from 32 bits to 1024 bits.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- eComStation: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("fnv1a32", $input);
hash("fnv1a64", $input);
- Plan 9: -
- Solaris: -
- Windows: -
- OpenSSL: -
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.Fnv1a_32 and Fnv1a_n
fork256, fork-256
algorithm:
FORK-256
length:
256 bits
type:
cryptographic hash function
published:
11/2005
broken:
yes
webseite:
http://www.nist.gov/hash-function (archived)
http://www.csrc.nist.gov/pki/HashWorkshop/2005/Nov1_Presentations/Sung_FORK-256.pdf
http://dx.doi.org/10.1007/11799313_13
\
comment:
In response to the SHA-1 vulnerability that was announced in
Feb. 2005, NIST held a Cryptographic Hash Workshop on
Oct. 31-Nov. 1, 2005 to solicit public input on its cryptographic
hash function policy and standards. FORK-256 was presented on
Nov 1, 2005 at this first NIST Hash Workshop. The NIST conducted
also a second workshop. However, NIST did not select an algorithm
immediately, but held a public competition from 2007 to 2012
(SHA-3 Competition) to find a successor for SHA-1 and the SHA-2
family. Between 2006 and 2007 attacks on FORK-256 have been
published and in response the authors improved FORK-256 under the
name "New FORK-256". But also this one was discovered to be broken
in 2007.
\
since:
Jacksum 3.0.0
implementation:
de.flexiprovider.core.md.FORK256
fugue<w>, fugue-<w>
algorithm:
Fugue
length:
224, 384, 256 or 512 bits
type:
cryptographic hash function
published:
2008
broken:
no
website:
https://researcher.watson.ibm.com/researcher/view_group.php?id=3253
comment:
Fugue is one of 14 hash functions that had made it into the
second round of the NIST SHA-3 competition (2007-2012). Fugue
was submitted by IBM.
Fugue did not pass the final (3rd) round of the NIST SHA-3
competition, but it is not broken. This is the latest
implementation according to the second round of the NIST SHA-3
competition.
IBM improved the algorithm further and it is called Fugue 2.0
which is currently not supported by Jacksum.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.Fugue<w>
gost[:init]
algorithm:
GOST R 34.11-94
length:
256 bits
type:
cryptographic hash function
published:
1994
broken:
2008, see also http://dx.doi.org/10.1007/978-3-540-85174-5_10
standard:
GOST R 34.11-94
comment:
"GOsudarstvennyi STandard", Russian for "Government Standard".
Published in 1994 as the Soviet Standard GOST R-34.11-94.
The default encoding is hexadecimal.
The hash function is based on the GOST block cipher
GOST 28147-89. If you don't specify init or if you set initto
"default" it will initialize the underlying cipher with the
default S-boxes as also described in RFC 5831 (March 2010).
If you set init to "crypto-pro" it will initialize the cipher
with the S-Boxes as suggested by the Crypto-Pro company in
January 2006 as described in RFC 4357.
For the GOST-Standard from 2012 see streebog.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- eComStation: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -md_gost94
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("gost", $input);
- PHP 5.6.0+: hash("gost-crypto", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0, init available since Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.GOST3411Digest
groestl<w>, groestl-<w>
algorithm:
Groestl
length:
224, 384, 256 oder 512 Bits
type:
cryptographic hash function
published:
01/2011
broken:
no
website:
http://www.groestl.info/
comment:
Groestl is one of the five hash functions that had made it into
the final round of the NIST SHA-3 competition (2007-2012). This
is the implementation according to the third and final round of
the NIST SHA-3 Competition.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.Groestl<w>
has160, has-160
algoritm:
HAS-160
length:
160 bits
type:
cryptographic hash function
published:
2000
broken:
no
comment:
HAS-160 is both a cryptographic hash function and a korean
TTA-Standard (Telecommunications and Technology Association).
The default encoding is hexadecimal.
since:
Jacksum 1.7.0
implementation:
gnu.crypto.hash.Has160 (by jonelo)
haval, haval_<w>_<r>
algorithm:
HAVAL
length:
128, 160, 192, 224 or 256 bits
type:
cryptographic hash function
published:
1992
broken:
2004, but 128 bits only,
see https://eprint.iacr.org/2004/199.pdf
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 <w> 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.
The default encoding is hexadecimal.
compatibility:
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- PHP: hash("haval<w>,<r>", $input);
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.4.0
implementation:
gnu.crypto.hash.Haval
jh<w>, jh-<w>
algorithm:
JH
length:
224, 384, 256 oder 512 bits
type:
cryptographic hash function
published:
01/2011
broken:
no
wbesite:
https://www3.ntu.edu.sg/home/wuhj/research/jh/
comment:
JH is one of the five hash functions that had made it into the
final round of the NIST SHA-3 competition (2007-2012). This is
the implementation according to the third and final round of the
NIST SHA-3 Competition. Author of JH is Hongjun Wu from
Singapore.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.JH<w>
joaat, joaat32, joaat-32
algorithm:
Bob Jenkins' One-at-a-Time Hash (joaat)
length:
32 Bits
type:
non-cryptographic hash function
published:
1997
website:
http://www.burtleburtle.net/bob/hash/doobs.html
comment:
Developed by Robert John Jenkins Junior (Bob Jenkins).
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- PHP 5.4.0+: hash("joaat", $input);
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.checksums.Joaat32
k12, kangaroo12, kangarootwelve
algorithm:
KangarooTwelve
length:
256 bits
type:
XOF as a cryptographic hash function with a fixed length
published:
04/2018
broken:
no
website:
https://keccak.team/kangarootwelve.html
comment:
KangarooTwelve is a extendable-output function (XOF) which
supports arbitrary output lengths. It is derived from the Keccak
algorithm and it has a 128-bit security strength like SHAKE128.
A XOF can be specialized to a hash function by selecting a
fixed output length.
Jacksum restricts the set of the supported value for the output
length to 256 bits in order to define a reasonable hash
function.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- FreeBSD 10.4+: -
- FreeDOS: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: -
- Kali Linux: -
- KeccakSum: KeccakSum --k12 --hex --outputbits 256
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: -
- PHP 7.1+: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.Kangaroo
m14, marsupilami14, marsupilamifourteen
algorithm:
MarsupilamiFourteen
length:
512 bits
type:
XOF as a cryptographic hash function with a fixed length
published:
04/2018
broken:
no
website:
https://keccak.team/kangarootwelve.html
comment:
MarsupilamiFourteen is a extendable-output function (XOF) which
supports arbitrary output lengths. It is derived from the Keccak
algorithm and it has a 256-bit security strength like SHAKE256.
A XOF can be specialized to a hash function by selecting a
fixed output length.
Jacksum restricts the set of the supported value for the output
length to 512 bits in order to define a reasonable hash
function.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- FreeBSD 10.4+: -
- FreeDOS: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: -
- Kali Linux: -
- KeccakSum: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: -
- PHP 7.1+: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.Kangaroo
keccak<w>, keccak-<w>
algorithm:
Keccak
length:
224, 256, 288, 384, or 512 bits
type:
cryptographic hash function
published:
2012
broken:
no
website:
https://keccak.team/
comment:
Keccak (pronounced like "ketchak") was designed by Guido
Bertoni, Joan Daemen, Michael Peeters, and Gilles Van Assche.
Keccak is based on earlier hash function designs PANAMA and
RadioGatún.
On October 2, 2012, Keccak was selected as the winner of the
NIST hash function competition.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.Keccak<w>
kupyna-<w>
algorithm:
Kupyna
length:
256, 384, or 512 bits
type:
cryptographic hash function
published:
2015
broken:
no
standard:
DSTU 7564:2014
comment:
The Kupyna hash function was approved as the new Ukrainian
standard DSTU 7564:2014 in 2015.
since:
Jacksum 3.0.0
lsh-<b>-<w>
algorithm:
LSH (Lightweight Secure Hash)
length:
the actual output length <w> is dependent on the <b> value.
<b> can become 256 or 512.
If <b> is 256, <w> can become 224 or 256.
If <b> is 512, <w> can become 224, 256, 384, or 512.
type:
cryptographic hash
published:
2014
broken:
no
website:
https://seed.kisa.or.kr/kisa/Board/22/detailView.do
standard:
KS X 3262
comment:
LSH is a national standard of South Korea (KS X 3262).
since:
Jacksum 3.0.0
implementation:
kr.re.nsr.crypto
luffa<w>, luffa-<w>
algorithm:
Luffa v2.0.1
length:
224, 384, 256 or 512 bits
type:
cryptographic hash function
published:
10/2009
broken:
no
website:
https://www.hitachi.com/rd/yrl/crypto/luffa/
comment:
Luffa is one of 14 hash functions that had made it into the
second round of the NIST SHA-3 competition (2007-2012). Luffa
was submitted by Hitachi (and others).
Luffa did not pass the final (3rd) round of the NIST SHA-3
competition, but it is not broken.
This is the latest implementation according to the second round
of the NIST SHA-3 competition.
(Luffa specification ver. 2.0.1 from Oct 2, 2009)
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.Luffa<w>
md2, md2sum
algorithm:
MD2
length:
128 bits
type:
cryptographic hash function
published:
1998
broken:
yes
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. The default encoding is hexadecimal.
Use option "--compat openssl" to get the openssl output format.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java 5+: java.security.MessageDigest.
MessageDigest.getInstance("MD2");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix 3.2.1+: /usr/bin/md2
/usr/bin/sum -a md2
/usr/bin/cksum -a md2
- NetBSD: /usr/bin/md2
- NetBSD 9.2+: /usr/bin/md2
/usr/bin/sum -a md2
/usr/bin/cksum -a md2
- PHP 5.3.0+: hash("md2", $input);
- MS-DOS: -
- NetBSD: /usr/bin/md2
- NextStep: -
- OpenSSL: openssl dgst -md2
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows 7+: certutil -hashfile <file> MD2
since:
Jacksum 1.2.0
implementation:
gnu.crypto.hash.MD2
md4, md4sum
algorithm:
MD4
length:
128 bits
type:
cryptographic hash function
published:
1990
broken:
yes
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.
The default encoding is hexadecimal.
Use option "--compat openssl" to get the openssl output format.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -md4
- Mac OS X: -
- macOS 10.12+: -
- Minix 3.2.1+: /usr/bin/md4
/usr/bin/sum -a md4
/usr/bin/cksum -a md4
- MS-DOS: -
- NetBSD: /usr/bin/md4
- NetBSD 9.2+: /usr/bin/md4
/usr/bin/sum -a md4
/usr/bin/cksum -a md4
- NextStep: -
- OpenSSL: openssl dgst -md4
- PHP: hash("md4", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris 11 Express:
/usr/bin/sum --method=md4
- Windows 7+: certutil -hashfile <file> MD4
since:
Jacksum 1.2.0
implementation:
gnu.crypto.hash.MD4
md5, md5sum
algorithm:
MD5
length:
128 bits
type:
cryptographic hash function
published:
1991
broken:
yes
comment:
The MD5 message digest algorithm was designed by Ronald Rivest
in 1991, and it is defined in RFC 1321.
The default encoding is hexadecimal.
Use -F "(#FILENAME) = #DIGEST" to get the Solaris format.
Use -F "MD5(#FILENAME) = #DIGEST" to get the openssl format.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/md5sum
- Angstrom: /usr/bin/md5sum
- BeOS: /bin/md5sum
- CentOS: /bin/md5sum
- DragonFly BSD: /sbin/md5
- eComStation: C:\ecs\KLIBC\bin\md5sum
- FreeBSD: /sbin/md5
- FreeDOS: \FDOS\BIN\MD5SUM [/M=md5]
- GNU/Hurd: /usr/bin/md5sum
- GNU/Linux: /usr/bin/md5sum
- gpg: -
- Haiku: /bin/md5sum
- HP-UX: -
- Java: java.security.MessageDigest.
MessageDigest.getInstance("MD5");
- Kali Linux: /usr/bin/md5sum
- LibreSSL: openssl dgst -md5
- Mac OS X: /usr/bin/md5
- macOS 10.12+: /usr/bin/md5
- Minix 3.2.1+: /usr/bin/md5
/usr/bin/sum -a md5
/usr/bin/cksum -a md5
- MS-DOS: -
- NetBSD: /usr/bin/md5
- NetBSD 9.2+: /usr/bin/md5
/usr/bin/sum -a md5
/usr/bin/cksum -a md5
- NextStep: -
- OpenSSL: openssl dgst -md5
- PHP: hash("md5", $input);
- Plan 9: /bin/md5sum
- PowerShell: -
- Python 2.5+: hashlib.md5()
- PowerShell: Get-FileHash -Algorithm MD5
- Solaris 9: /usr/sbin/md5 (package SUNWkeymg)
- Solaris 10+: /usr/bin/digest -a md5
- Solaris 11 Express:
/usr/bin/sum --method=md5
/usr/bin/md5sum
- Windows 7+: certutil -hashfile <file> MD5
- Visopsys: /programs/md5
since:
Jacksum 1.0.0
implementation:
java.security.MessageDigest. gnu.crypto.hash.MD5 is the
alternate implementation and it will be used if you have set the
option -A.
mdc2, mdc-2
algorithm:
MDC-2
length:
128 bits
type:
crytpographic hash function
published:
1987
broken:
yes
comment:
The MDC2 (Modification Detection Code 2) algorithm is specified
in the ANSI X9.31 and ISO/IEC 10118-2 standards. It works in
conjunction with a block clipher (DES). OpenSSL can be
configured to support MDC2. MDC2 is also used by the HBCI
(Home Banking Computer Interface). The U.S. Patent 4,908,861
submitted by IBM, expired on August 28, 2007. The default
encoding is hexadecimal.
Use option "--compat openssl" to get the openssl output format.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: openssl dgst -mdc2
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.kapott.hbci.security.MDC2
none
algorithm:
none
length:
0 bits
type:
n/a
comment:
Calculates no checksum, it does not read the content of files,
it just determines the file size and time stamp if required.
since:
Jacksum 1.6.0
implementation:
net.jacksum.algorithm
panama
algorithm:
PANAMA
length:
256 bits
type:
cryptographic hash function
published:
1998
broken:
yes
comment:
PANAMA was designed by Joan Daemen (Belgium) and Craig Clapp
(USA) and presented in the paper "Fast Hashing and Stream
Encryption with PANAMA" on the 5th Fast Software Encryption
(FSE) conference at Paris, France in 1998.
RadioGatún is the successor of PANAMA.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.PANAMA
radiogatun[:<wordlen>]
algorithm:
RadioGatun[32] and RadioGatun[64]
length:
256 bits
type:
cryptographic hash function
published:
2006
broken:
no
website:
http://radiogatun.noekeon.org/
comment:
RadioGatun was designed by Guido Bertoni, Joan Daemen,
Michael Peeters and Gilles Van Assche and presented at the
Second Cryptographic Hash Workshop, Santa Barbara, CA, USA in
August 2006.
In theory <wordlen> can become 1 to 64. However only 32 and 64
bits are implemented actually.
The <wordlen> is optional, so radiogatun or radiogatun:64
selects the RadioGatun[64] algorithm with 64-bit words.
Keccak is the successor of RadioGatún.
since:
Jacksum 3.0.0
implementation:
fr.cryptohash.RadioGatun32 and fr.cryptohash.RadioGatun64
read
algorithm:
read
length:
0 bits
type:
n/a
comment:
Calculates no checksum, but it does read the content of files,
it also determines the file size and time stamp if required.
since:
Jacksum 1.6.0
implementation:
net.jacksum.algorithm
rmd128, rmd-128, ripemd128, ripemd-128, ripe-md128
algorithm:
RIPEMD-128
length:
128 bits
type:
cryptographic hash function
published:
1996
broken:
2004, https://eprint.iacr.org/2004/199.pdf
comment:
a message digest, see also RIPEMD-160.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("ripemd128", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.2.0, alias rmd128 and rmd-128 since 1.4.0
implementation:
gnu.crypto.hash.RipeMD128
rmd160, rmd-160, ripemd160, ripemd-160, ripe-md160
algorithm:
RIPEMD-160
length:
160 bits
type:
cryptographic hash function
published:
1996
broken:
no
comment:
RIPEMD was developed in the framework of the EU project RIPE
(RACE Integrity Primitives Evaluation), used by GnuPG.
The default encoding is hexadecimal.
Use option "--compat openssl" to get the openssl output format.
format.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: /sbin/rmd160
- FreeBSD 5.3+: /sbin/rmd160
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: gpg --print-md ripemd160
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -ripemd160
- Mac OS X: -
- macOS 10.12+: -
- Minix 3.2.1+: /usr/bin/rmd160
/usr/bin/sum -a rmd160
/usr/bin/cksum -a rmd160
- MS-DOS: -
- NetBSD: /usr/bin/rmd160
- NetBSD 9.2+: /usr/bin/rmd160
/usr/bin/sum -a rmd160
/usr/bin/cksum -a rmd160
- NextStep: -
- OpenSSL: openssl dgst -rmd160
openssl dgst -ripemd
openssl dgst -ripemd160
- PHP: hash("ripemd160", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.2.0, alias rmd160 and rmd-160 since 1.4.0
implementation:
gnu.crypto.hash.RipeMD160
rmd256, rmd-256, ripemd256, ripemd-256, ripe-md256
algorithm:
RIPEMD-256
length:
256 bits
type:
cryptographic hash function
published:
1996
broken:
no
comment:
a message digest, see also RIPEMD-160. RIPEMD-256 is as secure
as RIPEMD-128. The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP 5.3.0+: hash("ripemd256", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
org.bouncycastle.crypto.digests
rmd320, rmd-320, ripemd320, ripemd-320, ripe-md320
algorithm:
RIPEMD-320
length:
128 bits
type:
hash
published:
1996
broken:
no
comment:
a message digest, see also RIPEMD-160. RIPEMD-320 is as secure
as RIPEMD-160. The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP 5.3.0+: hash("ripemd320", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
org.bouncycastle.crypto.digests
sha0, sha-0
algorithm:
SHA-0
length:
160 bits
type:
cryptographic hash function
published:
1993
broken:
2004
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".
The default encoding is hexadecimal.
Use option "--compat openssl" to get the openssl output format.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -sha
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: openssl dgst -sha
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Sha0 (by jonelo)
sha, sha1, sha1sum, sha-1, sha160, sha-160, dssl
algorithm:
SHA-1
length:
160 bits
type:
cryptographic hash function
published:
1995
broken:
02/2017, see also https://shattered.io
standard:
NIST FIPS 180-1
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).
The default encoding is hexadecimal.
Use -F "(#FILENAME) = #DIGEST" to get the Solaris format.
Use -F "SHA1(#FILENAME) = #DIGEST" to get the openssl format.
The alias called dss1 (Digital Subscriber Signalling System
No. 1) is used by OpenSSL.
compatibility:
- 7z: 7z h -scrcsha1
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sha1sum
/usr/bin/shasum [-a 1]
- Angstrom: -
- BeOS: -
- CentOS: /bin/sha1sum
- DragonFly BSD: /sbin/sha1
- eComStation: C:\ecs\KLIBC\bin\sha1sum
- FreeBSD: /sbin/sha1
- FreeDOS: \FDOS\BIN\MD5SUM /M=sha
- GNU/Hurd: /usr/bin/sha1sum
/usr/bin/shasum [-a 1]
- GNU/Linux: /usr/bin/sha1sum
/usr/bin/shasum [-a 1]
(not available on every Linux)
- gpg: gpg --print-md sha1
- Haiku: /bin/sha1sum
- HP-UX: -
- IBM AIX: -
- Java: java.security.MessageDigest.
MessageDigest.getInstance("SHA-1");
- Kali Linux: /usr/bin/sha1sum
/usr/bin/shasum [-a 1]
- LibreSSL: openssl dgst -sha1
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum [-a 1]
- Minix 3.2.1+: /usr/bin/sha1
/usr/bin/sum -a sha1
/usr/bin/cksum -a sha1
- MS-DOS: -
- NetBSD: /usr/bin/sha1
- NetBSD 9.2+: /usr/bin/sha1
/usr/bin/sum -a sha1
/usr/bin/cksum -a sha1
- NextStep: -
- OpenSSL: openssl dgst -sha1
- PHP: hash("sha1", $input);
- Plan 9: /bin/sha1sum
- PowerShell: Get-FileHash -Algorithm SHA1
- Python 2.5+: hashlib.sha1()
- Solaris 10+: /usr/bin/digest -a sha1
- Solaris 11 Express:
/usr/bin/sum --method=sha1
/usr/bin/sha1sum
- Windows 7+: certutil -hashfile <file> SHA1
since:
Jacksum 1.0.0, alias sha-1 since 1.2.0, aliases sha160 and
sha-160 since 1.5.0, aliases dss1 and sha1sum since 2.0.0,
default algorithm since 1.5.0 for the Jacksum 1.x family.
implementation:
java.security.MessageDigest as provided by the JRE.
gnu.crypto.hash.Sha160 is the alternate implementation and it
will be used if you have specified the option -A.
sha224, sha-224
algorithm:
SHA-224
length:
224 bits
type:
cryptographic hash function
published:
2004
broken:
no
standard:
NIST FIPS 180-2
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.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sha224sum
/usr/bin/shasum -a 224
- Angstrom: -
- BeOS: -
- CentOS: /bin/sha224sum
- DragonFly BSD: -
- FreeBSD 12+: /sbin/sha224
- FreeDOS: -
- GNU/Hurd: /usr/bin/sha224sum
/usr/bin/shasum -a 224
- GNU/Linux: /usr/bin/sha224sum
(not available on every Linux)
/usr/bin/shasum -a 224
(not available on every Linux)
- gpg: gpg --print-md sha224
- HP-UX: -
- Java: -
- Kali Linux: /usr/bin/sha224sum
/usr/bin/shasum -a 224
- LibreSSL: openssl dgst -sha224
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 224
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: openssl dgst -sha224
- PHP: hash("sha224", $input);
- Plan 9: -
- PowerShell: -
- Python 2.5+: hashlib.sha224()
- Solaris 10+: -
- Solaris 11.2+: /usr/bin/sha224sum
- Solaris 11 Express: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Sha224 (by jonelo)
sha256, sha-256
algorithm:
SHA-256
length:
256 bits
type:
cryptographic hash function
published:
2001
broken:
no
standard:
NIST FIPS 180-2
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). SHA-256 can be optionally
used by the file system called ZFS.
The default encoding is hexadecimal.
Use -F "(#FILENAME) = #DIGEST" to get the Solaris format.
compatibility:
- 7z: 7z h -scrcsha256
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sha256sum
/usr/bin/shasum -a 256
- Angstrom: -
- BeOS: -
- CentOS: /bin/sha256sum
- DragonFly BSD: /sbin/sha256
- FreeBSD 6+: /sbin/sha256
- FreeDOS: -
- GNU/Hurd: /usr/bin/sha256sum
/usr/bin/shasum -a 256
- GNU/Linux: /usr/bin/sha256sum
(not available on every Linux)
/usr/bin/shasum -a 256
(not available on every Linux)
- gpg: gpg --print-md sha256
- HP-UX: -
- Java: java.security.MessageDigest.
MessageDigest.getInstance("SHA-256");
- Kali Linux: /usr/bin/sha256sum
/usr/bin/shasum -a 256
- LibreSSL: openssl dgst -sha256
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 256
- Minix 3.2.1+: /usr/bin/sum -a sha256
/usr/bin/cksum -a sha256
- MS-DOS: -
- NetBSD 9.2+: /usr/bin/sum -a sha256
/usr/bin/cksum -a sha256
- NextStep: -
- OpenSSL: openssl dgst -sha256
- PHP: hash("sha256", $input);
- Plan 9: -
- PowerShell: Get-FileHash -Algorithm SHA256
- Python 2.5+: hashlib.sha256()
- Solaris 10+: /usr/bin/digest -a sha256
- Solaris 11.2+: /usr/bin/sha256sum
- Solaris 11 Express:
/usr/bin/sum --method=sha256
- Windows 7+: certutil -hashfile <file> SHA256
since:
Jacksum 1.3.0
implementation:
java.security.MessageDigest as provided by the JRE.
gnu.crypto.hash.Sha256 is an alternate implementation and it is
used if you have specified option -A.
sha384, sha-384
algorithm:
SHA-384
length:
384 bits
type:
cryptographic hash function
published:
2001
broken:
no
standard:
NIST FIPS 180-2
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).
The default encoding is hexadecimal.
Use -F "(#FILENAME) = #DIGEST" to get the Solaris format.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sha384sum
/usr/bin/shasum -a 384
- Angstrom: -
- BeOS: -
- CentOS: /bin/sha384sum
- DragonFly BSD: -
- FreeBSD 11+: /sbin/sha384 (prob. earlier)
- FreeDOS: -
- GNU/Hurd: /usr/bin/sha384sum
/usr/bin/shasum -a 384
- GNU/Linux: /usr/bin/sha384sum
(not available on every Linux)
/usr/bin/shasum -a 384
(not available on every Linux)
- gpg: gpg --print-md sha384
- HP-UX: -
- Java: java.security.MessageDigest.
MessageDigest.getInstance("SHA-384");
- Kali Linux: /usr/bin/sha384sum
/usr/bin/shasum -a 384
- LibreSSL: openssl dgst -sha384
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 384
- Minix 3.2.1+: /usr/bin/sum -a sha384
/usr/bin/cksum -a sha384
- MS-DOS: -
- NetBSD 9.2+: /usr/bin/sum -a sha384
/usr/bin/cksum -a sha384
- NextStep: -
- OpenSSL: openssl dgst -sha384
- PHP: hash("sha384", $input);
- Plan 9: -
- PowerShell: Get-FileHash -Algorithm SHA384
- Python 2.5+: hashlib.sha384()
- Solaris 10+: /usr/bin/digest -a sha384
- Solaris 11.2+: /usr/bin/sha384sum
- Solaris 11 Express:
/usr/bin/sum --method=sha384
- Windows 7+: certutil -hashfile <file> SHA384
since:
Jacksum 1.3.0
implementation:
java.security.MessageDigest as provided by the JRE.
gnu.crypto.hash.Sha384 is an alternate implementation and it is
used if you have specified option -A.
sha512, sha-512
algorithm:
SHA-512
length:
512 bits
type:
cryptographic hash function
published:
2001
broken:
no
standard:
NIST FIPS 180-2
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).
The default encoding is hexadecimal.
Use -F "(#FILENAME) = #DIGEST" to get the Solaris format.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sha512sum
/usr/bin/shasum -a 512
- Angstrom: -
- BeOS: -
- CentOS: /bin/sha512sum
- DragonFly BSD: -
- FreeBSD 11+: /sbin/sha512 (probably also earlier)
- FreeDOS: -
- GNU/Hurd: /usr/bin/sha512sum
/usr/bin/shasum -a 512
- GNU/Linux: /usr/bin/sha512sum
(not available on every Linux)
/usr/bin/shasum -a 512
(not available on every Linux)
- gpg: gpg --print-md sha512
- HP-UX: -
- Java: java.security.MessageDigest.
MessageDigest.getInstance("SHA-512");
- Kali Linux: /usr/bin/sha512sum
/usr/bin/shasum -a 512
- LibreSSL: openssl dgst -sha512
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 512
- Minix 3.2.1+: /usr/bin/sum -a sha512
/usr/bin/cksum -a sha512
- MS-DOS: -
- NetBSD 9.2+: /usr/bin/sum -a sha512
/usr/bin/cksum -a sha512
- NextStep: -
- OpenSSL: openssl dgst -sha512
- PHP: hash("sha512", $input);
- Plan 9: -
- PowerShell: Get-FileHash -Algorithm SHA512
- Python 2.5+: hashlib.sha512()
- Solaris 10+: /usr/bin/digest -a sha512
- Solaris 11.2+: /usr/bin/sha512sum
- Solaris 11 Express:
/usr/bin/sum --method=sha512
- Windows 7+: certutil -hashfile <file> SHA512
since:
Jacksum 1.3.0
implementation:
java.security.MessageDigest as provided by the JRE.
gnu.crypto.hash.Sha512 is an alternate implementation and it is
used if you have specified option -A.
sha512/224, sha-512/224
algorithm:
SHA-512/224
length:
224 bits
type:
cryptographic hash function
published:
03/2012
broken:
no
standard:
NIST FIPS 180-4
comment:
In March 2012, the secure hash standard was updated in
FIPS PUB 180-4, adding the hash functions SHA-512/224.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/shasum -a 512224
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Linux: /usr/bin/shasum -a 512224
(not available on every Linux)
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA512/224");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 512224
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: openssl dgst -sha512-224
- PHP 7.1+: hash("sha512/224", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris 11.4+: /usr/bin/digest -a 512_t -t 224
- Ubuntu: /usr/bin/shasum -a 512224
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crytpo.digests.SHA512tDigest
sha512/256, sha-512/256
algorithm:
SHA-512/256
length:
256 bits
type:
cryptographic hash function
published:
03/2012
broken:
no
standard:
NIST FIPS 180-4
comment:
In March 2012, the secure hash standard was updated in
FIPS 180-4, adding the hash functions SHA-512/256.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/shasum -a 512256
- Angstrom: -
- BeOS: -
- CentOS: -
- FreeBSD 10.4+: /sbin/sha512t256
- FreeDOS: -
- GNU/Linux: /usr/bin/shasum -a 512256
(not available on every Linux)
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA512/256");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: /usr/bin/shasum -a 512256
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: openssl dgst -sha512-256
- PHP 7.1+: hash("sha512/256", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris 11.4+: /usr/bin/digest -a 512_t -t 256
- Ubuntu: /usr/bin/shasum -a 512256
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crytpo.digests.SHA512tDigest
sha3-224, sha-3-224
algorithm:
SHA-3
length:
224 bits
type:
cryptographic hash function
published:
08/2015
broken:
no
standard:
NIST FIPS 202 (SHA-3 Standard)
comment:
In 2007 NIST announced the competition called
"SHA-3 Cryptographic Hash Algorithm Competition" to determine
SHA-3. In 2012, the Keccak team's submission was announced as
the winner. However, in 2014 NIST made slight changes to the
Keccak proposal, and published FIPS 202. FIPS specifies
the new SHA-3 family of permutation-based hash functions that
were published as a stardard on August 5, 2015. Note that only
the four fixed-length SHA-3 algorithms are NIST approved
hash algorithms: SHA3-224, SHA3-256, SHA3-384, and SHA3-512.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA3-224");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: openssl dgst -sha3-224
- PHP 7.1+: hash("sha3-224", $input);
- Plan 9: -
- PowerShell: -
- Python 3.6+: hashlib.sha3_224()
- Solaris 11.4+: /usr/bin/digest -a sha3_224
- Windows: -
since:
Jacksum 3.0.0
implementation:
java.security.MessageDigest, the alternate implementation
org.bouncycastle.crytpo.digests.SHA3Digest will be used if your
JRE/JDK doesn't support that algorithm, or if the option -A has
been specified.
sha3-256, sha-3-256
algorithm:
SHA-3
length:
256 bits
type:
cryptographic hash function
published:
08/2015
broken:
no
standard:
NIST FIPS 202 (SHA-3 Standard)
comment:
In 2007 NIST announced the competition called
"SHA-3 Cryptographic Hash Algorithm Competition" to determine
SHA-3. In 2012, the Keccak team's submission was announced as
the winner. However, in 2014 NIST made slight changes to the
Keccak proposal, and published FIPS 202. FIPS specifies
the new SHA-3 family of permutation-based hash functions that
were published as a stardard on August 5, 2015. Note that only
the four fixed-length SHA-3 algorithms are NIST approved hash
algorithms: SHA3-224, SHA3-256, SHA3-384, and SHA3-512.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA3-256");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: openssl dgst -sha3-256
- PHP 7.1+: hash("sha3-256", $input);
- Plan 9: -
- PowerShell: -
- Python 3.6+: hashlib.sha3_256()
- Solaris 11.4+: /usr/bin/digest -a sha3_256
- Windows: -
since:
Jacksum 3.0.0
implementation:
java.security.MessageDigest, the alternate implementation
org.bouncycastle.crytpo.digests.SHA3Digest will be used if your
JRE/JDK doesn't support that algorithm, or if the option -A has
been specified.
sha3-384, sha-3-384
algorithm:
SHA-3
length:
384 bits
type:
cryptographic hash function
published:
08/2015
broken:
no
standard:
NIST FIPS 202 (SHA-3 Standard)
comment:
In 2007 NIST announced the competition called
"SHA-3 Cryptographic Hash Algorithm Competition"
to determine SHA-3. In 2012, the Keccak team's submission was
announced as the winner. However, in 2014 NIST made slight
changes to the Keccak proposal, and published FIPS 202. FIPS
specifies the new SHA-3 family of permutation-based hash
functions that were published as a stardard on August 5, 2015.
Note that only the four fixed-length SHA-3 algorithms are NIST
approved hash algorithms: SHA3-224, SHA3-256, SHA3-384,
and SHA3-512.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA3-384");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NextStep: -
- NetBSD: -
- OpenSSL 1.1.1+: openssl dgst -sha3-384
- PHP 7.1+: hash("sha3-384", $input);
- Plan 9: -
- PowerShell: -
- Python 3.6+: hashlib.sha3_384()
- Solaris 11.4+: /usr/bin/digest -a sha3_384
- Windows: -
since:
Jacksum 3.0.0
implementation:
java.security.MessageDigest, the alternate implementation
org.bouncycastle.crytpo.digests.SHA3Digest will be used if your
JRE/JDK doesn't support that algorithm, or if the option -A has
been specified.
sha3-512, sha-3-512
algorithm:
SHA-3
length:
512 bits
type:
cryptographic hash function
published:
08/2015
broken:
no
standard:
NIST FIPS 202 (SHA-3 Standard)
comment:
In 2007 NIST announced the competition called
"SHA-3 Cryptographic Hash Algorithm Competition" to determine
SHA-3. In 2012, the Keccak team's submission was announced as
the winner. However, in 2014 NIST made slight changes to the
Keccak proposal, and published FIPS 202. FIPS specifies
the new SHA-3 family of permutation-based hash functions that
were published as a stardard on August 5, 2015. Note that only
the four fixed-length SHA-3 algorithms are NIST approved
hash algorithms: SHA3-224, SHA3-256, SHA3-384, and SHA3-512.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java 9+: java.security.MessageDigest.
MessageDigest.getInstance("SHA3-512");
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+: openssl dgst -sha3-512
- PHP 7.1+: hash("sha3-512", $input);
- Plan 9: -
- PowerShell: -
- Python 3.6+: hashlib.sha3_512()
- Solaris 11.4+: /usr/bin/digest -a sha3_512
- Windows: -
since:
Jacksum 3.0.0
implementation:
java.security.MessageDigest, the alternate implementation
org.bouncycastle.crytpo.digests.SHA3Digest will be used if your
JRE/JDK doesn't support that algorithm, or if the option -A has
been specified.
shake128
algorithm:
SHAKE128 (Secure Hash Algorithm KECCAK, 128 bit security)
length:
256 bits
type:
XOF as a cryptographic hash function with a fixed output length
published:
08/2015
broken:
no
website:
https://csrc.nist.gov/publications/detail/fips/202/final
standard:
NIST FIPS PUB 202 (SHA-3 Standard)
comment:
FIPS 202 from NIST specifies the new SHA-3 family of
permutation-based hash functions, which were published as a
standard on August 5, 2015.
In addition to the four fixed-length hash functions, FIPS 202
also defines two "eXtendable Output Functions (XOF)",
SHAKE128 and SHAKE256.
An XOF is a powerful new kind of cryptographic primitive that
offers the flexibility to produce outputs with any desired
length.
The suffixes "128" and "256" indicate the security strengths
that these two XOFs can generally support, in contrast to the
suffixes for the fixed-length-hash functions, which indicate
the digest lengths.
The XOF can be specialized to a hash function by selecting a
fixed output length.
The SHAKE128 function have a generic security strength of 128
bits against all attacks, provided that at least 2x128 bits
of the output is used.
Requesting more than 256 bits of output does not increase the
collision-resistance of the SHAKE128 function.
Jacksum takes those considerations into account and restricts
the set of the supported value for the output length to
256 bits in order to define a reasonable hash function.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- FreeBSD 10.4+: -
- FreeDOS: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: -
- KeccakSum: KeccakSum --shake128 --hex --outputbits 256
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+ (128 bits only): openssl dgst -shake128
- PHP 7.1+: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.SHAKEDigest
shake256
algorithm:
SHAKE256 (Secure Hash Algorithm KECCAK, 256 bit security)
length:
512 bits
type:
XOF as a cryptographic hash function with a fixed output length
published:
08/2015
broken:
no
website:
https://csrc.nist.gov/publications/detail/fips/202/final
standard:
NIST FIPS PUB 202 (SHA-3 Standard)
comment:
FIPS 202 from NIST specifies the new SHA-3 family of
permutation-based hash functions, which were published as a
standard on August 5, 2015.
In addition to the four fixed-length hash functions, FIPS 202
also defines two "eXtendable Output Functions (XOF)",
SHAKE128 and SHAKE256.
An XOF is a powerful new kind of cryptographic primitive that
offers the flexibility to produce outputs with any desired
length.
The suffixes "128" and "256" indicate the security strengths
that these two XOFs can generally support, in contrast to the
suffixes for the fixed-length-hash functions, which indicate
the digest lengths.
The XOF can be specialized to a hash function by selecting a
fixed output length.
The SHAKE256 function have a generic security strength of 256
bits against all attacks, provided that at least 2x256 bits
of the output is used.
Requesting more than 512 bits of output does not increase the
collision-resistance of the SHAKE256 function.
Jacksum takes those considerations into account and restricts
the set of the supported value for the output length to
512 bits in order to define a reasonable hash function.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- FreeBSD 10.4+: -
- FreeDOS: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- IBM AIX: -
- Java 9+: -
- Kali Linux: -
- KeccakSum: KeccakSum --shake256 --hex --outputbits 512
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL 1.1.1+ (256 bits): openssl dgst -shake256
- PHP 7.1+: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Ubuntu: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.SHAKEDigest
skein-256, skein-256-<w>
algorithm:
Skein-256
length:
customizable (w > 0 and w % 8 = 0),
w = 256 bits if w is not specified
type:
cryptographic hash function
published:
10/2010
broken:
no
website:
http://www.skein-hash.info/
https://www.schneier.com/academic/skein/
https://en.wikipedia.org/wiki/Skein_(hash_function)
comment:
Skein is a cryptographic hash function and one of the five
finalists in the NIST hash function competition.
The name Skein refers to how the Skein function intertwines the
input, similar to a skein of yarn. Skein was created by
Bruce Schneier, Niels Ferguson, Stefan Lucks, Doug Whiting,
Mihir Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker.
Skein supports internal state sizes of 256, 512 and 1024 bits,
and arbitrary output sizes.
This is the implementation of version 1.3 of Skein, which was
presented to NIST for the 3rd and final round of the competition
in October 2010.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: /sbin/skein256
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.SkeinDigest
skein-512, skein-512-<w>
algorithm:
Skein-512
length:
customizable (w > 0 and w % 8 = 0),
w = 512 bits if w is not specified
type:
cryptographic hash function
published:
10/2010
broken:
no
website:
http://www.skein-hash.info/
https://www.schneier.com/academic/skein/
https://en.wikipedia.org/wiki/Skein_(hash_function)
comment:
Skein is a cryptographic hash function and one of the five
finalists in the NIST hash function competition.
The name Skein refers to how the Skein function intertwines the
input, similar to a skein of yarn. Skein was created by
Bruce Schneier, Niels Ferguson, Stefan Lucks, Doug Whiting,
Mihir Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker.
Skein supports internal state sizes of 256, 512 and 1024 bits,
and arbitrary output sizes.
This is the implementation of version 1.3 of Skein, which was
presented to NIST for the 3rd and final round of the competition
in October 2010.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: /sbin/skein512
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.SkeinDigest
skein-1024, skein-1024-<w>
algorithm:
Skein-1024
length:
customizable (w > 0 and w % 8 = 0),
w = 1024 bits if w is not specified
type:
cryptographic hash function
published:
10/2010
broken:
no
website:
http://www.skein-hash.info/
https://www.schneier.com/academic/skein/
https://en.wikipedia.org/wiki/Skein_(hash_function)
comment:
Skein is a cryptographic hash function and one of the five
finalists in the NIST hash function competition.
The name Skein refers to how the Skein function intertwines the
input, similar to a skein of yarn. Skein was created by
Bruce Schneier, Niels Ferguson, Stefan Lucks, Doug Whiting,
Mihir Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker.
Skein supports internal state sizes of 256, 512 and 1024 bits,
and arbitrary output sizes.
This is the implementation of version 1.3 of Skein, which was
presented to NIST for the 3rd and final round of the competition
in October 2010.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: /sbin/skein1024
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.SkeinDigest
streebog256, streebog-256
algorithm:
Streebog Hash Function (GOST R 34.11-2012)
length:
256 bits
type:
cryptographic hash function
published:
2012
broken:
no
website:
https://www.streebog.net
standards:
GOST R 34.11-2012
RFC 6986
comment:
Streebogis a cryptographic hash function defined in the Russian
national standard GOST R 34.11-2012. It was co-developed by the
FSB (Federalnaja Sluschba Besopasnosti), the Federal Security
Service of the Russian Federation to replace the obsolete GOST
hash function defined in the old standard GOST R 34.11-94, and
as an asymmetric reply to SHA-3 competition by the US NIST.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -strebog256
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.GOST3411_2012_256Digest
streebog512, streebog-512
algorithm:
Streebog Hash Function (GOST R 34.11-2012)
length:
512 bits
type:
cryptographic hash function
published:
2012
broken:
no
website:
https://www.streebog.net
standards:
GOST R 34.11-2012
RFC 6986
comment:
Streebogis a cryptographic hash function defined in the Russian
national standard GOST R 34.11-2012. It was co-developed by the
FSB (Federalnaja Sluschba Besopasnosti), the Federal Security
Service of the Russian Federation to replace the obsolete GOST
hash function defined in the old standard GOST R 34.11-94, and
as an asymmetric reply to SHA-3 competition by the US NIST.´
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -strebog512
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
implementation:
org.bouncycastle.crypto.digests.GOST3411_2012_512Digest
sm3
algorithm:
SM3
length:
256 bits
type:
cryptographic hash function
published:
12/2010
broken:
no
comment:
SM3 is a cryptographic hash function used in the "Chinese
National Standard". It was published by the State Cryptography
Administration on Deceber 17, 2010 as GM/T 0004-2012.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 11.1+: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: openssl dgst -sm3
- PHP: -
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 3.0.0
sum<w>, sum-<w>
algorithm:
Sum
length:
8, 16, 24, 32, 40, 48, or 56 bits
type:
checksum
comment:
classic checksum, value is computed by adding together all
values in the input data stream modulo 2^<w>.
This algorithm doesn't care about the arrangement of bytes.
The default encoding is decimal.
sum8 is used by the Intel HEX file format for example.
since:
Jacksum 1.3.0; 40, 48, and 56 bits are available since
Jacksum 3.0.0
implementation:
net.jacksum.algorithm.Sum*
sum_bsd, bsd, bsdsum, sumbsd
algorithm:
BSD checksum algorithm
length:
16 bits
type:
checksum
comment:
output format is exactly like the native program sum (size in
1024 byte blocks). The default encoding is decimal.
See also sysv
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sum [-r]
- Angstrom: -
- BeOS: /bin/sum [-r]
- eComStation: C:\ecs\KLIBC\bin\sum [-r]
- FreeBSD: /usr/bin/sum
/usr/bin/cksum -o 1
- FreeDOS: -
- GNU/Hurd: /usr/bin/sum [-r]
- GNU/Linux: /usr/bin/sum [-r]
- Haiku: /bin/sum [-r]
- HP-UX: /usr/bin/sum -r
- IBM AIX: /usr/bin/sum [-r]
- Kali Linux: /usr/bin/sum [-r]
- Mac OS X: /usr/bin/sum
/usr/bin/cksum -o 1
- macOS: /usr/bin/sum
/usr/bin/cksum -o 1
- Minix: -
- MS-DOS: -
- NetBSD: /usr/bin/sum -o 1
/usr/bin/sum -a old1
/usr/bin/cksum -o 1
/usr/bin/cksum -a old1
- NextStep: /usr/bin/sum
- PHP: -
- Plan 9: /bin/sum -r
- SCO UnixWare: /bin/sum -r
- Solaris -10: /usr/ucb/sum
- Solaris 11 Express:
/usr/bin/sum -r|--bsd|--method=<bsd|ucb>
- Tcl: crc::sum [-bsd]
- Tru64 Unix: /usr/bin/sum [-r]
- Windows: -
- OpenSSL: -
since:
Jacksum 1.0.0, alias "bsdsum" since 1.2.0, alias "sumbsd"
since 1.6.0, "sum_bsd" since 2.0.0)
implementation:
net.jacksum.algorithm
sum_minix
algorithm:
Minix' sum
length:
16 bits
type:
checksum
comment:
it is the same like the bsd algorithm, with the exception that
the size is printed in 512 byte blocks rather than in 1024 byte
blocks.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- HP-UX: -
- IBM AIX: -
- Kali Linux: -
- Mac OS X: -
- macOS: -
- Minix: /usr/bin/sum
- MS-DOS: -
- PHP: -
- Plan 9: -
- Solaris: -
- Windows: -
- OpenSSL: -
since:
Jacksum 3.0.0
implementation:
net.jacksum.algorithm
sum_plan9, crc32_fddi
algorithm:
FDDI CRC / Plan 9 sum
length:
32 bits
type:
CRC
comment:
The default encoding is decimal.
The sum command on Plan 9 prints the crc in hex, in order to get
the output of Plan 9, specify the option -E hex.
The FDDI CRC cannot be described completely by the Rocksoft-
Model, because the algorithm includes the xor'ed length to the
CRC. Without this special, the code would be:
crc:32,04C11DB7,0,true,true,0
With the additional length parameter the algorithm can be
expressed as
crc:32,04C11DB7,0,true,true,0,true,CC55CC55
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- HP-UX: -
- IBM AIX: -
- Kali Linux: -
- Mac OS X: -
- macOS: -
- Minix: -
- MS-DOS: -
- PHP: -
- Plan 9: /bin/sum
- Solaris 11 Express:
/usr/bin/sum --method=fddi
- Windows: -
- OpenSSL: -
since:
Jacksum 3.0.0
implementation:
crc:32,04C11DB7,0,true,true,0,true,CC55CC55
sum_sysv, sysv, sysvsum, sumsysv
algorithm:
UNIX System V checksum algorithm
length:
16 bits
type:
checksum
published:
1985
comment:
output format is exactly like the native program sum
(size in 512 bytes blocks), see also bsd.
The default encoding is decimal.
compatibility:
- 7z: -
- Azure Cloud Shell (Common Base Linux 10):
/usr/bin/sum -s|--sysv
- Angstrom: -
- BeOS: /bin/sum -s
- eComStation: C:\ecs\KLIBC\bin\sum -s|--sysv
- FreeBSD: /usr/bin/cksum -o 2
- FreeDOS: -
- GNU/Hurd: /usr/bin/sum -s
- GNU/Linux: /usr/bin/sum -s
- Haiku: /bin/sum -s
- HP-UX: /usr/bin/sum
- Kali Linux: /usr/bin/sum -s
- Mac OS X: /usr/bin/cksum -o 2
- macOS 10.12+: /usr/bin/cksum -o 2
- Minix 3.2.1+: /usr/bin/sum -a old2
/usr/bin/sum -o 2
/usr/bin/cksum -a old2
/usr/bin/cksum -o 2
- MS-DOS: -
- NetBSD: /usr/bin/cksum -o 2
/usr/bin/sum -o 2
/usr/bin/cksum -a old2
/usr/bin/sum -a old2
- NextStep: -
- PHP: -
- Plan 9: /bin/sum -5
- SCO UnixWare: /bin/sum
- Solaris -10: /usr/bin/sum
- Solaris 11 Express:
/usr/bin/sum -s|--sysv|
--method=<att|sys5|s5|default>
- Tcl: crc::sum -sysv
- Tru64 Unix: /usr/bin/sum -o
- Windows: -
- OpenSSL: -
since:
Jacksum 1.2.0, alias "sumsysv" since 1.6.0 alias "sum_sysv"
since 2.0.0
implementation:
net.jacksum.algorithm
tiger128, tiger-128
algorithm:
Tiger 128
length:
128 bits
type:
cryptographic hash function
published:
1995
broken:
yes
comment:
the hash value is the first 128 bits of the result of Tiger-192.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD 5.3+: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("tiger128,3", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Tiger160 (by jonelo)
tiger160, tiger-160
algorithm:
Tiger 160
length:
160 bits
type:
cryptographic hash function
published:
1995
broken:
yes
comment:
the hash value is the first 160 bits of the result of Tiger-192.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("tiger160,3", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Tiger160 (by jonelo)
tiger, tiger192, tiger-192
algorithm:
Tiger
length:
192 bits
type:
cryptographic hash function
published:
1995
broken:
yes
comment:
developed by Ross Anderson and Eli Biham, 1995.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- CentOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: -
- PHP: hash("tiger192,3", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.4.0
implementation:
gnu.crypto.hash.Tiger
tiger2
algorithm:
Tiger2
length:
192 bits
type:
cryptographic hash function
published:
2005
broken:
no
comment:
developed by Ross Anderson and Eli Biham, 2005.
The default encoding is hexadecimal.
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Tiger2 (by jonelo)
tth, tree:tiger, tree:tiger192, tree:tiger-192
algorithm:
Tiger Tree Hash (based on a Hash tree/Merkle tree)
length:
192 bits
published:
Merkle tree was published in 1979, tiger was published in 1995.
type:
hash tree
comment:
tiger is the underlying algorithm for the hash tree.
The hash tree was invented by Ralph Merkle, 1979. A hash tree is
a tree of hashes in which the leaves are hashes of data blocks.
The Tiger Tree Hash uses a binary hash tree (two child nodes
under each node), with a data block size of 1024 bytes.
Tiger Tree Hashes are used in P2P file sharing protocols and
in file sharing applications.
The default encoding is base32_nopad.
since:
Jacksum 1.7.0
implementation:
net.jacksum.algorithm
tth2, tree:tiger2
algorithm:
Tiger Tree Hash 2 (based on a Hash tree/Merkle tree)
length:
192 bits
published:
Merkle tree was published in 1979, tiger2 was published in 2005.
type:
hash tree
comment:
tiger2 is the underlying algorithm for the hash tree.
The hash tree was invented by Ralph Merkle, 1979. A hash tree is
a tree of hashes in which the leaves are hashes of data blocks.
The Tiger Tree Hash uses a binary hash tree (two child nodes
under each node), with a data block size of 1024 bytes.
Tree hashes are used in P2P file sharing protocols and
applications.
The default encoding is base32_nopad.
since:
Jacksum 1.7.0
implementation:
net.jacksum.algorithm
vsh, vsh-1024
algorithm:
VSH (Very Smooth Hash)
length:
1024 bits
type:
cryptographic hash function
published:
11/2005
broken:
no
website:
http://www.nist.gov/hash-function (archived)
http://www.csrc.nist.gov/pki/HashWorkshop/2005/Nov1_Presentations/LENSTRA_vsh.pdf (archived)
comment:
In response to the SHA-1 vulnerability that was announced in
Feb. 2005, NIST held a Cryptographic Hash Workshop on
Oct. 31-Nov. 1, 2005 to solicit public input on its
cryptographic hash function policy and standards.
VSH was presented on Nov 1, 2005 by scientists from the
Macquarie University, Sydney and Bell Laboratories (Lucent
Technologies) at this first NIST Hash Workshop.
The NIST conducted also a second workshop.
However, NIST did not select an algorithm immediately, but held
a public competition from 2007 to 2012 (SHA-3 Competition) to
find a successor for SHA-1 and the SHA-2 family.
since:
Jacksum 3.0.0
implementation:
de.flexiprovider.core.md.VSH
whirlpool0, whirlpool-0
algorithm:
Whirlpool-0
length:
512 bits
type:
cryptographic hash function
published:
2000
broken:
yes
comment:
The Whirlpool Hashing Function by Paulo S.L.M. Barreto and
Vincent Rijmen, 2000. This is the original specification of
Whirlpool from 2000.
The default encoding is hexadecimal.
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Whirlpool (by jonelo)
whirlpool1, whirlpool-1, whirlpool-t
algorithm:
Whirlpool-1
length:
512 bits
type:
cryptographic hash function
published:
2001
broken:
yes
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."
Since March 2007 the Whirlpool authors name this whirlpool
revision "Whirlpool-T".
The default encoding is hexadecimal.
since:
Jacksum 1.2.0
implementation:
gnu.crypto.hash.Whirlpool
whirlpool,whirlpool2, whirlpool-2
algorithm:
Whirlpool
length:
512 bits
type:
cryptographic hash function
published:
2003
broken:
no
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]"
This whirlpool revision was adopted by the International
Organization for Standardization (ISO) in the
ISO/IEC 10118-3:2004 standard.
The default encoding is hexadecimal.
compatibility:
- 7z: -
- Angstrom: -
- BeOS: -
- DragonFly BSD: -
- FreeBSD: -
- FreeDOS: -
- GNU/Hurd: -
- GNU/Linux: -
- gpg: -
- HP-UX: -
- Java: -
- Kali Linux: -
- LibreSSL: openssl dgst -whirlpool
- Mac OS X: -
- macOS 10.12+: -
- Minix: -
- MS-DOS: -
- NetBSD: -
- NextStep: -
- OpenSSL: openssl dgst -whirlpool
- PHP: hash("whirlpool", $input);
- Plan 9: -
- PowerShell: -
- Python: -
- Solaris: -
- Windows: -
since:
Jacksum 1.6.0
implementation:
gnu.crypto.hash.Whirlpool (by jonelo)
xor8, xor-8
algorithm:
Exclusive-OR
length:
8 bits
type:
checksum
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 default encoding is decimal.
since:
Jacksum 1.3.0
implementation:
net.jacksum.algorithm
xxhash32, xxh32
algorithm:
xxHash32 (XXH32)
length:
32 Bits
type:
non-cryptographic hash function
website:
http://www.xxhash.com/
comment:
The default output is equivalent to the Open Source program
called xxhsum: hex lowercase checksum, big endian,
without message length.
compatibility:
- xxhsum: xxhsum -H0
xxhsum -H32
since:
Jacksum 3.0.0
implementation:
org.apache.commons.codec.digest.XXHash32
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 hash; output
depends on options -a, -E, -g, -G, -x, and -X
sep is a separator; it can be modified by -s,
otherwise it is dependent on -a
filesize is the size (bytes or blocks) of a file, it depends
on -a, the filesize won't be written by any
message digest algorithm
timestamp is the 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.
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
Get information about the program:
`jacksum -v` or `jacksum --version`
returns the version of Jacksum
`jacksum -h` or `jacksum --help`
prints the entire manpage
`jacksum --info`
returns the version of Jacksum, primary IDs of all supported algorithms
and their descriptions, number of supported algorithms, supported
character sets, number of supported character sets, system properties,
available processors for the application and many more.
Useful for support requests.
Get information about one algorithm:
`jacksum --help md5`
prints the MD5 section from the help file, including a compatibility
list.
`jacksum -a md5 --info`
prints implementation details about the MD5 algorithm, such as hash
length in bits
`jacksum -a crc64_xz --info`
prints implementation details about the CRC64_xz. Since it is a CRC,
also the CRC parameters such as the polynomial is printed.
Get information about multiple algorithms:
`jacksum -a all --list`
prints a list of all supported algorithm IDs.
`jacksum -a all --list --verbose summary`
prints a list of all supported algorithm IDs and the count of the
algorithms.
`jacksum -a all:skein --list`
prints a list of all supported algorithm IDs that has skein in their
names.
`jacksum -a all:128 --list`
prints a list of all supported algorithm IDs that produce a digest
width of 128 bits.
`jacksum -a all:8 --list --info`
prints a list of all supported algorithms IDs that produce a digest
width of 8 bits, and for each algorithm ID additional information is
printed.
Get information on compatibility definitions:
`jacksum -C bsd --info`
all properties of the compatibility definition for bsd are printed out.
Calculate hashes from standard input (stdin):
`echo -n "Hello World" | jacksum -V summary -`
Calculates a SHA3-256 hash (default) from standard input stream (stdin).
Enabling the option `--verbose summary` or `-V summary` make sense in
some cases, because it will show how many bytes have been read acutally.
Note: the echo command could behave on your platform/environment
completely different!
A more platform independent way is to use the -q option.
`printf "Hello World\r\n" | jacksum -`
Returns the SHA3-256 (default) of the input "Hello World\r\n".
printf is a shell builtin in GNU/Linux shells such as bash and zsh.
A more platform independent way is to use the -q option.
`jacksum -a md5 -`
Calculates the MD5 hash from input that is entered in the terminal.
Hit Ctrl+Z on GNU/Linux and macoOS, and Ctrl+D on Windows to end the
input.
`cat fat.iso | jacksum -`
prints the SHA3-256 (default) of the binary file called fat.iso on
GNU/Linux and macOS. Use type rather than cat on Windows.
Calculate hashes from the command line:
`jacksum -q txt:"The quick brown fox jumps over the lazy dog"`
calculates the sha3-256 (default) hash from the given string.
`jacksum -a crc32 -q 'txt:Hello World!'
calculates a 32-bit CRC of the text "Hello World!". In GNU/Linux
shells such as bash you have to enclose characters in single quotes
rather than double quotes in order to preserve the literal value of each
character whithin the quotes. On Windows you can use double quotes.
`jacksum -q txtf:"Hallo Welt\r\n"`
Returns the SHA3-256 (default) of the input "Hallo Welt\r\n",
interpreted as UTF-8 String and using of escape sequences.
`jacksum -a crc32 -q 48656C6C6F20576F726C6421`
calculates a 32-bit CRC of the hex sequence
48656C6C6F20576F726C6421 which actually represents the string
"Hello World!" (without the quotes)
`jacksum -a crc64 -q txt:`
calculates a 64-bit CRC of an empty string (the result is the same
if you calculate the 64-bit CRC of a file with a file size of 0 bytes)
`jacksum -V summary -q txtf:abc\n -F "#ALGONAME(#SEQUENCE) = #HASH" -x`
calculates the sha3-256 (default) of 4 input bytes. Since you have
specified #SEQUENCE and -V summary, you can see not only the input as
hex, but also the number of bytes that have been read.
Calculate hashes from files on the file system:
`jacksum -a crc32 -x *.txt`
calculates a 32 bit CRC of all text files within the current folder.
The checksum will be printed in a hexadecimal format (-x).
`jacksum -a crc32 -t default .`
not only CRCs will be printed, but also timestamps (-t) of all
files within the current folder (.)
`jacksum -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 cksum /mnt/share`
calculates a 32 bit CRC with the standard Unix-algorithm cksum
of all files /mnt/share and it's sub folders
`jacksum -A -a md5 -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).
Calculate hashes from file lists:
`jacksum --file-list filelist.txt`
for each filename in filelist.txt, read the file and calculate the
hashes.
`jacksum --file-list filelist.txt *.mp3 *.info myfolder`
for each filename in filelist.txt, for all *.mp3 and *.info files, and
for any files under myfolder, read the files and calculate the hashes.
`chcp 65001 & echo "a filename that contains unicode chars" |
jacksum --utf8 --file-list - --file-list-format ssv`
on the Windows' cmd, change the code page to UTF-8, and pass a filename
that contains unicode characters through a pipe to Jacksum
(--file-list -). The file list format has been specified as ssv which
stands for space separated values. --utf8 has been set in order to
read the filenames from the pipe in UTF-8 mode.
Create hash lists for later verification:
`jacksum -o hashes.list /data`
calculates the Message-Digest SHA3-256 (default) of all files in /data
and it's subfolders, and stores the output to hashes.list, path
information is stored absolutely since your path started with /.
`jacksum -o hashes.list data`
calculates the Message-Digest SHA3-256 (default) of all files in data
and it's sub folders, and stores output to hashes.list, path
information is stored relatively, because your path didn't start with /.
`jacksum -a blake3+ -o hashes.list data`
calculates the Message-Digest Blake3 of all files in data
and it's sub folders, and stores output to hashes.list. Since the + has
been used, filesizes are also stored to hashes.list.
`jacksum -a blake3+ -E base64 -t iso8601 -o hashes.list data`
calculates the Message-Digest Blake3 of all files in data
and it's sub folders, and stores output to hashes.list. Hashes are
stored in base64 format. Since the + has been used, filesizes are also
stored to hashes.list, and since the -t iso8601 has been used,
timestamps are also sotred to hashes.list.
`jacksum -a sm3 -E base64 -o hashes.txt -C linux *.txt`
calculates the SM3 hashes in base64 encoding for all txt-files
using the linux compatibility output format.
Check/verify hashes:
`jacksum -a blake3+ -E base64 -t iso8601 -c hashes.list data`
verifies all checksums stored in a file called list.hashes. You have to
specify -a blake3+ and -E hex, because Blake3 was the algorithm, and hex
was the encoding that was used when the hashes.list was generated.
`jacksum -C bsd -a sha3-256 -c hashes.list .`
checks the integrity of the sha3-256 hashes for all filenames stored in
the hashes.list, and it also finds all new files that are being stored
anywhere in the directory tree below the current working directory.
`jacksum -c my.hashes -a sha3-256 -E hex --list --list-filter bad
--verbose nosummary`
lists only filnames for bad files (failed or missing).
Customize the output:
`jacksum -C bsd -a sha3-256 .`
calculates the SHA3-256 hashes for all files in the current
directory recursively in BSD-style format.
`jacksum -a md5+sha1 -F "MD5-SHA1(#FILENAME)= #HASH{hex}" file`
produces the same output as `openssl dgst -md5-sha1 file`
`jacksum -a ed2k -F
"ed2k://|file|#FILENAME{name}|#FILESIZE|#HASH{hex}|/" .`
produces ed2k-links
`jacksum -a tth+ed2k+sha1+md5 -F
"magnet:?xl=#FILESIZE&dn=#FILENAME{name}
&xt=urn:tree:tiger:#HASH{tth,base32}
&xt=urn:ed2k:#HASH{ed2k,hex}
&xt=urn:bitprint:#HASH{sha1,base32}.#HASH{tth,base32}
&xt=urn:sha1:#HASH{sha1,base32}
&xt=urn:md5:#HASH{md5,hex}" -`
produces magnet-links
`jacksum -a sumsysv -E dec -t unixtime -F
"1 i #FILENAME{name} #FILESIZE #CHECKSUM #TIMESTAMP"
install/*`
prints appropriate entries that are compatible with the
syntax of a Solaris 10+ pkgmap file - that is useful if you
want to patch a Solaris patch for example.
Find files having the same hash (find all duplicates of the file):
`jacksum -a md5 -E hex -F #FILENAME -e 9666f5e2632d05b806e782d7d50855e8 .`
finds all files below the current working directory, that produces
the given hex-encoded MD5-hash. Only the filenames of those files
will be printed.
Find the algorithm that produces a particular hash:
`jacksum -a unknown:16 -q hex:050000 -E hex -e d893`
Finds all algorithms with a digest width of 16 bits that can produce the
hex output d893 for the hex input 050000. The example above returns 20
potential algorithms, each of those returns the same checksum. Test with
more input/output sequences in order to find the right algorithm.
Customize the output format:
`jacksum -a sha256 -P / -F "<a href=\"#FILENAME\">#HASH</a><br>" mp4s`
prints the SHA256 hashes for all files in the mp4s folder as hyperlinks
with the slash as path separator, even on Windows where the path
separator would be the back slash.
`jacksum -a sumsysv -E dec -t unixtime
-F "1 i #FILENAME{name} #FILESIZE #CHECKSUM #TIMESTAMP" install/*`
prints appropriate entries that are compatible with the syntax of
Solaris 10's pkgmap file (useful if you want to patch a Solaris patch)
`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 md5 -f -F "#FINGERPRINT #FILESIZE #FILENAME" *`
calculates the Message-Digest MD5 of all files in the current
directory. The output format is customized, it prints also
the filesize.
`jacksum -a 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>" .`
calculates the edonkey hash of all files in the current directory
and it's sub folders with a customized output format (HTML)
`jacksum -a tree:tiger -F "urn:#ALGONAME:#FINGERPRINT" -q hex:`
calculates the root hash of the Tiger Tree Hash (a widely used form of
the Merkle tree). The underlying Tiger algorithm is used with an empty
input.
Working with multiple algorithms:
`jacksum -a sha1+crc32 .`
calculates the sha1 hash and the crc32 as a chained checksum
`jacksum -a sha1+crc32 -F "sha1=#CHECKSUM{0} crc32=#CHECKSUM{1} #FILENAME" .`
calculates the sha1 hash and the crc32, printed separately
`jacksum -a all -F "#ALGONAME{i} (#FILENAME) = #CHECKSUM{i}" .`
calculates all supported algorithms on all files in a customized format
`jacksum -a all -q txt: -F "#ALGONAME{i}"`
returns all supported algorithm IDs only, a more elegant way is to type
`jacksum -a all --list` however
`jacksum -a all:224 -q txt: -F "#ALGONAME{i}"`
returns all supported algorithm IDs that hava a bit-length of 224 only
a more elegant way is to type `jacksum -a all:224 --list`however
`jacksum -a crc32+md5+sha1 -F
"#SEPARATOR#ALGONAME{i}(#FILENAME):hex=#DIGEST{i,hex}
#SEPARATOR#ALGONAME{i}(#FILENAME):HEX=#DIGEST{i,hex-uppercase}
#SEPARATOR#ALGONAME{i}(#FILENAME):base64=#DIGEST{i,base64}"
-s "\n" -r .`
for all files, including all subdirectories, calculate the crc32, md5
and sha1 hash and for each of those algorithms print the digest encoded
in hex, uppercase hex and base64
`jacksum -a sha3-512+blake2b -q txtf:"Hello World\x0a" -s \n -F
"#ALGONAME{0} (#SEQUENCE)[hex] = #DIGEST{0,hex}#SEPARATOR
#ALGONAME{1} (#SEQUENCE)[bb] = #DIGEST{1,bb}"`
Returns the SHA3-512 digest hexadecimal and the blake2b Digest in the
BubbleBabble format for the input that has been specified with -q.
`cat template.txt
INPUT:
hex: #SEQUENCE{hex}
base32: #SEQUENCE{base32}
base64: #SEQUENCE{base64}
OUTPUT of #ALGONAME{i}:
hex: #CHECKSUM{i,base16}
base32: #CHECKSUM{i,base32}
base64: #CHECKSUM{i,base64}`
`jacksum -a blake2b+sha3-512 -q txtf:123456789\x0a -E hex -g 1 -F \
"$(cat template.txt)"`
with the help of a template that is stored in a plain text file, not
only the input "123456789\x0a", but also the hashes are being encoded
as hex, base32 and base64 for both algorithms blake2s and sha3-512.
`jacksum -s \n -a sha1+sha1+sha3-256 -F
"#ALGONAME{0}/hex: #CHECKSUM{0,hex} #FILENAME{name}#SEPARATOR
#ALGONAME{1}/base32: #CHECKSUM{1,base32} #FILENAME{name}#SEPARATOR
#ALGONAME{2}/base64: #CHECKSUM{2,base64} #FILENAME{name}#SEPARATOR"
*.txt`
You want different encodings, such as hex and base32 for SHA-1, and
base64 for SHA3-256?
Each text file will be read only once and also sha1's engine will run
only once for each file.
Working with the help:
jacksum -h -h
prints the help about the -h option
jacksum -h synopsis
prints the SYNOPSIS section
jacksum -h license
prints the LICENSE section
jacksum -h whirlpool
prints all information about the algorithms starting with whirlpool
jacksum -h -
prints all information about all options (since each option starts
with a minis sign), - and -- options are listed at the end of the
output.
jacksum -h | more
prints the entire help, pagewise
Copyright (c) 2001-2021, Dipl.-Inf. (FH) Johann N. Loefflmann
<https://jacksum.net>
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 3 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, see <https://www.gnu.org/licenses/>.
Jacksum • https://jacksum.net • Jacksum on GitHub