nfc_oath/

lib.rs

#[macro_use]
extern crate log;
extern crate byteorder;
extern crate nfc;

use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use nfc::context;
use nfc::device;
use nfc::ffi;
use nfc::initiator;
use nfc::misc;
use std::collections::HashMap;
use std::fmt;
use std::io::{Cursor, Read, Write};
use std::mem;
use std::ptr;
use std::time::{Duration, Instant, SystemTime};

#[cfg(test)]
mod tests {
    use std::time::{Duration, SystemTime};

    #[test]
    fn it_works() {}

    #[test]
    fn code_formatter_works() {
        let code = ::OathCode {
            digits: ::OathDigits::Six,
            value: 595641143,
            expiration: 0,
            steam: false,
        };
        assert_eq!(format!("{}", code), "641143");
    }

    #[test]
    fn parse_tlv_works() {
        let resp = ::parse_tlv(&vec![0x76, 0x05, 0x06, 0x23, 0x80, 0xc3, 0x37, 0x90, 0x00]);
        println!("{:?}", resp);
    }

    #[test]
    fn parse_list_works() {
        let result = ::parse_list(&vec![
            0x72, 0x1A, 0x21, 0x44, 0x6F, 0x6F, 0x72, 0x79, 0x3A, 0x64, 0x6F, 0x6F, 0x72, 0x79,
            0x40, 0x63, 0x75, 0x74, 0x65, 0x6C, 0x61, 0x62, 0x2E, 0x68, 0x6F, 0x75, 0x73, 0x65,
            0x90, 0x00,
        ]);
        let answer = vec![::OathCredential::new(
            "Doory:doory@cutelab.house",
            ::OathType::Totp,
            false,
            ::OathAlgo::Sha1,
        )];
        assert_eq!(answer, result.unwrap());

        let result = ::parse_list(&vec![
            0x72, 0x16, 0x21, 0x44, 0x6F, 0x6D, 0x61, 0x69, 0x6E, 0x3A, 0x79, 0x6F, 0x75, 0x72,
            0x40, 0x65, 0x6D, 0x61, 0x69, 0x6C, 0x2E, 0x63, 0x6F, 0x6D, 0x72, 0x17, 0x21, 0x44,
            0x6F, 0x6F, 0x72, 0x79, 0x3A, 0x65, 0x76, 0x40, 0x63, 0x75, 0x74, 0x65, 0x6C, 0x61,
            0x62, 0x2E, 0x68, 0x6F, 0x75, 0x73, 0x65, 0x90, 0x00,
        ]);
        let answer = vec![
            ::OathCredential::new(
                "Domain:your@email.com",
                ::OathType::Totp,
                false,
                ::OathAlgo::Sha1,
            ),
            ::OathCredential::new(
                "Doory:ev@cutelab.house",
                ::OathType::Totp,
                false,
                ::OathAlgo::Sha1,
            ),
        ];
        assert_eq!(answer, result.unwrap());
    }

    #[test]
    fn time_challenge_works() {
        let vectors: &[(Duration, Vec<u8>)] = &[
            (
                Duration::new(0, 0),
                vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
            ),
            (
                Duration::new(12345678, 0),
                vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x47, 0x82],
            ),
            (
                Duration::new(1484223461, 264495800),
                vec![0x00, 0x00, 0x00, 0x00, 0x02, 0xf2, 0xea, 0x43],
            ),
        ];

        for i in 0..vectors.len() {
            let (dur, ref answer) = vectors[i];

            let time = SystemTime::UNIX_EPOCH + dur;
            let result = ::time_challenge(Some(time));

            assert_eq!(*answer, result);
        }
    }

}

#[repr(u8)]
pub enum Tag {
    Name = 0x71,
    NameList = 0x72,
    Key = 0x73,
    Challenge = 0x74,
    Response = 0x75,
    TruncatedResponse = 0x76,
    Hotp = 0x77,
    Property = 0x78,
    Version = 0x79,
    Imf = 0x7a,
    Algorithm = 0x7b,
    Touch = 0x7c,
}

#[derive(Debug, PartialEq)]
#[repr(u8)]
pub enum OathAlgo {
    Sha1 = 0x01,
    Sha256 = 0x02,
}

impl OathAlgo {
    fn from_u8(n: u8) -> Option<OathAlgo> {
        match n {
            0x01 => Some(OathAlgo::Sha1),
            0x02 => Some(OathAlgo::Sha256),
            _ => None,
        }
    }
}

#[derive(Debug, PartialEq)]
#[repr(u8)]
pub enum OathType {
    Hotp = 0x10,
    Totp = 0x20,
}

