commit 97b407ad111a956d2864813d4ce60ed254990a81
Author: Milan Špinka <mspi21@protonmail.com>
Date:   Sun Jan 26 01:31:43 2025 +0100

    Initial commit - AES tests, high level impl

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d8c8979
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+.zig-cache
+zig-out
diff --git a/build.zig b/build.zig
new file mode 100644
index 0000000..bb8eeed
--- /dev/null
+++ b/build.zig
@@ -0,0 +1,91 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    const lib = b.addStaticLibrary(.{
+        .name = "crypto",
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the library to be installed into the standard
+    // location when the user invokes the "install" step (the default step when
+    // running `zig build`).
+    b.installArtifact(lib);
+
+    //const exe = b.addExecutable(.{
+    //    .name = "crypto",
+    //    .root_source_file = b.path("src/main.zig"),
+    //    .target = target,
+    //    .optimize = optimize,
+    //});
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    //b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    //const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    //run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    //if (b.args) |args| {
+    //    run_cmd.addArgs(args);
+    //}
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    //const run_step = b.step("run", "Run the app");
+    //run_step.dependOn(&run_cmd.step);
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const lib_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+
+    //const exe_unit_tests = b.addTest(.{
+    //    .root_source_file = b.path("src/main.zig"),
+    //    .target = target,
+    //    .optimize = optimize,
+    //});
+
+    //const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_unit_tests.step);
+    //test_step.dependOn(&run_exe_unit_tests.step);
+}
diff --git a/build.zig.zon b/build.zig.zon
new file mode 100644
index 0000000..9f5865a
--- /dev/null
+++ b/build.zig.zon
@@ -0,0 +1,72 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = "crypto",
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // This field is optional.
+    // This is currently advisory only; Zig does not yet do anything
+    // with this value.
+    //.minimum_zig_version = "0.11.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}
diff --git a/src/primitive/blockcipher/aes.zig b/src/primitive/blockcipher/aes.zig
new file mode 100644
index 0000000..bf0c618
--- /dev/null
+++ b/src/primitive/blockcipher/aes.zig
@@ -0,0 +1,505 @@
+const std = @import("std");
+const testing = std.testing;
+
+// ----------------------------------- AES CONSTANTS -----------------------------------  //
+
+pub const AES_BLOCK_SIZE = 128 / 8;
+
+pub const Aes128Parameters = struct {
+    pub const KEY_SIZE = 128 / 8;
+    pub const N_ROUNDS = 10;
+};
+pub const Aes192Parameters = struct {
+    pub const KEY_SIZE = 192 / 8;
+    pub const N_ROUNDS = 12;
+};
+pub const Aes256Parameters = struct {
+    pub const KEY_SIZE = 256 / 8;
+    pub const N_ROUNDS = 14;
+};
+
+const AES_SBOX = [_]u8{
+    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
+};
+
+const AES_INV_SBOX = [_]u8{
+    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
+};
+
+const AES_RCON = [_]u32{
+    0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,
+    0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000,
+};
+
+// ----------------------------------- ENCRYPTION/DECRYPTION -----------------------------------  //
+
+pub fn aes_encrypt_block(n_rounds: comptime_int, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8, expanded_key: *const [4 * (n_rounds + 1)]u32) void {
+    // Copy input buffer into state (we're treating the buffer as a column-first matrix).
+    var state: [AES_BLOCK_SIZE]u8 = undefined;
+    @memcpy(state[0..], block_in);
+
+    // Initial AddRoundKey.
+    aes_add_round_key(&state, expanded_key[0..4]);
+
+    // Nr - 1 identical rounds.
+    for (1..n_rounds) |round| {
+        aes_sub_bytes(&state);
+        aes_shift_rows(&state);
+        aes_mix_columns(&state);
+        aes_add_round_key(&state, @ptrCast(expanded_key[(4 * round)..(4 * round + 4)]));
+    }
+
+    // Last round is without MixColumns.
+    aes_sub_bytes(&state);
+    aes_shift_rows(&state);
+    aes_add_round_key(&state, @ptrCast(expanded_key[(4 * n_rounds)..(4 * n_rounds + 4)]));
+
+    // Write the result into the destination buffer.
+    @memcpy(block_out, &state);
+
+    // Destroy the ciphertext in the internal buffer.
+    @memset(state[0..], 0);
+}
+
+pub fn aes_decrypt_block(n_rounds: comptime_int, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8, expanded_key: *const [4 * (n_rounds + 1)]u32) void {
+    // Copy input buffer into state (we're treating the buffer as a column-first matrix).
+    var state: [AES_BLOCK_SIZE]u8 = undefined;
+    @memcpy(state[0..], block_in);
+
+    // Reverse the AddRoundKey that was applied after the last encryption round.
+    aes_add_round_key(&state, @ptrCast(expanded_key[(4 * n_rounds)..(4 * n_rounds + 4)]));
+
+    // Nr - 1 identical rounds.
+    for (1..n_rounds) |inv_round| {
+        const round = n_rounds - inv_round;
+        aes_inv_shift_rows(&state);
+        aes_inv_sub_bytes(&state);
+        aes_add_round_key(&state, @ptrCast(expanded_key[(4 * round)..(4 * round + 4)]));
+        aes_inv_mix_columns(&state);
+    }
+
+    // Finish last round.
+    aes_inv_shift_rows(&state);
+    aes_sub_bytes(&state);
+    aes_add_round_key(&state, expanded_key[0..4]);
+
+    // Write the result into the destination buffer.
+    @memcpy(block_out, &state);
+
+    // Destroy the plaintext in the internal buffer.
+    @memset(state[0..], 0);
+}
+
+pub fn aes_128_encrypt_block(key: *const [Aes128Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_128_expand_key(key);
+
+    // Call the generic encryption procedure.
+    aes_encrypt_block(Aes128Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+pub fn aes_128_decrypt_block(key: *const [Aes128Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_128_expand_key(key);
+
+    // Call the generic decryption procedure.
+    aes_decrypt_block(Aes128Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+pub fn aes_192_encrypt_block(key: *const [Aes192Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_192_expand_key(key);
+
+    // Call the generic encryption procedure.
+    aes_encrypt_block(Aes192Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+pub fn aes_192_decrypt_block(key: *const [Aes192Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_192_expand_key(key);
+
+    // Call the generic decryption procedure.
+    aes_decrypt_block(Aes192Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+pub fn aes_256_encrypt_block(key: *const [Aes256Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_256_expand_key(key);
+
+    // Call the generic encryption procedure.
+    aes_encrypt_block(Aes256Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+pub fn aes_256_decrypt_block(key: *const [Aes256Parameters.KEY_SIZE]u8, block_in: *const [AES_BLOCK_SIZE]u8, block_out: *[AES_BLOCK_SIZE]u8) void {
+    // Prepare the subkeys for AddRoundKey.
+    const expanded_key = aes_256_expand_key(key);
+
+    // Call the generic decryption procedure.
+    aes_decrypt_block(Aes256Parameters.N_ROUNDS, block_in, block_out, &expanded_key);
+}
+
+// ----------------------------------- KEY EXPANSION -----------------------------------  //
+
+pub fn aes_expand_key(n_rounds: comptime_int, n_key_words: comptime_int, key: *const [n_key_words * 4]u8) [4 * (n_rounds + 1)]u32 {
+    var expanded_key: [4 * (n_rounds + 1)]u32 = undefined;
+
+    var i: u32 = 0;
+    while (i <= n_key_words - 1) : (i += 1) {
+        expanded_key[i] = bytes_to_word(&.{ key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3] });
+    }
+    while (i <= 4 * n_rounds + 3) : (i += 1) {
+        var temp = expanded_key[i - 1];
+        if (i % n_key_words == 0) {
+            temp = aes_sub_word(aes_rot_word(temp)) ^ AES_RCON[i / n_key_words - 1];
+        } else if (n_key_words > 6 and i % n_key_words == 4) {
+            temp = aes_sub_word(temp);
+        }
+        expanded_key[i] = expanded_key[i - n_key_words] ^ temp;
+    }
+
+    return expanded_key;
+}
+
+pub fn aes_128_expand_key(key: *const [Aes128Parameters.KEY_SIZE]u8) [4 * (Aes128Parameters.N_ROUNDS + 1)]u32 {
+    return aes_expand_key(Aes128Parameters.N_ROUNDS, Aes128Parameters.KEY_SIZE / 4, key);
+}
+
+pub fn aes_192_expand_key(key: *const [Aes192Parameters.KEY_SIZE]u8) [4 * (Aes192Parameters.N_ROUNDS + 1)]u32 {
+    return aes_expand_key(Aes192Parameters.N_ROUNDS, Aes192Parameters.KEY_SIZE / 4, key);
+}
+
+pub fn aes_256_expand_key(key: *const [Aes256Parameters.KEY_SIZE]u8) [4 * (Aes256Parameters.N_ROUNDS + 1)]u32 {
+    return aes_expand_key(Aes256Parameters.N_ROUNDS, Aes256Parameters.KEY_SIZE / 4, key);
+}
+
+// ----------------------------------- AES OPERATIONS -----------------------------------  //
+
+fn aes_add_round_key(state: *[AES_BLOCK_SIZE]u8, subkey: *const [4]u32) void {
+    for (0..4) |wi| {
+        const subkey_bytes = word_to_bytes(subkey[wi]);
+        for (0..4) |bi| {
+            state[wi * 4 + bi] ^= subkey_bytes[bi];
+        }
+    }
+}
+
+fn aes_sub_bytes(state: *[AES_BLOCK_SIZE]u8) void {
+    for (0..state.len) |i| {
+        state[i] = AES_SBOX[state[i]];
+    }
+}
+
+fn aes_shift_rows(state: *[AES_BLOCK_SIZE]u8) void {
+    _ = state;
+    // TODO
+}
+
+fn aes_mix_columns(state: *[AES_BLOCK_SIZE]u8) void {
+    _ = state;
+    // TODO
+}
+
+fn aes_inv_sub_bytes(state: *[AES_BLOCK_SIZE]u8) void {
+    for (0..state.len) |i| {
+        state[i] = AES_INV_SBOX[state[i]];
+    }
+}
+
+fn aes_inv_shift_rows(state: *[AES_BLOCK_SIZE]u8) void {
+    _ = state;
+    // TODO
+}
+
+fn aes_inv_mix_columns(state: *[AES_BLOCK_SIZE]u8) void {
+    _ = state;
+    // TODO
+}
+
+fn aes_sub_word(word: u32) u32 {
+    var bytes = word_to_bytes(word);
+    for (0..4) |i| {
+        bytes[i] = AES_SBOX[bytes[i]];
+    }
+    return bytes_to_word(&bytes);
+}
+
+fn aes_rot_word(word: u32) u32 {
+    const bytes = word_to_bytes(word);
+    return bytes_to_word(&.{ bytes[1], bytes[2], bytes[3], bytes[0] });
+}
+
+// ----------------------------------- ENDIANNESS HELPERS -----------------------------------  //
+
+fn word_to_bytes(word: u32) [4]u8 {
+    var bytes: [4]u8 = undefined;
+    bytes[0] = @truncate(word >> 24);
+    bytes[1] = @truncate(word >> 16);
+    bytes[2] = @truncate(word >> 8);
+    bytes[3] = @truncate(word);
+    return bytes;
+}
+
+fn bytes_to_word(bytes: *const [4]u8) u32 {
+    return (@as(u32, bytes[0]) << 24) | (@as(u32, bytes[1]) << 16) | (@as(u32, bytes[2]) << 8) | @as(u32, bytes[3]);
+}
+
+// ----------------------------------- TEST VECTORS -----------------------------------  //
+
+test "AES-128 key expansion test vector from FIPS 197 A.1" {
+    const key = [Aes128Parameters.KEY_SIZE]u8{
+        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
+        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
+    };
+    const expected_expansion = [(Aes128Parameters.N_ROUNDS + 1) * 4]u32{
+        0x2b7e1516, 0x28aed2a6, 0xabf71588, 0x09cf4f3c,
+        0xa0fafe17, 0x88542cb1, 0x23a33939, 0x2a6c7605,
+        0xf2c295f2, 0x7a96b943, 0x5935807a, 0x7359f67f,
+        0x3d80477d, 0x4716fe3e, 0x1e237e44, 0x6d7a883b,
+        0xef44a541, 0xa8525b7f, 0xb671253b, 0xdb0bad00,
+        0xd4d1c6f8, 0x7c839d87, 0xcaf2b8bc, 0x11f915bc,
+        0x6d88a37a, 0x110b3efd, 0xdbf98641, 0xca0093fd,
+        0x4e54f70e, 0x5f5fc9f3, 0x84a64fb2, 0x4ea6dc4f,
+        0xead27321, 0xb58dbad2, 0x312bf560, 0x7f8d292f,
+        0xac7766f3, 0x19fadc21, 0x28d12941, 0x575c006e,
+        0xd014f9a8, 0xc9ee2589, 0xe13f0cc8, 0xb6630ca6,
+    };
+
+    try testing.expect(std.mem.eql(u32, &aes_128_expand_key(&key), &expected_expansion));
+}
+
+test "AES-192 key expansion test vector from FIPS 197 A.1" {
+    const key = [Aes192Parameters.KEY_SIZE]u8{
+        0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
+        0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
+        0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b,
+    };
+    const expected_expansion = [(Aes192Parameters.N_ROUNDS + 1) * 4]u32{
+        0x8e73b0f7, 0xda0e6452, 0xc810f32b, 0x809079e5,
+        0x62f8ead2, 0x522c6b7b, 0xfe0c91f7, 0x2402f5a5,
+        0xec12068e, 0x6c827f6b, 0x0e7a95b9, 0x5c56fec2,
+        0x4db7b4bd, 0x69b54118, 0x85a74796, 0xe92538fd,
+        0xe75fad44, 0xbb095386, 0x485af057, 0x21efb14f,
+        0xa448f6d9, 0x4d6dce24, 0xaa326360, 0x113b30e6,
+        0xa25e7ed5, 0x83b1cf9a, 0x27f93943, 0x6a94f767,
+        0xc0a69407, 0xd19da4e1, 0xec1786eb, 0x6fa64971,
+        0x485f7032, 0x22cb8755, 0xe26d1352, 0x33f0b7b3,
+        0x40beeb28, 0x2f18a259, 0x6747d26b, 0x458c553e,
+        0xa7e1466c, 0x9411f1df, 0x821f750a, 0xad07d753,
+        0xca400538, 0x8fcc5006, 0x282d166a, 0xbc3ce7b5,
+        0xe98ba06f, 0x448c773c, 0x8ecc7204, 0x01002202,
+    };
+    try testing.expect(std.mem.eql(u32, &aes_192_expand_key(&key), &expected_expansion));
+}
+
+test "AES-256 key expansion test vector from FIPS 197 A.1" {
+    const key = [Aes256Parameters.KEY_SIZE]u8{
+        0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
+        0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
+        0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
+        0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4,
+    };
+    const expected_expansion = [(Aes256Parameters.N_ROUNDS + 1) * 4]u32{
+        0x603deb10, 0x15ca71be, 0x2b73aef0, 0x857d7781,
+        0x1f352c07, 0x3b6108d7, 0x2d9810a3, 0x0914dff4,
+        0x9ba35411, 0x8e6925af, 0xa51a8b5f, 0x2067fcde,
+        0xa8b09c1a, 0x93d194cd, 0xbe49846e, 0xb75d5b9a,
+        0xd59aecb8, 0x5bf3c917, 0xfee94248, 0xde8ebe96,
+        0xb5a9328a, 0x2678a647, 0x98312229, 0x2f6c79b3,
+        0x812c81ad, 0xdadf48ba, 0x24360af2, 0xfab8b464,
+        0x98c5bfc9, 0xbebd198e, 0x268c3ba7, 0x09e04214,
+        0x68007bac, 0xb2df3316, 0x96e939e4, 0x6c518d80,
+        0xc814e204, 0x76a9fb8a, 0x5025c02d, 0x59c58239,
+        0xde136967, 0x6ccc5a71, 0xfa256395, 0x9674ee15,
+        0x5886ca5d, 0x2e2f31d7, 0x7e0af1fa, 0x27cf73c3,
+        0x749c47ab, 0x18501dda, 0xe2757e4f, 0x7401905a,
+        0xcafaaae3, 0xe4d59b34, 0x9adf6ace, 0xbd10190d,
+        0xfe4890d1, 0xe6188d0b, 0x046df344, 0x706c631e,
+    };
+    try testing.expect(std.mem.eql(u32, &aes_256_expand_key(&key), &expected_expansion));
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-128 ECB encryption" {
+    const key = [Aes128Parameters.KEY_SIZE]u8{
+        0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x3A, 0xD7, 0x7B, 0xB4, 0x0D, 0x7A, 0x36, 0x60, 0xA8, 0x9E, 0xCA, 0xF3, 0x24, 0x66, 0xEF, 0x97 },
+        .{ 0xF5, 0xD3, 0xD5, 0x85, 0x03, 0xB9, 0x69, 0x9D, 0xE7, 0x85, 0x89, 0x5A, 0x96, 0xFD, 0xBA, 0xAF },
+        .{ 0x43, 0xB1, 0xCD, 0x7F, 0x59, 0x8E, 0xCE, 0x23, 0x88, 0x1B, 0x00, 0xE3, 0xED, 0x03, 0x06, 0x88 },
+        .{ 0x7B, 0x0C, 0x78, 0x5E, 0x27, 0xE8, 0xAD, 0x3F, 0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5D, 0xD4 },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (plaintext, 0..) |pt, i| {
+        aes_128_encrypt_block(&key, &pt, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &ciphertext[i]));
+    }
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-128 ECB decryption" {
+    const key = [Aes128Parameters.KEY_SIZE]u8{
+        0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x3A, 0xD7, 0x7B, 0xB4, 0x0D, 0x7A, 0x36, 0x60, 0xA8, 0x9E, 0xCA, 0xF3, 0x24, 0x66, 0xEF, 0x97 },
+        .{ 0xF5, 0xD3, 0xD5, 0x85, 0x03, 0xB9, 0x69, 0x9D, 0xE7, 0x85, 0x89, 0x5A, 0x96, 0xFD, 0xBA, 0xAF },
+        .{ 0x43, 0xB1, 0xCD, 0x7F, 0x59, 0x8E, 0xCE, 0x23, 0x88, 0x1B, 0x00, 0xE3, 0xED, 0x03, 0x06, 0x88 },
+        .{ 0x7B, 0x0C, 0x78, 0x5E, 0x27, 0xE8, 0xAD, 0x3F, 0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5D, 0xD4 },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (ciphertext, 0..) |ct, i| {
+        aes_128_decrypt_block(&key, &ct, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &plaintext[i]));
+    }
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-192 ECB encryption" {
+    const key = [Aes192Parameters.KEY_SIZE]u8{
+        0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
+        0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
+        0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0xBD, 0x33, 0x4F, 0x1D, 0x6E, 0x45, 0xF2, 0x5F, 0xF7, 0x12, 0xA2, 0x14, 0x57, 0x1F, 0xA5, 0xCC },
+        .{ 0x97, 0x41, 0x04, 0x84, 0x6D, 0x0A, 0xD3, 0xAD, 0x77, 0x34, 0xEC, 0xB3, 0xEC, 0xEE, 0x4E, 0xEF },
+        .{ 0xEF, 0x7A, 0xFD, 0x22, 0x70, 0xE2, 0xE6, 0x0A, 0xDC, 0xE0, 0xBA, 0x2F, 0xAC, 0xE6, 0x44, 0x4E },
+        .{ 0x9A, 0x4B, 0x41, 0xBA, 0x73, 0x8D, 0x6C, 0x72, 0xFB, 0x16, 0x69, 0x16, 0x03, 0xC1, 0x8E, 0x0E },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (plaintext, 0..) |pt, i| {
+        aes_192_encrypt_block(&key, &pt, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &ciphertext[i]));
+    }
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-192 ECB decryption" {
+    const key = [Aes192Parameters.KEY_SIZE]u8{
+        0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
+        0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
+        0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0xBD, 0x33, 0x4F, 0x1D, 0x6E, 0x45, 0xF2, 0x5F, 0xF7, 0x12, 0xA2, 0x14, 0x57, 0x1F, 0xA5, 0xCC },
+        .{ 0x97, 0x41, 0x04, 0x84, 0x6D, 0x0A, 0xD3, 0xAD, 0x77, 0x34, 0xEC, 0xB3, 0xEC, 0xEE, 0x4E, 0xEF },
+        .{ 0xEF, 0x7A, 0xFD, 0x22, 0x70, 0xE2, 0xE6, 0x0A, 0xDC, 0xE0, 0xBA, 0x2F, 0xAC, 0xE6, 0x44, 0x4E },
+        .{ 0x9A, 0x4B, 0x41, 0xBA, 0x73, 0x8D, 0x6C, 0x72, 0xFB, 0x16, 0x69, 0x16, 0x03, 0xC1, 0x8E, 0x0E },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (ciphertext, 0..) |ct, i| {
+        aes_192_decrypt_block(&key, &ct, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &plaintext[i]));
+    }
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-256 ECB encryption" {
+    const key = [Aes256Parameters.KEY_SIZE]u8{
+        0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE, 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
+        0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7, 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0xF3, 0xEE, 0xD1, 0xBD, 0xB5, 0xD2, 0xA0, 0x3C, 0x06, 0x4B, 0x5A, 0x7E, 0x3D, 0xB1, 0x81, 0xF8 },
+        .{ 0x59, 0x1C, 0xCB, 0x10, 0xD4, 0x10, 0xED, 0x26, 0xDC, 0x5B, 0xA7, 0x4A, 0x31, 0x36, 0x28, 0x70 },
+        .{ 0xB6, 0xED, 0x21, 0xB9, 0x9C, 0xA6, 0xF4, 0xF9, 0xF1, 0x53, 0xE7, 0xB1, 0xBE, 0xAF, 0xED, 0x1D },
+        .{ 0x23, 0x30, 0x4B, 0x7A, 0x39, 0xF9, 0xF3, 0xFF, 0x06, 0x7D, 0x8D, 0x8F, 0x9E, 0x24, 0xEC, 0xC7 },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (plaintext, 0..) |pt, i| {
+        aes_256_encrypt_block(&key, &pt, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &ciphertext[i]));
+    }
+}
+
+// https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values
+test "AES-256 ECB decryption" {
+    const key = [Aes256Parameters.KEY_SIZE]u8{
+        0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE, 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
+        0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7, 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4,
+    };
+    const plaintext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
+        .{ 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
+        .{ 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF },
+        .{ 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10 },
+    };
+    const ciphertext = [_][AES_BLOCK_SIZE]u8{
+        .{ 0xF3, 0xEE, 0xD1, 0xBD, 0xB5, 0xD2, 0xA0, 0x3C, 0x06, 0x4B, 0x5A, 0x7E, 0x3D, 0xB1, 0x81, 0xF8 },
+        .{ 0x59, 0x1C, 0xCB, 0x10, 0xD4, 0x10, 0xED, 0x26, 0xDC, 0x5B, 0xA7, 0x4A, 0x31, 0x36, 0x28, 0x70 },
+        .{ 0xB6, 0xED, 0x21, 0xB9, 0x9C, 0xA6, 0xF4, 0xF9, 0xF1, 0x53, 0xE7, 0xB1, 0xBE, 0xAF, 0xED, 0x1D },
+        .{ 0x23, 0x30, 0x4B, 0x7A, 0x39, 0xF9, 0xF3, 0xFF, 0x06, 0x7D, 0x8D, 0x8F, 0x9E, 0x24, 0xEC, 0xC7 },
+    };
+
+    var buffer: [AES_BLOCK_SIZE]u8 = undefined;
+    for (ciphertext, 0..) |ct, i| {
+        aes_256_decrypt_block(&key, &ct, &buffer);
+        try testing.expect(std.mem.eql(u8, &buffer, &plaintext[i]));
+    }
+}
diff --git a/src/root.zig b/src/root.zig
new file mode 100644
index 0000000..6996c6a
--- /dev/null
+++ b/src/root.zig
@@ -0,0 +1,18 @@
+const std = @import("std");
+const testing = std.testing;
+
+const CryptoError = error{
+    InvalidBufferSize,
+};
+
+// rn just for build, later will be used by high-level API
+const aes = @import("primitive/blockcipher/aes.zig");
+
+// Leave this for later, maybe make a separate ffi module
+
+//export fn aes_128_encrypt_block_ffi(block_in: [*c]const u8, len_in: usize, block_out: [*c]u8, len_out: usize) !void {
+//    if (len_in != AES_128_BLOCK_SIZE or len_out != AES_128_BLOCK_SIZE)
+//        return CryptoError.InvalidBufferSize;
+//
+//    aes_128_encrypt_block(block_in[0..AES_128_BLOCK_SIZE], block_out[0..AES_128_BLOCK_SIZE]);
+//}