dymokomi/luc
Source of release 0.24.0
## 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