Rename device-agnostic APDU methods

Author: Crote

src/apdu.rs

@@ -17,7 +17,7 @@ pub trait APDUDevice {
 // Device Commands
 ////////////////////////////////////////////////////////////////////////
 
-pub fn u2f_register<T>(dev: &mut T, challenge: &[u8], application: &[u8]) -> io::Result<Vec<u8>>
+pub fn apdu_register<T>(dev: &mut T, challenge: &[u8], application: &[u8]) -> io::Result<Vec<u8>>
 where
     T: APDUDevice,
 {
@@ -34,10 +34,10 @@ where
 
     let flags = U2F_REQUEST_USER_PRESENCE;
     let (resp, status) = dev.send_apdu(U2F_REGISTER, flags, &register_data)?;
-    status_word_to_result(status, resp)
+    apdu_status_to_result(status, resp)
 }
 
-pub fn u2f_sign<T>(
+pub fn apdu_sign<T>(
     dev: &mut T,
     challenge: &[u8],
     application: &[u8],
@@ -68,10 +68,10 @@ where
 
     let flags = U2F_REQUEST_USER_PRESENCE;
     let (resp, status) = dev.send_apdu(U2F_AUTHENTICATE, flags, &sign_data)?;
-    status_word_to_result(status, resp)
+    apdu_status_to_result(status, resp)
 }
 
-pub fn u2f_is_keyhandle_valid<T>(
+pub fn apdu_is_keyhandle_valid<T>(
     dev: &mut T,
     challenge: &[u8],
     application: &[u8],
@@ -105,21 +105,21 @@ where
     Ok(status == SW_CONDITIONS_NOT_SATISFIED)
 }
 
-pub fn is_v2_device<T>(dev: &mut T) -> io::Result<bool>
+pub fn apdu_is_v2_device<T>(dev: &mut T) -> io::Result<bool>
 where
     T: APDUDevice
 {
     let (data, status) = dev.send_apdu(U2F_VERSION, 0x00, &[])?;
     let actual = CString::new(data)?;
     let expected = CString::new("U2F_V2")?;
-    status_word_to_result(status, actual == expected)
+    apdu_status_to_result(status, actual == expected)
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Error Handling
 ////////////////////////////////////////////////////////////////////////
 
-pub fn status_word_to_result<T>(status: [u8; 2], val: T) -> io::Result<T> {
+pub fn apdu_status_to_result<T>(status: [u8; 2], val: T) -> io::Result<T> {
     use self::io::ErrorKind::{InvalidData, InvalidInput};
 
     match status {

src/statemachine.rs

@@ -7,7 +7,7 @@ use crate::errors;
 use crate::platform::device::Device;
 use crate::platform::transaction::Transaction;
 use crate::statecallback::StateCallback;
-use crate::apdu::{u2f_is_keyhandle_valid, u2f_register, u2f_sign, APDUDevice};
+use crate::apdu::{apdu_is_keyhandle_valid, apdu_register, apdu_sign, APDUDevice};
 use crate::u2ftypes::U2FInfoQueryable;
 
 use std::sync::mpsc::Sender;
@@ -117,20 +117,20 @@ impl StateMachine {
             // consent, to be consistent with CTAP2 device behavior.
             let excluded = key_handles.iter().any(|key_handle| {
                 is_valid_transport(key_handle.transports)
-                    && u2f_is_keyhandle_valid(dev, &challenge, &application, &key_handle.credential)
+                    && apdu_is_keyhandle_valid(dev, &challenge, &application, &key_handle.credential)
                         .unwrap_or(false) /* no match on failure */
             });
 
             while alive() {
                 if excluded {
                     let blank = vec![0u8; PARAMETER_SIZE];
-                    if u2f_register(dev, &blank, &blank).is_ok() {
+                    if apdu_register(dev, &blank, &blank).is_ok() {
                         callback.call(Err(errors::AuthenticatorError::U2FToken(
                             errors::U2FTokenError::InvalidState,
                         )));
                         break;
                     }
-                } else if let Ok(bytes) = u2f_register(dev, &challenge, &application) {
+                } else if let Ok(bytes) = apdu_register(dev, &challenge, &application) {
                     let dev_info = dev.get_device_info();
                     send_status(
                         &status_mutex,
@@ -201,7 +201,7 @@ impl StateMachine {
             // valid key handle for an appId, we'll use that appId below.
             let (app_id, valid_handles) =
                 find_valid_key_handles(&app_ids, &key_handles, |app_id, key_handle| {
-                    u2f_is_keyhandle_valid(dev, &challenge, app_id, &key_handle.credential)
+                    apdu_is_keyhandle_valid(dev, &challenge, app_id, &key_handle.credential)
                         .unwrap_or(false) /* no match on failure */
                 });
 
@@ -230,7 +230,7 @@ impl StateMachine {
                 // then just make it blink with bogus data.
                 if valid_handles.is_empty() {
                     let blank = vec![0u8; PARAMETER_SIZE];
-                    if u2f_register(dev, &blank, &blank).is_ok() {
+                    if apdu_register(dev, &blank, &blank).is_ok() {
                         callback.call(Err(errors::AuthenticatorError::U2FToken(
                             errors::U2FTokenError::InvalidState,
                         )));
@@ -239,7 +239,7 @@ impl StateMachine {
                 } else {
                     // Otherwise, try to sign.
                     for key_handle in &valid_handles {
-                        if let Ok(bytes) = u2f_sign(dev, &challenge, app_id, &key_handle.credential)
+                        if let Ok(bytes) = apdu_sign(dev, &challenge, app_id, &key_handle.credential)
                         {
                             let dev_info = dev.get_device_info();
                             send_status(

src/u2fprotocol.rs

@@ -23,7 +23,7 @@ where
         thread_rng().fill_bytes(&mut nonce);
 
         // Initialize the device and check its version.
-        init_device(self, &nonce).and(is_v2_device(self)).map(|_| ())
+        init_device(self, &nonce).and(apdu_is_v2_device(self)).map(|_| ())
     }
 
     fn send_apdu(&mut self, cmd: u8, p1: u8, send: &[u8]) -> io::Result<(Vec<u8>, [u8; 2])>