Fowler–Noll–Vo hash function

Short description: Non-cryptographic hash function

Fowler–Noll–Vo (or FNV) is a non-cryptographic hash function created by Glenn Fowler, Landon Curt Noll, and Kiem-Phong Vo.

The basis of the FNV hash algorithm was taken from an idea sent as reviewer comments to the IEEE POSIX P1003.2 committee by Glenn Fowler and Phong Vo in 1991. In a subsequent ballot round, Landon Curt Noll improved on their algorithm. In an email message to Landon, they named it the Fowler/Noll/Vo or FNV hash.[1]

## Contents

* 1 Overview
* 2 The hash
* 2.1 FNV-1 hash
* 2.2 FNV-1a hash
* 2.3 FNV-0 hash (deprecated)
* 2.4 FNV offset basis
* 2.5 FNV prime
* 2.6 FNV hash parameters
* 3 Non-cryptographic hash
* 4 See also
* 5 References
* 6 External links

## Overview

The current versions are FNV-1 and FNV-1a, which supply a means of creating non-zero FNV offset basis. FNV currently comes in 32-, 64-, 128-, 256-, 512-, and 1024-bit variants. For pure FNV implementations, this is determined solely by the availability of FNV primes for the desired bit length; however, the FNV webpage discusses methods of adapting one of the above versions to a smaller length that may or may not be a power of two.[2][3]

The FNV hash algorithms and reference FNV source code[4][5] have been released into the public domain.[6]

The Python programming language previously used a modified version of the FNV scheme for its default `hash` function. From Python 3.4, FNV has been replaced with SipHash to resist "hash flooding" denial-of-service attacks.[7]

FNV is not a cryptographic hash.[4]

## The hash

One of FNV's key advantages is that it is very simple to implement. Start with an initial hash value of FNV offset basis. For each byte in the input, multiply hash by the FNV prime, then XOR it with the byte from the input. The alternate algorithm, FNV-1a, reverses the multiply and XOR steps.

### FNV-1 hash

The FNV-1 hash algorithm is as follows:[8][9]

algorithm fnv-1 is
hash := FNV_offset_basis

for each byte_of_data to be hashed do
hash := hash × FNV_prime
hash := hash XOR byte_of_data

return hash

In the above pseudocode, all variables are unsigned integers. All variables, except for byte_of_data, have the same number of bits as the FNV hash. The variable, byte_of_data, is an 8 bit unsigned integer.

As an example, consider the 64-bit FNV-1 hash:

* All variables, except for byte_of_data, are 64-bit unsigned integers.
* The variable, byte_of_data, is an 8-bit unsigned integer.
* The FNV_offset_basis is the 64-bit FNV offset basis value: 14695981039346656037 (in hex, 0xcbf29ce484222325).
* The FNV_prime is the 64-bit FNV prime value: 1099511628211 (in hex, 0x100000001b3).
* The multiply returns the lower 64-bits of the product.
* The XOR is an 8-bit operation that modifies only the lower 8-bits of the hash value.
* The hash value returned is a 64-bit unsigned integer.

### FNV-1a hash

The FNV-1a hash differs from the FNV-1 hash by only the order in which the multiply and XOR is performed:[8][10]

algorithm fnv-1a is
hash := FNV_offset_basis

for each byte_of_data to be hashed do
hash := hash XOR byte_of_data
hash := hash × FNV_prime

return hash

The above pseudocode has the same assumptions that were noted for the FNV-1 pseudocode. The change in order leads to slightly better avalanche characteristics.[8][11]

### FNV-0 hash (deprecated)

The FNV-0 hash differs from the FNV-1 hash only by the initialisation value of the hash variable:[8][12]

algorithm fnv-0 is
hash := 0

for each byte_of_data to be hashed do
hash := hash × FNV_prime
hash := hash XOR byte_of_data

return hash

The above pseudocode has the same assumptions that were noted for the FNV-1 pseudocode.

A consequence of the initialisation of the hash to 0 is that empty messages and all messages consisting of only the byte 0, regardless of their length, hash to 0.[12]

Use of the FNV-0 hash is deprecated except for the computing of the FNV offset basis for use as the FNV-1 and FNV-1a hash parameters.[8][12]

### FNV offset basis

There are several different FNV offset bases for various bit lengths. These offset bases are computed by computing the FNV-0 from the following 32 octets when expressed in ASCII:

