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

Source line 1

std.crypto.aes.soft.Aes128

namespace

Source line 695

AES-128 with the standard key schedule.

std.crypto.aes.soft.Aes128.block

alias

Source line 698

Alias of std.crypto.aes.soft.Block

std.crypto.aes.soft.Aes128.initDec

function

Source line 706

Create a new context for decryption.

pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes128)

Parameters

key: [key_bits / 8]u8

std.crypto.aes.soft.Aes128.initEnc

function

Source line 701

Create a new context for encryption.

pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes128)

Parameters

key: [key_bits / 8]u8

std.crypto.aes.soft.Aes128.key_bits

constant

Source line 696

usize

std.crypto.aes.soft.Aes128.rounds

constant

Source line 697

std.crypto.aes.soft.Aes256

namespace

Source line 712

AES-256 with the standard key schedule.

std.crypto.aes.soft.Aes256.block

alias

Source line 715

Alias of std.crypto.aes.soft.Block

std.crypto.aes.soft.Aes256.initDec

function

Source line 723

Create a new context for decryption.

pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes256)

Parameters

key: [key_bits / 8]u8

std.crypto.aes.soft.Aes256.initEnc

function

Source line 718

Create a new context for encryption.

pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes256)

Parameters

key: [key_bits / 8]u8

std.crypto.aes.soft.Aes256.key_bits

constant

Source line 713

usize

std.crypto.aes.soft.Aes256.rounds

constant

Source line 714

std.crypto.aes.soft.AesDecryptCtx

type-function

Source line 640

A context to perform decryption using the standard AES key schedule.

pub fn AesDecryptCtx(comptime Aes: type) type

Parameters

Aes: type

Fields

key_schedule: KeySchedule(Aes)
packed_keys: PackedKeys(rounds)

std.crypto.aes.soft.AesDecryptCtx.block

constant

Source line 646

std.crypto.aes.soft.AesDecryptCtx.block_length

constant

Source line 647

std.crypto.aes.soft.AesDecryptCtx.decrypt

function

Source line 677

Decrypt a single block.

pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void

Parameters

ctx: Self
dst: *[16]u8
src: *const [16]u8

std.crypto.aes.soft.AesDecryptCtx.decryptUnprotectedBlock

function

Source line 666

Decrypt a single block, without any protection against side channels.

fn decryptUnprotectedBlock(ctx: Self, dst: *[16]u8, src: *const [16]u8) void

Parameters

ctx: Self
dst: *[16]u8
src: *const [16]u8

std.crypto.aes.soft.AesDecryptCtx.decryptWide

function

Source line 682

Decrypt multiple blocks, possibly leveraging parallelization.

pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void

Parameters

ctx: Self
count: usize
dst: *[16 * count]u8
src: *const [16 * count]u8

std.crypto.aes.soft.AesDecryptCtx.init

function

Source line 660

Create a new decryption context with the given key.

pub fn init(key: [Aes.key_bits / 8]u8) Self

Parameters

key: [Aes.key_bits / 8]u8

std.crypto.aes.soft.AesDecryptCtx.initFromEnc

function

Source line 652

Create a decryption context from an existing encryption context.

pub fn initFromEnc(ctx: AesEncryptCtx(Aes)) Self

Parameters

ctx: AesEncryptCtx(Aes)

std.crypto.aes.soft.AesDecryptCtx.Self

alias

Source line 645

Alias of std.crypto.aes.soft.AesDecryptCtx

std.crypto.aes.soft.AesEncryptCtx

type-function

Source line 578

A context to perform encryption using the standard AES key schedule.

pub fn AesEncryptCtx(comptime Aes: type) type

Parameters

Aes: type

Fields

key_schedule: KeySchedule(Aes)
packed_keys: PackedKeys(rounds)

std.crypto.aes.soft.AesEncryptCtx.block

constant

Source line 584

std.crypto.aes.soft.AesEncryptCtx.block_length

constant

Source line 585

std.crypto.aes.soft.AesEncryptCtx.encrypt

function

Source line 610

Encrypt a single block.

pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void

Parameters

ctx: Self
dst: *[16]u8
src: *const [16]u8

std.crypto.aes.soft.AesEncryptCtx.encryptUnprotectedBlock

function

Source line 599

Encrypt a single block, without any protection against side channels.

fn encryptUnprotectedBlock(ctx: Self, dst: *[16]u8, src: *const [16]u8) void

Parameters

ctx: Self
dst: *[16]u8
src: *const [16]u8

std.crypto.aes.soft.AesEncryptCtx.encryptWide

function

Source line 620

Encrypt multiple blocks, possibly leveraging parallelization.

pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void

Parameters

ctx: Self
count: usize
dst: *[16 * count]u8
src: *const [16 * count]u8

std.crypto.aes.soft.AesEncryptCtx.init

function

Source line 590

Create a new encryption context with the given key.

pub fn init(key: [Aes.key_bits / 8]u8) Self

Parameters

key: [Aes.key_bits / 8]u8

std.crypto.aes.soft.AesEncryptCtx.Self

alias

Source line 583

Alias of std.crypto.aes.soft.AesEncryptCtx

std.crypto.aes.soft.AesEncryptCtx.xor

function

Source line 615

Encrypt+XOR a single block.

pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void

Parameters

ctx: Self
dst: *[16]u8
src: *const [16]u8
counter: [16]u8

std.crypto.aes.soft.AesEncryptCtx.xorWide

function

Source line 631

Encrypt+XOR multiple blocks, possibly leveraging parallelization.

pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void

Parameters

ctx: Self
count: usize
dst: *[16 * count]u8
src: *const [16 * count]u8
counters: [16 * count]u8

std.crypto.aes.soft.bitsliced

alias

Source line 4

Alias of std.crypto.aes.bitsliced

std.crypto.aes.soft.bitslicedOperation

function

Source line 551

