How to natively hash a struct without randomization?

Question

Is it possible to hash a struct without randomization natively in Swift?

struct Kiwi: Hashable {
    let userId: String
    let selections: Set<Int>
    
    init(userId: String, selections: Set<Int>) {
        self.userId = userId
        self.selections = selections
    }

    func hash(into hasher: inout Hasher) {
        hasher.combine(userId)
        hasher.combine(selections)
    }
}

let k1 = Kiwi(userId: "u1", selections: [1])
print(k1.hashValue)

let k2 = Kiwi(userId: "u1", selections: [1])
print(k2.hashValue)

These hash values are not guaranteed to be equal across different points of execution (due to randomization of the hashing function). The purpose of this hash is simply to generate a signature of a struct's values so that they are always the same if the values of the struct are the same, regardless of when it's executed.

For the time being, I've made the struct Equatable and just compare struct instances but would prefer to be able to compare "signatures" (i.e. hashes) instead.

score 2 · Accepted Answer · answered Nov 18 '20 at 17:44

You should make your own protocol, something like:

protocol Signable {
    /// A signature that's stable across app launches
    var signature: Signature { get }
}

Equatable/Hashable are standard protocols with very specific semantics (Equality implies substitutability, and Hashability is a heuristic, as a performance optimization of Equatable). They're not catch-all bags of syntax for anything vaguely similar to equality checking or hashing.

Also beware: the randomly seeded behavior of Hasher is intentional. It protects you against hash-flooding DoS attacks. You should be very careful circumventing this, because you'll be exposing yourself to this vector.

Using signature to compare instances persisted across app launches seems fine. But I would not recommend using that to implement any kind of hashed data structures, which could be attacked to degenerate into linear-time-lookups.

A `Signable` protocol is an attractive solution. Any high-level suggestions on how to generate the signature itself? — lurning too koad, Nov 18 '20 at 18:22
@acidgate Swift's `Hasher` is a concrete type, not a protocol. So unfortunately you can't just make a new implementation. However, you could make your own seperate hash struct. Swift's `Hasher` uses SipHash. It's open source, so you could use that for reference: https://github.com/apple/swift/blob/main/stdlib/public/core/SipHash.swift There's lot of existing packages for SPM that implement SipHash, or many other hashes. Just remember that hash functions have varying applications, with different trade offs. E.g. slow and cryptographicaly secure, vs fast and "good enough" for data structures. — Alexander, Nov 18 '20 at 18:37

How to natively hash a struct without randomization?

1 Answers1