Luce packages
LuceLuce BaseLuciaOS

dymokomi/luc

Source of release 0.24.3

0.24.3 / src / credentials.lucb

## Encrypted origin-bound session credentials; explicit non-terminal stdin only.
from luce_crypto import native as crypto
import io
import strings
import platform
from luce_std import files
import c
import registry_http as registry

let invalid: ErrorCode = ErrorCode.package(5)
extern func isatty(descriptor: i32) -> i32

func origin_valid(origin: str) -> bool:
    return registry.valid(origin)

func name_valid(name: str) -> bool:
    if name.length == 0 or name.length > 32: return false
    for byte in name.bytes:
        if not ((byte >= 'a' and byte <= 'z') or (byte >= '0' and byte <= '9') or byte == '_'): return false
    return true

func token_valid(token: const u8[]) -> bool:
    if token.length != 32: return false
    for byte in token:
        if not ((byte >= 'a' and byte <= 'f') or (byte >= '0' and byte <= '9')): return false
    return true

func credential_token_valid(token: const u8[]) -> bool:
    if token.length != 64: return false
    for byte in token:
        if not ((byte >= 'a' and byte <= 'f') or (byte >= '0' and byte <= '9')): return false
    return true

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

extern func tcgetattr(descriptor: i32, state: u8*) -> i32
extern func tcsetattr(descriptor: i32, actions: i32, state: const u8*) -> i32

## Read one line from the terminal without echo. The local-mode flags sit at a different
## offset in each system's termios; ECHO is bit 3 on both.
func hidden_line(prompt: str, output: u8[]) -> usize!:
    try io.stderr().write(prompt)
    var state: u8[256]
    if tcgetattr(0, &state[0]) != 0: error(invalid, "cannot read the terminal state")
    let flags: usize = 24 if platform.macos else 12
    let saved = state[flags]
    state[flags] = saved & 0xf7
    if tcsetattr(0, 0, &state[0]) != 0: error(invalid, "cannot turn off terminal echo")
    var reader = io.stdin()
    var size: usize = 0
    var failed = false
    while true:
        var byte: u8[1]
        let n = reader.read(byte[0..]) catch:
            failed = true
            recover 0
        if n == 0 or byte[0] == '\n': break
        if byte[0] == '\r': continue
        if size >= output.length:
            failed = true
            break
        output[size] = byte[0]
        size += 1
    state[flags] = saved
    _ = tcsetattr(0, 0, &state[0])
    try io.stderr().write("\n")
    if failed: error(invalid, "secret input failed or is too long")
    return size

## Secrets come from a private pipe, one line each, or are asked for at a terminal with
## echo off. A prompt starting with "Choose" or "New" is asked twice and must match.
func input(buffer: u8[], prompts: const str[]) -> usize!:
    if not (platform.macos or platform.linux): error(invalid, "credential stdin requires POSIX")
    if isatty(0) != 0:
        var size: usize = 0
        for prompt in prompts:
            var line: u8[1100]
            defer crypto.wipe(line)
            let length = try hidden_line(prompt, line[0..])
            if strings.starts_with(prompt, "Choose") or strings.starts_with(prompt, "New"):
                var again: u8[1100]
                defer crypto.wipe(again)
                let repeated = try hidden_line("  again: ", again[0..])
                var same = repeated == length
                for i in 0..<(length if same else 0):
                    if line[i] != again[i]: same = false
                if not same: error(invalid, "the two entries do not match; nothing was sent")
            if size + length + 1 > buffer.length: error(invalid, "credential input exceeds bounds")
            for i in 0..<length: buffer[size + i] = line[i]
            buffer[size + length] = '\n'
            size += length + 1
        return size
    var reader = io.stdin()
    var size: usize = 0
    while size < buffer.length:
        let n = try reader.read(buffer[size..])
        if n == 0: return size
        size += n
    error(invalid, "credential input exceeds bounds")

func quote(value: const u8[], output: u8[]) -> usize!:
    var size: usize = 1
    output[0] = '"'
    let digits = b"0123456789abcdef"
    for byte in value:
        let need: usize = 6 if byte < 32 else (2 if byte == '"' or byte == '\\' else 1)
        if size + need + 1 > output.length: error(invalid, "login JSON exceeds server limit")
        if byte < 32:
            output[size] = '\\'
            output[size + 1] = 'u'
            output[size + 2] = '0'
            output[size + 3] = '0'
            output[size + 4] = digits[byte >> 4]
            output[size + 5] = digits[byte & 15]
        elif need == 2:
            output[size] = '\\'
            output[size + 1] = byte
        else: output[size] = byte
        size += need
    output[size] = '"'
    return size + 1

