hatter/card-cli
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: fix clippy

Browse Source
This commit is contained in:
Hatter Jiang
2023-10-14 00:05:11 +08:00
parent 69529b1813
commit 09bb894242
15 changed files with 68 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/cmd_pgpageaddress.rs
View File

@@ -29,7 +29,10 @@ impl Command for CommandImpl {
} }
let encryption_public_key = match trans.public_key(KeyType::Decryption) { let encryption_public_key = match trans.public_key(KeyType::Decryption) {
Ok(pub_key) => pub_key, Ok(pub_key) => pub_key,
Err(e) => return simple_error!("Get decryption public key failed: {}", e), Err(e) => {
failure!("Get decryption public key failed: {}", e);
continue;
}
}; };
if let PublicKeyMaterial::E(ecc_pub) = &encryption_public_key { if let PublicKeyMaterial::E(ecc_pub) = &encryption_public_key {
if let Algo::Ecc(ecc) = ecc_pub.algo() { if let Algo::Ecc(ecc) = ecc_pub.algo() {
@@ -41,11 +44,11 @@ impl Command for CommandImpl {
Variant::Bech32, Variant::Bech32,
), "Generate age address failed: {}"); ), "Generate age address failed: {}");
success!("Age address: {}", age_address); success!("Age address: {}", age_address);
return Ok(None);
} }
} }
} else {
failure!("Not supported encryption key: {}", encryption_public_key);
} }
return simple_error!("Not supported encryption key: {}", encryption_public_key);
} }
Ok(None) Ok(None)
} }

14
src/cmd_pgpcarddecrypt.rs
View File

