Luce packages
LuceLuce BaseLuciaOS

dymokomi/luc

Source of release 0.24.1

0.24.1 / src / remote.lucb

## Native Git smart-HTTP transport over canonical loopback HTTP or verified
## production HTTPS.
from luce_git import git
import os
import c
import strings
import memory
import io
from luce_std import files, paths
from luce_crypto import native as crypto_native
import pack_check
import credentials
import registry_http as registry

let invalid: ErrorCode = ErrorCode.package(2)

func revoke_managed(managed: bool, origin: str, session: crypto_native.Secret*, credential: crypto_native.Secret*):
    if not managed: return
    let session_bytes = session.bytes() catch: return
    let credential_bytes = credential.bytes() catch: return
    _ = credentials.revoke_credential(session_bytes, origin, credential_bytes) catch: recover ()

func component(value: str, owner: bool) -> bool:
    if value.length == 0 or value.length > (32 if owner else 64): return false
    for i in 0..<value.length:
        let byte = value.bytes[i]
        let alnum = (byte >= 'a' and byte <= 'z') or (byte >= '0' and byte <= '9')
        if not alnum and byte != '_' and (owner or byte != '-'): return false
        if not owner and i == 0 and not alnum: return false
    return true

## Validate the complete advertisement before printing any untrusted server text.
func advertisement(wire: const u8[], emit: bool, wanted: const u8[]) -> bool!:
    var found = false
    let service = try git.decode_packet(wire)
    if service.kind != git.PacketKind.data or (str)service.payload != "# service=git-upload-pack\n":
        error(invalid, "invalid Git service advertisement")
    var at = service.consumed
    let separator = try git.decode_packet(wire[at..])
    if separator.kind != git.PacketKind.flush: error(invalid, "missing Git service flush")
    at += separator.consumed
    var count: usize = 0
    var empty = false
    while at < wire.length:
        let packet = try git.decode_packet(wire[at..])
        at += packet.consumed
        if packet.kind == git.PacketKind.flush:
            if at != wire.length or count == 0: error(invalid, "invalid Git discovery end")
            return found
        if packet.kind != git.PacketKind.data or count >= 2049 or empty:
            error(invalid, "invalid Git discovery packet")
        var line = packet.payload
        if line.length > 0 and line[line.length - 1] == '\n': line = line[..<line.length - 1]
        var end: usize = 0
        while end < line.length and line[end] != 0: end += 1
        if count == 0:
            if end == line.length: error(invalid, "missing Git discovery capabilities")
            if line.length - end - 1 > 4096: error(invalid, "Git discovery capabilities too large")
            for i in end + 1..<line.length:
                if line[i] < 32 or line[i] > 126: error(invalid, "invalid Git capability text")
        elif end != line.length: error(invalid, "unexpected Git capability field")
        if end < 42 or line[40] != ' ': error(invalid, "invalid advertised identity")
        let identity = (str)line[..<40]
        var id: u8[20]
        try git.decode_id(identity, id)
        if wanted.length == 20 and crypto_native.equal(id, wanted): found = true
        let name = (str)line[41..<end]
        var zero = true
        for byte in id:
            if byte != 0: zero = false
        if zero:
            if count != 0 or name != "capabilities^{}": error(invalid, "invalid null advertised identity")
            empty = true
        else:
            var ref = name
            if strings.ends_with(ref, "^{}"): ref = (str)ref.bytes[..<ref.length - 3]
            if name != "HEAD" and not git.valid_ref(ref): error(invalid, "invalid advertised ref")
            if emit: try io.stdout().write(f"{identity}\t{name}\n")
        count += 1
    error(invalid, "missing Git discovery flush")

pub func refs(url: str, vault_path: str = "") -> i32!:
    return try run(url, "", "", vault_path)

pub func fetch(url: str, commit: str, destination: str, vault_path: str = "") -> i32!:
    if commit.length != 40 or destination.length == 0: error(invalid, "invalid fetch commit or destination")
    for byte in destination.bytes:
        if byte == 0: error(invalid, "invalid destination path")
    return try run(url, commit, destination, vault_path)