pub func register(origin: str, account: str) -> i32!:
    if not origin_valid(origin) or not name_valid(account): error(invalid, "invalid registration origin or account")
    var incoming: u8[1060]
    defer crypto.wipe(incoming)
    let size = try input(incoming, ["Invitation code: ", "Choose a registry password: "])
    if size < 35 or size > 1058 or incoming[32] != '\n' or incoming[size - 1] != '\n':
        error(invalid, "expected invitation line then password line and EOF")
    let invitation = incoming[..<32]
    if not token_valid(invitation): error(invalid, "invalid invitation code")
    let password = incoming[33..<size - 1]
    for byte in password:
        if byte == '\n': error(invalid, "unexpected additional password line")
    var request: u8[4096]
    defer crypto.wipe(request)
    let beginning = try strings.format(request, f"{{\"code\":\"{(str)invitation}\",\"name\":\"{account}\",\"password\":")
    var length = beginning.length
    length += try quote(password, request[length..<request.length - 1])
    request[length] = '}'
    length += 1
    var response: u8[128]
    defer crypto.wipe(response)
    let result = try registry.request(origin, "POST", "/v1/invites/redeem", "",
        "application/json", request[..<length], response)
    if result.status != 201: error(invalid, "registration not confirmed; check account state before retrying")
    if (str)response[..<result.count] != "registered": error(invalid, "unexpected registration response; account may exist")
    try io.stdout().write("Registered. Now run: luc login\n")
    return 0

pub func create_repository(origin: str, name: str, path: str) -> i32!:
    if not origin_valid(origin) or path.length == 0 or name.length == 0 or name.length > 64:
        error(invalid, "invalid repository origin, name or vault path")
    for i in 0..<name.length:
        let byte = name.bytes[i]
        let alnum = (byte >= 'a' and byte <= 'z') or (byte >= '0' and byte <= '9')
        if not alnum and (i == 0 or (byte != '_' and byte != '-')):
            error(invalid, "invalid repository name")
    var token = try load(path, origin)
    defer token.close()
    var bearer_buffer: u8[48]
    defer crypto.wipe(bearer_buffer)
    let bearer = try strings.format(bearer_buffer, f"Bearer {(str)try token.bytes()}")
    var body: u8[96]
    let payload = try strings.format(body, f"{{\"name\":\"{name}\"}}")
    var response: u8[128]
    let result = try registry.request(origin, "POST", "/v1/repositories", bearer,
        "application/json", payload.bytes, response)
    if result.status != 201: error(invalid, "repository creation not confirmed; check remote state before retrying")
    if (str)response[..<result.count] != "created": error(invalid, "unexpected response; repository may exist")
    try io.stdout().write("Created remote repository.\n")
    return 0

## Create the repository unless it already exists. True when it was created.
pub func ensure_repository(origin: str, name: str, path: str) -> bool!:
    if not origin_valid(origin) or not repository_valid(name): error(invalid, "invalid repository origin or name")
    var token = try load(path, origin)
    defer token.close()
    var bearer_buffer: u8[48]
    defer crypto.wipe(bearer_buffer)
    let bearer = try strings.format(bearer_buffer, f"Bearer {(str)try token.bytes()}")
    var body: u8[96]
    let payload = try strings.format(body, f"{{\"name\":\"{name}\"}}")
    var response: u8[128]
    let result = try registry.request(origin, "POST", "/v1/repositories", bearer, "application/json", payload.bytes, response)
    if result.status == 401: error(invalid, "the saved session is no longer valid; run: luc login")
    if result.status != 201 and result.status != 409: error(invalid, "the registry refused to create the repository")
    return result.status == 201

## A short-lived git:write password for one repository, for the Git credential helper.
pub func write_password(origin: str, repository: str, path: str) -> crypto.Secret!:
    var session = try load(path, origin)
    defer session.close()
    return try issue_credential(try session.bytes(), origin, repository)

