claude is gud

2 files changed, 540 insertions, 0 deletions

diff --git a/vere/ext/urcrypt/build.zig b/vere/ext/urcrypt/build.zig
new file mode 100644
index 0000000..2289287
--- /dev/null
+++ b/vere/ext/urcrypt/build.zig
@@ -0,0 +1,515 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const openssl = b.dependency("openssl", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "urcrypt",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.linkLibrary(libsecp256k1(b, target, optimize));
+    lib.linkLibrary(libargon2(b, target, optimize));
+    lib.linkLibrary(libblake3(b, target, optimize));
+    lib.linkLibrary(libed25519(b, target, optimize));
+    lib.linkLibrary(libge_additions(b, target, optimize));
+    lib.linkLibrary(libkeccak_tiny(b, target, optimize));
+    lib.linkLibrary(libmonocypher(b, target, optimize));
+    lib.linkLibrary(libscrypt(b, target, optimize));
+
+    lib.linkLibrary(libaes_siv(b, target, optimize));
+    lib.linkLibrary(openssl.artifact("ssl"));
+    lib.linkLibrary(openssl.artifact("crypto"));
+
+    lib.addIncludePath(dep_c.path("urcrypt"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("urcrypt"),
+        .files = &.{
+            "aes_cbc.c",
+            "aes_ecb.c",
+            "aes_siv.c",
+            "argon.c",
+            "blake3.c",
+            "chacha.c",
+            "ed25519.c",
+            "ge_additions.c",
+            "keccak.c",
+            "ripemd.c",
+            "scrypt.c",
+            "secp256k1.c",
+            "sha.c",
+            "util.c",
+        },
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+            "-g",
+            "-Wall",
+            "-DSECP256K1_STATIC",
+        },
+    });
+
+    lib.installHeader(dep_c.path("urcrypt/urcrypt.h"), "urcrypt.h");
+
+    b.installArtifact(lib);
+}
+
+fn libaes_siv(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const openssl = b.dependency("openssl", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const dep_c = b.dependency("aes_siv", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "aes_siv",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibrary(openssl.artifact("ssl"));
+    lib.linkLibrary(openssl.artifact("crypto"));
+
+    const config_h = b.addConfigHeader(.{
+        .style = .blank,
+        .include_path = "config.h",
+    }, .{});
+    lib.addConfigHeader(config_h);
+    lib.addIncludePath(dep_c.path(""));
+    lib.addCSourceFiles(.{
+        .root = dep_c.path(""),
+        .files = &.{
+            "aes_siv.c",
+        },
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+        },
+    });
+
+    lib.installHeader(dep_c.path("aes_siv.h"), "aes_siv.h");
+
+    lib.linkLibC();
+
+    return lib;
+}
+
+fn libsecp256k1(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("secp256k1", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "secp256k1",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("src"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("src"),
+        .files = &.{
+            "precomputed_ecmult.c",
+            "precomputed_ecmult_gen.c",
+            "secp256k1.c",
+        },
+        .flags = &.{
+            "-fno-sanitize=all",
+            "-g",
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-std=c89",
+            "-pedantic",
+            "-Wno-long-long",
+            "-Wnested-externs",
+            "-Wshadow",
+            "-Wstrict-prototypes",
+            "-Wundef",
+            "-Wno-overlength-strings",
+            "-Wall",
+            "-Wno-unused-function",
+            "-Wextra",
+            "-Wcast-align",
+            "-Wconditional-uninitialized",
+            "-fvisibility=hidden",
+
+            // "-DHAVE_CONFIG_H",
+            // "-dexhaustive_test_ORDER=7",
+            "-DSECP256K1_BUILD",
+            "-DECMULT_WINDOW_SIZE=15",
+            "-DCOMB_BLOCKS=43",
+            "-DCOMB_TEETH=6",
+            "-DENABLE_MODULE_ELLSWIFT=1",
+            "-DENABLE_MODULE_SCHNORRSIG=1",
+            "-DENABLE_MODULE_EXTRAKEYS=1",
+            "-DENABLE_MODULE_RECOVERY=1",
+            "-DENABLE_MODULE_ECDH=1",
+        },
+    });
+
+    lib.installHeadersDirectory(dep_c.path("include"), "", .{});
+
+    return lib;
+}
+
+fn libargon2(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "argon2",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    const flags = .{
+        "-O2",
+        "-fno-omit-frame-pointer",
+        "-fno-sanitize=all",
+        "-Wno-unused-value",
+        "-Wno-unused-function",
+        "-DARGON2_NO_THREADS",
+    };
+
+    const common_files = .{
+        "src/argon2.c",
+        "src/core.c",
+        "src/blake2/blake2b.c",
+        "src/encoding.c",
+        "src/thread.c",
+    };
+
+    lib.addIncludePath(dep_c.path("argon2/include"));
+    lib.addIncludePath(dep_c.path("argon2/src"));
+    lib.addIncludePath(dep_c.path("argon2/src/blake2"));
+
+    if (target.result.cpu.arch == .x86_64) {
+        lib.addCSourceFiles(.{
+            .root = dep_c.path("argon2"),
+            .files = &(common_files ++ .{"src/opt.c"}),
+            .flags = &flags,
+        });
+    } else {
+        lib.addCSourceFiles(.{
+            .root = dep_c.path("argon2"),
+            .files = &(common_files ++ .{"src/ref.c"}),
+            .flags = &flags,
+        });
+    }
+
+    lib.installHeader(dep_c.path("argon2/include/argon2.h"), "argon2.h");
+    lib.installHeader(dep_c.path("argon2/src/blake2/blake2.h"), "blake2.h");
+
+    return lib;
+}
+
+fn libblake3(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "blake3",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    const common_files = .{
+        "blake3.c",
+        "blake3_dispatch.c",
+        "blake3_portable.c",
+    };
+
+    lib.addIncludePath(dep_c.path("blake3"));
+
+    if (target.result.cpu.arch == .x86_64) {
+        lib.addCSourceFiles(.{
+            .root = dep_c.path("blake3"),
+            .files = &(common_files ++ .{
+                "blake3_sse2_x86-64_unix.S",
+                "blake3_sse41_x86-64_unix.S",
+                "blake3_avx2_x86-64_unix.S",
+                "blake3_avx512_x86-64_unix.S",
+            }),
+            .flags = &.{
+                "-O2",
+                "-fno-omit-frame-pointer",
+                "-fno-sanitize=all",
+            },
+        });
+    } else {
+        lib.addCSourceFiles(.{
+            .root = dep_c.path("blake3"),
+            .files = &(common_files ++ .{"blake3_neon.c"}),
+            .flags = &.{
+                "-O2",
+                "-fno-omit-frame-pointer",
+                "-fno-sanitize=all",
+                "-DBLAKE3_USE_NEON=1",
+            },
+        });
+    }
+
+    lib.installHeader(dep_c.path("blake3/blake3.h"), "blake3.h");
+    lib.installHeader(dep_c.path("blake3/blake3_impl.h"), "blake3_impl.h");
+
+    return lib;
+}
+
+fn libed25519(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "ed25519",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("ed25519/src"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("ed25519"),
+        .files = &.{
+            "src/add_scalar.c",
+            "src/fe.c",
+            "src/ge.c",
+            "src/keypair.c",
+            "src/key_exchange.c",
+            "src/sc.c",
+            "src/seed.c",
+            "src/sha512.c",
+            "src/sign.c",
+            "src/verify.c",
+        },
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+            "-Wno-unused-result",
+        },
+    });
+
+    lib.installHeadersDirectory(dep_c.path("ed25519/src"), "", .{
+        .include_extensions = &.{".h"},
+    });
+
+    return lib;
+}
+
+fn libge_additions(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "ge_additions",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("ed25519/src"));
+    lib.addIncludePath(dep_c.path("ge-additions"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("ge-additions"),
+        .files = &.{"ge-additions.c"},
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+            "-Werror",
+            "-pedantic",
+            "-std=gnu99",
+        },
+    });
+
+    lib.installHeader(dep_c.path("ge-additions/ge-additions.h"), "ge-additions.h");
+
+    return lib;
+}
+
+fn libkeccak_tiny(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "keccak_tiny",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("keccak-tiny"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("keccak-tiny"),
+        .files = &.{"keccak-tiny.c"},
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+            "-std=c11",
+            "-Wextra",
+            "-Wpedantic",
+            "-Wall",
+        },
+    });
+
+    lib.installHeader(dep_c.path("keccak-tiny/keccak-tiny.h"), "keccak-tiny.h");
+
+    return lib;
+}
+
+fn libmonocypher(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "monocypher",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("monocypher"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("monocypher"),
+        .files = &.{"monocypher.c"},
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+        },
+    });
+
+    lib.installHeader(dep_c.path("monocypher/monocypher.h"), "monocypher.h");
+
+    return lib;
+}
+
+fn libscrypt(
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Step.Compile {
+    const dep_c = b.dependency("urcrypt", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const lib = b.addStaticLibrary(.{
+        .name = "scrypt",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.linkLibC();
+
+    lib.addIncludePath(dep_c.path("scrypt"));
+
+    lib.addCSourceFiles(.{
+        .root = dep_c.path("scrypt"),
+        .files = &.{
+            "b64.c",
+            "crypto-mcf.c",
+            "crypto-scrypt-saltgen.c",
+            "crypto_scrypt-check.c",
+            "crypto_scrypt-hash.c",
+            "crypto_scrypt-hexconvert.c",
+            "crypto_scrypt-nosse.c",
+            // "main.c",
+            "sha256.c",
+            "slowequals.c",
+        },
+        .flags = &.{
+            "-O2",
+            "-fno-omit-frame-pointer",
+            "-fno-sanitize=all",
+            "-D_FORTIFY_SOURCE=2",
+        },
+    });
+
+    lib.installHeader(dep_c.path("scrypt/libscrypt.h"), "libscrypt.h");
+    lib.installHeader(dep_c.path("scrypt/sha256.h"), "sha256.h");
+
+    return lib;
+}
diff --git a/vere/ext/urcrypt/build.zig.zon b/vere/ext/urcrypt/build.zig.zon
new file mode 100644
index 0000000..0ab2398
--- /dev/null
+++ b/vere/ext/urcrypt/build.zig.zon
@@ -0,0 +1,25 @@
+.{
+    .name = .urcrypt,
+    .fingerprint = 0x590576beb64ce5db,
+    .version = "0.0.1",
+    .dependencies = .{
+        .aes_siv = .{
+            .url = "https://github.com/dfoxfranke/libaes_siv/archive/9681279cfaa6e6399bb7ca3afbbc27fc2e19df4b.tar.gz",
+            .hash = "N-V-__8AADRgAQComAaFJaS9o75BOcaFVew6nO8D7ZTGMRXd",
+        },
+        .openssl = .{
+            .path = "../openssl",
+        },
+        .secp256k1 = .{
+            .url = "https://github.com/bitcoin-core/secp256k1/archive/refs/tags/v0.5.1.tar.gz",
+            .hash = "N-V-__8AAJ4DSwC7aDpt90TmGPWKAI6q4-titwp4M0zsZ2vY",
+        },
+        .urcrypt = .{
+            .url = "https://github.com/urbit/urcrypt/archive/465aad6262f2710f76f75adfe74effb5751c5ab3.tar.gz",
+            .hash = "N-V-__8AAL3OSQDA9xQasK60FkxcKuQoSANeWy_f9SxmxX1X",
+        },
+    },
+    .paths = .{
+        "",
+    },
+}