tiny.quic.tls.message

1pub const Certificate = struct {2    request_context: []const u8,3    entries: CertificateEntries,4};

1pub const CertificateEntries = struct {2    bytes: []const u8,34    pub fn iterator(self: CertificateEntries) CertificateIterator {5        return .{ .input = cursor.Read.init(self.bytes), .count = 0 };6    }7};

1pub const CertificateEntry = struct {2    data: []const u8,3    extensions: Extensions,4};

1pub const CertificateIterator = struct {2    input: cursor.Read,3    count: u8,45    pub fn next(self: *CertificateIterator) DecodeError!?CertificateEntry {6        if (self.input.remaining() == 0) return null;7        if (self.count == certificate_entries_max) {8            return error.TooManyCertificateEntries;9        }10        self.count += 1;11        const data = try takeVector24(&self.input);12        const extensions = try takeVector16(&self.input);13        return .{ .data = data, .extensions = .{ .bytes = extensions } };14    }15};

1pub const CertificateRequest = struct {2    context: []const u8,3    extensions: Extensions,4};

1pub const CertificateVerify = struct {2    algorithm: std.crypto.tls.SignatureScheme,3    signature: []const u8,4};

1pub const ClientHello = struct {2    legacy_version: u16,3    random: [32]u8,4    legacy_session_id: []const u8,5    cipher_suites: []const u8,6    compression_methods: []const u8,7    extensions: Extensions,8};

1pub const EncryptedExtensions = struct { extensions: Extensions };

1pub const Extension = struct {2    kind: ExtensionType,3    data: []const u8,4};

1pub const ExtensionIterator = struct {2    input: cursor.Read,3    count: u8,45    pub fn next(self: *ExtensionIterator) DecodeError!?Extension {6        if (self.input.remaining() == 0) return null;7        if (self.count == extension_count_max) return error.TooManyExtensions;8        self.count += 1;9        const kind: ExtensionType = @fromBackingInt(@intCast(try self.input.int(u16)));10        const length = try self.input.int(u16);11        return .{ .kind = kind, .data = try self.input.take(length) };12    }13};

1pub const Extensions = struct {2    bytes: []const u8,34    pub fn iterator(self: Extensions) ExtensionIterator {5        return .{ .input = cursor.Read.init(self.bytes), .count = 0 };6    }7};

1pub const Finished = struct { verify_data: []const u8 };

1pub const Handshake = struct {2    kind: HandshakeType,3    body: []const u8,4};

1pub const NewSessionTicket = struct {2    lifetime: u32,3    age_add: u32,4    nonce: []const u8,5    ticket: []const u8,6    extensions: Extensions,7};

1pub const ServerHello = struct {2    legacy_version: u16,3    random: [32]u8,4    legacy_session_id_echo: []const u8,5    cipher_suite: u16,6    compression_method: u8,7    extensions: Extensions,8};

1pub const DecodeError = cursor.ReadError || DecodeSpecific;

1pub const certificate_entries_max: u8 = 8;

1pub fn decode(bytes: []const u8) DecodeError!Handshake {2    var input = cursor.Read.init(bytes);3    const kind: HandshakeType = @fromBackingInt(@intCast(try input.byte()));4    const length = try input.int(u24);5    const body = try input.take(length);6    if (input.remaining() != 0) return error.InvalidLength;7    return .{ .kind = kind, .body = body };8}

1pub fn decodeCertificate(bytes: []const u8) DecodeError!Certificate {2    var input = try expected(bytes, .certificate);3    const context = try takeVector8(&input);4    const entries = try takeVector24(&input);5    try finish(&input);6    return .{ .request_context = context, .entries = .{ .bytes = entries } };7}

1pub fn decodeCertificateRequest(bytes: []const u8) DecodeError!CertificateRequest {2    var input = try expected(bytes, .certificate_request);3    const context = try takeVector8(&input);4    const extensions = try takeVector16(&input);5    try finish(&input);6    return .{ .context = context, .extensions = .{ .bytes = extensions } };7}

1pub fn decodeCertificateVerify(bytes: []const u8) DecodeError!CertificateVerify {2    var input = try expected(bytes, .certificate_verify);3    const algorithm: std.crypto.tls.SignatureScheme = @fromBackingInt(@intCast(try input.int(u16)));4    const signature = try takeVector16(&input);5    try finish(&input);6    return .{ .algorithm = algorithm, .signature = signature };7}