Bitsliced operation over count blocks

fn bitslicedOperation( comptime rounds: usize, comptime operation: enum { encrypt, decrypt }, keys: *const [rounds + 1]bitsliced.State, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, ) void

Parameters

rounds: usize
operation: enum { encrypt, decrypt }
keys: *const [rounds + 1]bitsliced.State
count: usize
dst: *[16 * count]u8
src: *const [16 * count]u8

std.crypto.aes.soft.Block

container

Source line 11

A single AES block.

Fields

repr: Repr align(16)

Internal representation of a block.

std.crypto.aes.soft.Block.andBlocks

function

Source line 252

Apply the bitwise AND operation to the content of two blocks.

pub fn andBlocks(block1: Block, block2: Block) Block

Parameters

block1: Block
block2: Block

std.crypto.aes.soft.Block.block_length

constant

Source line 14

usize

std.crypto.aes.soft.Block.decrypt

function

Source line 146

Decrypt a block with a round key.

pub fn decrypt(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.decryptLast

function

Source line 216

Decrypt a block with the last round key.

pub fn decryptLast(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.decryptUnprotected

function

Source line 171

Decrypt a block with a round key WITHOUT ANY PROTECTION AGAINST SIDE CHANNELS

pub fn decryptUnprotected(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.encrypt

function

Source line 50

Encrypt a block with a round key.

pub fn encrypt(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.encryptLast

function

Source line 120

Encrypt a block with the last round key.

pub fn encryptLast(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.encryptUnprotected

function

Source line 75

Encrypt a block with a round key WITHOUT ANY PROTECTION AGAINST SIDE CHANNELS

pub fn encryptUnprotected(block: Block, round_key: Block) Block

Parameters

block: Block
round_key: Block

std.crypto.aes.soft.Block.fromBytes

function

Source line 20

Convert a byte sequence into an internal representation.

pub fn fromBytes(bytes: *const [16]u8) Block

Parameters

bytes: *const [16]u8

std.crypto.aes.soft.Block.invMixColumns

function

Source line 272

Apply the inverse MixColumns operation to a block.

pub fn invMixColumns(block: Block) Block

Parameters

block: Block

std.crypto.aes.soft.Block.orBlocks

function

Source line 262

Apply the bitwise OR operation to the content of two blocks.

pub fn orBlocks(block1: Block, block2: Block) Block

Parameters

block1: Block
block2: Block

std.crypto.aes.soft.Block.parallel

namespace

Source line 292

Perform operations on multiple blocks in parallel.

std.crypto.aes.soft.Block.parallel.decryptLastWide

function

Source line 347

Decrypt multiple blocks in parallel with the same last round key.

pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_key: Block

std.crypto.aes.soft.Block.parallel.decryptParallel

function

Source line 307

Decrypt multiple blocks in parallel, each their own round key.

pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_keys: [count]Block

std.crypto.aes.soft.Block.parallel.decryptWide

function

Source line 327

Decrypt multiple blocks in parallel with the same round key.

pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_key: Block

std.crypto.aes.soft.Block.parallel.encryptLastWide

function

Source line 337

Encrypt multiple blocks in parallel with the same last round key.

pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_key: Block

std.crypto.aes.soft.Block.parallel.encryptParallel

function

Source line 297

Encrypt multiple blocks in parallel, each their own round key.

pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_keys: [count]Block

std.crypto.aes.soft.Block.parallel.encryptWide

function

Source line 317

Encrypt multiple blocks in parallel with the same round key.

pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block

Parameters

count: usize
blocks: [count]Block
round_key: Block

std.crypto.aes.soft.Block.parallel.optimal_parallel_blocks

constant

Source line 294

The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.

std.crypto.aes.soft.Block.Repr

type

Source line 12

std.crypto.aes.soft.Block.toBytes

function

Source line 29

Convert the internal representation of a block into a byte sequence.

pub fn toBytes(block: Block) [16]u8

Parameters

block: Block

std.crypto.aes.soft.Block.xorBlocks

function

Source line 242

Apply the bitwise XOR operation to the content of two blocks.

pub fn xorBlocks(block1: Block, block2: Block) Block

Parameters

block1: Block
block2: Block

std.crypto.aes.soft.Block.xorBytes

function

Source line 39

XOR the block with a byte sequence.

pub fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8

Parameters

block: Block
bytes: *const [16]u8

std.crypto.aes.soft.BlockVec

type-function

Source line 360

A fixed-size vector of AES blocks. All operations are performed in parallel, using SIMD instructions when available.

pub fn BlockVec(comptime blocks_count: comptime_int) type

Parameters

blocks_count: comptime_int

Fields

repr: [native_words]Block

Internal representation of a block vector.

std.crypto.aes.soft.BlockVec.andBlocks

function

Source line 451

Apply the bitwise AND operation to the content of two block vectors.

pub fn andBlocks(block_vec1: Self, block_vec2: Self) Self

Parameters

block_vec1: Self
block_vec2: Self

std.crypto.aes.soft.BlockVec.block_length

constant

Source line 376

Length of the block vector in bytes.

usize

std.crypto.aes.soft.BlockVec.decrypt

function

Source line 424

Apply the inverse AES operation to the block vector with a vector of round keys.

pub fn decrypt(block_vec: Self, inv_round_key_vec: Self) Self

Parameters

block_vec: Self
inv_round_key_vec: Self

std.crypto.aes.soft.BlockVec.decryptLast

function

Source line 433

Apply the inverse AES operation to the block vector with a vector of last round keys.

pub fn decryptLast(block_vec: Self, inv_round_key_vec: Self) Self

Parameters

block_vec: Self
inv_round_key_vec: Self

std.crypto.aes.soft.BlockVec.encrypt

function

Source line 406

Apply the forward AES operation to the block vector with a vector of round keys.

pub fn encrypt(block_vec: Self, round_key_vec: Self) Self

Parameters

block_vec: Self
round_key_vec: Self

std.crypto.aes.soft.BlockVec.encryptLast

function

Source line 415

Apply the forward AES operation to the block vector with a vector of last round keys.

pub fn encryptLast(block_vec: Self, round_key_vec: Self) Self

Parameters

block_vec: Self
round_key_vec: Self

std.crypto.aes.soft.BlockVec.fromBytes

function

Source line 379

Convert a byte sequence into an internal representation.

pub fn fromBytes(bytes: *const [blocks_count * 16]u8) Self

Parameters

bytes: *const [blocks_count * 16]u8

std.crypto.aes.soft.BlockVec.invMixColumns

function

Source line 469

Apply the inverse MixColumns operation to each block in the vector.

pub fn invMixColumns(block_vec: Self) Self

Parameters

block_vec: Self

std.crypto.aes.soft.BlockVec.native_vector_size

constant

Source line 365

The number of AES blocks the target architecture can process with a single instruction.

std.crypto.aes.soft.BlockVec.native_word_size

constant

Source line 368

The size of the AES block vector that the target architecture can process with a single instruction, in bytes.

std.crypto.aes.soft.BlockVec.native_words

constant

Source line 370

std.crypto.aes.soft.BlockVec.orBlocks

function

Source line 460

Apply the bitwise OR operation to the content of two block vectors.

pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self

Parameters

block_vec1: Self
block_vec2: Self

std.crypto.aes.soft.BlockVec.Self

alias

Source line 362

Alias of std.crypto.aes.soft.BlockVec

std.crypto.aes.soft.BlockVec.toBytes

function

Source line 388

Convert the internal representation of a block vector into a byte sequence.

pub fn toBytes(block_vec: Self) [blocks_count * 16]u8

Parameters

block_vec: Self

std.crypto.aes.soft.BlockVec.xorBlocks

function

Source line 442

Apply the bitwise XOR operation to the content of two block vectors.

pub fn xorBlocks(block_vec1: Self, block_vec2: Self) Self

Parameters

block_vec1: Self
block_vec2: Self

std.crypto.aes.soft.BlockVec.xorBytes

function

Source line 397

XOR the block vector with a byte sequence.

pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8

Parameters

block_vec: Self
bytes: *const [blocks_count * 16]u8

std.crypto.aes.soft.cache_line_bytes

alias

Source line 828

Alias of std.atomic.cache_line

std.crypto.aes.soft.generateSbox

function

Source line 753

fn generateSbox(invert: bool) [256]u8

Parameters

invert: bool

std.crypto.aes.soft.generateTable

function

Source line 787

fn generateTable(invert: bool) [4][256]u32

Parameters

invert: bool

std.crypto.aes.soft.KeySchedule

type-function

Source line 479

fn KeySchedule(comptime Aes: type) type

Parameters

Aes: type

Fields

round_keys: [rounds + 1]Block

std.crypto.aes.soft.KeySchedule.expandKey

function

Source line 491

fn expandKey(key: [key_length]u8) Self

Parameters

key: [key_length]u8

std.crypto.aes.soft.KeySchedule.expandKey.func

function

Source line 494

fn func(w: u32) u32

Parameters

w: u32

std.crypto.aes.soft.KeySchedule.invert

function

Source line 522

Invert the key schedule.

pub fn invert(key_schedule: Self) Self

Parameters

key_schedule: Self

std.crypto.aes.soft.KeySchedule.Self

alias

Source line 485

Alias of std.crypto.aes.soft.KeySchedule

std.crypto.aes.soft.KeySchedule.words_in_key

constant

Source line 486

std.crypto.aes.soft.math

alias

Source line 2

Alias of std.math

std.crypto.aes.soft.mem

alias

Source line 3

Alias of std.mem

std.crypto.aes.soft.mul

function

Source line 807

fn mul(a: u8, b: u8) u8

Parameters

a: u8
b: u8

std.crypto.aes.soft.PackedKeys

type-function

Source line 546

Packed forward round keys for the bitsliced implementation

fn PackedKeys(comptime rounds: usize) type

Parameters

rounds: usize

std.crypto.aes.soft.poly

constant

Source line 731

u9

std.crypto.aes.soft.powx

constant

Source line 734

std.crypto.aes.soft.protected

constant

Source line 8

std.crypto.aes.soft.sbox_decrypt

constant

Source line 748

std.crypto.aes.soft.sbox_encrypt

constant

Source line 746

std.crypto.aes.soft.sbox_key_schedule

constant

Source line 747

std.crypto.aes.soft.sbox_lookup

function

Source line 830

fn sbox_lookup(sbox: *align(64) const [256]u8, idx0: u8, idx1: u8, idx2: u8, idx3: u8) [4]u8

Parameters

sbox: *align(64) const [256]u8
idx0: u8
idx1: u8
idx2: u8
idx3: u8

std.crypto.aes.soft.side_channels_mitigations

constant

Source line 6

std.crypto.aes.soft.std

alias

Source line 1

Alias of std

std.crypto.aes.soft.table_decrypt

constant

Source line 750

std.crypto.aes.soft.table_encrypt

constant

Source line 749

std.crypto.aes.soft.table_lookup

function

Source line 868

fn table_lookup(table: *align(64) const [4][256]u32, idx0: u8, idx1: u8, idx2: u8, idx3: u8) [4]u32

Parameters

table: *align(64) const [4][256]u32
idx0: u8
idx1: u8
idx2: u8
idx3: u8
Source code

std/crypto/aes/soft.zig

const std = @import("../../std.zig");
const math = std.math;
const mem = std.mem;
const bitsliced = @import("bitsliced.zig");

const side_channels_mitigations = std.options.side_channels_mitigations;

const protected = side_channels_mitigations != .none;

/// A single AES block.
pub const Block = struct {
    const Repr = [4]u32;

    pub const block_length: usize = 16;

    /// Internal representation of a block.
    repr: Repr align(16),

    /// Convert a byte sequence into an internal representation.
    pub fn fromBytes(bytes: *const [16]u8) Block {
        const s0 = mem.readInt(u32, bytes[0..4], .little);
        const s1 = mem.readInt(u32, bytes[4..8], .little);
        const s2 = mem.readInt(u32, bytes[8..12], .little);
        const s3 = mem.readInt(u32, bytes[12..16], .little);
        return Block{ .repr = Repr{ s0, s1, s2, s3 } };
    }

    /// Convert the internal representation of a block into a byte sequence.
    pub fn toBytes(block: Block) [16]u8 {
        var bytes: [16]u8 = undefined;
        mem.writeInt(u32, bytes[0..4], block.repr[0], .little);
        mem.writeInt(u32, bytes[4..8], block.repr[1], .little);
        mem.writeInt(u32, bytes[8..12], block.repr[2], .little);
        mem.writeInt(u32, bytes[12..16], block.repr[3], .little);
        return bytes;
    }

    /// XOR the block with a byte sequence.
    pub fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
        const block_bytes = block.toBytes();
        var x: [16]u8 = undefined;
        comptime var i: usize = 0;
        inline while (i < 16) : (i += 1) {
            x[i] = block_bytes[i] ^ bytes[i];
        }
        return x;
    }

    /// Encrypt a block with a round key.
    pub fn encrypt(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        var x: [4]u32 = undefined;
        x = table_lookup(&table_encrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s3 >> 24)));
        var t0 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_encrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s0 >> 24)));
        var t1 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_encrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s1 >> 24)));
        var t2 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_encrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s2 >> 24)));
        var t3 = x[0] ^ x[1] ^ x[2] ^ x[3];

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Encrypt a block with a round key *WITHOUT ANY PROTECTION AGAINST SIDE CHANNELS*
    pub fn encryptUnprotected(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        var x: [4]u32 = undefined;
        x = .{
            table_encrypt[0][@as(u8, @truncate(s0))],
            table_encrypt[1][@as(u8, @truncate(s1 >> 8))],
            table_encrypt[2][@as(u8, @truncate(s2 >> 16))],
            table_encrypt[3][@as(u8, @truncate(s3 >> 24))],
        };
        var t0 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_encrypt[0][@as(u8, @truncate(s1))],
            table_encrypt[1][@as(u8, @truncate(s2 >> 8))],
            table_encrypt[2][@as(u8, @truncate(s3 >> 16))],
            table_encrypt[3][@as(u8, @truncate(s0 >> 24))],
        };
        var t1 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_encrypt[0][@as(u8, @truncate(s2))],
            table_encrypt[1][@as(u8, @truncate(s3 >> 8))],
            table_encrypt[2][@as(u8, @truncate(s0 >> 16))],
            table_encrypt[3][@as(u8, @truncate(s1 >> 24))],
        };
        var t2 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_encrypt[0][@as(u8, @truncate(s3))],
            table_encrypt[1][@as(u8, @truncate(s0 >> 8))],
            table_encrypt[2][@as(u8, @truncate(s1 >> 16))],
            table_encrypt[3][@as(u8, @truncate(s2 >> 24))],
        };
        var t3 = x[0] ^ x[1] ^ x[2] ^ x[3];

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Encrypt a block with the last round key.
    pub fn encryptLast(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        // Last round uses s-box directly and XORs to produce output.
        var x: [4]u8 = undefined;
        x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s3 >> 24)));
        var t0 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s0 >> 24)));
        var t1 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s1 >> 24)));
        var t2 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_encrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s2 >> 24)));
        var t3 = mem.readInt(u32, &x, .little);

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Decrypt a block with a round key.
    pub fn decrypt(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        var x: [4]u32 = undefined;
        x = table_lookup(&table_decrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s1 >> 24)));
        var t0 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_decrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s2 >> 24)));
        var t1 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_decrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s3 >> 24)));
        var t2 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = table_lookup(&table_decrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s0 >> 24)));
        var t3 = x[0] ^ x[1] ^ x[2] ^ x[3];

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Decrypt a block with a round key *WITHOUT ANY PROTECTION AGAINST SIDE CHANNELS*
    pub fn decryptUnprotected(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        var x: [4]u32 = undefined;
        x = .{
            table_decrypt[0][@as(u8, @truncate(s0))],
            table_decrypt[1][@as(u8, @truncate(s3 >> 8))],
            table_decrypt[2][@as(u8, @truncate(s2 >> 16))],
            table_decrypt[3][@as(u8, @truncate(s1 >> 24))],
        };
        var t0 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_decrypt[0][@as(u8, @truncate(s1))],
            table_decrypt[1][@as(u8, @truncate(s0 >> 8))],
            table_decrypt[2][@as(u8, @truncate(s3 >> 16))],
            table_decrypt[3][@as(u8, @truncate(s2 >> 24))],
        };
        var t1 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_decrypt[0][@as(u8, @truncate(s2))],
            table_decrypt[1][@as(u8, @truncate(s1 >> 8))],
            table_decrypt[2][@as(u8, @truncate(s0 >> 16))],
            table_decrypt[3][@as(u8, @truncate(s3 >> 24))],
        };
        var t2 = x[0] ^ x[1] ^ x[2] ^ x[3];
        x = .{
            table_decrypt[0][@as(u8, @truncate(s3))],
            table_decrypt[1][@as(u8, @truncate(s2 >> 8))],
            table_decrypt[2][@as(u8, @truncate(s1 >> 16))],
            table_decrypt[3][@as(u8, @truncate(s0 >> 24))],
        };
        var t3 = x[0] ^ x[1] ^ x[2] ^ x[3];

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Decrypt a block with the last round key.
    pub fn decryptLast(block: Block, round_key: Block) Block {
        const s0 = block.repr[0];
        const s1 = block.repr[1];
        const s2 = block.repr[2];
        const s3 = block.repr[3];

        // Last round uses s-box directly and XORs to produce output.
        var x: [4]u8 = undefined;
        x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s0)), @as(u8, @truncate(s3 >> 8)), @as(u8, @truncate(s2 >> 16)), @as(u8, @truncate(s1 >> 24)));
        var t0 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s1)), @as(u8, @truncate(s0 >> 8)), @as(u8, @truncate(s3 >> 16)), @as(u8, @truncate(s2 >> 24)));
        var t1 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s2)), @as(u8, @truncate(s1 >> 8)), @as(u8, @truncate(s0 >> 16)), @as(u8, @truncate(s3 >> 24)));
        var t2 = mem.readInt(u32, &x, .little);
        x = sbox_lookup(&sbox_decrypt, @as(u8, @truncate(s3)), @as(u8, @truncate(s2 >> 8)), @as(u8, @truncate(s1 >> 16)), @as(u8, @truncate(s0 >> 24)));
        var t3 = mem.readInt(u32, &x, .little);

        t0 ^= round_key.repr[0];
        t1 ^= round_key.repr[1];
        t2 ^= round_key.repr[2];
        t3 ^= round_key.repr[3];

        return Block{ .repr = Repr{ t0, t1, t2, t3 } };
    }

    /// Apply the bitwise XOR operation to the content of two blocks.
    pub fn xorBlocks(block1: Block, block2: Block) Block {
        var x: Repr = undefined;
        comptime var i = 0;
        inline while (i < 4) : (i += 1) {
            x[i] = block1.repr[i] ^ block2.repr[i];
        }
        return Block{ .repr = x };
    }

    /// Apply the bitwise AND operation to the content of two blocks.
    pub fn andBlocks(block1: Block, block2: Block) Block {
        var x: Repr = undefined;
        comptime var i = 0;
        inline while (i < 4) : (i += 1) {
            x[i] = block1.repr[i] & block2.repr[i];
        }
        return Block{ .repr = x };
    }

    /// Apply the bitwise OR operation to the content of two blocks.
    pub fn orBlocks(block1: Block, block2: Block) Block {
        var x: Repr = undefined;
        comptime var i = 0;
        inline while (i < 4) : (i += 1) {
            x[i] = block1.repr[i] | block2.repr[i];
        }
        return Block{ .repr = x };
    }

    /// Apply the inverse MixColumns operation to a block.
    pub fn invMixColumns(block: Block) Block {
        var out: Repr = undefined;
        inline for (0..4) |i| {
            const col = block.repr[i];
            const b0: u8 = @truncate(col);
            const b1: u8 = @truncate(col >> 8);
            const b2: u8 = @truncate(col >> 16);
            const b3: u8 = @truncate(col >> 24);

            const r0 = mul(0x0e, b0) ^ mul(0x0b, b1) ^ mul(0x0d, b2) ^ mul(0x09, b3);
            const r1 = mul(0x09, b0) ^ mul(0x0e, b1) ^ mul(0x0b, b2) ^ mul(0x0d, b3);
            const r2 = mul(0x0d, b0) ^ mul(0x09, b1) ^ mul(0x0e, b2) ^ mul(0x0b, b3);
            const r3 = mul(0x0b, b0) ^ mul(0x0d, b1) ^ mul(0x09, b2) ^ mul(0x0e, b3);

            out[i] = @as(u32, r0) | (@as(u32, r1) << 8) | (@as(u32, r2) << 16) | (@as(u32, r3) << 24);
        }
        return Block{ .repr = out };
    }

    /// Perform operations on multiple blocks in parallel.
    pub const parallel = struct {
        /// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
        pub const optimal_parallel_blocks = if (protected) bitsliced.width else 1;

        /// Encrypt multiple blocks in parallel, each their own round key.
        pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].encrypt(round_keys[i]);
            }
            return out;
        }

        /// Decrypt multiple blocks in parallel, each their own round key.
        pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].decrypt(round_keys[i]);
            }
            return out;
        }

        /// Encrypt multiple blocks in parallel with the same round key.
        pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].encrypt(round_key);
            }
            return out;
        }

        /// Decrypt multiple blocks in parallel with the same round key.
        pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].decrypt(round_key);
            }
            return out;
        }

        /// Encrypt multiple blocks in parallel with the same last round key.
        pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].encryptLast(round_key);
            }
            return out;
        }

        /// Decrypt multiple blocks in parallel with the same last round key.
        pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
            var i = 0;
            var out: [count]Block = undefined;
            while (i < count) : (i += 1) {
                out[i] = blocks[i].decryptLast(round_key);
            }
            return out;
        }
    };
};

