Skip to content
Standard libraryZig 0.17.1Official documentation
Sourcestd/crypto/sha3.zig

Source line 1

std.crypto.sha3.assert

alias

Source line 3

Alias of std.debug.assert

std.crypto.sha3.builtin

constant

Source line 1

std.crypto.sha3.CShake

type-function

Source line 199

The cSHAKE extendable output hash function. cSHAKE is similar to SHAKE, but in addition to the input message, it also takes an optional context (aka customization string).

pub fn CShake(comptime security_level: u11, comptime fname: ?[]const u8) type

Parameters

security_level: u11
fname: ?[]const u8

Fields

shaker: Shaker

std.crypto.sha3.CShake128

type

Source line 22

std.crypto.sha3.CShake256

type

Source line 23

std.crypto.sha3.CShakeLike

type-function

Source line 203

fn CShakeLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5, comptime fname: ?[]const u8) type

Parameters

security_level: u11
default_delim: u8
rounds: u5
fname: ?[]const u8

Fields

shaker: Shaker

std.crypto.sha3.CShakeLike.block_length

constant

Source line 211

The block length, or rate, in bytes.

std.crypto.sha3.CShakeLike.digest_length

constant

Source line 209

The recommended output length, in bytes.

std.crypto.sha3.CShakeLike.fillBlock

function

Source line 272

Align the input to a block boundary.

pub fn fillBlock(self: *Self) void

Parameters

self: *Self

std.crypto.sha3.CShakeLike.final

function

Source line 267

Return the hash of the absorbed bytes. out can be of any length, but the function must not be called multiple times (use squeeze for that purpose instead).

