Merge #29: Async and support TAPSIGNER backup and change commands, sign PSBT

3d7c1ec Make uniffi dep version less restrictive (Praveen Perera)
6609c34 Update README.md to show that we've added support for `change` and `backup` commands (Praveen Perera)
1f95e27 Update tap_signer.rs (Praveen Perera)
3ac5f95 Add note about toggling the hardened bit (Praveen Perera)
9cf9fbd Get the correct path for deriving (Praveen Perera)
09c2f57 Derive pubkey from TAPSIGNER if we get a pubkey mismatch (Praveen Perera)
30bfddb Improve comments on the PSBT signing code (Praveen Perera)
7db62ee Fix clippy warnings (Praveen Perera)
fe190c4 Add docs and remove finalizing PSBT, leave it up to the user (Praveen Perera)
2871698 Get the subpath correctly from the PSBT (Praveen Perera)
37f7fc6 Use byte arrays for `DeriveResponse` (Praveen Perera)
c71ba3f Add function to finalize PSBT (Praveen Perera)
bbcb1d2 Use secp from `bitcoin`, verify pubkey matches (Praveen Perera)
ad81034 Retry  `UnluckyNumber` errors during `sign` command (Praveen Perera)
0b98baa Add `reason` to `InvalidScript` error (Praveen Perera)
ab0ae62 Make `bitcoin` a regular dependency (Praveen Perera)
2097a84 Use a `vec` for subpath because it can be 0,1,2 in length (Praveen Perera)
898f7be Add `sign` command to cli (Praveen Perera)
ae2fb07 Use byte arrays whenever possible (Praveen Perera)
c907f6f Add `psbt` signing to lib (Praveen Perera)
4856cc0 Fix typo in comments (Praveen Perera)
54bd325 Make all commands take a &str instead of a String for cvc and fix tests (Praveen Perera)
f93d247 Fix errors in examples (Praveen Perera)
b787752 Update tap_signer.rs (Praveen Perera)
98c21e0 Add `StatusCommand` to TapSigner (Praveen Perera)
b020c4d Update tap_signer.rs (Praveen Perera)
f6841a3 Revert changes, SATSCARD won't have pubkey set (Praveen Perera)
3dfec7e Added note about signature verification for derive command (Praveen Perera)
37721f4 Fix signature verification for `derive` command (Praveen Perera)
cf7f6e2 Adjust wording on `BackupFirst` error (Praveen Perera)
dd01257 Create `CkTapError` enum to represent errors returned by the card (Praveen Perera)
22515cc Use slice instead of Vec for master pubkey (Praveen Perera)
c754df5 Make `derive` signature verification work with a derivation path (Praveen Perera)
2f8d83e Make `chain_code` a byte array instead of a Vec (Praveen Perera)
a74be41 Rework CvcChangeError (Praveen Perera)
fe3033e Fix imports (Praveen Perera)
bf32158 Improve error handling (Praveen Perera)
d36a8f0 Complete `change` command (Praveen Perera)
a81474f Add `backup` and `change` commands to CLI (Praveen Perera)
d1a7bc6 Implement `change` and `backup` commands and validation logic (Praveen Perera)
115374d Set card nonce as 16 byte array (Praveen Perera)
2756692 Create new `TapSignerError` (Praveen Perera)
591f92a Change all `epubkey` to be 33 bytes (Praveen Perera)
0440250 Change all `cmd` from `String` to `&'static str` (Praveen Perera)
b51dd5b Separate apdu commands to modules (Praveen Perera)
5dc76a5 Separate out functions for `TAPSIGNER` & `SATSCARD` (Praveen Perera)
42a04fa Allow transmit to be used in async contexts (Praveen Perera)
e6fa7ab Fix CLI (Praveen Perera)
0ef500f Make the `CkTransport` trait `async` (Praveen Perera)
0450bc6 Update deps and fix breaking changes (Praveen Perera)

Pull request description:

ACKs for top commit:
  notmandatory:
    ACK 3d7c1ec

Tree-SHA512: 176362a894575cad82491cefafa79c625f55909dc8287192aa1dcd27c789dd4bf6266407a8aaf3cffcba7cb9ca3873a62bf73f4f20a6e8cbf4cb88ec8e0a16af

Author: notmandatory

README.md

@@ -1,13 +1,13 @@
 # rust-cktap
 
