gitoria

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