reach_attestant/

commands.rs

// SPDX-FileCopyrightText: 2023-2025 eaon <eaon@posteo.net>
// SPDX-License-Identifier: EUPL-1.2

use std::{borrow::Cow, env, fs, fs::File, io, io::IsTerminal, path::PathBuf, process::exit};

use rand_core::CryptoRngCore;

use reach_aliases::*;
use reach_core::{
    RandomFromRng,
    storage::{ReachablePublicKeyRing, Storable, UnsignedReachableVerifyingKeys},
    wire::{AttestantVerifyingKeys, ReachableVerifyingKeys, Salts},
};
use reach_passphrase::{WORDLIST_EN_V0, generate_passphrase};
use reach_signatures::{Sign, Verifiable};
use reach_visual_key_identity::visual_key_identity;

use crate::{
    cli_utils::*,
    macros::{shared_keys_random_from_rng, sign_and_store_shared_keys},
    memory::{
        self, AttestantSigningKeys, UnsignedSalts, UnsignedSharedPublicKeys,
        UnsignedSharedSecretKeys, UnsignedSharedSigningKeys, UnsignedSharedVerifyingKeys,
    },
    net::authenticate,
    storage,
};

pub fn generate(
    profile_name: &str,
    profile: &Option<String>,
    force: bool,
    csprng: &mut impl CryptoRngCore,
) {
    if let (false, Ok(locked_signing_key_path)) =
        (force, storage::file_path(profile_name, None, "lask", false))
    {
        (!locked_signing_key_path.exists()).may_bail_with(
            &format!(
                "A locked signing key for '{profile_name}' already exists! {}",
                "To overwrite it use --force"
            ),
            false,
        );
    }

    let pac_salt = ThreeTwo::random_from_rng(csprng);
    let key_salt = ThreeTwo::random_from_rng(csprng);

    // generate passphrase
    let passphrase = generate_passphrase(WORDLIST_EN_V0, &pac_salt, csprng);
    print!("\u{1f537} Your generated passphrase");
    if let Some(profile_name) = profile {
        print!(" for profile '{profile_name}'");
    }
    println!(":\n");
    print_passphrase(&passphrase);

    // generate signing keys
    let signing_keys = AttestantSigningKeys::random_from_rng(csprng);
    let verifying_keys = signing_keys.verifying_keys();

    println!("\u{2712}\u{fe0f} Successfully generated attestant signing keys");

    let key = derive_unlocking_key(passphrase, &pac_salt, &key_salt, true);
    let augmentation = [pac_salt, key_salt].concat();
    // lock it with generated passphrase
    memory::lock_and_store(&signing_keys, &key, augmentation, profile_name, csprng)
        .may_bail_with("Locking and storing your signing keys has failed.", true);
    println!("\u{1f512} Locked attestant signing keys with your generated passphrase.\n");

    let verifying_keys_path = verifying_keys_path(profile_name, true);

    verifying_keys
        .store(&verifying_keys_path)
        .may_bail_with("Couldn't store attestant verifying keys.", true);

    let unsigned_salts = UnsignedSalts::random_from_rng(csprng);
    let reach_salts = signing_keys.sign(unsigned_salts, csprng);

    let reach_salts_path = storage::file_path(profile_name, None, "slt", true)
        .may_bail_with("Couldn't determine path for salts.", true);

    reach_salts
        .store(&reach_salts_path)
        .may_bail_with("Couldn't store salts.", true);

    let (shared_signing_keys, shared_verifying_keys) = shared_keys_random_from_rng!(
        signing_keys,
        UnsignedSharedSigningKeys,
        UnsignedSharedVerifyingKeys,
        csprng,
    );
    sign_and_store_shared_keys!(
        (shared_signing_keys, "signing", "ssik"),
        (shared_verifying_keys, "verifying", "svk"),
        profile_name,
    );

    let (shared_secret_keys, shared_public_keys) = shared_keys_random_from_rng!(
        signing_keys,
        UnsignedSharedSecretKeys,
        UnsignedSharedPublicKeys,
        csprng,
    );
    sign_and_store_shared_keys!(
        (shared_secret_keys, "secret", "ssek"),
        (shared_public_keys, "public", "spk"),
        profile_name,
    );

    let identity = visual_key_identity(&verifying_keys, &reach_salts.attestant_identity)
        .may_bail_with(
            "Couldn't synthesize visual identity for your verifying keys.",
            true,
        );

    print!("\u{1f6c2} Your attestant verifying keys' visual identity:");
    println!("\n\n{identity}\n");

    print!("\u{2139}\u{fe0f} You can publish this visual identity on your website to ");
    println!("allow users to verify that they are communicating with the right folks.");
}

