Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-tls

Source of release 0.7.0

0.7.0 / src / server.lucb

## A small TLS 1.3 server handshake for private endpoints and loopback tests:
## one ECDSA-P256 certificate, x25519 key exchange, and the first mutually
## supported cipher suite. A test may force a HelloRetryRequest by asking for a
## group the client did not send a share for, and may request a client
## certificate, which must then arrive empty. No resumption.
import io
import memory
import os
from luce_crypto import native as crypto
import record
import handshake as hs
import signature

pub let invalid = crypto.invalid

## Server suite preference; only suites the record layer supports are chosen.
let preferred_suites: u16[3] = [0x1303, 0x1301, 0x1302]

## The ClientHello fields the server uses.
struct ClientHello:
    var session: u8[32]
    var session_size: usize
    var suite: u16
    var share: u8[97]
    var share_size: usize
    var share_group: u16
    var offers_x25519: bool
    var offers_p256: bool
    var cookie_size: usize
    var only_suite: u16

## Answer a client on an accepted transport with certificate `der` and P-256
## private key `d`. `retry_group`, when not zero, is demanded by a
## HelloRetryRequest unless the first ClientHello already shares it.
## `request_certificate` sends a CertificateRequest. `suite`, when not zero,
## is the only cipher suite the server accepts.
pub func accept(channel: record.Channel*, source: io.Reader, sink: io.Writer, der: const u8[], d: const u8[],
    retry_group: u16 = 0, request_certificate: bool = false, suite: u16 = 0) -> !:
    if der.length == 0 or der.length > 16000:
        error(invalid, "server certificate size is out of range")
    var messages = try hs.Messages.create()
    defer messages.close()
    var first = try messages.next(channel, source)
    var hello = ClientHello(only_suite = suite)
    try parse_client_hello(first, &hello)
    let parameters = try record.suite_for(hello.suite)
    var schedule = try hs.Schedule.start(parameters)
    defer schedule.wipe()
    var group = hs.group_x25519
    if retry_group != 0:
        group = retry_group
    elif not hello.offers_x25519:
        error(invalid, "the client does not support x25519")
    if hello.share_group != group:
        try schedule.add_retry_hash(first)
        var retry: u8[128]
        let retry_size = try build_server_hello(retry, &hello, true, group, b"")
        try schedule.add(retry[..<retry_size])
        try channel.send(sink, record.handshake, retry[..<retry_size])
        first = try messages.next(channel, source)
        let suite_before = hello.suite
        hello = ClientHello(only_suite = suite)
        try parse_client_hello(first, &hello)
        if hello.share_group != group or hello.suite != suite_before:
            error(invalid, "the second ClientHello ignores the HelloRetryRequest")
    try schedule.add(first)
    var share = try hs.KeyShare.generate(group)
    defer share.wipe()
    var shared: u8[48]
    defer crypto.wipe(shared)
    let shared_size = try share.agree(hello.share[..<hello.share_size], shared)
    var reply: u8[256]
    let reply_size = try build_server_hello(reply, &hello, false, group, share.public_key())
    try schedule.add(reply[..<reply_size])
    try channel.send(sink, record.handshake, reply[..<reply_size])
    let ccs = b"\x01"
    try channel.send(sink, record.change_cipher_spec, ccs)
    try schedule.enter_handshake(shared[..<shared_size])
    try channel.protect_write(parameters, schedule.handshake_secret(false))
    try channel.protect_read(parameters, schedule.handshake_secret(true))
    var flight = try new u8[der.length + 512] in memory.heap
    defer free(flight) in memory.heap
    let flight_size = try build_flight(flight, &schedule, der, d, parameters, request_certificate)
    try channel.send(sink, record.handshake, flight[..<flight_size])
    var client_secret: u8[48]
    var server_secret: u8[48]
    defer crypto.wipe(client_secret)
    defer crypto.wipe(server_secret)
    try schedule.enter_application(client_secret, server_secret)
    var message = try messages.next(channel, source)
    if request_certificate:
        if message.length != 8 or message[0] != hs.certificate or (message[4] | message[5] | message[6] | message[7]) != 0:
            error(invalid, "expected an empty client Certificate")
        try schedule.add(message)
        message = try messages.next(channel, source)
    var expected: u8[48]
    try schedule.finished_value(schedule.handshake_secret(true), expected[..<parameters.hash_size])
    try hs.check_finished(message, expected[..<parameters.hash_size])
    if not messages.empty():
        error(invalid, "unexpected handshake data after client Finished")
    try channel.start_application(parameters, client_secret[..<parameters.hash_size], server_secret[..<parameters.hash_size])