/// A fixed-size vector of AES blocks.
/// All operations are performed in parallel, using SIMD instructions when available.
pub fn BlockVec(comptime blocks_count: comptime_int) type {
    return struct {
        const Self = @This();

        /// The number of AES blocks the target architecture can process with a single instruction.
        pub const native_vector_size = 1;

        /// The size of the AES block vector that the target architecture can process with a single instruction, in bytes.
        pub const native_word_size = native_vector_size * 16;

        const native_words = blocks_count;

        /// Internal representation of a block vector.
        repr: [native_words]Block,

        /// Length of the block vector in bytes.
        pub const block_length: usize = blocks_count * 16;

        /// Convert a byte sequence into an internal representation.
        pub fn fromBytes(bytes: *const [blocks_count * 16]u8) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = Block.fromBytes(bytes[i * native_word_size ..][0..native_word_size]);
            }
            return out;
        }

        /// Convert the internal representation of a block vector into a byte sequence.
        pub fn toBytes(block_vec: Self) [blocks_count * 16]u8 {
            var out: [blocks_count * 16]u8 = undefined;
            for (0..native_words) |i| {
                out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].toBytes();
            }
            return out;
        }

        /// XOR the block vector with a byte sequence.
        pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8 {
            var out: [blocks_count * 16]u8 = undefined;
            for (0..native_words) |i| {
                out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
            }
            return out;
        }

        /// Apply the forward AES operation to the block vector with a vector of round keys.
        pub fn encrypt(block_vec: Self, round_key_vec: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec.repr[i].encrypt(round_key_vec.repr[i]);
            }
            return out;
        }

        /// Apply the forward AES operation to the block vector with a vector of last round keys.
        pub fn encryptLast(block_vec: Self, round_key_vec: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec.repr[i].encryptLast(round_key_vec.repr[i]);
            }
            return out;
        }

        /// Apply the inverse AES operation to the block vector with a vector of round keys.
        pub fn decrypt(block_vec: Self, inv_round_key_vec: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec.repr[i].decrypt(inv_round_key_vec.repr[i]);
            }
            return out;
        }

        /// Apply the inverse AES operation to the block vector with a vector of last round keys.
        pub fn decryptLast(block_vec: Self, inv_round_key_vec: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec.repr[i].decryptLast(inv_round_key_vec.repr[i]);
            }
            return out;
        }

        /// Apply the bitwise XOR operation to the content of two block vectors.
        pub fn xorBlocks(block_vec1: Self, block_vec2: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec1.repr[i].xorBlocks(block_vec2.repr[i]);
            }
            return out;
        }

        /// Apply the bitwise AND operation to the content of two block vectors.
        pub fn andBlocks(block_vec1: Self, block_vec2: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec1.repr[i].andBlocks(block_vec2.repr[i]);
            }
            return out;
        }

        /// Apply the bitwise OR operation to the content of two block vectors.
        pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec1.repr[i].orBlocks(block_vec2.repr[i]);
            }
            return out;
        }

        /// Apply the inverse MixColumns operation to each block in the vector.
        pub fn invMixColumns(block_vec: Self) Self {
            var out: Self = undefined;
            for (0..native_words) |i| {
                out.repr[i] = block_vec.repr[i].invMixColumns();
            }
            return out;
        }
    };
}