pub fn list_profiles() {
    let config_path = storage::config_path(false).may_bail(false);

    let dir_entries = config_path.read_dir().may_bail(false);

    dir_entries.for_each(|f| {
        let dir_entry = f.may_bail(false);
        let os_file_name = dir_entry.file_name();
        let file_name = os_file_name.to_string_lossy();
        if file_name.ends_with(".lask") {
            println!("{}", file_name.split(".").next().expect("Infallible"));
        };
    });
}

pub fn list_signed_verifying_keys() {
    // list {alias} part of {data}/{profile}/{alias}.vfk
    todo!();
}

pub fn offboard() {
    // As with Onboard, may be used in an airgapped environment
    todo!();
}

// May be used in an airgapped manner, where it onboards keys signed by a different machine.
pub async fn onboard(
    profile_name: &str,
    profile: &Option<String>,
    reachable_verifying_keys_public_key_rings: Vec<(String, String)>,
) {
    let url_path = url_path(profile_name, false);
    let url = format!(
        "{}/reach",
        fs::read_to_string(&url_path)
            .map_err(|_| format!("Could not read {}", url_path.to_string_lossy()))
            .may_bail(false)
            .trim()
    );

    let signing_keys = load_and_unlock_signing_keys(profile_name, profile);
    let verifying_keys_path = verifying_keys_path(profile_name, false);
    let verifying_keys = AttestantVerifyingKeys::load(&verifying_keys_path).may_bail(false);

    let reachable_verifying_keys_public_key_rings = reachable_verifying_keys_public_key_rings
        .iter()
        .map(|(rvk, rpkr)| {
            let vfk_aliased =
                storage::file_path(profile_name, Some(rvk), "vfk", false).may_bail(true);
            let vfk_path = PathBuf::from(rvk);
            let vfk = match (vfk_aliased.exists(), vfk_path.exists()) {
                (_, true) => ReachableVerifyingKeys::load(&vfk_path).may_bail(true),
                (true, false) => ReachableVerifyingKeys::load(&vfk_aliased).may_bail(true),
                (false, false) => exit(1),
            };

            vfk.verify(&verifying_keys).may_bail_with(
                concat!(
                    "Supplied reachable verifying keys are not verifiable with this profile's ",
                    "attestant verifying keys."
                ),
                false,
            );

            let pkr_path = PathBuf::from(rpkr);
            let ring = ReachablePublicKeyRing::load(&pkr_path).may_bail_with(
                &format!(
                    "Couldn't load reachable public key ring from '{}'.",
                    pkr_path.to_string_lossy()
                ),
                false,
            );

            ring.reachable_public_keys
                .iter()
                .all(|rpk| rpk.verify(&vfk))
                .may_bail_with(
                    &format!(
                        concat!(
                            "Reachable public keys in '{}' are not signed with the verifying keys ",
                            "you supplied."
                        ),
                        pkr_path.to_string_lossy()
                    ),
                    false,
                );

            (vfk, ring)
        })
        .collect::<Vec<(_, _)>>();

    let mut client = authenticate(&signing_keys, &verifying_keys, &url).await;

    for (vfk, pkr) in &reachable_verifying_keys_public_key_rings {
        client
            .send_and_wait(vfk)
            .await
            .map_err(|_| "Onboarding reachable verifying keys failed")
            .may_bail(true);
        client
            .send_and_wait(pkr)
            .await
            .map_err(|_| "Adding reachable public key ring failed.")
            .may_bail(true);
    }

    println!(
        "Successfully onboarded {} peers!",
        reachable_verifying_keys_public_key_rings.len()
    );
}

pub fn revoke(profile_name: &str, profile: &Option<String>) {
    let _signing_keys = load_and_unlock_signing_keys(profile_name, profile);
    // sign b"revoke" + read({data}/{profile}/{alias}.vfk)
    // save revoked key to {pwd}/{alias}.rvfk
    // remove {data}/{profile}/{alias}.vfk
    todo!();
}

