75 lines
3.1 KiB
Rust
75 lines
3.1 KiB
Rust
use bech32::{ToBase32, Variant};
|
|
use clap::{App, Arg, ArgMatches, SubCommand};
|
|
use openpgp_card::algorithm::{Algo, Curve};
|
|
use openpgp_card::crypto_data::{EccType, PublicKeyMaterial};
|
|
use openpgp_card::{KeyType, OpenPgp};
|
|
use openpgp_card_pcsc::PcscBackend;
|
|
use rust_util::util_clap::{Command, CommandError};
|
|
use rust_util::util_msg;
|
|
use std::collections::BTreeMap;
|
|
|
|
const AGE_PUBLIC_KEY_PREFIX: &str = "age";
|
|
|
|
pub struct CommandImpl;
|
|
|
|
impl Command for CommandImpl {
|
|
fn name(&self) -> &str { "pgp-age-address" }
|
|
|
|
fn subcommand<'a>(&self) -> App<'a, 'a> {
|
|
SubCommand::with_name(self.name()).about("OpenPGP Card encryption key to age address")
|
|
.arg(Arg::with_name("json").long("json").help("JSON output"))
|
|
}
|
|
|
|
fn run(&self, _arg_matches: &ArgMatches, sub_arg_matches: &ArgMatches) -> CommandError {
|
|
let json_output = sub_arg_matches.is_present("json");
|
|
if json_output { util_msg::set_logger_std_out(false); }
|
|
|
|
let cards = opt_result!(PcscBackend::cards(None), "Failed to list OpenPGP cards: {}");
|
|
|
|
let mut cards_output: Vec<BTreeMap<&str, String>> = vec![];
|
|
information!("Found {} card(s)", cards.len());
|
|
for (i, card) in cards.into_iter().enumerate() {
|
|
let mut card_output = BTreeMap::new();
|
|
|
|
let mut pgp = OpenPgp::new(card);
|
|
let mut trans = opt_result!(pgp.transaction(), "Open card failed: {}");
|
|
if let Ok(application_related_data) = trans.application_related_data() {
|
|
success!("Found card #{}: {:?}", i, application_related_data.application_id());
|
|
if let Ok(application_id) = application_related_data.application_id() {
|
|
card_output.insert("application_id", format!("{}", application_id));
|
|
}
|
|
}
|
|
let encryption_public_key = match trans.public_key(KeyType::Decryption) {
|
|
Ok(pub_key) => pub_key,
|
|
Err(e) => {
|
|
failure!("Get decryption public key failed: {}", e);
|
|
continue;
|
|
}
|
|
};
|
|
if let PublicKeyMaterial::E(ecc_pub) = &encryption_public_key {
|
|
if let Algo::Ecc(ecc) = ecc_pub.algo() {
|
|
if let (EccType::ECDH, Curve::Cv25519) = (ecc.ecc_type(), ecc.curve()) {
|
|
let pub_key_bytes = ecc_pub.data();
|
|
let age_address = opt_result!(bech32::encode(
|
|
AGE_PUBLIC_KEY_PREFIX,
|
|
pub_key_bytes.to_base32(),
|
|
Variant::Bech32,
|
|
), "Generate age address failed: {}");
|
|
success!("Age address: {}", age_address);
|
|
card_output.insert("age_address", age_address);
|
|
}
|
|
}
|
|
} else {
|
|
failure!("Not supported encryption key: {}", encryption_public_key);
|
|
}
|
|
|
|
cards_output.push(card_output);
|
|
}
|
|
|
|
if json_output {
|
|
println!("{}", serde_json::to_string_pretty(&cards_output).unwrap());
|
|
}
|
|
Ok(None)
|
|
}
|
|
}
|