fn KeySchedule(comptime Aes: type) type {
    std.debug.assert(Aes.rounds == 10 or Aes.rounds == 14);
    const key_length = Aes.key_bits / 8;
    const rounds = Aes.rounds;

    return struct {
        const Self = @This();
        const words_in_key = key_length / 4;

        round_keys: [rounds + 1]Block,

        // Key expansion algorithm. See FIPS-197, Figure 11.
        fn expandKey(key: [key_length]u8) Self {
            const subw = struct {
                // Apply sbox_encrypt to each byte in w.
                fn func(w: u32) u32 {
                    const x = sbox_lookup(&sbox_key_schedule, @as(u8, @truncate(w)), @as(u8, @truncate(w >> 8)), @as(u8, @truncate(w >> 16)), @as(u8, @truncate(w >> 24)));
                    return mem.readInt(u32, &x, .little);
                }
            }.func;

            var round_keys: [rounds + 1]Block = undefined;
            comptime var i: usize = 0;
            inline while (i < words_in_key) : (i += 1) {
                round_keys[i / 4].repr[i % 4] = mem.readInt(u32, key[4 * i ..][0..4], .big);
            }
            inline while (i < round_keys.len * 4) : (i += 1) {
                var t = round_keys[(i - 1) / 4].repr[(i - 1) % 4];
                if (i % words_in_key == 0) {
                    t = subw(std.math.rotl(u32, t, 8)) ^ (@as(u32, powx[i / words_in_key - 1]) << 24);
                } else if (words_in_key > 6 and i % words_in_key == 4) {
                    t = subw(t);
                }
                round_keys[i / 4].repr[i % 4] = round_keys[(i - words_in_key) / 4].repr[(i - words_in_key) % 4] ^ t;
            }
            i = 0;
            inline while (i < round_keys.len * 4) : (i += 1) {
                round_keys[i / 4].repr[i % 4] = @byteSwap(round_keys[i / 4].repr[i % 4]);
            }
            return Self{ .round_keys = round_keys };
        }

        /// Invert the key schedule.
        pub fn invert(key_schedule: Self) Self {
            const round_keys = &key_schedule.round_keys;
            var inv_round_keys: [rounds + 1]Block = undefined;
            const total_words = 4 * round_keys.len;
            var i: usize = 0;
            while (i < total_words) : (i += 4) {
                const ei = total_words - i - 4;
                comptime var j: usize = 0;
                inline while (j < 4) : (j += 1) {
                    var rk = round_keys[(ei + j) / 4].repr[(ei + j) % 4];
                    if (i > 0 and i + 4 < total_words) {
                        const x = sbox_lookup(&sbox_key_schedule, @as(u8, @truncate(rk >> 24)), @as(u8, @truncate(rk >> 16)), @as(u8, @truncate(rk >> 8)), @as(u8, @truncate(rk)));
                        const y = table_lookup(&table_decrypt, x[3], x[2], x[1], x[0]);
                        rk = y[0] ^ y[1] ^ y[2] ^ y[3];
                    }
                    inv_round_keys[(i + j) / 4].repr[(i + j) % 4] = rk;
                }
            }
            return Self{ .round_keys = inv_round_keys };
        }
    };
}