func u16_at(data: const u8[], at: usize) -> u16:
    return ((u16)data[at] << 8) | (u16)data[at + 1]

func parse_client_hello(message: const u8[], out: ClientHello*) -> !:
    if message.length < 4 + 2 + 32 + 1 or message[0] != hs.client_hello or hs.message_length(message) != message.length - 4:
        error(invalid, "expected a ClientHello")
    var at: usize = 38
    out.session_size = (usize)message[at]
    at += 1
    if out.session_size > 32 or message.length - at < out.session_size + 2:
        error(invalid, "invalid ClientHello session id")
    for i in 0..<out.session_size:
        out.session[i] = message[at + i]
    at += out.session_size
    let suites_size = (usize)u16_at(message, at)
    at += 2
    if suites_size == 0 or suites_size % 2 != 0 or message.length - at < suites_size + 1:
        error(invalid, "invalid ClientHello cipher suites")
    for p in 0..<preferred_suites.length:
        let allowed = out.only_suite == 0 or out.only_suite == preferred_suites[p]
        if out.suite == 0 and allowed and record.suite_supported(preferred_suites[p]):
            for i in 0..<suites_size // 2:
                if u16_at(message, at + 2 * i) == preferred_suites[p]:
                    out.suite = preferred_suites[p]
    if out.suite == 0:
        error(invalid, "no shared TLS 1.3 cipher suite")
    at += suites_size
    let compression_size = (usize)message[at]
    at += 1 + compression_size
    if message.length - at < 2 or (usize)u16_at(message, at) != message.length - at - 2:
        error(invalid, "invalid ClientHello extensions")
    at += 2
    var tls13 = false
    while at < message.length:
        if message.length - at < 4:
            error(invalid, "truncated ClientHello extension")
        let kind = u16_at(message, at)
        let size = (usize)u16_at(message, at + 2)
        at += 4
        if size > message.length - at:
            error(invalid, "ClientHello extension runs past its container")
        let value = message[at..<at + size]
        if kind == 0x002b:
            var i: usize = 1
            while i + 1 < size:
                if value[i] == 3 and value[i + 1] == 4:
                    tls13 = true
                i += 2
        elif kind == 0x000a:
            var i: usize = 2
            while i + 1 < size:
                if u16_at(value, i) == hs.group_x25519:
                    out.offers_x25519 = true
                if u16_at(value, i) == hs.group_secp256r1:
                    out.offers_p256 = true
                i += 2
        elif kind == 0x0033:
            try parse_shares(value, out)
        elif kind == 0x002c:
            out.cookie_size = size
        at += size
    if not tls13:
        error(invalid, "the client does not offer TLS 1.3")

func parse_shares(value: const u8[], out: ClientHello*) -> !:
    if value.length < 2 or (usize)u16_at(value, 0) != value.length - 2:
        error(invalid, "invalid ClientHello key_share")
    var at: usize = 2
    while at < value.length:
        if value.length - at < 4:
            error(invalid, "truncated ClientHello key share")
        let group = u16_at(value, at)
        let size = (usize)u16_at(value, at + 2)
        at += 4
        if size > value.length - at:
            error(invalid, "ClientHello key share runs past its container")
        if out.share_size == 0 and size <= out.share.length:
            out.share_group = group
            for i in 0..<size:
                out.share[i] = value[at + i]
            out.share_size = size
        at += size

