Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
8.5 KB
Raw Blame
//! Pin a release artifact, verify it against that release's SHA256SUMS, and
//! extract the `graff` binary. Fail closed if the sums file is missing,
//! malformed, or does not match. No remote scripts.

const std = @import("std");
const Allocator = std.mem.Allocator;

pub const Error = error{ VerifyFailed, Malformed, OutOfMemory };

pub fn sha256Hex(bytes: []const u8, out: *[64]u8) []const u8 {
    var digest: [32]u8 = undefined;
    std.crypto.hash.sha2.Sha256.hash(bytes, &digest, .{});
    const digits = "0123456789abcdef";
    for (digest, 0..) |b, i| {
        out[i * 2] = digits[b >> 4];
        out[i * 2 + 1] = digits[b & 0x0f];
    }
    return out;
}

/// Find the lowercase hex digest for `asset` in GNU `sha256sum` text.
/// Fail closed on a missing or malformed line.
pub fn digestFor(sums: []const u8, asset: []const u8) ?[]const u8 {
    var lines = std.mem.splitScalar(u8, sums, '\n');
    while (lines.next()) |raw| {
        const line = std.mem.trim(u8, raw, " \t\r");
        if (line.len == 0 or line[0] == '#') continue;
        if (line.len < 66) return null;
        const hex = line[0..64];
        for (hex) |c| {
            const ok = (c >= '0' and c <= '9') or (c >= 'a' and c <= 'f') or (c >= 'A' and c <= 'F');
            if (!ok) return null;
        }
        var rest = std.mem.trim(u8, line[64..], " \t");
        if (rest.len > 0 and (rest[0] == '*' or rest[0] == ' ')) rest = std.mem.trim(u8, rest, " *");
        if (std.mem.eql(u8, rest, asset) or std.mem.endsWith(u8, rest, asset)) return hex;
    }
    return null;
}

pub fn verifyAsset(sums: []const u8, asset: []const u8, bytes: []const u8) Error!void {
    const want = digestFor(sums, asset) orelse return error.VerifyFailed;
    var hex: [64]u8 = undefined;
    const got = sha256Hex(bytes, &hex);
    if (!eqlHex(want, got)) return error.VerifyFailed;
}

fn eqlHex(a: []const u8, b: []const u8) bool {
    if (a.len != b.len) return false;
    var same: u8 = 0;
    for (a, b) |x, y| same |= std.ascii.toLower(x) ^ std.ascii.toLower(y);
    return same == 0;
}

fn isZeroBlock(hdr: []const u8) bool {
    for (hdr) |b| if (b != 0) return false;
    return true;
}

fn tarName(hdr: []const u8) []const u8 {
    const prefix = memCstr(hdr[345..500]);
    const name = memCstr(hdr[0..100]);
    if (prefix.len == 0) return name;
    return name; // we only match a basename of graff
}

fn memCstr(s: []const u8) []const u8 {
    return s[0 .. std.mem.indexOfScalar(u8, s, 0) orelse s.len];
}

fn tarSize(hdr: []const u8) ?u64 {
    const field = memCstr(hdr[124..136]);
    const trimmed = std.mem.trim(u8, field, " \t");
    if (trimmed.len == 0) return 0;
    return std.fmt.parseInt(u64, trimmed, 8) catch null;
}

fn isGraffMember(name: []const u8) bool {
    const base = std.fs.path.basename(name);
    return std.mem.eql(u8, base, "graff") or std.mem.eql(u8, base, "graff.exe");
}

/// A tarball's regular files, in order.
pub const Members = struct {
    tar: []const u8,
    off: usize = 0,

    pub const Member = struct { name: []const u8, payload: []const u8 };

    pub fn init(tar: []const u8) Members {
        return .{ .tar = tar };
    }

    pub fn next(m: *Members) Error!?Member {
        while (m.off + 512 <= m.tar.len) {
            const hdr = m.tar[m.off .. m.off + 512];
            if (isZeroBlock(hdr)) return null;
            const size = tarSize(hdr) orelse return error.Malformed;
            m.off += 512;
            if (m.off + size > m.tar.len) return error.Malformed;
            const payload = m.tar[m.off .. m.off + @as(usize, @intCast(size))];
            m.off += std.mem.alignForward(usize, @as(usize, @intCast(size)), 512);
            if (hdr[156] == 0 or hdr[156] == '0') return .{ .name = tarName(hdr), .payload = payload };
        }
        return null;
    }
};

pub fn extractGraff(gpa: Allocator, tar_bytes: []const u8) Error![]u8 {
    if (tar_bytes.len < 512) return error.Malformed;
    var off: usize = 0;
    while (off + 512 <= tar_bytes.len) {
        const hdr = tar_bytes[off .. off + 512];
        if (isZeroBlock(hdr)) break;
        const size = tarSize(hdr) orelse return error.Malformed;
        const typeflag = hdr[156];
        off += 512;
        if (off + size > tar_bytes.len) return error.Malformed;
        const payload = tar_bytes[off .. off + @as(usize, @intCast(size))];
        off += std.mem.alignForward(usize, @as(usize, @intCast(size)), 512);
        if ((typeflag == 0 or typeflag == '0') and isGraffMember(tarName(hdr)))
            return gpa.dupe(u8, payload);
    }
    return error.Malformed;
}