/// Packed forward round keys for the bitsliced implementation
fn PackedKeys(comptime rounds: usize) type {
    return if (protected) [rounds + 1]bitsliced.State else void;
}

/// Bitsliced operation over `count` blocks
fn bitslicedOperation(
    comptime rounds: usize,
    comptime operation: enum { encrypt, decrypt },
    keys: *const [rounds + 1]bitsliced.State,
    comptime count: usize,
    dst: *[16 * count]u8,
    src: *const [16 * count]u8,
) void {
    const w = bitsliced.width;
    const chunks = (count + w - 1) / w;
    inline for (0..chunks) |c| {
        const off: usize = c * w;
        const n: usize = @min(w, count - off);
        const lo = off * 16;
        const hi = lo + n * 16;
        var buf: [w * 16]u8 = undefined;
        @memcpy(buf[0 .. n * 16], src[lo..hi]);
        if (operation == .decrypt) {
            bitsliced.Wide.decrypt(rounds, keys, &buf);
        } else {
            bitsliced.Wide.encrypt(rounds, keys, &buf);
        }
        @memcpy(dst[lo..hi], buf[0 .. n * 16]);
    }
}

/// A context to perform encryption using the standard AES key schedule.
pub fn AesEncryptCtx(comptime Aes: type) type {
    std.debug.assert(Aes.key_bits == 128 or Aes.key_bits == 256);
    const rounds = Aes.rounds;

    return struct {
        const Self = @This();
        pub const block = Aes.block;
        pub const block_length = block.block_length;
        key_schedule: KeySchedule(Aes),
        packed_keys: PackedKeys(rounds),

        /// Create a new encryption context with the given key.
        pub fn init(key: [Aes.key_bits / 8]u8) Self {
            const key_schedule = KeySchedule(Aes).expandKey(key);
            return Self{
                .key_schedule = key_schedule,
                .packed_keys = if (protected) bitsliced.Wide.packKeys(key_schedule.round_keys[0..]) else {},
            };
        }

        /// Encrypt a single block, without any protection against side channels.
        fn encryptUnprotectedBlock(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
            const round_keys = ctx.key_schedule.round_keys;
            var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
            inline for (1..rounds) |i| {
                t = t.encryptUnprotected(round_keys[i]);
            }
            t = t.encryptLast(round_keys[rounds]);
            dst.* = t.toBytes();
        }

        /// Encrypt a single block.
        pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
            ctx.encryptWide(1, dst, src);
        }

        /// Encrypt+XOR a single block.
        pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
            ctx.xorWide(1, dst, src, counter);
        }

        /// Encrypt multiple blocks, possibly leveraging parallelization.
        pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
            if (protected) {
                bitslicedOperation(rounds, .encrypt, &ctx.packed_keys, count, dst, src);
            } else {
                for (0..count) |i| {
                    ctx.encryptUnprotectedBlock(dst[16 * i .. 16 * i + 16][0..16], src[16 * i .. 16 * i + 16][0..16]);
                }
            }
        }

        /// Encrypt+XOR multiple blocks, possibly leveraging parallelization.
        pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void {
            var ks: [16 * count]u8 = undefined;
            ctx.encryptWide(count, &ks, &counters);
            for (dst, ks, src) |*d, k, s| d.* = k ^ s;
        }
    };
}