-[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](https://github.com/notmandatory/rust-cktap/blob/master/LICENSE) 
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](https://github.com/notmandatory/rust-cktap/blob/master/LICENSE)
 [![CI](https://github.com/notmandatory/rust-cktap/actions/workflows/test.yml/badge.svg)](https://github.com/notmandatory/rust-cktap/actions/workflows/test.yml)
 [![rustc](https://img.shields.io/badge/rustc-1.57.0%2B-lightgrey.svg)](https://blog.rust-lang.org/2021/12/02/Rust-1.57.0.html)
 
 A Rust implementation of the [Coinkite Tap Protocol](https://github.com/coinkite/coinkite-tap-proto) (cktap)
 for use with [SATSCARD], [TAPSIGNER], and [SATSCHIP] products.
 
-This project provides PC/SC APDU message encoding and decoding, cvc authentication, certificate chain verification, and card response verification. 
+This project provides PC/SC APDU message encoding and decoding, cvc authentication, certificate chain verification, and card response verification.
 
 It is up to the crate user to send and receive the raw cktap APDU messages via NFC to the card by implementing the `CkTransport` trait. An example implementation is provided using the optional rust `pcsc` crate. Mobile users are expected to implement `CkTransport` using the iOS or Android provided libraries.
 
@@ -37,9 +37,9 @@ It is up to the crate user to send and receive the raw cktap APDU messages via N
 
 #### TAPSIGNER-Only Commands
 
-- [ ] [change](https://github.com/coinkite/coinkite-tap-proto/blob/master/docs/protocol.md#change)
+- [x] [change](https://github.com/coinkite/coinkite-tap-proto/blob/master/docs/protocol.md#change)
 - [x] [xpub](https://github.com/coinkite/coinkite-tap-proto/blob/master/docs/protocol.md#xpub)
-- [ ] [backup](https://github.com/coinkite/coinkite-tap-proto/blob/master/docs/protocol.md#backup)
+- [x] [backup](https://github.com/coinkite/coinkite-tap-proto/blob/master/docs/protocol.md#backup)
 
 ### Automated Testing with Emulator
 
@@ -52,21 +52,21 @@ It is up to the crate user to send and receive the raw cktap APDU messages via N
 
 #### Prerequisites
 
-1. USB PCSC NFC card reader, for example:  
-   * [OMNIKEY 5022 CL](https://www.hidglobal.com/products/omnikey-5022-reader)
+1. USB PCSC NFC card reader, for example:
+   - [OMNIKEY 5022 CL](https://www.hidglobal.com/products/omnikey-5022-reader)
 2. Coinkite SATSCARD, TAPSIGNER, or SATSCHIP cards
-Install vendor PCSC driver
+   Install vendor PCSC driver
 3. Connect NFC reader to desktop system
 4. Place SATSCARD, TAPSIGNER, or SATSCHIP on reader
- 
+
 #### Run CLI
 
-   ```
-   cargo run -p cktap-cli -- --help
-   cargo run -p cktap-cli -- certs
-   cargo run -p cktap-cli -- read
-   ```
+```
+cargo run -p cktap-cli -- --help
+cargo run -p cktap-cli -- certs
+cargo run -p cktap-cli -- read
+```
 
 [SATSCARD]: https://satscard.com/
 [TAPSIGNER]: https://tapsigner.com/
-[SATSCHIP]: https://satschip.com/
+[SATSCHIP]: https://satschip.com/

cli/Cargo.toml

@@ -10,6 +10,7 @@ rust-cktap = { path = "../lib", features = ["pcsc"] }
 pcsc = { version = "2" }
 clap = { version = "4.3.1", features = ["derive"] }
 rpassword = { version = "7.2" }
+tokio = { version = "1", features = ["full"] }
 
 [features]
 emulator = ["rust-cktap/emulator"]

cli/src/main.rs

@@ -6,6 +6,7 @@ use rust_cktap::commands::{CkTransport, Read};
 use rust_cktap::emulator;
 #[cfg(not(feature = "emulator"))]
 use rust_cktap::pcsc;
+use rust_cktap::secp256k1::hashes::Hash as _;
 use rust_cktap::secp256k1::rand;
 use rust_cktap::{apdu::Error, commands::Certificate, rand_chaincode, CkTapCard};
 use std::io;
@@ -65,16 +66,23 @@ enum TapSignerCommand {
         #[clap(short, long, value_delimiter = ',', num_args = 1..)]
         path: Vec<u32>,
     },
+    /// Get an encrypted backup of the card's private key
+    Backup,
+    /// Change the PIN (CVC) used for card authentication to a new user provided one
+    Change { new_cvc: String },
+    /// Sign a digest
+    Sign { to_sign: String },
 }
 
-fn main() -> Result<(), Error> {
+#[tokio::main]
+async fn main() -> Result<(), Error> {
     // figure out what type of card we have before parsing cli args
     #[cfg(not(feature = "emulator"))]
-    let mut card = pcsc::find_first()?;
+    let mut card = pcsc::find_first().await?;
 
     // if emulator feature enabled override pcsc card
     #[cfg(feature = "emulator")]
-    let mut card = emulator::find_emulator()?;
+    let mut card = emulator::find_emulator().await?;
 
     let rng = &mut rand::thread_rng();
 
@@ -86,21 +94,21 @@ fn main() -> Result<(), Error> {
                     dbg!(&sc);
                 }
                 SatsCardCommand::Address => println!("Address: {}", sc.address().unwrap()),
-                SatsCardCommand::Certs => check_cert(sc),
-                SatsCardCommand::Read => read(sc, None),
+                SatsCardCommand::Certs => check_cert(sc).await,
+                SatsCardCommand::Read => read(sc, None).await,
                 SatsCardCommand::New => {
                     let slot = sc.slot().expect("current slot number");
-                    let chain_code = Some(rand_chaincode(rng).to_vec());
-                    let response = &sc.new_slot(slot, chain_code, cvc()).unwrap();
+                    let chain_code = Some(rand_chaincode(rng));
+                    let response = &sc.new_slot(slot, chain_code, &cvc()).await.unwrap();
                     println!("{}", response)
                 }
                 SatsCardCommand::Unseal => {
                     let slot = sc.slot().expect("current slot number");
-                    let response = &sc.unseal(slot, cvc()).unwrap();
+                    let response = &sc.unseal(slot, &cvc()).await.unwrap();
                     println!("{}", response)
                 }
                 SatsCardCommand::Derive => {
-                    dbg!(&sc.derive());
+                    dbg!(&sc.derive().await);
                 }
             }
         }
@@ -110,15 +118,33 @@ fn main() -> Result<(), Error> {
                 TapSignerCommand::Debug => {
                     dbg!(&ts);
                 }
-                TapSignerCommand::Certs => check_cert(ts),
-                TapSignerCommand::Read => read(ts, Some(cvc())),
+                TapSignerCommand::Certs => check_cert(ts).await,
+                TapSignerCommand::Read => read(ts, Some(cvc())).await,
                 TapSignerCommand::Init => {
-                    let chain_code = rand_chaincode(rng).to_vec();
-                    let response = &ts.init(chain_code, cvc());
+                    let chain_code = rand_chaincode(rng);
+                    let response = &ts.init(chain_code, &cvc()).await;
                     dbg!(response);
                 }
                 TapSignerCommand::Derive { path } => {
-                    dbg!(&ts.derive(path, cvc()));
+                    dbg!(&ts.derive(&path, &cvc()).await);
+                }
+
+                TapSignerCommand::Backup => {
+                    let response = &ts.backup(&cvc()).await;
+                    println!("{:?}", response);
+                }
+
+                TapSignerCommand::Change { new_cvc } => {
+                    let response = &ts.change(&new_cvc, &cvc()).await;
+                    println!("{:?}", response);
+                }
+                TapSignerCommand::Sign { to_sign } => {
+                    let digest: [u8; 32] =
+                        rust_cktap::secp256k1::hashes::sha256::Hash::hash(to_sign.as_bytes())
+                            .to_byte_array();
+
+                    let response = &ts.sign(digest, vec![], &cvc()).await;
+                    println!("{:?}", response);
                 }
             }
         }
@@ -129,8 +155,11 @@ fn main() -> Result<(), Error> {
 
 // handler functions for each command
 
-fn check_cert<T: CkTransport>(card: &mut dyn Certificate<T>) {
-    if let Ok(k) = card.check_certificate() {
+async fn check_cert<C, T: CkTransport>(card: &mut C)
+where
+    C: Certificate<T>,
+{
+    if let Ok(k) = card.check_certificate().await {
         println!(
             "Genuine card from Coinkite.\nHas cert signed by: {}",
             k.name()
@@ -140,8 +169,11 @@ fn check_cert<T: CkTransport>(card: &mut dyn Certificate<T>) {
     }
 }
 
-fn read<T: CkTransport>(card: &mut dyn Read<T>, cvc: Option<String>) {
-    match card.read(cvc) {
+async fn read<C, T: CkTransport>(card: &mut C, cvc: Option<String>)
+where
+    C: Read<T>,
+{
+    match card.read(cvc).await {
         Ok(resp) => println!("{}", resp),
         Err(e) => {
             dbg!(&e);

lib/Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [lib]
 crate-type = ["lib", "staticlib", "cdylib"]
 name = "rust_cktap"
@@ -13,15 +12,26 @@ name = "rust_cktap"
 ciborium = "0.2.0"
 serde = "1"
 serde_bytes = "0.11"
-secp256k1 = { version = "0.26.0", features = ["rand-std", "bitcoin-hashes-std", "recovery"] }
 
-# optional dependencies
+# async
+tokio = { version = "1.44", features = ["macros"] }
+
+# error handling
+thiserror = "2.0"
+
+# bitcoin
+bitcoin = { version = "0.32", features = ["rand-std"] }
+
+# logging
+log = "0.4"
+
+# uniffi todo: make this optional
+uniffi = { version = "0.29.1", features = ["cli"] }
+
 pcsc = { version = "2", optional = true }
-uniffi = { version = "=0.28.0", features = ["cli"] }
-thiserror = "1.0.58"
 
 [build-dependencies]
-uniffi = { version = "=0.28.0", features = ["build"] }
+uniffi = { version = "0.29.1", features = ["build"] }
 
 [features]
 default = []

lib/build.rs

@@ -4,7 +4,7 @@ use rust_cktap::apdu::Error;
 use rust_cktap::commands::{Certificate, Wait};
 use rust_cktap::{pcsc, rand_chaincode, CkTapCard};
 
-use secp256k1::rand;
+use bitcoin::secp256k1::rand;
 use std::io;
 use std::io::Write;
 
@@ -17,8 +17,9 @@ fn get_cvc() -> String {
 }
 
 // Example using pcsc crate
-fn main() -> Result<(), Error> {
-    let card = pcsc::find_first()?;
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    let card = pcsc::find_first().await?;
     dbg!(&card);
 
     let rng = &mut rand::thread_rng();
@@ -30,25 +31,25 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while ts.auth_delay.is_some() {
                 dbg!(ts.auth_delay.unwrap());
-                ts.wait(None)?;
+                ts.wait(None).await?;
             }
 
             // only do this once per card!
             if ts.path.is_none() {
-                let chain_code = rand_chaincode(rng).to_vec();
-                let new_result = ts.init(chain_code, cvc)?;
+                let chain_code = rand_chaincode(rng);
+                let new_result = ts.init(chain_code, &cvc).await.unwrap();
                 dbg!(new_result);
             }
 
-            // let read_result = card.read(cvc.clone())?;
+            // let read_result = ts.read(Some(cvc.clone())).await?;
             // dbg!(read_result);
 
-            dbg!(ts.check_certificate().unwrap().name());
+            dbg!(ts.check_certificate().await.unwrap().name());
 
             //let dump_result = card.dump();
 
             // let path = vec![2147483732, 2147483648, 2147483648];
-            // let derive_result = card.derive(path, cvc.clone())?;
+            // let derive_result = ts.derive(path, cvc.clone()).await?;
             // dbg!(&derive_result);
 
             // let nfc_result = card.nfc()?;
@@ -60,17 +61,17 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while chip.auth_delay.is_some() {
                 dbg!(chip.auth_delay.unwrap());
-                chip.wait(None)?;
+                chip.wait(None).await?;
             }
 
             // only do this once per card!
             if chip.path.is_none() {
-                let chain_code = rand_chaincode(rng).to_vec();
-                let new_result = chip.init(chain_code, get_cvc())?;
+                let chain_code = rand_chaincode(rng);
+                let new_result = chip.init(chain_code, &get_cvc()).await.unwrap();
                 dbg!(new_result);
             }
 
-            // let read_result = card.read(cvc)?;
+            // let read_result = chip.read(Some(cvc.clone())).await?;
             // dbg!(read_result);
 
             // let nfc_result = card.nfc()?;
@@ -80,17 +81,17 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while sc.auth_delay.is_some() {
                 dbg!(sc.auth_delay.unwrap());
-                let wait_response = sc.wait(None)?;
+                let wait_response = sc.wait(None).await?;
                 dbg!(wait_response);
             }
 
-            // let read_result = sc.read(None)?;
+            // let read_result = sc.read(None).await?;
             // dbg!(read_result);
 
-            // let derive_result = card.derive()?;
+            // let derive_result = sc.derive().await?;
             // dbg!(&derive_result);
 
-            dbg!(sc.check_certificate().unwrap().name());
+            dbg!(sc.check_certificate().await.unwrap().name());
 
             // let nfc_result = card.nfc()?;
             // dbg!(nfc_result);
@@ -99,20 +100,20 @@ fn main() -> Result<(), Error> {
             //     if slot == &0 {
             //         // TODO must unseal first
             //         let chain_code = rand_chaincode(rng).to_vec();
-            //         let new_result = card.new_slot(0, chain_code, get_cvc())?;
+            //         let new_result = sc.new_slot(0, chain_code, get_cvc()).await?;
             //     }
             // }
 
             // let certs_result = card.certs()?;
             // dbg!(certs_result);
 
-            // let unseal_result = card.unseal(0, get_cvc())?;
+            // let unseal_result = sc.unseal(0, get_cvc()).await?;
             // dbg!(unseal_result);
 
-            // let dump_result = card.dump(0, None)?;
+            // let dump_result = sc.dump(0, None).await?;
             // dbg!(dump_result);
 
-            // let dump_result = card.dump(0, Some(get_cvc()))?;
+            // let dump_result = sc.dump(0, Some(get_cvc())).await?;
             // dbg!(dump_result);
         }
     }