ReviewOS

also looking at this

mail-os/mail

Harden encrypted mail storage, recovery, and forwarding

#8
Merged chris wants to merge codex/mail-storage-hardening into main
50 files +1701 -9001
packages/zig/vendor/zig-tls/src/handshake_client.zigdeleted+0-1396
Changes to packages/zig/vendor/zig-tls/src/handshake_client.zig
@@ -1,1396 +0,0 @@
1const std = @import("std");
2const assert = std.debug.assert;
3const crypto = std.crypto;
4const mem = std.mem;
5const posix = std.posix;
6const Io = std.Io;
7const Certificate = crypto.Certificate;
8
9// Helper function for Zig 0.16 compatibility
10fn getMilliTimestamp() i64 {
11 var ts: std.c.timespec = undefined;
12 if (std.c.clock_gettime(.REALTIME, &ts) != 0) return 0;
13 return ts.sec * 1000 + @divFloor(ts.nsec, std.time.ns_per_ms);
14}
15
16const rng = @import("random.zig");
17const Cipher = @import("cipher.zig").Cipher;
18const CipherSuite = @import("cipher.zig").CipherSuite;
19const cipher_suites = @import("cipher.zig").cipher_suites;
20const max_cleartext_len = @import("cipher.zig").max_cleartext_len;
21
22const Transcript = @import("transcript.zig").Transcript;
23const record = @import("record.zig");
24const Record = record.Record;
25const rsa = @import("rsa/rsa.zig");
26const key_log = @import("key_log.zig");
27const PrivateKey = @import("PrivateKey.zig");
28const proto = @import("protocol.zig");
29
30const common = @import("handshake_common.zig");
31const CertificateBuilder = common.CertificateBuilder;
32const CertificateParser = common.CertificateParser;
33const DhKeyPair = common.DhKeyPair;
34const CertKeyPair = common.CertKeyPair;
35const cert = common.cert;
36
37const log = std.log.scoped(.tls);
38
39pub const Options = struct {
40 host: []const u8,
41 /// Set of root certificate authorities that clients use when verifying
42 /// server certificates.
43 root_ca: cert.Bundle,
44
45 /// Controls whether a client verifies the server's certificate chain and
46 /// host name.
47 insecure_skip_verify: bool = false,
48
49 /// List of cipher suites to use.
50 /// To use just tls 1.3 cipher suites:
51 /// .cipher_suites = &tls.CipherSuite.tls13,
52 /// To select particular cipher suite:
53 /// .cipher_suites = &[_]tls.CipherSuite{tls.CipherSuite.CHACHA20_POLY1305_SHA256},
54 cipher_suites: []const CipherSuite = cipher_suites.all,
55
56 /// List of named groups to use.
57 /// To use specific named group:
58 /// .named_groups = &[_]tls.NamedGroup{.secp384r1},
59 named_groups: []const proto.NamedGroup = &[_]proto.NamedGroup{
60 .x25519,
61 .secp256r1,
62 .secp384r1,
63 .x25519_ml_kem768,
64 },
65
66 /// Client authentication certificates and private key.
67 auth: ?*CertKeyPair = null,
68
69 /// If this structure is provided it will be filled with handshake attributes
70 /// at the end of the handshake process.
71 diagnostic: ?*Diagnostic = null,
72
73 /// For logging current connection tls keys, so we can share them with
74 /// Wireshark and analyze decrypted traffic there.
75 key_log_callback: ?key_log.Callback = null,
76
77 session_resumption: ?*SessionResumption = null,
78
79 pub const Diagnostic = struct {
80 tls_version: proto.Version = @fromBackingInt(@intCast(0)),
81 cipher_suite_tag: CipherSuite = @fromBackingInt(@intCast(0)),
82 named_group: proto.NamedGroup = @fromBackingInt(@intCast(0)),
83 signature_scheme: proto.SignatureScheme = @fromBackingInt(@intCast(0)),
84 client_signature_scheme: proto.SignatureScheme = @fromBackingInt(@intCast(0)),
85 is_session_resumption: bool = false,
86 max_server_record_len: usize = 0,
87 max_server_cleartext_len: usize = 0,
88 max_client_record_len: usize = 0,
89 };
90
91 /// Collects and stores session resumption tickets.
92 pub const SessionResumption = struct {
93 const Self = @This();
94
95 pub const Ticket = struct {
96 // in seconds
97 lifetime: u32,
98 // in milliseconds
99 created_at: i64,
100 // value to add to the milliseconds age
101 age_add: u32,
102 // nonce and identity are pointes to the part of the payload
103 nonce: []const u8, // <0..255>
104 identity: []const u8, // <1..2^16-1>
105 // payload is allocated and should be freed
106 payload: []const u8,
107 // pointer to the externaly allocated secret
108 secret: []const u8,
109
110 pub fn init(payload: []const u8, secret: []const u8) !Ticket {
111 var d = record.Decoder.init(.handshake, payload);
112 const handshake_type: proto.Handshake = @fromBackingInt(@intCast(try d.decode(u8)));
113 if (handshake_type != proto.Handshake.new_session_ticket) return error.InvalidType;
114 const length = try d.decode(u24);
115 if (d.rest().len != length) return error.InvalidLength;
116
117 return .{
118 .lifetime = try d.decode(u32),
119 .age_add = try d.decode(u32),
120 .nonce = try d.slice(try d.decode(u8)),
121 .identity = try d.slice(try d.decode(u16)),
122 .payload = payload,
123 .secret = secret,
124 .created_at = getMilliTimestamp(),
125 };
126 }
127
128 /// Obfuscated age for pre shared extension in client hello message when
129 /// using this ticket.
130 pub fn obfuscatedAge(t: Ticket) u32 {
131 const age: u32 = @intCast(getMilliTimestamp() - t.created_at);
132 return t.age_add +% age;
133 }
134 };
135
136 allocator: std.mem.Allocator,
137 hash_tag: CipherSuite.HashTag = .sha256,
138 tickets: std.ArrayListUnmanaged(Ticket) = .empty,
139 secrets: std.ArrayListUnmanaged([]const u8) = .empty,
140 used_tickets: usize = 0,
141
142 pub fn init(allocator: mem.Allocator) Self {
143 return .{ .allocator = allocator };
144 }
145
146 /// Set resumption master secret (known at then end of the handshake) to
147 /// be used by new session ticket's sent on that connection. Returns
148 /// index of the appended secret in the secrets list. Connection should
149 /// use that index in pushTicket to connect ticket and the secret.
150 pub fn appendSecret(self: *Self, tag: CipherSuite.HashTag, secret: []const u8) !usize {
151 if (self.secrets.items.len == 0) self.hash_tag = tag;
152 if (tag != self.hash_tag) return error.InvalidHash;
153 try self.secrets.ensureUnusedCapacity(self.allocator, 1);
154 self.secrets.appendAssumeCapacity(try self.allocator.dupe(u8, secret));
155 return self.secrets.items.len - 1;
156 }
157
158 /// When new session ticket message is recived connection should push ticket.
159 pub fn pushTicket(self: *Self, data: []const u8, secret_idx: usize) !void {
160 assert(self.secrets.items.len > secret_idx);
161 try self.tickets.ensureUnusedCapacity(self.allocator, 1);
162 const payload = try self.allocator.dupe(u8, data);
163 errdefer self.allocator.free(payload);
164 const ticket = try Ticket.init(payload, self.secrets.items[secret_idx]);
165 self.tickets.appendAssumeCapacity(ticket);
166 }
167
168 pub fn popTicket(self: *Self) ?Ticket {
169 if (self.used_tickets >= self.tickets.items.len) return null;
170 defer self.used_tickets += 1;
171 return self.tickets.items[self.used_tickets];
172 }
173
174 pub fn deinit(self: *Self) void {
175 for (self.tickets.items) |ticket|
176 self.allocator.free(ticket.payload);
177 self.tickets.deinit(self.allocator);
178 for (self.secrets.items) |secret|
179 self.allocator.free(secret);
180 self.secrets.deinit(self.allocator);
181 }
182
183 pub fn print(self: Self) !void {
184 std.debug.print(
185 "resumption tag: {}, tickets: {} used_tickets: {}\n",
186 .{ self.hash_tag, self.tickets.items.len, self.used_tickets },
187 );
188 for (self.tickets.items) |ticket| {
189 std.debug.print(
190 " lifetime: {}, ticket age add: {}, nonce: {x}\n ticket: {x}\n secret: {x}\n\n",
191 .{ ticket.lifetime, ticket.age_add, ticket.nonce, ticket.identity, ticket.secret },
192 );
193 }
194 }
195 };
196};
197
198const ResumptionTicket = Options.SessionResumption.Ticket;
199
200const supported_named_groups = &[_]proto.NamedGroup{
201 .x25519,
202 .secp256r1,
203 .secp384r1,
204 .x25519_ml_kem768,
205};
206
207/// Handshake parses tls server message and creates client messages. Collects
208/// tls attributes: server random, cipher suite and so on. Client messages are
209/// created using provided buffer. Provided record reader is used to get tls
210/// record when needed.
211pub const Handshake = struct {
212 /// Underlying network connection stream reader/writer pair.
213 input: *Io.Reader,
214 output: *Io.Writer,
215
216 client_random: [32]u8 = undefined,
217 server_random: [32]u8 = undefined,
218 master_secret: [48]u8 = undefined,
219 key_material: [48 * 4]u8 = undefined, // for sha256 32 * 4 is filled, for sha384 48 * 4
220
221 transcript: Transcript = .{},
222 cipher_suite: CipherSuite = @fromBackingInt(@intCast(0)),
223 named_group: ?proto.NamedGroup = null,
224 dh_kp: DhKeyPair = undefined,
225 rsa_secret: RsaSecret = undefined,
226 tls_version: proto.Version = .tls_1_2,
227 cipher: Cipher = undefined,
228 cert: CertificateParser = undefined,
229 client_certificate_requested: bool = false,
230 // public key len: x25519 = 32, secp256r1 = 65, secp384r1 = 97, x25519_ml_kem768 = 1120
231 server_pub_key_buf: [1120]u8 = undefined,
232 server_pub_key: []const u8 = undefined,
233 pre_shared_selected_identity: ?u16 = null,
234 // statistics
235 max_server_record_len: usize = 0,
236 max_server_cleartext_len: usize = 0,
237 max_client_record_len: usize = 0,
238
239 const Self = @This();
240
241 fn initKeys(h: *Self, opt: Options) !void {
242 const init_keys_buf_len = 32 + 46 + DhKeyPair.seed_len;
243 var buf: [init_keys_buf_len]u8 = undefined;
244 rng.fill(&buf);
245
246 h.client_random = buf[0..32].*;
247 h.rsa_secret = RsaSecret.init(buf[32..][0..46].*);
248 h.dh_kp = try DhKeyPair.init(buf[32 + 46 ..][0..DhKeyPair.seed_len].*, opt.named_groups);
249
250 h.cert = .{
251 .host = opt.host,
252 .root_ca = opt.root_ca,
253 .skip_verify = opt.insecure_skip_verify,
254 };
255 }
256
257 /// Handshake exchanges messages with server to get agreement about
258 /// cryptographic parameters. That upgrades existing client-server
259 /// connection to TLS connection. Returns cipher used in application for
260 /// encrypted message exchange.
261 ///
262 /// Handles TLS 1.2 and TLS 1.3 connections. After initial client hello
263 /// server chooses in its server hello which TLS version will be used.
264 ///
265 /// TLS 1.2 handshake messages exchange:
266 /// Client Server
267 /// --------------------------------------------------------------
268 /// ClientHello client flight 1 --->
269 /// ServerHello
270 /// Certificate
271 /// ServerKeyExchange
272 /// CertificateRequest*
273 /// <--- server flight 1 ServerHelloDone
274 /// Certificate*
275 /// ClientKeyExchange
276 /// CertificateVerify*
277 /// ChangeCipherSpec
278 /// Finished client flight 2 --->
279 /// ChangeCipherSpec
280 /// <--- server flight 2 Finished
281 ///
282 /// TLS 1.3 handshake messages exchange:
283 /// Client Server
284 /// --------------------------------------------------------------
285 /// ClientHello client flight 1 --->
286 /// ServerHello
287 /// {EncryptedExtensions}
288 /// {CertificateRequest*}
289 /// {Certificate}
290 /// {CertificateVerify}
291 /// <--- server flight 1 {Finished}
292 /// ChangeCipherSpec
293 /// {Certificate*}
294 /// {CertificateVerify*}
295 /// Finished client flight 2 --->
296 ///
297 /// * - optional
298 /// {} - encrypted
299 ///
300 /// References:
301 /// https://datatracker.ietf.org/doc/html/rfc5246#section-7.3
302 /// https://datatracker.ietf.org/doc/html/rfc8446#section-2
303 ///
304 pub fn handshake(h: *Self, opt: Options) !struct { Cipher, ?usize } {
305 var resumption_ticket: ?ResumptionTicket =
306 if (opt.session_resumption) |r|
307 r.popTicket()
308 else
309 null;
310
311 defer h.updateDiagnostic(opt, resumption_ticket != null);
312 try h.initKeys(opt);
313
314 if (resumption_ticket) |ticket| {
315 h.transcript.use(opt.session_resumption.?.hash_tag);
316 h.transcript.setPreSharedSecret(ticket.secret, ticket.nonce);
317 }
318
319 try h.makeClientHello(opt, resumption_ticket); // client flight 1
320 h.max_client_record_len = h.output.end;
321 try h.output.flush();
322
323 try h.readServerFlight1(); // server flight 1
324
325 if (resumption_ticket != null and h.pre_shared_selected_identity == null) {
326 // server didn't accept resuption
327 resumption_ticket = null;
328 h.transcript.clearPreSharedSecret();
329 }
330
331 if (resumption_ticket != null and h.cipher_suite.hash() != h.transcript.tag)
332 return error.TlsAlertIllegalParameter; // session resumption must use same hash as previous session
333 h.transcript.use(h.cipher_suite.hash());
334
335 // tls 1.3 specific handshake part
336 if (h.tls_version == .tls_1_3) {
337 try h.generateHandshakeCipher(opt.key_log_callback);
338 try h.readEncryptedServerFlight1(resumption_ticket != null); // server flight 1
339 const app_cipher = try h.generateApplicationCipher(opt.key_log_callback);
340 try h.makeClientFlight2Tls13(opt.auth); // client flight 2
341 h.max_client_record_len = @max(h.max_client_record_len, h.output.end);
342 try h.output.flush();
343
344 const secret_idx: ?usize = if (opt.session_resumption) |r|
345 try r.appendSecret(h.transcript.tag, h.transcript.resumptionSecret())
346 else
347 null;
348
349 return .{ app_cipher, secret_idx };
350 }
351
352 // tls 1.2 specific handshake part
353 try h.generateCipher(opt.key_log_callback);
354 try h.makeClientFlight2Tls12(opt.auth); // client flight 2
355 h.max_client_record_len = @max(h.max_client_record_len, h.output.end);
356 try h.output.flush();
357 try h.readServerFlight2(); // server flight 2
358 return .{ h.cipher, null };
359 }
360
361 fn clientFlight1(h: *Self, opt: Options) !void {
362 try h.makeClientHello(opt, null);
363 }
364
365 fn serverFlight1(h: *Self, opt: Options) !void {
366 try h.readServerFlight1();
367 h.transcript.use(h.cipher_suite.hash());
368 if (h.tls_version == .tls_1_3) {
369 try h.generateHandshakeCipher(opt.key_log_callback);
370 try h.readEncryptedServerFlight1(false);
371 }
372 }
373
374 fn clientFlight2(h: *Self, opt: Options) !void {
375 if (h.tls_version == .tls_1_3) {
376 const app_cipher = try h.generateApplicationCipher(opt.key_log_callback);
377 try h.makeClientFlight2Tls13(opt.auth);
378 h.cipher = app_cipher;
379 } else {
380 // tls 1.2 specific handshake part
381 try h.generateCipher(opt.key_log_callback);
382 try h.makeClientFlight2Tls12(opt.auth);
383 }
384 }
385
386 fn serverFlight2(h: *Self, _: Options) !void {
387 if (h.tls_version == .tls_1_3) return;
388 try h.readServerFlight2();
389 }
390
391 /// Prepare key material and generate cipher for TLS 1.2
392 fn generateCipher(h: *Self, key_log_callback: ?key_log.Callback) !void {
393 try h.verifyCertificateSignatureTls12();
394 try h.generateKeyMaterial(key_log_callback);
395 h.cipher = try Cipher.initTls12(h.cipher_suite, &h.key_material, .client);
396 }
397
398 /// Generate TLS 1.2 pre master secret, master secret and key material.
399 fn generateKeyMaterial(h: *Self, key_log_callback: ?key_log.Callback) !void {
400 const pre_master_secret = if (h.named_group) |named_group|
401 try h.dh_kp.sharedKey(named_group, h.server_pub_key)
402 else
403 &h.rsa_secret.secret;
404
405 h.transcript.masterSecret(&h.master_secret, pre_master_secret, h.client_random, h.server_random);
406 h.transcript.keyMaterial(&h.key_material, &h.master_secret, h.client_random, h.server_random);
407
408 if (key_log_callback) |cb| {
409 cb(key_log.label.client_random, &h.client_random, &h.master_secret);
410 }
411 }
412
413 /// TLS 1.3 cipher used during handshake
414 fn generateHandshakeCipher(h: *Self, key_log_callback: ?key_log.Callback) !void {
415 const shared_key = try h.dh_kp.sharedKey(h.named_group.?, h.server_pub_key);
416 const handshake_secret = h.transcript.handshakeSecret(shared_key);
417 if (key_log_callback) |cb| {
418 cb(key_log.label.server_handshake_traffic_secret, &h.client_random, handshake_secret.server);
419 cb(key_log.label.client_handshake_traffic_secret, &h.client_random, handshake_secret.client);
420 }
421 h.cipher = try Cipher.initTls13(h.cipher_suite, handshake_secret, .client);
422 }
423
424 /// TLS 1.3 application (client) cipher
425 fn generateApplicationCipher(h: *Self, key_log_callback: ?key_log.Callback) !Cipher {
426 const application_secret = h.transcript.applicationSecret();
427 if (key_log_callback) |cb| {
428 cb(key_log.label.server_traffic_secret_0, &h.client_random, application_secret.server);
429 cb(key_log.label.client_traffic_secret_0, &h.client_random, application_secret.client);
430 }
431 return try Cipher.initTls13(h.cipher_suite, application_secret, .client);
432 }
433
434 fn makeClientHello(h: *Self, opt: Options, resumption_ticket: ?ResumptionTicket) !void {
435 // Prepare data
436 const tls_versions = try CipherSuite.versions(opt.cipher_suites);
437 const shared_keys: []const []const u8 = if (tls_versions != .tls_1_2) brk: {
438 var keys: [supported_named_groups.len][]const u8 = undefined;
439 for (opt.named_groups, 0..) |ng, i| {
440 keys[i] = try h.dh_kp.publicKey(ng);
441 }
442 break :brk keys[0..opt.named_groups.len];
443 } else &.{};
444 const supported_versions = switch (tls_versions) {
445 .both => &[_]proto.Version{ .tls_1_3, .tls_1_2 },
446 .tls_1_3 => &[_]proto.Version{.tls_1_3},
447 .tls_1_2 => &[_]proto.Version{.tls_1_2},
448 };
449 const psk_binder_len = if (resumption_ticket == null) 0 else h.transcript.hashLength() + 3;
450
451 var w: record.Writer = .initFromIo(h.output);
452
453 // Placeholder for tls record header (5 bytes) and handshake header (4 bytes).
454 // We will write it when we know payload length.
455 const header_pos = try w.skip(9);
456
457 try w.enumValue(proto.Version.tls_1_2);
458 try w.slice(&h.client_random);
459 try w.byte(0); // no session id
460 try w.enumList(CipherSuite, opt.cipher_suites);
461 try w.slice(&[_]u8{ 0x01, 0x00 }); // no compression
462 // Remeber position to write extensions length
463 const ext_len_pos = try w.skip(2);
464 try w.extension(.supported_versions, supported_versions);
465 try w.extension(.signature_algorithms, common.supported_signature_algorithms);
466 try w.extension(.supported_groups, opt.named_groups);
467 try w.keyShare(opt.named_groups, shared_keys);
468 try w.serverName(opt.host);
469 // binder key placeholder
470 const binder_pos: ?usize = if (resumption_ticket) |ticket| brk: {
471 // Add pre shared key extension if this is session resumption. Must be last extension.
472 try w.extension(.psk_key_exchange_modes, &[_]proto.KeyExchangeModes{.psk_dhe_ke});
473 try w.preSharedKey(ticket.identity, ticket.obfuscatedAge(), psk_binder_len);
474 // Retruns placeholder for binder, we can write binder when we have
475 // hash up to thise point with valid extnsions length and
476 // record header written.
477 break :brk try w.skip(psk_binder_len);
478 } else null;
479
480 // Write extensions length to the placeholder
481 var ew = w.writerAt(ext_len_pos);
482 try ew.int(u16, w.pos() - ext_len_pos - 2);
483 // Writer header to the placeholder
484 var hw = w.writerAt(header_pos);
485 try hw.recordHeader(.handshake, w.pos() - 5);
486 try hw.handshakeRecordHeader(.client_hello, w.pos() - 9);
487
488 const pre_binder_hash_buf = w.buffered()[record.header_len .. w.pos() - psk_binder_len];
489 h.transcript.update(pre_binder_hash_buf);
490
491 if (binder_pos) |pos| {
492 // Write binder to the placeholder and update hash with binder extenstion
493 const binder = h.transcript.pskBinder();
494 var bw = w.writerAt(pos);
495 try bw.preSharedKeyBinder(binder);
496 h.transcript.update(w.buffered()[w.buffered().len - psk_binder_len ..]);
497 }
498
499 h.output.advance(w.buffered().len);
500 }
501
502 /// Process first flight of the messages from the server.
503 /// Read server hello message. If TLS 1.3 is chosen in server hello
504 /// return. For TLS 1.2 continue and read certificate, key_exchange
505 /// eventual certificate request and hello done messages.
506 fn readServerFlight1(h: *Self) !void {
507 var handshake_states: []const proto.Handshake = &.{.server_hello};
508
509 while (true) {
510 var d = try Record.decoder(h.input);
511 try d.expectContentType(.handshake);
512 h.transcript.update(d.payload);
513 h.max_server_record_len = @max(h.max_server_record_len, d.payload.len + record.header_len);
514
515 // Multiple handshake messages can be packed in single tls record.
516 while (!d.eof()) {
517 const handshake_type = try d.decode(proto.Handshake);
518
519 const length = try d.decode(u24);
520 if (length > max_cleartext_len)
521 return error.TlsUnsupportedFragmentedHandshakeMessage;
522
523 brk: {
524 for (handshake_states) |state|
525 if (state == handshake_type) break :brk;
526 return error.TlsUnexpectedMessage;
527 }
528 switch (handshake_type) {
529 .server_hello => { // server hello, ref: https://datatracker.ietf.org/doc/html/rfc5246#section-7.4.1.3
530 try h.parseServerHello(&d, length);
531 if (h.tls_version == .tls_1_3) {
532 if (!d.eof()) return error.TlsIllegalParameter;
533 return; // end of tls 1.3 server flight 1
534 }
535 handshake_states = if (h.cert.skip_verify)
536 &.{ .certificate, .server_key_exchange, .server_hello_done }
537 else
538 &.{.certificate};
539 },
540 .certificate => {
541 try h.cert.parseCertificate(&d, h.tls_version);
542 handshake_states = if (h.cipher_suite.keyExchange() == .rsa)
543 &.{.server_hello_done}
544 else
545 &.{.server_key_exchange};
546 },
547 .server_key_exchange => {
548 try h.parseServerKeyExchange(&d);
549 handshake_states = &.{ .certificate_request, .server_hello_done };
550 },
551 .certificate_request => {
552 h.client_certificate_requested = true;
553 try d.skip(length);
554 handshake_states = &.{.server_hello_done};
555 },
556 .server_hello_done => {
557 if (length != 0) return error.TlsIllegalParameter;
558 return;
559 },
560 else => return error.TlsUnexpectedMessage,
561 }
562 }
563 }
564 }
565
566 /// Parse server hello message.
567 fn parseServerHello(h: *Self, d: *record.Decoder, length: u24) !void {
568 if (try d.decode(proto.Version) != proto.Version.tls_1_2)
569 return error.TlsBadVersion;
570 h.server_random = try d.array(32);
571 if (isServerHelloRetryRequest(&h.server_random))
572 return error.TlsServerHelloRetryRequest;
573
574 const session_id_len = try d.decode(u8);
575 if (session_id_len > 32) return error.TlsIllegalParameter;
576 try d.skip(session_id_len);
577
578 h.cipher_suite = try d.decode(CipherSuite);
579 try h.cipher_suite.validate();
580 try d.skip(1); // skip compression method
581
582 const extensions_present = length > 2 + 32 + 1 + session_id_len + 2 + 1;
583 if (extensions_present) {
584 const exs_len = try d.decode(u16);
585 var l: usize = 0;
586 while (l < exs_len) {
587 const typ = try d.decode(proto.Extension);
588 const len = try d.decode(u16);
589 defer l += len + 4;
590
591 switch (typ) {
592 .supported_versions => {
593 switch (try d.decode(proto.Version)) {
594 .tls_1_2, .tls_1_3 => |v| h.tls_version = v,
595 else => return error.TlsIllegalParameter,
596 }
597 if (len != 2) return error.TlsIllegalParameter;
598 },
599 .key_share => {
600 h.named_group = try d.decode(proto.NamedGroup);
601 h.server_pub_key = try common.dupe(&h.server_pub_key_buf, try d.slice(try d.decode(u16)));
602 if (len != h.server_pub_key.len + 4) return error.TlsIllegalParameter;
603 },
604 .pre_shared_key => {
605 h.pre_shared_selected_identity = try d.decode(u16);
606 },
607 else => {
608 try d.skip(len);
609 },
610 }
611 }
612 }
613 }
614
615 fn isServerHelloRetryRequest(server_random: []const u8) bool {
616 // Ref: https://datatracker.ietf.org/doc/html/rfc8446#section-4.1.3
617 const hello_retry_request_magic = [32]u8{
618 0xCF, 0x21, 0xAD, 0x74, 0xE5, 0x9A, 0x61, 0x11, 0xBE, 0x1D, 0x8C, 0x02, 0x1E, 0x65, 0xB8, 0x91,
619 0xC2, 0xA2, 0x11, 0x16, 0x7A, 0xBB, 0x8C, 0x5E, 0x07, 0x9E, 0x09, 0xE2, 0xC8, 0xA8, 0x33, 0x9C,
620 };
621 return mem.eql(u8, server_random, &hello_retry_request_magic);
622 }
623
624 fn parseServerKeyExchange(h: *Self, d: *record.Decoder) !void {
625 const curve_type = try d.decode(proto.Curve);
626 h.named_group = try d.decode(proto.NamedGroup);
627 h.server_pub_key = try common.dupe(&h.server_pub_key_buf, try d.slice(try d.decode(u8)));
628 h.cert.signature_scheme = try d.decode(proto.SignatureScheme);
629 h.cert.signature = try common.dupe(&h.cert.signature_buf, try d.slice(try d.decode(u16)));
630 if (curve_type != .named_curve) return error.TlsIllegalParameter;
631 }
632
633 /// Read encrypted part (after server hello) of the server first flight
634 /// for TLS 1.3: change cipher spec, eventual certificate request,
635 /// certificate, certificate verify and handshake finished messages.
636 fn readEncryptedServerFlight1(h: *Self, is_session_resumption: bool) !void {
637 // buffer for decrypted handshake records
638 var cleartext_buffer: [max_cleartext_len]u8 = undefined;
639 // cleartext writer
640 var cw = Io.Writer.fixed(&cleartext_buffer);
641 // valid handshake types for the next record
642 var handshake_states: []const proto.Handshake = &.{.encrypted_extensions};
643
644 outer: while (true) {
645 // wrapped record decoder
646 const rec = try Record.read(h.input);
647 if (rec.protocol_version != .tls_1_2) return error.TlsBadVersion;
648 h.max_server_record_len = @max(h.max_server_record_len, rec.buffer.len);
649 switch (rec.content_type) {
650 .change_cipher_spec => {},
651 .application_data => {
652 // `decrypt` will return TlsCipherNoSpaceLeft
653 // unusedCapacitySlice is too small to hold cleartext
654 const content_type, const cleartext = try h.cipher.decrypt(cw.unusedCapacitySlice(), rec);
655 cw.advance(cleartext.len);
656 h.max_server_cleartext_len = @max(h.max_server_cleartext_len, cw.end);
657
658 var d = record.Decoder.init(content_type, cw.buffered());
659 try d.expectContentType(.handshake);
660 while (!d.eof()) {
661 const handshake_type = try d.decode(proto.Handshake);
662 const length = try d.decode(u24);
663
664 if (length > max_cleartext_len)
665 return error.TlsUnsupportedFragmentedHandshakeMessage;
666 if (length > d.rest().len)
667 continue :outer; // handshake fragmented into multiple records
668 // jump to outer must be before this defer to presrve buffers
669 defer {
670 // 'd.idx' data is consumed
671 h.transcript.update(d.payload[0..d.idx]);
672 _ = cw.consume(d.idx);
673 d = record.Decoder.init(content_type, cw.buffered());
674 }
675 // check valid handshake types in this state
676 brk: {
677 for (handshake_states) |state|
678 if (state == handshake_type) break :brk;
679 return error.TlsUnexpectedMessage;
680 }
681 switch (handshake_type) {
682 .encrypted_extensions => {
683 try d.skip(length);
684 handshake_states = if (is_session_resumption)
685 &.{ .certificate_request, .certificate, .finished }
686 else if (h.cert.skip_verify)
687 &.{ .certificate_request, .certificate, .finished }
688 else
689 &.{ .certificate_request, .certificate };
690 },
691 .certificate_request => {
692 h.client_certificate_requested = true;
693 try d.skip(length);
694 handshake_states = if (h.cert.skip_verify)
695 &.{ .certificate, .finished }
696 else
697 &.{.certificate};
698 },
699 .certificate => {
700 try h.cert.parseCertificate(&d, h.tls_version);
701 handshake_states = &.{.certificate_verify};
702 },
703 .certificate_verify => {
704 try h.cert.parseCertificateVerify(&d);
705 try h.cert.verifySignature(h.transcript.serverCertificateVerify());
706 handshake_states = &.{.finished};
707 },
708 .finished => {
709 const actual = try d.slice(length);
710 const expected = h.transcript.serverFinishedTls13();
711 if (!mem.eql(u8, expected, actual))
712 return error.TlsDecryptError;
713 return;
714 },
715 else => return error.TlsUnexpectedMessage,
716 }
717 }
718 },
719 else => return error.TlsUnexpectedMessage,
720 }
721 }
722 }
723
724 fn verifyCertificateSignatureTls12(h: *Self) !void {
725 if (h.cipher_suite.keyExchange() != .ecdhe) return;
726 const verify_bytes = brk: {
727 var buffer: [h.server_pub_key_buf.len + 128]u8 = undefined;
728 var w = Io.Writer.fixed(&buffer);
729 try w.writeAll(&h.client_random);
730 try w.writeAll(&h.server_random);
731 try w.writeByte(@backingInt(proto.Curve.named_curve));
732 try w.writeInt(u16, @backingInt(h.named_group.?), .big);
733 try w.writeByte(@intCast(h.server_pub_key.len));
734 try w.writeAll(h.server_pub_key);
735 break :brk w.buffered();
736 };
737 try h.cert.verifySignature(verify_bytes);
738 }
739
740 /// Create client key exchange, change cipher spec and handshake
741 /// finished messages for tls 1.2.
742 /// If client certificate is requested also adds client certificate and
743 /// certificate verify messages.
744 fn makeClientFlight2Tls12(h: *Self, auth: ?*CertKeyPair) !void {
745 var w: record.Writer = .initFromIo(h.output);
746 var cert_builder: ?CertificateBuilder = null;
747
748 // Client certificate
749 if (h.client_certificate_requested) {
750 if (auth) |a| {
751 const cb = h.certificateBuilder(a);
752 cert_builder = cb;
753 var hw = try w.writerAdvance(record.header_len);
754 try cb.makeCertificate(&hw);
755 h.transcript.update(hw.buffered());
756 try w.record(.handshake, hw.buffered());
757 } else {
758 var hw = try w.writerAdvance(record.header_len);
759 try hw.handshakeRecord(.certificate, &[_]u8{ 0, 0, 0 });
760 h.transcript.update(hw.buffered());
761 try w.record(.handshake, hw.buffered());
762 }
763 }
764
765 { // Client key exchange
766 var hw = try w.writerAdvance(record.header_len);
767 if (h.named_group) |named_group| {
768 const key = try h.dh_kp.publicKey(named_group);
769 try hw.handshakeRecordHeader(.client_key_exchange, 1 + key.len);
770 try hw.int(u8, key.len);
771 try hw.slice(key);
772 } else {
773 var key_buf: [512]u8 = undefined;
774 const key = try h.rsa_secret.encrypted(&key_buf, h.cert.pub_key_algo, h.cert.pub_key);
775 try hw.handshakeRecordHeader(.client_key_exchange, 2 + key.len);
776 try hw.int(u16, key.len);
777 try hw.slice(key);
778 }
779 h.transcript.update(hw.buffered());
780 try w.record(.handshake, hw.buffered());
781 }
782
783 // Client certificate verify
784 if (cert_builder) |cb| {
785 var hw = try w.writerAdvance(record.header_len);
786 try cb.makeCertificateVerify(&hw);
787 h.transcript.update(hw.buffered());
788 try w.record(.handshake, hw.buffered());
789 }
790
791 // Client change cipher spec
792 try w.record(.change_cipher_spec, &[_]u8{1});
793
794 { // Client handshake finished
795 const client_finished = &record.handshakeHeader(.finished, 12) ++
796 h.transcript.clientFinishedTls12(&h.master_secret);
797 h.transcript.update(client_finished);
798 try h.writeEncrypted(&w, client_finished);
799 }
800
801 h.output.advance(w.buffered().len);
802 }
803
804 /// Create client change cipher spec and handshake finished messages for
805 /// tls 1.3.
806 /// If the client certificate is requested by the server and client is
807 /// configured with certificates and private key then client certificate
808 /// and client certificate verify messages are also created. If the
809 /// server has requested certificate but the client is not configured
810 /// empty certificate message is sent, as is required by rfc.
811 fn makeClientFlight2Tls13(h: *Self, auth: ?*CertKeyPair) !void {
812 var w: record.Writer = .initFromIo(h.output);
813
814 // Client change cipher spec
815 try w.record(.change_cipher_spec, &[_]u8{1});
816
817 if (h.client_certificate_requested) {
818 if (auth) |a| {
819 const cb = h.certificateBuilder(a);
820 { // Certificate
821 var hw = try w.writerAdvance(record.header_len);
822 try cb.makeCertificate(&hw);
823 h.transcript.update(hw.buffered());
824 try h.writeEncrypted(&w, hw.buffered());
825 }
826 { // Client certificate
827 var hw = try w.writerAdvance(record.header_len);
828 try cb.makeCertificateVerify(&hw);
829 h.transcript.update(hw.buffered());
830 try h.writeEncrypted(&w, hw.buffered());
831 }
832 } else {
833 // Empty certificate message and no certificate verify message
834 var hw = try w.writerAdvance(record.header_len);
835 try hw.handshakeRecord(.certificate, &[_]u8{ 0, 0, 0, 0 });
836 h.transcript.update(hw.buffered());
837 try h.writeEncrypted(&w, hw.buffered());
838 }
839 }
840
841 { // Finished
842 var hw = try w.writerAdvance(record.header_len);
843 try hw.handshakeRecord(.finished, h.transcript.clientFinishedTls13());
844 h.transcript.update(hw.buffered());
845 try h.writeEncrypted(&w, hw.buffered());
846 }
847
848 h.output.advance(w.buffered().len);
849 }
850
851 fn certificateBuilder(h: *Self, auth: *CertKeyPair) CertificateBuilder {
852 return .{
853 .cert_key_pair = auth,
854 .transcript = &h.transcript,
855 .tls_version = h.tls_version,
856 .side = .client,
857 };
858 }
859
860 fn readServerFlight2(h: *Self) !void {
861 // Read server change cipher spec message.
862 {
863 var d = try Record.decoder(h.input);
864 try d.expectContentType(.change_cipher_spec);
865 h.max_server_record_len = @max(h.max_server_record_len, d.payload.len + record.header_len);
866 }
867 // Read encrypted server handshake finished message. Verify that
868 // content of the server finished message is based on transcript
869 // hash and master secret.
870 {
871 const rec = try Record.read(h.input);
872 h.max_server_record_len = @max(h.max_server_record_len, rec.buffer.len);
873 const content_type, const server_finished = try h.cipher.decrypt(@constCast(rec.buffer), rec);
874 if (content_type != .handshake)
875 return error.TlsUnexpectedMessage;
876 const expected = record.handshakeHeader(.finished, 12) ++ h.transcript.serverFinishedTls12(&h.master_secret);
877 if (!mem.eql(u8, server_finished, &expected))
878 return error.TlsBadRecordMac;
879 }
880 }
881
882 /// Write encrypted handshake message into `w`
883 fn writeEncrypted(h: *Self, w: *record.Writer, cleartext: []const u8) !void {
884 const ciphertext = try h.cipher.encrypt(w.unused(), .handshake, cleartext);
885 w.advance(ciphertext.len);
886 }
887
888 // Copy handshake parameters to opt.diagnostic
889 fn updateDiagnostic(h: *Self, opt: Options, is_session_resumption: bool) void {
890 if (opt.diagnostic) |d| {
891 d.tls_version = h.tls_version;
892 d.cipher_suite_tag = h.cipher_suite;
893 d.named_group = h.named_group orelse @as(proto.NamedGroup, @fromBackingInt(@intCast(0x0000)));
894 d.signature_scheme = h.cert.signature_scheme;
895 d.is_session_resumption = is_session_resumption;
896 d.max_server_record_len = h.max_server_record_len;
897 d.max_server_cleartext_len = h.max_server_cleartext_len;
898 d.max_client_record_len = h.max_client_record_len;
899 if (opt.auth) |a|
900 d.client_signature_scheme = a.key.signature_scheme;
901 }
902 }
903};
904
905const RsaSecret = struct {
906 secret: [48]u8,
907
908 fn init(rand: [46]u8) RsaSecret {
909 return .{ .secret = [_]u8{ 0x03, 0x03 } ++ rand };
910 }
911
912 // Pre master secret encrypted with certificate public key.
913 fn encrypted(
914 self: RsaSecret,
915 out: *[512]u8,
916 cert_pub_key_algo: Certificate.Parsed.PubKeyAlgo,
917 cert_pub_key: []const u8,
918 ) ![]const u8 {
919 if (cert_pub_key_algo != .rsaEncryption) return error.TlsBadSignatureScheme;
920 const pk = try rsa.PublicKey.fromDer(cert_pub_key);
921 return try pk.encryptPkcsv1_5(&self.secret, out);
922 }
923};
924
925const testing = std.testing;
926const data12 = @import("testdata/tls12.zig");
927const data13 = @import("testdata/tls13.zig");
928const testu = @import("testu.zig");
929
930test "parse tls 1.2 server hello" {
931 var buffer: [1024]u8 = undefined;
932 var writer: Io.Writer = .fixed(&buffer);
933 var reader: Io.Reader = .fixed(&data12.server_hello_responses);
934 var h: Handshake = .{
935 .output = &writer,
936 .input = &reader,
937 .client_random = data12.client_random,
938 };
939 // Set to known instead of random
940 h.dh_kp.x25519_kp.secret_key = data12.client_secret;
941
942 // Parse server hello, certificate and key exchange messages.
943 // Read cipher suite, named group, signature scheme, server random certificate public key
944 // Verify host name, signature
945 // Calculate key material
946 h.cert = .{ .host = "example.ulfheim.net", .skip_verify = true, .root_ca = .empty };
947 try h.readServerFlight1();
948 try testing.expectEqual(.ECDHE_RSA_WITH_AES_128_CBC_SHA, h.cipher_suite);
949 try testing.expectEqual(.x25519, h.named_group.?);
950 try testing.expectEqual(.rsa_pkcs1_sha256, h.cert.signature_scheme);
951 try testing.expectEqualSlices(u8, &data12.server_random, &h.server_random);
952 try testing.expectEqualSlices(u8, &data12.server_pub_key, h.server_pub_key);
953 try testing.expectEqualSlices(u8, &data12.signature, h.cert.signature);
954 try testing.expectEqualSlices(u8, &data12.cert_pub_key, h.cert.pub_key);
955
956 try h.verifyCertificateSignatureTls12();
957 try h.generateKeyMaterial(null);
958
959 try testing.expectEqualSlices(u8, &data12.key_material, h.key_material[0..data12.key_material.len]);
960}
961
962test "verify google.com certificate" {
963 var buffer: [1024]u8 = undefined;
964 var writer: Io.Writer = .fixed(&buffer);
965 var reader: Io.Reader = .fixed(@embedFile("testdata/google.com/server_hello"));
966 var h: Handshake = .{
967 .output = &writer,
968 .input = &reader,
969 .client_random = @embedFile("testdata/google.com/client_random").*,
970 };
971
972 var ca_bundle: Certificate.Bundle = .empty;
973 try ca_bundle.rescan(testing.allocator);
974 defer ca_bundle.deinit(testing.allocator);
975
976 h.cert = .{ .host = "google.com", .skip_verify = true, .root_ca = .empty, .now_sec = 1714846451 };
977 try h.readServerFlight1();
978 try h.verifyCertificateSignatureTls12();
979}
980
981test "parse tls 1.3 server hello" {
982 var reader: Io.Reader = .fixed(&data13.server_hello);
983 var d = try Record.decoder(&reader);
984
985 const handshake_type = try d.decode(proto.Handshake);
986 const length = try d.decode(u24);
987 try testing.expectEqual(0x000076, length);
988 try testing.expectEqual(.server_hello, handshake_type);
989
990 var h: Handshake = undefined;
991 try h.parseServerHello(&d, length);
992
993 try testing.expectEqual(.AES_256_GCM_SHA384, h.cipher_suite);
994 try testing.expectEqualSlices(u8, &data13.server_random, &h.server_random);
995 try testing.expectEqual(.tls_1_3, h.tls_version);
996 try testing.expectEqual(.x25519, h.named_group);
997 try testing.expectEqualSlices(u8, &data13.server_pub_key, h.server_pub_key);
998}
999
1000test "init tls 1.3 handshake cipher" {
1001 const cipher_suite_tag: CipherSuite = .AES_256_GCM_SHA384;
1002
1003 var transcript = Transcript{};
1004 transcript.use(cipher_suite_tag.hash());
1005 transcript.update(data13.client_hello[record.header_len..]);
1006 transcript.update(data13.server_hello[record.header_len..]);
1007
1008 var dh_kp = DhKeyPair{
1009 .x25519_kp = .{
1010 .public_key = data13.client_public_key,
1011 .secret_key = data13.client_private_key,
1012 },
1013 };
1014 const shared_key = try dh_kp.sharedKey(.x25519, &data13.server_pub_key);
1015 try testing.expectEqualSlices(u8, &data13.shared_key, shared_key);
1016
1017 const cipher = try Cipher.initTls13(cipher_suite_tag, transcript.handshakeSecret(shared_key), .client);
1018
1019 const c = &cipher.AES_256_GCM_SHA384;
1020 try testing.expectEqualSlices(u8, &data13.server_handshake_key, &c.decrypt_key);
1021 try testing.expectEqualSlices(u8, &data13.client_handshake_key, &c.encrypt_key);
1022 try testing.expectEqualSlices(u8, &data13.server_handshake_iv, &c.decrypt_iv);
1023 try testing.expectEqualSlices(u8, &data13.client_handshake_iv, &c.encrypt_iv);
1024}
1025
1026fn initExampleHandshake(h: *Handshake) !void {
1027 h.cipher_suite = .AES_256_GCM_SHA384;
1028 h.transcript.use(h.cipher_suite.hash());
1029 h.transcript.update(data13.client_hello[record.header_len..]);
1030 h.transcript.update(data13.server_hello[record.header_len..]);
1031 h.cipher = try Cipher.initTls13(h.cipher_suite, h.transcript.handshakeSecret(&data13.shared_key), .client);
1032 h.tls_version = .tls_1_3;
1033 h.cert.now_sec = 1714846451;
1034 h.server_pub_key = &data13.server_pub_key;
1035}
1036
1037test "tls 1.3 decrypt wrapped record" {
1038 var cipher = brk: {
1039 var h: Handshake = .{ .input = undefined, .output = undefined };
1040 try initExampleHandshake(&h);
1041 break :brk h.cipher;
1042 };
1043
1044 var cleartext_buf: [1024]u8 = undefined;
1045 {
1046 const rec = record.Record.init(&data13.server_encrypted_extensions_wrapped);
1047
1048 const content_type, const cleartext = try cipher.decrypt(&cleartext_buf, rec);
1049 try testing.expectEqual(.handshake, content_type);
1050 try testing.expectEqualSlices(u8, &data13.server_encrypted_extensions, cleartext);
1051 }
1052 {
1053 const rec = record.Record.init(&data13.server_certificate_wrapped);
1054
1055 const content_type, const cleartext = try cipher.decrypt(&cleartext_buf, rec);
1056 try testing.expectEqual(.handshake, content_type);
1057 try testing.expectEqualSlices(u8, &data13.server_certificate, cleartext);
1058 }
1059}
1060
1061test "tls 1.3 process server flight" {
1062 var h: Handshake = brk: {
1063 var buffer: [1024]u8 = undefined;
1064 var writer: Io.Writer = .fixed(&buffer);
1065 var reader: Io.Reader = .fixed(&data13.server_flight);
1066 break :brk .{ .input = &reader, .output = &writer };
1067 };
1068 try initExampleHandshake(&h);
1069
1070 h.cert = .{ .host = "example.ulfheim.net", .skip_verify = true, .root_ca = .empty };
1071 try h.readEncryptedServerFlight1(false);
1072
1073 { // application cipher keys calculation
1074 try testing.expectEqualSlices(u8, &data13.handshake_hash, &h.transcript.sha384.hash.peek());
1075
1076 var cipher = try Cipher.initTls13(h.cipher_suite, h.transcript.applicationSecret(), .client);
1077 const c = &cipher.AES_256_GCM_SHA384;
1078 try testing.expectEqualSlices(u8, &data13.server_application_key, &c.decrypt_key);
1079 try testing.expectEqualSlices(u8, &data13.client_application_key, &c.encrypt_key);
1080 try testing.expectEqualSlices(u8, &data13.server_application_iv, &c.decrypt_iv);
1081 try testing.expectEqualSlices(u8, &data13.client_application_iv, &c.encrypt_iv);
1082
1083 var buffer: [128]u8 = undefined;
1084 const encrypted = try cipher.encrypt(&buffer, .application_data, "ping");
1085 try testing.expectEqualSlices(u8, &data13.client_ping_wrapped, encrypted);
1086 }
1087 { // client finished message
1088 const verify_data = h.transcript.clientFinishedTls13();
1089 try testing.expectEqualSlices(u8, &data13.client_finished_verify_data, verify_data);
1090
1091 var buffer: [128]u8 = undefined;
1092 var w: Io.Writer = .fixed(&buffer);
1093 h.output = &w;
1094 try h.makeClientFlight2Tls13(null);
1095 try testing.expectEqualSlices(u8, &testu.hexToBytes("140303000101"), w.buffered()[0..6]);
1096 try testing.expectEqualSlices(u8, &data13.client_finished_wrapped, w.buffered()[6..]);
1097 }
1098}
1099
1100test "create client hello" {
1101 const expected = testu.hexToBytes(
1102 "16 03 03 00 6d " ++ // record header
1103 "01 00 00 69 " ++ // handshake header
1104 "03 03 " ++ // protocol version
1105 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " ++ // client random
1106 "00 " ++ // no session id
1107 "00 02 c0 2b " ++ // cipher suites
1108 "01 00 " ++ // compression methods
1109 "00 3e " ++ // extensions length
1110 "00 2b 00 03 02 03 03 " ++ // supported versions extension
1111 "00 0d 00 14 00 12 04 03 05 03 08 04 08 05 08 06 08 07 02 01 04 01 05 01 " ++ // signature algorithms extension
1112 "00 0a 00 08 00 06 00 1d 00 17 00 18 " ++ // named groups extension
1113 "00 00 00 0f 00 0d 00 00 0a 67 6f 6f 67 6c 65 2e 63 6f 6d ", // server name extension
1114 );
1115
1116 var h = brk: {
1117 var buffer: [256 + 10]u8 = undefined; // reserved + host name len
1118 var stream_writer: Io.Writer = .fixed(&buffer);
1119 break :brk Handshake{
1120 .output = &stream_writer,
1121 .input = undefined,
1122 .client_random = testu.hexToBytes(
1123 \\ 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
1124 ),
1125 };
1126 };
1127
1128 try h.makeClientHello(.{
1129 .host = "google.com",
1130 .root_ca = .empty,
1131 .cipher_suites = &[_]CipherSuite{CipherSuite.ECDHE_ECDSA_WITH_AES_128_GCM_SHA256},
1132 .named_groups = &[_]proto.NamedGroup{ .x25519, .secp256r1, .secp384r1 },
1133 }, null);
1134
1135 const actual = h.output.buffered();
1136 try testing.expectEqualSlices(u8, &expected, actual);
1137 try testing.expectEqual(152, h.output.unusedCapacityLen());
1138 try testing.expectEqual(114, expected.len);
1139}
1140
1141test "client hello size" {
1142 const opt: Options = .{
1143 .host = "some-host-name.net",
1144 .root_ca = .empty,
1145 .cipher_suites = cipher_suites.all,
1146 //.named_groups = supported_named_groups,
1147 };
1148
1149 var buffer: [max_cleartext_len]u8 = undefined;
1150 var stream_writer: Io.Writer = .fixed(&buffer);
1151 var h = Handshake{
1152 .output = &stream_writer,
1153 .input = undefined,
1154 };
1155 try h.initKeys(opt);
1156 try h.makeClientHello(opt, null);
1157 try testing.expectEqual(1572 + opt.host.len, h.output.end);
1158 //try testing.expectEqual(2794 + opt.host.len, h.stream_writer.end);
1159}
1160
1161test "handshake verify server finished message" {
1162 var h: Handshake = brk: {
1163 var buffer: [1024]u8 = undefined;
1164 var writer: Io.Writer = .fixed(&buffer);
1165 var reader: Io.Reader = .fixed(&data12.server_handshake_finished_msgs);
1166 break :brk .{ .input = &reader, .output = &writer };
1167 };
1168
1169 h.cipher_suite = .ECDHE_ECDSA_WITH_AES_128_CBC_SHA;
1170 h.master_secret = data12.master_secret;
1171
1172 // add handshake messages to the transcript
1173 for (data12.handshake_messages) |msg| {
1174 h.transcript.update(msg[record.header_len..]);
1175 }
1176
1177 // expect verify data
1178 const client_finished = h.transcript.clientFinishedTls12(&h.master_secret);
1179 try testing.expectEqualSlices(u8, &data12.client_finished, &record.handshakeHeader(.finished, 12) ++ client_finished);
1180
1181 // init client with prepared key_material
1182 h.cipher = try Cipher.initTls12(.ECDHE_RSA_WITH_AES_128_CBC_SHA, &data12.key_material, .client);
1183
1184 // check that server verify data matches calculates from hashes of all handshake messages
1185 h.transcript.update(&data12.client_finished);
1186 try h.readServerFlight2();
1187}
1188
1189pub const NonBlock = struct {
1190 const Self = @This();
1191
1192 // inner sync handshake
1193 inner: Handshake = undefined,
1194 opt: Options = undefined,
1195 state: State = .none,
1196
1197 const State = enum {
1198 none,
1199 init,
1200 client_flight_1,
1201 server_flight_1,
1202 client_flight_2,
1203 server_flight_2,
1204
1205 fn next(self: *State) void {
1206 self.* = @fromBackingInt(@intCast(@backingInt(self.*) + 1));
1207 }
1208 };
1209
1210 pub fn init(opt: Options) Self {
1211 var inner = Handshake{
1212 .input = undefined,
1213 .output = undefined,
1214 };
1215 inner.initKeys(opt) catch unreachable;
1216 return .{
1217 .inner = inner,
1218 .opt = opt,
1219 .state = .init,
1220 };
1221 }
1222
1223 fn send(self: *Self) !void {
1224 switch (self.state) {
1225 .init => {
1226 try self.inner.clientFlight1(self.opt);
1227 self.state.next();
1228 },
1229 .server_flight_1 => {
1230 try self.inner.clientFlight2(self.opt);
1231 self.state.next();
1232 if (self.done()) self.inner.updateDiagnostic(self.opt, false);
1233 },
1234 else => return,
1235 }
1236 }
1237
1238 fn recv(self: *Self) !void {
1239 const prev: Transcript = self.inner.transcript;
1240 errdefer self.inner.transcript = prev;
1241
1242 switch (self.state) {
1243 .client_flight_1 => {
1244 try self.inner.serverFlight1(self.opt);
1245 self.state.next();
1246 },
1247 .client_flight_2 => {
1248 try self.inner.serverFlight2(self.opt);
1249 self.state.next();
1250 if (self.done()) self.inner.updateDiagnostic(self.opt, false);
1251 },
1252 else => return,
1253 }
1254 }
1255
1256 /// True when handshake is successfully finished
1257 pub fn done(self: Self) bool {
1258 return self.state == .server_flight_2 or
1259 (self.inner.tls_version == .tls_1_3 and self.state == .client_flight_2);
1260 }
1261
1262 /// Runs next handshake step.
1263 pub fn run(
1264 self: *Self,
1265 /// Data received from the peer
1266 recv_buf: []const u8,
1267 /// Scratch buffer where data to be sent to the peer will be prepared
1268 send_buf: []u8,
1269 ) !struct {
1270 /// Number of bytes consumed from recv_buf
1271 recv_pos: usize,
1272 /// Number of bytes prepared in send_buf
1273 send_pos: usize,
1274 /// Unused part of the recv_buf,
1275 unused_recv: []const u8,
1276 /// Part of the send_buf that should be sent to the peer
1277 send: []const u8,
1278 } {
1279 if (self.done()) return .{
1280 .recv_pos = 0,
1281 .send_pos = 0,
1282 .unused_recv = recv_buf,
1283 .send = &.{},
1284 };
1285
1286 var input: Io.Reader = .fixed(recv_buf);
1287 var output: Io.Writer = .fixed(send_buf);
1288 self.inner.input = &input;
1289 self.inner.output = &output;
1290
1291 const recv_pos: usize = if (recv_buf.len > 0) brk: {
1292 self.recv() catch |err| switch (err) {
1293 error.EndOfStream, error.InputBufferUndersize => break :brk 0,
1294 else => return err,
1295 };
1296 break :brk input.seek;
1297 } else 0;
1298
1299 try self.send();
1300
1301 return .{
1302 .recv_pos = recv_pos,
1303 .send_pos = output.end,
1304 .unused_recv = recv_buf[recv_pos..],
1305 .send = output.buffered(),
1306 };
1307 }
1308
1309 /// Cipher produced in handshake, null until successful handshake.
1310 pub fn cipher(self: Self) ?Cipher {
1311 return if (self.done()) self.inner.cipher else null;
1312 }
1313};
1314
1315test "nonblock handshake" {
1316 var buffer: [1024]u8 = undefined;
1317 var h = NonBlock.init(.{
1318 .host = "example.ulfheim.net",
1319 .insecure_skip_verify = true,
1320 .root_ca = .empty,
1321 .cipher_suites = &[_]CipherSuite{CipherSuite.AES_256_GCM_SHA384},
1322 .named_groups = &[_]proto.NamedGroup{.x25519},
1323 });
1324 { // update secrets to well known from example
1325 h.inner.client_random = data13.client_random;
1326 h.inner.dh_kp.x25519_kp = .{
1327 .public_key = data13.client_public_key,
1328 .secret_key = data13.client_private_key,
1329 };
1330 }
1331
1332 const expected_client_flight_1 = testu.hexToBytes(
1333 \\ 16 03 03 00 9c
1334 \\ 01 00 00 98
1335 \\ 03 03
1336 \\ 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
1337 \\ 00
1338 \\ 00 02 13 02
1339 \\ 01 00
1340 \\ 00 6d
1341 \\ 00 2b 00 03 02 03 04
1342 \\ 00 0d 00 14 00 12 04 03 05 03 08 04 08 05 08 06 08 07 02 01 04 01 05 01
1343 \\ 00 0a 00 04 00 02 00 1d 00 33 00 26 00 24 00 1d 00 20
1344 \\ 35 80 72 d6 36 58 80 d1 ae ea 32 9a df 91 21 38 38 51 ed 21 a2 8e 3b 75 e9 65 d0 d2 cd 16 62 54
1345 \\ 00 00 00 18 00 16 00 00 13 65 78 61 6d 70 6c 65 2e 75 6c 66 68 65 69 6d 2e 6e 65 74
1346 );
1347
1348 var res = try h.run(&.{}, &buffer);
1349 try testing.expectEqualSlices(u8, &expected_client_flight_1, res.send);
1350
1351 { // update transcript to well known from example
1352 h.inner.transcript = .{};
1353 h.inner.transcript.update(data13.client_hello[record.header_len..]);
1354 }
1355
1356 // Parsing partial server flight consumes nothing
1357 var i: usize = 1;
1358 while (i < data13.server_flight_1.len) : (i += 16) {
1359 //for (1..data13.server_flight_1.len - 1) |i| {
1360 res = try h.run(data13.server_flight_1[0..i], &.{});
1361 try testing.expectEqual(0, res.recv_pos);
1362 try testing.expectEqual(i, res.unused_recv.len);
1363 }
1364
1365 res = try h.run(&(data13.server_flight_1 ++ "dummy footer".*), &buffer);
1366 {
1367 try testing.expectEqual(data13.server_flight_1.len, res.recv_pos); // footer is not touched
1368 try testing.expectEqual(.tls_1_3, h.inner.tls_version);
1369 try testing.expectEqual(.x25519, h.inner.named_group);
1370 try testing.expectEqualSlices(u8, &data13.server_random, &h.inner.server_random);
1371 try testing.expectEqual(.AES_256_GCM_SHA384, h.inner.cipher_suite);
1372 try testing.expectEqualSlices(u8, &data13.server_pub_key, h.inner.server_pub_key);
1373 try testing.expect(h.done());
1374 try testing.expectEqualSlices(u8, &data13.client_flight_2, res.send);
1375 }
1376
1377 // When done pushing more data is noop
1378 res = try h.run(&("dummy footer".*), &buffer);
1379 try testing.expectEqual(0, res.recv_pos);
1380 try testing.expectEqual(0, res.send_pos);
1381 try testing.expect(h.done());
1382}
1383
1384test "note about sizes" {
1385 // values valid only for 64 bit platform, so skip in ci
1386 if (true) return error.SkipZigTest;
1387
1388 try testing.expectEqual(18928, @sizeOf(Handshake));
1389 try testing.expectEqual(19072, @sizeOf(NonBlock));
1390 try testing.expectEqual(14384, @sizeOf(DhKeyPair));
1391 try testing.expectEqual(136, @sizeOf(Options));
1392 try testing.expectEqual(2792, @sizeOf(CertKeyPair));
1393 try testing.expectEqual(1736, @sizeOf(CertificateParser));
1394 try testing.expectEqual(48, @sizeOf(cert.Bundle));
1395 try testing.expectEqual(208, @sizeOf(Cipher));
1396}