impl OathType {
    fn from_u8(n: u8) -> Option<OathType> {
        match n {
            0x10 => Some(OathType::Hotp),
            0x20 => Some(OathType::Totp),
            _ => None,
        }
    }
}

#[repr(u8)]
pub enum Properties {
    RequireTouch = 0x02,
}

#[repr(u8)]
pub enum Ins {
    Put = 0x01,
    Delete = 0x02,
    SetCode = 0x03,
    Reset = 0x04,
    List = 0xa1,
    Calculate = 0xa2,
    Validate = 0xa3,
    CalculateAll = 0xa4,
    SendRemaining = 0xa5,
}

#[repr(u8)]
pub enum Mask {
    Algo = 0x0f,
    Type = 0xf0,
}

pub enum Sw {
    NoSpace = 0x6a84,
    CommandAborted = 0x6f00,
    MoreData = 0x61,
    InvalidInstruction = 0x6d00,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OathDigits {
    Six = 6,
    Eight = 8,
}

#[derive(Debug, PartialEq)]
pub struct OathCode {
    pub digits: OathDigits,
    pub value: u32,
    pub expiration: u32, // FIXME
    pub steam: bool,
}
#[derive(Debug, PartialEq)]
pub struct OathCredential {
    pub name: String,
    pub code: Result<OathCode, String>,
    pub oath_type: OathType,
    pub touch: bool,
    pub algo: OathAlgo,
    pub hidden: bool,
    pub steam: bool,
}
pub struct OathController {
    pub context: *mut ffi::nfc_context,
    pub device: *mut ffi::nfc_device,
}

pub const INS_SELECT: u8 = 0xa4;
pub const OATH_AID: [u8; 8] = [0xa0, 0x00, 0x00, 0x05, 0x27, 0x21, 0x01, 0x01];

pub fn tlv(tag: Tag, value: &[u8]) -> Vec<u8> {
    let mut buf = vec![tag as u8];
    let len = value.len();
    if len < 0x80 {
        buf.push(len as u8);
    } else if len < 0xff {
        buf.push(0x81);
        buf.push(len as u8);
    } else {
        buf.push(0x82);
        buf.write_u16::<BigEndian>(len as u16).unwrap();
    }
    buf.write(value).unwrap();
    buf
}

pub fn parse_tlv(data: &[u8]) -> HashMap<u8, Vec<u8>> {
    let mut rdr = Cursor::new(data);
    let mut map = HashMap::new();
    loop {
        let tag = match rdr.read_u8() {
            Ok(tag) => tag,
            Err(_) => break,
        };
        let mut len: u16 = match rdr.read_u8() {
            Ok(len) => len as u16,
            Err(_) => break,
        };
        if len > 0x80 {
            let n_bytes = len - 0x80;
            if n_bytes == 1 {
                len = match rdr.read_u8() {
                    Ok(len) => len as u16,
                    Err(_) => break,
                };
            } else if n_bytes == 2 {
                len = match rdr.read_u16::<BigEndian>() {
                    Ok(len) => len,
                    Err(_) => break,
                };
            }
        }
        let mut dst = Vec::with_capacity(len as usize);
        unsafe {
            dst.set_len(len as usize);
        }
        match rdr.read_exact(dst.as_mut_slice()) {
            Ok(_) => (),
            Err(_) => break,
        };
        map.insert(tag, dst);
    }
    map
}

fn parse_list(resp: &[u8]) -> Result<Vec<OathCredential>, String> {
    let mut rdr = Cursor::new(resp);

    let mut result: Vec<OathCredential> = Vec::new();

    while let Ok(tag) = rdr.read_u8() {
        if tag != (Tag::NameList as u8) {
            break;
        }
        let length = rdr.read_u8().or(Err("Missing length after tag"))?;

        let type_code = rdr
            .read_u8()
            .or(Err("Malformed response, missing type code"))?;

        let mut buf = vec![0; (length - 1) as usize];
        rdr.read_exact(&mut buf)
            .or(Err("Malformed response, incorrect key name length"))?;
        result.push(OathCredential::new(
            &String::from_utf8(buf).or(Err("Invalid key name"))?,
            OathType::from_u8(type_code & (Mask::Type as u8)).ok_or("Invalid type")?,
            false,
            OathAlgo::from_u8(type_code & (Mask::Algo as u8)).ok_or("Invalid algorithm")?,
        ));
    }

    return Ok(result);
}

pub fn time_challenge(datetime: Option<SystemTime>) -> Vec<u8> {
    let ts = match datetime {
        Some(datetime) => {
            datetime
                .duration_since(SystemTime::UNIX_EPOCH)
                .unwrap()
                .as_secs()
                / 30
        }
        None => {
            SystemTime::now()
                .duration_since(SystemTime::UNIX_EPOCH)
                .unwrap()
                .as_secs()
                / 30
        }
    };
    let mut buf = vec![];
    buf.write_u64::<BigEndian>(ts).unwrap();
    buf
}

impl fmt::Display for OathCode {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        const STEAM_CHAR_TABLE_LEN: u32 = 26;
        const STEAM_CHAR_TABLE: [char; STEAM_CHAR_TABLE_LEN as usize] = [
            '2', '3', '4', '5', '6', '7', '8', '9', 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'M',
            'N', 'P', 'Q', 'R', 'T', 'V', 'W', 'X', 'Y',
        ];
        let mut code = self.value;
        if self.steam {
            let mut str = String::new();
            for _i in 0..5 {
                str.push(
                    *STEAM_CHAR_TABLE
                        .get((code % STEAM_CHAR_TABLE_LEN) as usize)
                        .unwrap(),
                );
                code /= STEAM_CHAR_TABLE_LEN;
            }
            try!(fmt.write_str(&str));
        } else {
            let code = self.value % (10 as u32).pow(self.digits as u32);
            match self.digits {
                OathDigits::Six => write!(fmt, "{:06}", code),
                OathDigits::Eight => write!(fmt, "{:08}", code),
            }
            .unwrap();
        }
        Ok(())
    }
}

