MessageAuthenticationHash.swift

/// A hash that can be used to generate a message authentication code (MAC).
public
protocol MessageAuthenticationHash:RandomAccessCollection<UInt8> where Index == Int
{
    /// The natural block stride of this hash function.
    static
    var stride:Int { get }

    /// The output size, in bytes, of this hash function.
    static
    var count:Int { get }

    /// Computes an instance of this hash for the given message.
    init(hashing message:some Collection<UInt8>)
}
extension MessageAuthenticationHash
{
    @inlinable public
    var endIndex:Int
    {
        self.startIndex + Self.count
    }
    @inlinable public
    var count:Int
    {
        Self.count
    }
}
extension MessageAuthenticationHash
{
    /// Computes a hash-based message authentication code (HMAC) for
    /// the given message using the given key.
    ///
    /// This initializer computes an instance of ``MessageAuthenticationKey``
    /// and uses it to generate an instance of `Self`. If you are reusing
    /// the same `key` multiple times, it is more efficient to compute the
    /// message authentication key externally and call its
    /// ``MessageAuthenticationKey.authenticate(_:)`` method instead.
    @inlinable public
    init(authenticating message:some Sequence<UInt8>, key:some Collection<UInt8>)
    {
        let key:MessageAuthenticationKey<Self> = .init(key)
        self = key.authenticate(message)
    }
}

extension MessageAuthenticationHash
{
    /// Derives an encryption key from a password and salt.
    /// This is a password-based key derivation function
    /// ([PBKDR2](https://en.wikipedia.org/wiki/PBKDF2)).
    @inlinable public static
    func pbkdf2(
        password:some Collection<UInt8>,
        salt:some Collection<UInt8>,
        iterations:Int,
        blocks:Int = 1) -> [UInt8]
    {
        let key:MessageAuthenticationKey<Self> = .init(password)
        return key.derive(salt: salt, iterations: iterations, blocks: blocks)
    }
}