chongo <Landon Curt Noll> /\../\

which is one of Landon Curt Noll's signature lines. This is the only current practical use for the deprecated FNV-0.[8][12]

### FNV prime

An FNV prime is a prime number and is determined as follows:[4][13]

For a given [math]\displaystyle{ s }[/math]:

* [math]\displaystyle{ s\in \mathbb{Z}^*~ }[/math] (i.e., s is an integer)
* [math]\displaystyle{ 4 \lt s \lt 11 }[/math]

where [math]\displaystyle{ n }[/math] is:

* [math]\displaystyle{ n = 2^s }[/math]

and where [math]\displaystyle{ t }[/math] is:

* [math]\displaystyle{ t = \left\lfloor \frac{5+n}{12}\right\rfloor }[/math]

NOTE: [math]\displaystyle{ \lfloor x \rfloor\, }[/math] is the floor function

then the n-bit FNV prime is the smallest prime number [math]\displaystyle{ p }[/math] that is of the form:

[math]\displaystyle{ 256^t + 2^8 + \mathrm{b}\, }[/math]

such that:

* [math]\displaystyle{ 0 \lt b \lt 2^8 }[/math]
* The number of one-bits in the binary number representation of [math]\displaystyle{ b }[/math] is either 4 or 5
* [math]\displaystyle{ p\mod(2^{40} - 2^{24} - 1) \gt (2^{24} + 2^8 + 2^7) }[/math]

Experimentally, FNV prime matching the above constraints tend to have better dispersion properties. They improve the polynomial feedback characteristic when an FNV prime multiplies an intermediate hash value. As such, the hash values produced are more scattered throughout the n-bit hash space.[4][13]

### FNV hash parameters

The above FNV prime constraints and the definition of the FNV offset basis yield the following table of FNV hash parameters:

FNV parameters [4][14] Size in bits

[math]\displaystyle{ n = 2^s }[/math]

| Representation  | FNV prime | FNV offset basis

|
|
|

32  | Expression  | 224 \+ 28 \+ 0x93  |
Decimal  | 16777619  | 2166136261
Hexadecimal | 0x01000193  | 0x811c9dc5
64  | Expression  | 240 \+ 28 \+ 0xb3  |
Decimal  | 1099511628211  | 14695981039346656037
Hexadecimal  | 0x00000100000001B3  | 0xcbf29ce484222325
128  | Representation  | 288 \+ 28 \+ 0x3b  |
Decimal  | 309485009821345068724781371  | 144066263297769815596495629667062367629
Hexadecimal  | 0x0000000001000000000000000000013B  | 0x6c62272e07bb014262b821756295c58d
256  | Representation  | 2168 \+ 28 \+ 0x63  |
Decimal  |

374144419156711147060143317
175368453031918731002211

100029257958052580907070968620625704837
092796014241193945225284501741471925557

Hexadecimal  |

0x00000000000000000000010000000000
00000000000000000000000000000163

0xdd268dbcaac550362d98c384c4e576ccc8b153
6847b6bbb31023b4c8caee0535

512  | Representation  | 2344 \+ 28 \+ 0x57  |
Decimal  |

358359158748448673689190764
890951084499463279557543925
583998256154206699388825751
26094039892345713852759

965930312949666949800943540071631046609
041874567263789610837432943446265799458
293219771643844981305189220653980578449
5328239340083876191928701583869517785

Hexadecimal  |

0x0000000000000000 0000000000000000
0000000001000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000157

0xb86db0b1171f4416 dca1e50f309990ac
ac87d059c9000000 0000000000000d21
e948f68a34c192f6 2ea79bc942dbe7ce
182036415f56e34b ac982aac4afe9fd9

1024  | Representation  | 2680 \+ 28 \+ 0x8d  |
Decimal  |

501645651011311865543459881103
527895503076534540479074430301
752383111205510814745150915769
222029538271616265187852689524
938529229181652437508374669137
180409427187316048473796672026
0389217684476157468082573

14197795064947621068722070641403218320
88062279544193396087847491461758272325
22967323037177221508640965212023555493
65628174669108571814760471015076148029
75596980407732015769245856300321530495
71501574036444603635505054127112859663
61610267868082893823963790439336411086
884584107735010676915

Hexadecimal  |

0x0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000010000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 000000000000018D