// May be used in an airgapped manner, on a separate machine that does the signing.
pub fn sign(
    profile_name: &str,
    profile: &Option<String>,
    unsigned_verifying_keys: Vec<PathBuf>,
    copy_to_cwd: bool,
    csprng: &mut impl CryptoRngCore,
) {
    let signing_keys = load_and_unlock_signing_keys(profile_name, profile);

    let data_path =
        storage::data_path(true).may_bail_with("Data directory needs to be writeable.", false);

    let aliases = unsigned_verifying_keys
        .iter()
        .fold(String::new(), |acc, p| {
            let unsigned_file_name = p
                .file_name()
                .may_bail_with("Attempting to sign an invalid path.", false)
                .to_string_lossy();
            let alias = unsigned_file_name
                .rsplit_once('.')
                .map_or_else(|| unsigned_file_name.clone(), |(alias, _)| Cow::from(alias));

            fs::copy(p, data_path.join(format!("{alias}.uvfk"))).may_bail_with(
                "Could not copy unsigned verifying key to data directory.",
                true,
            );

            let unsigned_reachable_verifying_keys = UnsignedReachableVerifyingKeys::load(p)
                .may_bail_with(&format!("{p:?} is malformed, it can't be signed."), false);

            let reachable_verifying_keys =
                signing_keys.sign(unsigned_reachable_verifying_keys, csprng);

            let signed_file_name = format!("{alias}.vfk");

            reachable_verifying_keys
                .store(&data_path.join(&signed_file_name))
                .may_bail_with(
                    "Could not store signed reachable verifying keys in data directory.",
                    true,
                );

            if copy_to_cwd {
                reachable_verifying_keys
                    .store(&env::current_dir().may_bail(true).join(&signed_file_name))
                    .may_bail_with(
                        "Could not store signed reachable verifying keys in the current directory.",
                        true,
                    );
            }

            format!("{acc}, {alias}")
        });
    let aliases = aliases.trim_start_matches(',').trim();

    println!("\u{2712}\u{FE0F} Successfully signed reachable verifying keys for: {aliases}");
}

pub fn url(profile_name: &str, force: bool, url: Option<String>) {
    let url_path = url_path(profile_name, url.is_some());
    let url_exists = url_path.exists();

    let suffix = match profile_name {
        "default" => String::new(),
        profile_name => format!(" for '{profile_name}'"),
    };

    match (url, !url_exists || force) {
        (None, _) => {
            url_exists.may_bail_with("No URL was set for profile.", false);

            let url = fs::read_to_string(url_path).may_bail_with("Could not read URL", true);

            println!("{}/", url.trim().trim_matches('/'));
        }
        (Some(url), true) => {
            fs::write(url_path, url.trim_end_matches('/')).may_bail(true);

            println!("\u{1f517} Successfully set URL{suffix}!");
        }
        (Some(_), false) => {
            err_msg(
                format!(
                    "URL already exists{suffix}. Rerun with --force if you want to replace it."
                ),
                false,
            );
            exit(1);
        }
    }
}

// Shows path to verifying keys, dumps them if piped to a file or command
pub fn verifying_keys(profile_name: &str) {
    let verifying_keys_path = verifying_keys_path(profile_name, false);

    let stdout = io::stdout();
    if stdout.is_terminal() {
        println!(
            "\u{1f6c2} Your verifying key is located at:\n\n{}",
            verifying_keys_path.to_string_lossy()
        );
    } else {
        let mut verifying_keys = File::open(&verifying_keys_path).may_bail(false);
        let mut lock = stdout.lock();
        io::copy(&mut verifying_keys, &mut lock).may_bail(false);
    }
}

pub fn visual_identity(profile_name: &str) {
    let verifying_keys_path = storage::file_path(profile_name, None, "vfk", false).may_bail(false);

    let verifying_keys = AttestantVerifyingKeys::load(&verifying_keys_path).may_bail_with(
        "Verifying keys could not be loaded.\nHave you generated signing keys for this profile?",
        false,
    );

    let reach_salts_path = storage::file_path(profile_name, None, "slt", true)
        .may_bail_with("Couldn't determine path for salts.", true);

    let reach_salts = Salts::load(&reach_salts_path).may_bail_with("", false);

    let identity = visual_key_identity(&verifying_keys, &reach_salts.attestant_identity)
        .may_bail_with(
            "Couldn't create visual identity for your verifying keys.",
            true,
        );

    println!("{identity}");
}