@zigc/lib 0.17.0-dev.228 → 0.17.0-dev.242

package/std/crypto/bcrypt.zig

@@ -868,20 +868,25 @@ test "bcrypt crypt format" {
         strVerify(s, "invalid password", verify_options),
     );
 
+    const password_100: []const u8 = password: {
+        const arr: [100][8]u8 = @splat("password".*);
+        break :password @ptrCast(&arr);
+    };
+
     var long_buf: [hash_length]u8 = undefined;
-    var long_s = try strHash("password" ** 100, hash_options, &long_buf, io);
+    var long_s = try strHash(password_100, hash_options, &long_buf, io);
 
     try testing.expect(mem.startsWith(u8, long_s, crypt_format.prefix));
-    try strVerify(long_s, "password" ** 100, verify_options);
+    try strVerify(long_s, password_100, verify_options);
     try testing.expectError(
         error.PasswordVerificationFailed,
-        strVerify(long_s, "password" ** 101, verify_options),
+        strVerify(long_s, password_100 ++ "password", verify_options),
     );
 
     hash_options.params.silently_truncate_password = true;
     verify_options.silently_truncate_password = true;
-    long_s = try strHash("password" ** 100, hash_options, &long_buf, io);
-    try strVerify(long_s, "password" ** 101, verify_options);
+    long_s = try strHash(password_100, hash_options, &long_buf, io);
+    try strVerify(long_s, password_100 ++ "password", verify_options);
 
     try strVerify(
         "$2b$08$WUQKyBCaKpziCwUXHiMVvu40dYVjkTxtWJlftl0PpjY2BxWSvFIEe",
@@ -909,20 +914,25 @@ test "bcrypt phc format" {
         strVerify(s, "invalid password", verify_options),
     );
 
+    const password_100: []const u8 = password: {
+        const arr: [100][8]u8 = @splat("password".*);
+        break :password @ptrCast(&arr);
+    };
+
     var long_buf: [hash_length * 2]u8 = undefined;
-    var long_s = try strHash("password" ** 100, hash_options, &long_buf, io);
+    var long_s = try strHash(password_100, hash_options, &long_buf, io);
 
     try testing.expect(mem.startsWith(u8, long_s, prefix));
-    try strVerify(long_s, "password" ** 100, verify_options);
+    try strVerify(long_s, password_100, verify_options);
     try testing.expectError(
         error.PasswordVerificationFailed,
-        strVerify(long_s, "password" ** 101, verify_options),
+        strVerify(long_s, password_100 ++ "password", verify_options),
     );
 
     hash_options.params.silently_truncate_password = true;
     verify_options.silently_truncate_password = true;
-    long_s = try strHash("password" ** 100, hash_options, &long_buf, io);
-    try strVerify(long_s, "password" ** 101, verify_options);
+    long_s = try strHash(password_100, hash_options, &long_buf, io);
+    try strVerify(long_s, password_100 ++ "password", verify_options);
 
     try strVerify(
         "$bcrypt$r=5$2NopntlgE2lX3cTwr4qz8A$r3T7iKYQNnY4hAhGjk9RmuyvgrYJZwc",

package/std/crypto/benchmark.zig

@@ -173,7 +173,7 @@ const signatures = [_]Crypto{
 };
 
 pub fn benchmarkSignature(comptime Signature: anytype, comptime signatures_count: comptime_int, io: std.Io) !u64 {
-    const msg = [_]u8{0} ** 64;
+    const msg: [64]u8 = @splat(0);
     const key_pair = Signature.KeyPair.generate(io);
 
     const start = benchTime(io);
@@ -200,7 +200,7 @@ const signature_verifications = [_]Crypto{
 };
 
 pub fn benchmarkSignatureVerification(comptime Signature: anytype, comptime signatures_count: comptime_int, io: std.Io) !u64 {
-    const msg = [_]u8{0} ** 64;
+    const msg: [64]u8 = @splat(0);
     const key_pair = Signature.KeyPair.generate(io);
     const sig = try key_pair.sign(&msg, null);
 
@@ -223,7 +223,7 @@ pub fn benchmarkSignatureVerification(comptime Signature: anytype, comptime sign
 const batch_signature_verifications = [_]Crypto{Crypto{ .ty = crypto.sign.Ed25519, .name = "ed25519" }};
 
 pub fn benchmarkBatchSignatureVerification(comptime Signature: anytype, comptime signatures_count: comptime_int, io: std.Io) !u64 {
-    const msg = [_]u8{0} ** 64;
+    const msg: [64]u8 = @splat(0);
     const key_pair = Signature.KeyPair.generate(io);
     const sig = try key_pair.sign(&msg, null);
 
@@ -367,7 +367,7 @@ pub fn benchmarkAes(comptime Aes: anytype, comptime count: comptime_int, io: Io)
     random.bytes(key[0..]);
     const ctx = Aes.initEnc(key);
 
-    var in = [_]u8{0} ** 16;
+    var in: [16]u8 = @splat(0);
 
     const start = benchTime(io);
     {
@@ -395,7 +395,7 @@ pub fn benchmarkAes8(comptime Aes: anytype, comptime count: comptime_int, io: Io
     random.bytes(key[0..]);
     const ctx = Aes.initEnc(key);
 
-    var in = [_]u8{0} ** (8 * 16);
+    var in: [8 * 16]u8 = @splat(0);
 
     const start = benchTime(io);
     {
@@ -444,7 +444,7 @@ fn benchmarkPwhash(
     comptime count: comptime_int,
     io: std.Io,
 ) !f64 {
-    const password = "testpass" ** 2;
+    const password = "testpasstestpass";
     const opts = ty.HashOptions{
         .allocator = allocator,
         .params = @as(*const ty.Params, @ptrCast(@alignCast(params))).*,
@@ -456,7 +456,7 @@ fn benchmarkPwhash(
     const strHashFnInfo = @typeInfo(@TypeOf(strHash)).@"fn";
     const needs_io = strHashFnInfo.params.len == 4 and strHashFnInfo.params[3].type == std.Io;
     const needs_salt = strHashFnInfo.params.len == 4 and strHashFnInfo.params[3].type != std.Io;
-    const salt: [16]u8 = .{0} ** 16;
+    const salt: [16]u8 = @splat(0);
 
     const start = benchTime(io);
     {

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);

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 },