1pub fn decodeClientHello(bytes: []const u8) DecodeError!ClientHello {2    var input = try expected(bytes, .client_hello);3    const legacy_version = try input.int(u16);4    var random: [32]u8 = undefined;5    @memcpy(&random, try input.take(32));6    const session_id = try takeVector8(&input);7    const cipher_suites = try takeVector16(&input);8    if (cipher_suites.len == 0) return error.InvalidLength;9    if (cipher_suites.len % 2 != 0) return error.InvalidLength;10    const compression = try takeVector8(&input);11    const extensions = try takeVector16(&input);12    try finish(&input);13    return .{14        .legacy_version = legacy_version,15        .random = random,16        .legacy_session_id = session_id,17        .cipher_suites = cipher_suites,18        .compression_methods = compression,19        .extensions = .{ .bytes = extensions },20    };21}

1pub fn decodeEncryptedExtensions(bytes: []const u8) DecodeError!EncryptedExtensions {2    var input = try expected(bytes, .encrypted_extensions);3    const extensions = try takeVector16(&input);4    try finish(&input);5    return .{ .extensions = .{ .bytes = extensions } };6}

1pub fn decodeFinished(bytes: []const u8) DecodeError!Finished {2    const value = try decode(bytes);3    if (value.kind != .finished) return error.WrongMessage;4    return .{ .verify_data = value.body };5}

1pub fn decodeNewSessionTicket(bytes: []const u8) DecodeError!NewSessionTicket {2    var input = try expected(bytes, .new_session_ticket);3    const lifetime = try input.int(u32);4    const age_add = try input.int(u32);5    const nonce = try takeVector8(&input);6    const ticket = try takeVector16(&input);7    if (ticket.len == 0) return error.InvalidLength;8    const extensions = try takeVector16(&input);9    if (extensions.len > std.math.maxInt(u16) - 1) return error.InvalidLength;10    try finish(&input);11    return .{12        .lifetime = lifetime,13        .age_add = age_add,14        .nonce = nonce,15        .ticket = ticket,16        .extensions = .{ .bytes = extensions },17    };18}

1pub fn decodeServerHello(bytes: []const u8) DecodeError!ServerHello {2    var input = try expected(bytes, .server_hello);3    const legacy_version = try input.int(u16);4    var random: [32]u8 = undefined;5    @memcpy(&random, try input.take(32));6    const session_id = try takeVector8(&input);7    const cipher_suite = try input.int(u16);8    const compression_method = try input.byte();9    const extensions = try takeVector16(&input);10    try finish(&input);11    return .{12        .legacy_version = legacy_version,13        .random = random,14        .legacy_session_id_echo = session_id,15        .cipher_suite = cipher_suite,16        .compression_method = compression_method,17        .extensions = .{ .bytes = extensions },18    };19}

1pub fn encode(value: Handshake, output: *cursor.Write) EncodeError!void {2    try writeHeader(value.kind, value.body.len, output);3    try output.put(value.body);4}

1pub fn encodeCertificate(value: Certificate, output: *cursor.Write) EncodeError!void {2    var length = try addLength(1, value.request_context.len);3    length = try addLength(length, 3);4    length = try addLength(length, value.entries.bytes.len);5    try writeHeader(.certificate, length, output);6    try writeVector8(value.request_context, output);7    try writeVector24(value.entries.bytes, output);8}

1pub fn encodeCertificateRequest(2    value: CertificateRequest,3    output: *cursor.Write,4) EncodeError!void {5    var length = try addLength(1, value.context.len);6    length = try addLength(length, 2);7    length = try addLength(length, value.extensions.bytes.len);8    try writeHeader(.certificate_request, length, output);9    try writeVector8(value.context, output);10    try writeVector16(value.extensions.bytes, output);11}

1pub fn encodeCertificateVerify(2    value: CertificateVerify,3    output: *cursor.Write,4) EncodeError!void {5    const length = try addLength(4, value.signature.len);6    try writeHeader(.certificate_verify, length, output);7    try output.int(u16, @backingInt(value.algorithm));8    try writeVector16(value.signature, output);9}

1pub fn encodeClientHello(value: ClientHello, output: *cursor.Write) EncodeError!void {2    if (value.cipher_suites.len == 0) return error.InvalidLength;3    if (value.cipher_suites.len % 2 != 0) return error.InvalidLength;4    const length = try helloLength(5        value.legacy_session_id.len,6        value.cipher_suites.len,7        value.compression_methods.len,8        value.extensions.bytes.len,9    );10    try writeHeader(.client_hello, length, output);11    try output.int(u16, value.legacy_version);12    try output.put(&value.random);13    try writeVector8(value.legacy_session_id, output);14    try writeVector16(value.cipher_suites, output);15    try writeVector8(value.compression_methods, output);16    try writeVector16(value.extensions.bytes, output);17}

