srctree

const std = @import("std");

 

const print = std.debug.print;

const fixedBufferStream = std.io.fixedBufferStream;

ecc: EllipticCurve,

} = .{ .invalid = {} },

 

TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA = 0x0013,

TLS_DHE_DSS_WITH_AES_128_CBC_SHA = 0x0032,

TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = 0x0040,

TLS_DH_anon_WITH_AES_256_CBC_SHA = 0x003A,

TLS_DH_anon_WITH_AES_256_CBC_SHA256 = 0x006D,

TLS_DH_anon_WITH_RC4_128_MD5 = 0x0018,

TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAC,

TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAB,

TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAE,

 

pub fn fromInt(s: u16) Suites {

return switch (s) {

0xCCA9 => .TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,

0xCCA8 => .TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,

else => unreachable,

};

}

pub const EllipticCurve = struct {

curve: Curves = .{ .invalid = {} },

 

 

pub const Curves = union(CurveType) {

invalid: void,

pub const ExplicitChar2 = struct {};

pub const NamedCurve = struct {};

 

}

 

var fba = fixedBufferStream(buffer);

const w = fba.writer().any();

 

 

pub fn packKeyExchange(ecc: EllipticCurve, buffer: []u8) !usize {

return switch (ecc.curve) {

};

}

 

var fba = fixedBufferStream(buffer);

const r = fba.reader().any();

 

const curve_type = try CurveType.fromByte(try r.readByte());

}

};

 

 

const CompressionMethod = root.CompressionMethod;

const SessionID = root.SessionID;

 

 

cipher: Cipher = .{},

session_id: ?SessionID = null,

entity: ConnectionEnd = .{},

prf_algorithm: PRFAlgorithm = .{},

 

///

const std = @import("std");

 

const Protocol = @import("protocol.zig");

const root = @import("root.zig");

const Extensions = @import("extensions.zig");

const Cipher = @import("cipher.zig");

 

const SessionID = root.SessionID;

const Extension = Extensions.Extension;

 

 

/// Client Section

pub const ClientHello = struct {

random: Random,

session_id: SessionID,

extensions: []const Extension = &[0]Extension{},

 

pub const SupportedExtensions = [_]type{

 

pub const length = @sizeOf(ClientHello);

 

var hello = ClientHello{

.session_id = [_]u8{0} ** 32,

};

 

csprng.fill(&hello.session_id);

return hello;

}

var w = fba.writer().any();

try w.writeByte(ch.version.major);

try w.writeByte(ch.version.minor);

try w.writeByte(0);

//try w.writeByte(ch.session_id.len);

//try w.writeAll(&ch.session_id);

return fba.pos;

}

 

_ = buffer;

unreachable;

}

} = .explicit,

cipher: *const Cipher,

 

return cke;

}

 

compression: Compression,

extensions: []const Extension,

 

print("buffer:: {any}\n", .{buffer});

var fba = fixedBufferStream(buffer);

const r = fba.reader().any();

.major = try r.readByte(),

.minor = try r.readByte(),

};

 

const session_size = try r.readByte();

var session_id: [32]u8 = [_]u8{0} ** 32;

.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,

.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,

=> {

},

}

 

// compression

if (try r.readByte() != 0) return error.InvalidCompression;

 

// extensions

var extbuffer: [0x1000]u8 = undefined;

try r.readNoEof(extbuffer[0..extbytes]);

} else |err| switch (err) {

}

 

/// Will modify sess with supplied

else => unreachable,

}

return .{

.buffer = buffer,

};

}

};

 

pub const ServerHelloDone = struct {

buffer: []const u8,

 

return .{

.buffer = buffer,

.session = sess,

/// Certs

pub const Certificate = struct {

buffer: []const u8,

 

return .{

.buffer = buffer,

.session = sess,

 

pub const CertificateRequest = struct {

buffer: []const u8,

 

return .{

.buffer = buffer,

.session = sess,

return len + 4;

}

 

const hs_type = try Type.fromByte(buffer[0]);

const hsbuf = buffer[4..];

return .{

 

const Extensions = @import("extensions.zig");

const Extension = Extensions.Extension;

const Protocol = @import("protocol.zig");

const Handshake = @import("handshake.zig");

const Cipher = @import("cipher.zig");

 

const ContentType = enum(u8) {

change_cipher_spec = 20,

alert = 21,

return record.packFragment(buffer);

}

 

var fba = fixedBufferStream(buffer);

var r = fba.reader().any();

 

},

};

}

return try unpackFragment(buffer, sess);

}

};

 

test "Handshake ClientHello" {

var buffer = [_]u8{0} ** 0x400;

const record = TLSRecord{

.kind = .{

.handshake = try Handshake.Handshake.wrap(client_hello),

_ = len;

}

 

var buffer = [_]u8{0} ** 0x1000;

const record = TLSRecord{

.kind = .{

.handshake = try Handshake.Handshake.wrap(client_hello),

const dout = try conn.write(buffer[0..len]);

if (false) print("data count {}\n", .{dout});

if (false) print("data out {any}\n", .{buffer[0..len]});

}

 

/// Forgive me, I'm tired

return s_read;

}

 

var next_block: []const u8 = data;

 

while (next_block.len > 0) {

if (false) print("server block\n{any}\n", .{next_block});

if (false) print("mock {}\n", .{tlsr.length});

next_block = next_block[tlsr.length + 5 ..];

 

print("server hello {}\n", .{@TypeOf(hello)});

print("srv selected suite {any}\n", .{hello.cipher});

print("test selected suite {any}\n", .{.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256});

return error.UnexpectedCipherSuite;

}

},

.certificate => |cert| {

print("server cert {}\n", .{@TypeOf(cert)});

}

}

 

var buffer = [_]u8{0} ** 0x1000;

const cke_record = TLSRecord{

.kind = .{

.handshake = try Handshake.Handshake.wrap(cke),

if (true) print("cke delivered, {}\n", .{ckeout});

 

var r_buf: [0x1000]u8 = undefined;

if (false) { // check for alerts

const num = try conn.read(&r_buf);

print("sin: {any}\n", .{r_buf[0..num]});

print("server thing {}\n", .{sin});

}

 

 

const num2 = try conn.read(&r_buf);

print("sin: {any}\n", .{r_buf[0..num2]});

print("server thing {}\n", .{sin2});

}

 

fn fullHandshake(conn: std.net.Stream) !void {

var server: [0x1000]u8 = undefined;

const l = try readServer(conn, &server);

}

 

test "tls" {

};

const conn = try net.tcpConnectToAddress(addr);

 

var server: [0x1000]u8 = undefined;

const l = try readServer(conn, &server);

}

 

test "mock server response" {

if (true) return error.SkipZigTest;

// zig fmt: off

const server_data = [_]u8{

22, 3, 3, 0, 74,

};

// zig fmt: on

 

 

//const cke = try ClientKeyExchange.init();

//const record = TLSRecord{