@zigc/lib 0.16.0 → 0.17.0-dev.131

package/std/array_hash_map.zig

@@ -280,8 +280,7 @@ pub fn Custom(
                 if (it.index >= it.len) return null;
                 const result = Entry{
                     .key_ptr = &it.keys[it.index],
-                    // workaround for #6974
-                    .value_ptr = if (@sizeOf(*V) == 0) undefined else &it.values[it.index],
+                    .value_ptr = &it.values[it.index],
                 };
                 it.index += 1;
                 return result;
@@ -323,8 +322,7 @@ pub fn Custom(
                 const slice = self.entries.slice();
                 return GetOrPutResult{
                     .key_ptr = &slice.items(.key)[index],
-                    // workaround for #6974
-                    .value_ptr = if (@sizeOf(*V) == 0) undefined else &slice.items(.value)[index],
+                    .value_ptr = &slice.items(.value)[index],
                     .found_existing = true,
                     .index = index,
                 };
@@ -369,8 +367,7 @@ pub fn Custom(
                     if (hashes_array[i] == h and checkedEql(ctx, key, item_key.*, i)) {
                         return GetOrPutResult{
                             .key_ptr = item_key,
-                            // workaround for #6974
-                            .value_ptr = if (@sizeOf(*V) == 0) undefined else &slice.items(.value)[i],
+                            .value_ptr = &slice.items(.value)[i],
                             .found_existing = true,
                             .index = i,
                         };
@@ -383,8 +380,7 @@ pub fn Custom(
 
                 return GetOrPutResult{
                     .key_ptr = &keys_array.ptr[index],
-                    // workaround for #6974
-                    .value_ptr = if (@sizeOf(*V) == 0) undefined else &slice.items(.value).ptr[index],
+                    .value_ptr = &slice.items(.value).ptr[index],
                     .found_existing = false,
                     .index = index,
                 };
@@ -569,8 +565,7 @@ pub fn Custom(
             const slice = self.entries.slice();
             return Entry{
                 .key_ptr = &slice.items(.key)[index],
-                // workaround for #6974
-                .value_ptr = if (@sizeOf(*V) == 0) undefined else &slice.items(.value)[index],
+                .value_ptr = &slice.items(.value)[index],
             };
         }
 
@@ -634,8 +629,7 @@ pub fn Custom(
         }
         pub fn getPtrAdapted(self: Self, key: anytype, ctx: anytype) ?*V {
             const index = self.getIndexAdapted(key, ctx) orelse return null;
-            // workaround for #6974
-            return if (@sizeOf(*V) == 0) @as(*V, undefined) else &self.values()[index];
+            return &self.values()[index];
         }
 
         /// Find the actual key associated with an adapted key
@@ -1314,8 +1308,7 @@ pub fn Custom(
                     return .{
                         .found_existing = false,
                         .key_ptr = &keys_array.ptr[new_index],
-                        // workaround for #6974
-                        .value_ptr = if (@sizeOf(*V) == 0) undefined else &values_array.ptr[new_index],
+                        .value_ptr = &values_array.ptr[new_index],
                         .index = new_index,
                     };
                 }
@@ -1328,8 +1321,7 @@ pub fn Custom(
                     return .{
                         .found_existing = true,
                         .key_ptr = &keys_array[slot_data.entry_index],
-                        // workaround for #6974
-                        .value_ptr = if (@sizeOf(*V) == 0) undefined else &values_array[slot_data.entry_index],
+                        .value_ptr = &values_array[slot_data.entry_index],
                         .index = slot_data.entry_index,
                     };
                 }
@@ -1370,8 +1362,7 @@ pub fn Custom(
                             return .{
                                 .found_existing = false,
                                 .key_ptr = &keys_array.ptr[new_index],
-                                // workaround for #6974
-                                .value_ptr = if (@sizeOf(*V) == 0) undefined else &values_array.ptr[new_index],
+                                .value_ptr = &values_array.ptr[new_index],
                                 .index = new_index,
                             };
                         }

package/std/builtin.zig

@@ -341,6 +341,10 @@ pub const CallingConvention = union(enum(u8)) {
     spirv_fragment,
     spirv_vertex,
 
+    // Calling conventions for the `ez80` architecture.
+    ez80_cet,
+    ez80_tiflags,
+
     /// Options shared across most calling conventions.
     pub const CommonOptions = struct {
         /// The boundary the stack is aligned to when the function is called.

package/std/c/haiku.zig

@@ -6,6 +6,7 @@ const iovec = std.posix.iovec;
 const iovec_const = std.posix.iovec_const;
 const socklen_t = std.c.socklen_t;
 const fd_t = std.c.fd_t;
+const off_t = std.c.off_t;
 const PATH_MAX = std.c.PATH_MAX;
 const uid_t = std.c.uid_t;
 const gid_t = std.c.gid_t;
@@ -28,6 +29,8 @@ pub extern "root" fn _kern_open_dir(fd: fd_t, path: [*:0]const u8) fd_t;
 pub extern "root" fn _kern_read_dir(fd: fd_t, buffer: [*]u8, bufferSize: usize, maxCount: u32) isize;
 pub extern "root" fn _kern_rewind_dir(fd: fd_t) status_t;
 pub extern "root" fn _kern_read_stat(fd: fd_t, path: [*:0]const u8, traverseLink: bool, stat: *std.c.Stat, statSize: usize) status_t;
+pub extern "root" fn readv_pos(fd: fd_t, pos: off_t, vec: [*]const std.c.iovec, count: i32) isize;
+pub extern "root" fn writev_pos(fd: fd_t, pos: off_t, vec: [*]const std.c.iovec_const, count: i32) isize;
 
 pub const area_info = extern struct {
     area: u32,

package/std/c/serenity.zig

@@ -53,9 +53,7 @@ pub extern "c" fn profiling_enable(pid: pid_t, event_mask: PERF_EVENT) c_int;
 pub extern "c" fn profiling_disable(pid: pid_t) c_int;
 pub extern "c" fn profiling_free_buffer(pid: pid_t) c_int;
 
-pub extern "c" fn futex(userspace_address: *u32, futex_op: c_int, value: u32, timeout: *const timespec, userspace_address2: *u32, value3: u32) c_int;
-pub extern "c" fn futex_wait(userspace_address: *u32, value: u32, abstime: *const timespec, clockid: clockid_t, process_shared: c_int) c_int;
-pub extern "c" fn futex_wake(userspace_address: *u32, count: u32, process_shared: c_int) c_int;
+pub extern "c" fn futex(userspace_address: *u32, futex_op: c_int, value: u32, timeout: ?*const timespec, userspace_address2: ?*u32, value3: u32) c_int;
 
 pub extern "c" fn purge(mode: c_int) c_int;
 
@@ -66,9 +64,6 @@ pub extern "c" fn get_stack_bounds(user_stack_base: *usize, user_stack_size: *us
 
 pub extern "c" fn anon_create(size: usize, options: O) c_int;
 
-pub extern "c" fn serenity_readlink(path: [*]const u8, path_length: usize, buffer: [*]u8, buffer_size: usize) c_int;
-pub extern "c" fn serenity_open(path: [*]const u8, path_length: usize, options: c_int, ...) c_int;
-
 pub extern "c" fn getkeymap(name_buffer: [*]u8, name_buffer_size: usize, map: [*]u32, shift_map: [*]u32, alt_map: [*]u32, altgr_map: [*]u32, shift_altgr_map: [*]u32) c_int;
 pub extern "c" fn setkeymap(name: [*]const u8, map: [*]const u32, shift_map: [*]const u32, alt_map: [*]const u32, altgr_map: [*]const u32, shift_altgr_map: [*]const u32) c_int;
 

package/std/c.zig

@@ -3260,8 +3260,8 @@ pub const Sigaction = switch (native_os) {
 
         /// signal handler
         handler: extern union {
-            handler: handler_fn,
-            sigaction: sigaction_fn,
+            handler: ?handler_fn,
+            sigaction: ?sigaction_fn,
         },
 
         /// signal mask to apply
@@ -7898,6 +7898,20 @@ pub const Stat = switch (native_os) {
     else => void,
 };
 
+pub const pthread_spinlock_t = switch (native_os) {
+    .openbsd => openbsd.pthread_spinlock_t,
+    .freebsd => extern struct {
+        inner: ?*anyopaque = null,
+    },
+    .netbsd => extern struct {
+        pts_magic: c_uint,
+        spin: pthread_spin_t,
+        pts_flags: c_int,
+    },
+    .windows => isize,
+    else => c_int,
+};
+
 pub const pthread_mutex_t = switch (native_os) {
     .linux => extern struct {
         data: [data_len]u8 align(@alignOf(usize)) = [_]u8{0} ** data_len,
@@ -10956,6 +10970,19 @@ pub extern "c" fn dn_expand(
     length: c_int,
 ) c_int;
 
+pub const PTHREAD_PROCESS_PRIVATE: c_int = if (native_os.isDarwin())
+    2
+else
+    0;
+
+pub const PTHREAD_PROCESS_SHARED: c_int = 1;
+
+pub extern "c" fn pthread_spin_init(spin: *pthread_spinlock_t, pshared: c_int) c_int;
+pub extern "c" fn pthread_spin_lock(spin: *pthread_spinlock_t) c_int;
+pub extern "c" fn pthread_spin_unlock(spin: *pthread_spinlock_t) c_int;
+pub extern "c" fn pthread_spin_trylock(spin: *pthread_spinlock_t) c_int;
+pub extern "c" fn pthread_spin_destroy(spin: *pthread_spinlock_t) c_int;
+
 pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = .{};
 pub extern "c" fn pthread_mutex_lock(mutex: *pthread_mutex_t) E;
 pub extern "c" fn pthread_mutex_unlock(mutex: *pthread_mutex_t) E;
@@ -11102,6 +11129,64 @@ pub const ioctl = switch (native_os) {
     else => private.ioctl,
 };
 
+pub extern "c" fn bzero(s: *anyopaque, n: usize) void;
+
+pub extern "c" fn swab(noalias from: *const anyopaque, noalias to: *anyopaque, n: isize) void;
+
+pub extern "c" fn strncmp(a: [*:0]const c_char, b: [*:0]const c_char, max: usize) c_int;
+pub extern "c" fn strcasecmp(a: [*:0]const c_char, b: [*:0]const c_char) c_int;
+pub extern "c" fn strncasecmp(a: [*:0]const c_char, b: [*:0]const c_char, max: usize) c_int;
+pub extern "c" fn strdup(s: [*:0]const c_char) ?[*:0]c_char;
+pub extern "c" fn strndup(s: [*:0]const c_char, n: usize) ?[*:0]c_char;
+pub extern "c" fn wcsdup(s: [*:0]const wchar_t) ?[*:0]wchar_t;
+
+pub extern "c" fn ffs(i: c_int) c_int;
+pub extern "c" fn ffsl(i: c_long) c_long;
+pub extern "c" fn ffsll(i: c_longlong) c_longlong;
+
+pub extern "c" fn erand48(xsubi: *[3]c_ushort) f64;
+pub extern "c" fn jrand48(xsubi: *[3]c_ushort) c_long;
+pub extern "c" fn nrand48(xsubi: *[3]c_ushort) c_long;
+
+pub extern "c" fn insque(element: *anyopaque, pred: ?*anyopaque) void;
+pub extern "c" fn remque(element: *anyopaque) void;
+
+pub extern "c" fn imaxabs(a: intmax_t) intmax_t;
+pub extern "c" fn imaxdiv(a: intmax_t, b: intmax_t) imaxdiv_t;
+
+pub extern "c" fn abs(a: c_int) c_int;
+pub extern "c" fn labs(a: c_long) c_long;
+pub extern "c" fn llabs(a: c_longlong) c_longlong;
+
+pub extern "c" fn div(a: c_int, b: c_int) div_t;
+pub extern "c" fn ldiv(a: c_long, b: c_long) ldiv_t;
+pub extern "c" fn lldiv(a: c_longlong, b: c_longlong) lldiv_t;
+
+pub extern "c" fn atoi(str: [*:0]const c_char) c_int;
+pub extern "c" fn atol(str: [*:0]const c_char) c_long;
+pub extern "c" fn atoll(str: [*:0]const c_char) c_longlong;
+
+pub extern "c" fn bsearch(
+    key: *const anyopaque,
+    base: *const anyopaque,
+    n: usize,
+    size: usize,
+    compare: *const fn (a: *const anyopaque, b: *const anyopaque) callconv(.c) c_int,
+) ?*anyopaque;
+
+// Math
+pub extern "c" fn atan(x: f64) f64;
+pub extern "c" fn copysign(x: f64, y: f64) f64;
+pub extern "c" fn fdim(x: f64, y: f64) f64;
+pub extern "c" fn frexp(x: f64, e: *c_int) f64;
+pub extern "c" fn hypot(x: f64, y: f64) f64;
+pub extern "c" fn modff(x: f32, iptr: *f32) f32;
+pub extern "c" fn modf(x: f64, iptr: *f64) f64;
+pub extern "c" fn modfl(x: c_longdouble, iptr: *c_longdouble) c_longdouble;
+pub extern "c" fn rintf(x: f32) f32;
+pub extern "c" fn rint(x: f64) f64;
+pub extern "c" fn rintl(x: c_longdouble) c_longdouble;
+
 // OS-specific bits. These are protected from being used on the wrong OS by
 // comptime assertions inside each OS-specific file.
 
@@ -11142,6 +11227,8 @@ pub const _kern_open_dir = haiku._kern_open_dir;
 pub const _kern_read_dir = haiku._kern_read_dir;
 pub const _kern_read_stat = haiku._kern_read_stat;
 pub const _kern_rewind_dir = haiku._kern_rewind_dir;
+pub const readv_pos = haiku.readv_pos;
+pub const writev_pos = haiku.writev_pos;
 pub const area_id = haiku.area_id;
 pub const area_info = haiku.area_info;
 pub const directory_which = haiku.directory_which;
@@ -11211,7 +11298,6 @@ pub const login_getcaptime = openbsd.login_getcaptime;
 pub const login_getclass = openbsd.login_getclass;
 pub const login_getstyle = openbsd.login_getstyle;
 pub const pledge = openbsd.pledge;
-pub const pthread_spinlock_t = openbsd.pthread_spinlock_t;
 pub const pw_dup = openbsd.pw_dup;
 pub const setclasscontext = openbsd.setclasscontext;
 pub const setpassent = openbsd.setpassent;
@@ -11449,15 +11535,11 @@ pub const disown = serenity.disown;
 pub const profiling_enable = serenity.profiling_enable;
 pub const profiling_disable = serenity.profiling_disable;
 pub const profiling_free_buffer = serenity.profiling_free_buffer;
-pub const futex_wait = serenity.futex_wait;
-pub const futex_wake = serenity.futex_wake;
 pub const purge = serenity.purge;
 pub const perf_event = serenity.perf_event;
 pub const perf_register_string = serenity.perf_register_string;
 pub const get_stack_bounds = serenity.get_stack_bounds;
 pub const anon_create = serenity.anon_create;
-pub const serenity_readlink = serenity.serenity_readlink;
-pub const serenity_open = serenity.serenity_open;
 pub const getkeymap = serenity.getkeymap;
 pub const setkeymap = serenity.setkeymap;
 

package/std/compress/flate/Decompress.zig

@@ -129,8 +129,7 @@ fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize {
     }
     const n = r.stream(&writer, limit) catch |err| switch (err) {
         error.WriteFailed => unreachable,
-        error.ReadFailed => return error.ReadFailed,
-        error.EndOfStream => return error.EndOfStream,
+        error.ReadFailed, error.EndOfStream => |e| return e,
     };
     assert(n <= @intFromEnum(limit));
     return n;
@@ -258,7 +257,7 @@ fn streamFallible(d: *Decompress, w: *Writer, limit: std.Io.Limit) Reader.Stream
                 return error.ReadFailed;
             }
         },
-        error.WriteFailed => return error.WriteFailed,
+        error.WriteFailed => |e| return e,
         else => |e| {
             // In the event of an error, state is unmodified so that it can be
             // better used to diagnose the failure.

package/std/compress/zstd/Decompress.zig

@@ -173,8 +173,7 @@ fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize {
     }
     const n = r.stream(&writer, limit) catch |err| switch (err) {
         error.WriteFailed => unreachable,
-        error.ReadFailed => return error.ReadFailed,
-        error.EndOfStream => return error.EndOfStream,
+        error.ReadFailed, error.EndOfStream => |e| return e,
     };
     assert(n <= @intFromEnum(limit));
     return n;
@@ -252,8 +251,7 @@ fn stream(d: *Decompress, w: *Writer, limit: Limit) Reader.StreamError!usize {
         },
         .in_frame => |*in_frame| {
             return readInFrame(d, w, limit, in_frame) catch |err| switch (err) {
-                error.ReadFailed => return error.ReadFailed,
-                error.WriteFailed => return error.WriteFailed,
+                error.ReadFailed, error.WriteFailed => |e| return e,
                 else => |e| {
                     d.err = e;
                     return error.ReadFailed;

package/std/crypto/Certificate.zig

@@ -580,7 +580,10 @@ pub fn parseTime(cert: Certificate, elem: der.Element) ParseTimeError!u64 {
                 return error.CertificateTimeInvalid;
 
             return Date.toSeconds(.{
-                .year = @as(u16, 2000) + try parseTimeDigits(bytes[0..2], 0, 99),
+                .year = blk: {
+                    const year = try parseTimeDigits(bytes[0..2], 0, 99);
+                    break :blk if (year < 50) @as(u16, 2000) + year else @as(u16, 1900) + year;
+                },
                 .month = try parseTimeDigits(bytes[2..4], 1, 12),
                 .day = try parseTimeDigits(bytes[4..6], 1, 31),
                 .hour = try parseTimeDigits(bytes[6..8], 0, 23),
@@ -670,6 +673,15 @@ pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8 {
     return @intCast(result);
 }
 
+test "parseTime UTCTime year mapping per RFC 5280" {
+    const utc_time_id: der.Identifier = .{ .tag = .utc_time, .pc = .primitive, .class = .universal };
+    const elem = der.Element{ .identifier = utc_time_id, .slice = .{ .start = 0, .end = 13 } };
+    const cert49 = Certificate{ .buffer = "490101000000Z", .index = 0 };
+    try std.testing.expectEqual(@as(u64, 2493072000), try cert49.parseTime(elem));
+    const cert99 = Certificate{ .buffer = "990101000000Z", .index = 0 };
+    try std.testing.expectEqual(@as(u64, 915148800), try cert99.parseTime(elem));
+}
+
 test parseTimeDigits {
     const expectEqual = std.testing.expectEqual;
     try expectEqual(@as(u8, 0), try parseTimeDigits("00", 0, 99));

package/std/crypto/ascon.zig

@@ -681,6 +681,8 @@ pub const AsconXof128 = struct {
 
     st: AsconState,
     squeezed: bool,
+    buf: [block_length]u8,
+    buf_len: usize,
 
     pub const Options = struct {};
 
@@ -698,7 +700,7 @@ pub const AsconXof128 = struct {
         const words: [5]u64 = .{ iv, 0, 0, 0, 0 };
         var st = AsconState.initFromWords(words);
         st.permuteR(12);
-        return AsconXof128{ .st = st, .squeezed = false };
+        return AsconXof128{ .st = st, .squeezed = false, .buf = @splat(0), .buf_len = 0 };
     }
 
     /// Hash a slice of bytes with variable-length output.
@@ -726,24 +728,26 @@ pub const AsconXof128 = struct {
 
         var i: usize = 0;
 
-        // Process full 64-bit blocks
-        while (i + 8 <= b.len) : (i += 8) {
-            self.st.addBytes(b[i..][0..8]);
+        if (self.buf_len > 0) {
+            const to_fill = @min(block_length - self.buf_len, b.len);
+            @memcpy(self.buf[self.buf_len..][0..to_fill], b[0..to_fill]);
+            self.buf_len += to_fill;
+            i += to_fill;
+            if (self.buf_len == block_length) {
+                self.st.addBytes(&self.buf);
+                self.st.permuteR(12);
+                self.buf_len = 0;
+            }
+        }
+
+        while (i + block_length <= b.len) : (i += block_length) {
+            self.st.addBytes(b[i..][0..block_length]);
             self.st.permuteR(12);
         }
 
-        // Store partial block for finalization
         if (i < b.len) {
-            var padded: [8]u8 = @splat(0);
-            const remaining = b.len - i;
-            @memcpy(padded[0..remaining], b[i..]);
-            padded[remaining] = 0x01;
-            self.st.addBytes(&padded);
-        } else {
-            // Add padding block
-            var padded: [8]u8 = @splat(0);
-            padded[0] = 0x01;
-            self.st.addBytes(&padded);
+            self.buf_len = b.len - i;
+            @memcpy(self.buf[0..self.buf_len], b[i..]);
         }
     }
 
@@ -756,7 +760,10 @@ pub const AsconXof128 = struct {
     /// After first call, no more data can be absorbed with update().
     pub fn squeeze(self: *AsconXof128, out: []u8) void {
         if (!self.squeezed) {
-            // First squeeze - apply final permutation
+            var padded: [block_length]u8 = @splat(0);
+            @memcpy(padded[0..self.buf_len], self.buf[0..self.buf_len]);
+            padded[self.buf_len] = 0x01;
+            self.st.addBytes(&padded);
             self.st.permuteR(12);
             self.squeezed = true;
         }
@@ -783,6 +790,8 @@ pub const AsconCxof128 = struct {
 
     st: AsconState,
     squeezed: bool,
+    buf: [block_length]u8,
+    buf_len: usize,
 
     pub const Options = struct { custom: []const u8 = "" };
 
@@ -804,7 +813,7 @@ pub const AsconCxof128 = struct {
         var st = AsconState.initFromWords(words);
         st.permuteR(12);
 
-        var self = AsconCxof128{ .st = st, .squeezed = false };
+        var self = AsconCxof128{ .st = st, .squeezed = false, .buf = @splat(0), .buf_len = 0 };
 
         // Process customization string - always process length and padding
         // First block: length of customization string
@@ -867,28 +876,30 @@ pub const AsconCxof128 = struct {
     ///
     /// Note: Cannot be called after squeeze() has been called
     pub fn update(self: *AsconCxof128, b: []const u8) void {
-        debug.assert(!self.squeezed);
+        debug.assert(!self.squeezed); // Cannot update after squeezing
 
         var i: usize = 0;
 
-        // Process full 64-bit blocks
-        while (i + 8 <= b.len) : (i += 8) {
-            self.st.addBytes(b[i..][0..8]);
+        if (self.buf_len > 0) {
+            const to_fill = @min(block_length - self.buf_len, b.len);
+            @memcpy(self.buf[self.buf_len..][0..to_fill], b[0..to_fill]);
+            self.buf_len += to_fill;
+            i += to_fill;
+            if (self.buf_len == block_length) {
+                self.st.addBytes(&self.buf);
+                self.st.permuteR(12);
+                self.buf_len = 0;
+            }
+        }
+
+        while (i + block_length <= b.len) : (i += block_length) {
+            self.st.addBytes(b[i..][0..block_length]);
             self.st.permuteR(12);
         }
 
-        // Store partial block for finalization
         if (i < b.len) {
-            var padded: [8]u8 = @splat(0);
-            const remaining = b.len - i;
-            @memcpy(padded[0..remaining], b[i..]);
-            padded[remaining] = 0x01;
-            self.st.addBytes(&padded);
-        } else {
-            // Add padding block
-            var padded: [8]u8 = @splat(0);
-            padded[0] = 0x01;
-            self.st.addBytes(&padded);
+            self.buf_len = b.len - i;
+            @memcpy(self.buf[0..self.buf_len], b[i..]);
         }
     }
 
@@ -901,7 +912,10 @@ pub const AsconCxof128 = struct {
     /// After first call, no more data can be absorbed with update().
     pub fn squeeze(self: *AsconCxof128, out: []u8) void {
         if (!self.squeezed) {
-            // First squeeze - apply final permutation
+            var padded: [block_length]u8 = @splat(0);
+            @memcpy(padded[0..self.buf_len], self.buf[0..self.buf_len]);
+            padded[self.buf_len] = 0x01;
+            self.st.addBytes(&padded);
             self.st.permuteR(12);
             self.squeezed = true;
         }
@@ -1267,6 +1281,34 @@ test "Ascon-XOF128 official test vectors" {
     }
 }
 
+test "Ascon-XOF128/CXOF128 streaming chunking invariance" {
+    const msg = "Hello, World!";
+
+    // XOF128: one-shot vs split must match
+    var out1: [32]u8 = undefined;
+    var out2: [32]u8 = undefined;
+    var xof1 = AsconXof128.init(.{});
+    xof1.update(msg);
+    xof1.squeeze(&out1);
+    var xof2 = AsconXof128.init(.{});
+    xof2.update("Hello, ");
+    xof2.update("World!");
+    xof2.squeeze(&out2);
+    try testing.expectEqualSlices(u8, &out1, &out2);
+
+    // CXOF128: one-shot vs split must match
+    var cout1: [32]u8 = undefined;
+    var cout2: [32]u8 = undefined;
+    var cxof1 = AsconCxof128.init(.{ .custom = "cust" });
+    cxof1.update(msg);
+    cxof1.squeeze(&cout1);
+    var cxof2 = AsconCxof128.init(.{ .custom = "cust" });
+    cxof2.update("Hello, ");
+    cxof2.update("World!");
+    cxof2.squeeze(&cout2);
+    try testing.expectEqualSlices(u8, &cout1, &cout2);
+}
+
 test "Ascon-CXOF128 official test vectors" {
 
     // Test vector 1: Empty message, empty customization, 64-byte output

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/base64_hex_ct.zig

@@ -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/ml_kem.zig

@@ -1725,15 +1725,8 @@ const NistDRBG = struct {
     v: [16]u8,
 
     fn incV(g: *NistDRBG) void {
-        var j: usize = 15;
-        while (j >= 0) : (j -= 1) {
-            if (g.v[j] == 255) {
-                g.v[j] = 0;
-            } else {
-                g.v[j] += 1;
-                break;
-            }
-        }
+        const val = std.mem.readInt(u128, &g.v, .big);
+        std.mem.writeInt(u128, &g.v, val +% 1, .big);
     }
 
     // AES256_CTR_DRBG_Update(pd, &g.key, &g.v).