#!/usr/bin/bash
set -Eeuo pipefail
trap 'status=$?; printf "image: USER provisioning command failed (exit %s) at %s:%s\n" "${status}" "${BASH_SOURCE[0]}" "${LINENO}" >&2' ERR

key=/run/image-user-provision.key
marker=/run/image-user-provision.required
reset_marker=/run/image-user-provision.factory-reset
# TODO(systemd>=262): Evaluate systemd-cryptenroll-firstboot.service/Varlink
# before replacing this bootstrap coordinator. Require verified human enrollment
# and bootstrap-slot retirement before switch-root
cleanup_failed_enrollment() {
    local status=$?
    trap - EXIT
    [[ ${status} -eq 0 ]] && exit 0

    unset first second 2>/dev/null || true
    rm -f -- "${credential_dir:-/run/image-user-enrollment}/cryptenroll.new-passphrase"
    echo "image: USER credential provisioning failed; existing credentials and data were preserved" >&2
    exit "${status}"
}

root_device() {
    local candidate
    local -a candidates=(/dev/gpt-auto-root-luks /dev/disk/by-designator/root-luks
                        /dev/gpt-auto-root /dev/disk/by-designator/root)
    # Ordinary root links are withheld until native reset completion. Only the
    # enrollment phase, ordered after successful repart, may bypass that gate.
    # Its bootstrap-key check below proves this is our freshly created volume.
    if [[ ${1:-} == enroll && -e ${reset_marker} ]]; then
        candidates=(/dev/gpt-auto-root-luks-ignore-factory-reset
                    /dev/disk/by-designator/root-luks-ignore-factory-reset)
    fi
    # Before unlocking, the native GPT links have the -luks suffix. Never
    # return the decrypted mapper: key enrollment must operate on its header.
    for candidate in "${candidates[@]}"; do
        if [[ -b ${candidate} ]] && cryptsetup isLuks "${candidate}"; then
            readlink -f -- "${candidate}"
            return 0
        fi
    done
    return 1
}

case ${1:?prepare or enroll required} in
prepare)
    umask 0077
    echo 'image: preparing USER provisioning' >&2
    reset_status=0
    reset_state="$(/usr/lib/systemd/systemd-factory-reset status)" || reset_status=$?
    [[ ${reset_status} == 0 || ${reset_status} == 10 || ${reset_status} == 11 ]] || {
        echo 'image: cannot determine factory-reset state; refusing provisioning' >&2
        exit 1
    }
    case ${reset_state} in
        on)
            dd if=/dev/urandom of="${key}" bs=64 count=1 status=none
            : >"${reset_marker}"
            : >"${marker}"
            echo 'image: explicit factory reset; recreate and provision USER in this boot' >&2
            exit 0
            ;;
        off|unspecified|unsupported|pending|complete) ;;
        *) echo "image: unexpected factory-reset state '${reset_state}'" >&2; exit 1 ;;
    esac
    probe_status=0
    device="$(/usr/lib/image-user-device)" || probe_status=$?
    case ${probe_status} in
    3)
        echo 'image: USER is absent; provisioning required after repart' >&2
        dd if=/dev/urandom of="${key}" bs=64 count=1 status=none
        : >"${marker}"
        ;;
    0)
        echo "image: existing encrypted USER at ${device}; preserving its keys and data" >&2
        # A keyslot number does not identify its owner. A public token records
        # our bootstrap transaction, but never authorizes automatic erasure.
        if cryptsetup luksDump --dump-json-metadata "${device}" 2>/dev/null |
                jq -e 'any(.tokens[]?; .type == "image-user-bootstrap" and .imageProvisioning == 1)' >/dev/null; then
            echo 'image: incomplete USER provisioning detected; use the passphrase if already set, otherwise request an explicit factory reset; automatic erasure is disabled' >&2
        fi
        ;;
    *)
        echo 'image: cannot safely determine USER state; refusing provisioning' >&2
        exit 1
        ;;
    esac
    ;;
