dymokomi/luc
Source of release 0.24.2
0.24.2 / 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
func scope_valid(scope: str) -> bool:
return scope == "git:read" or scope == "git:write" or scope == "package:read" or scope == "package:publish"
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, "git:write")
## 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)
pub func issue_credential(session: const u8[], origin: str, repository: str,
scope: str, lifetime_seconds: i64 = 300) -> crypto.Secret!:
if not origin_valid(origin) or not token_valid(session) or not repository_valid(repository) or not scope_valid(scope) 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\":\"{scope}\",\"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, access: str, path: str) -> i32!:
if not origin_valid(origin) or not repository_valid(repository) or path.length == 0:
error(invalid, "invalid Git credential context")
let scope = "git:read" if access == "read" else ("git:write" if access == "write" else "")
if scope.length == 0: error(invalid, "Git credential access must be read or write")
var session = try load(path, origin)
defer session.close()
var token = try issue_credential(try session.bytes(), origin, repository, scope)
defer token.close()
try io.stdout().write((str)try token.bytes())
try io.stdout().write("\n")
return 0
## Revoke one raw repository credential with the owning interactive session.
pub func revoke_credential(session: const u8[], origin: str, credential: const u8[]) -> !:
if not origin_valid(origin) or not token_valid(session) or not credential_token_valid(credential):
error(invalid, "invalid scoped credential revocation")
var bearer_buffer: u8[48]
defer crypto.wipe(bearer_buffer)
let bearer = try strings.format(bearer_buffer, f"Bearer {(str)session}")
var body: u8[96]
defer crypto.wipe(body)
let payload = try strings.format(body, f"{{\"token\":\"{(str)credential}\"}}")
var response: u8[128]
defer crypto.wipe(response)
let result = try registry.request(origin, "POST", "/v1/credentials/revoke", bearer,
"application/json", payload.bytes, response)
if result.status != 200 or (str)response[..<result.count] != "revoked":
error(invalid, "registry credential revocation failed")
pub func revoke_quiet(session: const u8[], origin: str, credential: const u8[]):
_ = revoke_credential(session, origin, credential) catch: recover ()
## Canonical HTTP Basic authorization for stock Git-compatible endpoints.
pub func basic_authorization(account: str, credential: const u8[], output: u8[]) -> str!:
if not name_valid(account) or not credential_token_valid(credential):
error(invalid, "invalid Git credential")
var raw: u8[97]
defer crypto.wipe(raw)
let value = try strings.format(raw, f"{account}:{(str)credential}")
let encoded_size = ((value.length + 2) // 3) * 4
if output.length < 6 + encoded_size: error(invalid, "Git authorization buffer is too small")
output[0] = 'B'
output[1] = 'a'
output[2] = 's'
output[3] = 'i'
output[4] = 'c'
output[5] = ' '
let alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
var at: usize = 0
var used: usize = 6
while at < value.length:
let remaining = value.length - at
let a = value.bytes[at]
let b: u8 = value.bytes[at + 1] if remaining > 1 else 0
let d: u8 = value.bytes[at + 2] if remaining > 2 else 0
output[used] = alphabet[(usize)(a >> 2)]
output[used + 1] = alphabet[(usize)(((a & 3) << 4) | (b >> 4))]
output[used + 2] = alphabet[(usize)(((b & 15) << 2) | (d >> 6))] if remaining > 1 else '='
output[used + 3] = alphabet[(usize)(d & 63)] if remaining > 2 else '='
at += 3
used += 4
return (str)output[..<used]
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)