/// A context to perform decryption using the standard AES key schedule.
pub fn AesDecryptCtx(comptime Aes: type) type {
    std.debug.assert(Aes.key_bits == 128 or Aes.key_bits == 256);
    const rounds = Aes.rounds;

    return struct {
        const Self = @This();
        pub const block = Aes.block;
        pub const block_length = block.block_length;
        key_schedule: KeySchedule(Aes),
        packed_keys: PackedKeys(rounds),

        /// Create a decryption context from an existing encryption context.
        pub fn initFromEnc(ctx: AesEncryptCtx(Aes)) Self {
            return Self{
                .key_schedule = ctx.key_schedule.invert(),
                .packed_keys = ctx.packed_keys,
            };
        }

        /// Create a new decryption context with the given key.
        pub fn init(key: [Aes.key_bits / 8]u8) Self {
            const enc_ctx = AesEncryptCtx(Aes).init(key);
            return initFromEnc(enc_ctx);
        }

        /// Decrypt a single block, without any protection against side channels.
        fn decryptUnprotectedBlock(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
            const inv_round_keys = ctx.key_schedule.round_keys;
            var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
            inline for (1..rounds) |i| {
                t = t.decryptUnprotected(inv_round_keys[i]);
            }
            t = t.decryptLast(inv_round_keys[rounds]);
            dst.* = t.toBytes();
        }

        /// Decrypt a single block.
        pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
            ctx.decryptWide(1, dst, src);
        }

        /// Decrypt multiple blocks, possibly leveraging parallelization.
        pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
            if (protected) {
                bitslicedOperation(rounds, .decrypt, &ctx.packed_keys, count, dst, src);
            } else {
                for (0..count) |i| {
                    ctx.decryptUnprotectedBlock(dst[16 * i .. 16 * i + 16][0..16], src[16 * i .. 16 * i + 16][0..16]);
                }
            }
        }
    };
}

