PeaZip
is a free, Open Source file hashing utility which provides primitives
to compute multiple hash and checksum algorithms.
File hash computation can be used either to find
duplicate files (which have identical checksum/hash value), and to
detect
corrupted files which have different checksum / hash values from a
known
one.
Why it is needed to verify
data integrity
|
Data corruption
may arise by simple technical issues - transmission
faults, degradation of memory support - which can usually be detected
with ease by quick and computationally light functions (often
integrated at various levels of transmission protocols and memory
technologies), or may arise from forgery, purposely crafted
modifications
of data created by a malicious attacker to exploit weakness of simpler
error detection mechanisms - which requires calculation of more
powerful verification functions like cryptographically strong hash
algorithms. |
Compute error detection
algorithms
Check
files tool in
"File tools" submenu (context menu) allows to verify multiple hash and
checksum algorithms on multiple files at once, e.g. to
compare a group of file to identify redundant ones, or to check
files for corruption
when an original
checksum or hash value is
known (or when it can be calculated for reference from a known safe
copy of the data).
Selected algorithms are performed in a single passage so reading the
data from
disk (usually the main performance bottleneck) occurs only one time,
speeding up the disk-bound part of the process.
The algorithms to be performed can be selected in Options >
Settings, in File Tools tab; calculated output value of hashes and
checksums can
be seen as exadecimal (HEX,
either LSB or MSB) or encoded as
Base64.
CRC and hashing
algorithms supported by PeaZip
15 checksum and
hash algorithms are currently supported:
-
checksum functions Adler32, CRC16, CRC24, CRC32,
CRC64
-
general-purpose hash functions as
eDonkey/eMule, MD4, MD5
-
cryptographically strong hash:
-
Ripemd160
-
SHA-1
-
SHA-2
family (SHA256, SHA512)
-
SHA-3 family (SHA-3 256, SHA-3 512)
- BLAKE2S and BLAKE2B
-
AES-based Whirlpool512
File hash
verification best practices
|
Hint:
chose faster checksums like CRC32 to
perform a quick comparison (e.g. to detect duplicate
files of test for casual corruption data errors), but it is
recommended to employ a cryptographically
secure hash function (like BLAKE2S or BLAKE2B, SHA256, SHA-3
algorithms, or the
AES-based Whirlpool512) to detect
malicious
corruption / forgery attacks that might be calculated in order to pass
undetected
to one (or some) of the non-secure algorithms exploiting collision -
algorithm maps different input to same ouput digest. |
|
Use multiple hash
functions at once
Employing multiple
functions
at once, and especially relying on
cryptographically
strong hash functions as Ripemd160, SHA-2, SHA-3 or Whirlpool, can
defeat
attempt
of forging identical-looking files, as it is computationally feasible
to find a collision (different input files mapped to same output
digest) for
simpler
checksum and hash functions, while finding digest value collisions is
currently not computationally feasible for more robust cryptographic
hash functions.
This way, even a purposely crafted modification of a file would not
pass unnoticed to most sophisticated error / forgery detection
algorithms, making
possible to identify not only plain data corruption (e.g. communication
or device fault) but also to avoid certain classes of attacks relying
on replacing original content with forged data.
Byte-to-byte file
comparison
Compare files
tool in
"File tools" submenu performs byte to byte comparison between two
files, a slower process in which all single bytes of one file are
verified and matched with the same offset byte of the other file.
Unlike checksum / hash comparison, this method it is not subject to
collisions
under any
circumstance, and can effectively tell what the different bytes are,
providing not
only a way to verify if two files are identical or different, but also
to find in details what changes were
made between the two versions.
Test archive
files for
errors
Most archive formats
can be tested for errors using PeaZip Open Source file hash utility
routines
(Test button), detecting if data is correctly readable and matches file
format specification's standards, either testing archive table of
content and single archive items.
Some archive types (7z, rar, tar, zipx...) improves error detection
storing pre-computed checksum values (usually CRC32, RAR format can optionally use 256-bit
BLAKE2sp hash) of archived data.
Data errors can be due to random corruption (faulty support, troubles
during download), out of standard archiving processes (bug, obsolete
specifications), or in worst case purposeful alteration of original
content. In some cases corruption or alteration of data can lead to an unreadable archive as result.
Testing archives for errors is an useful good practice sufficient for
low risk scenarios, but if there is a reasonable suspicion of the data
being purposely manipulated it is preferable to test the file with a
cryptographically strong hash function (SHA family, Ripemd, Whirlpool)
against
a known value, using aforementioned "Check files" tool.
Integrity checking in PEA archives
|
PEA file format
provides a wide array of strong hash functions and authenticated
encryption options, saving inside the archive the calculated digest
values - Adler, CRC32, CRC64, MD5, SHA1, Ripemd, SHA2 (SHA256, SHA512)
and SHA3 (SHA-3 256, SHA-3 512), Whirlpool, plus OMAC or HMAC for
authenticated encryption (default EAX AES256 CTR+OMAC).
In this way the data integrity can be thoroughly tested
during extraction, reducing needs of relying on external file hashing
tools,
for verification both of integrity and autenticity of the content. |
Read more about error detection and related topics: definitions of data
integrity , checksum, hash, cryptographically
secure hash function, and data
deduplication on
Wikipedia, sha-2-family standard.
Synopsis: Error
detection, how to verify data integrity with PeaZip, freeware Open
Source file hashing utility. Calculate CRC checksum and MD5, SHA256
file hash values to detect corrupt files.
Topics: how to compute
crc, verify md5, sha256 hash values, detect corrputed files, test files
for data errors
PeaZip > FAQ >
File hashing utility, verify CRC MD5 SHA256 hash values
|