## Fetch one advertised commit into caller-owned bounded storage using an
## already-unlocked session. The exact returned prefix is a validated full pack.
pub func fetch_into(url: str, commit: str, session: const u8[], incoming: u8[]) -> usize!:
    # The HTTP transport's 64 MiB response limit includes Git framing.
    if commit.length != 40 or incoming.length < 67108864: error(invalid, "invalid fetch input")
    var requested: u8[20]
    try git.decode_id(commit, requested)
    let at = try registry.url_origin_length(url)
    let origin = (str)url.bytes[..<at]
    let path = (str)url.bytes[at..]
    if not strings.starts_with(path, "/git/"): error(invalid, "invalid registry repository URL")
    var split: usize = 5
    while split < path.length and path.bytes[split] != '/': split += 1
    if split == path.length: error(invalid, "missing registry package name")
    let owner = (str)path.bytes[5..<split]
    let repository = (str)path.bytes[split + 1..]
    if not component(owner, true) or not component(repository, false):
        error(invalid, "invalid registry owner or package name")
    var scoped = try credentials.issue_credential(session, origin, repository, "git:read")
    defer scoped.close()
    let token = try scoped.bytes()
    defer credentials.revoke_quiet(session, origin, token)
    var authorization_buffer: u8[160]
    defer crypto_native.wipe(authorization_buffer)
    let authorization = try credentials.basic_authorization(owner, token, authorization_buffer)
    var target_buffer: u8[256]
    let target = try strings.format(target_buffer, f"{path}/info/refs?service=git-upload-pack")
    let discovery = try new u8[4194304] --- in memory.heap
    defer free(discovery) in memory.heap
    let advertised = try registry.request(origin, "GET", target, authorization, "", b"", discovery)
    if advertised.status != 200: error(invalid, "registry discovery request failed")
    if not try advertisement(discovery[..<advertised.count], false, requested):
        error(invalid, "requested commit is not advertised")
    var encoded: u8[40]
    _ = try git.hex_id(requested, encoded)
    var line_buffer: u8[64]
    let line = try strings.format(line_buffer, f"want {(str)encoded}\n")
    var request: u8[128]
    var size = try git.encode_packet(git.PacketKind.data, line.bytes, request)
    size += try git.encode_packet(git.PacketKind.flush, b"", request[size..])
    size += try git.encode_packet(git.PacketKind.data, b"done\n", request[size..])
    var fetch_target: u8[256]
    let endpoint = try strings.format(fetch_target, f"{path}/git-upload-pack")
    let response = try registry.request(origin, "POST", endpoint, authorization,
        "application/x-git-upload-pack-request", request[..<size], incoming)
    if response.status != 200: error(invalid, "registry fetch request failed")
    let acknowledgement = try git.decode_packet(incoming[..<response.count])
    if acknowledgement.kind != git.PacketKind.data or (str)acknowledgement.payload != "NAK\n":
        error(invalid, "invalid initial fetch acknowledgement")
    let wire = incoming[acknowledgement.consumed..<response.count]
    var pack = try git.decode_pack(wire)
    defer pack.close()
    try pack_check.validate(&pack, requested)
    let pack_size = wire.length
    for i in 0..<pack_size: incoming[i] = wire[i]
    return pack_size

func run(url: str, commit: str, destination: str, vault_path: str) -> i32!:
    var requested: u8[20]
    if commit.length > 0: try git.decode_id(commit, requested)
    let at = try registry.url_origin_length(url)
    let origin = (str)url.bytes[..<at]
    let path = (str)url.bytes[at..]
    if not strings.starts_with(path, "/git/"): error(invalid, "invalid registry repository URL")
    var split: usize = 5
    while split < path.length and path.bytes[split] != '/': split += 1
    if split == path.length: error(invalid, "missing registry package name")
    let owner = (str)path.bytes[5..<split]
    let repository = (str)path.bytes[split + 1..]
    if not component(owner, true) or not component(repository, false):
        error(invalid, "invalid registry owner or package name")
    var session = crypto_native.Secret()
    defer session.close()
    var scoped = crypto_native.Secret()
    defer scoped.close()
    var managed = false
    defer revoke_managed(managed, origin, &session, &scoped)
    var token: str
    if vault_path.length > 0:
        session = try credentials.load(vault_path, origin, owner)
        scoped = try credentials.issue_credential(try session.bytes(), origin, repository, "git:read")
        token = (str)try scoped.bytes()
        managed = true
    else:
        token = os.env((c.str)"LUCE_REGISTRY_TOKEN") else error(invalid, "LUCE_REGISTRY_TOKEN is required")
    var target_buffer: u8[256]
    let target = try strings.format(target_buffer, f"{path}/info/refs?service=git-upload-pack")
    var authorization_buffer: u8[160]
    defer crypto_native.wipe(authorization_buffer)
    let authorization = try credentials.basic_authorization(owner, token.bytes, authorization_buffer)
    let output = try new u8[4194304] --- in memory.heap
    defer free(output) in memory.heap
    let result = try registry.request(origin, "GET", target, authorization, "", b"", output)
    if result.status != 200: error(invalid, "registry discovery request failed")
    if commit.length == 0:
        _ = try advertisement(output[..<result.count], false, b"")
        _ = try advertisement(output[..<result.count], true, b"")
        return 0
    if not try advertisement(output[..<result.count], false, requested): error(invalid, "requested commit is not advertised")
    var encoded: u8[40]
    _ = try git.hex_id(requested, encoded)
    var line_buffer: u8[64]
    let line = try strings.format(line_buffer, f"want {(str)encoded}\n")
    var request: u8[128]
    var size = try git.encode_packet(git.PacketKind.data, line.bytes, request)
    size += try git.encode_packet(git.PacketKind.flush, b"", request[size..])
    size += try git.encode_packet(git.PacketKind.data, b"done\n", request[size..])
    var fetch_target: u8[256]
    let endpoint = try strings.format(fetch_target, f"{path}/git-upload-pack")
    let incoming = try new u8[67108864] --- in memory.heap
    defer free(incoming) in memory.heap
    let response = try registry.request(origin, "POST", endpoint, authorization,
        "application/x-git-upload-pack-request", request[..<size], incoming)
    if response.status != 200: error(invalid, "registry fetch request failed")
    let acknowledgement = try git.decode_packet(incoming[..<response.count])
    if acknowledgement.kind != git.PacketKind.data or (str)acknowledgement.payload != "NAK\n":
        error(invalid, "invalid initial fetch acknowledgement")
    let wire = incoming[acknowledgement.consumed..<response.count]
    var pack = try git.decode_pack(wire)
    defer pack.close()
    try pack_check.validate(&pack, requested)
    # No destination entry is created until all protocol and graph checks pass.
    let filename = try strings.copy(destination)
    defer strings.release(filename)
    let directory = paths.directory(filename)
    let parent = try strings.copy(directory if directory.length > 0 else ".")
    defer strings.release(parent)
    var temporary = try files.TemporaryFile.create((c.str)parent)
    defer temporary.destroy()
    try io.write_all(&temporary, wire)
    try temporary.sync()
    try temporary.publish((c.str)filename, replace = false)
    try io.stdout().write("downloaded validated Git pack (release signature not verified)\n")
    return 0