james/yubikey.rs
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Return Result<(), ErrorKind> from most APIs

Browse Source 
This commit modifies all public APIs where doing so wouldn't require
modifying internal functions.
This commit is contained in:
Jack Grigg
2019-11-19 20:22:20 +00:00
parent 65ec5aad63
commit 943dd6f146
2 changed files with 302 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/util.rs
+171 -90
View File
@@ -80,17 +80,20 @@ pub static mut CCC_TMPL: &[u8] = &[
pub struct CardId([u8; 16]);
/// Get Card ID
pub unsafe fn ykpiv_util_get_cardid(state: *mut YubiKey, cardid: *mut CardId) -> ErrorKind {
pub unsafe fn ykpiv_util_get_cardid(
state: *mut YubiKey,
cardid: *mut CardId,
) -> Result<(), ErrorKind> {
let mut buf = [0u8; CB_OBJ_MAX];
let mut len = buf.len();
let mut res: ErrorKind = ErrorKind::Ok;
if cardid.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -110,22 +113,28 @@ pub unsafe fn ykpiv_util_get_cardid(state: *mut YubiKey, cardid: *mut CardId) ->
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Set Card ID
pub unsafe fn ykpiv_util_set_cardid(state: *mut YubiKey, cardid: *const CardId) -> ErrorKind {
pub unsafe fn ykpiv_util_set_cardid(
state: *mut YubiKey,
cardid: *const CardId,
) -> Result<(), ErrorKind> {
let mut id = [0u8; YKPIV_CARDID_SIZE];
let mut buf = [0u8; CHUID_TMPL.len()];
let mut res = ErrorKind::Ok;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if cardid.is_null() {
if _ykpiv_prng_generate(id.as_mut_ptr(), id.len()) != PRngErrorKind::Ok {
return ErrorKind::RandomnessError;
return Err(ErrorKind::RandomnessError);
}
} else {
memcpy(
@@ -136,7 +145,7 @@ pub unsafe fn ykpiv_util_set_cardid(state: *mut YubiKey, cardid: *const CardId)
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -161,7 +170,10 @@ pub unsafe fn ykpiv_util_set_cardid(state: *mut YubiKey, cardid: *const CardId)
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Cardholder Capability Container (CCC) Identifier
@@ -169,17 +181,17 @@ pub unsafe fn ykpiv_util_set_cardid(state: *mut YubiKey, cardid: *const CardId)
pub struct CCCID([u8; 14]);
/// Get Cardholder Capability Container (CCC) ID
pub unsafe fn ykpiv_util_get_cccid(state: *mut YubiKey, ccc: *mut CCCID) -> ErrorKind {
pub unsafe fn ykpiv_util_get_cccid(state: *mut YubiKey, ccc: *mut CCCID) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut buf = [0u8; CB_OBJ_MAX];
let mut len = buf.len();
if ccc.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -193,7 +205,7 @@ pub unsafe fn ykpiv_util_get_cccid(state: *mut YubiKey, ccc: *mut CCCID) -> Erro
if res == ErrorKind::Ok {
if len != CCC_TMPL.len() {
_ykpiv_end_transaction(state);
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
memcpy(
@@ -204,23 +216,29 @@ pub unsafe fn ykpiv_util_get_cccid(state: *mut YubiKey, ccc: *mut CCCID) -> Erro
}
}
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get Cardholder Capability Container (CCC) ID
pub unsafe fn ykpiv_util_set_cccid(state: *mut YubiKey, ccc: *const CCCID) -> ErrorKind {
pub unsafe fn ykpiv_util_set_cccid(
state: *mut YubiKey,
ccc: *const CCCID,
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut id = [0u8; 14];
let mut buf = [0u8; 51];
let len: usize;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if ccc.is_null() {
if _ykpiv_prng_generate(id.as_mut_ptr(), id.len()) != PRngErrorKind::Ok {
return ErrorKind::RandomnessError;
return Err(ErrorKind::RandomnessError);
}
} else {
memcpy(
@@ -231,7 +249,7 @@ pub unsafe fn ykpiv_util_set_cccid(state: *mut YubiKey, ccc: *const CCCID) -> Er
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -253,7 +271,10 @@ pub unsafe fn ykpiv_util_set_cccid(state: *mut YubiKey, ccc: *const CCCID) -> Er
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get YubiKey device model
@@ -316,7 +337,7 @@ pub unsafe fn ykpiv_util_list_keys(
key_count: *mut u8,
data: *mut *mut YkPivKey,
data_len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut _currentBlock;
let mut res: ErrorKind = ErrorKind::Ok;
let mut p_key: *mut YkPivKey;
@@ -331,11 +352,11 @@ pub unsafe fn ykpiv_util_list_keys(
let CB_PAGE: usize = 4096;
if data.is_null() || data_len.is_null() || key_count.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -347,7 +368,7 @@ pub unsafe fn ykpiv_util_list_keys(
if p_data.is_null() {
_ykpiv_end_transaction(state);
return ErrorKind::MemoryError;
return Err(ErrorKind::MemoryError);
}
cb_data = CB_PAGE;
@@ -439,7 +460,10 @@ pub unsafe fn ykpiv_util_list_keys(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Read certificate
@@ -448,17 +472,17 @@ pub unsafe fn ykpiv_util_read_cert(
slot: u8,
data: *mut *mut u8,
data_len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut buf = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_buf: usize = buf.len();
if data.is_null() || data_len.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -488,7 +512,10 @@ pub unsafe fn ykpiv_util_read_cert(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Write certificate
@@ -498,11 +525,11 @@ pub unsafe fn ykpiv_util_write_cert(
data: *mut u8,
data_len: usize,
certinfo: u8,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -510,16 +537,19 @@ pub unsafe fn ykpiv_util_write_cert(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Delete certificate
pub unsafe fn ykpiv_util_delete_cert(state: *mut YubiKey, slot: u8) -> ErrorKind {
pub unsafe fn ykpiv_util_delete_cert(state: *mut YubiKey, slot: u8) -> Result<(), ErrorKind> {
ykpiv_util_write_cert(state, slot, ptr::null_mut(), 0, 0)
}
/// Block PUK
pub unsafe fn ykpiv_util_block_puk(state: *mut YubiKey) -> ErrorKind {
pub unsafe fn ykpiv_util_block_puk(state: *mut YubiKey) -> Result<(), ErrorKind> {
let mut _currentBlock;
let mut res: ErrorKind = ErrorKind::Ok;
let mut puk = [0x30, 0x42, 0x41, 0x44, 0x46, 0x30, 0x30, 0x44];
@@ -531,11 +561,11 @@ pub unsafe fn ykpiv_util_block_puk(state: *mut YubiKey) -> ErrorKind {
let mut flags: u8 = 0;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -629,7 +659,10 @@ pub unsafe fn ykpiv_util_block_puk(state: *mut YubiKey) -> ErrorKind {
}
} else {
_ykpiv_end_transaction(state);
return res;
return match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
};
}
}
}
@@ -669,7 +702,7 @@ pub unsafe fn ykpiv_util_read_mscmap(
state: *mut YubiKey,
containers: *mut *mut YkPivContainer,
n_containers: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut buf = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_buf: usize = buf.len();
@@ -677,11 +710,12 @@ pub unsafe fn ykpiv_util_read_mscmap(
let mut ptr: *mut u8;
if containers.is_null() || n_containers.is_null() {
// TODO(str4d): Should this really continue on here?
res = ErrorKind::GenericError;
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -697,14 +731,17 @@ pub unsafe fn ykpiv_util_read_mscmap(
if res != ErrorKind::Ok {
_ykpiv_end_transaction(state);
return res;
return match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
};
}
ptr = buf.as_mut_ptr();
if cb_buf < CB_OBJ_TAG_MIN {
_ykpiv_end_transaction(state);
return ErrorKind::Ok;
return Ok(());
}
if *ptr == TAG_MSCMAP {
@@ -713,7 +750,7 @@ pub unsafe fn ykpiv_util_read_mscmap(
if len > cb_buf - (ptr as isize - buf.as_mut_ptr() as isize) as usize {
_ykpiv_end_transaction(state);
return ErrorKind::Ok;
return Ok(());
}
*containers = calloc(len, 1) as (*mut YkPivContainer);
@@ -727,7 +764,10 @@ pub unsafe fn ykpiv_util_read_mscmap(
}
}
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get max object size
@@ -744,14 +784,14 @@ pub unsafe fn ykpiv_util_write_mscmap(
state: *mut YubiKey,
containers: *mut YkPivContainer,
n_containers: usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::Ok;
let mut buf = [0u8; CB_OBJ_MAX];
let mut offset: usize = 0;
let data_len: usize = n_containers.wrapping_mul(mem::size_of::<YkPivContainer>());
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -763,14 +803,17 @@ pub unsafe fn ykpiv_util_write_mscmap(
}
_ykpiv_end_transaction(state);
return res;
return match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
};
}
let req_len = 1 + _ykpiv_set_length(buf.as_mut_ptr(), data_len) + data_len;
if req_len > _obj_size_max(state) {
_ykpiv_end_transaction(state);
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
}
buf[offset] = 0x81;
@@ -786,7 +829,10 @@ pub unsafe fn ykpiv_util_write_mscmap(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Read msroots
@@ -794,7 +840,7 @@ pub unsafe fn ykpiv_util_read_msroots(
state: *mut YubiKey,
data: *mut *mut u8,
data_len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut _currentBlock;
let mut res = ErrorKind::Ok;
let mut buf = [0u8; YKPIV_OBJ_MAX_SIZE];
@@ -810,11 +856,11 @@ pub unsafe fn ykpiv_util_read_msroots(
let mut offset: usize = 0;
if data.is_null() || data_len.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -916,7 +962,10 @@ pub unsafe fn ykpiv_util_read_msroots(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Write msroots
@@ -924,7 +973,7 @@ pub unsafe fn ykpiv_util_write_msroots(
state: *mut YubiKey,
data: *mut u8,
data_len: usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut buf = [0u8; CB_OBJ_MAX];
let mut offset: usize;
@@ -934,7 +983,7 @@ pub unsafe fn ykpiv_util_write_msroots(
let cb_obj_max = _obj_size_max(state);
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -946,14 +995,17 @@ pub unsafe fn ykpiv_util_write_msroots(
}
_ykpiv_end_transaction(state);
return res;
return match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
};
}
n_objs = (data_len / (cb_obj_max - 4)) + 1;
if n_objs > 5 {
_ykpiv_end_transaction(state);
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
}
for i in 0..n_objs {
@@ -998,7 +1050,10 @@ pub unsafe fn ykpiv_util_write_msroots(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
// Keygen messages
@@ -1026,7 +1081,7 @@ pub unsafe fn ykpiv_util_generate_key(
exp_len: *mut usize,
point: *mut *mut u8,
point_len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::Ok;
let mut in_data = [0u8; 11];
let mut in_ptr = in_data.as_mut_ptr();
@@ -1043,7 +1098,7 @@ pub unsafe fn ykpiv_util_generate_key(
let setting_roca: SettingBool;
if state.is_null() {
return ErrorKind::ArgumentError;
return Err(ErrorKind::ArgumentError);
}
if ykpiv_util_devicemodel(state) == DEVTYPE_YK4
@@ -1082,7 +1137,7 @@ pub unsafe fn ykpiv_util_generate_key(
);
if !setting_roca.value {
return ErrorKind::NotSupported;
return Err(ErrorKind::NotSupported);
}
}
@@ -1092,7 +1147,7 @@ pub unsafe fn ykpiv_util_generate_key(
if (*state).verbose != 0 {
eprintln!("Invalid output parameter for ECC algorithm");
}
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
} else {
*point = ptr::null_mut();
*point_len = 0;
@@ -1103,7 +1158,7 @@ pub unsafe fn ykpiv_util_generate_key(
if (*state).verbose != 0 {
eprintln!("Invalid output parameter for RSA algorithm",);
}
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
} else {
*modulus = ptr::null_mut();
*modulus_len = 0;
@@ -1116,12 +1171,12 @@ pub unsafe fn ykpiv_util_generate_key(
eprintln!("Invalid algorithm specified");
}
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1384,7 +1439,10 @@ pub unsafe fn ykpiv_util_generate_key(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Config mgm type
@@ -1422,7 +1480,10 @@ pub struct YkPivConfig {
}
/// Get config
pub unsafe fn ykpiv_util_get_config(state: *mut YubiKey, config: *mut YkPivConfig) -> ErrorKind {
pub unsafe fn ykpiv_util_get_config(
state: *mut YubiKey,
config: *mut YkPivConfig,
) -> Result<(), ErrorKind> {
let mut data = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_data: usize = mem::size_of::<[u8; YKPIV_OBJ_MAX_SIZE]>();
let mut p_item: *mut u8 = ptr::null_mut();
@@ -1430,7 +1491,7 @@ pub unsafe fn ykpiv_util_get_config(state: *mut YubiKey, config: *mut YkPivConfi
let res = ErrorKind::Ok;
if state.is_null() || config.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
(*config).protected_data_available = 0u8;
@@ -1440,7 +1501,7 @@ pub unsafe fn ykpiv_util_get_config(state: *mut YubiKey, config: *mut YkPivConfi
(*config).mgm_type = YkPivConfigMgmType::YKPIV_CONFIG_MGM_MANUAL;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1541,22 +1602,25 @@ pub unsafe fn ykpiv_util_get_config(state: *mut YubiKey, config: *mut YkPivConfi
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Set PIN last changed
pub unsafe fn ykpiv_util_set_pin_last_changed(state: *mut YubiKey) -> ErrorKind {
pub unsafe fn ykpiv_util_set_pin_last_changed(state: *mut YubiKey) -> Result<(), ErrorKind> {
let mut data = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_data = data.len();
let mut res = ErrorKind::Ok;
let ykrc: ErrorKind;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1593,7 +1657,10 @@ pub unsafe fn ykpiv_util_set_pin_last_changed(state: *mut YubiKey) -> ErrorKind
}
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Management key (MGM)
@@ -1618,7 +1685,7 @@ pub unsafe fn ykpiv_util_get_derived_mgm(
pin: *const u8,
pin_len: usize,
mgm: *mut YkPivMgm,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut data = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_data: usize = data.len();
let mut p_item: *mut u8 = ptr::null_mut();
@@ -1626,15 +1693,15 @@ pub unsafe fn ykpiv_util_get_derived_mgm(
let mut res: ErrorKind = ErrorKind::Ok;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if pin.is_null() || pin_len == 0 || mgm.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1682,11 +1749,17 @@ pub unsafe fn ykpiv_util_get_derived_mgm(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get protected management key (MGM)
pub unsafe fn ykpiv_util_get_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivMgm) -> ErrorKind {
pub unsafe fn ykpiv_util_get_protected_mgm(
state: *mut YubiKey,
mgm: *mut YkPivMgm,
) -> Result<(), ErrorKind> {
let mut data = [0u8; YKPIV_OBJ_MAX_SIZE];
let mut cb_data: usize = data.len();
let mut p_item: *mut u8 = ptr::null_mut();
@@ -1694,11 +1767,11 @@ pub unsafe fn ykpiv_util_get_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivM
let mut res = ErrorKind::Ok;
if state.is_null() || mgm.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1744,12 +1817,18 @@ pub unsafe fn ykpiv_util_get_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivM
data.zeroize();
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Set protected management key (MGM)
#[allow(clippy::cognitive_complexity)]
pub unsafe fn ykpiv_util_set_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivMgm) -> ErrorKind {
pub unsafe fn ykpiv_util_set_protected_mgm(
state: *mut YubiKey,
mgm: *mut YkPivMgm,
) -> Result<(), ErrorKind> {
let mut _currentBlock;
let mut res: ErrorKind = ErrorKind::Ok;
let mut ykrc: ErrorKind = ErrorKind::Ok;
@@ -1764,7 +1843,7 @@ pub unsafe fn ykpiv_util_set_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivM
let mut flags_1: u8 = 0;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if mgm.is_null() {
@@ -1795,7 +1874,7 @@ pub unsafe fn ykpiv_util_set_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivM
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1953,11 +2032,14 @@ pub unsafe fn ykpiv_util_set_protected_mgm(state: *mut YubiKey, mgm: *mut YkPivM
mgm_key.zeroize();
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Reset
pub unsafe fn ykpiv_util_reset(state: *mut YubiKey) -> ErrorKind {
pub unsafe fn ykpiv_util_reset(state: *mut YubiKey) -> Result<(), ErrorKind> {
let templ = [0, YKPIV_INS_RESET, 0, 0];
let mut data = [0u8; 255];
let mut recv_len = data.len();
@@ -1973,10 +2055,9 @@ pub unsafe fn ykpiv_util_reset(state: *mut YubiKey) -> ErrorKind {
&mut sw,
);
if res == ErrorKind::Ok && sw == SW_SUCCESS {
ErrorKind::Ok
} else {
ErrorKind::GenericError
match (res, sw) {
(ErrorKind::Ok, SW_SUCCESS) => Ok(()),
_ => Err(ErrorKind::GenericError),
}
}
src/yubikey.rs
+131 -87
View File
@@ -178,15 +178,15 @@ pub(crate) unsafe fn _ykpiv_has_valid_length(buffer: *const u8, len: usize) -> b
}
/// Initialize YubiKey client instance
pub unsafe fn ykpiv_init(state: *mut *mut YubiKey, verbose: i32) -> ErrorKind {
pub unsafe fn ykpiv_init(state: *mut *mut YubiKey, verbose: i32) -> Result<(), ErrorKind> {
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
let s = malloc(mem::size_of::<YubiKey>()) as (*mut YubiKey);
if s.is_null() {
return ErrorKind::MemoryError;
return Err(ErrorKind::MemoryError);
}
memset(s as (*mut c_void), 0i32, mem::size_of::<YubiKey>());
@@ -194,7 +194,7 @@ pub unsafe fn ykpiv_init(state: *mut *mut YubiKey, verbose: i32) -> ErrorKind {
(*s).verbose = verbose;
(*s).context = -1i32;
*state = s;
ErrorKind::Ok
Ok(())
}
/// Cleanup YubiKey session
@@ -391,7 +391,7 @@ pub unsafe fn ykpiv_connect_with_external_card(
}
/// Connect to a YubiKey
pub unsafe fn ykpiv_connect(state: *mut YubiKey, wanted: *const c_char) -> ErrorKind {
pub unsafe fn ykpiv_connect(state: *mut YubiKey, wanted: *const c_char) -> Result<(), ErrorKind> {
let mut _currentBlock;
let mut active_protocol: u32 = 0;
let mut reader_buf: [c_char; 2048] = [0; 2048];
@@ -403,7 +403,7 @@ pub unsafe fn ykpiv_connect(state: *mut YubiKey, wanted: *const c_char) -> Error
let mut ret: ErrorKind = ykpiv_list_readers(state, reader_buf.as_mut_ptr(), &mut num_readers);
if ret != ErrorKind::Ok {
return ret;
return Err(ret);
}
reader_ptr = reader_buf.as_mut_ptr();
loop {
@@ -494,9 +494,9 @@ pub unsafe fn ykpiv_connect(state: *mut YubiKey, wanted: *const c_char) -> Error
SCardReleaseContext((*state).context);
(*state).context = -1;
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
} else {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
}
@@ -504,12 +504,15 @@ pub unsafe fn ykpiv_connect(state: *mut YubiKey, wanted: *const c_char) -> Error
// you may not want to select the applet when connecting to a card handle that
// was supplied by an external library.
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
ret = _ykpiv_select_application(state);
_ykpiv_end_transaction(state);
ret
match ret {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// List readers
@@ -879,7 +882,7 @@ pub(crate) unsafe fn _send_data(
pub const DEFAULT_AUTH_KEY: &[u8] = b"\x01\x02\x03\x04\x05\x06\x07\x08\x01\x02\x03\x04\x05\x06\x07\x08\x01\x02\x03\x04\x05\x06\x07\x08\0";
/// Authenticate to the card
pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> ErrorKind {
pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Result<(), ErrorKind> {
let mut data = [0u8; 261];
let mut challenge = [0u8; 8];
let mut recv_len = data.len() as u32;
@@ -890,11 +893,11 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
let mut res = ErrorKind::Ok;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -911,7 +914,7 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
"didn't expect mgm key to be set by failing op!"
);
_ykpiv_end_transaction(state);
return ErrorKind::AlgorithmError;
return Err(ErrorKind::AlgorithmError);
}
// get a challenge from the card
@@ -928,12 +931,12 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
if res != ErrorKind::Ok {
_ykpiv_end_transaction(state);
return res;
return Err(res);
}
if sw != SW_SUCCESS {
_ykpiv_end_transaction(state);
return ErrorKind::AuthenticationError;
return Err(ErrorKind::AuthenticationError);
}
memcpy(
@@ -956,7 +959,7 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
if drc != DesErrorKind::Ok {
_ykpiv_end_transaction(state);
return ErrorKind::AuthenticationError;
return Err(ErrorKind::AuthenticationError);
}
recv_len = data.len() as u32;
@@ -982,7 +985,7 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
}
_ykpiv_end_transaction(state);
return ErrorKind::RandomnessError;
return Err(ErrorKind::RandomnessError);
}
memcpy(
@@ -996,12 +999,12 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
if res != ErrorKind::Ok {
_ykpiv_end_transaction(state);
return res;
return Err(res);
}
if sw != SW_SUCCESS {
_ykpiv_end_transaction(state);
return ErrorKind::AuthenticationError;
return Err(ErrorKind::AuthenticationError);
}
// compare the response from the card with our challenge
@@ -1034,7 +1037,10 @@ pub unsafe fn ykpiv_authenticate(state: *mut YubiKey, mut key: *const u8) -> Err
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Set the management key (MGM)
@@ -1247,13 +1253,13 @@ pub unsafe fn ykpiv_sign_data(
out_len: *mut usize,
algorithm: u8,
key: u8,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
// don't attempt to reselect in crypt operations to avoid problems with PIN_ALWAYS
@@ -1263,7 +1269,10 @@ pub unsafe fn ykpiv_sign_data(
);
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Decrypt data using a PIV key
@@ -1275,20 +1284,23 @@ pub unsafe fn ykpiv_decrypt_data(
out_len: *mut usize,
algorithm: u8,
key: u8,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
// don't attempt to reselect in crypt operations to avoid problems with PIN_ALWAYS
let res = _general_authenticate(state, input, input_len, out, out_len, algorithm, key, true);
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get the version of the PIV application installed on the YubiKey
@@ -1551,11 +1563,11 @@ pub(crate) unsafe fn _ykpiv_get_serial(
}
/// Get YubiKey device serial number
pub unsafe fn ykpiv_get_serial(state: *mut YubiKey, p_serial: *mut u32) -> ErrorKind {
pub unsafe fn ykpiv_get_serial(state: *mut YubiKey, p_serial: *mut u32) -> Result<(), ErrorKind> {
let mut res = ErrorKind::Ok;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1563,7 +1575,10 @@ pub unsafe fn ykpiv_get_serial(state: *mut YubiKey, p_serial: *mut u32) -> Error
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Cache PIN in memory
@@ -1711,9 +1726,9 @@ pub unsafe fn ykpiv_verify_select(
}
/// Get the number of PIN retries
pub unsafe fn ykpiv_get_pin_retries(state: *mut YubiKey, tries: *mut i32) -> ErrorKind {
pub unsafe fn ykpiv_get_pin_retries(state: *mut YubiKey, tries: *mut i32) -> Result<(), ErrorKind> {
if state.is_null() || tries.is_null() {
return ErrorKind::ArgumentError;
return Err(ErrorKind::ArgumentError);
}
// Force a re-select to unverify, because once verified the spec dictates that
@@ -1722,16 +1737,15 @@ pub unsafe fn ykpiv_get_pin_retries(state: *mut YubiKey, tries: *mut i32) -> Err
let res = _ykpiv_select_application(state);
if res != ErrorKind::Ok {
return res;
return Err(res);
}
let ykrc = ykpiv_verify(state, ptr::null(), tries);
// WRONG_PIN is expected on successful query.
if ykrc == ErrorKind::WrongPin {
ErrorKind::Ok
} else {
ykrc
match ykrc {
ErrorKind::Ok | ErrorKind::WrongPin => Ok(()),
e => Err(e),
}
}
@@ -1740,7 +1754,7 @@ pub unsafe fn ykpiv_set_pin_retries(
state: *mut YubiKey,
pin_tries: i32,
puk_tries: i32,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::Ok;
let mut templ = [0, YKPIV_INS_SET_PIN_RETRIES, 0, 0];
let mut data = [0u8; 255];
@@ -1749,18 +1763,18 @@ pub unsafe fn ykpiv_set_pin_retries(
// Special case: if either retry count is 0, it's a successful no-op
if pin_tries == 0 || puk_tries == 0 {
return ErrorKind::Ok;
return Ok(());
}
if pin_tries > 0xff || puk_tries > 0xff || pin_tries < 1 || puk_tries < 1 {
return ErrorKind::RangeError;
return Err(ErrorKind::RangeError);
}
templ[2] = pin_tries as (u8);
templ[3] = puk_tries as (u8);
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1785,7 +1799,10 @@ pub unsafe fn ykpiv_set_pin_retries(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Change the PIN
@@ -1890,11 +1907,11 @@ pub unsafe fn ykpiv_change_pin(
new_pin: *const c_char,
new_pin_len: usize,
tries: *mut i32,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res: ErrorKind = ErrorKind::GenericError;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1916,7 +1933,10 @@ pub unsafe fn ykpiv_change_pin(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Change the PIN Unblocking Key (PUK). PUKs are codes for resetting
@@ -1965,11 +1985,11 @@ pub unsafe fn ykpiv_unblock_pin(
new_pin: *const c_char,
new_pin_len: usize,
tries: *mut i32,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::GenericError;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1977,7 +1997,10 @@ pub unsafe fn ykpiv_unblock_pin(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Fetch an object from the YubiKey
@@ -1986,11 +2009,11 @@ pub unsafe fn ykpiv_fetch_object(
object_id: i32,
data: *mut u8,
len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::Ok;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -1998,7 +2021,10 @@ pub unsafe fn ykpiv_fetch_object(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Fetch an object
@@ -2077,11 +2103,11 @@ pub unsafe fn ykpiv_save_object(
object_id: i32,
indata: *mut u8,
len: usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::Ok;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -2089,7 +2115,10 @@ pub unsafe fn ykpiv_save_object(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Save an object
@@ -2184,7 +2213,7 @@ pub unsafe fn ykpiv_import_private_key(
ec_data_len: u8,
pin_policy: u8,
touch_policy: u8,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut key_data = [0u8; 1024];
let mut in_ptr: *mut u8 = key_data.as_mut_ptr();
let templ = [0, YKPIV_INS_IMPORT_KEY, algorithm, key];
@@ -2199,7 +2228,7 @@ pub unsafe fn ykpiv_import_private_key(
let mut res = ErrorKind::Ok;
if state.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if key == YKPIV_KEY_CARDMGM
@@ -2207,7 +2236,7 @@ pub unsafe fn ykpiv_import_private_key(
|| key > YKPIV_KEY_RETIRED20 && (key < YKPIV_KEY_AUTHENTICATION)
|| key > YKPIV_KEY_CARDAUTH && (key != YKPIV_KEY_ATTESTATION)
{
return ErrorKind::KeyError;
return Err(ErrorKind::KeyError);
}
if pin_policy != YKPIV_PINPOLICY_DEFAULT
@@ -2215,7 +2244,7 @@ pub unsafe fn ykpiv_import_private_key(
&& (pin_policy != YKPIV_PINPOLICY_ONCE)
&& (pin_policy != YKPIV_PINPOLICY_ALWAYS)
{
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if touch_policy != YKPIV_TOUCHPOLICY_DEFAULT
@@ -2223,13 +2252,13 @@ pub unsafe fn ykpiv_import_private_key(
&& (touch_policy != YKPIV_TOUCHPOLICY_ALWAYS)
&& (touch_policy != YKPIV_TOUCHPOLICY_CACHED)
{
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
match algorithm {
YKPIV_ALGO_RSA1024 | YKPIV_ALGO_RSA2048 => {
if p_len + q_len + dp_len + dq_len + qinv_len >= 1024 {
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
} else {
if algorithm == YKPIV_ALGO_RSA1024 {
elem_len = 64;
@@ -2240,7 +2269,7 @@ pub unsafe fn ykpiv_import_private_key(
}
if p.is_null() || q.is_null() || dp.is_null() || dq.is_null() || qinv.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
params[0] = p;
@@ -2259,7 +2288,7 @@ pub unsafe fn ykpiv_import_private_key(
}
YKPIV_ALGO_ECCP256 | YKPIV_ALGO_ECCP384 => {
if ec_data_len as (usize) >= key_data.len() {
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
}
if algorithm == YKPIV_ALGO_ECCP256 {
@@ -2269,7 +2298,7 @@ pub unsafe fn ykpiv_import_private_key(
}
if ec_data.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
params[0] = ec_data;
@@ -2277,7 +2306,7 @@ pub unsafe fn ykpiv_import_private_key(
param_tag = 0x6;
n_params = 1;
}
_ => return ErrorKind::AlgorithmError,
_ => return Err(ErrorKind::AlgorithmError),
}
for i in 0..n_params {
@@ -2289,7 +2318,7 @@ pub unsafe fn ykpiv_import_private_key(
let remaining = (key_data.as_mut_ptr() as usize) + 1024 - in_ptr as usize;
if padding > remaining {
return ErrorKind::AlgorithmError;
return Err(ErrorKind::AlgorithmError);
}
memset(in_ptr as *mut c_void, 0, padding);
@@ -2317,7 +2346,7 @@ pub unsafe fn ykpiv_import_private_key(
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
} else if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
res = ykpiv_transfer_data(
state,
@@ -2339,7 +2368,10 @@ pub unsafe fn ykpiv_import_private_key(
key_data.zeroize();
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Generate an attestation certificate for a stored key
@@ -2348,20 +2380,20 @@ pub unsafe fn ykpiv_attest(
key: u8,
data: *mut u8,
data_len: *mut usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut res = ErrorKind::GenericError;
let templ = [0, YKPIV_INS_ATTEST, key, 0];
let mut sw: i32 = 0;
let mut ul_data_len: usize;
if state.is_null() || data.is_null() || data_len.is_null() {
return ErrorKind::ArgumentError;
return Err(ErrorKind::ArgumentError);
}
ul_data_len = *data_len;
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -2390,7 +2422,10 @@ pub unsafe fn ykpiv_attest(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Get an auth challenge
@@ -2398,22 +2433,22 @@ pub unsafe fn ykpiv_auth_getchallenge(
state: *mut YubiKey,
challenge: *mut u8,
challenge_len: usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut data = [0u8; 261];
let mut recv_len = data.len() as u32;
let mut sw: i32 = 0;
let mut res = ErrorKind::Ok;
if state.is_null() || challenge.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if challenge_len != 8 {
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
if _ykpiv_ensure_application_selected(state) == ErrorKind::Ok {
@@ -2442,7 +2477,10 @@ pub unsafe fn ykpiv_auth_getchallenge(
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// Verify an auth response
@@ -2450,22 +2488,22 @@ pub unsafe fn ykpiv_auth_verifyresponse(
state: *mut YubiKey,
response: *mut u8,
response_len: usize,
) -> ErrorKind {
) -> Result<(), ErrorKind> {
let mut data = [0u8; 261];
let mut recv_len = data.len() as u32;
let mut sw: i32 = 0;
let mut res: ErrorKind;
if state.is_null() || response.is_null() {
return ErrorKind::GenericError;
return Err(ErrorKind::GenericError);
}
if response_len != 8 {
return ErrorKind::SizeError;
return Err(ErrorKind::SizeError);
}
if _ykpiv_begin_transaction(state) != ErrorKind::Ok {
return ErrorKind::PcscError;
return Err(ErrorKind::PcscError);
}
// send the response to the card and a challenge of our own.
@@ -2494,27 +2532,30 @@ pub unsafe fn ykpiv_auth_verifyresponse(
apdu.zeroize();
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}
/// MGMT Application ID(?)
static mut MGMT_AID: [u8; 8] = [0xa0, 0x00, 0x00, 0x05, 0x27, 0x47, 0x11, 0x17];
/// Deauthenticate
pub unsafe fn ykpiv_auth_deauthenticate(state: *mut YubiKey) -> ErrorKind {
pub unsafe fn ykpiv_auth_deauthenticate(state: *mut YubiKey) -> Result<(), ErrorKind> {
let mut data = [0u8; 255];
let mut recv_len = data.len() as u32;
let mut sw: i32 = 0;
let mut res: ErrorKind;
if state.is_null() {
return ErrorKind::ArgumentError;
return Err(ErrorKind::ArgumentError);
}
res = _ykpiv_begin_transaction(state);
if res != ErrorKind::Ok {
return res;
return Err(res);
}
let mut apdu = APDU::default();
@@ -2545,5 +2586,8 @@ pub unsafe fn ykpiv_auth_deauthenticate(state: *mut YubiKey) -> ErrorKind {
}
_ykpiv_end_transaction(state);
res
match res {
ErrorKind::Ok => Ok(()),
e => Err(e),
}
}