highwayhash

> why is "iteration" even possible over a hash table? Going through all items in a container seems like a logical thing to want to do. > Shouldn't the keys be specified as a "set" on which only set-appropriate operations like map can be performed? Efficient implementation (in space and time) of these set operations would limit the possible efficient implementations of a hash table (i.e. to using the hash value as a key in an ordered map). Going one step further, this guarantee would freeze behaviour of the hash function (and how they are combined) for all time; optimisations for different architectures would not be possible, nor would avoiding hash collision attacks by changing seeds. Sometimes hash value stability is what you want (e.g. when transmitting data in space and time), so "frozen" hash functions give these guarantees e.g. https

Probably performance impact is little but still noticeable for a large project ,maybe even with modern hardware but wouldnt a portable approach would be better? Not the security but performance perspective maybe one would prefer cheap calculation, i.e. ext4 pre-calculate already crc32c , just found out google added alternative highwayhash recommends and claims it is faster. https://github.com/google/highwayhash

Google made faster Siphash variants, and also HighwayHash that's much faster. https://github.com/google/highwayhash

I'm curious what the article is referring to when it comes to collision resistance. I was looking at the GitHub repo posted below and saw only claims of "strong" collision resistance: https://github.com/google/highwayhash Unfortunately I'm not familiar enough with the details of the collision resistance properties of the other hash functions here to know how they compare. Could someone elaborate on the specifics of why HighwayHash compares poorly in terms of collision resistance to the others in the benchmark?

They claim the same "fastness" as Siphash whilst actually being on the slower end of all good hash functions. Too slow for real world usage, and not secure enough for real world security attacks. Compare https://github.com/rurban/smhasher and my complaints https://github.com/google/highwayhash/issues/28

This is a pretty sweet hash function, with security guarantees similar to SipHash but about 5x faster. Here's more info: https://github.com/google/highwayhash

HighwayHash uses PSHUFB to spread entropy from twin 32x32=64 muls across 128-bit vectors [or vector halves, on AVX2]. See ZipperMerge in https://github.com/google/highwayhash/blob/master/highwayhas....

The critique. There's more rambling by (I think) the same author here: https://github.com/google/highwayhash/issues/28 His arguments are a little inconsistent and ambiguous, which suggests either a misunderstanding, perhaps a touch of mania, or both. But they're all wrong--whether at face value or when assuming the best possible version--at least regarding the security and the ease of generating collisions. As for the argument that SipHash is too slow, that's a qualitative judgment that many people have made. But they don't usually need to first convince themselves, erroneously, that SipHash is insecure.

I didn't know much about this argument so I looked it up and funny enough it's you arguing here too: https://github.com/google/highwayhash/issues/28 Still trying to wrap my head around exactly what is being argued... but it's starting to feel like there's something personal going on here, not gonna lie. It's a bit quaint. (Also a bit curious why Rust is looped into this. It seems like Rust was insecure because the same key was being used for all tables, not really because the hash function was insecure?)

"smhasher discussions" where? This is not an answer. Especially regarding "4 min" re siphash, about which kind of attack do you talk about at all, under which conditions? The writings of those who try to protect from flooding attacks are more specific, e.g.: https://github.com/google/highwayhash "The author of SipHash has published C++ programs to generate" "'universal (key-independent) multicollisions' for CityHash and Murmur. Similar 'differential' attacks are likely possible for any hash function consisting only of reversible operations" "attackers are only looking for multiple m mapping to the same bin rather than identical hash values." "a strong hash function is not, by itself, sufficient to protect a chained hash table from flooding attacks. However, strong hash functions are important parts of two schemes for preventing denial of

HighwayHash is a new and very fast pseudo-random-function (PRF) developed by Jyrki Alakuijala, Bill Cox and Jan Wassenberg from Google research. The algorithm takes a 256-bit key and computes 64-, 128- or 256-bit hash values of given messages. HighwayHash can be used to prevent hash-flooding attacks or authenticate short-lived messages. Additionally it can be used as a fingerprinting function. Note that HighwayHash is not a general purpose cryptographic hash function (such as Blake2b, SHA-3 or SHA-2) and should not be used if strong collision resistance is required. At Minio we have developed a native Golang repository for HighwayHash with optimized assembly implementations for both Intel and ARM platforms. We will switch over the bit rot protection that is currently relying on the Blake2b algorithm to HighwayHash. Google repo: https://gi

There was a recent effort by Google to speed up SipHash, it's called HighwayHash: https://github.com/google/highwayhash - it includes a compatible, optimized SipHash implementation (1.5x speedup), a variation on that that is not compatible but similar, SipTreeHash (3x speedup on top of optimized implementation) and a new algorithm, HighwayHash, that yields another factor of 2-3. I haven't yet used it myself but it looks interesting and might be relevant to Rust? Edited to add that Google's implementation targets Haswell and later (AVX-2), I don't know about the performance of an implementation that targets older CPUs which would of course be very relevant for Rust