Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-http-client

Source of release 0.5.1

0.5.1 / src / secure.lucb

## HTTP/1.1 over native TLS with either private issuer pinning or the strict
## public ISRG Root X2 certificate-chain profile.
from luce_tls import session as tls
from luce_std import net
import framing

pub let invalid = net.http_invalid

pub struct Response:
    pub var status: u16
    pub var length: usize

## Encode and validate the complete request head before DNS or network I/O.
func encode_request(request: u8[], host: str, method: str, target: str,
                    authorization: str, content_type: str, body: const u8[]) -> usize!:
    var fields: net.HttpField[3]
    var count: usize = 1
    fields[0] = net.HttpField(name = "Host", value = host)
    if authorization.length > 0:
        fields[count] = net.HttpField(name = "Authorization", value = authorization)
        count += 1
    if content_type.length > 0:
        fields[count] = net.HttpField(name = "Content-Type", value = content_type)
        count += 1
    var head = net.HttpHead(method = method, target = target, version = "HTTP/1.1", fields = fields[..<count], keep_alive = false)
    if body.length > 0:
        head.body_kind = net.HttpBodyKind.fixed
        head.body_length = (u64)body.length
    let encoded = try net.http_encode_head(request, head)
    return encoded.length

## Send and decode one request over an already-authenticated TLS connection.
## `output` remains untrusted and must be discarded on any error.
func exchange(conn: net.Connection*, secrets: tls.Secrets*, encoded: const u8[],
              method: str, body: const u8[], output: u8[]) -> Response!:
    try tls.send(conn, secrets, encoded)
    var sent: usize = 0
    while sent < body.length:
        let size = 16384 if body.length - sent > 16384 else body.length - sent
        try tls.send(conn, secrets, body[sent..<sent + size])
        sent += size
    var response = try framing.Decoder.create()
    var incoming: u8[16640]
    while not response.finished():
        let got = try tls.receive(conn, secrets, incoming)
        if got == 0: break
        try response.consume(incoming[..<got], output, method)
    try response.finish()
    return Response(status = response.status, length = response.count)

## One bounded request using a directly pinned P-256 private issuer. This
## compatibility API is intended for private/test servers.
pub func fetch(host: str, port: u16, issuer_x: const u8[], issuer_y: const u8[],
               method: str, target: str, authorization: str, content_type: str,
               body: const u8[], output: u8[]) -> Response!:
    var request: u8[8192]
    let request_len = try encode_request(request, host, method, target, authorization, content_type, body)
    var secrets = tls.Secrets()
    var conn = try tls.connect(host, port, issuer_x, issuer_y, &secrets)
    defer _ = conn.close() catch: recover ()
    return try exchange(&conn, &secrets, request[..<request_len], method, body, output)

## One bounded public HTTPS request under the built-in ISRG Root X2 anchor.
pub func fetch_public(host: str, port: u16, method: str, target: str,
                      authorization: str, content_type: str, body: const u8[],
                      output: u8[]) -> Response!:
    var request: u8[8192]
    let request_len = try encode_request(request, host, method, target, authorization, content_type, body)
    var secrets = tls.Secrets()
    var conn = try tls.connect_public(host, port, &secrets)
    defer _ = conn.close() catch: recover ()
    return try exchange(&conn, &secrets, request[..<request_len], method, body, output)

## One bounded HTTPS request under a caller-supplied P-384 trust anchor.
pub func fetch_p384_chain(host: str, port: u16, root_x: const u8[], root_y: const u8[],
                          method: str, target: str, authorization: str, content_type: str,
                          body: const u8[], output: u8[]) -> Response!:
    var request: u8[8192]
    let request_len = try encode_request(request, host, method, target, authorization, content_type, body)
    var secrets = tls.Secrets()
    var conn = try tls.connect_p384_chain(host, port, root_x, root_y, &secrets)
    defer _ = conn.close() catch: recover ()
    return try exchange(&conn, &secrets, request[..<request_len], method, body, output)