refactor MAC auth

src/components/card_reader.rs

@@ -4,17 +4,18 @@ use embassy_sync::once_lock::OnceLock;
 use embassy_time::{Delay, Timer};
 use esp_hal::gpio;
 use esp_hal::rng::Trng;
-use pn532::felica::types::{FelicaPollingRequestCode};
+use pn532::felica::types::{CardSession, FelicaLiteSBlock, FelicaPollingRequestCode};
 use pn532::{BaudRate, Pn532};
+use pn532::felica::types::felica_lite_s::auth::CardKey;
 
-static CARD_KEY: OnceLock<[u8; 16]> = OnceLock::new();
+static CARD_KEY: OnceLock<CardKey> = OnceLock::new();
 const CARD_KEY_STR: &str = env!("CARD_KEY");
 
-fn get_card_key() -> &'static [u8; 16] {
+fn get_card_key() -> &'static CardKey {
     CARD_KEY.get_or_init(|| {
         let mut buffer = [0u8; 16];
         hex::decode_to_slice(CARD_KEY_STR, &mut buffer).unwrap();
-        buffer
+        CardKey(buffer)
     })
 }
 
@@ -43,7 +44,7 @@ pub async fn start_card_reader(
     mut trng: Trng
 ) -> () {
     let card_key = get_card_key();
-    defmt::trace!("card_key: {}", hex::encode_upper(card_key));
+    defmt::trace!("card_key: {}", card_key);
     
     loop {
         Timer::after_millis(50).await;
@@ -63,6 +64,7 @@ pub async fn start_card_reader(
             continue;
         };
         defmt::info!("Polling card: {}", Debug2Format(&response));
+        let card = CardSession::from(response);
         
         // if let Err(e) = card_reader.driver.felica_write_without_encryption(
         //     &response.idm, &response.pmm,
@@ -74,46 +76,28 @@ pub async fn start_card_reader(
         //     continue;
         // }
 
-        let (rc1, rc2) = match card_reader.driver.set_random_challenge(
-            &response.idm,
-            &response.pmm,
-            &mut trng
-        ) {
-            Ok(rc) => rc,
+        let auth_result = card_reader.driver.try_authenticate(
+            &mut trng, &card, card_key
+        );
+        let session = match auth_result {
+            Ok(Some(sk)) => sk,
+            Ok(None) => {
+                defmt::warn!("card key is invalid");
+                continue;
+            },
             Err(e) => {
-                defmt::error!("card_reader rc error: {}", e);
+                defmt::error!("card_reader auth error: {}", e);
                 continue;
             }
         };
-        defmt::info!("RC: rc1: {:02X}, rc2: {:02X}", rc1, rc2);
-
-        let mut rc = [0u8; 16];
-        rc[..8].copy_from_slice(&rc1);
-        rc[8..].copy_from_slice(&rc2);
-        
-        let (sk1, sk2) = match card_reader.driver.get_session_keys(&rc, card_key) {
-            Ok(v) => v,
+        let read_result = card_reader.driver.read_with_mac(&card, &session, FelicaLiteSBlock::PAD0);
+        let _read_data = match read_result { 
+            Ok(d) => d,
             Err(e) => {
-                defmt::error!("card_reader sk error: {}", e);
+                defmt::error!("card_reader read with mac error: {}", e);
                 continue;
             }
         };
-        defmt::info!("sk1: {:02X} sk2: {:02X}", sk1, sk2);
-        
-        let mac = match card_reader.driver.check_mac(
-            &response.idm,
-            &response.pmm,
-            &sk1,
-            &sk2,
-            &rc1
-        ) {
-            Ok(v) => v,
-            Err(e) => {
-                defmt::error!("card_driver mac check error: {}", e);
-                continue;
-            }
-        };
-        defmt::info!("mac check: {}", mac);
         
         match card_reader.driver.release() {
             Ok(_) => {},