ci: Fix syntax error and align codebase with Zig 0.15.2 modern APIs

Author: il1v3y

src/agent.zig

@@ -125,11 +125,15 @@ pub const Agent = struct {
         const conn = try std.net.tcpConnectToAddress(address);
         defer conn.close();
 
-        var bw = std.io.bufferedWriter(conn.writer());
-        const reader = conn.reader();
-
-        try self.sendPing(&bw, reader);
-        try self.checkTasks(&bw, reader);
+        var read_buf: [4096]u8 = undefined;
+        var write_buf: [4096]u8 = undefined;
+        var r_state = conn.reader(&read_buf);
+        var w_state = conn.writer(&write_buf);
+        const reader = r_state.interface();
+        const writer = &w_state.interface;
+
+        try self.sendPing(writer, reader);
+        try self.checkTasks(writer, reader);
     }
 
     fn sendPing(self: *Agent, writer: anytype, reader: anytype) !void {
@@ -320,12 +324,11 @@ pub const Agent = struct {
         if (resp) |r| self.allocator.free(r);
     }
 
-    fn sendEncrypted(self: *Agent, bw: anytype, plaintext: []const u8) !void {
+    fn sendEncrypted(self: *Agent, writer: anytype, plaintext: []const u8) !void {
         const encrypted = try crypto.encrypt(self.allocator, self.key, plaintext);
         defer self.allocator.free(encrypted);
-        try bw.writer().writeInt(u32, @as(u32, @intCast(encrypted.len)), .little);
-        try bw.writer().writeAll(encrypted);
-        try bw.flush();
+        try writer.writeInt(u32, @as(u32, @intCast(encrypted.len)), .little);
+        try writer.writeAll(encrypted);
     }
 
     fn receiveEncrypted(self: *Agent, reader: anytype) !?[]u8 {

src/c2.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const ArrayList = std.array_list.Managed;
 
 pub const default_state_file = ".zighound_c2_sim.txt";
 
@@ -29,15 +28,15 @@ pub const Command = struct {
 
 pub const C2State = struct {
     allocator: std.mem.Allocator,
-    beacons: ArrayList(Beacon),
-    commands: ArrayList(Command),
+    beacons: std.ArrayListUnmanaged(Beacon),
+    commands: std.ArrayListUnmanaged(Command),
     next_command_id: u64,
 
     pub fn init(allocator: std.mem.Allocator) C2State {
         return .{
             .allocator = allocator,
-            .beacons = ArrayList(Beacon).init(allocator),
-            .commands = ArrayList(Command).init(allocator),
+            .beacons = .empty,
+            .commands = .empty,
             .next_command_id = 1,
         };
     }
@@ -54,8 +53,8 @@ pub const C2State = struct {
             self.allocator.free(command.status);
             self.allocator.free(command.output);
         }
-        self.beacons.deinit();
-        self.commands.deinit();
+        self.beacons.deinit(self.allocator);
+        self.commands.deinit(self.allocator);
     }
 };
 
@@ -92,7 +91,7 @@ pub fn loadState(allocator: std.mem.Allocator, path: []const u8) !C2State {
             const jitter = std.fmt.parseInt(u32, jitter_str, 10) catch return StateError.InvalidStateLine;
             const last_callback = std.fmt.parseInt(i64, last_callback_str, 10) catch return StateError.InvalidStateLine;
 
-            try state.beacons.append(.{
+            try state.beacons.append(state.allocator, .{
                 .id = id,
                 .listener = listener,
                 .jitter = jitter,
@@ -113,7 +112,7 @@ pub fn loadState(allocator: std.mem.Allocator, path: []const u8) !C2State {
 
             if (id >= state.next_command_id) state.next_command_id = id + 1;
 
-            try state.commands.append(.{
+            try state.commands.append(state.allocator, .{
                 .id = id,
                 .beacon_id = beacon_id,
                 .command = command_text,
@@ -168,7 +167,7 @@ pub fn registerBeacon(state: *C2State, listener: []const u8, jitter: u32) ![]con
     const status = try state.allocator.dupe(u8, "active");
     const now = std.time.timestamp() * 1000;
 
-    try state.beacons.append(.{
+    try state.beacons.append(state.allocator, .{
         .id = id,
         .listener = listener_copy,
         .jitter = jitter,
@@ -193,7 +192,7 @@ pub fn queueCommand(state: *C2State, beacon_id: []const u8, command: []const u8)
     const status = try state.allocator.dupe(u8, "queued");
     const output = try state.allocator.dupe(u8, "");
 
-    try state.commands.append(.{
+    try state.commands.append(state.allocator, .{
         .id = command_id,
         .beacon_id = beacon_copy,
         .command = command_copy,

src/privesc.zig

@@ -15,9 +15,9 @@ pub const PrivEsc = struct {
     }
 
     pub fn audit(self: *PrivEsc) ![]u8 {
-        var report = ArrayList(u8).init(self.allocator);
-        defer report.deinit();
-        const writer = report.writer();
+        var report: std.ArrayListUnmanaged(u8) = .empty;
+        defer report.deinit(self.allocator);
+        const writer = report.writer(self.allocator);
 
         try writer.print("=== Privilege Escalation Audit ===\n", .{});
 
@@ -29,7 +29,7 @@ pub const PrivEsc = struct {
             try writer.print("[-] OS not supported for automated audit.\n", .{});
         }
 
-        return report.toOwnedSlice();
+        return report.toOwnedSlice(self.allocator);
     }
 
     fn auditLinux(self: *PrivEsc, writer: anytype) !void {

src/scanner.zig

@@ -3,14 +3,22 @@
 // Proprietary and confidential.
 
 const std = @import("std");
+
 const builtin = @import("builtin");
+
 const util = @import("util.zig");
-const os = if (@hasDecl(std, "posix")) std.posix else os;
-const ArrayList = std.array_list.Managed;
+
+const os = if (@hasDecl(std, "posix")) std.posix else std.os;
+
+
 
 pub const Scanner = struct {
+
     allocator: std.mem.Allocator,
-    results: ArrayList(ScanResult),
+
+    results: std.ArrayListUnmanaged(ScanResult),
+
+
 
     pub const ReportFormat = enum {
         auto,
@@ -62,7 +70,7 @@ pub const Scanner = struct {
     pub fn init(allocator: std.mem.Allocator) Scanner {
         return .{
             .allocator = allocator,
-            .results = ArrayList(ScanResult).init(allocator),
+            .results = .empty,
         };
     }
 
@@ -71,7 +79,7 @@ pub const Scanner = struct {
             self.allocator.free(result.ip);
             if (result.banner) |b| self.allocator.free(b);
         }
-        self.results.deinit();
+        self.results.deinit(self.allocator);
     }
 
     pub fn scanTarget(
@@ -81,7 +89,7 @@ pub const Scanner = struct {
         options: ScanOptions,
     ) !void {
         var ports_list = try parsePorts(self.allocator, ports_str);
-        defer ports_list.deinit();
+        defer ports_list.deinit(self.allocator);
 
         const range = try parseTarget(target);
         const host_count: u64 = @as(u64, range.end) - @as(u64, range.start) + 1;
@@ -162,7 +170,7 @@ pub const Scanner = struct {
 
     const Shared = struct {
         allocator: std.mem.Allocator,
-        results: *ArrayList(ScanResult),
+        results: *std.ArrayListUnmanaged(ScanResult),
         verbose: bool,
         quiet: bool,
         color: bool,
@@ -219,7 +227,7 @@ pub const Scanner = struct {
 
                 var stored = false;
                 shared.results_mutex.lock();
-                shared.results.append(result) catch {};
+                shared.results.append(shared.allocator, result) catch {};
                 shared.open_count += 1;
                 stored = true;
                 shared.results_mutex.unlock();
@@ -383,8 +391,8 @@ pub const Scanner = struct {
         return .{ .start = start, .end = end };
     }
 
-    fn parsePorts(allocator: std.mem.Allocator, ports_str: []const u8) !ArrayList(u16) {
-        var ports = ArrayList(u16).init(allocator);
+    fn parsePorts(allocator: std.mem.Allocator, ports_str: []const u8) !std.ArrayListUnmanaged(u16) {
+        var ports: std.ArrayListUnmanaged(u16) = .empty;
 
         const included = try allocator.alloc(bool, 65_536);
         defer allocator.free(included);
@@ -408,15 +416,15 @@ pub const Scanner = struct {
                     const port = @as(u16, @intCast(port_value));
                     const index = @as(usize, port);
                     if (!included[index]) {
-                        try ports.append(port);
+                        try ports.append(allocator, port);
                         included[index] = true;
                     }
                 }
             } else {
                 const port = try parsePortValue(token);
                 const index = @as(usize, port);
                 if (!included[index]) {
-                    try ports.append(port);
+                    try ports.append(allocator, port);
                     included[index] = true;
                 }
             }