impl OathCredential {
    pub fn new(name: &str, oath_type: OathType, touch: bool, algo: OathAlgo) -> OathCredential {
        OathCredential {
            name: name.to_string(),
            code: Err("No code calculated yet".to_string()),
            oath_type: oath_type,
            touch: touch,
            algo: algo,
            hidden: name.starts_with("_hidden:"),
            steam: name.starts_with("Steam:"),
        }
    }
}

impl OathController {
    pub fn new() -> Result<OathController, String> {
        let mut context = context::new();

        if context.is_null() {
            return Err("Unable to initialize new NFC context!".to_string());
        }

        nfc::init(&mut context);

        debug!("libnfc version: {}", ::misc::version());

        let device = nfc::open(context, ptr::null());
        if device.is_null() {
            return Err("Unable to initialize new NFC device!".to_string());
        }

        initiator::init(Box::new(device));

        debug!("NFC reader: {} opened", device::get_name(device));

        device::set_property_bool(device, ffi::Enum_Unnamed1::NP_AUTO_ISO14443_4, 1);

        Ok(OathController {
            context: context,
            device: device,
        })
    }

    pub fn close(&self) {
        nfc::close(self.device);
    }

    pub fn poll(&self, duration: Option<Duration>) -> bool {
        let start = Instant::now();

        debug!("Polling for target...");
        let modu = ffi::nfc_modulation {
            nmt: ffi::nfc_modulation_type::NMT_ISO14443A,
            nbr: ffi::nfc_baud_rate::NBR_106,
        };
        unsafe {
            let mut target: ffi::nfc_target = mem::uninitialized();
            while initiator::poll_target(self.device, &modu, 1, 1, 1, &mut target) <= 0 {
                if let Some(duration) = duration {
                    if Instant::now() > (start + duration) {
                        debug!("Poll timed out");
                        return false;
                    }
                }
            }
            while initiator::select_passive_target(
                self.device,
                modu,
                (*target.nti.nai()).abtUid.as_mut_ptr(),
                (*target.nti.nai()).szUidLen,
                &mut target,
            ) <= 0
            {}
        }
        debug!("Target detected!");
        return true;
    }