0x0000000000000000 005f7a76758ecc4d
32e56d5a591028b7 4b29fc4223fdada1
6c3bf34eda3674da 9a21d90000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 000000000004c6d7
eb6e73802734510a 555f256cc005ae55
6bde8cc9c6a93b21 aff4b16c71ee90b3

## Non-cryptographic hash

The FNV hash was designed for fast hash table and checksum use, not cryptography. The authors have identified the following properties as making the algorithm unsuitable as a cryptographic hash function:[15]

* Speed of computation – As a hash designed primarily for hashtable and checksum use, FNV-1 and FNV-1a were designed to be fast to compute. However, this same speed makes finding specific hash values (collisions) by brute force faster.
* Sticky state – Being an iterative hash based primarily on multiplication and XOR, the algorithm is sensitive to the number zero. Specifically, if the hash value were to become zero at any point during calculation, and the next byte hashed were also all zeroes, the hash would not change. This makes colliding messages trivial to create given a message that results in a hash value of zero at some point in its calculation. Additional operations, such as the addition of a third constant prime on each step, can mitigate this but may have detrimental effects on avalanche effect or random distribution of hash values.
* Diffusion – The ideal secure hash function is one in which each byte of input has an equally-complex effect on every bit of the hash. In the FNV hash, the ones place (the rightmost bit) is always the XOR of the rightmost bit of every input byte. This can be mitigated by XOR-folding (computing a hash twice the desired length, and then XORing the bits in the "upper half" with the bits in the "lower half").[4]

## See also

* Bloom filter (application for fast hashes)
* Non-cryptographic hash functions

## References

1. ↑ "FNV Hash - FNV hash history". http://www.isthe.com/chongo/tech/comp/fnv/index.html#history.
2. ↑ "FNV Hash - Changing the FNV hash size - xor-folding". http://www.isthe.com/chongo/tech/comp/fnv/index.html#xor-fold.
3. ↑ "FNV Hash - Changing the FNV hash size - non-powers of 2". http://www.isthe.com/chongo/tech/comp/fnv/index.html#other-folding.
4. ↑ 4.0 4.1 4.2 4.3 4.4 4.5 Eastlake, Donald; Hansen, Tony; Fowler, Glenn; Vo, Kiem-Phong; Noll, Landon. "The FNV Non-Cryptographic Hash Algorithm". https://tools.ietf.org/html/draft-eastlake-fnv-17.html.
5. ↑ "FNV Hash - FNV source". http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-source.
6. ↑ FNV put into the public domain on isthe.com
7. ↑ "PEP 456 -- Secure and interchangeable hash algorithm". https://www.python.org/dev/peps/pep-0456/.
8. ↑ 8.0 8.1 8.2 8.3 8.4 8.5 Eastlake, Donald; Hansen, Tony; Fowler, Glenn; Vo, Kiem-Phong; <unknown-email-Landon-Noll>, Landon Noll (June 4, 2020). "The FNV Non-Cryptographic Hash Algorithm" (in en). https://tools.ietf.org/html/draft-eastlake-fnv-17.html.
9. ↑ "FNV Hash - The core of the FNV hash". http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-1.
10. ↑ "FNV Hash - FNV-1a alternate algorithm". http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-1a.
11. ↑ "avalanche - murmurhash". https://sites.google.com/site/murmurhash/avalanche.
12. ↑ 12.0 12.1 12.2 12.3 "FNV Hash - FNV-0 Historic not". http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-0.
13. ↑ 13.0 13.1 "FNV Hash - A few remarks on FNV primes". http://www.isthe.com/chongo/tech/comp/fnv/index.html#fnv-prime.
14. ↑ "FNV Hash - Parameters of the FNV-1/FNV-1a hash". http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param.
15. ↑ Eastlake, Donald; Hansen, Tony; Fowler, Glenn; Vo, Kiem-Phong; Noll, Landon. "The FNV Non-Cryptographic Hash Algorithm" (in en). https://tools.ietf.org/html/draft-eastlake-fnv-17.html.

## External links

* Landon Curt Noll's webpage on FNV (with table of base & prime parameters)
* Internet draft by Fowler, Noll, Vo, and Eastlake (IETF Informational Internet Draft)

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Fowler–Noll–Vo hash function. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Fowler–Noll–Vo_hash_function&oldid=3368135"