use rand::rand_core::UnwrapErr;
use rand::{rngs::SysRng, Rng};
use crate::proto::bac::{self, BacError, E_LEN, K_LEN, MAC_LEN, NONCE_LEN};
use crate::proto::dba_key::DBAKey;
use crate::proto::des_smcipher::DesSmCipher;
use crate::proto::iso7816::command_apdu::CommandApdu;
use crate::proto::iso7816::iso7816::{cla, ins};
use crate::proto::iso7816::response_apdu::{ResponseApdu, StatusWord};
use crate::proto::mrtd_sm::MrtdSM;
pub enum BacAction {
SendApdu(Vec<u8>),
Done(MrtdSM<DesSmCipher>),
}
pub struct BacSession {
key: DBAKey,
rnd_ifd: [u8; NONCE_LEN],
kifd: [u8; K_LEN],
state: State,
}
enum State {
Start,
WaitingForChallenge,
ReadyForExternalAuth { rnd_icc: [u8; NONCE_LEN] },
WaitingForAuth { rnd_icc: [u8; NONCE_LEN] },
Completed(Option<MrtdSM<DesSmCipher>>),
Failed,
}
impl BacSession {
pub fn new(key: DBAKey) -> Self {
let mut rng = UnwrapErr(SysRng);
let mut rnd_ifd = [0u8; NONCE_LEN];
let mut kifd = [0u8; K_LEN];
rng.fill_bytes(&mut rnd_ifd);
rng.fill_bytes(&mut kifd);
Self::with_random_bytes(key, rnd_ifd, kifd)
}
pub fn with_random_bytes(key: DBAKey, rnd_ifd: [u8; NONCE_LEN], kifd: [u8; K_LEN]) -> Self {
Self {
key,
rnd_ifd,
kifd,
state: State::Start,
}
}
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> Result<BacAction, BacError> {
match &self.state {
State::Start => {
let cmd = CommandApdu::new(
cla::NO_SM,
ins::GET_CHALLENGE,
0x00,
0x00,
None,
NONCE_LEN as u32,
)
.map_err(|e| BacError(format!("GET CHALLENGE APDU: {e}")))?;
self.state = State::WaitingForChallenge;
Ok(BacAction::SendApdu(cmd.to_bytes()))
}
State::ReadyForExternalAuth { rnd_icc } => {
let s = bac::generate_s(&self.rnd_ifd, rnd_icc, &self.kifd)?;
let k_enc = self.key.enc_key();
let k_mac = self.key.mac_key();
let e_ifd = bac::encrypt_s(&k_enc, &s)?;
let m_ifd = bac::mac_e(&k_mac, &e_ifd)?;
let data = bac::generate_ea_data(&e_ifd, &m_ifd)?;
let cmd = CommandApdu::new(
cla::NO_SM,
ins::EXTERNAL_AUTHENTICATE,
0x00,
0x00,
Some(data),
(E_LEN + MAC_LEN) as u32,
)
.map_err(|e| BacError(format!("EXTERNAL AUTHENTICATE APDU: {e}")))?;
self.state = State::WaitingForAuth { rnd_icc: *rnd_icc };
Ok(BacAction::SendApdu(cmd.to_bytes()))
}
State::Completed(sm_slot) => {
sm_slot
.as_ref()
.is_some()
.then_some(())
.ok_or_else(|| BacError("BAC session already consumed".into()))?;
let taken = match &mut self.state {
State::Completed(slot) => slot.take(),
_ => unreachable!(),
};
Ok(BacAction::Done(taken.unwrap()))
}
State::WaitingForChallenge | State::WaitingForAuth { .. } => Err(BacError(
"BAC session is waiting for a response; call feed_response first".into(),
)),
State::Failed => Err(BacError(
"BAC session has failed and cannot continue".into(),
)),
}
}
fn handle_challenge(data: &[u8]) -> Result<[u8; NONCE_LEN], BacError> {
if data.len() != NONCE_LEN {
return Err(BacError(format!(
"Expected {NONCE_LEN}-byte challenge, got {}",
data.len()
)));
}
let mut rnd_icc = [0u8; NONCE_LEN];
rnd_icc.copy_from_slice(data);
Ok(rnd_icc)
}
fn handle_auth(
&self,
data: &[u8],
rnd_icc: &[u8; NONCE_LEN],
) -> Result<MrtdSM<DesSmCipher>, BacError> {
if data.len() != E_LEN + MAC_LEN {
return Err(BacError(format!(
"Expected {} bytes for external-auth response, got {}",
E_LEN + MAC_LEN,
data.len()
)));
}
let pair = bac::extract_eicc_and_micc(data)?;
let k_enc = self.key.enc_key();
let k_mac = self.key.mac_key();
if !bac::verify_eicc(&pair.first, &k_mac, &pair.second)? {
return Err(BacError("Verifying MAC of E.IC failed".into()));
}
let r = bac::decrypt_e_icc(&k_enc, &pair.first)?;
let kicc = bac::verify_rnd_ifd_and_extract_kicc(&self.rnd_ifd, &r)?;
let ks = bac::calculate_session_keys(&self.kifd, &kicc)?;
let ssc = bac::calculate_ssc(&self.rnd_ifd, rnd_icc)?;
let sm = bac::establish_sm(&ks.first, &ks.second, ssc)?;
Ok(sm)
}
pub fn feed_response(&mut self, response: &[u8]) -> Result<(), BacError> {
if !matches!(
self.state,
State::WaitingForChallenge | State::WaitingForAuth { .. }
) {
return Err(BacError(
"BAC session has no outstanding APDU to consume".into(),
));
}
let result = self.consume_response(response);
if result.is_err() {
self.state = State::Failed;
}
result
}
fn consume_response(&mut self, response: &[u8]) -> Result<(), BacError> {
let rapdu = ResponseApdu::from_bytes(response)
.map_err(|e| BacError(format!("Invalid response APDU: {e}")))?;
if rapdu.status != StatusWord::SUCCESS {
return Err(BacError(format!(
"BAC step failed with status {}",
rapdu.status
)));
}
let data = rapdu
.data
.ok_or_else(|| BacError("Empty response data".into()))?;
match std::mem::replace(&mut self.state, State::Start) {
State::WaitingForChallenge => {
let rnd_icc = Self::handle_challenge(&data)?;
self.state = State::ReadyForExternalAuth { rnd_icc };
Ok(())
}
State::WaitingForAuth { rnd_icc } => {
let sm = self.handle_auth(&data, &rnd_icc)?;
self.state = State::Completed(Some(sm));
Ok(())
}
_ => unreachable!("consume_response called outside a waiting state"),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::proto::bac::S_LEN;
use crate::proto::iso7816::response_apdu::{ResponseApdu, StatusWord};
use chrono::NaiveDate;
fn hex(s: &str) -> Vec<u8> {
::hex::decode(s).unwrap()
}
fn icao_d3_key() -> DBAKey {
DBAKey::new(
"L898902C",
NaiveDate::from_ymd_opt(1969, 8, 6).unwrap(),
NaiveDate::from_ymd_opt(1994, 6, 23).unwrap(),
false,
)
.unwrap()
}
fn build_response(data: &[u8]) -> Vec<u8> {
ResponseApdu::new(StatusWord::SUCCESS, Some(data.to_vec())).to_bytes()
}
#[test]
fn first_action_is_get_challenge() {
let mut s = BacSession::new(icao_d3_key());
let a = s.next().unwrap();
match a {
BacAction::SendApdu(bytes) => {
assert_eq!(bytes, vec![0x00, 0x84, 0x00, 0x00, 0x08]);
}
_ => panic!("expected SendApdu"),
}
}
#[test]
fn next_without_feed_after_challenge_errors() {
let mut s = BacSession::new(icao_d3_key());
let _ = s.next().unwrap(); assert!(s.next().is_err()); }
#[test]
fn feed_before_first_next_errors() {
let mut s = BacSession::new(icao_d3_key());
let resp = build_response(&[0u8; NONCE_LEN]);
assert!(s.feed_response(&resp).is_err());
}
#[test]
fn feed_rejects_non_9000_status() {
let mut s = BacSession::new(icao_d3_key());
let _ = s.next().unwrap();
let rapdu = ResponseApdu::new(StatusWord::new(0x6A, 0x82), Some(vec![0u8; 8]));
let err = s.feed_response(&rapdu.to_bytes()).unwrap_err();
assert!(err.0.contains("BAC step failed"));
}
#[test]
fn feed_rejects_wrong_challenge_length() {
let mut s = BacSession::new(icao_d3_key());
let _ = s.next().unwrap();
let resp = build_response(&[0u8; 7]); assert!(s.feed_response(&resp).is_err());
}
#[test]
fn malformed_challenge_poisons_session_not_resets_to_start() {
let mut s = BacSession::new(icao_d3_key());
let _ = s.next().unwrap(); let resp = build_response(&[0u8; 7]);
assert!(s.feed_response(&resp).is_err());
assert!(s.next().err().unwrap().0.contains("has failed"));
}
#[test]
fn empty_or_error_response_poisons_session() {
let mut s = BacSession::new(icao_d3_key());
let _ = s.next().unwrap(); let empty = ResponseApdu::new(StatusWord::SUCCESS, None).to_bytes();
assert!(s.feed_response(&empty).is_err());
assert!(s.next().err().unwrap().0.contains("has failed"));
let mut s2 = BacSession::new(icao_d3_key());
let _ = s2.next().unwrap();
let err_status = ResponseApdu::new(StatusWord::SM_DATA_INVALID, None).to_bytes();
assert!(s2.feed_response(&err_status).is_err());
assert!(s2.next().err().unwrap().0.contains("has failed"));
let mut s3 = BacSession::new(icao_d3_key());
assert!(s3
.feed_response(&build_response(&[0u8; NONCE_LEN]))
.is_err());
assert!(s3.next().is_ok()); }
#[test]
fn full_icao_d3_loopback_produces_expected_session_keys() {
let rnd_ifd = hex("781723860C06C226");
let kifd = hex("0B795240CB7049B01C19B33E32804F0B");
let rnd_icc = hex("4608F91988702212");
let kicc = hex("0B4F80323EB3191CB04970CB4052790B");
let exp_ssc = hex("887022120C06C226");
let exp_ks_enc = hex("979EC13B1CBFE9DCD01AB0FED307EAE5");
let exp_ks_mac = hex("F1CB1F1FB5ADF208806B89DC579DC1F8");
let mut session = BacSession::with_random_bytes(
icao_d3_key(),
rnd_ifd.clone().try_into().unwrap(),
kifd.clone().try_into().unwrap(),
);
match session.next().unwrap() {
BacAction::SendApdu(apdu) => {
assert_eq!(apdu, vec![0x00, 0x84, 0x00, 0x00, 0x08]);
}
_ => panic!("expected GET CHALLENGE"),
}
session.feed_response(&build_response(&rnd_icc)).unwrap();
let ea_apdu = match session.next().unwrap() {
BacAction::SendApdu(bytes) => bytes,
_ => panic!("expected EXTERNAL AUTHENTICATE"),
};
assert_eq!(&ea_apdu[..5], &[0x00, 0x82, 0x00, 0x00, 0x28]);
let key = icao_d3_key();
let k_enc = key.enc_key();
let k_mac = key.mac_key();
let mut r = Vec::with_capacity(S_LEN);
r.extend_from_slice(&rnd_icc);
r.extend_from_slice(&rnd_ifd);
r.extend_from_slice(&kicc);
let eicc = bac::encrypt_s(&k_enc, &r).unwrap();
let micc = bac::mac_e(&k_mac, &eicc).unwrap();
let mut ea_body = eicc;
ea_body.extend_from_slice(&micc);
session.feed_response(&build_response(&ea_body)).unwrap();
let sm = match session.next().unwrap() {
BacAction::Done(sm) => sm,
_ => panic!("expected Done"),
};
use crate::proto::iso7816::smcipher::SmCipher as _;
let probe = [0u8; 8];
let expected_cipher = DesSmCipher::new(&exp_ks_enc, exp_ks_mac.clone()).unwrap();
assert_eq!(
sm.cipher.encrypt(&probe, None).unwrap(),
expected_cipher.encrypt(&probe, None).unwrap(),
);
assert_eq!(sm.cipher.mac_key, exp_ks_mac);
assert_eq!(sm.ssc().to_bytes(), exp_ssc);
}
#[test]
fn mac_mismatch_on_eicc_is_rejected() {
let rnd_ifd = [0xAAu8; NONCE_LEN];
let kifd = [0xBBu8; K_LEN];
let rnd_icc = [0xCCu8; NONCE_LEN];
let mut session = BacSession::with_random_bytes(icao_d3_key(), rnd_ifd, kifd);
let _ = session.next().unwrap();
session.feed_response(&build_response(&rnd_icc)).unwrap();
let _ea_apdu = match session.next().unwrap() {
BacAction::SendApdu(bytes) => bytes,
_ => panic!("expected EXTERNAL AUTHENTICATE"),
};
let bogus = vec![0u8; E_LEN + MAC_LEN];
let err = session.feed_response(&build_response(&bogus)).unwrap_err();
assert!(err.0.contains("MAC"));
}
#[test]
fn done_cannot_be_taken_twice() {
let rnd_ifd = hex("781723860C06C226");
let kifd = hex("0B795240CB7049B01C19B33E32804F0B");
let rnd_icc = hex("4608F91988702212");
let kicc = hex("0B4F80323EB3191CB04970CB4052790B");
let mut s = BacSession::with_random_bytes(
icao_d3_key(),
rnd_ifd.clone().try_into().unwrap(),
kifd.clone().try_into().unwrap(),
);
let _ = s.next().unwrap();
s.feed_response(&build_response(&rnd_icc)).unwrap();
let _ = s.next().unwrap();
let key = icao_d3_key();
let mut r = Vec::new();
r.extend_from_slice(&rnd_icc);
r.extend_from_slice(&rnd_ifd);
r.extend_from_slice(&kicc);
let eicc = bac::encrypt_s(&key.enc_key(), &r).unwrap();
let micc = bac::mac_e(&key.mac_key(), &eicc).unwrap();
let mut body = eicc;
body.extend_from_slice(&micc);
s.feed_response(&build_response(&body)).unwrap();
let _sm = match s.next().unwrap() {
BacAction::Done(sm) => sm,
_ => panic!("expected Done"),
};
assert!(s.next().is_err());
}
}