func build_server_hello(out: u8[], hello: const ClientHello*, retry: bool, group: u16, share: const u8[]) -> usize!:
    var b = hs.Builder.over(out)
    b.put8(hs.server_hello)
    let body = b.open(3)
    b.put16(0x0303)
    if retry:
        b.put(b"\xcf\x21\xad\x74\xe5\x9a\x61\x11\xbe\x1d\x8c\x02\x1e\x65\xb8\x91\xc2\xa2\x11\x16\x7a\xbb\x8c\x5e\x07\x9e\x09\xe2\xc8\xa8\x33\x9c")
    else:
        var random: u8[32]
        try os.random_bytes(random)
        b.put(random)
    b.put8((u8)hello.session_size)
    b.put(hello.session[..<hello.session_size])
    b.put16((usize)hello.suite)
    b.put8(0)
    let extensions = b.open(2)
    b.put16(0x002b)
    b.put16(2)
    b.put16(0x0304)
    b.put16(0x0033)
    let key_share = b.open(2)
    b.put16((usize)group)
    if not retry:
        b.put16(share.length)
        b.put(share)
    b.close(key_share, 2)
    b.close(extensions, 2)
    b.close(body, 3)
    return b.size()

## EncryptedExtensions, Certificate, CertificateVerify and server Finished.
func build_flight(out: u8[], schedule: hs.Schedule*, der: const u8[], d: const u8[], suite: record.Suite,
    request_certificate: bool) -> usize!:
    var b = hs.Builder.over(out)
    b.put(b"\x08\x00\x00\x02\x00\x00")
    try schedule.add(out[..<6])
    if request_certificate:
        let request = b"\x0d\x00\x00\x0b\x00\x00\x08\x00\x0d\x00\x04\x00\x02\x04\x03"
        b.put(request)
        try schedule.add(request)
    let certificate_at = b.size()
    b.put8(hs.certificate)
    let body = b.open(3)
    b.put8(0)
    let list = b.open(3)
    let entry = b.open(3)
    b.put(der)
    b.close(entry, 3)
    b.put16(0)
    b.close(list, 3)
    b.close(body, 3)
    try schedule.add(out[certificate_at..<b.size()])
    var transcript_hash: u8[48]
    let hash_size = try schedule.current(transcript_hash)
    var content: u8[160]
    let content_size = hs.verify_content(true, transcript_hash[..<hash_size], content)
    var digest: u8[32]
    _ = try crypto.digest(content[..<content_size], digest, "sha256")
    var r: u8[32]
    var s: u8[32]
    try crypto.ecdsa_p256_sign(d, digest, r, s)
    let verify_at = b.size()
    b.put8(hs.certificate_verify)
    let verify_body = b.open(3)
    b.put16((usize)signature.ecdsa_secp256r1_sha256)
    let signature_size = b.open(2)
    let sequence = b.open(2)
    out[sequence] = 0x30
    put_der_integer(&b, r)
    put_der_integer(&b, s)
    out[sequence + 1] = (u8)(b.size() - sequence - 2)
    b.close(signature_size, 2)
    b.close(verify_body, 3)
    try schedule.add(out[verify_at..<b.size()])
    var verify: u8[48]
    try schedule.finished_value(schedule.handshake_secret(false), verify[..<suite.hash_size])
    let finished_at = b.size()
    b.put8(hs.finished)
    let finished_body = b.open(3)
    b.put(verify[..<suite.hash_size])
    b.close(finished_body, 3)
    try schedule.add(out[finished_at..<b.size()])
    return b.size()

## A minimal DER INTEGER for a 32-byte unsigned big-endian value.
func put_der_integer(b: hs.Builder*, value: const u8[]):
    var start: usize = 0
    while start + 1 < value.length and value[start] == 0:
        start += 1
    let sign_byte = value[start] >= 0x80
    b.put8(0x02)
    b.put8((u8)(value.length - start + (1 if sign_byte else 0)))
    if sign_byte:
        b.put8(0)
    b.put(value[start..])