Zig TLS 与 HTTP/2：安全连接、证书与协议栈

# 生成私钥
openssl genpkey -algorithm ED25519 -out key.pem

# 生成自签名证书（含 SAN）
openssl req -new -x509 -key key.pem -out cert.pem -days 365 \
    -subj "/CN=localhost" \
    -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"

const std = @import("std");
const crypto = std.crypto;

test "hash" {
    var out: [32]u8 = undefined;
    crypto.hash.sha2.Sha256.hash("hello", &out, .{});

    var hmac = crypto.auth.hmac.sha2.HmacSha256.init("secret-key");
    hmac.update("message");
    var mac: [32]u8 = undefined;
    hmac.final(&mac);
}

test "aead" {
    const key = [_]u8{0x42} ** 32;
    const nonce = [_]u8{0x01} ** 12;
    const plaintext = "机密数据";
    const ad = "header";

    var ciphertext: [plaintext.len]u8 = undefined;
    var tag: [16]u8 = undefined;
    crypto.aead.aes_gcm.Aes256Gcm.encrypt(
        &ciphertext, &tag, plaintext, ad, nonce, key,
    );

    var decrypted: [plaintext.len]u8 = undefined;
    crypto.aead.aes_gcm.Aes256Gcm.decrypt(
        &decrypted, &ciphertext, tag, ad, nonce, key,
    ) catch unreachable;
    try std.testing.expectEqualStrings(plaintext, &decrypted);
}

test "x25519" {
    const sk = crypto.ecc.X25519.KeyPair.generate();
    const pk = sk.public_key;

    const their_sk = crypto.ecc.X25519.KeyPair.generate();
    const shared1 = try crypto.ecc.X25519.scalarmult(sk.secret_key, their_sk.public_key);
    const shared2 = try crypto.ecc.X25519.scalarmult(their_sk.secret_key, pk);
    try std.testing.expectEqual(shared1, shared2);
}

test "ed25519" {
    const kp = crypto.sign.Ed25519.KeyPair.generate();
    const msg = "签名内容";
    const sig = try kp.sign(msg, null);
    try sig.verify(msg, kp.public_key);
}

const std = @import("std");

pub fn openSocket(alloc: std.mem.Allocator, host: []const u8, port: u16) !std.net.Stream {
    const stream = try std.net.tcpConnectToHost(alloc, host, port);
    return stream;
}

const tls = std.crypto.tls;

pub fn connectTls(
    alloc: std.mem.Allocator,
    host: []const u8,
    port: u16,
) !tls.Client {
    const stream = try std.net.tcpConnectToHost(alloc, host, port);

    var bundle: std.crypto.Certificate.Bundle = .{};
    try bundle.rescan(alloc);
    defer bundle.deinit(alloc);

    var client = try tls.Client.init(stream, .{
        .host = .{ .explicit = host },
        .ca = .{ .bundle = bundle },
    });
    return client;
}

try client.writeAll("GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n");

var buf: [4096]u8 = undefined;
const n = try client.read(&buf);
std.debug.print("{s}\n", .{buf[0..n]});

var http_client = std.http.Client{ .allocator = alloc };
defer http_client.deinit();

var response_body = std.ArrayList(u8).init(alloc);
defer response_body.deinit();

const result = try http_client.fetch(.{
    .location = .{ .url = "https://example.com/" },
    .response_storage = .{ .dynamic = &response_body },
});
std.debug.print("状态码 {d}，响应 {d} 字节\n", .{ @intFromEnum(result.status), response_body.items.len });

server {
    listen 443 ssl http2;
    server_name example.com;

    ssl_certificate     /etc/ssl/cert.pem;
    ssl_certificate_key /etc/ssl/key.pem;
    ssl_protocols       TLSv1.2 TLSv1.3;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header X-Forwarded-Proto https;
    }
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    const addr = try std.net.Address.parseIp("127.0.0.1", 8080);
    var server = try addr.listen(.{ .reuse_address = true });
    defer server.deinit();

    while (true) {
        const conn = try server.accept();
        defer conn.stream.close();

        var buf: [4096]u8 = undefined;
        _ = conn.stream.read(&buf) catch continue;
        try conn.stream.writeAll(
            "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello",
        );
    }
}

const proto = header_value(headers, "x-forwarded-proto") orelse "http";
if (!std.mem.eql(u8, proto, "https")) {
    // 生成 301 到 https 地址
}

+-----------------------------------------------+
|                 Length (24)                   |
+---------------+---------------+---------------+
|   Type (8)    |   Flags (8)   |
+-+-------------+---------------+-------------------------------+
|R|                 Stream Identifier (31)                      |
+=+=============================================================+
|                   Frame Payload (0...)                      ...

const FrameHeader = struct {
    length: u24,
    type: u8,
    flags: u8,
    stream_id: u31,

    pub fn parse(bytes: *const [9]u8) FrameHeader {
        return .{
            .length = (@as(u24, bytes[0]) << 16) | (@as(u24, bytes[1]) << 8) | bytes[2],
            .type = bytes[3],
            .flags = bytes[4],
            .stream_id = std.mem.readInt(u32, bytes[5..9], .big) & 0x7fffffff,
        };
    }
};

连接 1 ┌─ stream 1: GET /a
       ├─ stream 3: GET /b
       ├─ stream 5: GET /c
       └─ stream 7: GET /d

var key: [32]u8 = undefined;
std.crypto.random.bytes(&key); // 密码学安全随机源

const ok = crypto.utils.timingSafeEql([32]u8, mac_a, mac_b);

Connection: keep-alive