@@ -10,16 +10,16 @@ use crate::util::{base64_decode, base64_encode};
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
enum EncryptAlgo { enum EncryptAlgo {
RSA, Rsa,
ECDH, Ecdh,
} }
impl EncryptAlgo { impl EncryptAlgo {
fn from_str(algo: &str) -> XResult<Self> { fn from_str(algo: &str) -> XResult<Self> {
match algo { match algo {
"rsa" => Ok(Self::RSA), "rsa" => Ok(Self::Rsa),
"x25519" | "ecdh" => Ok(Self::ECDH), "x25519" | "ecdh" => Ok(Self::Ecdh),
_ => return simple_error!("Unknown algo: {}", algo), _ => simple_error!("Unknown algo: {}", algo),
} }
} }
} }
@@ -68,8 +68,8 @@ impl Command for CommandImpl {
success!("User pin verify success!"); success!("User pin verify success!");
let text = match algo { let text = match algo {
EncryptAlgo::RSA => trans.decipher(Cryptogram::RSA(&cipher_bytes))?, EncryptAlgo::Rsa => trans.decipher(Cryptogram::RSA(&cipher_bytes))?,
EncryptAlgo::ECDH => trans.decipher(Cryptogram::ECDH(&cipher_bytes))?, EncryptAlgo::Ecdh => trans.decipher(Cryptogram::ECDH(&cipher_bytes))?,
}; };
success!("Clear text HEX: {}", hex::encode(&text)); success!("Clear text HEX: {}", hex::encode(&text));
success!("Clear text base64: {}", base64_encode(&text)); success!("Clear text base64: {}", base64_encode(&text));

3
src/cmd_pgpcardmake.rs
View File

@@ -159,6 +159,9 @@ impl Command for CommandImpl {
if last_pgp_rsa_private_key.is_some() { return simple_error!("Last PGP RSA private key is not none"); } if last_pgp_rsa_private_key.is_some() { return simple_error!("Last PGP RSA private key is not none"); }
last_pgp_rsa_private_key.replace(pgp_rsa_private_key); last_pgp_rsa_private_key.replace(pgp_rsa_private_key);
} else if let Packet::Signature(signature) = &pp.packet { } else if let Packet::Signature(signature) = &pp.packet {
if let Signature::V3(_signature_v3) = signature {
failure!("Signature v3 is not supported.");
}
if let Signature::V4(signature_v4) = signature { if let Signature::V4(signature_v4) = signature {
if let Some(sub_package) = signature_v4.hashed_area().subpacket(SubpacketTag::KeyFlags) { if let Some(sub_package) = signature_v4.hashed_area().subpacket(SubpacketTag::KeyFlags) {
if let SubpacketValue::KeyFlags(key_flags) = sub_package.value() { if let SubpacketValue::KeyFlags(key_flags) = sub_package.value() {

38
src/cmd_pgpcardsign.rs
View File

@@ -16,18 +16,18 @@ const BUFF_SIZE: usize = 512 * 1024;
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
enum SignAlgo { enum SignAlgo {
RSA, Rsa,
ECDSA, Ecdsa,
EdDSA, EdDsa,
} }
impl SignAlgo { impl SignAlgo {
fn from_str(algo: &str) -> XResult<Self> { fn from_str(algo: &str) -> XResult<Self> {
match algo { match algo {
"rsa" => Ok(Self::RSA), "rsa" => Ok(Self::Rsa),
"ecdsa" => Ok(Self::ECDSA), "ecdsa" => Ok(Self::Ecdsa),
"eddsa" => Ok(Self::EdDSA), "eddsa" => Ok(Self::EdDsa),
_ => return simple_error!("Unknown algo: {}", algo), _ => simple_error!("Unknown algo: {}", algo),
} }
} }
} }
@@ -111,15 +111,15 @@ impl Command for CommandImpl {
opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}"); opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}");
success!("User sign pin verify success!"); success!("User sign pin verify success!");
let sig = match algo { let sig = match algo {
SignAlgo::RSA => trans.signature_for_hash(Hash::SHA256(sha256_hex))?, SignAlgo::Rsa => trans.signature_for_hash(Hash::SHA256(sha256_hex))?,
SignAlgo::ECDSA => trans.signature_for_hash(Hash::ECDSA(&sha256_hex))?, SignAlgo::Ecdsa => trans.signature_for_hash(Hash::ECDSA(&sha256_hex))?,
SignAlgo::EdDSA => trans.signature_for_hash(Hash::EdDSA(&sha256_hex))?, SignAlgo::EdDsa => trans.signature_for_hash(Hash::EdDSA(&sha256_hex))?,
}; };
success!("SHA256 signature HEX: {}", hex::encode(&sig)); success!("SHA256 signature HEX: {}", hex::encode(&sig));
success!("SHA256 signature base64: {}", base64_encode(&sig)); success!("SHA256 signature base64: {}", base64_encode(&sig));
if json_output { if json_output {
let mut entry = BTreeMap::new(); let mut entry = BTreeMap::new();
entry.insert("digest", hex::encode(&sha256_hex)); entry.insert("digest", hex::encode(sha256_hex));
entry.insert("signature", hex::encode(&sig)); entry.insert("signature", hex::encode(&sig));
json.insert("sha256", entry); json.insert("sha256", entry);
} }
@@ -130,15 +130,15 @@ impl Command for CommandImpl {
opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}"); opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}");
success!("User sign pin verify success!"); success!("User sign pin verify success!");
let sig = match algo { let sig = match algo {
SignAlgo::RSA => trans.signature_for_hash(Hash::SHA384(sha384_hex))?, SignAlgo::Rsa => trans.signature_for_hash(Hash::SHA384(sha384_hex))?,
SignAlgo::ECDSA => trans.signature_for_hash(Hash::ECDSA(&sha384_hex))?, SignAlgo::Ecdsa => trans.signature_for_hash(Hash::ECDSA(&sha384_hex))?,
SignAlgo::EdDSA => trans.signature_for_hash(Hash::EdDSA(&sha384_hex))?, SignAlgo::EdDsa => trans.signature_for_hash(Hash::EdDSA(&sha384_hex))?,
}; };
success!("SHA384 signature HEX: {}", hex::encode(&sig)); success!("SHA384 signature HEX: {}", hex::encode(&sig));
success!("SHA384 signature base64: {}", base64_encode(&sig)); success!("SHA384 signature base64: {}", base64_encode(&sig));
if json_output { if json_output {
let mut entry = BTreeMap::new(); let mut entry = BTreeMap::new();
entry.insert("digest", hex::encode(&sha384_hex)); entry.insert("digest", hex::encode(sha384_hex));
entry.insert("signature", hex::encode(&sig)); entry.insert("signature", hex::encode(&sig));
json.insert("sha384", entry); json.insert("sha384", entry);
} }
@@ -149,15 +149,15 @@ impl Command for CommandImpl {
opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}"); opt_result!(trans.verify_pw1_sign(pin.as_ref()), "User sign pin verify failed: {}");
success!("User sign pin verify success!"); success!("User sign pin verify success!");
let sig = match algo { let sig = match algo {
SignAlgo::RSA => trans.signature_for_hash(Hash::SHA512(sha512_hex))?, SignAlgo::Rsa => trans.signature_for_hash(Hash::SHA512(sha512_hex))?,
SignAlgo::ECDSA => trans.signature_for_hash(Hash::ECDSA(&sha512_hex))?, SignAlgo::Ecdsa => trans.signature_for_hash(Hash::ECDSA(&sha512_hex))?,
SignAlgo::EdDSA => trans.signature_for_hash(Hash::EdDSA(&sha512_hex))?, SignAlgo::EdDsa => trans.signature_for_hash(Hash::EdDSA(&sha512_hex))?,
}; };
success!("SHA512 signature HEX: {}", hex::encode(&sig)); success!("SHA512 signature HEX: {}", hex::encode(&sig));
success!("SHA512 signature base64: {}", base64_encode(&sig)); success!("SHA512 signature base64: {}", base64_encode(&sig));
if json_output { if json_output {
let mut entry = BTreeMap::new(); let mut entry = BTreeMap::new();
entry.insert("digest", hex::encode(&sha512_hex)); entry.insert("digest", hex::encode(sha512_hex));
entry.insert("signature", hex::encode(&sig)); entry.insert("signature", hex::encode(&sig));
json.insert("sha512", entry); json.insert("sha512", entry);
} }

8
src/cmd_pivdecrypt.rs
View File

@@ -43,8 +43,8 @@ impl Command for CommandImpl {
return simple_error!("Not valid encrypted data, prefix: {}", hex::encode(&decrypted_data_bytes[0..2])); return simple_error!("Not valid encrypted data, prefix: {}", hex::encode(&decrypted_data_bytes[0..2]));
} }
let mut index_of_00_from_index_1 = 0; let mut index_of_00_from_index_1 = 0;
for i in 1..decrypted_data_bytes.len() { for (i, byte) in decrypted_data_bytes.iter().enumerate().skip(1) {
if decrypted_data_bytes[i] == 0x00 { if *byte == 0x00 {
index_of_00_from_index_1 = i + 1; index_of_00_from_index_1 = i + 1;
break; break;
} }
@@ -59,8 +59,8 @@ impl Command for CommandImpl {
if json_output { if json_output {
let mut json = BTreeMap::<&'_ str, String>::new(); let mut json = BTreeMap::<&'_ str, String>::new();
json.insert("encrypted_data_hex", hex::encode(&encrypted_data)); json.insert("encrypted_data_hex", hex::encode(&encrypted_data));
json.insert("decrypted_data_hex", hex::encode(&decrypted_data_bytes)); json.insert("decrypted_data_hex", hex::encode(decrypted_data_bytes));
json.insert("clear_data_hex", hex::encode(&clear_data)); json.insert("clear_data_hex", hex::encode(clear_data));
json.insert("clear_data", String::from_utf8_lossy(clear_data).to_string()); json.insert("clear_data", String::from_utf8_lossy(clear_data).to_string());
println!("{}", serde_json::to_string_pretty(&json).unwrap()); println!("{}", serde_json::to_string_pretty(&json).unwrap());
} }

13
src/cmd_pivecdh.rs
View File

@@ -66,7 +66,7 @@ impl Command for CommandImpl {
let public_key_point_hex = sub_arg_matches.value_of("public-key-point-hex").unwrap_or_else(|| let public_key_point_hex = sub_arg_matches.value_of("public-key-point-hex").unwrap_or_else(||
failure_and_exit!("--public-key, --public-key-file or --public-key-point-hex must require one")); failure_and_exit!("--public-key, --public-key-file or --public-key-point-hex must require one"));
let public_key_point_bytes = opt_result!(hex::decode(public_key_point_hex), "Parse public key point hex failed: {}"); let public_key_point_bytes = opt_result!(hex::decode(public_key_point_hex), "Parse public key point hex failed: {}");
let encoded_point = opt_result!(EncodedPoint::from_bytes(&public_key_point_bytes), "Parse public key point failed: {}"); let encoded_point = opt_result!(EncodedPoint::from_bytes(public_key_point_bytes), "Parse public key point failed: {}");
public_key = PublicKey::from_encoded_point(&encoded_point).unwrap(); public_key = PublicKey::from_encoded_point(&encoded_point).unwrap();
}; };
@@ -109,18 +109,15 @@ impl Command for CommandImpl {
} }
} }
if let Some(public_key) = &meta.public { if let Some(public_key) = &meta.public {
let algorithm_id = opt_result!(get_algorithm_id(&public_key), "Get algorithm id failed: {}"); let algorithm_id = opt_result!(get_algorithm_id(public_key), "Get algorithm id failed: {}");
match algorithm_id { match algorithm_id {
AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 | AlgorithmId::EccP384 => { AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
failure_and_exit!("Not supported algorithm: {:?}", algorithm_id); failure_and_exit!("Not supported algorithm: {:?}", algorithm_id);
} }
AlgorithmId::EccP256 => { AlgorithmId::EccP256 | AlgorithmId::EccP384 => {
match algorithm_id { if let Some(public) = &meta.public {
AlgorithmId::EccP256 => if let Some(public) = &meta.public {
json.insert("pk_point_hex", hex::encode(public.subject_public_key.raw_bytes())); json.insert("pk_point_hex", hex::encode(public.subject_public_key.raw_bytes()));
} }
_ => {}
}
} }
} }
} }

10
src/cmd_pivecsign.rs
View File

@@ -53,7 +53,7 @@ impl Command for CommandImpl {
opt_result!(yk.verify_pin(pin.as_bytes()), "YubiKey verify pin failed: {}"); opt_result!(yk.verify_pin(pin.as_bytes()), "YubiKey verify pin failed: {}");
} }
let hash_bytes = opt_result!(hex::decode(&hash_hex), "Parse hash in hex failed: {}"); let hash_bytes = opt_result!(hex::decode(hash_hex), "Parse hash in hex failed: {}");
if let Ok(slot_metadata) = metadata(&mut yk, slot_id) { if let Ok(slot_metadata) = metadata(&mut yk, slot_id) {
match slot_metadata.algorithm { match slot_metadata.algorithm {
@@ -77,14 +77,14 @@ impl Command for CommandImpl {
json.insert("slot", slot_id.to_string()); json.insert("slot", slot_id.to_string());
json.insert("algorithm", algorithm_str.to_string()); json.insert("algorithm", algorithm_str.to_string());
json.insert("hash_hex", hex::encode(&hash_bytes)); json.insert("hash_hex", hex::encode(&hash_bytes));
json.insert("signed_data_hex", hex::encode(&signed_data.as_bytes())); json.insert("signed_data_hex", hex::encode(signed_data.as_bytes()));
json.insert("signed_data_base64", base64_encode(&signed_data.as_bytes())); json.insert("signed_data_base64", base64_encode(signed_data.as_bytes()));
} else { } else {
information!("Slot: {:?}", slot_id); information!("Slot: {:?}", slot_id);
information!("Algorithm: {}", algorithm_str); information!("Algorithm: {}", algorithm_str);
information!("Hash hex: {}", hex::encode(&hash_bytes)); information!("Hash hex: {}", hex::encode(&hash_bytes));
information!("Signed data base64: {}", base64_encode(&signed_data.as_bytes())); information!("Signed data base64: {}", base64_encode(signed_data.as_bytes()));
information!("Signed data hex: {}", hex::encode(&signed_data.as_bytes())); information!("Signed data hex: {}", hex::encode(signed_data.as_bytes()));
} }
if json_output { if json_output {

4
src/cmd_pivrsasign.rs
View File

@@ -62,8 +62,8 @@ impl Command for CommandImpl {
if json_output { if json_output {
let mut json = BTreeMap::<&'_ str, String>::new(); let mut json = BTreeMap::<&'_ str, String>::new();
json.insert("hash_hex", hex::encode(&hash)); json.insert("hash_hex", hex::encode(&hash));
json.insert("sign_hex", hex::encode(&sign_bytes)); json.insert("sign_hex", hex::encode(sign_bytes));
json.insert("sign_base64", base64_encode(&sign_bytes)); json.insert("sign_base64", base64_encode(sign_bytes));
println!("{}", serde_json::to_string_pretty(&json).unwrap()); println!("{}", serde_json::to_string_pretty(&json).unwrap());
} else { } else {
success!("Signature HEX: {}", hex::encode(sign_bytes)); success!("Signature HEX: {}", hex::encode(sign_bytes));

2
src/cmd_pivsummary.rs
View File

@@ -71,7 +71,7 @@ impl Command for CommandImpl {
if show_table { if show_table {
let mut table = Table::new(piv_slots); let mut table = Table::new(piv_slots);
table.with(Style::rounded()); table.with(Style::rounded());
println!("{}", table.to_string()); println!("{}", table);
} }
Ok(None) Ok(None)
} }

2
src/cmd_rsaverify.rs
View File

@@ -58,7 +58,7 @@ impl Command for CommandImpl {
let m = BigNum::from_slice(&signature).unwrap(); let m = BigNum::from_slice(&signature).unwrap();
let mut r = BigNum::new().unwrap(); let mut r = BigNum::new().unwrap();
r.mod_exp(&m, e, n, &mut BigNumContext::new().unwrap()).unwrap(); r.mod_exp(&m, e, n, &mut BigNumContext::new().unwrap()).unwrap();
debugging!("Signature raw HEX: 00{}", hex::encode(&r.to_vec())); debugging!("Signature raw HEX: 00{}", hex::encode(r.to_vec()));
}); });
let file_in = opt_value_result!(sub_arg_matches.value_of("in"), "File in --in required"); let file_in = opt_value_result!(sub_arg_matches.value_of("in"), "File in --in required");

11
src/cmd_sshagent.rs
View File

@@ -34,7 +34,7 @@ impl SshAgent {
let mut trans = opt_result!(pgp.transaction(), "Open card failed: {}"); let mut trans = opt_result!(pgp.transaction(), "Open card failed: {}");
let serial = trans.application_related_data() let serial = trans.application_related_data()
.map(|d| d.application_id().map(|i| i.serial())) .map(|d| d.application_id().map(|i| i.serial()))
.unwrap_or_else(|_| Ok(0)).unwrap_or_else(|_| 0); .unwrap_or_else(|_| Ok(0)).unwrap_or(0);
let serial = hex::encode(serial.to_be_bytes()); let serial = hex::encode(serial.to_be_bytes());
let public_key = opt_result!(trans.public_key(iff!(use_sign, KeyType::Signing, KeyType::Authentication)), "Cannot find signing key: {}"); let public_key = opt_result!(trans.public_key(iff!(use_sign, KeyType::Signing, KeyType::Authentication)), "Cannot find signing key: {}");
let rsa_public_key = match public_key { let rsa_public_key = match public_key {
@@ -67,11 +67,10 @@ impl SshAgent {
debugging!("Request: {:?}", request); debugging!("Request: {:?}", request);
let response = match request { let response = match request {
Message::RequestIdentities => { Message::RequestIdentities => {
let mut identities = vec![]; let identities = vec![message::Identity {
identities.push(message::Identity {
pubkey_blob: to_bytes(&self.public_key)?, pubkey_blob: to_bytes(&self.public_key)?,
comment: self.comment.clone(), comment: self.comment.clone(),
}); }];
Ok(Message::IdentitiesAnswer(identities)) Ok(Message::IdentitiesAnswer(identities))
} }
Message::RemoveIdentity(ref _identity) => { Message::RemoveIdentity(ref _identity) => {
@@ -121,7 +120,7 @@ impl SshAgent {
_ => Err(From::from(format!("Unknown message: {:?}", request))) _ => Err(From::from(format!("Unknown message: {:?}", request)))
}; };
debugging!("Response {:?}", response); debugging!("Response {:?}", response);
return response; response
} }
} }
@@ -170,7 +169,7 @@ impl Command for CommandImpl {
let sock_file_path = PathBuf::from("."); let sock_file_path = PathBuf::from(".");
match std::fs::canonicalize(sock_file_path) { match std::fs::canonicalize(sock_file_path) {
Ok(canonicalized_sock_file_path) => information!("SSH_AUTH_SOCK={}/{}", Ok(canonicalized_sock_file_path) => information!("SSH_AUTH_SOCK={}/{}",
canonicalized_sock_file_path.to_str().unwrap_or_else(|| "-"), sock_file), canonicalized_sock_file_path.to_str().unwrap_or("-"), sock_file),
Err(e) => warning!("Get canonicalized sock file path failed: {}", e), Err(e) => warning!("Get canonicalized sock file path failed: {}", e),
} }

4
src/cmd_u2fsign.rs
View File

@@ -116,7 +116,7 @@ impl Command for CommandImpl {
json.insert("challenge", u2fv2_challenge_str.to_string()); json.insert("challenge", u2fv2_challenge_str.to_string());
json.insert("challenge_hash", hex::encode(&challenge_hash)); json.insert("challenge_hash", hex::encode(&challenge_hash));
json.insert("device_info", format!("{}", &device_info)); json.insert("device_info", format!("{}", &device_info));
json.insert("signature", hex::encode(&signature)); json.insert("signature", hex::encode(signature));
json.insert("signed_message", hex::encode(&signed_message)); json.insert("signed_message", hex::encode(&signed_message));
json.insert("key_handle", hex::encode(&handle_used)); json.insert("key_handle", hex::encode(&handle_used));
json.insert("sign_data", hex::encode(&sign_data)); json.insert("sign_data", hex::encode(&sign_data));
@@ -128,7 +128,7 @@ impl Command for CommandImpl {
information!("Sign result : {}", base64_encode(&sign_data)); information!("Sign result : {}", base64_encode(&sign_data));
information!("- presence : {}", user_presence_flag); information!("- presence : {}", user_presence_flag);
information!("- counter : {}", counter_u32); information!("- counter : {}", counter_u32);
information!("- signature: {}", hex::encode(&signature)); information!("- signature: {}", hex::encode(signature));
information!("Key handle: {}", hex::encode(&handle_used)); information!("Key handle: {}", hex::encode(&handle_used));
information!("Signed message: {}", hex::encode(&signed_message)); information!("Signed message: {}", hex::encode(&signed_message));
} }

4
src/fido.rs
View File

@@ -103,7 +103,7 @@ impl U2fV2Challenge {
None => U2fV2Challenge::new_random(app_id, with_time_stamp_prefix), None => U2fV2Challenge::new_random(app_id, with_time_stamp_prefix),
Some(challenge_hex) => { Some(challenge_hex) => {
let challenge_bytes = opt_result!(hex::decode(challenge_hex), "Decode challenge hex failed: {}"); let challenge_bytes = opt_result!(hex::decode(challenge_hex), "Decode challenge hex failed: {}");
let challenge = URL_SAFE_NO_PAD.encode(&challenge_bytes); let challenge = URL_SAFE_NO_PAD.encode(challenge_bytes);
U2fV2Challenge::new(challenge, app_id) U2fV2Challenge::new(challenge, app_id)
} }
}) })
@@ -122,7 +122,7 @@ impl U2fV2Challenge {
rand_bytes[..8].clone_from_slice(&timestamp_be_bytes[..8]); rand_bytes[..8].clone_from_slice(&timestamp_be_bytes[..8]);
} }
let challenge = URL_SAFE_NO_PAD.encode(&rand_bytes); let challenge = URL_SAFE_NO_PAD.encode(rand_bytes);
Self::new(challenge, app_id) Self::new(challenge, app_id)
} }

8
src/pkiutil.rs
View File

@@ -10,7 +10,7 @@ use crate::digest::sha256_bytes;
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub enum PkiAlgorithm { pub enum PkiAlgorithm {
RSA, Rsa,
P256, P256,
P384, P384,
P521, P521,
@@ -19,7 +19,7 @@ pub enum PkiAlgorithm {
pub fn get_pki_algorithm(algorithm_identifier: &AlgorithmIdentifier) -> XResult<PkiAlgorithm> { pub fn get_pki_algorithm(algorithm_identifier: &AlgorithmIdentifier) -> XResult<PkiAlgorithm> {
let algorithm_id_string = algorithm_identifier.algorithm.to_id_string(); let algorithm_id_string = algorithm_identifier.algorithm.to_id_string();
if "1.2.840.113549.1.1.1" == algorithm_id_string { if "1.2.840.113549.1.1.1" == algorithm_id_string {
return Ok(PkiAlgorithm::RSA); return Ok(PkiAlgorithm::Rsa);
} }
if "1.2.840.10045.2.1" == algorithm_id_string { if "1.2.840.10045.2.1" == algorithm_id_string {
if let Some(parameters) = &algorithm_identifier.parameters { if let Some(parameters) = &algorithm_identifier.parameters {
@@ -60,8 +60,8 @@ pub fn openpgp_card_public_key_pem(public_key: &PublicKeyMaterial) -> Option<(Ve
Some(rsa_public_key_pem(rsa_pub.n(), rsa_pub.v())) Some(rsa_public_key_pem(rsa_pub.n(), rsa_pub.v()))
} }
PublicKeyMaterial::E(ecc_pub) => { PublicKeyMaterial::E(ecc_pub) => {
let ecc_pub_key_bytes_sha256 = sha256_bytes(&ecc_pub.data()); let ecc_pub_key_bytes_sha256 = sha256_bytes(ecc_pub.data());
Some((ecc_pub_key_bytes_sha256, format!("hex:{}", hex::encode(&ecc_pub.data())))) Some((ecc_pub_key_bytes_sha256, format!("hex:{}", hex::encode(ecc_pub.data()))))
} }
_ => { _ => {
warning!("Unknown public key: {:?}", public_key); warning!("Unknown public key: {:?}", public_key);

2
src/sshutil.rs
View File

@@ -1,7 +1,7 @@
use crate::util::base64_encode; use crate::util::base64_encode;
pub fn with_sign(mut vec: Vec<u8>) -> Vec<u8> { pub fn with_sign(mut vec: Vec<u8>) -> Vec<u8> {
if vec.len() > 0 && vec[0] >= 128 { if !vec.is_empty() && vec[0] >= 128 {
vec.insert(0, 0x00); vec.insert(0, 0x00);
} }
vec vec