pub fn gunzip(gpa: Allocator, gz: []const u8) Error![]u8 {
    var in_reader: std.Io.Reader = .fixed(gz);
    const window = gpa.alloc(u8, std.compress.flate.max_window_len) catch return error.OutOfMemory;
    defer gpa.free(window);
    var dec = std.compress.flate.Decompress.init(&in_reader, .gzip, window);
    var out: std.Io.Writer.Allocating = .init(gpa);
    errdefer out.deinit();
    _ = dec.reader.streamRemaining(&out.writer) catch return error.Malformed;
    return out.toOwnedSlice() catch return error.OutOfMemory;
}

pub fn extractVerified(gpa: Allocator, sums: []const u8, asset: []const u8, archive: []const u8) Error![]u8 {
    try verifyAsset(sums, asset, archive);
    const tar = gunzip(gpa, archive) catch |err| switch (err) {
        error.Malformed, error.OutOfMemory => return err,
        else => return error.Malformed,
    };
    defer gpa.free(tar);
    return extractGraff(gpa, tar);
}

fn checksumField(hdr: []u8) void {
    @memset(hdr[148..156], ' ');
    var sum: u32 = 0;
    for (hdr[0..512]) |b| sum += b;
    _ = std.fmt.bufPrint(hdr[148..155], "{o:0>6}", .{sum}) catch {};
    hdr[155] = 0;
}

/// Build a one-file ustar + gzip for isolated fixtures. Never used as a
/// production download path.
pub fn fixtureArchive(gpa: Allocator, member_name: []const u8, payload: []const u8) ![]u8 {
    const data_pad = std.mem.alignForward(usize, payload.len, 512);
    const tar = try gpa.alloc(u8, 512 + data_pad + 1024);
    errdefer gpa.free(tar);
    @memset(tar, 0);
    const hdr = tar[0..512];
    const name_len = @min(member_name.len, 99);
    @memcpy(hdr[0..name_len], member_name[0..name_len]);
    _ = try std.fmt.bufPrint(hdr[100..107], "{o:0>7}", .{@as(u32, 0o0755)});
    _ = try std.fmt.bufPrint(hdr[124..135], "{o:0>11}", .{payload.len});
    hdr[156] = '0';
    @memcpy(hdr[257..262], "ustar");
    hdr[263] = '0';
    checksumField(hdr);
    @memcpy(tar[512 .. 512 + payload.len], payload);
    const gz = try gzipAlloc(gpa, tar);
    gpa.free(tar);
    return gz;
}

pub fn gzipAlloc(gpa: Allocator, plain: []const u8) ![]u8 {
    var out_buf: [1 << 16]u8 = undefined;
    var out: std.Io.Writer = .fixed(&out_buf);
    const window = try gpa.alloc(u8, std.compress.flate.max_window_len);
    defer gpa.free(window);
    const c = try gpa.create(std.compress.flate.Compress);
    defer gpa.destroy(c);
    c.* = try std.compress.flate.Compress.init(&out, window, .gzip, .default);
    try c.writer.writeAll(plain);
    try c.finish();
    return gpa.dupe(u8, out.buffered());
}

pub fn sumsLine(gpa: Allocator, asset: []const u8, bytes: []const u8) ![]u8 {
    var hex: [64]u8 = undefined;
    _ = sha256Hex(bytes, &hex);
    return std.fmt.allocPrint(gpa, "{s}  {s}\n", .{ hex, asset });
}

test "digestFor reads GNU sha256sum lines and rejects junk" {
    const body = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa  graff-x86_64-linux.tar.gz\n";
    try std.testing.expectEqualStrings(
        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        digestFor(body, "graff-x86_64-linux.tar.gz").?,
    );
    try std.testing.expect(digestFor("not-a-sum\n", "graff-x86_64-linux.tar.gz") == null);
    try std.testing.expect(digestFor(body, "graff-aarch64-macos.tar.gz") == null);
}

test "verify + extract a fixture archive" {
    const gpa = std.testing.allocator;
    const archive = try fixtureArchive(gpa, "graff-x86_64-linux/graff", "NEWBIN");
    defer gpa.free(archive);
    const sums = try sumsLine(gpa, "graff-x86_64-linux.tar.gz", archive);
    defer gpa.free(sums);
    const bin = try extractVerified(gpa, sums, "graff-x86_64-linux.tar.gz", archive);
    defer gpa.free(bin);
    try std.testing.expectEqualStrings("NEWBIN", bin);
}

test "verification fails closed on a wrong digest" {
    const gpa = std.testing.allocator;
    const archive = try fixtureArchive(gpa, "graff", "NEWBIN");
    defer gpa.free(archive);
    try std.testing.expectError(
        error.VerifyFailed,
        extractVerified(gpa, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb  graff-x86_64-linux.tar.gz\n", "graff-x86_64-linux.tar.gz", archive),
    );
}