enroll)
    [[ -e ${marker} ]] || exit 0
    trap cleanup_failed_enrollment EXIT
    if ! device="$(root_device enroll)"; then
        # Repart has finished formatting. Wait only for the native root link
        # needed by this boot, not for unrelated devices to finish probing.
        root_link=/dev/gpt-auto-root-luks
        [[ ! -e ${reset_marker} ]] || root_link=/dev/gpt-auto-root-luks-ignore-factory-reset
        udevadm wait --timeout=60 --initialized=no "${root_link}"
        device="$(root_device enroll)" || { echo 'image: repart did not create USER' >&2; exit 1; }
    fi
    [[ ! -e /dev/mapper/root ]] || {
        echo 'image: root mapper already exists; refusing concurrent bootstrap enrollment' >&2
        exit 1
    }
    echo "image: enrolling credentials for newly created USER at ${device}" >&2
    # Only a freshly created volume with a single slot owned by this boot's
    # random key may enter bootstrap enrollment. Existing volumes are never
    # reformatted or enrolled because they happen to have a slot numbered 0.
    metadata="$(cryptsetup luksDump --dump-json-metadata "${device}")"
    bootstrap_slot="$(jq -er '.keyslots | keys | if length == 1 then .[0] else error("expected one bootstrap keyslot") end' <<<"${metadata}")"
    [[ ${bootstrap_slot} =~ ^[0-9]+$ ]] || exit 1
    jq -e '(.tokens | length) == 0' <<<"${metadata}" >/dev/null
    cryptsetup open --test-passphrase --key-slot="${bootstrap_slot}" --key-file="${key}" "${device}"
    jq -n --arg slot "${bootstrap_slot}" \
        '{type:"image-user-bootstrap", keyslots:[$slot], imageProvisioning:1}' |
        cryptsetup token import --token-id=0 --json-file=- "${device}"
    unset metadata

    while true; do
        # Use cryptsetup's native expiring kernel cache
        first="$(systemd-ask-password --no-tty --keyname=cryptsetup --timeout=0 'Set the disk-encryption passphrase:')"
        [[ ${#first} -ge 8 ]] || { echo 'Passphrase must have at least eight characters.' >&2; continue; }
        second="$(systemd-ask-password --no-tty --timeout=0 'Repeat the disk-encryption passphrase:')"
        [[ ${first} == "${second}" ]] && break
        unset first second
        echo 'Passphrases do not match.' >&2
    done

    # Native enrollment consumes a private, volatile service credential.
    credential_dir=/run/image-user-enrollment
    install -d -m 0700 "${credential_dir}"
    (umask 0077; printf %s "${first}" >"${credential_dir}/cryptenroll.new-passphrase")
    CREDENTIALS_DIRECTORY="${credential_dir}" systemd-cryptenroll \
        --password --unlock-key-file="${key}" "${device}"
    printf %s "${first}" | cryptsetup open --test-passphrase --key-file=- "${device}"
    unset first second
    rm -f -- "${credential_dir}/cryptenroll.new-passphrase"

    # The human passphrase was independently verified before retiring only
    # the keyslot that we proved belongs to this boot's bootstrap key.
    echo 'image: retiring the verified bootstrap keyslot' >&2
    systemd-cryptenroll --unlock-key-file="${key}" --wipe-slot="${bootstrap_slot}" "${device}"
    if cryptsetup luksDump --dump-json-metadata "${device}" |
            jq -e '.tokens["0"].type == "image-user-bootstrap"' >/dev/null; then
        cryptsetup token remove --token-id=0 "${device}"
    fi
    trap - EXIT
    # The native completion service checks this proof as well as unit success:
    # a skipped provisioning unit must never authorize reset completion.
    : >/run/image-user-provision.complete
    rm -f -- "${key}" "${marker}" "${reset_marker}"
    echo 'image: USER provisioning completed successfully' >&2
    ;;
*)
    echo "Unknown operation: $1" >&2
    exit 2
    ;;
esac
