Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company 👇
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
// ©AngelaMos | 2026
// smoke.zig
const std = @import("std");
const linux = std.os.linux;
const packet = @import("packet");
fn build_syn(dst_port: u16) [54]u8 {
var frame: [54]u8 = undefined;
const eth = packet.EthHdr{
.dst = .{0} ** 6,
.src = .{0} ** 6,
.ethertype = std.mem.nativeToBig(u16, 0x0800),
};
@memcpy(frame[0..14], std.mem.asBytes(ð));
var ip = packet.Ipv4Hdr{
.version_ihl = 0x45,
.tos = 0,
.total_len = std.mem.nativeToBig(u16, 40),
.id = 0,
.flags_frag = std.mem.nativeToBig(u16, 0x4000),
.ttl = 64,
.protocol = 6,
.checksum = 0,
.src = std.mem.nativeToBig(u32, 0x7f000001),
.dst = std.mem.nativeToBig(u32, 0x7f000001),
};
ip.checksum = std.mem.nativeToBig(u16, packet.checksum(std.mem.asBytes(&ip)));
@memcpy(frame[14..34], std.mem.asBytes(&ip));
var tcp = packet.TcpHdr{
.src_port = std.mem.nativeToBig(u16, 54321),
.dst_port = std.mem.nativeToBig(u16, dst_port),
.seq = std.mem.nativeToBig(u32, 0xdead_beef),
.ack = 0,
.data_off_ns = 0x50,
.flags = 0x02,
.window = std.mem.nativeToBig(u16, 1024),
.checksum = 0,
.urgent = 0,
};
tcp.checksum = std.mem.nativeToBig(u16, packet.tcpChecksum(ip.src, ip.dst, std.mem.asBytes(&tcp)));
@memcpy(frame[34..54], std.mem.asBytes(&tcp));
return frame;
}
pub fn run(io: std.Io, ifname: []const u8) !void {
var buf: [256]u8 = undefined;
var fw = std.Io.File.stdout().writer(io, &buf);
const out = &fw.interface;
const rc_sock = linux.socket(
linux.AF.PACKET,
linux.SOCK.RAW,
std.mem.nativeToBig(u16, @as(u16, linux.ETH.P.IP)),
);
switch (linux.errno(rc_sock)) {
.SUCCESS => {},
.PERM, .ACCES => {
try out.writeAll("smoke: need CAP_NET_RAW. Grant it once, then re-run (no sudo):\n sudo setcap cap_net_raw,cap_net_admin=eip ./zig-out/bin/zingela\n ./zig-out/bin/zingela smoke\nSkipping.\n");
try out.flush();
return;
},
else => |e| {
try out.print("smoke: socket() failed: {s}\n", .{@tagName(e)});
try out.flush();
return error.SocketFailed;
},
}
const fd: i32 = @intCast(rc_sock);
defer _ = linux.close(fd);
var ifr = std.mem.zeroes(linux.ifreq);
if (ifname.len >= ifr.ifrn.name.len) {
try out.print("smoke: interface name too long: {s}\n", .{ifname});
try out.flush();
return error.IfNameTooLong;
}
@memcpy(ifr.ifrn.name[0..ifname.len], ifname);
if (linux.errno(linux.ioctl(fd, linux.SIOCGIFINDEX, @intFromPtr(&ifr))) != .SUCCESS) {
try out.print("smoke: SIOCGIFINDEX failed for {s}\n", .{ifname});
try out.flush();
return error.IfIndexFailed;
}
const ifindex: i32 = ifr.ifru.ivalue;
var sll = std.mem.zeroes(linux.sockaddr.ll);
sll.family = linux.AF.PACKET;
sll.protocol = std.mem.nativeToBig(u16, @as(u16, linux.ETH.P.IP));
sll.ifindex = ifindex;
if (linux.errno(linux.bind(fd, @ptrCast(&sll), @sizeOf(linux.sockaddr.ll))) != .SUCCESS) {
try out.writeAll("smoke: bind() failed\n");
try out.flush();
return error.BindFailed;
}
const frame = build_syn(80);
const rc_send = linux.sendto(fd, &frame, frame.len, 0, @ptrCast(&sll), @sizeOf(linux.sockaddr.ll));
if (linux.errno(rc_send) != .SUCCESS) {
try out.writeAll("smoke: sendto() failed\n");
try out.flush();
return error.SendFailed;
}
try out.print("smoke: OK. Sent {d} bytes (one SYN -> 127.0.0.1:80) on {s} via AF_PACKET.\n", .{ rc_send, ifname });
try out.flush();
}
test "built SYN frame is 54 bytes and IP checksum self-verifies" {
const frame = build_syn(80);
try std.testing.expectEqual(@as(usize, 54), frame.len);
try std.testing.expectEqual(@as(u16, 0), packet.checksum(frame[14..34]));
}