/// AES-128 with the standard key schedule.
pub const Aes128 = struct {
    pub const key_bits: usize = 128;
    pub const rounds = ((key_bits - 64) / 32 + 8);
    pub const block = Block;

    /// Create a new context for encryption.
    pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes128) {
        return AesEncryptCtx(Aes128).init(key);
    }

    /// Create a new context for decryption.
    pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes128) {
        return AesDecryptCtx(Aes128).init(key);
    }
};

/// AES-256 with the standard key schedule.
pub const Aes256 = struct {
    pub const key_bits: usize = 256;
    pub const rounds = ((key_bits - 64) / 32 + 8);
    pub const block = Block;

    /// Create a new context for encryption.
    pub fn initEnc(key: [key_bits / 8]u8) AesEncryptCtx(Aes256) {
        return AesEncryptCtx(Aes256).init(key);
    }

    /// Create a new context for decryption.
    pub fn initDec(key: [key_bits / 8]u8) AesDecryptCtx(Aes256) {
        return AesDecryptCtx(Aes256).init(key);
    }
};

// constants

// Rijndael's irreducible polynomial.
const poly: u9 = 1 << 8 | 1 << 4 | 1 << 3 | 1 << 1 | 1 << 0; // x⁸ + x⁴ + x³ + x + 1

