upgrade to zig 0.16.0

Author: anshalshukla

.gitignore

@@ -22,10 +22,12 @@ Cargo.lock
 
 # Zig specific path
 zig-out/
+zig-pkg/
 .zig-cache/
 
 # OS-specific files
 **.DS_Store
 
 # Misc
 .vscode/
+.tool-versions

build.zig

@@ -11,11 +11,11 @@ fn buildSecp256k1(libsecp_c: *std.Build.Dependency, b: *std.Build, target: std.B
         }),
     });
 
-    lib.addIncludePath(libsecp_c.path(""));
-    lib.addIncludePath(libsecp_c.path("src"));
-    lib.addIncludePath(libsecp_c.path("include"));
+    lib.root_module.addIncludePath(libsecp_c.path(""));
+    lib.root_module.addIncludePath(libsecp_c.path("src"));
+    lib.root_module.addIncludePath(libsecp_c.path("include"));
 
-    lib.addCSourceFiles(.{
+    lib.root_module.addCSourceFiles(.{
         .root = libsecp_c.path(""),
         .flags = &.{
             "-DENABLE_MODULE_RECOVERY=1",
@@ -38,7 +38,7 @@ fn buildSecp256k1(libsecp_c: *std.Build.Dependency, b: *std.Build, target: std.B
 
     lib.installHeadersDirectory(libsecp_c.path("src"), "", .{ .include_extensions = &.{".h"} });
     lib.installHeadersDirectory(libsecp_c.path("include/"), "", .{ .include_extensions = &.{".h"} });
-    lib.linkLibC();
+    lib.root_module.link_libc = true;
 
     return lib;
 }
@@ -82,7 +82,7 @@ pub fn build(b: *std.Build) !void {
             .target = target,
         }),
     });
-    lib_unit_tests.linkLibrary(libsecp256k1);
+    lib_unit_tests.root_module.linkLibrary(libsecp256k1);
     const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
 
     const example_tests = b.addTest(.{
@@ -91,7 +91,7 @@ pub fn build(b: *std.Build) !void {
             .target = target,
         }),
     });
-    example_tests.linkLibrary(libsecp256k1);
+    example_tests.root_module.linkLibrary(libsecp256k1);
     const run_example_test = b.addRunArtifact(example_tests);
 
     // Similar to creating the run step earlier, this exposes a `test` step to

build.zig.zon

@@ -9,11 +9,11 @@
     .name = .secp256k1,
     .fingerprint = 0xed75d6d9e762dcbe,
     .version = "0.0.3",
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .libsecp256k1 = .{
-            .url = "https://github.com/bitcoin-core/secp256k1/archive/refs/tags/v0.5.1.tar.gz",
-            .hash = "1220bb683a6df744e618f58a008eaae3eb62b70a78334cec676bd82b1b9e8e944eeb",
+            .url = "https://github.com/bitcoin-core/secp256k1/archive/refs/tags/v0.7.1.tar.gz",
+            .hash = "N-V-__8AAO1SWwCbwhTAU7t6L3XQtTy6TzE8CiOGHjENn_rl",
         },
     },
     .paths = .{

src/ecdsa/ecdsa.zig

@@ -307,7 +307,7 @@ test "test sign ecdsa with nonce data" {
     // Generate a random private key (this would normally come from a wallet or similar)
     var private_key_data: [32]u8 = undefined;
 
-    std.crypto.random.bytes(&private_key_data);
+    secp.secureRandomBytes(&private_key_data);
 
     const sk = try secp.SecretKey.fromSlice(&private_key_data);
 
@@ -320,7 +320,7 @@ test "test sign ecdsa with nonce data" {
     // Generate a nonce manually for this test
     var nonce_data: [32]u8 = undefined;
 
-    std.crypto.random.bytes(&nonce_data);
+    secp.secureRandomBytes(&nonce_data);
 
     // Sign the message using the private key and nonce
     const signature = s.signEcdsaWithNoncedata(&message, &sk, nonce_data);

src/examples.zig

@@ -2,12 +2,14 @@ const std = @import("std");
 const secp256k1 = @import("./secp256k1.zig");
 
 const Sha256 = std.crypto.hash.sha2.Sha256;
-const rand = std.crypto.random;
 
 test "generateKeypair" {
     const secp = secp256k1.Secp256k1.genNew();
     defer secp.deinit();
 
+    var csprng = secp256k1.defaultCsprng();
+    const rand = csprng.random();
+
     // First option:
     {
         const seckey, const pubkey = secp.generateKeypair(rand);
@@ -25,7 +27,8 @@ test "signAndVerifyEcdsa" {
     const secp = secp256k1.Secp256k1.genNew();
     defer secp.deinit();
 
-    const seckey = secp256k1.SecretKey.generateWithRandom(rand);
+    var csprng = secp256k1.defaultCsprng();
+    const seckey = secp256k1.SecretKey.generateWithRandom(csprng.random());
     const pubkey = secp256k1.PublicKey.fromSecretKey(secp, seckey);
 
     var buf: [32]u8 = undefined;

src/secp256k1.zig

@@ -6,6 +6,26 @@ const schnorr_lib = @import("schnorr.zig");
 
 pub const constants = @import("constants.zig");
 
+pub fn secureRandomBytes(buf: []u8) void {
+    const posix = std.posix;
+    const fd = posix.openatZ(std.c.AT.FDCWD, "/dev/urandom", .{ .ACCMODE = .RDONLY }, 0) catch |e|
+        std.debug.panic("cannot open /dev/urandom: {s}", .{@errorName(e)});
+    defer _ = std.c.close(fd);
+    var off: usize = 0;
+    while (off < buf.len) {
+        const n = posix.read(fd, buf[off..]) catch |e|
+            std.debug.panic("cannot read /dev/urandom: {s}", .{@errorName(e)});
+        if (n == 0) std.debug.panic("unexpected EOF on /dev/urandom", .{});
+        off += n;
+    }
+}
+
+pub fn defaultCsprng() std.Random.DefaultCsprng {
+    var seed: [std.Random.DefaultCsprng.secret_seed_length]u8 = undefined;
+    secureRandomBytes(&seed);
+    return std.Random.DefaultCsprng.init(seed);
+}
+
 /// The main error type for this library.
 pub const Error = error{
     /// Signature failed verification.
@@ -205,7 +225,7 @@ pub const Secp256k1 = struct {
 
         // Create 32 byte random seed.
         var seed: [32]u8 = undefined;
-        crypto.random.bytes(&seed);
+        secureRandomBytes(&seed);
 
         const res = secp256k1.secp256k1_context_randomize(ctx, &seed);
         std.debug.assert(res == 1);
@@ -441,7 +461,7 @@ pub const SecretKey = struct {
         defer secp.deinit();
 
         var aux: [32]u8 = undefined;
-        std.crypto.random.bytes(&aux);
+        secureRandomBytes(&aux);
 
         return secp.signSchnorrHelper(&hash, try KeyPair.fromSecretKey(&secp, self), &aux);
     }
@@ -458,7 +478,8 @@ pub const SecretKey = struct {
 
     /// Generate random [`SecretKey`] with default random
     pub fn generate() SecretKey {
-        return generateWithRandom(std.crypto.random);
+        var csprng = defaultCsprng();
+        return generateWithRandom(csprng.random());
     }
 
     pub fn fromString(data: []const u8) (Error || ErrorParseHex)!@This() {