From 60767a8d7bd3132ccbb79be1fbfbeab93a14b092 Mon Sep 17 00:00:00 2001 From: Hatter Jiang Date: Mon, 24 Mar 2025 01:10:16 +0800 Subject: [PATCH] feat: v0.1.1 --- Cargo.toml | 2 +- examples/generate_keypair.rs | 11 +++++------ examples/private_ecdsa_sign.rs | 4 ++-- examples/recover_ecdh.rs | 4 ++-- examples/recover_ecdsa.rs | 5 ++--- src/lib.rs | 36 +++++++++++++++++++++++++--------- 6 files changed, 39 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 21a45bd..8ba5040 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "swift-secure-enclave-tool-rs" -version = "0.1.0" +version = "0.1.1" edition = "2024" authors = ["Hatter Jiang"] repository = "https://git.hatter.ink/hatter/swift-secure-enclave-tool-rs" diff --git a/examples/generate_keypair.rs b/examples/generate_keypair.rs index cfb0471..11cb37b 100644 --- a/examples/generate_keypair.rs +++ b/examples/generate_keypair.rs @@ -1,7 +1,7 @@ use base64::engine::general_purpose::STANDARD; use base64::Engine; use swift_secure_enclave_tool_rs::{ - generate_ecdsa_keypair, is_secure_enclave_supported, KeyMaterial, KeyPurpose, + generate_keypair, is_secure_enclave_supported, KeyMaterial, KeyPurpose, }; fn main() { @@ -10,20 +10,19 @@ fn main() { is_secure_enclave_supported().unwrap() ); - let ecdsa_key_material_require_bio = generate_ecdsa_keypair(KeyPurpose::Signing, true).unwrap(); + let ecdsa_key_material_require_bio = generate_keypair(KeyPurpose::Signing, true).unwrap(); print_key_material("Signing key [require bio]", &ecdsa_key_material_require_bio); - let ecdsa_key_material_no_bio = generate_ecdsa_keypair(KeyPurpose::Signing, true).unwrap(); + let ecdsa_key_material_no_bio = generate_keypair(KeyPurpose::Signing, true).unwrap(); print_key_material("Signing key [no bio]", &ecdsa_key_material_no_bio); - let ecdsa_key_material_require_bio = - generate_ecdsa_keypair(KeyPurpose::KeyAgreement, true).unwrap(); + let ecdsa_key_material_require_bio = generate_keypair(KeyPurpose::KeyAgreement, true).unwrap(); print_key_material( "Key agreement key [require bio]", &ecdsa_key_material_require_bio, ); - let ecdsa_key_material_no_bio = generate_ecdsa_keypair(KeyPurpose::KeyAgreement, true).unwrap(); + let ecdsa_key_material_no_bio = generate_keypair(KeyPurpose::KeyAgreement, true).unwrap(); print_key_material("Key agreement key [no bio]", &ecdsa_key_material_no_bio); } diff --git a/examples/private_ecdsa_sign.rs b/examples/private_ecdsa_sign.rs index 45f1920..922fefd 100644 --- a/examples/private_ecdsa_sign.rs +++ b/examples/private_ecdsa_sign.rs @@ -1,12 +1,12 @@ use base64::engine::general_purpose::STANDARD; use base64::Engine; -use swift_secure_enclave_tool_rs::private_key_ecdsa_sign; +use swift_secure_enclave_tool_rs::private_key_sign; fn main() { let args = std::env::args().collect::>(); let private_key_representation = STANDARD.decode(&args[1]).unwrap(); - let signature = private_key_ecdsa_sign(&private_key_representation, b"hello world").unwrap(); + let signature = private_key_sign(&private_key_representation, b"hello world").unwrap(); println!("{}", hex::encode(&signature)); } diff --git a/examples/recover_ecdh.rs b/examples/recover_ecdh.rs index 0d98ed5..5bcebaa 100644 --- a/examples/recover_ecdh.rs +++ b/examples/recover_ecdh.rs @@ -1,5 +1,5 @@ use base64::Engine; -use swift_secure_enclave_tool_rs::{recover_ecdsa_keypair, KeyPurpose}; +use swift_secure_enclave_tool_rs::{recover_keypair, KeyPurpose}; fn main() { let args = std::env::args().collect::>(); @@ -7,6 +7,6 @@ fn main() { .decode(&args[1]) .unwrap(); let key_material = - recover_ecdsa_keypair(KeyPurpose::KeyAgreement, &private_key_representation).unwrap(); + recover_keypair(KeyPurpose::KeyAgreement, &private_key_representation).unwrap(); println!("{:?}", key_material) } diff --git a/examples/recover_ecdsa.rs b/examples/recover_ecdsa.rs index 26b3611..24e7898 100644 --- a/examples/recover_ecdsa.rs +++ b/examples/recover_ecdsa.rs @@ -1,12 +1,11 @@ use base64::Engine; -use swift_secure_enclave_tool_rs::{recover_ecdsa_keypair, KeyPurpose}; +use swift_secure_enclave_tool_rs::{recover_keypair, KeyPurpose}; fn main() { let args = std::env::args().collect::>(); let private_key_representation = base64::engine::general_purpose::STANDARD .decode(&args[1]) .unwrap(); - let key_material = - recover_ecdsa_keypair(KeyPurpose::Signing, &private_key_representation).unwrap(); + let key_material = recover_keypair(KeyPurpose::Signing, &private_key_representation).unwrap(); println!("{:?}", key_material) } diff --git a/src/lib.rs b/src/lib.rs index 9da3738..4e92918 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -31,41 +31,59 @@ pub fn is_secure_enclave_supported() -> XResult { } } +#[deprecated] pub fn generate_ecdsa_keypair(key_purpose: KeyPurpose, require_bio: bool) -> XResult { + generate_keypair(key_purpose, require_bio) +} + +pub fn generate_keypair(key_purpose: KeyPurpose, require_bio: bool) -> XResult { let mut cmd = Command::new(SWIFT_SECURE_ENCLAVE_TOOL_CMD); cmd.arg(match key_purpose { KeyPurpose::Signing => "generate_p256_ecsign_keypair", KeyPurpose::KeyAgreement => "generate_p256_ecdh_keypair", }); - cmd.arg(&format!("{}", require_bio)); + cmd.arg(format!("{}", require_bio)); let cmd_stdout = run_command_stdout(cmd)?; parse_keypair_result(&cmd_stdout) } +#[deprecated] pub fn recover_ecdsa_keypair( key_purpose: KeyPurpose, private_key_representation: &[u8], +) -> XResult { + recover_keypair(key_purpose, private_key_representation) +} + +pub fn recover_keypair( + key_purpose: KeyPurpose, + private_key_representation: &[u8], ) -> XResult { let mut cmd = Command::new(SWIFT_SECURE_ENCLAVE_TOOL_CMD); cmd.arg(match key_purpose { KeyPurpose::Signing => "recover_p256_ecsign_public_key", KeyPurpose::KeyAgreement => "recover_p256_ecdh_public_key", }); - cmd.arg(&STANDARD.encode(private_key_representation)); + cmd.arg(STANDARD.encode(private_key_representation)); let cmd_stdout = run_command_stdout(cmd)?; parse_keypair_result(&cmd_stdout) } +#[deprecated] pub fn private_key_ecdsa_sign( private_key_representation: &[u8], content: &[u8], ) -> XResult> { + private_key_sign(private_key_representation, content) +} + +pub fn private_key_sign(private_key_representation: &[u8], content: &[u8]) -> XResult> { let mut cmd = Command::new(SWIFT_SECURE_ENCLAVE_TOOL_CMD); cmd.arg("compute_p256_ecsign"); - cmd.arg(&STANDARD.encode(private_key_representation)); - cmd.arg(&STANDARD.encode(content)); + cmd.arg(STANDARD.encode(private_key_representation)); + cmd.arg(STANDARD.encode(content)); let cmd_stdout = run_command_stdout(cmd)?; if cmd_stdout.starts_with("ok:") { @@ -83,8 +101,8 @@ pub fn private_key_ecdh( ) -> XResult> { let mut cmd = Command::new(SWIFT_SECURE_ENCLAVE_TOOL_CMD); cmd.arg("compute_p256_ecdh"); - cmd.arg(&STANDARD.encode(private_key_representation)); - cmd.arg(&STANDARD.encode(ephemera_public_key)); + cmd.arg(STANDARD.encode(private_key_representation)); + cmd.arg(STANDARD.encode(ephemera_public_key)); let cmd_stdout = run_command_stdout(cmd)?; if cmd_stdout.starts_with("ok:SharedSecret:") { @@ -121,9 +139,9 @@ fn parse_keypair_result(cmd_stdout: &str) -> XResult { if cmd_stdout.starts_with("ok:") { let result = cmd_stdout.chars().skip(3).collect::(); let parts = result.split(",").collect::>(); - let public_key_point = STANDARD.decode(&parts[0])?; - let public_key_der = STANDARD.decode(&parts[1])?; - let private_key_representation = STANDARD.decode(&parts[2])?; + let public_key_point = STANDARD.decode(parts[0])?; + let public_key_der = STANDARD.decode(parts[1])?; + let private_key_representation = STANDARD.decode(parts[2])?; Ok(KeyMaterial { public_key_point, public_key_der,