pub fn final(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.CShakeLike.hash

function

Source line 248

Hash a slice of bytes. out can be any length.

pub fn hash(bytes: []const u8, out: []u8, options: Options) void

Parameters

bytes: []const u8
out: []u8
options: Options

std.crypto.sha3.CShakeLike.init

function

Source line 219

Initialize a SHAKE extensible hash function.

pub fn init(options: Options) Self

Parameters

options: Options

std.crypto.sha3.CShakeLike.Options

container

Source line 214

cSHAKE options can include a context string.

Fields

context: ?[]const u8 = null

std.crypto.sha3.CShakeLike.Self

alias

Source line 216

Alias of std.crypto.sha3.CShakeLike

std.crypto.sha3.CShakeLike.Shaker

type

Source line 205

std.crypto.sha3.CShakeLike.squeeze

function

Source line 261

Squeeze a slice of bytes from the state. out can be any length, and the function can be called multiple times.

pub fn squeeze(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.CShakeLike.update

function

Source line 255

Absorb a slice of bytes into the state.

pub fn update(self: *Self, bytes: []const u8) void

Parameters

self: *Self
bytes: []const u8

std.crypto.sha3.htest

constant

Source line 493

std.crypto.sha3.kangarootwelve

alias

Source line 7

Alias of std.crypto.kangarootwelve

std.crypto.sha3.Keccak

type-function

Source line 50

A generic Keccak hash function.

pub fn Keccak(comptime f: u11, comptime output_bits: u11, comptime default_delim: u8, comptime rounds: u5) type

Parameters

f: u11
output_bits: u11
default_delim: u8
rounds: u5

Fields

st: State

std.crypto.sha3.Keccak.block_length

constant

Source line 63

The block length, or rate, in bytes.

std.crypto.sha3.Keccak.digest_length

constant

Source line 61

The output length, in bytes.

comptime_int

std.crypto.sha3.Keccak.final

function

Source line 85

Return the hash of the absorbed bytes.

pub fn final(self: *Self, out: *[digest_length]u8) void

Parameters

self: *Self
out: *[digest_length]u8

std.crypto.sha3.Keccak.finalResult

function

Source line 90

pub fn finalResult(d: *Self) [digest_length]u8

Parameters

d: *Self

std.crypto.sha3.Keccak.hash

function

Source line 73

Hash a slice of bytes.

pub fn hash(bytes: []const u8, out: *[digest_length]u8, options: Options) void

Parameters

bytes: []const u8
out: *[digest_length]u8
options: Options

std.crypto.sha3.Keccak.init

function

Source line 68

Initialize a Keccak hash function.

pub fn init(options: Options) Self

Parameters

options: Options

std.crypto.sha3.Keccak.Options

container

Source line 65

The delimiter can be overwritten in the options.

Fields

delim: u8 = default_delim

std.crypto.sha3.Keccak.Self

alias

Source line 56

Alias of std.crypto.sha3.Keccak

std.crypto.sha3.Keccak.update

function

Source line 80

Absorb a slice of bytes into the state.

pub fn update(self: *Self, bytes: []const u8) void

Parameters

self: *Self
bytes: []const u8

std.crypto.sha3.Keccak256

type

Source line 16

std.crypto.sha3.Keccak512

type

Source line 17

std.crypto.sha3.KeccakState

alias

Source line 9

Alias of std.crypto.keccak_p.State

std.crypto.sha3.KMac

type-function

Source line 281

The KMAC extendable output authentication function. KMAC is a keyed version of the cSHAKE function, with an optional context. It can be used as an SHA-3 based alternative to HMAC, as well as a generic keyed XoF (extendable output function).

pub fn KMac(comptime security_level: u11) type

Parameters

security_level: u11

Fields

cshaker: CShaker
xof_mode: bool = false

std.crypto.sha3.KMac128

type

Source line 25

std.crypto.sha3.KMac256

type

Source line 26

std.crypto.sha3.KMacLike

type-function

Source line 285

fn KMacLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type

Parameters

security_level: u11
default_delim: u8
rounds: u5

Fields

cshaker: CShaker
xof_mode: bool = false

std.crypto.sha3.KMacLike.block_length

constant

Source line 300

The block length, or rate, in bytes.

std.crypto.sha3.KMacLike.create

function

Source line 364

Return an authentication tag for a message and a key.

pub fn create(out: []u8, msg: []const u8, key: []const u8) void

Parameters

out: []u8
msg: []const u8
key: []const u8

std.crypto.sha3.KMacLike.createWithOptions

function

Source line 357

Return an authentication tag for a message and a key, with an optional context.

pub fn createWithOptions(out: []u8, msg: []const u8, key: []const u8, options: Options) void

Parameters

out: []u8
msg: []const u8
key: []const u8
options: Options

std.crypto.sha3.KMacLike.final

function

Source line 339

Return an authentication tag for the current state.

pub fn final(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.KMacLike.init

function

Source line 329

Initialize a state for the KMAC function. If the context and key are going to be reused, the structure can be initialized once, and cloned for each message. This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.

pub fn init(key: []const u8) Self

Parameters

key: []const u8

std.crypto.sha3.KMacLike.initWithOptions

function

Source line 313

Initialize a state for the KMAC function, with an optional context and an arbitrary-long key. If the context and key are going to be reused, the structure can be initialized once, and cloned for each message. This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.

pub fn initWithOptions(key: []const u8, options: Options) Self

Parameters

key: []const u8
options: Options

std.crypto.sha3.KMacLike.key_length

constant

Source line 296

The recommended key length, in bytes.

std.crypto.sha3.KMacLike.key_length_min

constant

Source line 298

The minimum key length, in bytes.

std.crypto.sha3.KMacLike.mac_length

constant

Source line 292

The recommended output length, in bytes.

std.crypto.sha3.KMacLike.mac_length_min

constant

Source line 294

The minimum output length, in bytes.

std.crypto.sha3.KMacLike.Options

container

Source line 306

KMAC options can include a context string.

Fields

context: ?[]const u8 = null

std.crypto.sha3.KMacLike.Self

alias

Source line 289

Alias of std.crypto.sha3.KMacLike

std.crypto.sha3.KMacLike.squeeze

function

Source line 347

Squeeze a slice of bytes from the state. out can be any length, and the function can be called multiple times.

pub fn squeeze(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.KMacLike.update

function

Source line 334

Add data to the state.

pub fn update(self: *Self, b: []const u8) void

Parameters

self: *Self
b: []const u8

std.crypto.sha3.KT128

alias

Source line 31

Alias of std.crypto.kangarootwelve.KT128

std.crypto.sha3.KT256

alias

Source line 32

Alias of std.crypto.kangarootwelve.KT256

std.crypto.sha3.math

alias

Source line 4

Alias of std.math

std.crypto.sha3.mem

alias

Source line 5

Alias of std.mem

std.crypto.sha3.NistLengthEncoding

container

Source line 453

The NIST SP 800-185 encoded length format.

Fields

left
right

std.crypto.sha3.NistLengthEncoding.encode

function

Source line 471

Encode a length according to NIST SP 800-185.

pub fn encode(comptime encoding: NistLengthEncoding, len: usize) Length

Parameters

encoding: NistLengthEncoding
len: usize

std.crypto.sha3.NistLengthEncoding.Length

container

Source line 458

A length encoded according to NIST SP 800-185.

Fields

len: usize = 0

The size of the encoded value, in bytes.

buf: [@sizeOf(usize) + 1]u8 = undefined

A buffer to store the encoded length.

std.crypto.sha3.NistLengthEncoding.Length.slice

function

Source line 465

Return the encoded length as a slice.

pub fn slice(self: *const Length) []const u8

Parameters

self: *const Length

std.crypto.sha3.Sha3_224

type

Source line 11

std.crypto.sha3.Sha3_256

type

Source line 12

std.crypto.sha3.Sha3_384

type

Source line 13

std.crypto.sha3.Sha3_512

type

Source line 14

std.crypto.sha3.Shake

type-function

Source line 99

The SHAKE extendable output hash function.

pub fn Shake(comptime security_level: u11) type

Parameters

security_level: u11

Fields

st: State
buf: [State.rate]u8 = undefined
offset: usize = 0
padded: bool = false

std.crypto.sha3.Shake128

type

Source line 19

std.crypto.sha3.Shake256

type

Source line 20

std.crypto.sha3.ShakeLike

type-function

Source line 114

fn ShakeLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type

Parameters

security_level: u11
default_delim: u8
rounds: u5

Fields

st: State
buf: [State.rate]u8 = undefined
offset: usize = 0
padded: bool = false

std.crypto.sha3.ShakeLike.block_length

constant

Source line 129

The block length, or rate, in bytes.

std.crypto.sha3.ShakeLike.digest_length

constant

Source line 127

The recommended output length, in bytes.

std.crypto.sha3.ShakeLike.fillBlock

function

Source line 191

Align the input to a block boundary.

pub fn fillBlock(self: *Self) void

Parameters

self: *Self

std.crypto.sha3.ShakeLike.final

function

Source line 185

Return the hash of the absorbed bytes. out can be of any length, but the function must not be called multiple times (use squeeze for that purpose instead).

pub fn final(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.ShakeLike.hash

function

Source line 140

Hash a slice of bytes. out can be any length.

pub fn hash(bytes: []const u8, out: []u8, options: Options) void

Parameters

bytes: []const u8
out: []u8
options: Options

std.crypto.sha3.ShakeLike.init

function

Source line 134

Initialize a SHAKE extensible hash function.

pub fn init(options: Options) Self

Parameters

options: Options

std.crypto.sha3.ShakeLike.Options

container

Source line 131

The delimiter can be overwritten in the options.

Fields

delim: u8 = default_delim

std.crypto.sha3.ShakeLike.Self

alias

Source line 119

Alias of std.crypto.sha3.ShakeLike

std.crypto.sha3.ShakeLike.squeeze

function

Source line 153

Squeeze a slice of bytes from the state. out can be any length, and the function can be called multiple times.

pub fn squeeze(self: *Self, out_: []u8) void

Parameters

self: *Self
out_: []u8

std.crypto.sha3.ShakeLike.update

function

Source line 147

Absorb a slice of bytes into the state.

pub fn update(self: *Self, bytes: []const u8) void

Parameters

self: *Self
bytes: []const u8

std.crypto.sha3.std

alias

Source line 2

Alias of std

std.crypto.sha3.TupleHash

type-function

Source line 380

The TupleHash extendable output hash function, with domain-separated inputs. TupleHash is a secure hash function with a variable output length, based on the cSHAKE function. It is designed for unambiguously hashing tuples of data.

With most hash functions, calling update("A") followed by update("B")is identical to update("AB"). With TupleHash, this is not the case: update("A"); update("B") is different from update("AB").

Any number of inputs can be hashed, and the output depends on individual inputs and their order.

pub fn TupleHash(comptime security_level: u11) type

Parameters

security_level: u11

Fields

cshaker: CShaker
xof_mode: bool = false

std.crypto.sha3.TupleHash128

type

Source line 28

std.crypto.sha3.TupleHash256

type

Source line 29

std.crypto.sha3.TupleHashLike

type-function

Source line 384

fn TupleHashLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type

Parameters

security_level: u11
default_delim: u8
rounds: u5

Fields

cshaker: CShaker
xof_mode: bool = false

std.crypto.sha3.TupleHashLike.block_length

constant

Source line 393

The block length, or rate, in bytes.

std.crypto.sha3.TupleHashLike.digest_length

constant

Source line 391

The output length, in bytes.

std.crypto.sha3.TupleHashLike.fillBlock

function

Source line 435

Align the input to a block boundary.

pub fn fillBlock(self: *Self) void

Parameters

self: *Self

std.crypto.sha3.TupleHashLike.final

function

Source line 428

Return an authentication tag for the current state.

pub fn final(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.TupleHashLike.init

function

Source line 416

Initialize a state for the MAC function.

pub fn init() Self

std.crypto.sha3.TupleHashLike.initWithOptions

function

Source line 408

Initialize a state for the TupleHash function, with an optional context. If the context is going to be reused, the structure can be initialized once, and cloned for each message. This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.

A key can be optionally added to the context to create a keyed TupleHash function, similar to KMAC.

pub fn initWithOptions(options: Options) Self

Parameters

options: Options

std.crypto.sha3.TupleHashLike.Options

container

Source line 399

TupleHash options can include a context string.

Fields

context: ?[]const u8 = null

std.crypto.sha3.TupleHashLike.Self

alias

Source line 388

Alias of std.crypto.sha3.TupleHashLike

std.crypto.sha3.TupleHashLike.squeeze

function

Source line 441

Squeeze a slice of bytes from the state. out can be any length, and the function can be called multiple times.

pub fn squeeze(self: *Self, out: []u8) void

Parameters

self: *Self
out: []u8

std.crypto.sha3.TupleHashLike.update

function

Source line 421

Add data to the state, separated from previous updates.

pub fn update(self: *Self, b: []const u8) void

Parameters

self: *Self
b: []const u8

std.crypto.sha3.TurboShake

type-function

Source line 107

The TurboSHAKE extendable output hash function. It is based on the same permutation as SHA3 and SHAKE, but which much higher performance. The delimiter is 0x1f by default, but can be changed for context-separation. https://eprint.iacr.org/2023/342

pub fn TurboShake(comptime security_level: u11, comptime delim: ?u7) type

Parameters

security_level: u11
delim: ?u7

Fields

st: State
buf: [State.rate]u8 = undefined
offset: usize = 0
padded: bool = false

std.crypto.sha3.TurboShake128

type-function

Source line 38

TurboSHAKE128 is a XOF (a secure hash function with a variable output length), with a 128 bit security level. It is based on the same permutation as SHA3 and SHAKE128, but which much higher performance. The delimiter is 0x1f by default, but can be changed for context-separation. For a protocol that uses both KangarooTwelve and TurboSHAKE128, it is recommended to avoid using 0x06, 0x07 or 0x0b for the delimiter.

pub fn TurboShake128(delim: ?u7) type

Parameters

delim: ?u7

Fields

st: State
buf: [State.rate]u8 = undefined
offset: usize = 0
padded: bool = false

std.crypto.sha3.TurboShake256

type-function

Source line 45

TurboSHAKE256 is a XOF (a secure hash function with a variable output length), with a 256 bit security level. It is based on the same permutation as SHA3 and SHAKE256, but which much higher performance. The delimiter is 0x1f by default, but can be changed for context-separation.

pub fn TurboShake256(comptime delim: ?u7) type

Parameters

delim: ?u7

Fields

st: State
buf: [State.rate]u8 = undefined
offset: usize = 0
padded: bool = false
Source code

std/crypto/sha3.zig

const builtin = @import("builtin");
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;

const kangarootwelve = @import("kangarootwelve.zig");

const KeccakState = std.crypto.core.keccak.State;

pub const Sha3_224 = Keccak(1600, 224, 0x06, 24);
pub const Sha3_256 = Keccak(1600, 256, 0x06, 24);
pub const Sha3_384 = Keccak(1600, 384, 0x06, 24);
pub const Sha3_512 = Keccak(1600, 512, 0x06, 24);

pub const Keccak256 = Keccak(1600, 256, 0x01, 24);
pub const Keccak512 = Keccak(1600, 512, 0x01, 24);

pub const Shake128 = Shake(128);
pub const Shake256 = Shake(256);

pub const CShake128 = CShake(128, null);
pub const CShake256 = CShake(256, null);

pub const KMac128 = KMac(128);
pub const KMac256 = KMac(256);

pub const TupleHash128 = TupleHash(128);
pub const TupleHash256 = TupleHash(256);

pub const KT128 = kangarootwelve.KT128;
pub const KT256 = kangarootwelve.KT256;

/// TurboSHAKE128 is a XOF (a secure hash function with a variable output length), with a 128 bit security level.
/// It is based on the same permutation as SHA3 and SHAKE128, but which much higher performance.
/// The delimiter is 0x1f by default, but can be changed for context-separation.
/// For a protocol that uses both KangarooTwelve and TurboSHAKE128, it is recommended to avoid using 0x06, 0x07 or 0x0b for the delimiter.
pub fn TurboShake128(delim: ?u7) type {
    return TurboShake(128, delim);
}

/// TurboSHAKE256 is a XOF (a secure hash function with a variable output length), with a 256 bit security level.
/// It is based on the same permutation as SHA3 and SHAKE256, but which much higher performance.
/// The delimiter is 0x1f by default, but can be changed for context-separation.
pub fn TurboShake256(comptime delim: ?u7) type {
    return TurboShake(256, delim);
}

/// A generic Keccak hash function.
pub fn Keccak(comptime f: u11, comptime output_bits: u11, comptime default_delim: u8, comptime rounds: u5) type {
    comptime assert(output_bits > 0 and output_bits * 2 < f and output_bits % 8 == 0); // invalid output length

    const State = KeccakState(f, output_bits * 2, rounds);

    return struct {
        const Self = @This();

        st: State,

        /// The output length, in bytes.
        pub const digest_length: comptime_int = @divCeil(output_bits, 8);
        /// The block length, or rate, in bytes.
        pub const block_length = State.rate;
        /// The delimiter can be overwritten in the options.
        pub const Options = struct { delim: u8 = default_delim };

        /// Initialize a Keccak hash function.
        pub fn init(options: Options) Self {
            return Self{ .st = .{ .delim = options.delim } };
        }

        /// Hash a slice of bytes.
        pub fn hash(bytes: []const u8, out: *[digest_length]u8, options: Options) void {
            var st = Self.init(options);
            st.update(bytes);
            st.final(out);
        }

        /// Absorb a slice of bytes into the state.
        pub fn update(self: *Self, bytes: []const u8) void {
            self.st.absorb(bytes);
        }

        /// Return the hash of the absorbed bytes.
        pub fn final(self: *Self, out: *[digest_length]u8) void {
            self.st.pad();
            self.st.squeeze(out[0..]);
        }

        pub fn finalResult(d: *Self) [digest_length]u8 {
            var result: [digest_length]u8 = undefined;
            d.final(&result);
            return result;
        }
    };
}

/// The SHAKE extendable output hash function.
pub fn Shake(comptime security_level: u11) type {
    return ShakeLike(security_level, 0x1f, 24);
}

/// The TurboSHAKE extendable output hash function.
/// It is based on the same permutation as SHA3 and SHAKE, but which much higher performance.
/// The delimiter is 0x1f by default, but can be changed for context-separation.
/// https://eprint.iacr.org/2023/342
pub fn TurboShake(comptime security_level: u11, comptime delim: ?u7) type {
    comptime assert(security_level <= 256);
    const d = delim orelse 0x1f;
    comptime assert(d >= 0x01); // delimiter must be >= 1
    return ShakeLike(security_level, d, 12);
}

fn ShakeLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type {
    const f = 1600;
    const State = KeccakState(f, security_level * 2, rounds);

    return struct {
        const Self = @This();

        st: State,
        buf: [State.rate]u8 = undefined,
        offset: usize = 0,
        padded: bool = false,

        /// The recommended output length, in bytes.
        pub const digest_length = security_level / 8 * 2;
        /// The block length, or rate, in bytes.
        pub const block_length = State.rate;
        /// The delimiter can be overwritten in the options.
        pub const Options = struct { delim: u8 = default_delim };

        /// Initialize a SHAKE extensible hash function.
        pub fn init(options: Options) Self {
            return Self{ .st = .{ .delim = options.delim } };
        }

        /// Hash a slice of bytes.
        /// `out` can be any length.
        pub fn hash(bytes: []const u8, out: []u8, options: Options) void {
            var st = Self.init(options);
            st.update(bytes);
            st.squeeze(out);
        }

        /// Absorb a slice of bytes into the state.
        pub fn update(self: *Self, bytes: []const u8) void {
            self.st.absorb(bytes);
        }

        /// Squeeze a slice of bytes from the state.
        /// `out` can be any length, and the function can be called multiple times.
        pub fn squeeze(self: *Self, out_: []u8) void {
            if (!self.padded) {
                self.st.pad();
                self.padded = true;
            }
            var out = out_;
            if (self.offset > 0) {
                const left = self.buf.len - self.offset;
                if (left > 0) {
                    const n = @min(left, out.len);
                    @memcpy(out[0..n], self.buf[self.offset..][0..n]);
                    out = out[n..];
                    self.offset += n;
                    if (out.len == 0) {
                        return;
                    }
                }
            }
            const full_blocks = out[0 .. out.len - out.len % State.rate];
            if (full_blocks.len > 0) {
                self.st.squeeze(full_blocks);
                out = out[full_blocks.len..];
            }
            if (out.len > 0) {
                self.st.squeeze(self.buf[0..]);
                @memcpy(out[0..], self.buf[0..out.len]);
                self.offset = out.len;
            }
        }

        /// Return the hash of the absorbed bytes.
        /// `out` can be of any length, but the function must not be called multiple times (use `squeeze` for that purpose instead).
        pub fn final(self: *Self, out: []u8) void {
            self.squeeze(out);
            self.st.st.clear(0, State.rate);
        }

        /// Align the input to a block boundary.
        pub fn fillBlock(self: *Self) void {
            self.st.fillBlock();
        }
    };
}

/// The cSHAKE extendable output hash function.
/// cSHAKE is similar to SHAKE, but in addition to the input message, it also takes an optional context (aka customization string).
pub fn CShake(comptime security_level: u11, comptime fname: ?[]const u8) type {
    return CShakeLike(security_level, 0x04, 24, fname);
}

fn CShakeLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5, comptime fname: ?[]const u8) type {
    return struct {
        const Shaker = ShakeLike(security_level, default_delim, rounds);
        shaker: Shaker,

        /// The recommended output length, in bytes.
        pub const digest_length = Shaker.digest_length;
        /// The block length, or rate, in bytes.
        pub const block_length = Shaker.block_length;

        /// cSHAKE options can include a context string.
        pub const Options = struct { context: ?[]const u8 = null };

        const Self = @This();

        /// Initialize a SHAKE extensible hash function.
        pub fn init(options: Options) Self {
            if (fname == null and options.context == null) {
                return Self{ .shaker = Shaker.init(.{ .delim = 0x1f }) };
            }
            var shaker = Shaker.init(.{});
            comptime assert(Shaker.block_length % 8 == 0);
            const encoded_rate_len = NistLengthEncoding.encode(.left, block_length / 8);
            shaker.update(encoded_rate_len.slice());
            const encoded_zero = comptime NistLengthEncoding.encode(.left, 0);
            if (fname) |name| {
                const encoded_fname_len = comptime NistLengthEncoding.encode(.left, name.len);
                const encoded_fname = comptime encoded_fname_len.slice() ++ name;
                shaker.update(encoded_fname);
            } else {
                shaker.update(encoded_zero.slice());
            }
            if (options.context) |context| {
                const encoded_context_len = NistLengthEncoding.encode(.left, context.len);
                shaker.update(encoded_context_len.slice());
                shaker.update(context);
            } else {
                shaker.update(encoded_zero.slice());
            }
            shaker.st.fillBlock();
            return Self{ .shaker = shaker };
        }

        /// Hash a slice of bytes.
        /// `out` can be any length.
        pub fn hash(bytes: []const u8, out: []u8, options: Options) void {
            var st = Self.init(options);
            st.update(bytes);
            st.squeeze(out);
        }

        /// Absorb a slice of bytes into the state.
        pub fn update(self: *Self, bytes: []const u8) void {
            self.shaker.update(bytes);
        }

        /// Squeeze a slice of bytes from the state.
        /// `out` can be any length, and the function can be called multiple times.
        pub fn squeeze(self: *Self, out: []u8) void {
            self.shaker.squeeze(out);
        }

        /// Return the hash of the absorbed bytes.
        /// `out` can be of any length, but the function must not be called multiple times (use `squeeze` for that purpose instead).
        pub fn final(self: *Self, out: []u8) void {
            self.shaker.final(out);
        }

        /// Align the input to a block boundary.
        pub fn fillBlock(self: *Self) void {
            self.shaker.fillBlock();
        }
    };
}

/// The KMAC extendable output authentication function.
/// KMAC is a keyed version of the cSHAKE function, with an optional context.
/// It can be used as an SHA-3 based alternative to HMAC, as well as a generic keyed XoF (extendable output function).
pub fn KMac(comptime security_level: u11) type {
    return KMacLike(security_level, 0x04, 24);
}

fn KMacLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type {
    const CShaker = CShakeLike(security_level, default_delim, rounds, "KMAC");

    return struct {
        const Self = @This();

        /// The recommended output length, in bytes.
        pub const mac_length = CShaker.digest_length;
        /// The minimum output length, in bytes.
        pub const mac_length_min = 4;
        /// The recommended key length, in bytes.
        pub const key_length = security_level / 8;
        /// The minimum key length, in bytes.
        pub const key_length_min = 0;
        /// The block length, or rate, in bytes.
        pub const block_length = CShaker.block_length;

        cshaker: CShaker,
        xof_mode: bool = false,

        /// KMAC options can include a context string.
        pub const Options = struct {
            context: ?[]const u8 = null,
        };

        /// Initialize a state for the KMAC function, with an optional context and an arbitrary-long key.
        /// If the context and key are going to be reused, the structure can be initialized once, and cloned for each message.
        /// This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.
        pub fn initWithOptions(key: []const u8, options: Options) Self {
            var cshaker = CShaker.init(.{ .context = options.context });
            const encoded_rate_len = NistLengthEncoding.encode(.left, block_length / 8);
            cshaker.update(encoded_rate_len.slice());
            const encoded_key_len = NistLengthEncoding.encode(.left, key.len);
            cshaker.update(encoded_key_len.slice());
            cshaker.update(key);
            cshaker.fillBlock();
            return Self{
                .cshaker = cshaker,
            };
        }

        /// Initialize a state for the KMAC function.
        /// If the context and key are going to be reused, the structure can be initialized once, and cloned for each message.
        /// This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.
        pub fn init(key: []const u8) Self {
            return initWithOptions(key, .{});
        }

        /// Add data to the state.
        pub fn update(self: *Self, b: []const u8) void {
            self.cshaker.update(b);
        }

        /// Return an authentication tag for the current state.
        pub fn final(self: *Self, out: []u8) void {
            const encoded_out_len = NistLengthEncoding.encode(.right, out.len);
            self.update(encoded_out_len.slice());
            self.cshaker.final(out);
        }

        /// Squeeze a slice of bytes from the state.
        /// `out` can be any length, and the function can be called multiple times.
        pub fn squeeze(self: *Self, out: []u8) void {
            if (!self.xof_mode) {
                const encoded_out_len = comptime NistLengthEncoding.encode(.right, 0);
                self.update(encoded_out_len.slice());
                self.xof_mode = true;
            }
            self.cshaker.squeeze(out);
        }

        /// Return an authentication tag for a message and a key, with an optional context.
        pub fn createWithOptions(out: []u8, msg: []const u8, key: []const u8, options: Options) void {
            var ctx = Self.initWithOptions(key, options);
            ctx.update(msg);
            ctx.final(out);
        }

        /// Return an authentication tag for a message and a key.
        pub fn create(out: []u8, msg: []const u8, key: []const u8) void {
            var ctx = Self.init(key);
            ctx.update(msg);
            ctx.final(out);
        }
    };
}

/// The TupleHash extendable output hash function, with domain-separated inputs.
/// TupleHash is a secure hash function with a variable output length, based on the cSHAKE function.
/// It is designed for unambiguously hashing tuples of data.
///
/// With most hash functions, calling `update("A")` followed by `update("B")`is identical to `update("AB")`.
/// With TupleHash, this is not the case: `update("A"); update("B")` is different from `update("AB")`.
///
/// Any number of inputs can be hashed, and the output depends on individual inputs and their order.
pub fn TupleHash(comptime security_level: u11) type {
    return TupleHashLike(security_level, 0x04, 24);
}

fn TupleHashLike(comptime security_level: u11, comptime default_delim: u8, comptime rounds: u5) type {
    const CShaker = CShakeLike(security_level, default_delim, rounds, "TupleHash");

    return struct {
        const Self = @This();

        /// The output length, in bytes.
        pub const digest_length = CShaker.digest_length;
        /// The block length, or rate, in bytes.
        pub const block_length = CShaker.block_length;

        cshaker: CShaker,
        xof_mode: bool = false,

        /// TupleHash options can include a context string.
        pub const Options = struct {
            context: ?[]const u8 = null,
        };

        /// Initialize a state for the TupleHash function, with an optional context.
        /// If the context is going to be reused, the structure can be initialized once, and cloned for each message.
        /// This is more efficient than reinitializing the state for each message at the cost of a small amount of memory.
        ///
        /// A key can be optionally added to the context to create a keyed TupleHash function, similar to KMAC.
        pub fn initWithOptions(options: Options) Self {
            const cshaker = CShaker.init(.{ .context = options.context });
            return Self{
                .cshaker = cshaker,
            };
        }

        /// Initialize a state for the MAC function.
        pub fn init() Self {
            return initWithOptions(.{});
        }

        /// Add data to the state, separated from previous updates.
        pub fn update(self: *Self, b: []const u8) void {
            const encoded_b_len = NistLengthEncoding.encode(.left, b.len);
            self.cshaker.update(encoded_b_len.slice());
            self.cshaker.update(b);
        }

        /// Return an authentication tag for the current state.
        pub fn final(self: *Self, out: []u8) void {
            const encoded_out_len = NistLengthEncoding.encode(.right, out.len);
            self.cshaker.update(encoded_out_len.slice());
            self.cshaker.final(out);
        }

        /// Align the input to a block boundary.
        pub fn fillBlock(self: *Self) void {
            self.cshaker.fillBlock();
        }

        /// Squeeze a slice of bytes from the state.
        /// `out` can be any length, and the function can be called multiple times.
        pub fn squeeze(self: *Self, out: []u8) void {
            if (!self.xof_mode) {
                const encoded_out_len = comptime NistLengthEncoding.encode(.right, 0);
                self.cshaker.update(encoded_out_len.slice());
                self.xof_mode = true;
            }
            self.cshaker.squeeze(out);
        }
    };
}

/// The NIST SP 800-185 encoded length format.
pub const NistLengthEncoding = enum {
    left,
    right,

    /// A length encoded according to NIST SP 800-185.
    pub const Length = struct {
        /// The size of the encoded value, in bytes.
        len: usize = 0,
        /// A buffer to store the encoded length.
        buf: [@sizeOf(usize) + 1]u8 = undefined,

        /// Return the encoded length as a slice.
        pub fn slice(self: *const Length) []const u8 {
            return self.buf[0..self.len];
        }
    };

    /// Encode a length according to NIST SP 800-185.
    pub fn encode(comptime encoding: NistLengthEncoding, len: usize) Length {
        const len_bits = @bitSizeOf(@TypeOf(len)) - @clz(len) + 3;
        const len_bytes = @divCeil(len_bits, 8);

        var res = Length{ .len = len_bytes + 1 };
        if (encoding == .right) {
            res.buf[len_bytes] = @intCast(len_bytes);
        }
        const end = if (encoding == .right) len_bytes - 1 else len_bytes;
        res.buf[end] = @truncate(len << 3);
        var len_ = len >> 5;
        for (1..len_bytes) |i| {
            res.buf[end - i] = @truncate(len_);
            len_ >>= 8;
        }
        if (encoding == .left) {
            res.buf[0] = @intCast(len_bytes);
        }
        return res;
    }
};

const htest = @import("test.zig");

test {
    _ = kangarootwelve;
}

test "sha3-224 single" {
    try htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", "");
    try htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc");
    try htest.assertEqualHash(Sha3_224, "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "sha3-224 streaming" {
    var h = Sha3_224.init(.{});
    var out: [28]u8 = undefined;

    h.final(out[0..]);
    try htest.assertEqual("6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", out[0..]);

    h = Sha3_224.init(.{});
    h.update("abc");
    h.final(out[0..]);
    try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);

    h = Sha3_224.init(.{});
    h.update("a");
    h.update("b");
    h.update("c");
    h.final(out[0..]);
    try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);
}

test "sha3-256 single" {
    try htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", "");
    try htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc");
    try htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "sha3-256 streaming" {
    var h = Sha3_256.init(.{});
    var out: [32]u8 = undefined;

    h.final(out[0..]);
    try htest.assertEqual("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", out[0..]);

    h = Sha3_256.init(.{});
    h.update("abc");
    h.final(out[0..]);
    try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);

    h = Sha3_256.init(.{});
    h.update("a");
    h.update("b");
    h.update("c");
    h.final(out[0..]);
    try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);
}

test "sha3-256 aligned final" {
    var block: [Sha3_256.block_length]u8 = @splat(0);
    var out: [Sha3_256.digest_length]u8 = undefined;

    var h = Sha3_256.init(.{});
    h.update(&block);
    h.final(out[0..]);
}

test "sha3-384 single" {
    const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
    try htest.assertEqualHash(Sha3_384, h1, "");
    const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";
    try htest.assertEqualHash(Sha3_384, h2, "abc");
    const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7";
    try htest.assertEqualHash(Sha3_384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "sha3-384 streaming" {
    var h = Sha3_384.init(.{});
    var out: [48]u8 = undefined;

    const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
    h.final(out[0..]);
    try htest.assertEqual(h1, out[0..]);

    const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";
    h = Sha3_384.init(.{});
    h.update("abc");
    h.final(out[0..]);
    try htest.assertEqual(h2, out[0..]);

    h = Sha3_384.init(.{});
    h.update("a");
    h.update("b");
    h.update("c");
    h.final(out[0..]);
    try htest.assertEqual(h2, out[0..]);
}

test "sha3-512 single" {
    const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
    try htest.assertEqualHash(Sha3_512, h1, "");
    const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";
    try htest.assertEqualHash(Sha3_512, h2, "abc");
    const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185";
    try htest.assertEqualHash(Sha3_512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "sha3-512 streaming" {
    var h = Sha3_512.init(.{});
    var out: [64]u8 = undefined;

    const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
    h.final(out[0..]);
    try htest.assertEqual(h1, out[0..]);

    const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";
    h = Sha3_512.init(.{});
    h.update("abc");
    h.final(out[0..]);
    try htest.assertEqual(h2, out[0..]);

    h = Sha3_512.init(.{});
    h.update("a");
    h.update("b");
    h.update("c");
    h.final(out[0..]);
    try htest.assertEqual(h2, out[0..]);
}

test "sha3-512 aligned final" {
    var block: [Sha3_512.block_length]u8 = @splat(0);
    var out: [Sha3_512.digest_length]u8 = undefined;

    var h = Sha3_512.init(.{});
    h.update(&block);
    h.final(out[0..]);
}

test "keccak-256 single" {
    try htest.assertEqualHash(Keccak256, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "");
    try htest.assertEqualHash(Keccak256, "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", "abc");
    try htest.assertEqualHash(Keccak256, "f519747ed599024f3882238e5ab43960132572b7345fbeb9a90769dafd21ad67", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "keccak-512 single" {
    try htest.assertEqualHash(Keccak512, "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", "");
    try htest.assertEqualHash(Keccak512, "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc");
    try htest.assertEqualHash(Keccak512, "ac2fb35251825d3aa48468a9948c0a91b8256f6d97d8fa4160faff2dd9dfcc24f3f1db7a983dad13d53439ccac0b37e24037e7b95f80f59f37a2f683c4ba4682", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}

test "SHAKE-128 single" {
    var out: [10]u8 = undefined;
    Shake128.hash("hello123", &out, .{});
    try htest.assertEqual("1b85861510bc4d8e467d", &out);
}

test "SHAKE-128 multisqueeze" {
    var out: [10]u8 = undefined;
    var h = Shake128.init(.{});
    h.update("hello123");
    h.squeeze(out[0..4]);
    h.squeeze(out[4..]);
    try htest.assertEqual("1b85861510bc4d8e467d", &out);
}

test "SHAKE-128 multisqueeze with multiple blocks" {
    var out: [100]u8 = undefined;
    var out2: [100]u8 = undefined;

    var h = Shake128.init(.{});
    h.update("hello123");
    h.squeeze(out[0..50]);
    h.squeeze(out[50..]);

    var h2 = Shake128.init(.{});
    h2.update("hello123");
    h2.squeeze(&out2);
    try std.testing.expectEqualSlices(u8, &out, &out2);
}

test "SHAKE-256 single" {
    var out: [10]u8 = undefined;
    Shake256.hash("hello123", &out, .{});
    try htest.assertEqual("ade612ba265f92de4a37", &out);
}

test "TurboSHAKE-128" {
    var out: [32]u8 = undefined;
    TurboShake(128, 0x06).hash("\xff", &out, .{});
    try htest.assertEqual("8ec9c66465ed0d4a6c35d13506718d687a25cb05c74cca1e42501abd83874a67", &out);
}

test "SHA-3 with streaming" {
    var msg: [613]u8 = [613]u8{ 0x97, 0xd1, 0x2d, 0x1a, 0x16, 0x2d, 0x36, 0x4d, 0x20, 0x62, 0x19, 0x0b, 0x14, 0x93, 0xbb, 0xf8, 0x5b, 0xea, 0x04, 0xc2, 0x61, 0x8e, 0xd6, 0x08, 0x81, 0xa1, 0x1d, 0x73, 0x27, 0x48, 0xbf, 0xa4, 0xba, 0xb1, 0x9a, 0x48, 0x9c, 0xf9, 0x9b, 0xff, 0x34, 0x48, 0xa9, 0x75, 0xea, 0xc8, 0xa3, 0x48, 0x24, 0x9d, 0x75, 0x27, 0x48, 0xec, 0x03, 0xb0, 0xbb, 0xdf, 0x33, 0x90, 0xe3, 0x93, 0xed, 0x68, 0x24, 0x39, 0x12, 0xdf, 0xea, 0xee, 0x8c, 0x9f, 0x96, 0xde, 0x42, 0x46, 0x8c, 0x2b, 0x17, 0x83, 0x36, 0xfb, 0xf4, 0xf7, 0xff, 0x79, 0xb9, 0x45, 0x41, 0xc9, 0x56, 0x1a, 0x6b, 0x0c, 0xa4, 0x1a, 0xdd, 0x6b, 0x95, 0xe8, 0x03, 0x0f, 0x09, 0x29, 0x40, 0x1b, 0xea, 0x87, 0xfa, 0xb9, 0x18, 0xa9, 0x95, 0x07, 0x7c, 0x2f, 0x7c, 0x33, 0xfb, 0xc5, 0x11, 0x5e, 0x81, 0x0e, 0xbc, 0xae, 0xec, 0xb3, 0xe1, 0x4a, 0x26, 0x56, 0xe8, 0x5b, 0x11, 0x9d, 0x37, 0x06, 0x9b, 0x34, 0x31, 0x6e, 0xa3, 0xba, 0x41, 0xbc, 0x11, 0xd8, 0xc5, 0x15, 0xc9, 0x30, 0x2c, 0x9b, 0xb6, 0x71, 0xd8, 0x7c, 0xbc, 0x38, 0x2f, 0xd5, 0xbd, 0x30, 0x96, 0xd4, 0xa3, 0x00, 0x77, 0x9d, 0x55, 0x4a, 0x33, 0x53, 0xb6, 0xb3, 0x35, 0x1b, 0xae, 0xe5, 0xdc, 0x22, 0x23, 0x85, 0x95, 0x88, 0xf9, 0x3b, 0xbf, 0x74, 0x13, 0xaa, 0xcb, 0x0a, 0x60, 0x79, 0x13, 0x79, 0xc0, 0x4a, 0x02, 0xdb, 0x1c, 0xc9, 0xff, 0x60, 0x57, 0x9a, 0x70, 0x28, 0x58, 0x60, 0xbc, 0x57, 0x07, 0xc7, 0x47, 0x1a, 0x45, 0x71, 0x76, 0x94, 0xfb, 0x05, 0xad, 0xec, 0x12, 0x29, 0x5a, 0x44, 0x6a, 0x81, 0xd9, 0xc6, 0xf0, 0xb6, 0x9b, 0x97, 0x83, 0x69, 0xfb, 0xdc, 0x0d, 0x4a, 0x67, 0xbc, 0x72, 0xf5, 0x43, 0x5e, 0x9b, 0x13, 0xf2, 0xe4, 0x6d, 0x49, 0xdb, 0x76, 0xcb, 0x42, 0x6a, 0x3c, 0x9f, 0xa1, 0xfe, 0x5e, 0xca, 0x0a, 0xfc, 0xfa, 0x39, 0x27, 0xd1, 0x3c, 0xcb, 0x9a, 0xde, 0x4c, 0x6b, 0x09, 0x8b, 0x49, 0xfd, 0x1e, 0x3d, 0x5e, 0x67, 0x7c, 0x57, 0xad, 0x90, 0xcc, 0x46, 0x5f, 0x5c, 0xae, 0x6a, 0x9c, 0xb2, 0xcd, 0x2c, 0x89, 0x78, 0xcf, 0xf1, 0x49, 0x96, 0x55, 0x1e, 0x04, 0xef, 0x0e, 0x1c, 0xde, 0x6c, 0x96, 0x51, 0x00, 0xee, 0x9a, 0x1f, 0x8d, 0x61, 0xbc, 0xeb, 0xb1, 0xa6, 0xa5, 0x21, 0x8b, 0xa7, 0xf8, 0x25, 0x41, 0x48, 0x62, 0x5b, 0x01, 0x6c, 0x7c, 0x2a, 0xe8, 0xff, 0xf9, 0xf9, 0x1f, 0xe2, 0x79, 0x2e, 0xd1, 0xff, 0xa3, 0x2e, 0x1c, 0x3a, 0x1a, 0x5d, 0x2b, 0x7b, 0x87, 0x25, 0x22, 0xa4, 0x90, 0xea, 0x26, 0x9d, 0xdd, 0x13, 0x60, 0x4c, 0x10, 0x03, 0xf6, 0x99, 0xd3, 0x21, 0x0c, 0x69, 0xc6, 0xd8, 0xc8, 0x9e, 0x94, 0x89, 0x51, 0x21, 0xe3, 0x9a, 0xcd, 0xda, 0x54, 0x72, 0x64, 0xae, 0x94, 0x79, 0x36, 0x81, 0x44, 0x14, 0x6d, 0x3a, 0x0e, 0xa6, 0x30, 0xbf, 0x95, 0x99, 0xa6, 0xf5, 0x7f, 0x4f, 0xef, 0xc6, 0x71, 0x2f, 0x36, 0x13, 0x14, 0xa2, 0x9d, 0xc2, 0x0c, 0x0d, 0x4e, 0xc0, 0x02, 0xd3, 0x6f, 0xee, 0x98, 0x5e, 0x24, 0x31, 0x74, 0x11, 0x96, 0x6e, 0x43, 0x57, 0xe8, 0x8e, 0xa0, 0x8d, 0x3d, 0x79, 0x38, 0x20, 0xc2, 0x0f, 0xb4, 0x75, 0x99, 0x3b, 0xb1, 0xf0, 0xe8, 0xe1, 0xda, 0xf9, 0xd4, 0xe6, 0xd6, 0xf4, 0x8a, 0x32, 0x4a, 0x4a, 0x25, 0xa8, 0xd9, 0x60, 0xd6, 0x33, 0x31, 0x97, 0xb9, 0xb6, 0xed, 0x5f, 0xfc, 0x15, 0xbd, 0x13, 0xc0, 0x3a, 0x3f, 0x1f, 0x2d, 0x09, 0x1d, 0xeb, 0x69, 0x6a, 0xfe, 0xd7, 0x95, 0x3e, 0x8a, 0x4e, 0xe1, 0x6e, 0x61, 0xb2, 0x6c, 0xe3, 0x2b, 0x70, 0x60, 0x7e, 0x8c, 0xe4, 0xdd, 0x27, 0x30, 0x7e, 0x0d, 0xc7, 0xb7, 0x9a, 0x1a, 0x3c, 0xcc, 0xa7, 0x22, 0x77, 0x14, 0x05, 0x50, 0x57, 0x31, 0x1b, 0xc8, 0xbf, 0xce, 0x52, 0xaf, 0x9c, 0x8e, 0x10, 0x2e, 0xd2, 0x16, 0xb6, 0x6e, 0x43, 0x10, 0xaf, 0x8b, 0xde, 0x1d, 0x60, 0xb2, 0x7d, 0xe6, 0x2f, 0x08, 0x10, 0x12, 0x7e, 0xb4, 0x76, 0x45, 0xb6, 0xd8, 0x9b, 0x26, 0x40, 0xa1, 0x63, 0x5c, 0x7a, 0x2a, 0xb1, 0x8c, 0xd6, 0xa4, 0x6f, 0x5a, 0xae, 0x33, 0x7e, 0x6d, 0x71, 0xf5, 0xc8, 0x6d, 0x80, 0x1c, 0x35, 0xfc, 0x3f, 0xc1, 0xa6, 0xc6, 0x1a, 0x15, 0x04, 0x6d, 0x76, 0x38, 0x32, 0x95, 0xb2, 0x51, 0x1a, 0xe9, 0x3e, 0x89, 0x9f, 0x0c, 0x79 };
    var out: [Sha3_256.digest_length]u8 = undefined;

    Sha3_256.hash(&msg, &out, .{});
    try htest.assertEqual("5780048dfa381a1d01c747906e4a08711dd34fd712ecd7c6801dd2b38fd81a89", &out);

    var h = Sha3_256.init(.{});
    h.update(msg[0..64]);
    h.update(msg[64..613]);
    h.final(&out);
    try htest.assertEqual("5780048dfa381a1d01c747906e4a08711dd34fd712ecd7c6801dd2b38fd81a89", &out);
}

test "cSHAKE-128 with no context nor function name" {
    var out: [32]u8 = undefined;
    CShake128.hash("hello123", &out, .{});
    try htest.assertEqual("1b85861510bc4d8e467d6f8a92270533cbaa7ba5e06c2d2a502854bac468b8b9", &out);
}

test "cSHAKE-128 with context" {
    var out: [32]u8 = undefined;
    CShake128.hash("hello123", &out, .{ .context = "custom" });
    try htest.assertEqual("7509fa13a6bd3e38ad5c6fac042142c233996e40ebffc86c276f108b3b19cc6a", &out);
}

test "cSHAKE-128 with context and function" {
    var out: [32]u8 = undefined;
    CShake(128, "function").hash("hello123", &out, .{ .context = "custom" });
    try htest.assertEqual("ad7f4d7db2d96587fcd5047c65d37c368f5366e3afac60bb9b66b0bb95dfb675", &out);
}

test "cSHAKE-256" {
    var out: [32]u8 = undefined;
    CShake256.hash("hello123", &out, .{ .context = "custom" });
    try htest.assertEqual("dabe027eb1a6cbe3a0542d0560eb4e6b39146dd72ae1bf89c970a61bd93b1813", &out);
}

test "KMAC-128 with empty key and message" {
    var out: [KMac128.mac_length]u8 = undefined;
    const key = "";
    KMac128.create(&out, "", key);
    try htest.assertEqual("5c135c615152fb4d9784dd1155f9b6034e013fd77165c327dfa4d36701983ef7", &out);
}

test "KMAC-128" {
    var out: [KMac128.mac_length]u8 = undefined;
    const key = "A KMAC secret key";
    KMac128.create(&out, "hello123", key);
    try htest.assertEqual("1fa1c0d761129a83f9a4299ca137674de8373a3cc437799ae4c129e651627f8e", &out);
}

test "KMAC-128 with a customization string" {
    var out: [KMac128.mac_length]u8 = undefined;
    const key = "A KMAC secret key";
    KMac128.createWithOptions(&out, "hello123", key, .{ .context = "custom" });
    try htest.assertEqual("c58c6d42dc00a27dfa8e7e08f8c9307cecb5d662ddb11b6c36057fc2e0e068ba", &out);
}

test "KMACXOF-128" {
    const key = "A KMAC secret key";
    var xof = KMac128.init(key);
    xof.update("hello123");
    var out: [50]u8 = undefined;
    xof.squeeze(&out);
    try htest.assertEqual("628c2fb870d294b3673ac82d9f0d651aae6a5bb8084ea8cd8343cb888d075b9053173200a71f301141069c3c0322527981f7", &out);
    xof.squeeze(&out);
    try htest.assertEqual("7b638e178cfdac5727a4ea7694efaa967a65a1d0034501855acff506b4158d187d5a18d668e67b43f2abf61144b20ed4c09f", &out);
}

test "KMACXOF-256" {
    const key = "A KMAC secret key";
    var xof = KMac256.init(key);
    xof.update("hello123");
    var out: [50]u8 = undefined;
    xof.squeeze(&out);
    try htest.assertEqual("23fc644bc2655ba6fde7b7c11f2804f22e8d8c6bd7db856268bf3370ce2362703f6c7e91916a1b8c116e60edfbcb25613054", &out);
    xof.squeeze(&out);
    try htest.assertEqual("ff97251020ff255ee65a1c1f5f78ebe904f61211c39f973f82fbce2b196b9f51c2cb12afe51549a0f1eaf7954e657ba11af3", &out);
}

test "TupleHash-128" {
    var st = TupleHash128.init();
    st.update("hello");
    st.update("123");
    var out: [32]u8 = undefined;
    st.final(&out);
    try htest.assertEqual("3938d49ade8ec0f0c305ac63497b2d2e8b2f650714f9667cc41816b1c11ffd20", &out);
}

test "TupleHashXOF-128 as a XOF" {
    var st = TupleHash128.init();
    st.update(&.{ 0x00, 0x01, 0x02 });
    st.update(&.{ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 });
    var out: [32]u8 = undefined;
    st.squeeze(&out);
    try htest.assertEqual("2f103cd7c32320353495c68de1a8129245c6325f6f2a3d608d92179c96e68488", &out);
}

test "TupleHash-256" {
    var st = TupleHash256.init();
    st.update("hello");
    st.update("123");
    var out: [64]u8 = undefined;
    st.final(&out);
    try htest.assertEqual("2dca563c2882f2ba4f46a441a4c5e13fb97150d1436fe99c7e4e43a2d20d0f1cd3d38483bde4a966930606dfa6c61c4ca6400aeedfb474d1bf0d7f6a70968289", &out);
}