1pub fn encodeEncryptedExtensions(2    value: EncryptedExtensions,3    output: *cursor.Write,4) EncodeError!void {5    const length = try addLength(2, value.extensions.bytes.len);6    try writeHeader(.encrypted_extensions, length, output);7    try writeVector16(value.extensions.bytes, output);8}

1pub fn encodeFinished(value: Finished, output: *cursor.Write) EncodeError!void {2    try writeHeader(.finished, value.verify_data.len, output);3    try output.put(value.verify_data);4}

1pub fn encodeServerHello(value: ServerHello, output: *cursor.Write) EncodeError!void {2    var length: usize = 2 + 32 + 1 + 2 + 1 + 2;3    length = try addLength(length, value.legacy_session_id_echo.len);4    length = try addLength(length, value.extensions.bytes.len);5    try writeHeader(.server_hello, length, output);6    try output.int(u16, value.legacy_version);7    try output.put(&value.random);8    try writeVector8(value.legacy_session_id_echo, output);9    try output.int(u16, value.cipher_suite);10    try output.byte(value.compression_method);11    try writeVector16(value.extensions.bytes, output);12}

1pub fn encodeSingleCertificate(2    request_context: []const u8,3    certificate: []const u8,4    output: *cursor.Write,5) EncodeError!void {6    var entries_length = try addLength(3, certificate.len);7    entries_length = try addLength(entries_length, 2);8    var length = try addLength(1, request_context.len);9    length = try addLength(length, 3);10    length = try addLength(length, entries_length);11    try writeHeader(.certificate, length, output);12    try writeVector8(request_context, output);13    try writeLength(u24, entries_length, output);14    try writeVector24(certificate, output);15    try writeVector16(&.{}, output);16}

1pub const extension_count_max: u8 = 64;

1pub fn findExtension(2    extensions: Extensions,3    kind: ExtensionType,4) DecodeError!?[]const u8 {5    var iterator = extensions.iterator();6    var found: ?[]const u8 = null;7    for (0..extension_count_max + 1) |_| {8        const extension = try iterator.next() orelse return found;9        if (@backingInt(extension.kind) != @backingInt(kind)) continue;10        if (found != null) return error.DuplicateExtension;11        found = extension.data;12    }13    unreachable;14}

1const codec = @import("codec.zig");23pub const profile = @import("profile.zig");45pub const extension_count_max = codec.extension_count_max;6pub const certificate_entries_max = codec.certificate_entries_max;7pub const Handshake = codec.Handshake;8pub const Extension = codec.Extension;9pub const Extensions = codec.Extensions;10pub const ExtensionIterator = codec.ExtensionIterator;11pub const ClientHello = codec.ClientHello;12pub const ServerHello = codec.ServerHello;13pub const EncryptedExtensions = codec.EncryptedExtensions;14pub const CertificateRequest = codec.CertificateRequest;15pub const Certificate = codec.Certificate;16pub const CertificateEntry = codec.CertificateEntry;17pub const CertificateEntries = codec.CertificateEntries;18pub const CertificateIterator = codec.CertificateIterator;19pub const CertificateVerify = codec.CertificateVerify;20pub const Finished = codec.Finished;21pub const NewSessionTicket = codec.NewSessionTicket;22pub const DecodeError = codec.DecodeError;23pub const EncodeError = codec.EncodeError;24pub const decode = codec.decode;25pub const encode = codec.encode;26pub const findExtension = codec.findExtension;27pub const decodeClientHello = codec.decodeClientHello;28pub const encodeClientHello = codec.encodeClientHello;29pub const decodeServerHello = codec.decodeServerHello;30pub const encodeServerHello = codec.encodeServerHello;31pub const decodeEncryptedExtensions = codec.decodeEncryptedExtensions;32pub const encodeEncryptedExtensions = codec.encodeEncryptedExtensions;33pub const decodeCertificateRequest = codec.decodeCertificateRequest;34pub const encodeCertificateRequest = codec.encodeCertificateRequest;35pub const decodeCertificate = codec.decodeCertificate;36pub const encodeCertificate = codec.encodeCertificate;37pub const encodeSingleCertificate = codec.encodeSingleCertificate;38pub const decodeCertificateVerify = codec.decodeCertificateVerify;39pub const encodeCertificateVerify = codec.encodeCertificateVerify;40pub const decodeFinished = codec.decodeFinished;41pub const encodeFinished = codec.encodeFinished;42pub const decodeNewSessionTicket = codec.decodeNewSessionTicket;

1pub const message = @import("message/root.zig");