tracker

25.4 KB

1. // Shared TLS layer — OpenSSL via dlopen, compiled into each HTTP plugin at build time.
2. // Not a standalone plugin .so, but a Zig module imported by hl:http1 and hl:http2
3. // (the same shape as http_common.zig and ws_common.zig).
4. //
5. // Mission 121 EXTRACTED this file. Both http1 and http2 carried their own copy of
6. // the same dlopen dance — http1's since the plugin was written, http2's since
7. // mission 061 added ALPN on top of it. D8's rule applies here exactly as it does to
8. // WS framing: the transport-agnostic half is shared, the per-protocol half stays in
9. // the plugin. What is per-protocol about TLS is TWO things and nothing else:
10. // • the ALPN list a server offers ("h2" for http2, "http/1.1" for http1)
11. // • WHERE the handshake happens (http2 does it on the accept thread before the
12. // socket goes back to non-blocking; http1 does it in the I/O worker)
13. // Both are parameters here, so there is one implementation of the dlopen, the
14. // SSL_CTX, the cert/key load, the ALPN callback and the read/write/shutdown paths.
15. //
16. // No compile-time dependency on OpenSSL: the library is resolved at runtime and a
17. // server whose host has no libssl falls back to plaintext (the caller decides).
18. //
19. // NOT hl:http3. Its `Quic` struct dlopens the same library but through a DIFFERENT
20. // OpenSSL surface — `OSSL_QUIC_server_method`, `SSL_new_listener`/`SSL_listen`,
21. // `SSL_read_ex`/`SSL_write_ex`, event-driven, no `SSL_accept` and no socket fd —
22. // so it is not a copy of this and folding it in would be a rewrite, not an
23. // extraction. It stays where it is.
25. const std = @import("std");
27. const c_dlfcn = @cImport({
28. @cInclude("dlfcn.h");
29. });
31. const linux = std.os.linux;
33. // per-request allocations across threads: the plugins' allocator (plugin_api.zig)
34. const allocator = @import("plugin_api").allocator;
36. // Direct syscall for stderr — std.debug.print pulls in std.Progress, whose global
37. // state is ABI-incompatible when a .so is loaded into a differently-built binary.
38. fn logMsg(msg: []const u8) void {
39. _ = linux.write(2, msg.ptr, msg.len);
40. }
42. fn logFmt(comptime fmt: []const u8, args: anytype) void {
43. var buf: [512]u8 = undefined;
44. const s = std.fmt.bufPrint(&buf, fmt, args) catch return;
45. logMsg(s);
46. }
48. pub const SSL_CTX = opaque {};
49. pub const SSL = opaque {};
50. pub const SSL_METHOD = opaque {};
52. // OpenSSL function pointer types
53. const SSL_library_init_fn = *const fn () callconv(.c) c_int;
54. const SSL_load_error_strings_fn = *const fn () callconv(.c) void;
55. const TLS_server_method_fn = *const fn () callconv(.c) ?*const SSL_METHOD;
56. const SSL_CTX_new_fn = *const fn (?*const SSL_METHOD) callconv(.c) ?*SSL_CTX;
57. const SSL_CTX_free_fn = *const fn (?*SSL_CTX) callconv(.c) void;
58. const SSL_CTX_use_certificate_chain_file_fn = *const fn (?*SSL_CTX, [*:0]const u8) callconv(.c) c_int;
59. const SSL_CTX_use_PrivateKey_file_fn = *const fn (?*SSL_CTX, [*:0]const u8, c_int) callconv(.c) c_int;
60. const SSL_CTX_set_alpn_select_cb_fn = *const fn (?*SSL_CTX, ?AlpnSelectCallback, ?*anyopaque) callconv(.c) void;
61. const SSL_new_fn = *const fn (?*SSL_CTX) callconv(.c) ?*SSL;
62. const SSL_free_fn = *const fn (?*SSL) callconv(.c) void;
63. const SSL_set_fd_fn = *const fn (?*SSL, c_int) callconv(.c) c_int;
64. const SSL_accept_fn = *const fn (?*SSL) callconv(.c) c_int;
65. const SSL_read_fn = *const fn (?*SSL, [*]u8, c_int) callconv(.c) c_int;
66. const SSL_write_fn = *const fn (?*SSL, [*]const u8, c_int) callconv(.c) c_int;
67. const SSL_shutdown_fn = *const fn (?*SSL) callconv(.c) c_int;
68. const SSL_get_error_fn = *const fn (?*SSL, c_int) callconv(.c) c_int;
69. const OPENSSL_init_ssl_fn = *const fn (u64, ?*anyopaque) callconv(.c) c_int;
71. // ── The CLIENT half's symbols (hl:fetch, hl:smtp) ────────────────────────────
72. // RESTORED 2026-08-29 (mission 257): `initClient`/`connect` and everything they
73. // resolve were lost in the 2026-08-20 recovery replay, which nothing noticed
74. // because neither plugin that calls them was in `native/build.zig`.
75. const TLS_client_method_fn = *const fn () callconv(.c) ?*const SSL_METHOD;
76. const SSL_CTX_set_default_verify_paths_fn = *const fn (?*SSL_CTX) callconv(.c) c_int;
77. const SSL_CTX_load_verify_locations_fn = *const fn (?*SSL_CTX, ?[*:0]const u8, ?[*:0]const u8) callconv(.c) c_int;
78. const SSL_CTX_set_verify_fn = *const fn (?*SSL_CTX, c_int, ?*anyopaque) callconv(.c) void;
79. const SSL_connect_fn = *const fn (?*SSL) callconv(.c) c_int;
80. const SSL_get_verify_result_fn = *const fn (?*SSL) callconv(.c) c_long;
81. /// SNI goes through the generic control entry point: there is no exported
82. /// `SSL_set_tlsext_host_name` — it is a macro over `SSL_ctrl` in the headers.
83. const SSL_ctrl_fn = *const fn (?*SSL, c_int, c_long, ?*anyopaque) callconv(.c) c_long;
84. const SSL_set1_host_fn = *const fn (?*SSL, [*:0]const u8) callconv(.c) c_int;
86. pub const SSL_VERIFY_NONE: c_int = 0;
87. pub const SSL_VERIFY_PEER: c_int = 1;
88. pub const X509_V_OK: c_long = 0;
89. const SSL_CTRL_SET_TLSEXT_HOSTNAME: c_int = 55;
90. const TLSEXT_NAMETYPE_host_name: c_long = 0;
92. pub const SSL_FILETYPE_PEM: c_int = 1;
93. pub const SSL_ERROR_WANT_READ: c_int = 2;
94. pub const SSL_ERROR_WANT_WRITE: c_int = 3;
95. pub const SSL_ERROR_ZERO_RETURN: c_int = 6;
96. pub const SSL_TLSEXT_ERR_OK: c_int = 0;
97. pub const SSL_TLSEXT_ERR_NOACK: c_int = 2;
99. const AlpnSelectCallback = *const fn (?*SSL, [*c][*c]const u8, [*c]u8, [*c]const u8, c_uint, ?*anyopaque) callconv(.c) c_int;
101. /// The server's ALPN offer in wire format (each protocol length-prefixed), heap
102. /// allocated because OpenSSL keeps the callback's user_data pointer for the life of
103. /// the SSL_CTX and a TlsContext is returned BY VALUE (a pointer to it would dangle).
104. const AlpnOffer = struct {
105. wire: []u8,
106. };
108. /// RFC 7301 selection with SERVER preference: the first protocol this server offers
109. /// that the client also listed wins. No overlap → NOACK, which leaves the connection
110. /// without a negotiated protocol rather than failing the handshake (what http2 did
111. /// before the extraction, and what http1 wants anyway — a browser that omits ALPN
112. /// still speaks HTTP/1.1 over the socket).
113. fn alpnSelect(ssl: ?*SSL, out: [*c][*c]const u8, outlen: [*c]u8, in: [*c]const u8, inlen: c_uint, user_data: ?*anyopaque) callconv(.c) c_int {
114. _ = ssl;
115. const offer: *const AlpnOffer = @ptrCast(@alignCast(user_data orelse return SSL_TLSEXT_ERR_NOACK));
116. var si: usize = 0;
117. while (si < offer.wire.len) {
118. const slen = offer.wire[si];
119. si += 1;
120. if (si + slen > offer.wire.len) break;
121. const ours = offer.wire[si .. si + slen];
122. var ci: usize = 0;
123. while (ci < inlen) {
124. const clen = in[ci];
125. ci += 1;
126. if (ci + clen > inlen) break;
127. if (clen == slen and std.mem.eql(u8, in[ci .. ci + clen], ours)) {
128. out.* = in + ci;
129. outlen.* = clen;
130. return SSL_TLSEXT_ERR_OK;
131. }
132. ci += clen;
133. }
134. si += slen;
135. }
136. return SSL_TLSEXT_ERR_NOACK;
137. }
139. /// The per-protocol half, as data.
140. pub const Options = struct {
141. /// Protocols this server offers over ALPN, in preference order. Empty = no ALPN
142. /// callback is registered at all (byte-identical to a server that never had one).
143. alpn: []const []const u8 = &.{},
144. /// Prefix for this plugin's log lines ("http1" / "http2" / "fetch" / "smtp").
145. tag: []const u8 = "tls",
147. // ── client-side only ──
148. /// An EXTRA trust anchor on top of the system store, for a self-signed test
149. /// fixture. null = the system store alone. Never a replacement: a caFile that
150. /// fails to load fails the whole context rather than silently trusting less.
151. ca_file: ?[]const u8 = null,
152. /// Verify the peer's chain AND its hostname. hl:fetch never turns this off —
153. /// it does not pass the field at all. hl:smtp exposes it, because a mail host
154. /// with a self-signed certificate and no way to name its CA file is a real
155. /// configuration, and a deliberate one.
156. verify: bool = true,
157. };
159. pub const TlsContext = struct {
160. ssl_ctx: ?*SSL_CTX = null,
161. lib_ssl: ?*anyopaque = null,
162. lib_crypto: ?*anyopaque = null,
163. alpn: ?*AlpnOffer = null,
165. fn_ssl_ctx_new: ?SSL_CTX_new_fn = null,
166. fn_ssl_ctx_free: ?SSL_CTX_free_fn = null,
167. fn_ssl_ctx_use_cert: ?SSL_CTX_use_certificate_chain_file_fn = null,
168. fn_ssl_ctx_use_key: ?SSL_CTX_use_PrivateKey_file_fn = null,
169. fn_ssl_ctx_set_alpn: ?SSL_CTX_set_alpn_select_cb_fn = null,
170. fn_ssl_new: ?SSL_new_fn = null,
171. fn_ssl_free: ?SSL_free_fn = null,
172. fn_ssl_set_fd: ?SSL_set_fd_fn = null,
173. fn_ssl_accept: ?SSL_accept_fn = null,
174. fn_ssl_read: ?SSL_read_fn = null,
175. fn_ssl_write: ?SSL_write_fn = null,
176. fn_ssl_shutdown: ?SSL_shutdown_fn = null,
177. fn_ssl_get_error: ?SSL_get_error_fn = null,
179. // client half
180. fn_ssl_connect: ?SSL_connect_fn = null,
181. fn_ssl_ctrl: ?SSL_ctrl_fn = null,
182. fn_ssl_set1_host: ?SSL_set1_host_fn = null,
183. fn_ssl_get_verify_result: ?SSL_get_verify_result_fn = null,
184. /// What this context was built for. `connect` refuses on a server context and
185. /// `wrapConnection` on a client one, rather than calling a null function
186. /// pointer somewhere deep inside OpenSSL.
187. is_client: bool = false,
188. /// Whether `connect` enforces the chain and the hostname (client only).
189. verify: bool = true,
191. fn loadSym(lib: ?*anyopaque, comptime T: type, name: [*:0]const u8) ?T {
192. const sym = c_dlfcn.dlsym(lib, name) orelse return null;
193. return @ptrCast(sym);
194. }
196. /// dlopen libssl+libcrypto, run OpenSSL's own initialiser, and resolve every
197. /// symbol BOTH halves use. false = there is no usable OpenSSL on this host
198. /// (already logged, and anything opened is already closed again).
199. fn openOpenSsl(ctx: *TlsContext, tag: []const u8) bool {
200. const ssl_paths = [_][*:0]const u8{ "libssl.so.3", "libssl.so.1.1", "libssl.so" };
201. const crypto_paths = [_][*:0]const u8{ "libcrypto.so.3", "libcrypto.so.1.1", "libcrypto.so" };
203. for (ssl_paths) |path| {
204. ctx.lib_ssl = c_dlfcn.dlopen(path, c_dlfcn.RTLD_NOW | c_dlfcn.RTLD_LOCAL);
205. if (ctx.lib_ssl != null) break;
206. }
207. if (ctx.lib_ssl == null) {
208. logFmt("{s}: TLS: failed to load libssl.so\n", .{tag});
209. return false;
210. }
212. for (crypto_paths) |path| {
213. ctx.lib_crypto = c_dlfcn.dlopen(path, c_dlfcn.RTLD_NOW | c_dlfcn.RTLD_LOCAL);
214. if (ctx.lib_crypto != null) break;
215. }
216. if (ctx.lib_crypto == null) {
217. logFmt("{s}: TLS: failed to load libcrypto.so\n", .{tag});
218. _ = c_dlfcn.dlclose(ctx.lib_ssl);
219. ctx.lib_ssl = null;
220. return false;
221. }
223. // OPENSSL_init_ssl first (OpenSSL 1.1+), SSL_library_init as the fallback.
224. if (loadSym(ctx.lib_ssl, OPENSSL_init_ssl_fn, "OPENSSL_init_ssl")) |init_fn| {
225. _ = init_fn(0, null);
226. } else if (loadSym(ctx.lib_ssl, SSL_library_init_fn, "SSL_library_init")) |lib_init| {
227. _ = lib_init();
228. if (loadSym(ctx.lib_ssl, SSL_load_error_strings_fn, "SSL_load_error_strings")) |load_err| {
229. load_err();
230. }
231. }
233. ctx.fn_ssl_ctx_new = loadSym(ctx.lib_ssl, SSL_CTX_new_fn, "SSL_CTX_new");
234. ctx.fn_ssl_ctx_free = loadSym(ctx.lib_ssl, SSL_CTX_free_fn, "SSL_CTX_free");
235. ctx.fn_ssl_new = loadSym(ctx.lib_ssl, SSL_new_fn, "SSL_new");
236. ctx.fn_ssl_free = loadSym(ctx.lib_ssl, SSL_free_fn, "SSL_free");
237. ctx.fn_ssl_set_fd = loadSym(ctx.lib_ssl, SSL_set_fd_fn, "SSL_set_fd");
238. ctx.fn_ssl_read = loadSym(ctx.lib_ssl, SSL_read_fn, "SSL_read");
239. ctx.fn_ssl_write = loadSym(ctx.lib_ssl, SSL_write_fn, "SSL_write");
240. ctx.fn_ssl_shutdown = loadSym(ctx.lib_ssl, SSL_shutdown_fn, "SSL_shutdown");
241. ctx.fn_ssl_get_error = loadSym(ctx.lib_ssl, SSL_get_error_fn, "SSL_get_error");
242. return true;
243. }
245. /// Resolve OpenSSL, build an SSL_CTX, load cert+key, register the ALPN offer.
246. /// null = no TLS on this host or a bad cert/key; the caller falls back to plaintext.
247. pub fn init(cert_path: []const u8, key_path: []const u8, opts: Options) ?TlsContext {
248. var ctx = TlsContext{};
249. if (!openOpenSsl(&ctx, opts.tag)) return null;
251. const method_fn = loadSym(ctx.lib_ssl, TLS_server_method_fn, "TLS_server_method") orelse {
252. logFmt("{s}: TLS: TLS_server_method not found\n", .{opts.tag});
253. ctx.deinit();
254. return null;
255. };
257. ctx.fn_ssl_ctx_use_cert = loadSym(ctx.lib_ssl, SSL_CTX_use_certificate_chain_file_fn, "SSL_CTX_use_certificate_chain_file");
258. ctx.fn_ssl_ctx_use_key = loadSym(ctx.lib_ssl, SSL_CTX_use_PrivateKey_file_fn, "SSL_CTX_use_PrivateKey_file");
259. ctx.fn_ssl_ctx_set_alpn = loadSym(ctx.lib_ssl, SSL_CTX_set_alpn_select_cb_fn, "SSL_CTX_set_alpn_select_cb");
260. ctx.fn_ssl_accept = loadSym(ctx.lib_ssl, SSL_accept_fn, "SSL_accept");
262. if (ctx.fn_ssl_ctx_new == null or ctx.fn_ssl_new == null or
263. ctx.fn_ssl_set_fd == null or ctx.fn_ssl_accept == null or
264. ctx.fn_ssl_read == null or ctx.fn_ssl_write == null)
265. {
266. logFmt("{s}: TLS: missing required SSL symbols\n", .{opts.tag});
267. ctx.deinit();
268. return null;
269. }
271. const method = method_fn();
272. ctx.ssl_ctx = ctx.fn_ssl_ctx_new.?(method);
273. if (ctx.ssl_ctx == null) {
274. logFmt("{s}: TLS: SSL_CTX_new failed\n", .{opts.tag});
275. ctx.deinit();
276. return null;
277. }
279. if (opts.alpn.len > 0) {
280. if (ctx.fn_ssl_ctx_set_alpn) |set_alpn| {
281. var total: usize = 0;
282. for (opts.alpn) |p| total += 1 + p.len;
283. const wire = allocator.alloc(u8, total) catch {
284. ctx.deinit();
285. return null;
286. };
287. var w: usize = 0;
288. for (opts.alpn) |p| {
289. wire[w] = @intCast(p.len);
290. w += 1;
291. @memcpy(wire[w .. w + p.len], p);
292. w += p.len;
293. }
294. const offer = allocator.create(AlpnOffer) catch {
295. allocator.free(wire);
296. ctx.deinit();
297. return null;
298. };
299. offer.* = .{ .wire = wire };
300. ctx.alpn = offer;
301. set_alpn(ctx.ssl_ctx, &alpnSelect, offer);
302. }
303. }
305. const cert_z = allocator.dupeZ(u8, cert_path) catch {
306. ctx.deinit();
307. return null;
308. };
309. defer allocator.free(cert_z);
310. const key_z = allocator.dupeZ(u8, key_path) catch {
311. ctx.deinit();
312. return null;
313. };
314. defer allocator.free(key_z);
316. if (ctx.fn_ssl_ctx_use_cert) |use_cert| {
317. if (use_cert(ctx.ssl_ctx, cert_z.ptr) != 1) {
318. logFmt("{s}: TLS: failed to load certificate: {s}\n", .{ opts.tag, cert_path });
319. ctx.deinit();
320. return null;
321. }
322. }
324. if (ctx.fn_ssl_ctx_use_key) |use_key| {
325. if (use_key(ctx.ssl_ctx, key_z.ptr, SSL_FILETYPE_PEM) != 1) {
326. logFmt("{s}: TLS: failed to load private key: {s}\n", .{ opts.tag, key_path });
327. ctx.deinit();
328. return null;
329. }
330. }
332. logFmt("{s}: TLS initialized\n", .{opts.tag});
333. return ctx;
334. }
336. /// THE CLIENT HALF (mission 135, restored in 257). An SSL_CTX that VERIFIES:
337. /// the system trust store is loaded, `opts.ca_file` adds an extra anchor for a
338. /// self-signed fixture, and `connect` checks the hostname as well as the chain.
339. /// null = no usable OpenSSL, or a caFile that would not load — never a context
340. /// that trusts less than asked, because "https that silently stopped verifying"
341. /// is the one failure a caller cannot see.
342. ///
343. /// An SSL_CTX is thread-safe and expensive (it reads the trust store), so the
344. /// callers keep one per distinct caFile and share it across worker threads.
345. pub fn initClient(opts: Options) ?TlsContext {
346. var ctx = TlsContext{ .is_client = true, .verify = opts.verify };
347. if (!openOpenSsl(&ctx, opts.tag)) return null;
349. const method_fn = loadSym(ctx.lib_ssl, TLS_client_method_fn, "TLS_client_method") orelse {
350. logFmt("{s}: TLS: TLS_client_method not found\n", .{opts.tag});
351. ctx.deinit();
352. return null;
353. };
355. ctx.fn_ssl_connect = loadSym(ctx.lib_ssl, SSL_connect_fn, "SSL_connect");
356. ctx.fn_ssl_ctrl = loadSym(ctx.lib_ssl, SSL_ctrl_fn, "SSL_ctrl");
357. ctx.fn_ssl_set1_host = loadSym(ctx.lib_ssl, SSL_set1_host_fn, "SSL_set1_host");
358. ctx.fn_ssl_get_verify_result = loadSym(ctx.lib_ssl, SSL_get_verify_result_fn, "SSL_get_verify_result");
360. if (ctx.fn_ssl_ctx_new == null or ctx.fn_ssl_new == null or
361. ctx.fn_ssl_set_fd == null or ctx.fn_ssl_connect == null or
362. ctx.fn_ssl_read == null or ctx.fn_ssl_write == null)
363. {
364. logFmt("{s}: TLS: missing required client SSL symbols\n", .{opts.tag});
365. ctx.deinit();
366. return null;
367. }
368. // Hostname checking is not optional when verification is on. Without
369. // SSL_set1_host (OpenSSL < 1.1.0) a valid certificate for ANY host would
370. // pass, which is not verification — so refuse rather than pretend.
371. if (opts.verify and ctx.fn_ssl_set1_host == null) {
372. logFmt("{s}: TLS: SSL_set1_host not found — this OpenSSL cannot check hostnames\n", .{opts.tag});
373. ctx.deinit();
374. return null;
375. }
377. ctx.ssl_ctx = ctx.fn_ssl_ctx_new.?(method_fn());
378. if (ctx.ssl_ctx == null) {
379. logFmt("{s}: TLS: SSL_CTX_new failed\n", .{opts.tag});
380. ctx.deinit();
381. return null;
382. }
384. if (loadSym(ctx.lib_ssl, SSL_CTX_set_default_verify_paths_fn, "SSL_CTX_set_default_verify_paths")) |defaults| {
385. if (defaults(ctx.ssl_ctx) != 1 and opts.verify and opts.ca_file == null) {
386. logFmt("{s}: TLS: the system trust store could not be loaded\n", .{opts.tag});
387. ctx.deinit();
388. return null;
389. }
390. }
392. if (opts.ca_file) |ca| {
393. const load_verify = loadSym(ctx.lib_ssl, SSL_CTX_load_verify_locations_fn, "SSL_CTX_load_verify_locations") orelse {
394. logFmt("{s}: TLS: SSL_CTX_load_verify_locations not found\n", .{opts.tag});
395. ctx.deinit();
396. return null;
397. };
398. const ca_z = allocator.dupeZ(u8, ca) catch {
399. ctx.deinit();
400. return null;
401. };
402. defer allocator.free(ca_z);
403. if (load_verify(ctx.ssl_ctx, ca_z.ptr, null) != 1) {
404. logFmt("{s}: TLS: caFile could not be loaded: {s}\n", .{ opts.tag, ca });
405. ctx.deinit();
406. return null;
407. }
408. }
410. if (loadSym(ctx.lib_ssl, SSL_CTX_set_verify_fn, "SSL_CTX_set_verify")) |set_verify| {
411. set_verify(ctx.ssl_ctx, if (opts.verify) SSL_VERIFY_PEER else SSL_VERIFY_NONE, null);
412. } else if (opts.verify) {
413. logFmt("{s}: TLS: SSL_CTX_set_verify not found\n", .{opts.tag});
414. ctx.deinit();
415. return null;
416. }
418. logFmt("{s}: TLS client initialized (verify={s})\n", .{ opts.tag, if (opts.verify) "on" else "off" });
419. return ctx;
420. }
422. /// Connect `fd` — already a live TCP socket, and for STARTTLS one that has
423. /// already spoken plaintext — as a TLS CLIENT to `host`. SNI and the hostname
424. /// to check are both `host`, which is why the caller passes the name and not
425. /// just the socket. null = the handshake or the verification failed (logged).
426. pub fn connect(self: *const TlsContext, fd: i32, host: []const u8, tag: []const u8) ?*SSL {
427. if (!self.is_client) {
428. logFmt("{s}: TLS: connect() on a server context\n", .{tag});
429. return null;
430. }
431. const ssl = self.fn_ssl_new.?(self.ssl_ctx) orelse return null;
432. _ = self.fn_ssl_set_fd.?(ssl, fd);
434. // A name is only a name — an IP literal is not a valid SNI value, and
435. // OpenSSL rejects it, so the dupeZ is worth doing once either way.
436. const host_z = allocator.dupeZ(u8, host) catch {
437. self.fn_ssl_free.?(ssl);
438. return null;
439. };
440. defer allocator.free(host_z);
442. if (self.fn_ssl_ctrl) |ctrl| {
443. _ = ctrl(ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, @constCast(@ptrCast(host_z.ptr)));
444. }
445. if (self.verify) {
446. if (self.fn_ssl_set1_host.?(ssl, host_z.ptr) != 1) {
447. logFmt("{s}: TLS: could not set the hostname to verify ({s})\n", .{ tag, host });
448. self.fn_ssl_free.?(ssl);
449. return null;
450. }
451. }
453. while (true) {
454. const ret = self.fn_ssl_connect.?(ssl);
455. if (ret == 1) break;
456. const err = self.getError(ssl, ret);
457. if (err == SSL_ERROR_WANT_READ or err == SSL_ERROR_WANT_WRITE) continue;
458. logFmt("{s}: TLS client handshake failed ret={d} err={d} host={s}\n", .{ tag, ret, err, host });
459. self.fn_ssl_free.?(ssl);
460. return null;
461. }
463. // SSL_connect succeeding is NOT the verdict: with SSL_VERIFY_PEER the
464. // handshake already fails on a bad chain, but reading the result is the
465. // documented way to be sure, and it is the only signal when verify is off
466. // for a host that nevertheless presented something valid.
467. if (self.verify) {
468. if (self.fn_ssl_get_verify_result) |verify_result| {
469. const rc = verify_result(ssl);
470. if (rc != X509_V_OK) {
471. logFmt("{s}: TLS: certificate verification failed (code {d}) for {s}\n", .{ tag, rc, host });
472. self.shutdownAndFree(ssl);
473. return null;
474. }
475. }
476. }
477. return ssl;
478. }
480. /// A new SSL object bound to `fd`. No handshake — the caller decides where that
481. /// happens (this is the per-protocol half).
482. pub fn newSSL(self: *const TlsContext, fd: i32) ?*SSL {
483. const ssl = self.fn_ssl_new.?(self.ssl_ctx);
484. if (ssl == null) return null;
485. _ = self.fn_ssl_set_fd.?(ssl, fd);
486. return ssl;
487. }
489. pub fn getError(self: *const TlsContext, ssl: *SSL, ret: isize) c_int {
490. const f = self.fn_ssl_get_error orelse return 0;
491. return f(ssl, @intCast(ret));
492. }
494. /// Drive SSL_accept to completion. On a BLOCKING socket this returns on the
495. /// first call; on a non-blocking one it spins on WANT_READ/WANT_WRITE, which is
496. /// what http2's accept path relies on.
497. pub fn handshake(self: *const TlsContext, ssl: *SSL, tag: []const u8) bool {
498. while (true) {
499. const ret = self.fn_ssl_accept.?(ssl);
500. if (ret == 1) return true;
501. const err = self.getError(ssl, ret);
502. if (err == SSL_ERROR_WANT_READ or err == SSL_ERROR_WANT_WRITE) continue;
503. logFmt("{s}: TLS handshake failed ret={d} err={d}\n", .{ tag, ret, err });
504. return false;
505. }
506. }
508. /// newSSL + handshake, freeing the SSL object if the handshake fails.
509. pub fn wrapConnection(self: *const TlsContext, fd: i32, tag: []const u8) ?*SSL {
510. const ssl = self.newSSL(fd) orelse return null;
511. if (!self.handshake(ssl, tag)) {
512. self.fn_ssl_free.?(ssl);
513. return null;
514. }
515. return ssl;
516. }
518. /// Raw SSL_read. <= 0 means "ask getError" — WANT_READ/WANT_WRITE is "nothing
519. /// more right now", anything else is a dead connection.
520. pub fn read(self: *const TlsContext, ssl: *SSL, buf: []u8) isize {
521. return self.fn_ssl_read.?(ssl, buf.ptr, @intCast(@min(buf.len, std.math.maxInt(c_int))));
522. }
524. /// Raw SSL_write (one record's worth at most).
525. pub fn write(self: *const TlsContext, ssl: *SSL, data: []const u8) isize {
526. return self.fn_ssl_write.?(ssl, data.ptr, @intCast(@min(data.len, std.math.maxInt(c_int))));
527. }
529. /// Write everything, giving up on the first non-retryable error. Returns the
530. /// number of bytes actually written.
531. pub fn writeAll(self: *const TlsContext, ssl: *SSL, data: []const u8) usize {
532. var written: usize = 0;
533. while (written < data.len) {
534. const ret = self.write(ssl, data[written..]);
535. if (ret <= 0) return written;
536. written += @intCast(ret);
537. }
538. return written;
539. }
541. pub fn shutdownAndFree(self: *const TlsContext, ssl: *SSL) void {
542. if (self.fn_ssl_shutdown) |sd| _ = sd(ssl);
543. self.fn_ssl_free.?(ssl);
544. }
546. /// Free WITHOUT the close_notify — for a connection whose handshake never
547. /// completed (there is no session to shut down) or whose socket is already
548. /// gone (writing a TLS record into a recycled fd number is worse than
549. /// skipping the notify: mission 128 measured it corrupting a live peer).
550. pub fn freeSSL(self: *const TlsContext, ssl: *SSL) void {
551. self.fn_ssl_free.?(ssl);
552. }
554. pub fn deinit(self: *TlsContext) void {
555. if (self.ssl_ctx != null) {
556. if (self.fn_ssl_ctx_free) |free_fn| {
557. free_fn(self.ssl_ctx);
558. }
559. self.ssl_ctx = null;
560. }
561. if (self.alpn) |offer| {
562. allocator.free(offer.wire);
563. allocator.destroy(offer);
564. self.alpn = null;
565. }
566. if (self.lib_ssl != null) {
567. _ = c_dlfcn.dlclose(self.lib_ssl);
568. self.lib_ssl = null;
569. }
570. if (self.lib_crypto != null) {
571. _ = c_dlfcn.dlclose(self.lib_crypto);
572. self.lib_crypto = null;
573. }
574. }
575. };