@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.607

package/std/crypto/blake2.zig

@@ -199,7 +199,9 @@ test "blake2s160 single" {
     try htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
-    try htest.assertEqualHash(Blake2s160, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s160, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s160 streaming" {
@@ -227,27 +229,30 @@ test "blake2s160 streaming" {
 
     const h3 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     h = Blake2s160.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s160.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "4667fd60791a7fe41f939bca646b4529e296bd68";
 
-    h = Blake2s160.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h = Blake2s160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2s160.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32 ++ "b" ** 32);
+    h = Blake2s160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -256,7 +261,7 @@ test "comptime blake2s160" {
     //comptime
     {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s160.block_length;
+        var block: [Blake2s160.block_length]u8 = @splat(0);
         var out: [Blake2s160.digest_length]u8 = undefined;
 
         const h1 = "2c56ad9d0b2c8b474aafa93ab307db2f0940105f";
@@ -282,7 +287,9 @@ test "blake2s224 single" {
     try htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
-    try htest.assertEqualHash(Blake2s224, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s224, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s224 streaming" {
@@ -308,29 +315,32 @@ test "blake2s224 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     const h3 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
 
     h = Blake2s224.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s224.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "a4d6a9d253441b80e5dfd60a04db169ffab77aec56a2855c402828c3";
 
-    h = Blake2s224.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h = Blake2s224.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2s224.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32 ++ "b" ** 32);
+    h = Blake2s224.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -338,7 +348,7 @@ test "blake2s224 streaming" {
 test "comptime blake2s224" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s224.block_length;
+        var block: [Blake2s224.block_length]u8 = @splat(0);
         var out: [Blake2s224.digest_length]u8 = undefined;
 
         const h1 = "86b7611563293f8c73627df7a6d6ba25ca0548c2a6481f7d116ee576";
@@ -364,7 +374,9 @@ test "blake2s256 single" {
     try htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
-    try htest.assertEqualHash(Blake2s256, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s256, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s256 streaming" {
@@ -390,16 +402,19 @@ test "blake2s256 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     const h3 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
 
     h = Blake2s256.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s256.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 }
@@ -410,18 +425,21 @@ test "blake2s256 keyed" {
     const h1 = "10f918da4d74fab3302e48a5d67d03804b1ec95372a62a0f33b7c9fa28ba1ae6";
     const key = "secret_key";
 
-    Blake2s256.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key });
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
+    Blake2s256.hash(&repeat_a_64 ++ &repeat_b_64, &out, .{ .key = key });
     try htest.assertEqual(h1, out[0..]);
 
     var h = Blake2s256.init(.{ .key = key });
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
 
     h = Blake2s256.init(.{ .key = key });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
@@ -430,7 +448,7 @@ test "blake2s256 keyed" {
 test "comptime blake2s256" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s256.block_length;
+        var block: [Blake2s256.block_length]u8 = @splat(0);
         var out: [Blake2s256.digest_length]u8 = undefined;
 
         const h1 = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3";
@@ -623,7 +641,9 @@ test "blake2b160 single" {
     try htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
-    try htest.assertEqualHash(Blake2b160, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b160, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b160 streaming" {
@@ -649,36 +669,39 @@ test "blake2b160 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "72328f8a8200663752fc302d372b5dd9b49dd8dc";
 
-    h = Blake2b160.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2b160.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -686,7 +709,7 @@ test "blake2b160 streaming" {
 test "comptime blake2b160" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2b160.block_length;
+        var block: [Blake2b160.block_length]u8 = @splat(0);
         var out: [Blake2b160.digest_length]u8 = undefined;
 
         const h1 = "8d26f158f564e3293b42f5e3d34263cb173aa9c9";
@@ -712,7 +735,9 @@ test "blake2b384 single" {
     try htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
-    try htest.assertEqualHash(Blake2b384, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b384, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b384 streaming" {
@@ -738,36 +763,39 @@ test "blake2b384 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "934c48fcb197031c71f583d92f98703510805e72142e0b46f5752d1e971bc86c355d556035613ff7a4154b4de09dac5c";
 
-    h = Blake2b384.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b384.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2b384.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b384.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -775,7 +803,7 @@ test "blake2b384 streaming" {
 test "comptime blake2b384" {
     comptime {
         @setEvalBranchQuota(20000);
-        var block = [_]u8{0} ** Blake2b384.block_length;
+        var block: [Blake2b384.block_length]u8 = @splat(0);
         var out: [Blake2b384.digest_length]u8 = undefined;
 
         const h1 = "e8aa1931ea0422e4446fecdd25c16cf35c240b10cb4659dd5c776eddcaa4d922397a589404b46eb2e53d78132d05fd7d";
@@ -801,7 +829,9 @@ test "blake2b512 single" {
     try htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
-    try htest.assertEqualHash(Blake2b512, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b512, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b512 streaming" {
@@ -827,16 +857,19 @@ test "blake2b512 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
 
     h = Blake2b512.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b512.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 }
@@ -847,18 +880,21 @@ test "blake2b512 keyed" {
     const h1 = "8a978060ccaf582f388f37454363071ac9a67e3a704585fd879fb8a419a447e389c7c6de790faa20a7a7dccf197de736bc5b40b98a930b36df5bee7555750c4d";
     const key = "secret_key";
 
-    Blake2b512.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key });
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
+    Blake2b512.hash(&repeat_a_64 ++ &repeat_b_64, &out, .{ .key = key });
     try htest.assertEqual(h1, out[0..]);
 
     var h = Blake2b512.init(.{ .key = key });
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
 
     h = Blake2b512.init(.{ .key = key });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
@@ -867,7 +903,7 @@ test "blake2b512 keyed" {
 test "comptime blake2b512" {
     comptime {
         @setEvalBranchQuota(12000);
-        var block = [_]u8{0} ** Blake2b512.block_length;
+        var block: [Blake2b512.block_length]u8 = @splat(0);
         var out: [Blake2b512.digest_length]u8 = undefined;
 
         const h1 = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf798e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41";

package/std/crypto/cbc_mac.zig

@@ -21,7 +21,7 @@ pub fn CbcMac(comptime BlockCipher: type) type {
         pub const mac_length = block_length;
 
         cipher_ctx: BlockCipherCtx,
-        buf: Block = [_]u8{0} ** block_length,
+        buf: Block = @splat(0),
         pos: usize = 0,
 
         pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {

package/std/crypto/chacha20.zig

@@ -648,7 +648,7 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
             assert(c.len == m.len);
             assert(m.len <= 64 * (@as(u39, 1 << 32) - 1));
 
-            var polyKey = [_]u8{0} ** 32;
+            var polyKey: [32]u8 = @splat(0);
             ChaChaIETF(rounds_nb).xor(polyKey[0..], polyKey[0..], 0, k, npub);
 
             ChaChaIETF(rounds_nb).xor(c[0..m.len], m, 1, k, npub);
@@ -656,13 +656,13 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
             var mac = Poly1305.init(polyKey[0..]);
             mac.update(ad);
             if (ad.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (ad.len % 16);
                 mac.update(zeros[0..padding]);
             }
             mac.update(c[0..m.len]);
             if (m.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (m.len % 16);
                 mac.update(zeros[0..padding]);
             }
@@ -685,20 +685,20 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
         pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, k: [key_length]u8) AuthenticationError!void {
             assert(c.len == m.len);
 
-            var polyKey = [_]u8{0} ** 32;
+            var polyKey: [32]u8 = @splat(0);
             ChaChaIETF(rounds_nb).xor(polyKey[0..], polyKey[0..], 0, k, npub);
 
             var mac = Poly1305.init(polyKey[0..]);
 
             mac.update(ad);
             if (ad.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (ad.len % 16);
                 mac.update(zeros[0..padding]);
             }
             mac.update(c);
             if (c.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (c.len % 16);
                 mac.update(zeros[0..padding]);
             }
@@ -759,8 +759,8 @@ test "AEAD API" {
     const ad = "Additional data";
 
     inline for (aeads) |aead| {
-        const key = [_]u8{69} ** aead.key_length;
-        const nonce = [_]u8{42} ** aead.nonce_length;
+        const key: [aead.key_length]u8 = @splat(69);
+        const nonce: [aead.nonce_length]u8 = @splat(42);
         var c: [m.len]u8 = undefined;
         var tag: [aead.tag_length]u8 = undefined;
         var out: [m.len]u8 = undefined;
@@ -1138,8 +1138,8 @@ test "open" {
 }
 
 test "xchacha20" {
-    const key = [_]u8{69} ** 32;
-    const nonce = [_]u8{42} ** 24;
+    const key: [32]u8 = @splat(69);
+    const nonce: [24]u8 = @splat(42);
     const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
     {
         var c: [m.len]u8 = undefined;

package/std/crypto/cmac.zig

@@ -20,7 +20,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
         cipher_ctx: BlockCipherCtx,
         k1: Block,
         k2: Block,
-        buf: Block = [_]u8{0} ** block_length,
+        buf: Block = @splat(0),
         pos: usize = 0,
 
         pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {
@@ -31,7 +31,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
 
         pub fn init(key: *const [key_length]u8) Self {
             const cipher_ctx = BlockCipher.initEnc(key.*);
-            const zeros = [_]u8{0} ** block_length;
+            const zeros: [block_length]u8 = @splat(0);
             var k1: Block = undefined;
             cipher_ctx.encrypt(&k1, &zeros);
             k1 = double(k1);
@@ -74,7 +74,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
         }
 
         fn double(l: Block) Block {
-            const Int = std.meta.Int(.unsigned, block_length * 8);
+            const Int = @Int(.unsigned, block_length * 8);
             const l_ = mem.readInt(Int, &l, .big);
             const l_2 = switch (block_length) {
                 8 => (l_ << 1) ^ (0x1b & -%(l_ >> 63)), // mod x^64 + x^4 + x^3 + x + 1

package/std/crypto/codecs/asn1/Oid.zig

@@ -85,6 +85,14 @@ test toDot {
     }
 }
 
+test "malformed OID" {
+    var empty: der.Decoder = .{ .bytes = &.{ 0x06, 0x00 } };
+    try std.testing.expectError(error.EndOfStream, decodeDer(&empty));
+
+    var truncated: der.Decoder = .{ .bytes = &.{ 0x06, 0x02, 0x2a, 0x80 } };
+    try std.testing.expectError(error.InvalidEncoding, decodeDer(&truncated));
+}
+
 const TestCase = struct {
     encoded: []const u8,
     dot_notation: []const u8,
@@ -109,7 +117,10 @@ pub const asn1_tag = asn1.Tag.init(.oid, false, .universal);
 
 pub fn decodeDer(decoder: *der.Decoder) !Oid {
     const ele = try decoder.element(asn1_tag.toExpected());
-    return Oid{ .encoded = decoder.view(ele) };
+    const encoded = decoder.view(ele);
+    if (encoded.len == 0) return error.EndOfStream;
+    if (encoded[encoded.len - 1] & 0x80 != 0) return error.InvalidEncoding;
+    return Oid{ .encoded = encoded };
 }
 
 pub fn encodeDer(self: Oid, encoder: *der.Encoder) !void {

package/std/crypto/codecs/asn1/der/Encoder.zig

@@ -129,7 +129,7 @@ fn int(self: *Encoder, comptime T: type, value: T) !void {
     const needs_padding: u1 = if (value == 0)
         1
     else if (bits_needed > 8) brk: {
-        const RightShift = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
+        const RightShift = @Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
         const right_shift: RightShift = @intCast(bits_needed - 9);
         break :brk if (value >> right_shift == 0x1ff) 1 else 0;
     } else 0;

package/std/crypto/codecs/asn1.zig

@@ -233,7 +233,7 @@ test Element {
         .slice = Element.Slice{ .start = 2, .end = short_form.len },
     }, Element.decode(&short_form, 0));
 
-    const long_form = [_]u8{ 0x30, 129, 129 } ++ [_]u8{0} ** 129;
+    const long_form = [_]u8{ 0x30, 129, 129 } ++ @as([129]u8, @splat(0));
     try std.testing.expectEqual(Element{
         .tag = Tag.universal(.sequence, true),
         .slice = Element.Slice{ .start = 3, .end = long_form.len },

package/std/crypto/codecs/base64_hex_ct.zig

@@ -3,7 +3,7 @@
 //! This is designed to be used in cryptographic applications where timing attacks are a concern.
 const std = @import("std");
 const testing = std.testing;
-const StaticBitSet = std.StaticBitSet;
+const StaticBitSet = std.bit_set.Static;
 
 pub const Error = error{
     /// An invalid character was found in the input.
@@ -47,8 +47,7 @@ pub const hex = struct {
         }
         _ = decodeAny(bin, encoded, null) catch |err| {
             switch (err) {
-                error.InvalidCharacter => return error.InvalidCharacter,
-                error.InvalidPadding => return error.InvalidPadding,
+                error.InvalidCharacter, error.InvalidPadding => |e| return e,
                 else => unreachable,
             }
         };
@@ -228,8 +227,7 @@ pub const base64 = struct {
     pub fn decode(bin: []u8, encoded: []const u8, comptime variant: Variant) error{ InvalidCharacter, InvalidPadding }![]const u8 {
         return decodeAny(bin, encoded, variant, null) catch |err| {
             switch (err) {
-                error.InvalidCharacter => return error.InvalidCharacter,
-                error.InvalidPadding => return error.InvalidPadding,
+                error.InvalidCharacter, error.InvalidPadding => |e| return e,
                 else => unreachable,
             }
         };

package/std/crypto/ecdsa.zig

@@ -212,7 +212,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn finalizePrehashed(self: *Signer, msg_hash: [Hash.digest_length]u8) (IdentityElementError || NonCanonicalError)!Signature {
                 const scalar_encoded_length = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, scalar_encoded_length);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 std.debug.assert(h.len >= scalar_encoded_length);
                 const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
@@ -275,7 +275,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn verifyPrehashed(self: *Verifier, msg_hash: [Hash.digest_length]u8) VerifyError!void {
                 const ht = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, ht);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 const z = reduceToScalar(ht, h[0..ht].*);
                 if (z.isZero()) {
@@ -316,8 +316,8 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             ///
             /// Except in tests, applications should generally call `generate()` instead of this function.
             pub fn generateDeterministic(seed: [seed_length]u8) IdentityElementError!KeyPair {
-                const h = [_]u8{0x00} ** Hash.digest_length;
-                const k0 = [_]u8{0x01} ** SecretKey.encoded_length;
+                const h: [Hash.digest_length]u8 = @splat(0x00);
+                const k0: [SecretKey.encoded_length]u8 = @splat(0x01);
                 const secret_key = deterministicScalar(h, k0, seed).toBytes(.big);
                 return fromSecretKey(SecretKey{ .bytes = secret_key });
             }
@@ -367,11 +367,11 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Reduce the coordinate of a field element to the scalar field.
         fn reduceToScalar(comptime unreduced_len: usize, s: [unreduced_len]u8) Curve.scalar.Scalar {
             if (unreduced_len >= 48) {
-                var xs = [_]u8{0} ** 64;
+                var xs: [64]u8 = @splat(0);
                 @memcpy(xs[xs.len - s.len ..], s[0..]);
                 return Curve.scalar.Scalar.fromBytes64(xs, .big);
             }
-            var xs = [_]u8{0} ** 48;
+            var xs: [48]u8 = @splat(0);
             @memcpy(xs[xs.len - s.len ..], s[0..]);
             return Curve.scalar.Scalar.fromBytes48(xs, .big);
         }
@@ -379,9 +379,9 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Create a deterministic scalar according to a secret key and optional noise.
         // This uses the overly conservative scheme from the "Deterministic ECDSA and EdDSA Signatures with Additional Randomness" draft.
         fn deterministicScalar(h: [Hash.digest_length]u8, secret_key: Curve.scalar.CompressedScalar, noise: ?[noise_length]u8) Curve.scalar.Scalar {
-            var k = [_]u8{0x00} ** h.len;
-            var m = [_]u8{0x00} ** (h.len + 1 + noise_length + secret_key.len + h.len);
-            var t = [_]u8{0x00} ** Curve.scalar.encoded_length;
+            var k: [h.len]u8 = @splat(0);
+            var m: [h.len + 1 + noise_length + secret_key.len + h.len]u8 = @splat(0);
+            var t: [Curve.scalar.encoded_length]u8 = @splat(0);
             const m_v = m[0..h.len];
             const m_i = &m[m_v.len];
             const m_z = m[m_v.len + 1 ..][0..noise_length];