feat: udptes

src/cmd_pgp_age_address.rs

@@ -0,0 +1,74 @@
+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)
+    }
+}