    /* https://en.wikipedia.org/wiki/Application_protocol_data_unit
    Command APDU
    Field name	Length (bytes)	Description
    CLA	1	Instruction class - indicates the type of command, e.g. interindustry or proprietary
    INS	1	Instruction code - indicates the specific command, e.g. "write data"
    P1-P2	2	Instruction parameters for the command, e.g. offset into file at which to write the data
    Lc	0, 1 or 3	Encodes the number (Nc) of bytes of command data to follow
        0 bytes denotes Nc=0
        1 byte with a value from 1 to 255 denotes Nc with the same value
        3 bytes, the first of which must be 0, denotes Nc in the range 1 to 65 535 (all three bytes may not be zero)
    Command data	Nc	Nc bytes of data
    Le	0, 1, 2 or 3	Encodes the maximum number (Ne) of response bytes expected
        0 bytes denotes Ne=0
        1 byte in the range 1 to 255 denotes that value of Ne, or 0 denotes Ne=256
        2 bytes (if Lc was present in the command) in the range 1 to 65 535 denotes Ne of that value, or two zero bytes denotes 65 536
        3 bytes (if Lc was not present in the command), the first of which must be 0, denote Ne in the same way as two-byte Le
    */
    pub fn send_apdu(
        &self,
        class: u8,
        instruction: u8,
        parameter1: u8,
        parameter2: u8,
        data: Option<&[u8]>,
    ) -> Result<Vec<u8>, String> {
        let mut tx_buf = vec![];
        let nc = match data {
            Some(ref data) => data.len(),
            None => 0,
        };
        // Header
        tx_buf.push(class);
        tx_buf.push(instruction);
        tx_buf.push(parameter1);
        tx_buf.push(parameter2);

        // Data
        if nc > 255 {
            tx_buf.push(0);
            tx_buf.write_u16::<BigEndian>(nc as u16).unwrap();
        } else if nc > 0 {
            tx_buf.push(nc as u8);
        }
        if let Some(data) = data {
            tx_buf.write(data).unwrap();
        }

        let mut s = String::new();
        for byte in &tx_buf {
            s += &format!("{:02X} ", byte);
        }
        debug!(">> {}", s);

        let mut rx_buf = Vec::with_capacity(256);
        let bytes_read = initiator::transceive_bytes(
            self.device,
            tx_buf.as_ptr(),
            tx_buf.len(),
            rx_buf.as_mut_ptr(),
            256,
            0,
        );
        if bytes_read < 0 {
            return Err("Error no bytes were returned".to_string());
        }

        unsafe {
            rx_buf.set_len(bytes_read as usize);
        }

        let mut s = String::new();
        for byte in &rx_buf {
            s += &format!("{:02X} ", byte);
        }
        debug!("<< {}", s);

        {
            let sw1 = match rx_buf.get((bytes_read - 2) as usize) {
                Some(sw1) => sw1,
                None => return Err("Error invalid bytes were returned".to_string()),
            };
            let sw2 = match rx_buf.get((bytes_read - 1) as usize) {
                Some(sw2) => sw2,
                None => return Err("Error invalid bytes were returned".to_string()),
            };
            if *sw1 != 0x90 || *sw2 != 0x00 {
                return Err(format!("Error {:x} {:x}", sw1, sw2));
            }
        }
        Ok(rx_buf)
    }

    pub fn list(&self) -> Result<Vec<OathCredential>, String> {
        // Switch to the OATH applet
        self.send_apdu(0, INS_SELECT, 0x04, 0, Some(&OATH_AID))?;

        let resp = self.send_apdu(0, Ins::List as u8, 0, 0, None)?;
        return parse_list(&resp);
    }

    pub fn calculate(&self, mut credential: OathCredential) -> OathCredential {
        // Switch to the OATH applet
        if let Err(err) = self.send_apdu(0, INS_SELECT, 0x04, 0, Some(&OATH_AID)) {
            credential.code = Err(err);
            return credential;
        }

        let mut data = tlv(Tag::Name, credential.name.as_bytes());
        let datetime = SystemTime::now();
        let challenge = time_challenge(Some(datetime));
        data.write(&tlv(Tag::Challenge, &challenge)).unwrap();
        let resp = match self.send_apdu(0, Ins::Calculate as u8, 0, 0x01, Some(&data)) {
            Ok(resp) => resp,
            Err(err) => {
                credential.code = Err(err);
                return credential;
            }
        };

        let resp = parse_tlv(&resp[0..resp.len() - 2]);
        let resp = match resp.get(&(Tag::TruncatedResponse as u8)) {
            Some(resp) => resp,
            None => {
                credential.code = Err("Response tlv was invalid".to_string());
                return credential;
            }
        };
        let mut rdr = Cursor::new(resp);

        let digits = match rdr.read_u8() {
            Ok(digits) => {
                let digits = match digits {
                    6 => OathDigits::Six,
                    8 => OathDigits::Eight,
                    _ => {
                        credential.code = Err("Digits can only be 6 or 8".to_owned());
                        return credential;
                    }
                };
                digits
            }
            Err(err) => {
                credential.code = Err(err.to_string());
                return credential;
            }
        };

        let val = match rdr.read_u32::<BigEndian>() {
            Ok(val) => val,
            Err(err) => {
                credential.code = Err(err.to_string());
                return credential;
            }
        };
        let expiration = ((datetime
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_secs()
            + 30)
            / 30)
            * 30;

        credential.code = Ok(OathCode {
            digits: digits,
            value: val,
            expiration: expiration as u32,
            steam: credential.steam,
        });
        credential
    }
}