## Return a separate owning token only after validating exact origin and framing.
## `luc login`: one password, then a private session file, as gh, npm and cargo keep
## theirs. An existing session file is replaced. Commands that need the session read it
## without asking for anything.
pub func login_session(origin: str, account: str, path: str) -> i32!:
    if not origin_valid(origin) or not name_valid(account) or path.length == 0:
        error(invalid, "invalid login origin, account or session path")
    var incoming: u8[1026]
    defer crypto.wipe(incoming)
    var prompt: u8[160]
    let size = try input(incoming, [try strings.format(prompt, f"Registry password for {account}: ")])
    if size < 2 or size > 1025 or incoming[size - 1] != '\n': error(invalid, "expected one password line")
    var request: u8[4096]
    defer crypto.wipe(request)
    let beginning = try strings.format(request, f"{{\"name\":\"{account}\",\"password\":")
    var length = beginning.length
    length += try quote(incoming[..<size - 1], request[length..<request.length - 1])
    request[length] = '}'
    length += 1
    var response: u8[4096]
    defer crypto.wipe(response)
    let result = try registry.request(origin, "POST", "/v1/sessions", "", "application/json", request[..<length], response)
    if result.status == 401: error(invalid, "wrong account or password; nothing was saved")
    if result.status == 429: error(invalid, "too many attempts; wait a minute and try again")
    if result.status != 200: error(invalid, "the registry refused the login")
    let token = response[..<result.count]
    if not token_valid(token): error(invalid, "invalid registry session response")
    var payload: u8[256]
    defer crypto.wipe(payload)
    let wire = try strings.format(payload, f"LUC1\n{origin}\n{account}\n{(str)token}\n")
    let terminated = try strings.copy(path)
    defer strings.release(terminated)
    try files.write_atomic((c.str)terminated, wire.bytes, permissions = 0o600)
    try io.stdout().write(f"Logged in as {account}.\n")
    return 0

## A session file written by login_session starts with its plain marker.
func plain_session(path: str) -> bool:
    let terminated = strings.copy(path) catch: return false
    defer strings.release(terminated)
    let bytes = files.read((c.str)terminated, limit = 512) catch: return false
    defer bytes.release()
    return bytes.value.length > 5 and (str)bytes.value[..<5] == "LUC1\n"

## The saved session from `luc login`, or a plain error when there is none.
pub func load(path: str, origin: str, account: str = "") -> crypto.Secret!:
    if not origin_valid(origin): error(invalid, "invalid credential origin")
    if not plain_session(path): error(invalid, "not logged in; run: luc login")
    let terminated = try strings.copy(path)
    defer strings.release(terminated)
    let bytes = try files.read((c.str)terminated, limit = 512)
    defer bytes.release()
    defer crypto.wipe((u8[])bytes.value)
    return try decode_token(bytes.value, origin, account)

## A git:write credential for one repository: the only kind there is, since the registry
## takes release tags by push and serves everything else as files.
func issue_credential(session: const u8[], origin: str, repository: str,
                      lifetime_seconds: i64 = 300) -> crypto.Secret!:
    if not origin_valid(origin) or not token_valid(session) or not repository_valid(repository) or lifetime_seconds < 60 or lifetime_seconds > 7776000:
        error(invalid, "invalid scoped credential request")
    var bearer_buffer: u8[48]
    defer crypto.wipe(bearer_buffer)
    let bearer = try strings.format(bearer_buffer, f"Bearer {(str)session}")
    var body: u8[256]
    defer crypto.wipe(body)
    let payload = try strings.format(body, f"{{\"scope\":\"git:write\",\"repository\":\"{repository}\",\"lifetime_seconds\":{lifetime_seconds}}}")
    var response: u8[128]
    defer crypto.wipe(response)
    let result = try registry.request(origin, "POST", "/v1/credentials", bearer,
        "application/json", payload.bytes, response)
    if result.status != 201 or not credential_token_valid(response[..<result.count]):
        error(invalid, "registry credential issuance failed")
    return try crypto.secret_from_bytes(response[..<result.count])

## Print one short-lived repository password for an ordinary stock Git prompt.
## The token is intentionally secret output and expires after five minutes.
pub func issue_git_token(origin: str, repository: str, path: str) -> i32!:
    if not origin_valid(origin) or not repository_valid(repository) or path.length == 0:
        error(invalid, "invalid Git credential context")
    var session = try load(path, origin)
    defer session.close()
    var token = try issue_credential(try session.bytes(), origin, repository)
    defer token.close()
    try io.stdout().write((str)try token.bytes())
    try io.stdout().write("\n")
    return 0

func decode_token(wire: const u8[], origin: str, account: str = "") -> crypto.Secret!:
    var prefix_buffer: u8[64]
    let prefix = try strings.format(prefix_buffer, f"LUC1\n{origin}\n")
    if wire.length < prefix.length + 35 or not strings.starts_with((str)wire, prefix):
        error(invalid, "credential origin mismatch or invalid format")
    var split = prefix.length
    while split < wire.length and wire[split] != '\n': split += 1
    if not name_valid((str)wire[prefix.length..<split]) or wire.length != split + 34 or wire[wire.length - 1] != '\n':
        error(invalid, "invalid credential account or framing")
    if account.length != 0 and (str)wire[prefix.length..<split] != account:
        error(invalid, "credential account mismatch")
    let token = wire[split + 1..<wire.length - 1]
    if not token_valid(token): error(invalid, "invalid stored session token")
    return try crypto.secret_from_bytes(token)