Overview 
TurboSFV supports various hash functions to calculate checksums
for files. Checksums are fingerprints or digital signatures of bit
streams. Their calculation and length of the hash digits depends on the used hash algorithm.
Checksums can be used to algorithmically identify a file. In general,
if a file changes, then the checksum will change. So checksums can
be used to validate data.
The security of a hash function mainly depends on the used hash algorithm and the length
of the hash digits. At the time of writing, CRC32, MD5 and SHA1 are insecure: A different
file with the same checksum can be created or found. The decision, which hash function to use,
depends on the application and the available computer power.
TurboSFV supports the calculation of hash values using the following
hash functions. Mentioned links to some external websites provide you with further
details.

CRC32  Cyclic redundancy check 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

 Length of the hash digits: 32 bits
 File extension: sfv
 External links:

MD5  Messagedigest 5 hash function 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

 Length of the hash digits: 128 bits
 File extension: md5
 External links:

SHA1  Secure hash algorithm 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

 Length of the hash digits: 160 bits
 File extension: sh1
 External links:

SHA2 family 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

The SHA2 family includes the secure hash algorithms SHA224, SHA256, SHA384, SHA512 plus
the two tbit hash functions SHA512/224 and SHA512/256.
The tbit hash functions SHA512/224 and SHA512/256 are based on SHA512, but they start with
different initial vectors and come with smaller hash values.
For example, SHA512/256 is used in applications, where on one hand a keylength of 256 bit is needed,
on the other hand the higher security of SHA512 instead of SHA256. Additionally, on x64 platforms,
SHA512 can have a better performance  if properly coded.

Hash function  Length 
SHA224  224 bits 
SHA256  256 bits 
SHA384  384 bits 
SHA512  512 bits 
SHA512/224  224 bits 
SHA512/256  256 bits 

 File extension: sh2
 External links:

SHA3 family 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

The SHA3 hash functions are specified in the NIST standard FIPS 202 and are based on the KECCAK algorithm.
In FIPS 202, the specification of SHA3 slightly differs from the original KECCAK algorithm, which was submitted
to the NIST SHA3 competition. But there is no impact on the security of KECCAK, because only the padding (fill bits
for the last message block) has changed.
SHA3 was specified by NIST, to have an alternative to the SHA2 family in place in case of a successfull attack
against SHA2. SHA2 is based on the same technical principles as SHA1, for which successfull attacks are known
since 2005.
The current version of TurboSFV includes the secure hash algorithms SHA3224, SHA3256, SHA3384 and
SHA3512, as specified in FIPS 202.
The KECCAK algorithm is based on numerous operations with 64bit numbers. Thus, it's recommended to use the
capabilities of a 64bit CPU for the calculation of SHA3 hash values, which is only enabled on 64bit operating
systems. TurboSFV x64 was designed to run in a 64bit environment.

Hash function  Length 
SHA3224  224 bits 
SHA3256  256 bits 
SHA3384  384 bits 
SHA3512  512 bits 

 File extension: sh3
 External links:

BLAKE2 family 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

The hash algorithms from the BLAKE2 family are based on BLAKE, which was one of the finalists in the SHA3 competition
by NIST. BLAKE2 is the successor of BLAKE, optimized for speed and with less memory usage. BLAKE2 is specified in RFC 7693
and claims to be secure.
The algorithms implemented in TurboSFV are BLAKE2S and BLAKE2B: BLAKE2S operates with 32bit integers and is mainly designed
for 32bit CPUs. BLAKE2S produces digests up to 256 bits. BLAKE2B on the other hand works with 64bit numbers and is
optimized for 64bit platforms. BLAKE2B delivers hash digits up to 512 bits.
Both support standardized keyed hashing as well as salt, which are interesting features in the light of future
extensions of TurboSFV.
For BLAKE2, TurboSFV offers digest lengths from 256 bits up to 512 bits, in particular BLAKE2S256, BLAKE2B256,
BLAKE2B384 and BLAKE2B512. Note that BLAKE2S256 produces different hash values comparing to BLAKE2B256.

Hash function  Length 
BLAKE2S256  256 bits 
BLAKE2B256  256 bits 
BLAKE2B384  384 bits 
BLAKE2B512  512 bits 

 File extension: blk
 External links:

xxHash 
TurboSFV LE:  TurboSFV PE:  TurboSFV CE: 

xxHash is an open source project with the goal to develop a fast hash algorithm. The algorithm is not designed to be
used in cryptographic areas and is also not collision resistant.
TurboSFV supports the variants XXH32 and XXH64: XXH32 works with 32bit numbers and is optimized for 32bit environments,
while XXH64 operates with 64bit numbers and is thus optimized for 64bit CPUs. XXH32 produces digits with 32 bits, while
XXH64 delivers a 64bit hash value. Optionally, both can take a seed value as an additional input (similar to salt), but
this is not supported by TurboSFV.
In the current state of development, XXH32 and XXH64 seem to be stable now and thus the checksums produced by them  but
there is no guarantee for it.
The implementation in TurboSFV is in line with the documentation v0.1.1 (10/10/18). TurboSFV doesn't use any of the
libraries provided by the open source project.

Hash function  Length 
XXH32  32 bits 
XXH64  64 bits 

 File extension: xxh
 External links:


