use num_bigint::BigUint;
use thiserror::Error;
use crate::crypto::crypto_utils::constant_time_eq;
use crate::lds::asn1_object_identifiers::{
CipherAlgorithm, MappingType, OiePaceProtocol, TokenAgreementAlgo,
};
use crate::proto::access_key::AccessKey;
use crate::proto::aes_smcipher::AesSmCipher;
use crate::proto::dh_pace::{self, DHPace, DHPaceError};
use crate::proto::domain_parameter;
use crate::proto::ecdh_pace::{ECDHPace, ECDHPaceError};
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::iso7816::sm::SmError;
use crate::proto::mrtd_sm::MrtdSM;
use crate::proto::pace::{self, PaceError};
use crate::proto::public_key_pace::PublicKeyPace;
use crate::proto::ssc::AesSSC;
use crate::utils::big_uint_to_bytes;
pub enum PaceAction {
SendApdu(Vec<u8>),
Done(MrtdSM<AesSmCipher>),
}
#[derive(Debug, Error)]
pub enum PaceSessionError {
#[error("PACE session: token-agreement algorithm not supported here (got {0:?})")]
UnsupportedAgreement(TokenAgreementAlgo),
#[error("PACE session: only Generic Mapping (GM) is supported (got {0:?})")]
UnsupportedMapping(MappingType),
#[error("PACE session: only AES cipher is supported (got {0:?})")]
UnsupportedCipher(CipherAlgorithm),
#[error("PACE session: unsupported curve/parameter id (got id {0})")]
UnsupportedCurve(u32),
#[error("PACE session has no outstanding APDU to consume")]
NoOutstandingApdu,
#[error("PACE session is waiting for a response; feed_response first")]
PendingResponse,
#[error("PACE session already consumed")]
AlreadyTaken,
#[error("PACE step failed with status {0}")]
ChipStatus(StatusWord),
#[error("PACE step response was empty")]
EmptyResponse,
#[error("Invalid response APDU: {0}")]
InvalidResponse(String),
#[error("Shared secret has no x coordinate")]
MissingSharedSecretX,
#[error("ICC authentication token does not match the expected one")]
AuthTokenMismatch,
#[error(transparent)]
Pace(#[from] PaceError),
#[error(transparent)]
Ecdh(#[from] ECDHPaceError),
#[error(transparent)]
Dh(#[from] DHPaceError),
#[error(transparent)]
Sm(#[from] SmError),
}
#[allow(clippy::large_enum_variant)]
enum PaceEngine {
Ecdh(ECDHPace),
Dh(DHPace),
}
impl PaceEngine {
fn generate_main_key_pair(&mut self, seed: Option<&[u8]>) -> Result<(), PaceSessionError> {
match self {
PaceEngine::Ecdh(e) => e.generate_key_pair(seed)?,
PaceEngine::Dh(e) => e.generate_key_pair(seed.map(seed_to_u64))?,
}
Ok(())
}
fn main_pub_key(&self) -> Result<PublicKeyPace, PaceSessionError> {
match self {
PaceEngine::Ecdh(e) => Ok(e.get_pub_key()?),
PaceEngine::Dh(e) => Ok(e.get_pub_key()?),
}
}
fn ephemeral_pub_key(&self) -> Result<PublicKeyPace, PaceSessionError> {
match self {
PaceEngine::Ecdh(e) => Ok(e.get_pub_key_ephemeral()?),
PaceEngine::Dh(e) => Ok(e.get_pub_key_ephemeral()?),
}
}
fn map_and_generate_ephemeral(
&mut self,
icc_mapping_pub: &PublicKeyPace,
nonce: &[u8],
seed: Option<&[u8]>,
) -> Result<(), PaceSessionError> {
match self {
PaceEngine::Ecdh(e) => {
e.map_and_generate_ephemeral(icc_mapping_pub, nonce, seed)?;
}
PaceEngine::Dh(e) => {
let g_prime =
e.get_mapped_generator(&icc_mapping_pub.to_relevant_bytes(), nonce)?;
e.generate_ephemeral_with_custom_generator(
BigUint::from_bytes_be(&g_prime),
seed.map(seed_to_u64),
)?;
}
}
Ok(())
}
fn ephemeral_shared_seed(
&self,
icc_ephemeral_pub: &PublicKeyPace,
) -> Result<Vec<u8>, PaceSessionError> {
match self {
PaceEngine::Ecdh(e) => {
let seed_bytes = e.get_ephemeral_shared_seed(icc_ephemeral_pub)?;
Ok(seed_bytes)
}
PaceEngine::Dh(e) => {
let shared =
e.get_ephemeral_shared_secret(&icc_ephemeral_pub.to_relevant_bytes())?;
Ok(big_uint_to_bytes(&shared))
}
}
}
fn pubkey_response_le(&self) -> u32 {
match self {
PaceEngine::Ecdh(_) => 256,
PaceEngine::Dh(e) => {
if e.modulus_byte_len() + 8 <= 256 {
256
} else {
65_536
}
}
}
}
}
fn seed_to_u64(seed: &[u8]) -> u64 {
let mut b = [0u8; 8];
let n = seed.len().min(8);
b[..n].copy_from_slice(&seed[..n]);
u64::from_be_bytes(b)
}
pub struct PaceSession<K: AccessKey> {
key: K,
protocol: OiePaceProtocol,
engine: PaceEngine,
seed_main: Option<[u8; 32]>,
seed_ephemeral: Option<[u8; 32]>,
state: State,
}
enum State {
Start,
WaitingForMseSetAt,
ReadyForStep1,
WaitingForStep1,
ReadyForStep2 {
nonce: Vec<u8>,
},
WaitingForStep2 {
nonce: Vec<u8>,
},
ReadyForStep3,
WaitingForStep3,
ReadyForStep4 {
icc_ephemeral_pub: PublicKeyPace,
k_enc: Vec<u8>,
k_mac: Vec<u8>,
},
WaitingForStep4 {
k_enc: Vec<u8>,
k_mac: Vec<u8>,
},
Completed(Option<MrtdSM<AesSmCipher>>),
}
impl<K: AccessKey> PaceSession<K> {
pub fn new(
key: K,
protocol: OiePaceProtocol,
parameter_id: u32,
) -> Result<Self, PaceSessionError> {
match protocol.token_agreement_algorithm {
TokenAgreementAlgo::Ecdh => Self::new_ecdh(key, protocol, parameter_id),
TokenAgreementAlgo::Dh => Self::new_dh(key, protocol, parameter_id),
}
}
pub fn new_ecdh(
key: K,
protocol: OiePaceProtocol,
parameter_id: u32,
) -> Result<Self, PaceSessionError> {
if protocol.token_agreement_algorithm != TokenAgreementAlgo::Ecdh {
return Err(PaceSessionError::UnsupportedAgreement(
protocol.token_agreement_algorithm,
));
}
if protocol.cipher_algorithm != CipherAlgorithm::Aes {
return Err(PaceSessionError::UnsupportedCipher(
protocol.cipher_algorithm,
));
}
if protocol.mapping_type != MappingType::Gm {
return Err(PaceSessionError::UnsupportedMapping(protocol.mapping_type));
}
let supported = domain_parameter::get(parameter_id)
.map(|entry| {
entry.is_supported && entry.kind == domain_parameter::DomainParameterType::Ecp
})
.unwrap_or(false);
if !supported {
return Err(PaceSessionError::UnsupportedCurve(parameter_id));
}
Ok(Self {
key,
protocol,
engine: PaceEngine::Ecdh(ECDHPace::new(parameter_id)?),
seed_main: None,
seed_ephemeral: None,
state: State::Start,
})
}
pub fn new_dh(
key: K,
protocol: OiePaceProtocol,
parameter_id: u32,
) -> Result<Self, PaceSessionError> {
if protocol.token_agreement_algorithm != TokenAgreementAlgo::Dh {
return Err(PaceSessionError::UnsupportedAgreement(
protocol.token_agreement_algorithm,
));
}
if protocol.cipher_algorithm != CipherAlgorithm::Aes {
return Err(PaceSessionError::UnsupportedCipher(
protocol.cipher_algorithm,
));
}
if protocol.mapping_type != MappingType::Gm {
return Err(PaceSessionError::UnsupportedMapping(protocol.mapping_type));
}
let engine = dh_pace::get_domain_parameter(parameter_id)?;
Ok(Self {
key,
protocol,
engine: PaceEngine::Dh(engine),
seed_main: None,
seed_ephemeral: None,
state: State::Start,
})
}
pub fn new_ecdh_deterministic(
key: K,
protocol: OiePaceProtocol,
parameter_id: u32,
seed_main: [u8; 32],
seed_ephemeral: [u8; 32],
) -> Result<Self, PaceSessionError> {
let mut s = Self::new_ecdh(key, protocol, parameter_id)?;
s.seed_main = Some(seed_main);
s.seed_ephemeral = Some(seed_ephemeral);
Ok(s)
}
pub fn new_dh_deterministic(
key: K,
protocol: OiePaceProtocol,
parameter_id: u32,
seed_main: [u8; 32],
seed_ephemeral: [u8; 32],
) -> Result<Self, PaceSessionError> {
let mut s = Self::new_dh(key, protocol, parameter_id)?;
s.seed_main = Some(seed_main);
s.seed_ephemeral = Some(seed_ephemeral);
Ok(s)
}
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> Result<PaceAction, PaceSessionError> {
match std::mem::replace(&mut self.state, State::Start) {
State::Start => {
let data =
pace::generate_mse_set_at_data(&self.protocol, self.key.pace_ref_key_tag());
let cmd = CommandApdu::new(
cla::NO_SM,
ins::MANAGE_SECURITY_ENVIRONMENT,
0xC1,
0xA4,
Some(data),
0,
)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
self.state = State::WaitingForMseSetAt;
Ok(PaceAction::SendApdu(cmd.to_bytes()))
}
State::ReadyForStep1 => {
let data = pace::generate_general_authenticate_data_step1();
let cmd = CommandApdu::new(
cla::COMMAND_CHAINING,
ins::GENERAL_AUTHENTICATE,
0x00,
0x00,
Some(data),
256,
)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
self.state = State::WaitingForStep1;
Ok(PaceAction::SendApdu(cmd.to_bytes()))
}
State::ReadyForStep2 { nonce } => {
self.engine
.generate_main_key_pair(self.seed_main.as_ref().map(|s| &s[..]))?;
let terminal_pub = self.engine.main_pub_key()?;
let data =
pace::generate_general_authenticate_data_step2_or_3(&terminal_pub, false);
let cmd = CommandApdu::new(
cla::COMMAND_CHAINING,
ins::GENERAL_AUTHENTICATE,
0x00,
0x00,
Some(data),
self.engine.pubkey_response_le(),
)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
self.state = State::WaitingForStep2 { nonce };
Ok(PaceAction::SendApdu(cmd.to_bytes()))
}
State::ReadyForStep3 => {
let terminal_ephemeral_pub = self.engine.ephemeral_pub_key()?;
let data = pace::generate_general_authenticate_data_step2_or_3(
&terminal_ephemeral_pub,
true,
);
let cmd = CommandApdu::new(
cla::COMMAND_CHAINING,
ins::GENERAL_AUTHENTICATE,
0x00,
0x00,
Some(data),
self.engine.pubkey_response_le(),
)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
self.state = State::WaitingForStep3;
Ok(PaceAction::SendApdu(cmd.to_bytes()))
}
State::ReadyForStep4 {
icc_ephemeral_pub,
k_enc,
k_mac,
} => {
let input = pace::generate_encoding_input_data(&self.protocol, &icc_ephemeral_pub);
let t_ifd = pace::calculate_auth_token(&self.protocol, &input, &k_mac)?;
let data = pace::generate_general_authenticate_data_step4(&t_ifd);
let cmd = CommandApdu::new(
cla::NO_SM,
ins::GENERAL_AUTHENTICATE,
0x00,
0x00,
Some(data),
256,
)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
self.state = State::WaitingForStep4 { k_enc, k_mac };
Ok(PaceAction::SendApdu(cmd.to_bytes()))
}
State::Completed(slot) => match slot {
Some(sm) => {
self.state = State::Completed(None);
Ok(PaceAction::Done(sm))
}
None => {
self.state = State::Completed(None);
Err(PaceSessionError::AlreadyTaken)
}
},
other @ (State::WaitingForMseSetAt
| State::WaitingForStep1
| State::WaitingForStep2 { .. }
| State::WaitingForStep3
| State::WaitingForStep4 { .. }) => {
self.state = other;
Err(PaceSessionError::PendingResponse)
}
}
}
pub fn feed_response(&mut self, response: &[u8]) -> Result<(), PaceSessionError> {
let rapdu = ResponseApdu::from_bytes(response)
.map_err(|e| PaceSessionError::InvalidResponse(e.to_string()))?;
if rapdu.status != StatusWord::SUCCESS {
return Err(PaceSessionError::ChipStatus(rapdu.status));
}
match std::mem::replace(&mut self.state, State::Start) {
State::WaitingForMseSetAt => {
self.state = State::ReadyForStep1;
Ok(())
}
State::WaitingForStep1 => {
let data = rapdu.data.ok_or(PaceSessionError::EmptyResponse)?;
let encrypted_nonce = pace::parse_step1_response(&data)
.map_err(|e| PaceSessionError::InvalidResponse(e.0))?;
let nonce = pace::decrypt_nonce(&self.protocol, &encrypted_nonce, &self.key)?;
self.state = State::ReadyForStep2 { nonce };
Ok(())
}
State::WaitingForStep2 { nonce } => {
let data = rapdu.data.ok_or(PaceSessionError::EmptyResponse)?;
let icc_mapping_pub =
pace::parse_step2_or_3_response(&data, self.protocol.token_agreement_algorithm)
.map_err(|e| PaceSessionError::InvalidResponse(e.0))?;
self.engine.map_and_generate_ephemeral(
&icc_mapping_pub,
&nonce,
self.seed_ephemeral.as_ref().map(|s| &s[..]),
)?;
self.state = State::ReadyForStep3;
Ok(())
}
State::WaitingForStep3 => {
let data = rapdu.data.ok_or(PaceSessionError::EmptyResponse)?;
let icc_ephemeral_pub =
pace::parse_step2_or_3_response(&data, self.protocol.token_agreement_algorithm)
.map_err(|e| PaceSessionError::InvalidResponse(e.0))?;
let seed = self.engine.ephemeral_shared_seed(&icc_ephemeral_pub)?;
let k_enc = pace::calculate_enc_key(&self.protocol, &seed)?;
let k_mac = pace::calculate_mac_key(&self.protocol, &seed)?;
self.state = State::ReadyForStep4 {
icc_ephemeral_pub,
k_enc,
k_mac,
};
Ok(())
}
State::WaitingForStep4 { k_enc, k_mac } => {
let data = rapdu.data.ok_or(PaceSessionError::EmptyResponse)?;
let icc_token = pace::parse_step4_response(&data)
.map_err(|e| PaceSessionError::InvalidResponse(e.0))?;
let terminal_ephemeral_pub = self.engine.ephemeral_pub_key()?;
let expected_input =
pace::generate_encoding_input_data(&self.protocol, &terminal_ephemeral_pub);
let expected_token =
pace::calculate_auth_token(&self.protocol, &expected_input, &k_mac)?;
if !constant_time_eq(&expected_token, &icc_token) {
return Err(PaceSessionError::AuthTokenMismatch);
}
let cipher = AesSmCipher::new(k_enc, k_mac, self.protocol.key_length)?;
let sm = MrtdSM::new(cipher, AesSSC::default().0);
self.state = State::Completed(Some(sm));
Ok(())
}
other @ (State::Start
| State::ReadyForStep1
| State::ReadyForStep2 { .. }
| State::ReadyForStep3
| State::ReadyForStep4 { .. }
| State::Completed(_)) => {
self.state = other;
Err(PaceSessionError::NoOutstandingApdu)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::crypto::aes::{AesCipher, BlockCipherMode, AES_BLOCK_SIZE};
use crate::lds::tlv::Tlv;
use crate::proto::can_key::CanKey;
use crate::proto::ecdh_pace::NIST_P256_ID;
fn ecdh_gm_aes128_oid() -> OiePaceProtocol {
OiePaceProtocol::new(
"0.4.0.127.0.7.2.2.4.2.2",
"id-PACE-ECDH-GM-AES-CBC-CMAC-128",
vec![0, 4, 0, 127, 0, 7, 2, 2, 4, 2, 2],
)
.unwrap()
}
fn dh_gm_aes128_oid() -> OiePaceProtocol {
OiePaceProtocol::new(
"0.4.0.127.0.7.2.2.4.1.2",
"id-PACE-DH-GM-AES-CBC-CMAC-128",
vec![0, 4, 0, 127, 0, 7, 2, 2, 4, 1, 2],
)
.unwrap()
}
fn seed_u64(seed: &[u8]) -> u64 {
let mut b = [0u8; 8];
let n = seed.len().min(8);
b[..n].copy_from_slice(&seed[..n]);
u64::from_be_bytes(b)
}
fn build_response(data: Option<&[u8]>) -> Vec<u8> {
let r = ResponseApdu::new(
StatusWord::SUCCESS,
data.map(|d| d.to_vec()).filter(|d| !d.is_empty()),
);
r.to_bytes()
}
fn dyn_auth_wrap(tag: u32, body: &[u8]) -> Vec<u8> {
let inner = Tlv::encode(tag, body);
Tlv::encode(0x7C, &inner)
}
#[test]
fn rejects_dh_protocol() {
let dh_protocol = OiePaceProtocol::new(
"0.4.0.127.0.7.2.2.4.1.2",
"id-PACE-DH-GM-AES-CBC-CMAC-128",
vec![0, 4, 0, 127, 0, 7, 2, 2, 4, 1, 2],
)
.unwrap();
let can = CanKey::new("123456").unwrap();
match PaceSession::new_ecdh(can, dh_protocol, 2) {
Err(PaceSessionError::UnsupportedAgreement(_)) => {}
_ => panic!("expected UnsupportedAgreement"),
}
}
#[test]
fn rejects_im_mapping_ecdh() {
let im_protocol = OiePaceProtocol::new(
"0.4.0.127.0.7.2.2.4.4.2",
"id-PACE-ECDH-IM-AES-CBC-CMAC-128",
vec![0, 4, 0, 127, 0, 7, 2, 2, 4, 4, 2],
)
.unwrap();
let can = CanKey::new("123456").unwrap();
match PaceSession::new_ecdh(can, im_protocol, NIST_P256_ID) {
Err(PaceSessionError::UnsupportedMapping(MappingType::Im)) => {}
Err(e) => panic!("expected UnsupportedMapping(Im), got {e:?}"),
Ok(_) => panic!("expected UnsupportedMapping(Im), got Ok"),
}
}
#[test]
fn rejects_im_mapping_dh() {
let im_protocol = OiePaceProtocol::new(
"0.4.0.127.0.7.2.2.4.3.2",
"id-PACE-DH-IM-AES-CBC-CMAC-128",
vec![0, 4, 0, 127, 0, 7, 2, 2, 4, 3, 2],
)
.unwrap();
let can = CanKey::new("123456").unwrap();
match PaceSession::new_dh(can, im_protocol, 0) {
Err(PaceSessionError::UnsupportedMapping(MappingType::Im)) => {}
Err(e) => panic!("expected UnsupportedMapping(Im), got {e:?}"),
Ok(_) => panic!("expected UnsupportedMapping(Im), got Ok"),
}
}
#[test]
fn rejects_unsupported_curve() {
let can = CanKey::new("123456").unwrap();
match PaceSession::new_ecdh(can, ecdh_gm_aes128_oid(), 8) {
Err(PaceSessionError::UnsupportedCurve(8)) => {}
_ => panic!("expected UnsupportedCurve(8)"),
}
}
#[test]
fn first_action_is_mse_set_at() {
let can = CanKey::new("123456").unwrap();
let mut s = PaceSession::new_ecdh(can, ecdh_gm_aes128_oid(), NIST_P256_ID).unwrap();
match s.next().unwrap() {
PaceAction::SendApdu(apdu) => {
assert_eq!(&apdu[..4], &[0x00, 0x22, 0xC1, 0xA4]);
}
_ => panic!("expected SendApdu"),
}
}
#[test]
fn next_without_feed_errors() {
let can = CanKey::new("123456").unwrap();
let mut s = PaceSession::new_ecdh(can, ecdh_gm_aes128_oid(), NIST_P256_ID).unwrap();
let _ = s.next().unwrap();
assert!(s.next().is_err());
}
#[test]
fn feed_before_next_errors() {
let can = CanKey::new("123456").unwrap();
let mut s = PaceSession::new_ecdh(can, ecdh_gm_aes128_oid(), NIST_P256_ID).unwrap();
assert!(s.feed_response(&build_response(None)).is_err());
}
#[test]
fn full_pace_loopback_produces_sm() {
let protocol = ecdh_gm_aes128_oid();
let can = CanKey::new("123456").unwrap();
let seed_terminal_main = [0x11u8; 32];
let seed_terminal_eph = [0x22u8; 32];
let seed_icc_main = [0x33u8; 32];
let seed_icc_eph = [0x44u8; 32];
let mut session = PaceSession::new_ecdh_deterministic(
can,
protocol.clone(),
NIST_P256_ID,
seed_terminal_main,
seed_terminal_eph,
)
.unwrap();
let can_chip = CanKey::new("123456").unwrap();
let mut icc = ECDHPace::new(NIST_P256_ID).unwrap();
match session.next().unwrap() {
PaceAction::SendApdu(_) => {}
_ => panic!("expected MSE:Set AT"),
}
session.feed_response(&build_response(None)).unwrap();
match session.next().unwrap() {
PaceAction::SendApdu(_) => {}
_ => panic!("expected step 1"),
}
let nonce = [0x5Au8; 16];
let cipher = AesCipher::new(protocol.key_length);
let kpi = can_chip
.kpi(protocol.cipher_algorithm, protocol.key_length)
.unwrap();
let zero_iv = [0u8; AES_BLOCK_SIZE];
let enc_nonce = cipher
.encrypt(&nonce, &kpi, Some(&zero_iv), BlockCipherMode::Cbc, false)
.unwrap();
let step1_body = dyn_auth_wrap(0x80, &enc_nonce);
session
.feed_response(&build_response(Some(&step1_body)))
.unwrap();
let _step2_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 2"),
};
icc.generate_key_pair(Some(&seed_icc_main)).unwrap();
let icc_mapping_pub = icc.get_pub_key().unwrap();
let mut step2_body = vec![0x04];
step2_body.extend_from_slice(&icc_mapping_pub.to_bytes());
let step2_response = dyn_auth_wrap(0x82, &step2_body);
session
.feed_response(&build_response(Some(&step2_response)))
.unwrap();
let _step3_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 3"),
};
let terminal_mapping_pk =
icc_mapping_pub_from_session(&session).expect("terminal's main pubkey after step 2");
icc.map_and_generate_ephemeral(&terminal_mapping_pk, &nonce, Some(&seed_icc_eph))
.unwrap();
let icc_eph_pub = icc.get_pub_key_ephemeral().unwrap();
let mut step3_body = vec![0x04];
step3_body.extend_from_slice(&icc_eph_pub.to_bytes());
let step3_response = dyn_auth_wrap(0x84, &step3_body);
session
.feed_response(&build_response(Some(&step3_response)))
.unwrap();
let _step4_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 4"),
};
let terminal_eph_pub = terminal_ephemeral_pub_from_session(&session)
.expect("terminal ephemeral public after step 3");
let seed_bytes = icc.get_ephemeral_shared_seed(&terminal_eph_pub).unwrap();
let icc_k_mac = pace::calculate_mac_key(&protocol, &seed_bytes).unwrap();
let icc_auth_input = pace::generate_encoding_input_data(&protocol, &terminal_eph_pub);
let icc_token = pace::calculate_auth_token(&protocol, &icc_auth_input, &icc_k_mac).unwrap();
let step4_response = dyn_auth_wrap(0x86, &icc_token);
session
.feed_response(&build_response(Some(&step4_response)))
.unwrap();
match session.next().unwrap() {
PaceAction::Done(sm) => {
assert_eq!(sm.cipher.ks_enc().len(), 16);
assert_eq!(sm.cipher.ks_mac().len(), 16);
assert_eq!(sm.ssc().to_bytes().len(), 16); }
_ => panic!("expected Done"),
}
assert!(matches!(
session.next(),
Err(PaceSessionError::AlreadyTaken)
));
assert!(matches!(
session.next(),
Err(PaceSessionError::AlreadyTaken)
));
}
#[test]
fn full_pace_dh_loopback_produces_sm() {
let protocol = dh_gm_aes128_oid();
let can = CanKey::new("123456").unwrap();
let seed_terminal_main = [0x11u8; 32];
let seed_terminal_eph = [0x22u8; 32];
let seed_icc_main = [0x33u8; 32];
let seed_icc_eph = [0x44u8; 32];
let mut session = PaceSession::new_dh_deterministic(
can,
protocol.clone(),
0,
seed_terminal_main,
seed_terminal_eph,
)
.unwrap();
let can_chip = CanKey::new("123456").unwrap();
let mut icc = dh_pace::get_domain_parameter(0).unwrap();
match session.next().unwrap() {
PaceAction::SendApdu(_) => {}
_ => panic!("expected MSE:Set AT"),
}
session.feed_response(&build_response(None)).unwrap();
match session.next().unwrap() {
PaceAction::SendApdu(_) => {}
_ => panic!("expected step 1"),
}
let nonce = [0x5Au8; 16];
let cipher = AesCipher::new(protocol.key_length);
let kpi = can_chip
.kpi(protocol.cipher_algorithm, protocol.key_length)
.unwrap();
let zero_iv = [0u8; AES_BLOCK_SIZE];
let enc_nonce = cipher
.encrypt(&nonce, &kpi, Some(&zero_iv), BlockCipherMode::Cbc, false)
.unwrap();
let step1_body = dyn_auth_wrap(0x80, &enc_nonce);
session
.feed_response(&build_response(Some(&step1_body)))
.unwrap();
let _step2_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 2"),
};
icc.generate_key_pair(Some(seed_u64(&seed_icc_main)))
.unwrap();
let icc_mapping_pub = icc.get_pub_key().unwrap();
let step2_response = dyn_auth_wrap(0x82, &icc_mapping_pub.to_bytes());
session
.feed_response(&build_response(Some(&step2_response)))
.unwrap();
let _step3_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 3"),
};
let terminal_mapping_pub =
icc_mapping_pub_from_session(&session).expect("terminal's main pubkey after step 2");
let g = icc
.get_mapped_generator(&terminal_mapping_pub.to_relevant_bytes(), &nonce)
.unwrap();
icc.generate_ephemeral_with_custom_generator(
BigUint::from_bytes_be(&g),
Some(seed_u64(&seed_icc_eph)),
)
.unwrap();
let icc_eph_pub = icc.get_pub_key_ephemeral().unwrap();
let step3_response = dyn_auth_wrap(0x84, &icc_eph_pub.to_bytes());
session
.feed_response(&build_response(Some(&step3_response)))
.unwrap();
let _step4_apdu = match session.next().unwrap() {
PaceAction::SendApdu(bytes) => bytes,
_ => panic!("expected step 4"),
};
let terminal_eph_pub = terminal_ephemeral_pub_from_session(&session)
.expect("terminal ephemeral public after step 3");
let seed_bytes = big_uint_to_bytes(
&icc.get_ephemeral_shared_secret(&terminal_eph_pub.to_relevant_bytes())
.unwrap(),
);
let icc_k_mac = pace::calculate_mac_key(&protocol, &seed_bytes).unwrap();
let icc_auth_input = pace::generate_encoding_input_data(&protocol, &terminal_eph_pub);
let icc_token = pace::calculate_auth_token(&protocol, &icc_auth_input, &icc_k_mac).unwrap();
let step4_response = dyn_auth_wrap(0x86, &icc_token);
session
.feed_response(&build_response(Some(&step4_response)))
.unwrap();
match session.next().unwrap() {
PaceAction::Done(sm) => {
assert_eq!(sm.cipher.ks_enc().len(), 16);
assert_eq!(sm.cipher.ks_mac().len(), 16);
assert_eq!(sm.ssc().to_bytes().len(), 16); }
_ => panic!("expected Done"),
}
}
fn icc_mapping_pub_from_session<K: AccessKey>(
session: &PaceSession<K>,
) -> Option<PublicKeyPace> {
session.engine.main_pub_key().ok()
}
fn terminal_ephemeral_pub_from_session<K: AccessKey>(
session: &PaceSession<K>,
) -> Option<PublicKeyPace> {
session.engine.ephemeral_pub_key().ok()
}
}