Merge pull request #18 from siketyan/migrate-to-pcsc

feat(cli): Drop support of libnfc, use pcsc instead

Author: siketyan

.github/workflows/rust.yml

@@ -32,8 +32,8 @@ jobs:
           override: true
           components: rustfmt,clippy
 
-      - name: Install libnfc
-        run: sudo apt install libnfc5 libnfc-dev udev libudev-dev
+      - name: Install libpcsclite
+        run: sudo apt install libudev-dev libpcsclite-dev
 
       - name: Run clippy
         uses: actions-rs/clippy-check@v1
@@ -56,21 +56,34 @@ jobs:
     strategy:
       matrix:
         target:
+          - x86_64-pc-windows-msvc
+          - x86_64-apple-darwin
           - x86_64-unknown-linux-gnu
           - aarch64-linux-android
           - armv7-linux-androideabi
         include:
+          - target: x86_64-pc-windows-msvc
+            host: windows-2022
+            cli: true
+            android: false
+          - target: x86_64-apple-darwin
+            host: macos-12
+            cli: true
+            android: false
           - target: x86_64-unknown-linux-gnu
+            host: ubuntu-20.04
             cli: true
             android: false
           - target: aarch64-linux-android
+            host: ubuntu-20.04
             cli: false
             android: true
           - target: armv7-linux-androideabi
+            host: ubuntu-20.04
             cli: false
             android: true
 
-    runs-on: ubuntu-20.04
+    runs-on: ${{ matrix.host }}
     steps:
       - uses: actions/checkout@v2
         with:
@@ -91,9 +104,9 @@ jobs:
           override: true
           target: ${{ matrix.target }}
 
-      - name: Install libnfc
-        if: ${{ matrix.cli }}
-        run: sudo apt install libnfc5 libnfc-dev udev libudev-dev pcscd libpcsclite-dev
+      - name: Install libpcsclite
+        if: ${{ matrix.cli && matrix.host == 'ubuntu-20.04' }}
+        run: sudo apt install libudev-dev libpcsclite-dev
 
       - name: Install Android NDK
         if: ${{ matrix.android }}

cli/Cargo.toml

@@ -14,6 +14,9 @@ edition = "2021"
 [dependencies]
 clap = { version = "3.1", features = ["derive"] }
 dialoguer = "0.10"
+hex = "0.4"
 jpki = { version = "0.1.5", path = ".." }
-nfc1-sys = { version = "0.2", features = ["conffiles", "envvars", "logging", "driver_pcsc"] }
+pcsc = "2.7"
 thiserror = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

cli/src/main.rs

@@ -1,13 +1,16 @@
 mod nfc;
 
 use std::fs::File;
-use std::io::{stdin, stdout, Read, Write};
+use std::io::{stderr, stdin, stdout, Read, Write};
 use std::path::PathBuf;
 use std::process::exit;
 
 use clap::{ArgEnum, Parser, Subcommand};
 use dialoguer::Password;
+use jpki::ap::jpki as jpki_ap;
 use jpki::nfc::apdu::{Command, Handler, Response};
+use tracing::{error, info};
+use tracing_subscriber::EnvFilter;
 
 use crate::nfc::{Context, Initiator, Target};
 
@@ -49,13 +52,15 @@ enum CertType {
     AuthCA,
 }
 
-impl Into<jpki::ap::jpki::CertType> for CertType {
-    fn into(self) -> jpki::ap::jpki::CertType {
+impl Into<jpki_ap::CertType> for CertType {
+    fn into(self) -> jpki_ap::CertType {
+        use jpki_ap::CertType::*;
+
         match self {
-            Self::Sign => jpki::ap::jpki::CertType::Sign,
-            Self::SignCA => jpki::ap::jpki::CertType::SignCA,
-            Self::Auth => jpki::ap::jpki::CertType::Auth,
-            Self::AuthCA => jpki::ap::jpki::CertType::AuthCA,
+            Self::Sign => Sign,
+            Self::SignCA => SignCA,
+            Self::Auth => Auth,
+            Self::AuthCA => AuthCA,
         }
     }
 }
@@ -107,20 +112,20 @@ fn read_all<R: Read>(mut r: R) -> Result<Vec<u8>> {
     Ok(buffer)
 }
 
-fn main() -> Result<()> {
+fn run() -> Result<()> {
     let cli: Cli = Cli::parse();
 
     let ctx = Context::try_new().map_err(Error::NFC)?;
     let device = ctx.open().map_err(Error::NFC)?;
-    let initiator = Initiator::try_from(device).map_err(Error::NFC)?;
-    let target = initiator.select_dep_target().map_err(Error::NFC)?;
+    let initiator = Initiator::from(device);
+    let target = initiator.select_dep_target(ctx).map_err(Error::NFC)?;
 
     let nfc_card = NfcCard { target };
     let card = jpki::Card::new(Box::new(nfc_card));
     let jpki_ap = jpki::ap::JpkiAp::open((), Box::new(card)).map_err(Error::APDU)?;
     match &cli.command {
         SubCommand::ReadCertificate { ty } => {
-            let ty: jpki::ap::jpki::CertType = (*ty).into();
+            let ty: jpki_ap::CertType = (*ty).into();
             let pin = if ty.is_pin_required() {
                 prompt_password()?
             } else {
@@ -148,13 +153,24 @@ fn main() -> Result<()> {
             let certificate = read_all(File::open(certificate_path).map_err(Error::IO)?)?;
             let signature = read_all(File::open(signature_path).map_err(Error::IO)?)?;
             if jpki::digest::verify(certificate, read_all(stdin())?, signature) {
-                println!("OK");
+                info!("OK")
             } else {
-                println!("NG");
+                error!("NG");
                 exit(1);
             }
         }
     }
 
     Ok(())
 }
+
+fn main() {
+    tracing_subscriber::fmt::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .with_writer(stderr)
+        .init();
+
+    if let Err(e) = run() {
+        error!("{}", e);
+    }
+}