Adversarial C2 Protocol Implemented in Zig
+85
-64
+79
-61
src/NetWriter.zig
+79
-61
src/NetWriter.zig
···
29
29
30
30
fn drain(io_w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
31
31
const w: *NetWriter = @alignCast(@fieldParentPtr("interface", io_w));
32
-
const headers_byte_len = comptime (EthernetHeaders.byte_len + IpHeaders.byte_len + UdpHeaders.byte_len);
32
+
const headers_byte_len = comptime (EthernetHeaders.byte_len + (@bitSizeOf(IpHeaders) / 8) + @sizeOf(UdpHeaders));
33
33
const headers: [headers_byte_len]u8 = blk: {
34
34
const ether_headers: EthernetHeaders = .{
35
35
.dest_mac = .{ 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff },
···
56
56
const udp_headers: UdpHeaders = .{
57
57
.src_port = 0xbbbb,
58
58
.dest_port = 8888,
59
-
.length = @intCast(total_len + UdpHeaders.byte_len),
59
+
.length = @intCast(total_len + @sizeOf(UdpHeaders)),
60
60
};
61
61
62
62
var buf: [headers_byte_len]u8 = undefined;
63
63
var buf_w = Writer.fixed(&buf);
64
64
65
65
_ = try ether_headers.write(&buf_w);
66
-
_ = try ip_headers.write(&buf_w);
67
-
_ = try udp_headers.write(&buf_w);
66
+
try ip_headers.write(&buf_w);
67
+
try buf_w.writeStruct(udp_headers, .big);
68
68
69
69
break :blk buf;
70
70
};
···
104
104
}
105
105
};
106
106
107
-
const IpHeaders = struct {
108
-
// ip_version: u4,
109
-
// header_length: u4 = 0,
110
-
type_of_service: u8 = 0,
111
-
total_length: u16 = 0x04,
112
-
113
-
identification: u16 = 0,
107
+
const IpHeaders = extern struct {
108
+
dest_ip: @Vector(4, u8) align(1),
109
+
src_ip: @Vector(4, u8) align(1),
110
+
header_checksum: @Vector(2, u8) align(1) = .{ 0, 0 },
111
+
protocol: u8 align(1) = 0,
112
+
ttl: u8 align(1) = 0,
113
+
fragment_and_flags: packed struct(u16) {
114
+
fragment_offset: u13 = 0,
115
+
ethernet_flags: u3 = 0,
116
+
} = .{},
117
+
// fragment_offset: u13 = 0,
114
118
// ethernet_flags: u3 = 0,
115
-
// fragment_offset: u13 = 0,
116
-
ttl: u8 = 0,
117
-
protocol: u8 = 0,
118
-
119
-
header_checksum: @Vector(2, u8) = .{ 0, 0 },
120
-
src_ip: @Vector(4, u8),
121
-
122
-
dest_ip: @Vector(4, u8),
119
+
identification: u16 align(1) = 0,
120
+
total_length: u16 align(1) = 0x04,
121
+
type_of_service: u8 align(1) = 0,
122
+
header_and_version: packed struct(u8) {
123
+
header_length: u4 = 5,
124
+
ip_version: u4 = 4,
125
+
} = .{},
126
+
// header_length: u4 = 5,
127
+
// ip_version: u4 = 4,
123
128
124
-
fn write(hdr: @This(), writer: *std.Io.Writer) Writer.Error!usize {
129
+
fn write(hdr: IpHeaders, writer: *std.Io.Writer) Writer.Error!void {
125
130
try writer.writeInt(u8, 0x45, .big); // ip version and header length
126
131
try writer.writeByte(hdr.type_of_service);
127
132
try writer.writeInt(u16, hdr.total_length, .big);
···
132
137
try writer.writeInt(u16, @bitCast(hdr.header_checksum), .big);
133
138
try writer.writeInt(u32, @bitCast(hdr.src_ip), .big);
134
139
try writer.writeInt(u32, @bitCast(hdr.dest_ip), .big);
135
-
return byte_len;
136
140
}
137
141
138
-
const byte_len = blk: {
139
-
var res: usize = 0;
140
-
res += @sizeOf(u8);
141
-
res += @sizeOf(u8);
142
-
res += @sizeOf(u16);
143
-
res += @sizeOf(u16);
144
-
res += @sizeOf(u16);
145
-
res += @sizeOf(u8);
146
-
res += @sizeOf(u8);
147
-
res += @sizeOf(u16);
148
-
res += @sizeOf(u32);
149
-
res += @sizeOf(u32);
150
-
break :blk res;
151
-
};
152
-
153
-
fn bytes(hdr: IpHeaders) [byte_len]u8 {
154
-
var res: [byte_len]u8 = undefined;
155
-
hdr.write(Writer.fixed(&res)) catch unreachable;
142
+
fn bytes(hdr: IpHeaders) [@bitSizeOf(IpHeaders) / 8]u8 {
143
+
var res: [@bitSizeOf(IpHeaders) / 8]u8 = undefined;
144
+
var w = Writer.fixed(&res);
145
+
_ = hdr.write(&w) catch unreachable;
146
+
return res;
156
147
}
157
148
};
158
149
159
-
const UdpHeaders = packed struct {
160
-
src_port: u16,
150
+
test IpHeaders {
151
+
var a: IpHeaders = .{
152
+
.dest_ip = .{ 1, 2, 3, 4 },
153
+
.src_ip = .{ 5, 6, 7, 8 },
154
+
// .header_checksum = .{ 0x1, 0x1 },
155
+
// .protocol = 0,
156
+
// .ttl = 0x64,
157
+
// .identification = 3,
158
+
// .type_of_service = 7,
159
+
};
160
+
// a.dest_ip = .{ 1, 2, 3, 4 };
161
+
// a.src_ip = .{ 5, 6, 7, 8 };
162
+
std.debug.print("ip struct: {}\n", .{a});
163
+
std.debug.print("dest ip: {}\n", .{a.dest_ip});
164
+
std.debug.print("src ip: {}\n", .{a.src_ip});
165
+
166
+
std.debug.print("raw b : {x}\n", .{@as([@bitSizeOf(IpHeaders) / 8]u8, @bitCast(a))});
167
+
168
+
std.debug.print("ip bytes: {x}\n", .{a.bytes()});
169
+
var a_struct: [@bitSizeOf(IpHeaders) / 8]u8 = undefined;
170
+
var a_struct_w = Writer.fixed(&a_struct);
171
+
_ = a_struct_w.writeStruct(a, .big) catch unreachable;
172
+
std.debug.print("ip struct: {x}\n", .{a_struct});
173
+
try std.testing.expectEqual(a, a);
174
+
}
161
175
162
-
dest_port: u16,
163
-
length: u16,
176
+
const UdpHeaders = packed struct {
164
177
checksum: @Vector(2, u8) = .{ 0, 0 },
178
+
length: u16,
179
+
dest_port: u16,
180
+
src_port: u16,
165
181
166
-
fn write(hdr: @This(), writer: *std.Io.Writer) Writer.Error!usize {
167
-
try writer.writeInt(u16, hdr.src_port, .big);
168
-
try writer.writeInt(u16, hdr.dest_port, .big);
169
-
try writer.writeInt(u16, hdr.length, .big);
170
-
try writer.writeInt(u16, @bitCast(hdr.checksum), .big);
171
-
return byte_len;
182
+
fn write(hdr: UdpHeaders, writer: *std.Io.Writer) Writer.Error!void {
183
+
try writer.writeStruct(hdr, .big);
172
184
}
173
185
174
-
const byte_len = blk: {
175
-
var res: usize = 0;
176
-
res += @sizeOf(u16);
177
-
res += @sizeOf(u16);
178
-
res += @sizeOf(u16);
179
-
res += @sizeOf(u16);
180
-
break :blk res;
181
-
};
182
-
183
-
fn bytes(hdr: UdpHeaders) [byte_len]u8 {
184
-
var res: [byte_len]u8 = undefined;
185
-
hdr.write(Writer.fixed(&res)) catch unreachable;
186
+
fn bytes(hdr: UdpHeaders) [@sizeOf(UdpHeaders)]u8 {
187
+
var res: [@sizeOf(UdpHeaders)]u8 = undefined;
188
+
var w = Writer.fixed(&res);
189
+
_ = hdr.write(&w) catch unreachable;
190
+
return res;
186
191
}
187
192
};
193
+
194
+
test UdpHeaders {
195
+
const a: UdpHeaders = .{
196
+
.src_port = 1,
197
+
.dest_port = 2,
198
+
.length = 3,
199
+
.checksum = .{ 0x04, 0x05 },
200
+
};
201
+
var a_struct: [@sizeOf(UdpHeaders)]u8 = undefined;
202
+
var a_struct_w = Writer.fixed(&a_struct);
203
+
_ = a_struct_w.writeStruct(a, .big) catch unreachable;
204
+
try std.testing.expectEqual(a.bytes(), a_struct);
205
+
}
188
206
189
207
const std = @import("std");
190
208
const Random = std.Random;
+2
-2
src/message.zig
+2
-2
src/message.zig
···
196
196
var msg_bytes: [try Message.calcSize(.relay, payload.len)]u8 align(@alignOf(Message)) = undefined;
197
197
198
198
// Create a view of the byte slice as a Message
199
-
const msg: *Message = .init(.relay, &msg_bytes);
199
+
const msg: *align(1) Message = .init(.relay, &msg_bytes);
200
200
201
201
{
202
202
// Set the message values
···
234
234
var msg_bytes: [try Message.calcSize(.connection, payload.len)]u8 align(@alignOf(Message)) = undefined;
235
235
236
236
// Create a view of the byte slice as a Message
237
-
const msg: *Message = .init(.connection, &msg_bytes);
237
+
const msg: *align(1) Message = .init(.connection, &msg_bytes);
238
238
239
239
{
240
240
// Initializing connection header values
+4
-1
src/root.zig
+4
-1
src/root.zig
···
6
6
const msg = @import("message.zig");
7
7
8
8
pub const PacketType = msg.PacketType;
9
-
pub const foo = msg.foo;
10
9
pub const ConnectionOptions = msg.ConnectionOptions;
11
10
pub const MessageTypeError = msg.MessageTypeError;
12
11
pub const MessageParseError = msg.MessageParseError;
13
12
pub const Message = msg.Message;
13
+
14
+
test {
15
+
@import("std").testing.refAllDecls(@This());
16
+
}