// Powers of x mod poly in GF(2).
const powx = init: {
    var array: [16]u8 = undefined;

    var value = 1;
    for (&array) |*power| {
        power.* = value;
        value = mul(value, 2);
    }

    break :init array;
};

const sbox_encrypt align(64) = generateSbox(false); // S-box for encryption
const sbox_key_schedule align(64) = generateSbox(false); // S-box only for key schedule, so that it uses distinct L1 cache entries than the S-box used for encryption
const sbox_decrypt align(64) = generateSbox(true); // S-box for decryption
const table_encrypt align(64) = generateTable(false); // 4-byte LUTs for encryption
const table_decrypt align(64) = generateTable(true); // 4-byte LUTs for decryption

// Generate S-box substitution values.
fn generateSbox(invert: bool) [256]u8 {
    @setEvalBranchQuota(10000);

    var sbox: [256]u8 = undefined;

    var p: u8 = 1;
    var q: u8 = 1;
    for (sbox) |_| {
        p = mul(p, 3);
        q = mul(q, 0xf6); // divide by 3

        var value: u8 = q ^ 0x63;
        value ^= math.rotl(u8, q, 1);
        value ^= math.rotl(u8, q, 2);
        value ^= math.rotl(u8, q, 3);
        value ^= math.rotl(u8, q, 4);

        if (invert) {
            sbox[value] = p;
        } else {
            sbox[p] = value;
        }
    }

    if (invert) {
        sbox[0x63] = 0x00;
    } else {
        sbox[0x00] = 0x63;
    }

    return sbox;
}

// Generate lookup tables.
fn generateTable(invert: bool) [4][256]u32 {
    @setEvalBranchQuota(50000);

    var table: [4][256]u32 = undefined;

    for (generateSbox(invert), 0..) |value, index| {
        table[0][index] = math.shl(u32, mul(value, if (invert) 0xb else 0x3), 24);
        table[0][index] |= math.shl(u32, mul(value, if (invert) 0xd else 0x1), 16);
        table[0][index] |= math.shl(u32, mul(value, if (invert) 0x9 else 0x1), 8);
        table[0][index] |= mul(value, if (invert) 0xe else 0x2);

        table[1][index] = math.rotl(u32, table[0][index], 8);
        table[2][index] = math.rotl(u32, table[0][index], 16);
        table[3][index] = math.rotl(u32, table[0][index], 24);
    }

    return table;
}

// Multiply a and b as GF(2) polynomials modulo poly.
fn mul(a: u8, b: u8) u8 {
    @setEvalBranchQuota(30000);

    var i: u8 = a;
    var j: u9 = b;
    var s: u9 = 0;

    while (i > 0) : (i >>= 1) {
        if (i & 1 != 0) {
            s ^= j;
        }

        j *= 2;
        if (j & 0x100 != 0) {
            j ^= poly;
        }
    }

    return @as(u8, @truncate(s));
}

const cache_line_bytes = std.atomic.cache_line;

fn sbox_lookup(sbox: *align(64) const [256]u8, idx0: u8, idx1: u8, idx2: u8, idx3: u8) [4]u8 {
    if (side_channels_mitigations == .none) {
        return [4]u8{
            sbox[idx0],
            sbox[idx1],
            sbox[idx2],
            sbox[idx3],
        };
    } else {
        const stride = switch (side_channels_mitigations) {
            .none => unreachable,
            .basic => sbox.len / 4,
            .medium => @min(sbox.len, 2 * cache_line_bytes),
            .full => @min(sbox.len, cache_line_bytes),
        };
        const of0 = idx0 % stride;
        const of1 = idx1 % stride;
        const of2 = idx2 % stride;
        const of3 = idx3 % stride;
        var t: [4][sbox.len / stride]u8 align(64) = undefined;
        var i: usize = 0;
        while (i < t[0].len) : (i += 1) {
            const tx = sbox[i * stride ..];
            t[0][i] = tx[of0];
            t[1][i] = tx[of1];
            t[2][i] = tx[of2];
            t[3][i] = tx[of3];
        }
        std.mem.doNotOptimizeAway(t);
        return [4]u8{
            t[0][idx0 / stride],
            t[1][idx1 / stride],
            t[2][idx2 / stride],
            t[3][idx3 / stride],
        };
    }
}

fn table_lookup(table: *align(64) const [4][256]u32, idx0: u8, idx1: u8, idx2: u8, idx3: u8) [4]u32 {
    if (side_channels_mitigations == .none) {
        return [4]u32{
            table[0][idx0],
            table[1][idx1],
            table[2][idx2],
            table[3][idx3],
        };
    } else {
        const table_len: usize = 256;
        const stride = switch (side_channels_mitigations) {
            .none => unreachable,
            .basic => table_len / 4,
            .medium => @max(1, @min(table_len, 2 * cache_line_bytes / 4)),
            .full => @max(1, @min(table_len, cache_line_bytes / 4)),
        };
        const of0 = idx0 % stride;
        const of1 = idx1 % stride;
        const of2 = idx2 % stride;
        const of3 = idx3 % stride;
        var t: [4][table_len / stride]u32 align(64) = undefined;
        var i: usize = 0;
        while (i < t[0].len) : (i += 1) {
            const tx = table[0][i * stride ..];
            t[0][i] = tx[of0];
            t[1][i] = tx[of1];
            t[2][i] = tx[of2];
            t[3][i] = tx[of3];
        }
        std.mem.doNotOptimizeAway(t);
        return [4]u32{
            t[0][idx0 / stride],
            math.rotl(u32, (&t[1])[idx1 / stride], 8),
            math.rotl(u32, (&t[2])[idx2 / stride], 16),
            math.rotl(u32, (&t[3])[idx3 / stride], 24),
        };
    }
}