also looking at this
Harden encrypted mail storage, recovery, and forwarding
#8
50 files
+1701
-9001
| @@ -1,1396 +0,0 @@ | ||
| 1 | const std = @import("std"); | |
| 2 | const assert = std.debug.assert; | |
| 3 | const crypto = std.crypto; | |
| 4 | const mem = std.mem; | |
| 5 | const posix = std.posix; | |
| 6 | const Io = std.Io; | |
| 7 | const Certificate = crypto.Certificate; | |
| 8 | ||
| 9 | // Helper function for Zig 0.16 compatibility | |
| 10 | fn 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 | ||
| 16 | const rng = @import("random.zig"); | |
| 17 | const Cipher = @import("cipher.zig").Cipher; | |
| 18 | const CipherSuite = @import("cipher.zig").CipherSuite; | |
| 19 | const cipher_suites = @import("cipher.zig").cipher_suites; | |
| 20 | const max_cleartext_len = @import("cipher.zig").max_cleartext_len; | |
| 21 | ||
| 22 | const Transcript = @import("transcript.zig").Transcript; | |
| 23 | const record = @import("record.zig"); | |
| 24 | const Record = record.Record; | |
| 25 | const rsa = @import("rsa/rsa.zig"); | |
| 26 | const key_log = @import("key_log.zig"); | |
| 27 | const PrivateKey = @import("PrivateKey.zig"); | |
| 28 | const proto = @import("protocol.zig"); | |
| 29 | ||
| 30 | const common = @import("handshake_common.zig"); | |
| 31 | const CertificateBuilder = common.CertificateBuilder; | |
| 32 | const CertificateParser = common.CertificateParser; | |
| 33 | const DhKeyPair = common.DhKeyPair; | |
| 34 | const CertKeyPair = common.CertKeyPair; | |
| 35 | const cert = common.cert; | |
| 36 | ||
| 37 | const log = std.log.scoped(.tls); | |
| 38 | ||
| 39 | pub 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 | ||
| 198 | const ResumptionTicket = Options.SessionResumption.Ticket; | |
| 199 | ||
| 200 | const 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. | |
| 211 | pub 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 | ||
| 905 | const 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 | ||
| 925 | const testing = std.testing; | |
| 926 | const data12 = @import("testdata/tls12.zig"); | |
| 927 | const data13 = @import("testdata/tls13.zig"); | |
| 928 | const testu = @import("testu.zig"); | |
| 929 | ||
| 930 | test "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 | ||
| 962 | test "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 | ||
| 981 | test "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 | ||
| 1000 | test "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 | ||
| 1026 | fn 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 | ||
| 1037 | test "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 | ||
| 1061 | test "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 | ||
| 1100 | test "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 | ||
| 1141 | test "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 | ||
| 1161 | test "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 | ||
| 1189 | pub 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 | ||
| 1315 | test "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 | ||
| 1384 | test "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 | } | |