From 1d86885ab1fa4f58c3216b427bc059d81a54ce43 Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Sun, 17 Nov 2019 08:21:48 -0800 Subject: [PATCH] oxidize: Fix first pass of compile errors This commit contains a multitude of fixes and some initial translation work so the first rustc pass compiles. It removes `unsafe extern "C"` declarations, so now there are a number of errors about invocations of unsafe functions that need to be addressed. They should each be scoped to an `unsafe` block so as to aid in an eventual safe translation. Some of the functions are now using the module system rather than `extern "C"` bindings, but the translation is not complete. --- Cargo.toml | 2 + src/error.rs | 140 +-- src/internal.rs | 416 ++++----- src/lib.rs | 2339 ++++++++++++++++++++--------------------------- src/util.rs | 1524 ++++++++++++------------------ src/version.rs | 193 ---- 6 files changed, 1849 insertions(+), 2765 deletions(-) delete mode 100644 src/version.rs diff --git a/Cargo.toml b/Cargo.toml index dedff91..7553092 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,3 +6,5 @@ edition = "2018" license = "BSD" [dependencies] +libc = "0.2" +zeroize = "1" diff --git a/src/error.rs b/src/error.rs index b24ac6c..e8e5d7a 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,3 +1,6 @@ +// Adapted from yubico-piv-tool: +// +// // Copyright (c) 2014-2016 Yubico AB // All rights reserved. // @@ -25,72 +28,105 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#[derive(Clone, Copy)] +use std::fmt; + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] #[repr(i32)] -pub enum Enum2 { - YKPIV_OK = 0i32, - YKPIV_MEMORY_ERROR = -1i32, - YKPIV_PCSC_ERROR = -2i32, - YKPIV_SIZE_ERROR = -3i32, - YKPIV_APPLET_ERROR = -4i32, - YKPIV_AUTHENTICATION_ERROR = -5i32, - YKPIV_RANDOMNESS_ERROR = -6i32, - YKPIV_GENERIC_ERROR = -7i32, - YKPIV_KEY_ERROR = -8i32, - YKPIV_PARSE_ERROR = -9i32, - YKPIV_WRONG_PIN = -10i32, - YKPIV_INVALID_OBJECT = -11i32, - YKPIV_ALGORITHM_ERROR = -12i32, - YKPIV_PIN_LOCKED = -13i32, - YKPIV_ARGUMENT_ERROR = -14i32, - YKPIV_RANGE_ERROR = -15i32, - YKPIV_NOT_SUPPORTED = -16i32, +#[allow(non_camel_case_types)] +pub enum ErrorKind { + YKPIV_OK = 0, + YKPIV_MEMORY_ERROR = -1, + YKPIV_PCSC_ERROR = -2, + YKPIV_SIZE_ERROR = -3, + YKPIV_APPLET_ERROR = -4, + YKPIV_AUTHENTICATION_ERROR = -5, + YKPIV_RANDOMNESS_ERROR = -6, + YKPIV_GENERIC_ERROR = -7, + YKPIV_KEY_ERROR = -8, + YKPIV_PARSE_ERROR = -9, + YKPIV_WRONG_PIN = -10, + YKPIV_INVALID_OBJECT = -11, + YKPIV_ALGORITHM_ERROR = -12, + YKPIV_PIN_LOCKED = -13, + YKPIV_ARGUMENT_ERROR = -14, + YKPIV_RANGE_ERROR = -15, + YKPIV_NOT_SUPPORTED = -16, } +impl ErrorKind { + /// Name of the error + pub fn name(self) -> &'static str { + match self { + ErrorKind::YKPIV_OK => "YKPIV_OK", + ErrorKind::YKPIV_MEMORY_ERROR => "YKPIV_MEMORY_ERROR", + ErrorKind::YKPIV_PCSC_ERROR => "YKPIV_PCSC_ERROR", + ErrorKind::YKPIV_SIZE_ERROR => "YKPIV_SIZE_ERROR", + ErrorKind::YKPIV_APPLET_ERROR => "YKPIV_APPLET_ERROR", + ErrorKind::YKPIV_AUTHENTICATION_ERROR => "YKPIV_AUTHENTICATION_ERROR", + ErrorKind::YKPIV_RANDOMNESS_ERROR => "YKPIV_RANDOMNESS_ERROR", + ErrorKind::YKPIV_GENERIC_ERROR => "YKPIV_GENERIC_ERROR", + ErrorKind::YKPIV_KEY_ERROR => "YKPIV_KEY_ERROR", + ErrorKind::YKPIV_PARSE_ERROR => "YKPIV_PARSE_ERROR", + ErrorKind::YKPIV_WRONG_PIN => "YKPIV_WRONG_PIN", + ErrorKind::YKPIV_INVALID_OBJECT => "YKPIV_INVALID_OBJECT", + ErrorKind::YKPIV_ALGORITHM_ERROR => "YKPIV_ALGORITHM_ERROR", + ErrorKind::YKPIV_PIN_LOCKED => "YKPIV_PIN_LOCKED", + ErrorKind::YKPIV_ARGUMENT_ERROR => "YKPIV_ARGUMENT_ERROR", + ErrorKind::YKPIV_RANGE_ERROR => "YKPIV_RANGE_ERROR", + ErrorKind::YKPIV_NOT_SUPPORTED => "YKPIV_NOT_SUPPORTED", + } + } + + /// Error message + pub fn msg(self) -> &'static str { + match self { + ErrorKind::YKPIV_OK => "OK", + ErrorKind::YKPIV_MEMORY_ERROR => "memory error", + ErrorKind::YKPIV_PCSC_ERROR => "PCSC error", + ErrorKind::YKPIV_SIZE_ERROR => "size error", + ErrorKind::YKPIV_APPLET_ERROR => "applet error", + ErrorKind::YKPIV_AUTHENTICATION_ERROR => "authentication error", + ErrorKind::YKPIV_RANDOMNESS_ERROR => "randomness error", + ErrorKind::YKPIV_GENERIC_ERROR => "generic error", + ErrorKind::YKPIV_KEY_ERROR => "key error", + ErrorKind::YKPIV_PARSE_ERROR => "parse error", + ErrorKind::YKPIV_WRONG_PIN => "wrong pin", + ErrorKind::YKPIV_INVALID_OBJECT => "invalid object", + ErrorKind::YKPIV_ALGORITHM_ERROR => "algorithm error", + ErrorKind::YKPIV_PIN_LOCKED => "PIN locked", + ErrorKind::YKPIV_ARGUMENT_ERROR => "argument error", + ErrorKind::YKPIV_RANGE_ERROR => "range error", + ErrorKind::YKPIV_NOT_SUPPORTED => "not supported", + } + } +} + +impl fmt::Display for ErrorKind { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.msg()) + } +} + +impl std::error::Error for ErrorKind {} + #[derive(Copy)] #[repr(C)] -pub struct Struct1 { - pub rc: Enum2, +pub struct Error { + pub rc: ErrorKind, pub name: *const u8, pub description: *const u8, } -impl Clone for Struct1 { +impl Clone for Error { fn clone(&self) -> Self { *self } } -static mut errors: *const Struct1 = Enum2::YKPIV_OK as (*const Struct1); - -#[no_mangle] -pub unsafe extern "C" fn ykpiv_strerror(mut err: Enum2) -> *const u8 { - static mut unknown: *const u8 = (*b"Unknown ykpiv error\0").as_ptr(); - let mut p: *const u8; - if -(err as (i32)) < 0i32 - || -(err as (i32)) - >= ::std::mem::size_of::<*const Struct1>() - .wrapping_div(::std::mem::size_of::()) as (i32) - { - unknown - } else { - p = (*errors.offset(-(err as (i32)) as (isize))).description; - if p.is_null() { - p = unknown; - } - p - } +pub fn ykpiv_strerror(err: ErrorKind) -> &'static str { + err.msg() } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_strerror_name(mut err: Enum2) -> *const u8 { - if -(err as (i32)) < 0i32 - || -(err as (i32)) - >= ::std::mem::size_of::<*const Struct1>() - .wrapping_div(::std::mem::size_of::()) as (i32) - { - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - } else { - (*errors.offset(-(err as (i32)) as (isize))).name - } +pub fn ykpiv_strerror_name(err: ErrorKind) -> &'static str { + err.name() } diff --git a/src/internal.rs b/src/internal.rs index cbd76c0..264d1f6 100644 --- a/src/internal.rs +++ b/src/internal.rs @@ -1,3 +1,6 @@ +// Adapted from yubico-piv-tool: +// +// // Copyright (c) 2014-2016 Yubico AB // All rights reserved. // @@ -25,6 +28,12 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +use libc::{ + c_char, c_int, fclose, feof, fgets, fopen, free, getenv, malloc, memcpy, memset, strcasecmp, + strcmp, strlen, +}; +use std::ptr; + extern "C" { fn DES_ecb3_encrypt( input: *mut [u8; 8], @@ -48,39 +57,13 @@ extern "C" { fn RAND_bytes(buf: *mut u8, num: i32) -> i32; static mut _DefaultRuneLocale: Struct1; fn __maskrune(arg1: i32, arg2: usize) -> i32; - fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32; fn __tolower(arg1: i32) -> i32; fn __toupper(arg1: i32) -> i32; - fn fclose(arg1: *mut __sFILE) -> i32; - fn feof(arg1: *mut __sFILE) -> i32; - fn fgets(arg1: *mut u8, arg2: i32, arg3: *mut __sFILE) -> *mut u8; - fn fopen(__filename: *const u8, __mode: *const u8) -> *mut __sFILE; - fn free(arg1: *mut ::std::os::raw::c_void); - fn getenv(arg1: *const u8) -> *mut u8; - fn malloc(__size: usize) -> *mut ::std::os::raw::c_void; - fn memcpy( - __dst: *mut ::std::os::raw::c_void, - __src: *const ::std::os::raw::c_void, - __n: usize, - ) -> *mut ::std::os::raw::c_void; - fn memset( - __b: *mut ::std::os::raw::c_void, - __c: i32, - __len: usize, - ) -> *mut ::std::os::raw::c_void; fn snprintf(__str: *mut u8, __size: usize, __format: *const u8, ...) -> i32; fn sscanf(arg1: *const u8, arg2: *const u8, ...) -> i32; - fn strcasecmp(arg1: *const u8, arg2: *const u8) -> i32; - fn strcmp(__s1: *const u8, __s2: *const u8) -> i32; - fn strlen(__s: *const u8) -> usize; } -enum Union6 {} - -enum __sFILEX {} - -#[no_mangle] -pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 { +pub fn isascii(mut _c: i32) -> i32 { (_c & !0x7fi32 == 0i32) as (i32) } @@ -151,8 +134,7 @@ impl Clone for Struct1 { } } -#[no_mangle] -pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __istype(mut _c: i32, mut _f: usize) -> i32 { if isascii(_c) != 0 { !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } else { @@ -160,8 +142,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { @@ -169,8 +150,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { +pub fn __wcwidth(mut _c: i32) -> i32 { let mut _x: u32; if _c == 0i32 { 0i32 @@ -186,113 +166,91 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { +pub fn isalnum(mut _c: i32) -> i32 { __istype(_c, (0x100isize | 0x400isize) as (usize)) } -#[no_mangle] -pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { +pub fn isalpha(mut _c: i32) -> i32 { __istype(_c, 0x100usize) } -#[no_mangle] -pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { +pub fn isblank(mut _c: i32) -> i32 { __istype(_c, 0x20000usize) } -#[no_mangle] -pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { +pub fn iscntrl(mut _c: i32) -> i32 { __istype(_c, 0x200usize) } -#[no_mangle] -pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { +pub fn isdigit(mut _c: i32) -> i32 { __isctype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { +pub fn isgraph(mut _c: i32) -> i32 { __istype(_c, 0x800usize) } -#[no_mangle] -pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { +pub fn islower(mut _c: i32) -> i32 { __istype(_c, 0x1000usize) } -#[no_mangle] -pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { +pub fn isprint(mut _c: i32) -> i32 { __istype(_c, 0x40000usize) } -#[no_mangle] -pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { +pub fn ispunct(mut _c: i32) -> i32 { __istype(_c, 0x2000usize) } -#[no_mangle] -pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { +pub fn isspace(mut _c: i32) -> i32 { __istype(_c, 0x4000usize) } -#[no_mangle] -pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { +pub fn isupper(mut _c: i32) -> i32 { __istype(_c, 0x8000usize) } -#[no_mangle] -pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { +pub fn isxdigit(mut _c: i32) -> i32 { __isctype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { +pub fn toascii(mut _c: i32) -> i32 { _c & 0x7fi32 } -#[no_mangle] -pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { +pub fn tolower(mut _c: i32) -> i32 { __tolower(_c) } -#[no_mangle] -pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { +pub fn toupper(mut _c: i32) -> i32 { __toupper(_c) } -#[no_mangle] -pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { +pub fn digittoint(mut _c: i32) -> i32 { __maskrune(_c, 0xfusize) } -#[no_mangle] -pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { +pub fn ishexnumber(mut _c: i32) -> i32 { __istype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { +pub fn isideogram(mut _c: i32) -> i32 { __istype(_c, 0x80000usize) } -#[no_mangle] -pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { +pub fn isnumber(mut _c: i32) -> i32 { __istype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { +pub fn isphonogram(mut _c: i32) -> i32 { __istype(_c, 0x200000usize) } -#[no_mangle] -pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { +pub fn isrune(mut _c: i32) -> i32 { __istype(_c, 0xfffffff0usize) } -#[no_mangle] -pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 { +pub fn isspecial(mut _c: i32) -> i32 { __istype(_c, 0x100000usize) } @@ -309,65 +267,11 @@ impl Clone for __sbuf { } } -#[derive(Copy)] -#[repr(C)] -pub struct __sFILE { - pub _p: *mut u8, - pub _r: i32, - pub _w: i32, - pub _flags: i16, - pub _file: i16, - pub _bf: __sbuf, - pub _lbfsize: i32, - pub _cookie: *mut ::std::os::raw::c_void, - pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32, - pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32, - pub _ub: __sbuf, - pub _extra: *mut __sFILEX, - pub _ur: i32, - pub _ubuf: [u8; 3], - pub _nbuf: [u8; 1], - pub _lb: __sbuf, - pub _blksize: i32, - pub _offset: isize, -} - -impl Clone for __sFILE { - fn clone(&self) -> Self { - *self - } -} - -#[no_mangle] -pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 { - if { - (*_p)._w = (*_p)._w - 1; - (*_p)._w - } >= 0i32 - || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32)) - { - ({ - let _rhs = _c; - let _lhs = &mut *{ - let _old = (*_p)._p; - (*_p)._p = (*_p)._p.offset(1isize); - _old - }; - *_lhs = _rhs as (u8); - *_lhs - }) as (i32) - } else { - __swbuf(_c, _p) - } -} - -#[no_mangle] pub static mut szLOG_SOURCE: *const u8 = (*b"YubiKey PIV Library\0").as_ptr(); #[derive(Clone, Copy)] #[repr(i32)] +#[allow(non_camel_case_types)] pub enum Enum5 { DES_OK = 0i32, DES_INVALID_PARAMETER = -1i32, @@ -379,7 +283,7 @@ pub enum Enum5 { #[derive(Copy)] #[repr(C)] pub struct DES_ks { - pub ks: [Union6; 16], + pub ks: [u8; 16], } impl Clone for DES_ks { @@ -390,24 +294,23 @@ impl Clone for DES_ks { #[derive(Copy)] #[repr(C)] -pub struct des_key { +pub struct DesKey { pub ks1: DES_ks, pub ks2: DES_ks, pub ks3: DES_ks, } -impl Clone for des_key { +impl Clone for DesKey { fn clone(&self) -> Self { *self } } -#[no_mangle] -pub unsafe extern "C" fn des_import_key( +pub fn des_import_key( type_: i32, mut keyraw: *const u8, keyrawlen: usize, - mut key: *mut *mut des_key, + mut key: *mut *mut DesKey, ) -> Enum5 { let mut _currentBlock; let mut rc: Enum5 = Enum5::DES_OK; @@ -430,7 +333,7 @@ pub unsafe extern "C" fn des_import_key( rc = Enum5::DES_INVALID_PARAMETER; _currentBlock = 15; } else if { - *key = malloc(::std::mem::size_of::()) as (*mut des_key); + *key = malloc(::std::mem::size_of::()) as (*mut DesKey); *key } .is_null() @@ -441,7 +344,7 @@ pub unsafe extern "C" fn des_import_key( memset( *key as (*mut ::std::os::raw::c_void), 0i32, - ::std::mem::size_of::(), + ::std::mem::size_of::(), ); memcpy( key_tmp.as_mut_ptr() as (*mut ::std::os::raw::c_void), @@ -480,23 +383,21 @@ pub unsafe extern "C" fn des_import_key( if _currentBlock == 15 { if !key.is_null() { des_destroy_key(*key); - *key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut des_key); + *key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut DesKey); } } rc } -#[no_mangle] -pub unsafe extern "C" fn des_destroy_key(mut key: *mut des_key) -> Enum5 { +pub fn des_destroy_key(mut key: *mut DesKey) -> Enum5 { if !key.is_null() { free(key as (*mut ::std::os::raw::c_void)); } Enum5::DES_OK } -#[no_mangle] -pub unsafe extern "C" fn des_encrypt( - mut key: *mut des_key, +pub fn des_encrypt( + mut key: *mut DesKey, mut in_: *const u8, inlen: usize, mut out: *mut u8, @@ -518,9 +419,8 @@ pub unsafe extern "C" fn des_encrypt( rc } -#[no_mangle] -pub unsafe extern "C" fn des_decrypt( - mut key: *mut des_key, +pub fn des_decrypt( + mut key: *mut DesKey, mut in_: *const u8, inlen: usize, mut out: *mut u8, @@ -542,21 +442,20 @@ pub unsafe extern "C" fn des_decrypt( rc } -#[no_mangle] -pub unsafe extern "C" fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool { +pub fn yk_des_is_weak_key(mut key: *const u8, cb_key: usize) -> bool { cb_key; DES_is_weak_key(key as (*mut [u8; 8])) != 0 } #[derive(Clone, Copy)] #[repr(i32)] +#[allow(non_camel_case_types)] pub enum Enum7 { PRNG_OK = 0i32, PRNG_GENERAL_ERROR = -1i32, } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 { +pub fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize) -> Enum7 { let mut rc: Enum7 = Enum7::PRNG_OK; if -1i32 == RAND_bytes(buffer, cb_req as (i32)) { rc = Enum7::PRNG_GENERAL_ERROR; @@ -566,13 +465,13 @@ pub unsafe extern "C" fn _ykpiv_prng_generate(mut buffer: *mut u8, cb_req: usize #[derive(Clone, Copy)] #[repr(i32)] +#[allow(non_camel_case_types)] pub enum Enum8 { PKCS5_OK = 0i32, PKCS5_GENERAL_ERROR = -1i32, } -#[no_mangle] -pub unsafe extern "C" fn pkcs5_pbkdf2_sha1( +pub fn pkcs5_pbkdf2_sha1( mut password: *const u8, cb_password: usize, mut salt: *const u8, @@ -594,14 +493,13 @@ pub unsafe extern "C" fn pkcs5_pbkdf2_sha1( rc } -#[no_mangle] -pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 { - let mut psz_head: *mut u8 = sz; - let mut psz_tail: *mut u8 = sz - .offset(strlen(sz as (*const u8)) as (isize)) +pub fn _strip_ws(mut sz: *mut c_char) -> *mut c_char { + let mut psz_head: *mut c_char = sz; + let mut psz_tail: *mut c_char = sz + .offset(strlen(sz as *const c_char) as (isize)) .offset(-1isize); 'loop1: loop { - if isspace(*psz_head as (i32)) == 0 { + if isspace(*psz_head as i32) == 0 { break; } psz_head = psz_head.offset(1isize); @@ -614,150 +512,150 @@ pub unsafe extern "C" fn _strip_ws(mut sz: *mut u8) -> *mut u8 { let _old = psz_tail; psz_tail = psz_tail.offset(-1isize); _old - } = b'\0'; + } = 0; } psz_head } -#[derive(Clone, Copy)] -#[repr(i32)] -pub enum _setting_source_t { +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[allow(non_camel_case_types)] +pub enum SettingSource { SETTING_SOURCE_USER, SETTING_SOURCE_ADMIN, SETTING_SOURCE_DEFAULT, } #[derive(Copy)] -#[repr(C)] -pub struct _setting_bool_t { +pub struct SettingBool { pub value: bool, - pub source: _setting_source_t, + pub source: SettingSource, } -impl Clone for _setting_bool_t { +impl Clone for SettingBool { fn clone(&self) -> Self { *self } } -#[no_mangle] -pub unsafe extern "C" fn _get_bool_config(mut sz_setting: *const u8) -> _setting_bool_t { - let mut _currentBlock; - let mut setting: _setting_bool_t = _setting_bool_t { +pub unsafe fn _get_bool_config(mut sz_setting: *const c_char) -> SettingBool { + let mut setting: SettingBool = SettingBool { value: false, - source: _setting_source_t::SETTING_SOURCE_DEFAULT, + source: SettingSource::SETTING_SOURCE_DEFAULT, }; - let mut sz_line: [u8; 256]; - let mut psz_name: *mut u8 = 0i32 as (*mut u8); - let mut psz_value: *mut u8 = 0i32 as (*mut u8); + let mut sz_line = [0u8; 256]; + let mut psz_name: *mut c_char = ptr::null_mut(); + let mut psz_value: *mut c_char = ptr::null_mut(); let mut sz_name = [0u8; 256]; let mut sz_value = [0u8; 256]; - let mut pf: *mut __sFILE = 0i32 as (*mut __sFILE); - if !{ - pf = fopen( - (*b"/etc/yubico/yubikeypiv.conf\0").as_ptr(), - (*b"r\0").as_ptr(), - ); - pf + + let mut pf = unsafe { + fopen( + b"/etc/yubico/yubikeypiv.conf\0".as_ptr() as *const c_char, + b"r\0".as_ptr() as *const c_char, + ) + }; + + if pf.is_null() { + return setting; } - .is_null() - { - _currentBlock = 1; - } else { - _currentBlock = 10; - } - 'loop1: loop { - if _currentBlock == 1 { - if feof(pf) == 0 { - if fgets( - sz_line.as_mut_ptr(), - ::std::mem::size_of::<[u8; 256]>() as (i32), - pf, - ) - .is_null() - { - _currentBlock = 1; - continue; - } - if sz_line[0usize] as (i32) == b'#' as (i32) { - _currentBlock = 1; - continue; - } - if sz_line[0usize] as (i32) == b'\r' as (i32) { - _currentBlock = 1; - continue; - } - if sz_line[0usize] as (i32) == b'\n' as (i32) { - _currentBlock = 1; - continue; - } - if !(sscanf( - sz_line.as_mut_ptr() as (*const u8), - (*b"%255[^=]=%255s\0").as_ptr(), - sz_name.as_mut_ptr(), - sz_value.as_mut_ptr(), - ) == 2i32) - { - _currentBlock = 1; - continue; - } - psz_name = _strip_ws(sz_name.as_mut_ptr()); - if !(strcasecmp(psz_name as (*const u8), sz_setting) == 0) { - _currentBlock = 1; - continue; - } - psz_value = _strip_ws(sz_value.as_mut_ptr()); - setting.source = _setting_source_t::SETTING_SOURCE_ADMIN; - setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0 - || strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0; - } - fclose(pf); - _currentBlock = 10; - } else { - return setting; + + while feof(pf) == 0 { + if fgets( + sz_line.as_mut_ptr() as *mut c_char, + sz_line.len() as c_int, + pf, + ) + .is_null() + { + continue; } + + if sz_line[0] == b'#' { + continue; + } + + if sz_line[0] == b'\r' { + continue; + } + + if sz_line[0] == b'\n' { + continue; + } + + if !(sscanf( + sz_line.as_mut_ptr(), + (*b"%255[^=]=%255s\0").as_ptr(), + sz_name.as_mut_ptr(), + sz_value.as_mut_ptr(), + ) == 2) + { + continue; + } + + psz_name = _strip_ws(sz_name.as_mut_ptr() as *mut c_char); + + if !(strcasecmp(psz_name as *const c_char, sz_setting as *const c_char) == 0) { + continue; + } + + psz_value = _strip_ws(sz_value.as_mut_ptr() as *mut c_char); + setting.source = SettingSource::SETTING_SOURCE_ADMIN; + setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0 + || strcasecmp( + psz_value as *const c_char, + b"true\0".as_ptr() as *const c_char, + ) == 0; } + + fclose(pf); + setting } -#[no_mangle] -pub unsafe extern "C" fn _get_bool_env(mut sz_setting: *const u8) -> _setting_bool_t { - let mut setting: _setting_bool_t = _setting_bool_t { +pub fn _get_bool_env(mut sz_setting: *const c_char) -> SettingBool { + let mut setting: SettingBool = SettingBool { value: false, - source: _setting_source_t::SETTING_SOURCE_DEFAULT, + source: SettingSource::SETTING_SOURCE_DEFAULT, }; - let mut psz_value: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut psz_value: *mut c_char = ptr::null_mut(); let mut sz_name = [0u8; 256]; + snprintf( sz_name.as_mut_ptr(), ::std::mem::size_of::<[u8; 256]>().wrapping_sub(1usize), - (*b"%s%s\0").as_ptr(), - (*b"YUBIKEY_PIV_\0").as_ptr(), + b"%s%s\0".as_ptr(), + b"YUBIKEY_PIV_\0".as_ptr(), sz_setting, ); - psz_value = getenv(sz_name.as_mut_ptr() as (*const u8)); + + psz_value = getenv(sz_name.as_mut_ptr() as *const c_char); + if !psz_value.is_null() { - setting.source = _setting_source_t::SETTING_SOURCE_USER; - setting.value = strcmp(psz_value as (*const u8), (*b"1\0").as_ptr()) == 0 - || strcasecmp(psz_value as (*const u8), (*b"true\0").as_ptr()) == 0; + setting.source = SettingSource::SETTING_SOURCE_USER; + setting.value = strcmp(psz_value as *const c_char, b"1\0".as_ptr() as *const c_char) == 0 + || strcasecmp( + psz_value as *const c_char, + b"true\0".as_ptr() as *const c_char, + ) == 0; } + setting } -#[no_mangle] -pub unsafe extern "C" fn setting_get_bool( - mut sz_setting: *const u8, - mut def: bool, -) -> _setting_bool_t { - let mut setting: _setting_bool_t = _setting_bool_t { +pub fn setting_get_bool(mut sz_setting: *const c_char, mut def: bool) -> SettingBool { + let mut setting: SettingBool = SettingBool { value: def, - source: _setting_source_t::SETTING_SOURCE_DEFAULT, + source: SettingSource::SETTING_SOURCE_DEFAULT, }; + setting = _get_bool_config(sz_setting); - if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) { + + if setting.source == SettingSource::SETTING_SOURCE_DEFAULT { setting = _get_bool_env(sz_setting); } - if setting.source as (i32) == _setting_source_t::SETTING_SOURCE_DEFAULT as (i32) { + + if setting.source == SettingSource::SETTING_SOURCE_DEFAULT { setting.value = def; } + setting } diff --git a/src/lib.rs b/src/lib.rs index 820acde..4f01133 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,6 @@ +// Adapted from yubico-piv-tool: +// +// // Copyright (c) 2014-2016 Yubico AB // All rights reserved. // @@ -28,13 +31,22 @@ pub mod error; pub mod internal; pub mod util; -pub mod version; + +use self::{error::ErrorKind, internal::DesKey}; +use std::{convert::TryInto, ffi::CStr, mem, os::raw::c_void, ptr}; +use zeroize::Zeroize; + +use crate::error::ykpiv_strerror; +use libc::{ + c_char, calloc, free, malloc, memcmp, memcpy, memmove, memset, realloc, strchr, strlen, + strncasecmp, strnlen, +}; extern "C" { fn SCardBeginTransaction(hCard: i32) -> i32; fn SCardConnect( hContext: i32, - szReader: *const u8, + szReader: *const c_char, dwShareMode: u32, dwPreferredProtocols: u32, phCard: *mut i32, @@ -44,15 +56,15 @@ extern "C" { fn SCardEndTransaction(hCard: i32, dwDisposition: u32) -> i32; fn SCardEstablishContext( dwScope: u32, - pvReserved1: *const ::std::os::raw::c_void, - pvReserved2: *const ::std::os::raw::c_void, + pvReserved1: *const c_void, + pvReserved2: *const c_void, phContext: *mut i32, ) -> i32; fn SCardIsValidContext(hContext: i32) -> i32; fn SCardListReaders( hContext: i32, - mszGroups: *const u8, - mszReaders: *mut u8, + mszGroups: *const c_char, + mszReaders: *mut c_char, pcchReaders: *mut u32, ) -> i32; fn SCardReconnect( @@ -74,14 +86,11 @@ extern "C" { ) -> i32; static mut _DefaultRuneLocale: Struct1; fn __maskrune(arg1: i32, arg2: usize) -> i32; - static mut __stderrp: *mut __sFILE; - fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32; fn __tolower(arg1: i32) -> i32; fn __toupper(arg1: i32) -> i32; - fn calloc(__count: usize, __size: usize) -> *mut ::std::os::raw::c_void; - fn des_destroy_key(key: *mut des_key) -> Enum6; + fn des_destroy_key(key: *mut DesKey) -> Enum6; fn des_encrypt( - key: *mut des_key, + key: *mut DesKey, in_: *const u8, inlen: usize, out: *mut u8, @@ -91,46 +100,116 @@ extern "C" { type_: i32, keyraw: *const u8, keyrawlen: usize, - key: *mut *mut des_key, + key: *mut *mut DesKey, ) -> Enum6; - fn fprintf(arg1: *mut __sFILE, arg2: *const u8, ...) -> i32; - fn free(arg1: *mut ::std::os::raw::c_void); - fn memcmp( - __s1: *const ::std::os::raw::c_void, - __s2: *const ::std::os::raw::c_void, - __n: usize, - ) -> i32; - fn memcpy( - __dst: *mut ::std::os::raw::c_void, - __src: *const ::std::os::raw::c_void, - __n: usize, - ) -> *mut ::std::os::raw::c_void; - fn memmove( - __dst: *mut ::std::os::raw::c_void, - __src: *const ::std::os::raw::c_void, - __len: usize, - ) -> *mut ::std::os::raw::c_void; - fn memset( - __b: *mut ::std::os::raw::c_void, - __c: i32, - __len: usize, - ) -> *mut ::std::os::raw::c_void; - fn memset_s(__s: *mut ::std::os::raw::c_void, __smax: usize, __c: i32, __n: usize) -> i32; - fn realloc(__ptr: *mut ::std::os::raw::c_void, __size: usize) -> *mut ::std::os::raw::c_void; + fn memset_s(__s: *mut c_void, __smax: usize, __c: i32, __n: usize) -> i32; fn snprintf(__str: *mut u8, __size: usize, __format: *const u8, ...) -> i32; - fn strchr(__s: *const u8, __c: i32) -> *mut u8; - fn strlen(__s: *const u8) -> usize; - fn strncasecmp(arg1: *const u8, arg2: *const u8, arg3: usize) -> i32; - fn strnlen(__s1: *const u8, __n: usize) -> usize; fn yk_des_is_weak_key(key: *const u8, cb_key: usize) -> bool; - fn ykpiv_strerror(err: Enum5) -> *const u8; } -enum __sFILEX {} +pub const DES_TYPE_3DES: u8 = 1; -enum des_key {} +pub const DES_LEN_DES: usize = 8; +pub const DES_LEN_3DES: usize = DES_LEN_DES * 3; -enum u_APDU {} +pub const YKPIV_ALGO_TAG: u8 = 0x80; +pub const YKPIV_ALGO_3DES: u8 = 0x03; +pub const YKPIV_ALGO_RSA1024: u8 = 0x06; +pub const YKPIV_ALGO_RSA2048: u8 = 0x07; +pub const YKPIV_ALGO_ECCP256: u8 = 0x11; +pub const YKPIV_ALGO_ECCP384: u8 = 0x14; + +pub const YKPIV_KEY_AUTHENTICATION: u8 = 0x9a; +pub const YKPIV_KEY_CARDMGM: u8 = 0x9b; +pub const YKPIV_KEY_SIGNATURE: u8 = 0x9c; +pub const YKPIV_KEY_KEYMGM: u8 = 0x9d; +pub const YKPIV_KEY_CARDAUTH: u8 = 0x9e; +pub const YKPIV_KEY_RETIRED1: u8 = 0x82; +pub const YKPIV_KEY_RETIRED2: u8 = 0x83; +pub const YKPIV_KEY_RETIRED3: u8 = 0x84; +pub const YKPIV_KEY_RETIRED4: u8 = 0x85; +pub const YKPIV_KEY_RETIRED5: u8 = 0x86; +pub const YKPIV_KEY_RETIRED6: u8 = 0x87; +pub const YKPIV_KEY_RETIRED7: u8 = 0x88; +pub const YKPIV_KEY_RETIRED8: u8 = 0x89; +pub const YKPIV_KEY_RETIRED9: u8 = 0x8a; +pub const YKPIV_KEY_RETIRED10: u8 = 0x8b; +pub const YKPIV_KEY_RETIRED11: u8 = 0x8c; +pub const YKPIV_KEY_RETIRED12: u8 = 0x8d; +pub const YKPIV_KEY_RETIRED13: u8 = 0x8e; +pub const YKPIV_KEY_RETIRED14: u8 = 0x8f; +pub const YKPIV_KEY_RETIRED15: u8 = 0x90; +pub const YKPIV_KEY_RETIRED16: u8 = 0x91; +pub const YKPIV_KEY_RETIRED17: u8 = 0x92; +pub const YKPIV_KEY_RETIRED18: u8 = 0x93; +pub const YKPIV_KEY_RETIRED19: u8 = 0x94; +pub const YKPIV_KEY_RETIRED20: u8 = 0x95; +pub const YKPIV_KEY_ATTESTATION: u8 = 0xf9; + +pub const YKPIV_INS_VERIFY: u8 = 0x20; +pub const YKPIV_INS_CHANGE_REFERENCE: u8 = 0x24; +pub const YKPIV_INS_RESET_RETRY: u8 = 0x2c; +pub const YKPIV_INS_GENERATE_ASYMMETRIC: u8 = 0x47; +pub const YKPIV_INS_AUTHENTICATE: u8 = 0x87; +pub const YKPIV_INS_GET_DATA: u8 = 0xcb; +pub const YKPIV_INS_PUT_DATA: u8 = 0xdb; +pub const YKPIV_INS_SELECT_APPLICATION: u8 = 0xa4; +pub const YKPIV_INS_GET_RESPONSE_APDU: u8 = 0xc0; + +// Yubico vendor specific instructions +pub const YKPIV_INS_SET_MGMKEY: u8 = 0xff; +pub const YKPIV_INS_IMPORT_KEY: u8 = 0xfe; +pub const YKPIV_INS_GET_VERSION: u8 = 0xfd; +pub const YKPIV_INS_RESET: u8 = 0xfb; +pub const YKPIV_INS_SET_PIN_RETRIES: u8 = 0xfa; +pub const YKPIV_INS_ATTEST: u8 = 0xf9; +pub const YKPIV_INS_GET_SERIAL: u8 = 0xf8; + +/// Application Protocol Data Unit +#[derive(Clone)] +pub struct APDU { + /// Instruction class - indicates the type of command, e.g. interindustry or proprietary + pub cla: u8, + + /// Instruction code - indicates the specific command, e.g. "write data" + pub ins: u8, + + /// Instruction parameter 1 for the command, e.g. offset into file at which to write the data + pub p1: u8, + + /// Instruction parameter 2 for the command + pub p2: u8, + + /// Length of command - encodes the number of bytes of command data to follow + pub lc: u8, + + /// Command data + pub data: [u8; 255], +} + +impl Default for APDU { + fn default() -> Self { + Self { + cla: 0, + ins: 0, + p1: 0, + p2: 0, + lc: 0, + data: [0u8; 255], + } + } +} + +impl Zeroize for APDU { + fn zeroize(&mut self) { + self.cla.zeroize(); + self.ins.zeroize(); + self.p1.zeroize(); + self.p2.zeroize(); + self.lc.zeroize(); + self.data.zeroize(); + } +} #[derive(Copy)] #[repr(C)] @@ -145,62 +224,7 @@ impl Clone for __sbuf { } } -#[derive(Copy)] -#[repr(C)] -pub struct __sFILE { - pub _p: *mut u8, - pub _r: i32, - pub _w: i32, - pub _flags: i16, - pub _file: i16, - pub _bf: __sbuf, - pub _lbfsize: i32, - pub _cookie: *mut ::std::os::raw::c_void, - pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32, - pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32, - pub _ub: __sbuf, - pub _extra: *mut __sFILEX, - pub _ur: i32, - pub _ubuf: [u8; 3], - pub _nbuf: [u8; 1], - pub _lb: __sbuf, - pub _blksize: i32, - pub _offset: isize, -} - -impl Clone for __sFILE { - fn clone(&self) -> Self { - *self - } -} - -#[no_mangle] -pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 { - if { - (*_p)._w = (*_p)._w - 1; - (*_p)._w - } >= 0i32 - || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32)) - { - ({ - let _rhs = _c; - let _lhs = &mut *{ - let _old = (*_p)._p; - (*_p)._p = (*_p)._p.offset(1isize); - _old - }; - *_lhs = _rhs as (u8); - *_lhs - }) as (i32) - } else { - __swbuf(_c, _p) - } -} - -#[no_mangle] -pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 { +pub fn isascii(mut _c: i32) -> i32 { (_c & !0x7fi32 == 0i32) as (i32) } @@ -250,8 +274,8 @@ impl Clone for Struct4 { pub struct Struct1 { pub __magic: [u8; 8], pub __encoding: [u8; 32], - pub __sgetrune: unsafe extern "C" fn(*const u8, usize, *mut *const u8) -> i32, - pub __sputrune: unsafe extern "C" fn(i32, *mut u8, usize, *mut *mut u8) -> i32, + pub __sgetrune: unsafe fn(*const u8, usize, *mut *const u8) -> i32, + pub __sputrune: unsafe fn(i32, *mut u8, usize, *mut *mut u8) -> i32, pub __invalid_rune: i32, pub __runetype: [u32; 256], pub __maplower: [i32; 256], @@ -259,7 +283,7 @@ pub struct Struct1 { pub __runetype_ext: Struct2, pub __maplower_ext: Struct2, pub __mapupper_ext: Struct2, - pub __variable: *mut ::std::os::raw::c_void, + pub __variable: *mut c_void, pub __variable_len: i32, pub __ncharclasses: i32, pub __charclasses: *mut Struct4, @@ -271,8 +295,7 @@ impl Clone for Struct1 { } } -#[no_mangle] -pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __istype(mut _c: i32, mut _f: usize) -> i32 { if isascii(_c) != 0 { !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } else { @@ -280,8 +303,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { @@ -289,8 +311,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { +pub fn __wcwidth(mut _c: i32) -> i32 { let mut _x: u32; if _c == 0i32 { 0i32 @@ -306,113 +327,91 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { +pub fn isalnum(mut _c: i32) -> i32 { __istype(_c, (0x100isize | 0x400isize) as (usize)) } -#[no_mangle] -pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { +pub fn isalpha(mut _c: i32) -> i32 { __istype(_c, 0x100usize) } -#[no_mangle] -pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { +pub fn isblank(mut _c: i32) -> i32 { __istype(_c, 0x20000usize) } -#[no_mangle] -pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { +pub fn iscntrl(mut _c: i32) -> i32 { __istype(_c, 0x200usize) } -#[no_mangle] -pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { +pub fn isdigit(mut _c: i32) -> i32 { __isctype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { +pub fn isgraph(mut _c: i32) -> i32 { __istype(_c, 0x800usize) } -#[no_mangle] -pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { +pub fn islower(mut _c: i32) -> i32 { __istype(_c, 0x1000usize) } -#[no_mangle] -pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { +pub fn isprint(mut _c: i32) -> i32 { __istype(_c, 0x40000usize) } -#[no_mangle] -pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { +pub fn ispunct(mut _c: i32) -> i32 { __istype(_c, 0x2000usize) } -#[no_mangle] -pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { +pub fn isspace(mut _c: i32) -> i32 { __istype(_c, 0x4000usize) } -#[no_mangle] -pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { +pub fn isupper(mut _c: i32) -> i32 { __istype(_c, 0x8000usize) } -#[no_mangle] -pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { +pub fn isxdigit(mut _c: i32) -> i32 { __isctype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { +pub fn toascii(mut _c: i32) -> i32 { _c & 0x7fi32 } -#[no_mangle] -pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { +pub fn tolower(mut _c: i32) -> i32 { __tolower(_c) } -#[no_mangle] -pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { +pub fn toupper(mut _c: i32) -> i32 { __toupper(_c) } -#[no_mangle] -pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { +pub fn digittoint(mut _c: i32) -> i32 { __maskrune(_c, 0xfusize) } -#[no_mangle] -pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { +pub fn ishexnumber(mut _c: i32) -> i32 { __istype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { +pub fn isideogram(mut _c: i32) -> i32 { __istype(_c, 0x80000usize) } -#[no_mangle] -pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { +pub fn isnumber(mut _c: i32) -> i32 { __istype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { +pub fn isphonogram(mut _c: i32) -> i32 { __istype(_c, 0x200000usize) } -#[no_mangle] -pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { +pub fn isrune(mut _c: i32) -> i32 { __istype(_c, 0xfffffff0usize) } -#[no_mangle] -pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 { +pub fn isspecial(mut _c: i32) -> i32 { __istype(_c, 0x100000usize) } @@ -421,15 +420,10 @@ static mut aid: *const u8 = 0xa0i32 as (*const u8); #[derive(Copy)] #[repr(C)] pub struct ykpiv_allocator { - pub pfn_alloc: - unsafe extern "C" fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void, - pub pfn_realloc: unsafe extern "C" fn( - *mut ::std::os::raw::c_void, - *mut ::std::os::raw::c_void, - usize, - ) -> *mut ::std::os::raw::c_void, - pub pfn_free: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void), - pub alloc_data: *mut ::std::os::raw::c_void, + pub pfn_alloc: unsafe fn(*mut c_void, usize) -> *mut c_void, + pub pfn_realloc: unsafe fn(*mut c_void, *mut c_void, usize) -> *mut c_void, + pub pfn_free: unsafe fn(*mut c_void, *mut c_void), + pub alloc_data: *mut c_void, } impl Clone for ykpiv_allocator { @@ -438,37 +432,30 @@ impl Clone for ykpiv_allocator { } } -unsafe extern "C" fn _default_alloc( - mut data: *mut ::std::os::raw::c_void, - mut cb: usize, -) -> *mut ::std::os::raw::c_void { +unsafe fn _default_alloc(mut data: *mut c_void, mut cb: usize) -> *mut c_void { data; calloc(cb, 1usize) } -unsafe extern "C" fn _default_realloc( - mut data: *mut ::std::os::raw::c_void, - mut p: *mut ::std::os::raw::c_void, +unsafe fn _default_realloc( + mut data: *mut c_void, + mut p: *mut c_void, mut cb: usize, -) -> *mut ::std::os::raw::c_void { +) -> *mut c_void { data; realloc(p, cb) } -unsafe extern "C" fn _default_free( - mut data: *mut ::std::os::raw::c_void, - mut p: *mut ::std::os::raw::c_void, -) { +unsafe fn _default_free(mut data: *mut c_void, mut p: *mut c_void) { data; free(p); } -#[no_mangle] pub static mut _default_allocator: ykpiv_allocator = ykpiv_allocator { pfn_alloc: _default_alloc, pfn_realloc: _default_realloc, pfn_free: _default_free, - alloc_data: 0i32 as (*mut ::std::os::raw::c_void), + alloc_data: 0i32 as (*mut c_void), }; #[derive(Copy)] @@ -504,44 +491,7 @@ impl Clone for ykpiv_state { } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_alloc( - mut state: *mut ykpiv_state, - mut size: usize, -) -> *mut ::std::os::raw::c_void { - if state.is_null() || (*state).allocator.pfn_alloc == 0 { - 0i32 as (*mut ::std::os::raw::c_void) - } else { - ((*state).allocator.pfn_alloc)((*state).allocator.alloc_data, size) - } -} - -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_realloc( - mut state: *mut ykpiv_state, - mut address: *mut ::std::os::raw::c_void, - mut size: usize, -) -> *mut ::std::os::raw::c_void { - if state.is_null() || (*state).allocator.pfn_realloc == 0 { - 0i32 as (*mut ::std::os::raw::c_void) - } else { - ((*state).allocator.pfn_realloc)((*state).allocator.alloc_data, address, size) - } -} - -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_free( - mut state: *mut ykpiv_state, - mut data: *mut ::std::os::raw::c_void, -) { - if data.is_null() || state.is_null() || (*state).allocator.pfn_free == 0 { - } else { - ((*state).allocator.pfn_free)((*state).allocator.alloc_data, data); - } -} - -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usize) -> u32 { +pub fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usize) -> u32 { if length < 0x80usize { *{ let _old = buffer; @@ -581,8 +531,7 @@ pub unsafe extern "C" fn _ykpiv_set_length(mut buffer: *mut u8, mut length: usiz } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut usize) -> u32 { +pub fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut usize) -> u32 { if *buffer.offset(0isize) as (i32) < 0x81i32 { *len = *buffer.offset(0isize) as (usize); 1u32 @@ -598,8 +547,7 @@ pub unsafe extern "C" fn _ykpiv_get_length(mut buffer: *const u8, mut len: *mut } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len: usize) -> bool { +pub fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len: usize) -> bool { if *buffer.offset(0isize) as (i32) < 0x81i32 && (len > 0usize) { true } else if *buffer as (i32) & 0x7fi32 == 1i32 && (len > 1usize) { @@ -611,68 +559,32 @@ pub unsafe extern "C" fn _ykpiv_has_valid_length(mut buffer: *const u8, mut len: } } -#[derive(Clone, Copy)] -#[repr(i32)] -pub enum Enum5 { - YKPIV_OK = 0i32, - YKPIV_MEMORY_ERROR = -1i32, - YKPIV_PCSC_ERROR = -2i32, - YKPIV_SIZE_ERROR = -3i32, - YKPIV_APPLET_ERROR = -4i32, - YKPIV_AUTHENTICATION_ERROR = -5i32, - YKPIV_RANDOMNESS_ERROR = -6i32, - YKPIV_GENERIC_ERROR = -7i32, - YKPIV_KEY_ERROR = -8i32, - YKPIV_PARSE_ERROR = -9i32, - YKPIV_WRONG_PIN = -10i32, - YKPIV_INVALID_OBJECT = -11i32, - YKPIV_ALGORITHM_ERROR = -12i32, - YKPIV_PIN_LOCKED = -13i32, - YKPIV_ARGUMENT_ERROR = -14i32, - YKPIV_RANGE_ERROR = -15i32, - YKPIV_NOT_SUPPORTED = -16i32, -} - -#[no_mangle] -pub unsafe extern "C" fn ykpiv_init_with_allocator( +pub fn ykpiv_init_with_allocator( mut state: *mut *mut ykpiv_state, mut verbose: i32, mut allocator: *const ykpiv_allocator, -) -> Enum5 { +) -> ErrorKind { let mut s: *mut ykpiv_state; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*const ykpiv_allocator) == allocator - || (*allocator).pfn_alloc == 0 - || (*allocator).pfn_realloc == 0 - || (*allocator).pfn_free == 0 - { - Enum5::YKPIV_MEMORY_ERROR + if 0i32 as (*mut c_void) as (*mut *mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR } else { - s = ((*allocator).pfn_alloc)( - (*allocator).alloc_data, - ::std::mem::size_of::(), - ) as (*mut ykpiv_state); - (if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == s { - Enum5::YKPIV_MEMORY_ERROR + s = malloc(mem::size_of::()) as (*mut ykpiv_state); + + (if 0i32 as (*mut c_void) as (*mut ykpiv_state) == s { + ErrorKind::YKPIV_MEMORY_ERROR } else { - memset( - s as (*mut ::std::os::raw::c_void), - 0i32, - ::std::mem::size_of::(), - ); - (*s).pin = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + memset(s as (*mut c_void), 0i32, mem::size_of::()); + (*s).pin = 0i32 as (*mut c_void) as (*mut u8); (*s).allocator = *allocator; (*s).verbose = verbose; (*s).context = -1i32; *state = s; - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbose: i32) -> Enum5 { +pub fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbose: i32) -> ErrorKind { ykpiv_init_with_allocator( state, verbose, @@ -680,31 +592,25 @@ pub unsafe extern "C" fn ykpiv_init(mut state: *mut *mut ykpiv_state, mut verbos ) } -unsafe extern "C" fn _ykpiv_done(mut state: *mut ykpiv_state, mut disconnect: bool) -> Enum5 { +unsafe fn _ykpiv_done(mut state: *mut ykpiv_state, mut disconnect: bool) -> ErrorKind { if disconnect { ykpiv_disconnect(state); } - _cache_pin( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - 0usize, - ); - _ykpiv_free(state, state as (*mut ::std::os::raw::c_void)); - Enum5::YKPIV_OK + + _cache_pin(state, ptr::null(), 0usize); + free(state as *mut c_void); + ErrorKind::YKPIV_OK } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_done_with_external_card(mut state: *mut ykpiv_state) -> Enum5 { +pub fn ykpiv_done_with_external_card(mut state: *mut ykpiv_state) -> ErrorKind { _ykpiv_done(state, false) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_done(mut state: *mut ykpiv_state) -> Enum5 { +pub fn ykpiv_done(mut state: *mut ykpiv_state) -> ErrorKind { _ykpiv_done(state, true) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> Enum5 { +pub fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> ErrorKind { if (*state).card != 0 { SCardDisconnect((*state).card, 0x1u32); (*state).card = 0i32; @@ -713,16 +619,15 @@ pub unsafe extern "C" fn ykpiv_disconnect(mut state: *mut ykpiv_state) -> Enum5 SCardReleaseContext((*state).context); (*state).context = -1i32; } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_select_application(mut state: *mut ykpiv_state) -> Enum5 { - let mut apdu: u_APDU; +pub fn _ykpiv_select_application(mut state: *mut ykpiv_state) -> ErrorKind { + let mut apdu: APDU; let mut data: [u8; 255]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32); let mut sw: i32; - let mut res: Enum5 = Enum5::YKPIV_OK; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; // FIXME(tarcieri): translate APDU construction /* @@ -736,110 +641,92 @@ pub unsafe extern "C" fn _ykpiv_select_application(mut state: *mut ykpiv_state) if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); } res } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed selecting application: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed selecting application: {:04x}", sw); } - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { - res = _ykpiv_get_version( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_version_t), - ); - if res as (i32) != Enum5::YKPIV_OK as (i32) { + res = _ykpiv_get_version(state, 0i32 as (*mut c_void) as (*mut _ykpiv_version_t)); + if res as (i32) != ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to retrieve version: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), - ); + eprintln!("Failed to retrieve version: \'{}\'", ykpiv_strerror(res)); } } - res = _ykpiv_get_serial( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32), - false, - ); - if res as (i32) != Enum5::YKPIV_OK as (i32) { + res = _ykpiv_get_serial(state, 0i32 as (*mut c_void) as (*mut u32), false); + if res as (i32) != ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to retrieve serial number: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed to retrieve serial number: \'{}\'", + ykpiv_strerror(res) ); } - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } res } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_ensure_application_selected(mut state: *mut ykpiv_state) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn _ykpiv_ensure_application_selected(mut state: *mut ykpiv_state) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; state; res } -unsafe extern "C" fn _ykpiv_connect( +unsafe fn _ykpiv_connect( mut state: *mut ykpiv_state, mut context: usize, mut card: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR } else if context != (*state).context as (usize) && (0x0i32 != SCardIsValidContext(context as (i32))) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { if card != (*state).card as (usize) { let mut reader: [u8; 3072]; - let mut reader_len: u32 = ::std::mem::size_of::<[u8; 3072]>() as (u32); + let mut reader_len: u32 = mem::size_of::<[u8; 3072]>() as (u32); let mut atr: [u8; 33]; - let mut atr_len: u32 = ::std::mem::size_of::<[u8; 33]>() as (u32); + let mut atr_len: u32 = mem::size_of::<[u8; 33]>() as (u32); if 0x0i32 != SCardStatus( card as (i32), reader.as_mut_ptr(), &mut reader_len as (*mut u32), - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32), - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u32), + 0i32 as (*mut c_void) as (*mut u32), + 0i32 as (*mut c_void) as (*mut u32), atr.as_mut_ptr(), &mut atr_len as (*mut u32), ) { - return Enum5::YKPIV_PCSC_ERROR; + return ErrorKind::YKPIV_PCSC_ERROR; } else { - (*state).isNEO = ::std::mem::size_of::<[u8; 23]>().wrapping_sub(1usize) + (*state).isNEO = mem::size_of::<[u8; 23]>().wrapping_sub(1usize) == atr_len as (usize) && (0i32 == memcmp( (*b";\xFC\x13\0\0\x811\xFE\x15YubikeyNEOr3\xE1\0").as_ptr() - as (*const ::std::os::raw::c_void), - atr.as_mut_ptr() as (*const ::std::os::raw::c_void), + as (*const c_void), + atr.as_mut_ptr() as (*const c_void), atr_len as (usize), )); } @@ -850,33 +737,28 @@ unsafe extern "C" fn _ykpiv_connect( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_connect_with_external_card( +pub fn ykpiv_connect_with_external_card( mut state: *mut ykpiv_state, mut context: usize, mut card: usize, -) -> Enum5 { +) -> ErrorKind { _ykpiv_connect(state, context, card) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_connect( - mut state: *mut ykpiv_state, - mut wanted: *const u8, -) -> Enum5 { +pub fn ykpiv_connect(mut state: *mut ykpiv_state, mut wanted: *const c_char) -> ErrorKind { let mut _currentBlock; let mut active_protocol: u32; - let mut reader_buf: [u8; 2048]; - let mut num_readers: usize = ::std::mem::size_of::<[u8; 2048]>(); + let mut reader_buf: [c_char; 2048]; + let mut num_readers: usize = mem::size_of::<[u8; 2048]>(); let mut rc: isize; - let mut reader_ptr: *mut u8; + let mut reader_ptr: *mut c_char; let mut card: i32 = -1i32; - let mut ret: Enum5 = ykpiv_list_readers( + let mut ret: ErrorKind = ykpiv_list_readers( state, reader_buf.as_mut_ptr(), &mut num_readers as (*mut usize), ); - if ret as (i32) != Enum5::YKPIV_OK as (i32) { + if ret as (i32) != ErrorKind::YKPIV_OK as (i32) { ret } else { reader_ptr = reader_buf.as_mut_ptr(); @@ -886,14 +768,14 @@ pub unsafe extern "C" fn ykpiv_connect( break; } if !wanted.is_null() { - let mut ptr: *mut u8 = reader_ptr; + let mut ptr = reader_ptr as *const c_char; let mut found: bool = false; 'loop10: loop { - if strlen(ptr as (*const u8)) < strlen(wanted) { + if strlen(ptr) < strlen(wanted) { _currentBlock = 14; break; } - if strncasecmp(ptr as (*const u8), wanted, strlen(wanted)) == 0i32 { + if strncasecmp(ptr, wanted, strlen(wanted)) == 0i32 { _currentBlock = 13; break; } @@ -912,12 +794,10 @@ pub unsafe extern "C" fn ykpiv_connect( } if found as (i32) == 0i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"skipping reader \'%s\' since it doesn\'t match \'%s\'.\n\0") - .as_ptr(), - reader_ptr, - wanted, + eprintln!( + "skipping reader \'{}\' since it doesn\'t match \'{}\'.", + CStr::from_ptr(reader_ptr).to_string_lossy(), + CStr::from_ptr(wanted).to_string_lossy() ); _currentBlock = 26; } else { @@ -931,15 +811,14 @@ pub unsafe extern "C" fn ykpiv_connect( } if _currentBlock == 15 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"trying to connect to reader \'%s\'.\n\0").as_ptr(), - reader_ptr, + eprintln!( + "trying to connect to reader \'{}\'.", + CStr::from_ptr(reader_ptr).to_string_lossy() ); } rc = SCardConnect( (*state).context, - reader_ptr as (*const u8), + reader_ptr as *const c_char, 0x2u32, 0x2u32, &mut card as (*mut i32), @@ -947,39 +826,34 @@ pub unsafe extern "C" fn ykpiv_connect( ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"SCardConnect failed, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("SCardConnect failed, rc={}", rc); } - } else if Enum5::YKPIV_OK as (i32) + } else if ErrorKind::YKPIV_OK as (i32) == _ykpiv_connect(state, (*state).context as (usize), card as (usize)) as (i32) { _currentBlock = 19; break; } } - reader_ptr = reader_ptr - .offset(strlen(reader_ptr as (*const u8)).wrapping_add(1usize) as (isize)); + reader_ptr = reader_ptr.offset(strlen(reader_ptr).wrapping_add(1usize) as (isize)); } (if _currentBlock == 3 { (if *reader_ptr as (i32) == b'\0' as (i32) { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"error: no usable reader found.\n\0").as_ptr()); + eprintln!("error: no usable reader found."); } SCardReleaseContext((*state).context); (*state).context = -1i32; - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) - } else if Enum5::YKPIV_OK as (i32) != { + } else if ErrorKind::YKPIV_OK as (i32) != { ret = _ykpiv_begin_transaction(state); ret } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { ret = _ykpiv_select_application(state); _ykpiv_end_transaction(state); @@ -988,49 +862,40 @@ pub unsafe extern "C" fn ykpiv_connect( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_list_readers( +pub fn ykpiv_list_readers( mut state: *mut ykpiv_state, - mut readers: *mut u8, + mut readers: *mut c_char, mut len: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut num_readers: u32 = 0u32; let mut rc: isize; if SCardIsValidContext((*state).context) != 0x0i32 { rc = SCardEstablishContext( 0x2u32, - 0i32 as (*mut ::std::os::raw::c_void) as (*const ::std::os::raw::c_void), - 0i32 as (*mut ::std::os::raw::c_void) as (*const ::std::os::raw::c_void), + 0i32 as (*mut c_void) as (*const c_void), + 0i32 as (*mut c_void) as (*const c_void), &mut (*state).context as (*mut i32), ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"error: SCardEstablishContext failed, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("error: SCardEstablishContext failed, rc={}", rc); } - return Enum5::YKPIV_PCSC_ERROR; + return ErrorKind::YKPIV_PCSC_ERROR; } } rc = SCardListReaders( (*state).context, - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + ptr::null(), + ptr::null_mut(), &mut num_readers as (*mut u32), ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"error: SCardListReaders failed, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("error: SCardListReaders failed, rc={}", rc); } SCardReleaseContext((*state).context); (*state).context = -1i32; - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { if num_readers as (usize) > *len { num_readers = *len as (u32); @@ -1039,38 +904,31 @@ pub unsafe extern "C" fn ykpiv_list_readers( } rc = SCardListReaders( (*state).context, - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), + ptr::null(), readers, &mut num_readers as (*mut u32), ) as (isize); (if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"error: SCardListReaders failed, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("error: SCardListReaders failed, rc={}", rc); } SCardReleaseContext((*state).context); (*state).context = -1i32; - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { *len = num_readers as (usize); - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) } } -unsafe extern "C" fn reconnect(mut state: *mut ykpiv_state) -> Enum5 { +unsafe fn reconnect(mut state: *mut ykpiv_state) -> ErrorKind { let mut active_protocol: u32 = 0u32; let mut rc: isize; - let mut res: Enum5; + let mut res: ErrorKind; let mut tries: i32; if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"trying to reconnect to current reader.\n\0").as_ptr(), - ); + eprintln!("trying to reconnect to current reader."); } rc = SCardReconnect( (*state).card, @@ -1081,38 +939,37 @@ unsafe extern "C" fn reconnect(mut state: *mut ykpiv_state) -> Enum5 { ) as (isize); if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"SCardReconnect failed, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("SCardReconnect failed, rc={}", rc); } - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else if { res = _ykpiv_select_application(state); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { res } else if !(*state).pin.is_null() { - ykpiv_verify(state, (*state).pin as (*const u8), &mut tries as (*mut i32)) + ykpiv_verify( + state, + (*state).pin as *const c_char, + &mut tries as (*mut i32), + ) } else { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -> Enum5 { +pub fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) -> ErrorKind { let mut rc: isize; rc = SCardBeginTransaction((*state).card) as (isize); if (rc as (usize) & 0xffffffffusize) as (isize) as (usize) == 0x80100068usize { - let mut res: Enum5 = Enum5::YKPIV_OK; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; if { res = reconnect(state); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { return res; } else { @@ -1121,35 +978,25 @@ pub unsafe extern "C" fn _ykpiv_begin_transaction(mut state: *mut ykpiv_state) - } if rc != 0x0isize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"error: Failed to begin pcsc transaction, rc=%08lx\n\0").as_ptr(), - rc, - ); + eprintln!("error: Failed to begin pcsc transaction, rc={}", rc); } - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_end_transaction(mut state: *mut ykpiv_state) -> Enum5 { +pub fn _ykpiv_end_transaction(mut state: *mut ykpiv_state) -> ErrorKind { let mut rc: isize = SCardEndTransaction((*state).card, 0x0u32) as (isize); if rc != 0x0isize && ((*state).verbose != 0) { - fprintf( - __stderrp, - (*b"error: Failed to end pcsc transaction, rc=%08lx\n\0").as_ptr(), - rc, - ); - Enum5::YKPIV_PCSC_ERROR + eprintln!("error: Failed to end pcsc transaction, rc={}", rc); + ErrorKind::YKPIV_PCSC_ERROR } else { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_transfer_data( +pub fn _ykpiv_transfer_data( mut state: *mut ykpiv_state, mut templ: *const u8, mut in_data: *const u8, @@ -1157,47 +1004,48 @@ pub unsafe extern "C" fn _ykpiv_transfer_data( mut out_data: *mut u8, mut out_len: *mut usize, mut sw: *mut i32, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut in_ptr: *const u8 = in_data; let mut max_out: usize = *out_len; - let mut res: Enum5; + let mut res: ErrorKind; + let mut recv_len: u32; *out_len = 0usize; 'loop1: loop { let mut this_size: usize = 0xffusize; let mut data: [u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); - let mut apdu: u_APDU; - // FIXME(tarcieri): translate APDU code - /* - memset(apdu.raw, 0, sizeof(apdu.raw)); - memcpy(apdu.raw, templ, 4); - if(in_ptr + 0xff < in_data + in_len) { - apdu.st.cla = 0x10; + recv_len = mem::size_of::<[u8; 261]>() as (u32); + let mut apdu = APDU::default(); + apdu.cla = *templ; + apdu.ins = *templ.offset(1); + apdu.p1 = *templ.offset(2); + apdu.p2 = *templ.offset(3); + + if in_ptr.offset(0xff) < in_data.offset(in_len) { + apdu.cla = 0x10; } else { - this_size = (size_t)((in_data + in_len) - in_ptr); + this_size = in_data.offset(in_len) as usize - in_ptr as usize; } - */ + if (*state).verbose > 2i32 { - fprintf( - __stderrp, - (*b"Going to send %lu bytes in this go.\n\0").as_ptr(), - this_size, - ); + eprintln!("Going to send {} bytes in this go.", this_size); } - // FIXME(tarcieri): translate APDU code - /* - apdu.st.lc = (unsigned char)this_size; - memcpy(apdu.st.data, in_ptr, this_size); - */ + + apdu.lc = this_size.try_into().unwrap(); + memcpy( + apdu.data.as_mut_ptr() as *mut c_void, + in_ptr as *const c_void, + this_size, + ); + res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), sw, ); - if res as (i32) != Enum5::YKPIV_OK as (i32) { + if res as (i32) != ErrorKind::YKPIV_OK as (i32) { _currentBlock = 24; break; } @@ -1215,8 +1063,8 @@ pub unsafe extern "C" fn _ykpiv_transfer_data( } if !out_data.is_null() { memcpy( - out_data as (*mut ::std::os::raw::c_void), - data.as_mut_ptr() as (*const ::std::os::raw::c_void), + out_data as (*mut c_void), + data.as_mut_ptr() as (*const c_void), recv_len.wrapping_sub(2u32) as (usize), ); out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize)); @@ -1234,29 +1082,25 @@ pub unsafe extern "C" fn _ykpiv_transfer_data( _currentBlock = 24; break; } - let mut apdu: u_APDU; let mut data: [u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + recv_len = mem::size_of::<[u8; 261]>() as (u32); if (*state).verbose > 2i32 { - fprintf( - __stderrp, - (*b"The card indicates there is %d bytes more data for us.\n\0").as_ptr(), - *sw & 0xffi32, + eprintln!( + "The card indicates there is {} bytes more data for us.", + *sw & 0xffi32 ); } - // FIXME(tarcieri): translate APDU code - /* - memset(apdu.raw, 0, sizeof(apdu.raw)); - apdu.st.ins = YKPIV_INS_GET_RESPONSE_APDU; - */ + + let mut apdu = APDU::default(); + apdu.ins = YKPIV_INS_GET_RESPONSE_APDU; res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), sw, ); - if res as (i32) != Enum5::YKPIV_OK as (i32) { + if res as (i32) != ErrorKind::YKPIV_OK as (i32) { _currentBlock = 24; break; } @@ -1276,8 +1120,8 @@ pub unsafe extern "C" fn _ykpiv_transfer_data( continue; } memcpy( - out_data as (*mut ::std::os::raw::c_void), - data.as_mut_ptr() as (*const ::std::os::raw::c_void), + out_data as (*mut c_void), + data.as_mut_ptr() as (*const c_void), recv_len.wrapping_sub(2u32) as (usize), ); out_data = out_data.offset(recv_len.wrapping_sub(2u32) as (isize)); @@ -1286,35 +1130,32 @@ pub unsafe extern "C" fn _ykpiv_transfer_data( if _currentBlock == 24 { } else { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Output buffer to small, wanted to write %lu, max was %lu.\0").as_ptr(), + eprintln!( + "Output buffer to small, wanted to write {}, max was {}.", (*out_len) .wrapping_add(recv_len as (usize)) .wrapping_sub(2usize), - max_out, + max_out ); } - res = Enum5::YKPIV_SIZE_ERROR; + res = ErrorKind::YKPIV_SIZE_ERROR; } } else if _currentBlock == 21 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Output buffer to small, wanted to write %lu, max was %lu.\n\0").as_ptr(), + eprintln!( + "Output buffer to small, wanted to write {}, max was {}.", (*out_len) .wrapping_add(recv_len as (usize)) .wrapping_sub(2usize), - max_out, + max_out ); } - res = Enum5::YKPIV_SIZE_ERROR; + res = ErrorKind::YKPIV_SIZE_ERROR; } res } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_transfer_data( +pub fn ykpiv_transfer_data( mut state: *mut ykpiv_state, mut templ: *const u8, mut in_data: *const u8, @@ -1322,16 +1163,16 @@ pub unsafe extern "C" fn ykpiv_transfer_data( mut out_data: *mut u8, mut out_len: *mut usize, mut sw: *mut i32, -) -> Enum5 { - let mut res: Enum5; +) -> ErrorKind { + let mut res: ErrorKind; if { res = _ykpiv_begin_transaction(state); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { *out_len = 0usize; - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { res = _ykpiv_transfer_data(state, templ, in_data, in_len, out_data, out_len, sw); _ykpiv_end_transaction(state); @@ -1339,30 +1180,25 @@ pub unsafe extern "C" fn ykpiv_transfer_data( } } -unsafe extern "C" fn dump_hex(mut buf: *const u8, mut len: u32) { +unsafe fn dump_hex(mut buf: *const u8, mut len: u32) { let mut i: u32; i = 0u32; 'loop1: loop { if !(i < len) { break; } - fprintf( - __stderrp, - (*b"%02x \0").as_ptr(), - *buf.offset(i as (isize)) as (i32), - ); + eprintln!("{:02x} ", *buf.offset(i as (isize)) as (i32)); i = i.wrapping_add(1u32); } } -#[no_mangle] -pub unsafe extern "C" fn _send_data( +pub fn _send_data( mut state: *mut ykpiv_state, - mut apdu: *mut u_APDU, + mut apdu: *mut APDU, mut data: *mut u8, mut recv_len: *mut u32, mut sw: *mut i32, -) -> Enum5 { +) -> ErrorKind { let mut rc: isize; // FIXME(tarcieri): `send_len` is NOT supposed to be 0. Translate C code let mut send_len: u32 = 0u32; // (unsigned int)apdu->st.lc + 5; @@ -1387,9 +1223,9 @@ pub unsafe extern "C" fn _send_data( *recv_len = tmp_len; if (*state).verbose > 1i32 { - fprintf(__stderrp, (*b"< \0").as_ptr()); + eprint!("< "); dump_hex(data as (*const u8), *recv_len); - fprintf(__stderrp, (*b"\n\0").as_ptr()); + eprintln!(); } if *recv_len >= 2u32 { *sw = *data.offset((*recv_len).wrapping_sub(2u32) as (isize)) as (i32) << 8i32 @@ -1397,11 +1233,12 @@ pub unsafe extern "C" fn _send_data( } else { *sw = 0i32; } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } #[derive(Clone, Copy)] #[repr(i32)] +#[allow(non_camel_case_types)] pub enum Enum6 { DES_OK = 0i32, DES_INVALID_PARAMETER = -1i32, @@ -1410,35 +1247,31 @@ pub enum Enum6 { DES_GENERAL_ERROR = -4i32, } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_authenticate( - mut state: *mut ykpiv_state, - mut key: *const u8, -) -> Enum5 { - let mut apdu: u_APDU; +pub fn ykpiv_authenticate(mut state: *mut ykpiv_state, mut key: *const u8) -> ErrorKind { + let mut apdu: APDU; let mut data: [u8; 261]; let mut challenge: [u8; 8]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32); let mut sw: i32; - let mut res: Enum5; + let mut res: ErrorKind; let mut drc: Enum6 = Enum6::DES_OK; - let mut mgm_key: *mut des_key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut des_key); + let mut mgm_key: *mut DesKey = 0i32 as (*mut c_void) as (*mut DesKey); let mut out_len: usize = 0usize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) == key { + if 0i32 as (*mut c_void) as (*const u8) == key { key = (*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").as_ptr( ); } @@ -1447,10 +1280,10 @@ pub unsafe extern "C" fn ykpiv_authenticate( 1i32, key, (8i32 * 3i32) as (usize), - &mut mgm_key as (*mut *mut des_key), + &mut mgm_key as (*mut *mut DesKey), ) as (i32) { - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; } else { // get a challenge from the card // FIXME(tarcieri): Translate C code below @@ -1522,25 +1355,25 @@ pub unsafe extern "C" fn ykpiv_authenticate( } */ let mut response: [u8; 8]; - out_len = ::std::mem::size_of::<[u8; 8]>(); + out_len = mem::size_of::<[u8; 8]>(); drc = des_encrypt( mgm_key, challenge.as_mut_ptr() as (*const u8), - ::std::mem::size_of::<[u8; 8]>(), + mem::size_of::<[u8; 8]>(), response.as_mut_ptr(), &mut out_len as (*mut usize), ); if drc as (i32) != Enum6::DES_OK as (i32) { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } else if memcmp( - response.as_mut_ptr() as (*const ::std::os::raw::c_void), - data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void), + response.as_mut_ptr() as (*const c_void), + data.as_mut_ptr().offset(4isize) as (*const c_void), 8usize, ) == 0i32 { - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } } } @@ -1552,159 +1385,143 @@ pub unsafe extern "C" fn ykpiv_authenticate( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_set_mgmkey( - mut state: *mut ykpiv_state, - mut new_key: *const u8, -) -> Enum5 { +pub fn ykpiv_set_mgmkey(mut state: *mut ykpiv_state, mut new_key: *const u8) -> ErrorKind { ykpiv_set_mgmkey2(state, new_key, 0u8) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_set_mgmkey2( +pub fn ykpiv_set_mgmkey2( mut state: *mut ykpiv_state, mut new_key: *const u8, touch: u8, -) -> Enum5 { - let mut apdu: u_APDU; +) -> ErrorKind { let mut data: [u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32); let mut sw: i32; - let mut res: Enum5 = Enum5::YKPIV_OK; - if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) - { - if yk_des_is_weak_key(new_key, (8i32 * 3i32) as (usize)) { - if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Won\'t set new key \'\0").as_ptr()); - dump_hex(new_key, (8i32 * 3i32) as (u32)); - fprintf( - __stderrp, - (*b"\' since it\'s weak (with odd parity).\n\0").as_ptr(), - ); - } - res = Enum5::YKPIV_KEY_ERROR; - // FIXME(tarcieri): Translate C code below (should go after else clause) - /* - memset(apdu.raw, 0, sizeof(apdu)); - apdu.st.ins = YKPIV_INS_SET_MGMKEY; - apdu.st.p1 = 0xff; - if (touch == 0) { - apdu.st.p2 = 0xff; - } - else if (touch == 1) { - apdu.st.p2 = 0xfe; - } - else { - res = YKPIV_GENERIC_ERROR; - goto Cleanup; - } + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut apdu = APDU::default(); - apdu.st.lc = DES_LEN_3DES + 3; - apdu.st.data[0] = YKPIV_ALGO_3DES; - apdu.st.data[1] = YKPIV_KEY_CARDMGM; - apdu.st.data[2] = DES_LEN_3DES; - memcpy(apdu.st.data + 3, new_key, DES_LEN_3DES); - */ - } else if !({ - res = _send_data( - state, - &mut apdu as (*mut u_APDU), - data.as_mut_ptr(), - &mut recv_len as (*mut u32), - &mut sw as (*mut i32), - ); - res - } as (i32) - != Enum5::YKPIV_OK as (i32)) - { + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; + } + + if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK { + if yk_des_is_weak_key(new_key, (8i32 * 3i32) as (usize)) { + if (*state).verbose != 0 { + // TODO(tarcieri): format string + eprint!("Won\'t set new key \'"); + dump_hex(new_key, DES_LEN_3DES as u32); + eprintln!("\' since it\'s weak (with odd parity)."); + } + res = ErrorKind::YKPIV_KEY_ERROR; + apdu.ins = YKPIV_INS_SET_MGMKEY; + apdu.p1 = 0xff; + + apdu.p2 = match touch { + 0 => 0xff, + 1 => 0xfe, + _ => { + _ykpiv_end_transaction(state); + return ErrorKind::YKPIV_GENERIC_ERROR; + } + }; + + apdu.lc = DES_LEN_3DES as u8 + 3; + apdu.data[0] = YKPIV_ALGO_3DES; + apdu.data[1] = YKPIV_KEY_CARDMGM; + apdu.data[2] = DES_LEN_3DES as u8; + memcpy( + apdu.data.as_mut_ptr().offset(3) as *mut c_void, + new_key as *const c_void, + DES_LEN_3DES, + ); + } else { + res = _send_data( + state, + &mut apdu as (*mut APDU), + data.as_mut_ptr(), + &mut recv_len as (*mut u32), + &mut sw as (*mut i32), + ); + + if res != ErrorKind::YKPIV_OK { if !(sw == 0x9000i32) { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } } } - memset_s( - &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::(), - 0i32, - ::std::mem::size_of::(), - ); - _ykpiv_end_transaction(state); - res } + + apdu.zeroize(); + _ykpiv_end_transaction(state); + res } -static mut hex_translate: *mut u8 = (*b"0123456789abcdef\0").as_ptr() as (*mut u8); +const HEX_TABLE: &[u8] = b"0123456789abcdef"; -#[no_mangle] -pub unsafe extern "C" fn ykpiv_hex_decode( +pub fn ykpiv_hex_decode( mut hex_in: *const u8, mut in_len: usize, mut hex_out: *mut u8, mut out_len: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut i: usize; let mut first: bool = true; - if *out_len < in_len.wrapping_div(2usize) { - Enum5::YKPIV_SIZE_ERROR - } else if in_len.wrapping_rem(2usize) != 0usize { - Enum5::YKPIV_SIZE_ERROR - } else { - *out_len = in_len.wrapping_div(2usize); - i = 0usize; - 'loop3: loop { - if !(i < in_len) { - _currentBlock = 4; - break; - } - let mut ind_ptr: *mut u8 = strchr( - hex_translate as (*const u8), - tolower(*{ - let _old = hex_in; - hex_in = hex_in.offset(1isize); - _old - } as (i32)), - ); - let mut index: i32 = 0i32; - if ind_ptr.is_null() { - _currentBlock = 6; - break; - } - index = ((ind_ptr as (isize)).wrapping_sub(hex_translate as (isize)) - / ::std::mem::size_of::() as (isize)) as (i32); - if first { - *hex_out = (index << 4i32) as (u8); - } else { - let _rhs = index; - let _lhs = &mut *{ - let _old = hex_out; - hex_out = hex_out.offset(1isize); - _old - }; - *_lhs = (*_lhs as (i32) | _rhs) as (u8); - } - first = !first; - i = i.wrapping_add(1usize); + + if *out_len < in_len.wrapping_div(2) { + return ErrorKind::YKPIV_SIZE_ERROR; + } + + if in_len.wrapping_rem(2) != 0 { + return ErrorKind::YKPIV_SIZE_ERROR; + } + + *out_len = in_len.wrapping_div(2usize); + i = 0usize; + + while i < in_len { + let mut ind_ptr: *mut c_char = strchr( + HEX_TABLE.as_ptr() as *const c_char, + tolower(*{ + let _old = hex_in; + hex_in = hex_in.offset(1isize); + _old + } as (i32)), + ); + + if ind_ptr.is_null() { + _currentBlock = 6; + break; } - (if _currentBlock == 4 { - Enum5::YKPIV_OK + + let index = ind_ptr as usize - HEX_TABLE.as_ptr() as usize; + + if first { + *hex_out = (index << 4i32) as (u8); } else { - Enum5::YKPIV_PARSE_ERROR - }) + let _rhs = index; + + let _lhs = &mut *{ + let _old = hex_out; + hex_out = hex_out.offset(1isize); + _old + }; + + *_lhs = (*_lhs as usize | _rhs) as (u8); + } + + first = !first; + i = i.wrapping_add(1usize); + } + + if _currentBlock == 4 { + ErrorKind::YKPIV_OK + } else { + ErrorKind::YKPIV_PARSE_ERROR } } -unsafe extern "C" fn _general_authenticate( +unsafe fn _general_authenticate( mut state: *mut ykpiv_state, mut sign_in: *const u8, mut in_len: usize, @@ -1713,18 +1530,18 @@ unsafe extern "C" fn _general_authenticate( mut algorithm: u8, mut key: u8, mut decipher: bool, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut indata: [u8; 1024]; let mut dataptr: *mut u8 = indata.as_mut_ptr(); let mut data: [u8; 1024]; let mut templ: *mut u8 = 0i32 as (*mut u8); - let mut recv_len: usize = ::std::mem::size_of::<[u8; 1024]>(); + let mut recv_len: usize = mem::size_of::<[u8; 1024]>(); let mut key_len: usize = 0usize; let mut sw: i32 = 0i32; let mut bytes: usize; let mut len: usize = 0usize; - let mut res: Enum5; + let mut res: ErrorKind; if algorithm as (i32) == 0x14i32 { _currentBlock = 12; } else if algorithm as (i32) == 0x11i32 { @@ -1735,14 +1552,14 @@ unsafe extern "C" fn _general_authenticate( if algorithm as (i32) == 0x6i32 { key_len = 128usize; } else { - return Enum5::YKPIV_ALGORITHM_ERROR; + return ErrorKind::YKPIV_ALGORITHM_ERROR; } } if key_len == 0usize { key_len = 256usize; } if in_len != key_len { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } else { _currentBlock = 16; } @@ -1752,9 +1569,9 @@ unsafe extern "C" fn _general_authenticate( key_len = 48usize; } if !decipher && (in_len > key_len) { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } else if decipher && (in_len != key_len.wrapping_mul(2usize).wrapping_add(1usize)) { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } } if in_len < 0x80usize { @@ -1793,11 +1610,7 @@ unsafe extern "C" fn _general_authenticate( 0x81i32 } as (u8); dataptr = dataptr.offset(_ykpiv_set_length(dataptr, in_len) as (isize)); - memcpy( - dataptr as (*mut ::std::os::raw::c_void), - sign_in as (*const ::std::os::raw::c_void), - in_len, - ); + memcpy(dataptr as (*mut c_void), sign_in as (*const c_void), in_len); dataptr = dataptr.offset(in_len as (isize)); if { res = ykpiv_transfer_data( @@ -1805,81 +1618,60 @@ unsafe extern "C" fn _general_authenticate( templ as (*const u8), indata.as_mut_ptr() as (*const u8), (dataptr as (isize)).wrapping_sub(indata.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize), + / mem::size_of::() as (isize), data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Sign command failed to communicate.\n\0").as_ptr(), - ); + eprintln!("Sign command failed to communicate."); } res } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed sign command with code %x.\n\0").as_ptr(), - sw, - ); + eprintln!("Failed sign command with code {:x}.\n\0", sw); } (if sw == 0x6982i32 { - Enum5::YKPIV_AUTHENTICATION_ERROR + ErrorKind::YKPIV_AUTHENTICATION_ERROR } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) } else if data[0usize] as (i32) != 0x7ci32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed parsing signature reply.\n\0").as_ptr(), - ); + eprintln!("Failed parsing signature reply."); } - Enum5::YKPIV_PARSE_ERROR + ErrorKind::YKPIV_PARSE_ERROR } else { dataptr = data.as_mut_ptr().offset(1isize); - dataptr = dataptr - .offset(_ykpiv_get_length(dataptr as (*const u8), &mut len as (*mut usize)) as (isize)); + dataptr = dataptr.offset(_ykpiv_get_length(dataptr, &mut len as (*mut usize)) as (isize)); (if *dataptr as (i32) != 0x82i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed parsing signature reply.\n\0").as_ptr(), - ); + eprintln!("Failed parsing signature reply."); } - Enum5::YKPIV_PARSE_ERROR + ErrorKind::YKPIV_PARSE_ERROR } else { dataptr = dataptr.offset(1isize); - dataptr = dataptr - .offset( - _ykpiv_get_length(dataptr as (*const u8), &mut len as (*mut usize)) as (isize), - ); + dataptr = + dataptr.offset(_ykpiv_get_length(dataptr, &mut len as (*mut usize)) as (isize)); (if len > *out_len { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Wrong size on output buffer.\n\0").as_ptr()); + eprintln!("Wrong size on output buffer."); } - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { *out_len = len; - memcpy( - out as (*mut ::std::os::raw::c_void), - dataptr as (*const ::std::os::raw::c_void), - len, - ); - Enum5::YKPIV_OK + memcpy(out as (*mut c_void), dataptr as (*const c_void), len); + ErrorKind::YKPIV_OK }) }) } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_sign_data( +pub fn ykpiv_sign_data( mut state: *mut ykpiv_state, mut raw_in: *const u8, mut in_len: usize, @@ -1887,16 +1679,16 @@ pub unsafe extern "C" fn ykpiv_sign_data( mut out_len: *mut usize, mut algorithm: u8, mut key: u8, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { res = _general_authenticate( state, raw_in, in_len, sign_out, out_len, algorithm, key, false, @@ -1906,8 +1698,7 @@ pub unsafe extern "C" fn ykpiv_sign_data( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_decipher_data( +pub fn ykpiv_decipher_data( mut state: *mut ykpiv_state, mut in_: *const u8, mut in_len: usize, @@ -1915,16 +1706,16 @@ pub unsafe extern "C" fn ykpiv_decipher_data( mut out_len: *mut usize, mut algorithm: u8, mut key: u8, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { res = _general_authenticate(state, in_, in_len, out, out_len, algorithm, key, true); _ykpiv_end_transaction(state); @@ -1932,26 +1723,26 @@ pub unsafe extern "C" fn ykpiv_decipher_data( } } -unsafe extern "C" fn _ykpiv_get_version( +unsafe fn _ykpiv_get_version( mut state: *mut ykpiv_state, mut p_version: *mut _ykpiv_version_t, -) -> Enum5 { - let mut apdu: u_APDU; +) -> ErrorKind { + let mut apdu: APDU; let mut data: [u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32); let mut sw: i32; - let mut res: Enum5; + let mut res: ErrorKind; if state.is_null() { - Enum5::YKPIV_ARGUMENT_ERROR + ErrorKind::YKPIV_ARGUMENT_ERROR } else if (*state).ver.major != 0 || (*state).ver.minor != 0 || (*state).ver.patch != 0 { if !p_version.is_null() { memcpy( - p_version as (*mut ::std::os::raw::c_void), - &mut (*state).ver as (*mut _ykpiv_version_t) as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<_ykpiv_version_t>(), + p_version as (*mut c_void), + &mut (*state).ver as (*mut _ykpiv_version_t) as (*const c_void), + mem::size_of::<_ykpiv_version_t>(), ); } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK // get version from device // FIXME(tarcieri): Translate C code below (should go after the else clause) /* @@ -1961,47 +1752,45 @@ unsafe extern "C" fn _ykpiv_get_version( } else if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { res } else { if sw == 0x9000i32 { if recv_len < 3u32 { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } else { (*state).ver.major = data[0usize]; (*state).ver.minor = data[1usize]; (*state).ver.patch = data[2usize]; if !p_version.is_null() { memcpy( - p_version as (*mut ::std::os::raw::c_void), - &mut (*state).ver as (*mut _ykpiv_version_t) - as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<_ykpiv_version_t>(), + p_version as (*mut c_void), + &mut (*state).ver as (*mut _ykpiv_version_t) as (*const c_void), + mem::size_of::<_ykpiv_version_t>(), ); } } } else { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_get_version( +pub fn ykpiv_get_version( mut state: *mut ykpiv_state, mut version: *mut u8, mut len: usize, -) -> Enum5 { - let mut res: Enum5; +) -> ErrorKind { + let mut res: ErrorKind; let mut result: i32 = 0i32; let mut ver: _ykpiv_version_t = _ykpiv_version_t { major: 0u8, @@ -2012,21 +1801,21 @@ pub unsafe extern "C" fn ykpiv_get_version( res = _ykpiv_begin_transaction(state); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { if !({ res = _ykpiv_ensure_application_selected(state); res } as (i32) - < Enum5::YKPIV_OK as (i32)) + < ErrorKind::YKPIV_OK as (i32)) { if { res = _ykpiv_get_version(state, &mut ver as (*mut _ykpiv_version_t)); res } as (i32) - >= Enum5::YKPIV_OK as (i32) + >= ErrorKind::YKPIV_OK as (i32) { result = snprintf( version, @@ -2037,7 +1826,7 @@ pub unsafe extern "C" fn ykpiv_get_version( ver.patch as (i32), ); if result < 0i32 { - res = Enum5::YKPIV_SIZE_ERROR; + res = ErrorKind::YKPIV_SIZE_ERROR; } } } @@ -2046,30 +1835,30 @@ pub unsafe extern "C" fn ykpiv_get_version( } } -unsafe extern "C" fn _ykpiv_get_serial( +unsafe fn _ykpiv_get_serial( mut state: *mut ykpiv_state, mut p_serial: *mut u32, mut f_force: bool, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut apdu: u_APDU; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut apdu: APDU; let mut yk_applet: *const u8 = 0xa0i32 as (*const u8); let mut data: [u8; 255]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32); let mut sw: i32; - let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut p_temp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); if state.is_null() { - Enum5::YKPIV_ARGUMENT_ERROR + ErrorKind::YKPIV_ARGUMENT_ERROR } else if !f_force && ((*state).serial != 0u32) { if !p_serial.is_null() { *p_serial = (*state).serial; } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else { if (*state).ver.major as (i32) < 5i32 { let mut temp: [u8; 255]; - recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32); + recv_len = mem::size_of::<[u8; 255]>() as (u32); // FIXME(tarcieri): Translate C code below /* memset(apdu.raw, 0, sizeof(apdu)); @@ -2081,20 +1870,19 @@ unsafe extern "C" fn _ykpiv_get_serial( if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), temp.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); _currentBlock = 37; } else { @@ -2102,16 +1890,12 @@ unsafe extern "C" fn _ykpiv_get_serial( } } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed selecting yk application: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed selecting yk application: {:04x}", sw); } - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; _currentBlock = 37; } else { - recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32); + recv_len = mem::size_of::<[u8; 255]>() as (u32); // FIXME(tarcieri): Translate C code below /* memset(apdu.raw, 0, sizeof(apdu)); @@ -2122,20 +1906,19 @@ unsafe extern "C" fn _ykpiv_get_serial( if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); _currentBlock = 37; } else { @@ -2143,16 +1926,12 @@ unsafe extern "C" fn _ykpiv_get_serial( } } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed retrieving serial number: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed retrieving serial number: {:04x}", sw); } - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; _currentBlock = 37; } else { - recv_len = ::std::mem::size_of::<[u8; 255]>() as (u32); + recv_len = mem::size_of::<[u8; 255]>() as (u32); // FIXME(tarcieri): Translate C code below /* memset(apdu.raw, 0, sizeof(apdu)); @@ -2164,32 +1943,27 @@ unsafe extern "C" fn _ykpiv_get_serial( if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), temp.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); } return res; } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed selecting application: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed selecting application: {:04x}", sw); } - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } _currentBlock = 17; } @@ -2205,38 +1979,33 @@ unsafe extern "C" fn _ykpiv_get_serial( if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); } return res; } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed retrieving serial number: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed retrieving serial number: {:04x}", sw); } - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } _currentBlock = 17; } if _currentBlock == 17 { if recv_len < 4u32 { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } else { p_temp = &mut (*state).serial as (*mut u32) as (*mut u8); *{ @@ -2268,25 +2037,21 @@ unsafe extern "C" fn _ykpiv_get_serial( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_get_serial( - mut state: *mut ykpiv_state, - mut p_serial: *mut u32, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_get_serial(mut state: *mut ykpiv_state, mut p_serial: *mut u32) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; if { res = _ykpiv_begin_transaction(state); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { if !({ res = _ykpiv_ensure_application_selected(state); res } as (i32) - != Enum5::YKPIV_OK as (i32)) + != ErrorKind::YKPIV_OK as (i32)) { res = _ykpiv_get_serial(state, p_serial, false); } @@ -2295,75 +2060,69 @@ pub unsafe extern "C" fn ykpiv_get_serial( } } -unsafe extern "C" fn _cache_pin( +unsafe fn _cache_pin( mut state: *mut ykpiv_state, - mut pin: *const u8, + mut pin: *const c_char, mut len: usize, -) -> Enum5 { +) -> ErrorKind { if state.is_null() { - Enum5::YKPIV_ARGUMENT_ERROR - } else if !pin.is_null() && ((*state).pin as (*const u8) == pin) { - Enum5::YKPIV_OK - } else { - if !(*state).pin.is_null() { - memset_s( - (*state).pin as (*mut ::std::os::raw::c_void), - strnlen((*state).pin as (*const u8), 8usize), - 0i32, - strnlen((*state).pin as (*const u8), 8usize), - ); - _ykpiv_free(state, (*state).pin as (*mut ::std::os::raw::c_void)); - (*state).pin = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - } - if !pin.is_null() && (len > 0usize) { - (*state).pin = _ykpiv_alloc( - state, - len.wrapping_mul(::std::mem::size_of::()) - .wrapping_add(1usize), - ) as (*mut u8); - if (*state).pin == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) { - return Enum5::YKPIV_MEMORY_ERROR; - } else { - memcpy( - (*state).pin as (*mut ::std::os::raw::c_void), - pin as (*const ::std::os::raw::c_void), - len, - ); - *(*state).pin.offset(len as (isize)) = 0u8; - } - } - Enum5::YKPIV_OK + return ErrorKind::YKPIV_ARGUMENT_ERROR; } + + if !pin.is_null() && ((*state).pin as *const c_char == pin) { + return ErrorKind::YKPIV_OK; + } + + if !(*state).pin.is_null() { + memset_s( + (*state).pin as (*mut c_void), + strnlen((*state).pin as *const c_char, 8), + 0, + strnlen((*state).pin as *const c_char, 8), + ); + free((*state).pin as (*mut c_void)); + (*state).pin = ptr::null_mut(); + } + if !pin.is_null() && (len > 0) { + (*state).pin = malloc(len + 1) as (*mut u8); + if (*state).pin == 0i32 as (*mut c_void) as (*mut u8) { + return ErrorKind::YKPIV_MEMORY_ERROR; + } else { + memcpy((*state).pin as (*mut c_void), pin as (*const c_void), len); + *(*state).pin.offset(len as (isize)) = 0u8; + } + } + + ErrorKind::YKPIV_OK } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_verify( +pub fn ykpiv_verify( mut state: *mut ykpiv_state, - mut pin: *const u8, + mut pin: *const c_char, mut tries: *mut i32, -) -> Enum5 { +) -> ErrorKind { ykpiv_verify_select( state, pin, - if !pin.is_null() { strlen(pin) } else { 0usize }, + if !pin.is_null() { strlen(pin) } else { 0 }, tries, false, ) } -unsafe extern "C" fn _verify( +unsafe fn _verify( mut state: *mut ykpiv_state, - mut pin: *const u8, + mut pin: *const c_char, pin_len: usize, mut tries: *mut i32, -) -> Enum5 { - let mut apdu: u_APDU; +) -> ErrorKind { + let mut apdu: APDU; let mut data: [u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32); let mut sw: i32; - let mut res: Enum5; + let mut res: ErrorKind; if pin_len > 8usize { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { // FIXME(tarcieri): Translate C code below /* @@ -2381,18 +2140,18 @@ unsafe extern "C" fn _verify( */ res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); memset_s( - &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::(), + &mut apdu as (*mut APDU) as (*mut c_void), + mem::size_of::(), 0i32, - ::std::mem::size_of::(), + mem::size_of::(), ); - (if res as (i32) != Enum5::YKPIV_OK as (i32) { + (if res as (i32) != ErrorKind::YKPIV_OK as (i32) { res } else if sw == 0x9000i32 { if !pin.is_null() && (pin_len != 0) { @@ -2401,42 +2160,41 @@ unsafe extern "C" fn _verify( if !tries.is_null() { *tries = sw & 0xfi32; } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else if sw >> 8i32 == 0x63i32 { if !tries.is_null() { *tries = sw & 0xfi32; } - Enum5::YKPIV_WRONG_PIN + ErrorKind::YKPIV_WRONG_PIN } else if sw == 0x6983i32 { if !tries.is_null() { *tries = 0i32; } - Enum5::YKPIV_WRONG_PIN + ErrorKind::YKPIV_WRONG_PIN } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_verify_select( +pub fn ykpiv_verify_select( mut state: *mut ykpiv_state, - mut pin: *const u8, + mut pin: *const c_char, pin_len: usize, mut tries: *mut i32, mut force_select: bool, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; - if Enum5::YKPIV_OK as (i32) != { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { if force_select { - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32) @@ -2456,62 +2214,54 @@ pub unsafe extern "C" fn ykpiv_verify_select( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_get_pin_retries( - mut state: *mut ykpiv_state, - mut tries: *mut i32, -) -> Enum5 { - let mut res: Enum5; - let mut ykrc: Enum5; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut i32) == tries - { - Enum5::YKPIV_ARGUMENT_ERROR +pub fn ykpiv_get_pin_retries(mut state: *mut ykpiv_state, mut tries: *mut i32) -> ErrorKind { + let mut res: ErrorKind; + let mut ykrc: ErrorKind; + + if state.is_null() || tries.is_null() { + return ErrorKind::YKPIV_ARGUMENT_ERROR; + } + + res = _ykpiv_select_application(state); + + if res != ErrorKind::YKPIV_OK { + return res; + } + + ykrc = ykpiv_verify(state, ptr::null(), tries); + + if ykrc == ErrorKind::YKPIV_WRONG_PIN { + ErrorKind::YKPIV_OK } else { - res = _ykpiv_select_application(state); - (if res as (i32) != Enum5::YKPIV_OK as (i32) { - res - } else { - ykrc = ykpiv_verify( - state, - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - tries, - ); - (if ykrc as (i32) == Enum5::YKPIV_WRONG_PIN as (i32) { - Enum5::YKPIV_OK as (i32) - } else { - ykrc as (i32) - }) as (Enum5) - }) + ykrc } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_set_pin_retries( +pub fn ykpiv_set_pin_retries( mut state: *mut ykpiv_state, mut pin_tries: i32, mut puk_tries: i32, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut templ: *mut u8 = 0i32 as (*mut u8); let mut data: [u8; 255]; - let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>(); + let mut recv_len: usize = mem::size_of::<[u8; 255]>(); let mut sw: i32 = 0i32; if pin_tries == 0i32 || puk_tries == 0i32 { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else if pin_tries > 0xffi32 || puk_tries > 0xffi32 || pin_tries < 1i32 || puk_tries < 1i32 { - Enum5::YKPIV_RANGE_ERROR + ErrorKind::YKPIV_RANGE_ERROR } else { *templ.offset(2isize) = pin_tries as (u8); *templ.offset(3isize) = puk_tries as (u8); - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -2519,20 +2269,20 @@ pub unsafe extern "C" fn ykpiv_set_pin_retries( res = ykpiv_transfer_data( state, templ as (*const u8), - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), + 0i32 as (*mut c_void) as (*const u8), 0isize, data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), ); - if Enum5::YKPIV_OK as (i32) == res as (i32) { + if ErrorKind::YKPIV_OK as (i32) == res as (i32) { if !(0x9000i32 == sw) { if sw == 0x6983i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } else if sw == 0x6982i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } else { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } } } @@ -2543,25 +2293,25 @@ pub unsafe extern "C" fn ykpiv_set_pin_retries( } } -unsafe extern "C" fn _ykpiv_change_pin( +unsafe fn _ykpiv_change_pin( mut state: *mut ykpiv_state, mut action: i32, - mut current_pin: *const u8, + mut current_pin: *const c_char, mut current_pin_len: usize, - mut new_pin: *const u8, + mut new_pin: *const c_char, mut new_pin_len: usize, mut tries: *mut i32, -) -> Enum5 { +) -> ErrorKind { let mut sw: i32; let mut templ: *mut u8 = 0i32 as (*mut u8); let mut indata: [u8; 16]; let mut data: [u8; 255]; - let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>(); - let mut res: Enum5; + let mut recv_len: usize = mem::size_of::<[u8; 255]>(); + let mut res: ErrorKind; if current_pin_len > 8usize { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else if new_pin_len > 8usize { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { if action == 1i32 { *templ.offset(1isize) = 0x2cu8; @@ -2569,21 +2319,20 @@ unsafe extern "C" fn _ykpiv_change_pin( *templ.offset(3isize) = 0x81u8; } memcpy( - indata.as_mut_ptr() as (*mut ::std::os::raw::c_void), - current_pin as (*const ::std::os::raw::c_void), + indata.as_mut_ptr() as (*mut c_void), + current_pin as (*const c_void), current_pin_len, ); if current_pin_len < 8usize { memset( - indata.as_mut_ptr().offset(current_pin_len as (isize)) - as (*mut ::std::os::raw::c_void), + indata.as_mut_ptr().offset(current_pin_len as (isize)) as (*mut c_void), 0xffi32, 8usize.wrapping_sub(current_pin_len), ); } memcpy( - indata.as_mut_ptr().offset(8isize) as (*mut ::std::os::raw::c_void), - new_pin as (*const ::std::os::raw::c_void), + indata.as_mut_ptr().offset(8isize) as (*mut c_void), + new_pin as (*const c_void), new_pin_len, ); if new_pin_len < 8usize { @@ -2591,8 +2340,7 @@ unsafe extern "C" fn _ykpiv_change_pin( indata .as_mut_ptr() .offset(8isize) - .offset(new_pin_len as (isize)) - as (*mut ::std::os::raw::c_void), + .offset(new_pin_len as (isize)) as (*mut c_void), 0xffi32, 8usize.wrapping_sub(new_pin_len), ); @@ -2601,140 +2349,120 @@ unsafe extern "C" fn _ykpiv_change_pin( state, templ as (*const u8), indata.as_mut_ptr() as (*const u8), - ::std::mem::size_of::<[u8; 16]>() as (isize), + mem::size_of::<[u8; 16]>() as (isize), data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), ); memset_s( - indata.as_mut_ptr() as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 16]>(), + indata.as_mut_ptr() as (*mut c_void), + mem::size_of::<[u8; 16]>(), 0i32, - ::std::mem::size_of::<[u8; 16]>(), + mem::size_of::<[u8; 16]>(), ); - (if res as (i32) != Enum5::YKPIV_OK as (i32) { + (if res as (i32) != ErrorKind::YKPIV_OK as (i32) { res } else if sw != 0x9000i32 { (if sw >> 8i32 == 0x63i32 { if !tries.is_null() { *tries = sw & 0xfi32; } - Enum5::YKPIV_WRONG_PIN + ErrorKind::YKPIV_WRONG_PIN } else if sw == 0x6983i32 { - Enum5::YKPIV_PIN_LOCKED + ErrorKind::YKPIV_PIN_LOCKED } else { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed changing pin, token response code: %x.\n\0").as_ptr(), - sw, - ); + eprintln!("Failed changing pin, token response code: {:x}.", sw); } - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) } else { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_change_pin( +pub fn ykpiv_change_pin( mut state: *mut ykpiv_state, - mut current_pin: *const u8, + mut current_pin: *const c_char, mut current_pin_len: usize, - mut new_pin: *const u8, + mut new_pin: *const c_char, mut new_pin_len: usize, mut tries: *mut i32, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; - if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) - { - res = _ykpiv_change_pin( - state, - 0i32, - current_pin, - current_pin_len, - new_pin, - new_pin_len, - tries, - ); - if res as (i32) == Enum5::YKPIV_OK as (i32) - && (new_pin != 0i32 as (*mut ::std::os::raw::c_void) as (*const u8)) - { - _cache_pin(state, new_pin, new_pin_len); - } - } - _ykpiv_end_transaction(state); - res +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_GENERIC_ERROR; + + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; } + + if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK { + res = _ykpiv_change_pin( + state, + 0i32, + current_pin, + current_pin_len, + new_pin, + new_pin_len, + tries, + ); + + if res == ErrorKind::YKPIV_OK && !new_pin.is_null() { + _cache_pin(state, new_pin, new_pin_len); + } + } + + _ykpiv_end_transaction(state); + res } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_change_puk( +pub fn ykpiv_change_puk( mut state: *mut ykpiv_state, - mut current_puk: *const u8, + mut current_puk: *const c_char, mut current_puk_len: usize, - mut new_puk: *const u8, + mut new_puk: *const c_char, mut new_puk_len: usize, mut tries: *mut i32, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; - if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) - { - res = _ykpiv_change_pin( - state, - 2i32, - current_puk, - current_puk_len, - new_puk, - new_puk_len, - tries, - ); - } - _ykpiv_end_transaction(state); - res +) -> ErrorKind { + let mut res = ErrorKind::YKPIV_GENERIC_ERROR; + + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; } + + if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK { + res = _ykpiv_change_pin( + state, + 2, + current_puk, + current_puk_len, + new_puk, + new_puk_len, + tries, + ); + } + + _ykpiv_end_transaction(state); + res } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_unblock_pin( +pub fn ykpiv_unblock_pin( mut state: *mut ykpiv_state, - mut puk: *const u8, + mut puk: *const c_char, mut puk_len: usize, - mut new_pin: *const u8, + mut new_pin: *const c_char, mut new_pin_len: usize, mut tries: *mut i32, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_GENERIC_ERROR; - if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_GENERIC_ERROR; + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -2746,22 +2474,21 @@ pub unsafe extern "C" fn ykpiv_unblock_pin( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_fetch_object( +pub fn ykpiv_fetch_object( mut state: *mut ykpiv_state, mut object_id: i32, mut data: *mut u8, mut len: *mut usize, -) -> Enum5 { - let mut res: Enum5; - if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind; + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -2773,7 +2500,7 @@ pub unsafe extern "C" fn ykpiv_fetch_object( } } -unsafe extern "C" fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut u8 { +unsafe fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut u8 { *{ let _old = buffer; buffer = buffer.offset(1isize); @@ -2815,35 +2542,34 @@ unsafe extern "C" fn set_object(mut object_id: i32, mut buffer: *mut u8) -> *mut buffer } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_fetch_object( +pub fn _ykpiv_fetch_object( mut state: *mut ykpiv_state, mut object_id: i32, mut data: *mut u8, mut len: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut sw: i32; let mut indata: [u8; 5]; let mut inptr: *mut u8 = indata.as_mut_ptr(); let mut templ: *mut u8 = 0i32 as (*mut u8); - let mut res: Enum5; + let mut res: ErrorKind; inptr = set_object(object_id, inptr); - if inptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) { - Enum5::YKPIV_INVALID_OBJECT + if inptr == 0i32 as (*mut c_void) as (*mut u8) { + ErrorKind::YKPIV_INVALID_OBJECT } else if { res = ykpiv_transfer_data( state, templ as (*const u8), indata.as_mut_ptr() as (*const u8), (inptr as (isize)).wrapping_sub(indata.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize), + / mem::size_of::() as (isize), data, len, &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { res } else if sw == 0x9000i32 { @@ -2855,56 +2581,53 @@ pub unsafe extern "C" fn _ykpiv_fetch_object( (*len).wrapping_sub(1usize), ) { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { offs = _ykpiv_get_length( data.offset(1isize) as (*const u8), &mut outlen as (*mut usize), ); (if offs == 0u32 { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else if outlen.wrapping_add(offs as (usize)).wrapping_add(1usize) != *len { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Invalid length indicated in object, total objlen is %lu, indicated length is %lu.\0").as_ptr( - ), + eprintln!( + "Invalid length indicated in object, total objlen is {}, indicated length is {}.", *len, outlen ); } - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { memmove( - data as (*mut ::std::os::raw::c_void), - data.offset(1isize).offset(offs as (isize)) as (*const ::std::os::raw::c_void), + data as (*mut c_void), + data.offset(1isize).offset(offs as (isize)) as (*const c_void), outlen, ); *len = outlen; - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) }) } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_save_object( +pub fn ykpiv_save_object( mut state: *mut ykpiv_state, mut object_id: i32, mut indata: *mut u8, mut len: usize, -) -> Enum5 { - let mut res: Enum5; - if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind; + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -2916,25 +2639,24 @@ pub unsafe extern "C" fn ykpiv_save_object( } } -#[no_mangle] -pub unsafe extern "C" fn _ykpiv_save_object( +pub fn _ykpiv_save_object( mut state: *mut ykpiv_state, mut object_id: i32, mut indata: *mut u8, mut len: usize, -) -> Enum5 { +) -> ErrorKind { let mut data: [u8; 3072]; let mut dataptr: *mut u8 = data.as_mut_ptr(); let mut templ: *mut u8 = 0i32 as (*mut u8); let mut sw: i32; - let mut res: Enum5; + let mut res: ErrorKind; let mut outlen: usize = 0usize; - if len > ::std::mem::size_of::<[u8; 3072]>().wrapping_sub(9usize) { - Enum5::YKPIV_SIZE_ERROR + if len > mem::size_of::<[u8; 3072]>().wrapping_sub(9usize) { + ErrorKind::YKPIV_SIZE_ERROR } else { dataptr = set_object(object_id, dataptr); - (if dataptr == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) { - Enum5::YKPIV_INVALID_OBJECT + (if dataptr == 0i32 as (*mut c_void) as (*mut u8) { + ErrorKind::YKPIV_INVALID_OBJECT } else { *{ let _old = dataptr; @@ -2942,11 +2664,7 @@ pub unsafe extern "C" fn _ykpiv_save_object( _old } = 0x53u8; dataptr = dataptr.offset(_ykpiv_set_length(dataptr, len) as (isize)); - memcpy( - dataptr as (*mut ::std::os::raw::c_void), - indata as (*const ::std::os::raw::c_void), - len, - ); + memcpy(dataptr as (*mut c_void), indata as (*const c_void), len); dataptr = dataptr.offset(len as (isize)); (if { res = _ykpiv_transfer_data( @@ -2954,29 +2672,28 @@ pub unsafe extern "C" fn _ykpiv_save_object( templ as (*const u8), data.as_mut_ptr() as (*const u8), (dataptr as (isize)).wrapping_sub(data.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize), - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + / mem::size_of::() as (isize), + 0i32 as (*mut c_void) as (*mut u8), &mut outlen as (*mut usize), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32) + != ErrorKind::YKPIV_OK as (i32) { res } else if 0x9000i32 == sw { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else if 0x6982i32 == sw { - Enum5::YKPIV_AUTHENTICATION_ERROR + ErrorKind::YKPIV_AUTHENTICATION_ERROR } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) }) } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_import_private_key( +pub fn ykpiv_import_private_key( mut state: *mut ykpiv_state, key: u8, mut algorithm: u8, @@ -2994,13 +2711,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key( mut ec_data_len: u8, pin_policy: u8, touch_policy: u8, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut key_data: [u8; 1024]; let mut in_ptr: *mut u8 = key_data.as_mut_ptr(); let mut templ: *mut u8 = 0i32 as (*mut u8); let mut data: [u8; 256]; - let mut recv_len: usize = ::std::mem::size_of::<[u8; 256]>(); + let mut recv_len: usize = mem::size_of::<[u8; 256]>(); let mut elem_len: u32; let mut sw: i32; let mut params: [*const u8; 5]; @@ -3009,27 +2726,27 @@ pub unsafe extern "C" fn ykpiv_import_private_key( let mut n_params: u8; let mut i: i32; let mut param_tag: i32; - let mut res: Enum5; - if state == 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) { - Enum5::YKPIV_GENERIC_ERROR + let mut res: ErrorKind; + if state == 0i32 as (*mut c_void) as (*mut ykpiv_state) { + ErrorKind::YKPIV_GENERIC_ERROR } else if key as (i32) == 0x9bi32 || key as (i32) < 0x82i32 || key as (i32) > 0x95i32 && (key as (i32) < 0x9ai32) || key as (i32) > 0x9ei32 && (key as (i32) != 0xf9i32) { - Enum5::YKPIV_KEY_ERROR + ErrorKind::YKPIV_KEY_ERROR } else if pin_policy as (i32) != 0i32 && (pin_policy as (i32) != 1i32) && (pin_policy as (i32) != 2i32) && (pin_policy as (i32) != 3i32) { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else if touch_policy as (i32) != 0i32 && (touch_policy as (i32) != 1i32) && (touch_policy as (i32) != 2i32) && (touch_policy as (i32) != 3i32) { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { if algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32 { if p_len @@ -3037,9 +2754,9 @@ pub unsafe extern "C" fn ykpiv_import_private_key( .wrapping_add(dp_len) .wrapping_add(dq_len) .wrapping_add(qinv_len) - >= ::std::mem::size_of::<[u8; 1024]>() + >= mem::size_of::<[u8; 1024]>() { - return Enum5::YKPIV_SIZE_ERROR; + return ErrorKind::YKPIV_SIZE_ERROR; } else { if algorithm as (i32) == 0x6i32 { elem_len = 64u32; @@ -3047,13 +2764,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key( if algorithm as (i32) == 0x7i32 { elem_len = 128u32; } - if p == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - || q == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - || dp == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - || dq == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - || qinv == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) + if p == 0i32 as (*mut c_void) as (*const u8) + || q == 0i32 as (*mut c_void) as (*const u8) + || dp == 0i32 as (*mut c_void) as (*const u8) + || dq == 0i32 as (*mut c_void) as (*const u8) + || qinv == 0i32 as (*mut c_void) as (*const u8) { - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } else { params[0usize] = p; lens[0usize] = p_len; @@ -3070,8 +2787,8 @@ pub unsafe extern "C" fn ykpiv_import_private_key( } } } else if algorithm as (i32) == 0x11i32 || algorithm as (i32) == 0x14i32 { - if ec_data_len as (usize) >= ::std::mem::size_of::<[u8; 1024]>() { - return Enum5::YKPIV_SIZE_ERROR; + if ec_data_len as (usize) >= mem::size_of::<[u8; 1024]>() { + return ErrorKind::YKPIV_SIZE_ERROR; } else { if algorithm as (i32) == 0x11i32 { elem_len = 32u32; @@ -3079,8 +2796,8 @@ pub unsafe extern "C" fn ykpiv_import_private_key( if algorithm as (i32) == 0x14i32 { elem_len = 48u32; } - if ec_data == 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) { - return Enum5::YKPIV_GENERIC_ERROR; + if ec_data == 0i32 as (*mut c_void) as (*const u8) { + return ErrorKind::YKPIV_GENERIC_ERROR; } else { params[0usize] = ec_data; lens[0usize] = ec_data_len as (usize); @@ -3089,7 +2806,7 @@ pub unsafe extern "C" fn ykpiv_import_private_key( } } } else { - return Enum5::YKPIV_ALGORITHM_ERROR; + return ErrorKind::YKPIV_ALGORITHM_ERROR; } i = 0i32; 'loop24: loop { @@ -3106,17 +2823,17 @@ pub unsafe extern "C" fn ykpiv_import_private_key( in_ptr = in_ptr.offset(_ykpiv_set_length(in_ptr, elem_len as (usize)) as (isize)); padding = (elem_len as (usize)).wrapping_sub(lens[i as (usize)]); remaining = (key_data.as_mut_ptr() as (usize)) - .wrapping_add(::std::mem::size_of::<[u8; 1024]>()) + .wrapping_add(mem::size_of::<[u8; 1024]>()) .wrapping_sub(in_ptr as (usize)); if padding > remaining { _currentBlock = 39; break; } - memset(in_ptr as (*mut ::std::os::raw::c_void), 0i32, padding); + memset(in_ptr as (*mut c_void), 0i32, padding); in_ptr = in_ptr.offset(padding as (isize)); memcpy( - in_ptr as (*mut ::std::os::raw::c_void), - params[i as (usize)] as (*const ::std::os::raw::c_void), + in_ptr as (*mut c_void), + params[i as (usize)] as (*const c_void), lens[i as (usize)], ); in_ptr = in_ptr.offset(lens[i as (usize)] as (isize)); @@ -3157,13 +2874,13 @@ pub unsafe extern "C" fn ykpiv_import_private_key( _old } = touch_policy; } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - return Enum5::YKPIV_PCSC_ERROR; - } else if !(Enum5::YKPIV_OK as (i32) != { + return ErrorKind::YKPIV_PCSC_ERROR; + } else if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -3174,274 +2891,239 @@ pub unsafe extern "C" fn ykpiv_import_private_key( templ as (*const u8), key_data.as_mut_ptr() as (*const u8), (in_ptr as (isize)).wrapping_sub(key_data.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize), + / mem::size_of::() as (isize), data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), ); res } as (i32) - != Enum5::YKPIV_OK as (i32)) + != ErrorKind::YKPIV_OK as (i32)) { if 0x9000i32 != sw { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; if sw == 0x6982i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } } } } } else { - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; } memset_s( - key_data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 1024]>(), + key_data.as_mut_ptr() as (*mut c_void), + mem::size_of::<[u8; 1024]>(), 0i32, - ::std::mem::size_of::<[u8; 1024]>(), + mem::size_of::<[u8; 1024]>(), ); _ykpiv_end_transaction(state); res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_attest( +pub fn ykpiv_attest( mut state: *mut ykpiv_state, key: u8, mut data: *mut u8, mut data_len: *mut usize, -) -> Enum5 { - let mut res: Enum5; +) -> ErrorKind { + let mut res = ErrorKind::YKPIV_GENERIC_ERROR; let mut templ: *mut u8 = 0i32 as (*mut u8); let mut sw: i32; let mut ul_data_len: usize; - if state == 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) - || data == 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) - || data_len == 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) - { - Enum5::YKPIV_ARGUMENT_ERROR - } else { - ul_data_len = *data_len; - (if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) - { - if !({ - res = ykpiv_transfer_data( - state, - templ as (*const u8), - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), - 0isize, - data, - &mut ul_data_len as (*mut usize), - &mut sw as (*mut i32), - ); - res - } as (i32) - != Enum5::YKPIV_OK as (i32)) - { - if 0x9000i32 != sw { - res = Enum5::YKPIV_GENERIC_ERROR; - if 0x6d00i32 == sw { - res = Enum5::YKPIV_NOT_SUPPORTED; - } - } else if *data.offset(0isize) as (i32) != 0x30i32 { - res = Enum5::YKPIV_GENERIC_ERROR; - } else { - *data_len = ul_data_len; - } - } - } - _ykpiv_end_transaction(state); - res - }) + if state.is_null() || data.is_null() || data_len.is_null() { + return ErrorKind::YKPIV_ARGUMENT_ERROR; } + + ul_data_len = *data_len; + + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; + } + + if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK { + res = ykpiv_transfer_data( + state, + templ as (*const u8), + 0i32 as (*mut c_void) as (*const u8), + 0isize, + data, + &mut ul_data_len as (*mut usize), + &mut sw as (*mut i32), + ); + + if res == ErrorKind::YKPIV_OK { + if 0x9000i32 != sw { + res = ErrorKind::YKPIV_GENERIC_ERROR; + if 0x6d00i32 == sw { + res = ErrorKind::YKPIV_NOT_SUPPORTED; + } + } else if *data as i32 != 0x30 { + res = ErrorKind::YKPIV_GENERIC_ERROR; + } else { + *data_len = ul_data_len; + } + } + } + + _ykpiv_end_transaction(state); + res } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_auth_getchallenge( +pub fn ykpiv_auth_getchallenge( mut state: *mut ykpiv_state, mut challenge: *mut u8, challenge_len: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut apdu: u_APDU = 0i32 as (u_APDU); +) -> ErrorKind { + let mut res = ErrorKind::YKPIV_OK; let mut data = [0u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 261]>() as (u32); let mut sw: i32 = 0i32; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == challenge { - Enum5::YKPIV_GENERIC_ERROR - } else if 8usize != challenge_len { - Enum5::YKPIV_SIZE_ERROR - } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - if !(Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_ensure_application_selected(state); - res - } as (i32)) - { - // get a challenge from the card - // FIXME(tarcieri): Translate C code below - /* - memset(apdu.raw, 0, sizeof(apdu)); - apdu.st.ins = YKPIV_INS_AUTHENTICATE; - apdu.st.p1 = YKPIV_ALGO_3DES; // triple des - apdu.st.p2 = YKPIV_KEY_CARDMGM; // management key - apdu.st.lc = 0x04; - apdu.st.data[0] = 0x7c; - apdu.st.data[1] = 0x02; - apdu.st.data[2] = 0x81; //0x80; - */ - if !({ - res = _send_data( - state, - &mut apdu as (*mut u_APDU), - data.as_mut_ptr(), - &mut recv_len as (*mut u32), - &mut sw as (*mut i32), + + if state.is_null() || challenge.is_null() { + return ErrorKind::YKPIV_GENERIC_ERROR; + } + + if challenge_len != 8 { + return ErrorKind::YKPIV_SIZE_ERROR; + } + + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; + } + + if _ykpiv_ensure_application_selected(state) == ErrorKind::YKPIV_OK { + let mut apdu = APDU::default(); + apdu.ins = YKPIV_INS_AUTHENTICATE; + apdu.p1 = YKPIV_ALGO_3DES; // triple des + apdu.p2 = YKPIV_KEY_CARDMGM; // management key + apdu.lc = 0x04; + apdu.data[0] = 0x7c; + apdu.data[1] = 0x02; + apdu.data[2] = 0x81; //0x80; + + res = _send_data( + state, + &mut apdu as (*mut APDU), + data.as_mut_ptr(), + &mut recv_len as (*mut u32), + &mut sw as (*mut i32), + ); + + if res != ErrorKind::YKPIV_OK { + if sw != 0x9000i32 { + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; + } else { + memcpy( + challenge as (*mut c_void), + data.as_mut_ptr().offset(4isize) as (*const c_void), + 8usize, ); - res - } as (i32) - != Enum5::YKPIV_OK as (i32)) - { - if sw != 0x9000i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; - } else { - memcpy( - challenge as (*mut ::std::os::raw::c_void), - data.as_mut_ptr().offset(4isize) as (*const ::std::os::raw::c_void), - 8usize, - ); - } } } - _ykpiv_end_transaction(state); - res } + _ykpiv_end_transaction(state); + res } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_auth_verifyresponse( +pub fn ykpiv_auth_verifyresponse( mut state: *mut ykpiv_state, mut response: *mut u8, response_len: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut apdu: u_APDU = 0i32 as (u_APDU); +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut data = [0u8; 261]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 261]>() as (u32); + let mut recv_len = data.len() as u32; let mut sw: i32 = 0i32; - // FIXME(tarcieri): dataptr should NOT be 0! Translate C code below - let mut dataptr: *mut u8 = 0i32 as (*mut u8); // apdu.st.data - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == response { - Enum5::YKPIV_GENERIC_ERROR - } else if 8usize != response_len { - Enum5::YKPIV_SIZE_ERROR - } else if Enum5::YKPIV_OK as (i32) != { - res = _ykpiv_begin_transaction(state); - res - } as (i32) - { - Enum5::YKPIV_PCSC_ERROR - } else { - // send the response to the card and a challenge of our own. - recv_len = ::std::mem::size_of::<[u8; 261]>() as (u32); - // FIXME(tarcieri): Translate C code below - /* - memset(apdu.raw, 0, sizeof(apdu)); - apdu.st.ins = YKPIV_INS_AUTHENTICATE; - apdu.st.p1 = YKPIV_ALGO_3DES; // triple des - apdu.st.p2 = YKPIV_KEY_CARDMGM; // management key - */ - *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0x7cu8; - *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0xau8; - *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 0x82u8; - *{ - let _old = dataptr; - dataptr = dataptr.offset(1isize); - _old - } = 8u8; - memcpy( - dataptr as (*mut ::std::os::raw::c_void), - response as (*const ::std::os::raw::c_void), - response_len, - ); - dataptr = dataptr.offset(8isize); - // FIXME(tarcieri): Translate C code below - /* apdu.st.lc = (unsigned char)(dataptr - apdu.st.data); */ - if !({ - res = _send_data( - state, - &mut apdu as (*mut u_APDU), - data.as_mut_ptr(), - &mut recv_len as (*mut u32), - &mut sw as (*mut i32), - ); - res - } as (i32) - != Enum5::YKPIV_OK as (i32)) - { - if sw != 0x9000i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; - } - } - memset_s( - &mut apdu as (*mut u_APDU) as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::(), - 0i32, - ::std::mem::size_of::(), - ); - _ykpiv_end_transaction(state); - res + let mut apdu = APDU::default(); + + let mut dataptr = apdu.data.as_mut_ptr(); + + if state.is_null() || response.is_null() { + return ErrorKind::YKPIV_GENERIC_ERROR; } + + if response_len != 8 { + return ErrorKind::YKPIV_SIZE_ERROR; + } + + if _ykpiv_begin_transaction(state) != ErrorKind::YKPIV_OK { + return ErrorKind::YKPIV_PCSC_ERROR; + } + + // send the response to the card and a challenge of our own. + apdu.ins = YKPIV_INS_AUTHENTICATE; + apdu.p1 = YKPIV_ALGO_3DES; // triple des + apdu.p2 = YKPIV_KEY_CARDMGM; // management key + + *{ + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0x7cu8; + + *{ + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0xau8; + + *{ + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 0x82u8; + + *{ + let _old = dataptr; + dataptr = dataptr.offset(1isize); + _old + } = 8u8; + + memcpy( + dataptr as *mut c_void, + response as *const c_void, + response_len, + ); + + dataptr = dataptr.offset(8isize); + apdu.lc = (dataptr as usize - apdu.data.as_ptr() as usize) + .try_into() + .unwrap(); + + res = _send_data( + state, + &mut apdu as (*mut APDU), + data.as_mut_ptr(), + &mut recv_len, + &mut sw, + ); + + if res == ErrorKind::YKPIV_OK && sw != 0x9000i32 { + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; + } + + apdu.zeroize(); + _ykpiv_end_transaction(state); + res } static mut MGMT_AID: *const u8 = 0xa0i32 as (*const u8); -#[no_mangle] -pub unsafe extern "C" fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut apdu: u_APDU; +pub fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut apdu: APDU; let mut data: [u8; 255]; - let mut recv_len: u32 = ::std::mem::size_of::<[u8; 255]>() as (u32); + let mut recv_len: u32 = mem::size_of::<[u8; 255]>() as (u32); let mut sw: i32; if state.is_null() { - Enum5::YKPIV_ARGUMENT_ERROR + ErrorKind::YKPIV_ARGUMENT_ERROR } else if { res = _ykpiv_begin_transaction(state); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { res } else { @@ -3456,31 +3138,26 @@ pub unsafe extern "C" fn ykpiv_auth_deauthenticate(mut state: *mut ykpiv_state) if { res = _send_data( state, - &mut apdu as (*mut u_APDU), + &mut apdu as (*mut APDU), data.as_mut_ptr(), &mut recv_len as (*mut u32), &mut sw as (*mut i32), ); res } as (i32) - < Enum5::YKPIV_OK as (i32) + < ErrorKind::YKPIV_OK as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed communicating with card: \'%s\'\n\0").as_ptr(), - ykpiv_strerror(res), + eprintln!( + "Failed communicating with card: \'{}\'", + ykpiv_strerror(res) ); } } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed selecting mgmt application: %04x\n\0").as_ptr(), - sw, - ); + eprintln!("Failed selecting mgmt application: {:04x}", sw); } - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } _ykpiv_end_transaction(state); res diff --git a/src/util.rs b/src/util.rs index 4187752..aeea831 100644 --- a/src/util.rs +++ b/src/util.rs @@ -1,3 +1,6 @@ +// Adapted from yubico-piv-tool: +// +// // Copyright (c) 2014-2016 Yubico AB // All rights reserved. // @@ -25,38 +28,41 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#![allow(non_camel_case_types)] + +use crate::{ + error::ErrorKind, + internal::{setting_get_bool, SettingBool, SettingSource}, +}; +use libc::{free, memcpy, memmove, time, time_t}; +use std::{ffi::CString, mem, os::raw::c_void}; + extern "C" { static mut _DefaultRuneLocale: Struct1; fn __maskrune(arg1: i32, arg2: usize) -> i32; - static mut __stderrp: *mut __sFILE; - fn __swbuf(arg1: i32, arg2: *mut __sFILE) -> i32; fn __tolower(arg1: i32) -> i32; fn __toupper(arg1: i32) -> i32; - fn _ykpiv_alloc(state: *mut ykpiv_state, size: usize) -> *mut ::std::os::raw::c_void; - fn _ykpiv_begin_transaction(state: *mut ykpiv_state) -> Enum5; - fn _ykpiv_end_transaction(state: *mut ykpiv_state) -> Enum5; - fn _ykpiv_ensure_application_selected(state: *mut ykpiv_state) -> Enum5; + fn _ykpiv_alloc(state: *mut ykpiv_state, size: usize) -> *mut c_void; + fn _ykpiv_begin_transaction(state: *mut ykpiv_state) -> ErrorKind; + fn _ykpiv_end_transaction(state: *mut ykpiv_state) -> ErrorKind; + fn _ykpiv_ensure_application_selected(state: *mut ykpiv_state) -> ErrorKind; fn _ykpiv_fetch_object( state: *mut ykpiv_state, object_id: i32, data: *mut u8, len: *mut usize, - ) -> Enum5; - fn _ykpiv_free(state: *mut ykpiv_state, data: *mut ::std::os::raw::c_void); + ) -> ErrorKind; + fn _ykpiv_free(state: *mut ykpiv_state, data: *mut c_void); fn _ykpiv_get_length(buffer: *const u8, len: *mut usize) -> u32; fn _ykpiv_has_valid_length(buffer: *const u8, len: usize) -> bool; fn _ykpiv_prng_generate(buffer: *mut u8, cb_req: usize) -> Enum7; - fn _ykpiv_realloc( - state: *mut ykpiv_state, - address: *mut ::std::os::raw::c_void, - size: usize, - ) -> *mut ::std::os::raw::c_void; + fn _ykpiv_realloc(state: *mut ykpiv_state, address: *mut c_void, size: usize) -> *mut c_void; fn _ykpiv_save_object( state: *mut ykpiv_state, object_id: i32, indata: *mut u8, len: usize, - ) -> Enum5; + ) -> ErrorKind; fn _ykpiv_set_length(buffer: *mut u8, length: usize) -> u32; fn _ykpiv_transfer_data( state: *mut ykpiv_state, @@ -66,19 +72,8 @@ extern "C" { out_data: *mut u8, out_len: *mut usize, sw: *mut i32, - ) -> Enum5; - fn fprintf(arg1: *mut __sFILE, arg2: *const u8, ...) -> i32; - fn memcpy( - __dst: *mut ::std::os::raw::c_void, - __src: *const ::std::os::raw::c_void, - __n: usize, - ) -> *mut ::std::os::raw::c_void; - fn memmove( - __dst: *mut ::std::os::raw::c_void, - __src: *const ::std::os::raw::c_void, - __len: usize, - ) -> *mut ::std::os::raw::c_void; - fn memset_s(__s: *mut ::std::os::raw::c_void, __smax: usize, __c: i32, __n: usize) -> i32; + ) -> ErrorKind; + fn memset_s(__s: *mut c_void, __smax: usize, __c: i32, __n: usize) -> i32; fn pkcs5_pbkdf2_sha1( password: *const u8, cb_password: usize, @@ -88,8 +83,6 @@ extern "C" { key: *const u8, cb_key: usize, ) -> Enum11; - fn setting_get_bool(sz_setting: *const u8, f_default: bool) -> _setting_bool_t; - fn time(arg1: *mut isize) -> isize; fn ykpiv_change_puk( state: *mut ykpiv_state, current_puk: *const u8, @@ -97,8 +90,8 @@ extern "C" { new_puk: *const u8, new_puk_len: usize, tries: *mut i32, - ) -> Enum5; - fn ykpiv_set_mgmkey(state: *mut ykpiv_state, new_key: *const u8) -> Enum5; + ) -> ErrorKind; + fn ykpiv_set_mgmkey(state: *mut ykpiv_state, new_key: *const u8) -> ErrorKind; fn ykpiv_transfer_data( state: *mut ykpiv_state, templ: *const u8, @@ -107,11 +100,9 @@ extern "C" { out_data: *mut u8, out_len: *mut usize, sw: *mut i32, - ) -> Enum5; + ) -> ErrorKind; } -enum __sFILEX {} - #[derive(Copy)] #[repr(C)] pub struct __sbuf { @@ -125,62 +116,7 @@ impl Clone for __sbuf { } } -#[derive(Copy)] -#[repr(C)] -pub struct __sFILE { - pub _p: *mut u8, - pub _r: i32, - pub _w: i32, - pub _flags: i16, - pub _file: i16, - pub _bf: __sbuf, - pub _lbfsize: i32, - pub _cookie: *mut ::std::os::raw::c_void, - pub _close: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> i32, - pub _read: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut u8, i32) -> i32, - pub _seek: unsafe extern "C" fn(*mut ::std::os::raw::c_void, isize, i32) -> isize, - pub _write: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *const u8, i32) -> i32, - pub _ub: __sbuf, - pub _extra: *mut __sFILEX, - pub _ur: i32, - pub _ubuf: [u8; 3], - pub _nbuf: [u8; 1], - pub _lb: __sbuf, - pub _blksize: i32, - pub _offset: isize, -} - -impl Clone for __sFILE { - fn clone(&self) -> Self { - *self - } -} - -#[no_mangle] -pub unsafe extern "C" fn __sputc(mut _c: i32, mut _p: *mut __sFILE) -> i32 { - if { - (*_p)._w = (*_p)._w - 1; - (*_p)._w - } >= 0i32 - || (*_p)._w >= (*_p)._lbfsize && (_c as (u8) as (i32) != b'\n' as (i32)) - { - ({ - let _rhs = _c; - let _lhs = &mut *{ - let _old = (*_p)._p; - (*_p)._p = (*_p)._p.offset(1isize); - _old - }; - *_lhs = _rhs as (u8); - *_lhs - }) as (i32) - } else { - __swbuf(_c, _p) - } -} - -#[no_mangle] -pub unsafe extern "C" fn isascii(mut _c: i32) -> i32 { +pub fn isascii(mut _c: i32) -> i32 { (_c & !0x7fi32 == 0i32) as (i32) } @@ -230,8 +166,8 @@ impl Clone for Struct4 { pub struct Struct1 { pub __magic: [u8; 8], pub __encoding: [u8; 32], - pub __sgetrune: unsafe extern "C" fn(*const u8, usize, *mut *const u8) -> i32, - pub __sputrune: unsafe extern "C" fn(i32, *mut u8, usize, *mut *mut u8) -> i32, + pub __sgetrune: unsafe fn(*const u8, usize, *mut *const u8) -> i32, + pub __sputrune: unsafe fn(i32, *mut u8, usize, *mut *mut u8) -> i32, pub __invalid_rune: i32, pub __runetype: [u32; 256], pub __maplower: [i32; 256], @@ -239,7 +175,7 @@ pub struct Struct1 { pub __runetype_ext: Struct2, pub __maplower_ext: Struct2, pub __mapupper_ext: Struct2, - pub __variable: *mut ::std::os::raw::c_void, + pub __variable: *mut c_void, pub __variable_len: i32, pub __ncharclasses: i32, pub __charclasses: *mut Struct4, @@ -251,8 +187,7 @@ impl Clone for Struct1 { } } -#[no_mangle] -pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __istype(mut _c: i32, mut _f: usize) -> i32 { if isascii(_c) != 0 { !(_DefaultRuneLocale.__runetype[_c as (usize)] as (usize) & _f == 0) as (i32) } else { @@ -260,8 +195,7 @@ pub unsafe extern "C" fn __istype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { +pub fn __isctype(mut _c: i32, mut _f: usize) -> i32 { if _c < 0i32 || _c >= 256i32 { 0i32 } else { @@ -269,8 +203,7 @@ pub unsafe extern "C" fn __isctype(mut _c: i32, mut _f: usize) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { +pub fn __wcwidth(mut _c: i32) -> i32 { let mut _x: u32; if _c == 0i32 { 0i32 @@ -286,144 +219,98 @@ pub unsafe extern "C" fn __wcwidth(mut _c: i32) -> i32 { } } -#[no_mangle] -pub unsafe extern "C" fn isalnum(mut _c: i32) -> i32 { +pub fn isalnum(mut _c: i32) -> i32 { __istype(_c, (0x100isize | 0x400isize) as (usize)) } -#[no_mangle] -pub unsafe extern "C" fn isalpha(mut _c: i32) -> i32 { +pub fn isalpha(mut _c: i32) -> i32 { __istype(_c, 0x100usize) } -#[no_mangle] -pub unsafe extern "C" fn isblank(mut _c: i32) -> i32 { +pub fn isblank(mut _c: i32) -> i32 { __istype(_c, 0x20000usize) } -#[no_mangle] -pub unsafe extern "C" fn iscntrl(mut _c: i32) -> i32 { +pub fn iscntrl(mut _c: i32) -> i32 { __istype(_c, 0x200usize) } -#[no_mangle] -pub unsafe extern "C" fn isdigit(mut _c: i32) -> i32 { +pub fn isdigit(mut _c: i32) -> i32 { __isctype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isgraph(mut _c: i32) -> i32 { +pub fn isgraph(mut _c: i32) -> i32 { __istype(_c, 0x800usize) } -#[no_mangle] -pub unsafe extern "C" fn islower(mut _c: i32) -> i32 { +pub fn islower(mut _c: i32) -> i32 { __istype(_c, 0x1000usize) } -#[no_mangle] -pub unsafe extern "C" fn isprint(mut _c: i32) -> i32 { +pub fn isprint(mut _c: i32) -> i32 { __istype(_c, 0x40000usize) } -#[no_mangle] -pub unsafe extern "C" fn ispunct(mut _c: i32) -> i32 { +pub fn ispunct(mut _c: i32) -> i32 { __istype(_c, 0x2000usize) } -#[no_mangle] -pub unsafe extern "C" fn isspace(mut _c: i32) -> i32 { +pub fn isspace(mut _c: i32) -> i32 { __istype(_c, 0x4000usize) } -#[no_mangle] -pub unsafe extern "C" fn isupper(mut _c: i32) -> i32 { +pub fn isupper(mut _c: i32) -> i32 { __istype(_c, 0x8000usize) } -#[no_mangle] -pub unsafe extern "C" fn isxdigit(mut _c: i32) -> i32 { +pub fn isxdigit(mut _c: i32) -> i32 { __isctype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn toascii(mut _c: i32) -> i32 { +pub fn toascii(mut _c: i32) -> i32 { _c & 0x7fi32 } -#[no_mangle] -pub unsafe extern "C" fn tolower(mut _c: i32) -> i32 { +pub fn tolower(mut _c: i32) -> i32 { __tolower(_c) } -#[no_mangle] -pub unsafe extern "C" fn toupper(mut _c: i32) -> i32 { +pub fn toupper(mut _c: i32) -> i32 { __toupper(_c) } -#[no_mangle] -pub unsafe extern "C" fn digittoint(mut _c: i32) -> i32 { +pub fn digittoint(mut _c: i32) -> i32 { __maskrune(_c, 0xfusize) } -#[no_mangle] -pub unsafe extern "C" fn ishexnumber(mut _c: i32) -> i32 { +pub fn ishexnumber(mut _c: i32) -> i32 { __istype(_c, 0x10000usize) } -#[no_mangle] -pub unsafe extern "C" fn isideogram(mut _c: i32) -> i32 { +pub fn isideogram(mut _c: i32) -> i32 { __istype(_c, 0x80000usize) } -#[no_mangle] -pub unsafe extern "C" fn isnumber(mut _c: i32) -> i32 { +pub fn isnumber(mut _c: i32) -> i32 { __istype(_c, 0x400usize) } -#[no_mangle] -pub unsafe extern "C" fn isphonogram(mut _c: i32) -> i32 { +pub fn isphonogram(mut _c: i32) -> i32 { __istype(_c, 0x200000usize) } -#[no_mangle] -pub unsafe extern "C" fn isrune(mut _c: i32) -> i32 { +pub fn isrune(mut _c: i32) -> i32 { __istype(_c, 0xfffffff0usize) } -#[no_mangle] -pub unsafe extern "C" fn isspecial(mut _c: i32) -> i32 { +pub fn isspecial(mut _c: i32) -> i32 { __istype(_c, 0x100000usize) } -#[no_mangle] pub static mut CHUID_TMPL: *const u8 = 0x30i32 as (*const u8); -#[no_mangle] pub static mut CCC_TMPL: *const u8 = 0xf0i32 as (*const u8); -#[derive(Clone, Copy)] -#[repr(i32)] -pub enum Enum5 { - YKPIV_OK = 0i32, - YKPIV_MEMORY_ERROR = -1i32, - YKPIV_PCSC_ERROR = -2i32, - YKPIV_SIZE_ERROR = -3i32, - YKPIV_APPLET_ERROR = -4i32, - YKPIV_AUTHENTICATION_ERROR = -5i32, - YKPIV_RANDOMNESS_ERROR = -6i32, - YKPIV_GENERIC_ERROR = -7i32, - YKPIV_KEY_ERROR = -8i32, - YKPIV_PARSE_ERROR = -9i32, - YKPIV_WRONG_PIN = -10i32, - YKPIV_INVALID_OBJECT = -11i32, - YKPIV_ALGORITHM_ERROR = -12i32, - YKPIV_PIN_LOCKED = -13i32, - YKPIV_ARGUMENT_ERROR = -14i32, - YKPIV_RANGE_ERROR = -15i32, - YKPIV_NOT_SUPPORTED = -16i32, -} - #[derive(Copy)] #[repr(C)] pub struct Struct6 { @@ -436,24 +323,20 @@ impl Clone for Struct6 { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_get_cardid( - mut state: *mut ykpiv_state, - mut cardid: *mut Struct6, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_util_get_cardid(mut state: *mut ykpiv_state, mut cardid: *mut Struct6) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3063]; - let mut len: usize = ::std::mem::size_of::<[u8; 3063]>(); + let mut len: usize = mem::size_of::<[u8; 3063]>(); if cardid.is_null() { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -464,13 +347,13 @@ pub unsafe extern "C" fn ykpiv_util_get_cardid( buf.as_mut_ptr(), &mut len as (*mut usize), ); - if Enum5::YKPIV_OK as (i32) == res as (i32) { + if ErrorKind::YKPIV_OK as (i32) == res as (i32) { if len != 59usize { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } else { memcpy( - (*cardid).data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - buf.as_mut_ptr().offset(29isize) as (*const ::std::os::raw::c_void), + (*cardid).data.as_mut_ptr() as (*mut c_void), + buf.as_mut_ptr().offset(29isize) as (*const c_void), 16usize, ); } @@ -488,52 +371,48 @@ pub enum Enum7 { PRNG_GENERAL_ERROR = -1i32, } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_set_cardid( - mut state: *mut ykpiv_state, - mut cardid: *const Struct6, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_util_set_cardid(mut state: *mut ykpiv_state, mut cardid: *const Struct6) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut id: [u8; 16]; let mut buf: [u8; 59]; let mut len: usize = 0usize; if state.is_null() { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { if cardid.is_null() { if Enum7::PRNG_OK as (i32) - != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 16]>()) as (i32) + != _ykpiv_prng_generate(id.as_mut_ptr(), mem::size_of::<[u8; 16]>()) as (i32) { - return Enum5::YKPIV_RANDOMNESS_ERROR; + return ErrorKind::YKPIV_RANDOMNESS_ERROR; } } else { memcpy( - id.as_mut_ptr() as (*mut ::std::os::raw::c_void), - (*cardid).data.as_mut_ptr() as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 16]>(), + id.as_mut_ptr() as (*mut c_void), + (*cardid).data.as_mut_ptr() as (*const c_void), + mem::size_of::<[u8; 16]>(), ); } - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { memcpy( - buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), - CHUID_TMPL as (*const ::std::os::raw::c_void), + buf.as_mut_ptr() as (*mut c_void), + CHUID_TMPL as (*const c_void), 59usize, ); memcpy( - buf.as_mut_ptr().offset(29isize) as (*mut ::std::os::raw::c_void), - id.as_mut_ptr() as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 16]>(), + buf.as_mut_ptr().offset(29isize) as (*mut c_void), + id.as_mut_ptr() as (*const c_void), + mem::size_of::<[u8; 16]>(), ); len = 59usize; res = _ykpiv_save_object(state, 0x5fc102i32, buf.as_mut_ptr(), len); @@ -556,24 +435,20 @@ impl Clone for Struct8 { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_get_cccid( - mut state: *mut ykpiv_state, - mut ccc: *mut Struct8, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_util_get_cccid(mut state: *mut ykpiv_state, mut ccc: *mut Struct8) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3063]; - let mut len: usize = ::std::mem::size_of::<[u8; 3063]>(); + let mut len: usize = mem::size_of::<[u8; 3063]>(); if ccc.is_null() { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -584,13 +459,13 @@ pub unsafe extern "C" fn ykpiv_util_get_cccid( buf.as_mut_ptr(), &mut len as (*mut usize), ); - if Enum5::YKPIV_OK as (i32) == res as (i32) { + if ErrorKind::YKPIV_OK as (i32) == res as (i32) { if len != 51usize { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } else { memcpy( - (*ccc).data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - buf.as_mut_ptr().offset(9isize) as (*const ::std::os::raw::c_void), + (*ccc).data.as_mut_ptr() as (*mut c_void), + buf.as_mut_ptr().offset(9isize) as (*const c_void), 14usize, ); } @@ -601,52 +476,48 @@ pub unsafe extern "C" fn ykpiv_util_get_cccid( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_set_cccid( - mut state: *mut ykpiv_state, - mut ccc: *const Struct8, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_util_set_cccid(mut state: *mut ykpiv_state, mut ccc: *const Struct8) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut id: [u8; 14]; let mut buf: [u8; 51]; let mut len: usize = 0usize; if state.is_null() { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { if ccc.is_null() { if Enum7::PRNG_OK as (i32) - != _ykpiv_prng_generate(id.as_mut_ptr(), ::std::mem::size_of::<[u8; 14]>()) as (i32) + != _ykpiv_prng_generate(id.as_mut_ptr(), mem::size_of::<[u8; 14]>()) as (i32) { - return Enum5::YKPIV_RANDOMNESS_ERROR; + return ErrorKind::YKPIV_RANDOMNESS_ERROR; } } else { memcpy( - id.as_mut_ptr() as (*mut ::std::os::raw::c_void), - (*ccc).data.as_mut_ptr() as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 14]>(), + id.as_mut_ptr() as (*mut c_void), + (*ccc).data.as_mut_ptr() as (*const c_void), + mem::size_of::<[u8; 14]>(), ); } - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { len = 51usize; memcpy( - buf.as_mut_ptr() as (*mut ::std::os::raw::c_void), - CCC_TMPL as (*const ::std::os::raw::c_void), + buf.as_mut_ptr() as (*mut c_void), + CCC_TMPL as (*const c_void), len, ); memcpy( - buf.as_mut_ptr().offset(9isize) as (*mut ::std::os::raw::c_void), - id.as_mut_ptr() as (*const ::std::os::raw::c_void), + buf.as_mut_ptr().offset(9isize) as (*mut c_void), + id.as_mut_ptr() as (*const c_void), 14usize, ); res = _ykpiv_save_object(state, 0x5fc107i32, buf.as_mut_ptr(), len); @@ -660,15 +531,10 @@ pub unsafe extern "C" fn ykpiv_util_set_cccid( #[derive(Copy)] #[repr(C)] pub struct ykpiv_allocator { - pub pfn_alloc: - unsafe extern "C" fn(*mut ::std::os::raw::c_void, usize) -> *mut ::std::os::raw::c_void, - pub pfn_realloc: unsafe extern "C" fn( - *mut ::std::os::raw::c_void, - *mut ::std::os::raw::c_void, - usize, - ) -> *mut ::std::os::raw::c_void, - pub pfn_free: unsafe extern "C" fn(*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void), - pub alloc_data: *mut ::std::os::raw::c_void, + pub pfn_alloc: unsafe fn(*mut c_void, usize) -> *mut c_void, + pub pfn_realloc: unsafe fn(*mut c_void, *mut c_void, usize) -> *mut c_void, + pub pfn_free: unsafe fn(*mut c_void, *mut c_void), + pub alloc_data: *mut c_void, } impl Clone for ykpiv_allocator { @@ -710,8 +576,7 @@ impl Clone for ykpiv_state { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_devicemodel(mut state: *mut ykpiv_state) -> u32 { +pub fn ykpiv_util_devicemodel(mut state: *mut ykpiv_state) -> u32 { if state.is_null() || (*state).context == 0 || (*state).context as (usize) == -1i32 as (usize) { 0x0u32 } else { @@ -737,18 +602,17 @@ impl Clone for _ykpiv_key { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_list_keys( +pub fn ykpiv_util_list_keys( mut state: *mut ykpiv_state, mut key_count: *mut u8, mut data: *mut *mut _ykpiv_key, mut data_len: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut pKey: *mut _ykpiv_key = 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_key); - let mut pData: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - let mut pTemp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut pKey: *mut _ykpiv_key = 0i32 as (*mut c_void) as (*mut _ykpiv_key); + let mut pData: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); + let mut pTemp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cbData: usize = 0usize; let mut offset: usize = 0usize; let mut buf: [u8; 3072]; @@ -757,59 +621,59 @@ pub unsafe extern "C" fn ykpiv_util_list_keys( let mut cbRealloc: usize = 0usize; let CB_PAGE: usize = 4096usize; let mut SLOTS: *const u8 = 0x9ai32 as (*const u8); - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut _ykpiv_key) == data - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == data_len - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == key_count + if 0i32 as (*mut c_void) as (*mut *mut _ykpiv_key) == data + || 0i32 as (*mut c_void) as (*mut usize) == data_len + || 0i32 as (*mut c_void) as (*mut u8) == key_count { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { *key_count = 0u8; - *data = 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_key); + *data = 0i32 as (*mut c_void) as (*mut _ykpiv_key); *data_len = 0usize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { + if 0i32 as (*mut c_void) as (*mut u8) == { pData = _ykpiv_alloc(state, CB_PAGE) as (*mut u8); pData } { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { cbData = CB_PAGE; i = 0usize; 'loop5: loop { - if !(i < ::std::mem::size_of::<*const u8>()) { + if !(i < mem::size_of::<*const u8>()) { _currentBlock = 6; break; } - cbBuf = ::std::mem::size_of::<[u8; 3072]>(); + cbBuf = mem::size_of::<[u8; 3072]>(); res = _read_certificate( state, *SLOTS.offset(i as (isize)), buf.as_mut_ptr(), &mut cbBuf as (*mut usize), ); - if res as (i32) == Enum5::YKPIV_OK as (i32) && (cbBuf > 0usize) { - cbRealloc = if ::std::mem::size_of::<_ykpiv_key>() + if res as (i32) == ErrorKind::YKPIV_OK as (i32) && (cbBuf > 0usize) { + cbRealloc = if mem::size_of::<_ykpiv_key>() .wrapping_add(cbBuf) .wrapping_sub(1usize) > cbData.wrapping_sub(offset) { - (if ::std::mem::size_of::<_ykpiv_key>() + (if mem::size_of::<_ykpiv_key>() .wrapping_add(cbBuf) .wrapping_sub(1usize) .wrapping_sub(cbData.wrapping_sub(offset)) > CB_PAGE { - ::std::mem::size_of::<_ykpiv_key>() + mem::size_of::<_ykpiv_key>() .wrapping_add(cbBuf) .wrapping_sub(1usize) .wrapping_sub(cbData.wrapping_sub(offset)) @@ -823,7 +687,7 @@ pub unsafe extern "C" fn ykpiv_util_list_keys( if { pTemp = _ykpiv_realloc( state, - pData as (*mut ::std::os::raw::c_void), + pData as (*mut c_void), cbData.wrapping_add(cbRealloc), ) as (*mut u8); pTemp @@ -834,19 +698,19 @@ pub unsafe extern "C" fn ykpiv_util_list_keys( break; } pData = pTemp; - pTemp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + pTemp = 0i32 as (*mut c_void) as (*mut u8); } cbData = cbData.wrapping_add(cbRealloc); pKey = pData.offset(offset as (isize)) as (*mut _ykpiv_key); (*pKey).slot = *SLOTS.offset(i as (isize)); (*pKey).cert_len = cbBuf as (u16); memcpy( - (*pKey).cert.as_mut_ptr() as (*mut ::std::os::raw::c_void), - buf.as_mut_ptr() as (*const ::std::os::raw::c_void), + (*pKey).cert.as_mut_ptr() as (*mut c_void), + buf.as_mut_ptr() as (*const c_void), cbBuf, ); offset = offset.wrapping_add( - ::std::mem::size_of::<_ykpiv_key>() + mem::size_of::<_ykpiv_key>() .wrapping_add(cbBuf) .wrapping_sub(1usize), ); @@ -856,74 +720,66 @@ pub unsafe extern "C" fn ykpiv_util_list_keys( } if _currentBlock == 6 { *data = pData as (*mut _ykpiv_key); - pData = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + pData = 0i32 as (*mut c_void) as (*mut u8); if !data_len.is_null() { *data_len = offset; } - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } } } if !pData.is_null() { - _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, pData as (*mut c_void)); } _ykpiv_end_transaction(state); res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_free( - mut state: *mut ykpiv_state, - mut data: *mut ::std::os::raw::c_void, -) -> Enum5 { - if data.is_null() { - Enum5::YKPIV_OK - } else if state.is_null() || (*state).allocator.pfn_free == 0 { - Enum5::YKPIV_GENERIC_ERROR - } else { - _ykpiv_free(state, data); - Enum5::YKPIV_OK +pub fn ykpiv_util_free(mut _state: *mut ykpiv_state, mut data: *mut c_void) -> ErrorKind { + if !data.is_null() { + free(data); } + + ErrorKind::YKPIV_OK } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_read_cert( +pub fn ykpiv_util_read_cert( mut state: *mut ykpiv_state, mut slot: u8, mut data: *mut *mut u8, mut data_len: *mut usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3072]; - let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>(); - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut u8) == data - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == data_len + let mut cbBuf: usize = mem::size_of::<[u8; 3072]>(); + if 0i32 as (*mut c_void) as (*mut *mut u8) == data + || 0i32 as (*mut c_void) as (*mut usize) == data_len { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { *data = 0i32 as (*mut u8); *data_len = 0usize; - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = _read_certificate(state, slot, buf.as_mut_ptr(), &mut cbBuf as (*mut usize)); res } as (i32) { if cbBuf == 0usize { - *data = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *data = 0i32 as (*mut c_void) as (*mut u8); *data_len = 0usize; } else if { *data = _ykpiv_alloc(state, cbBuf) as (*mut u8); @@ -931,11 +787,11 @@ pub unsafe extern "C" fn ykpiv_util_read_cert( } .is_null() { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { memcpy( - *data as (*mut ::std::os::raw::c_void), - buf.as_mut_ptr() as (*const ::std::os::raw::c_void), + *data as (*mut c_void), + buf.as_mut_ptr() as (*const c_void), cbBuf, ); *data_len = cbBuf; @@ -947,23 +803,22 @@ pub unsafe extern "C" fn ykpiv_util_read_cert( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_write_cert( +pub fn ykpiv_util_write_cert( mut state: *mut ykpiv_state, mut slot: u8, mut data: *mut u8, mut data_len: usize, mut certinfo: u8, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - if Enum5::YKPIV_OK as (i32) != { +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -975,41 +830,30 @@ pub unsafe extern "C" fn ykpiv_util_write_cert( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_delete_cert( - mut state: *mut ykpiv_state, - mut slot: u8, -) -> Enum5 { - ykpiv_util_write_cert( - state, - slot, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize, - 0u8, - ) +pub fn ykpiv_util_delete_cert(mut state: *mut ykpiv_state, mut slot: u8) -> ErrorKind { + ykpiv_util_write_cert(state, slot, 0i32 as (*mut c_void) as (*mut u8), 0usize, 0u8) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> Enum5 { +pub fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut puk: *mut u8 = 0x30i32 as (*mut u8); let mut tries: i32 = -1i32; let mut data: [u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_item: usize = 0usize; let mut flags: u8 = 0u8; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32) @@ -1021,13 +865,13 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En 'loop3: loop { if _currentBlock == 3 { if tries != 0i32 { - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = ykpiv_change_puk( state, puk as (*const u8), - ::std::mem::size_of::<*mut u8>(), + mem::size_of::<*mut u8>(), puk as (*const u8), - ::std::mem::size_of::<*mut u8>(), + mem::size_of::<*mut u8>(), &mut tries as (*mut i32), ); res @@ -1038,16 +882,16 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En *_lhs = (*_lhs as (i32) + _rhs) as (u8); _currentBlock = 3; } else { - if !(Enum5::YKPIV_PIN_LOCKED as (i32) == res as (i32)) { + if !(ErrorKind::YKPIV_PIN_LOCKED as (i32) == res as (i32)) { _currentBlock = 3; continue; } tries = 0i32; - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; _currentBlock = 3; } } else { - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _read_metadata( state, 0x80u8, @@ -1055,7 +899,7 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En &mut cb_data as (*mut usize), ) as (i32) { - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -1064,41 +908,39 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En &mut cb_item as (*mut usize), ) as (i32) { - if ::std::mem::size_of::() == cb_item { + if mem::size_of::() == cb_item { memcpy( - &mut flags as (*mut u8) as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), + &mut flags as (*mut u8) as (*mut c_void), + p_item as (*const c_void), cb_item, ); } else if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"admin flags exist, but are incorrect size = %lu\0") - .as_ptr(), + eprintln!( + "admin flags exist, but are incorrect size = {}", cb_item, ); } } } flags = (flags as (i32) | 0x1i32) as (u8); - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) != _set_metadata_item( data.as_mut_ptr(), &mut cb_data as (*mut usize), 3063usize, 0x81u8, &mut flags as (*mut u8), - ::std::mem::size_of::(), + mem::size_of::(), ) as (i32) { if (*state).verbose == 0 { _currentBlock = 20; continue; } - fprintf(__stderrp, (*b"could not set admin flags\0").as_ptr()); + eprintln!("could not set admin flags"); _currentBlock = 20; } else { - if !(Enum5::YKPIV_OK as (i32) + if !(ErrorKind::YKPIV_OK as (i32) != _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data) as (i32)) { _currentBlock = 20; @@ -1108,7 +950,7 @@ pub unsafe extern "C" fn ykpiv_util_block_puk(mut state: *mut ykpiv_state) -> En _currentBlock = 20; continue; } - fprintf(__stderrp, (*b"could not write admin metadata\0").as_ptr()); + eprintln!("could not write admin metadata"); _currentBlock = 20; } } @@ -1139,35 +981,34 @@ impl Clone for _ykpiv_container { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_read_mscmap( +pub fn ykpiv_util_read_mscmap( mut state: *mut ykpiv_state, mut containers: *mut *mut _ykpiv_container, mut n_containers: *mut usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3072]; - let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>(); + let mut cbBuf: usize = mem::size_of::<[u8; 3072]>(); let mut len: usize = 0usize; - let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut *mut _ykpiv_container) == containers - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut usize) == n_containers + let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); + if 0i32 as (*mut c_void) as (*mut *mut _ykpiv_container) == containers + || 0i32 as (*mut c_void) as (*mut usize) == n_containers { - res = Enum5::YKPIV_GENERIC_ERROR; - } else if Enum5::YKPIV_OK as (i32) != { + res = ErrorKind::YKPIV_GENERIC_ERROR; + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - return Enum5::YKPIV_PCSC_ERROR; - } else if !(Enum5::YKPIV_OK as (i32) != { + return ErrorKind::YKPIV_PCSC_ERROR; + } else if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { *containers = 0i32 as (*mut _ykpiv_container); *n_containers = 0usize; - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = _ykpiv_fetch_object( state, 0x5fff10i32, @@ -1179,7 +1020,7 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap( { ptr = buf.as_mut_ptr(); if cbBuf < 2usize { - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else if *{ let _old = ptr; ptr = ptr.offset(1isize); @@ -1194,23 +1035,18 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap( if len > cbBuf.wrapping_sub( ((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize)) - as (usize), + / mem::size_of::() as (isize)) as (usize), ) { - res = Enum5::YKPIV_OK; - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == { + res = ErrorKind::YKPIV_OK; + } else if 0i32 as (*mut c_void) as (*mut _ykpiv_container) == { *containers = _ykpiv_alloc(state, len) as (*mut _ykpiv_container); *containers } { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { - memcpy( - *containers as (*mut ::std::os::raw::c_void), - ptr as (*const ::std::os::raw::c_void), - len, - ); - *n_containers = len.wrapping_div(::std::mem::size_of::<_ykpiv_container>()); + memcpy(*containers as (*mut c_void), ptr as (*const c_void), len); + *n_containers = len.wrapping_div(mem::size_of::<_ykpiv_container>()); } } } @@ -1219,7 +1055,7 @@ pub unsafe extern "C" fn ykpiv_util_read_mscmap( res } -unsafe extern "C" fn _obj_size_max(mut state: *mut ykpiv_state) -> usize { +unsafe fn _obj_size_max(mut state: *mut ykpiv_state) -> usize { (if !state.is_null() && (*state).isNEO { 2048i32 - 9i32 } else { @@ -1227,41 +1063,40 @@ unsafe extern "C" fn _obj_size_max(mut state: *mut ykpiv_state) -> usize { }) as (usize) } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_write_mscmap( +pub fn ykpiv_util_write_mscmap( mut state: *mut ykpiv_state, mut containers: *mut _ykpiv_container, mut n_containers: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3063]; let mut offset: usize = 0usize; let mut req_len: usize = 0usize; - let mut data_len: usize = n_containers.wrapping_mul(::std::mem::size_of::<_ykpiv_container>()); - if Enum5::YKPIV_OK as (i32) != { + let mut data_len: usize = n_containers.wrapping_mul(mem::size_of::<_ykpiv_container>()); + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) == containers + if 0i32 as (*mut c_void) as (*mut _ykpiv_container) == containers || 0usize == n_containers { - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_container) != containers + if 0i32 as (*mut c_void) as (*mut _ykpiv_container) != containers || 0usize != n_containers { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } else { res = _ykpiv_save_object( state, 0x5fff10i32, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0i32 as (*mut c_void) as (*mut u8), 0usize, ); } @@ -1270,7 +1105,7 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap( .wrapping_add(_ykpiv_set_length(buf.as_mut_ptr(), data_len) as (usize)) .wrapping_add(data_len); if req_len > _obj_size_max(state) { - res = Enum5::YKPIV_SIZE_ERROR; + res = ErrorKind::YKPIV_SIZE_ERROR; } else { buf[{ let _old = offset; @@ -1282,8 +1117,8 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap( data_len, ) as (usize)); memcpy( - buf.as_mut_ptr().offset(offset as (isize)) as (*mut ::std::os::raw::c_void), - containers as (*mut u8) as (*const ::std::os::raw::c_void), + buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void), + containers as (*mut u8) as (*const c_void), data_len, ); offset = offset.wrapping_add(data_len); @@ -1296,35 +1131,34 @@ pub unsafe extern "C" fn ykpiv_util_write_mscmap( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_read_msroots( +pub fn ykpiv_util_read_msroots( mut state: *mut ykpiv_state, mut data: *mut *mut u8, mut data_len: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3072]; - let mut cbBuf: usize = ::std::mem::size_of::<[u8; 3072]>(); + let mut cbBuf: usize = mem::size_of::<[u8; 3072]>(); let mut len: usize = 0usize; - let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut object_id: i32 = 0i32; let mut tag: u8 = 0u8; - let mut pData: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); - let mut pTemp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut pData: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); + let mut pTemp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cbData: usize = 0usize; let mut cbRealloc: usize = 0usize; let mut offset: usize = 0usize; if data.is_null() || data_len.is_null() { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -1332,11 +1166,11 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( *data = 0i32 as (*mut u8); *data_len = 0usize; cbData = _obj_size_max(state); - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { + if 0i32 as (*mut c_void) as (*mut u8) == { pData = _ykpiv_alloc(state, cbData) as (*mut u8); pData } { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { object_id = 0x5fff11i32; 'loop5: loop { @@ -1344,8 +1178,8 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( _currentBlock = 15; break; } - cbBuf = ::std::mem::size_of::<[u8; 3072]>(); - if Enum5::YKPIV_OK as (i32) != { + cbBuf = mem::size_of::<[u8; 3072]>(); + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_fetch_object( state, object_id, @@ -1380,7 +1214,7 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( if len > cbBuf.wrapping_sub( ((ptr as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize)) + / mem::size_of::() as (isize)) as (usize), ) { @@ -1396,7 +1230,7 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( if { pTemp = _ykpiv_realloc( state, - pData as (*mut ::std::os::raw::c_void), + pData as (*mut c_void), cbData.wrapping_add(cbRealloc), ) as (*mut u8); pTemp @@ -1407,12 +1241,12 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( break; } pData = pTemp; - pTemp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + pTemp = 0i32 as (*mut c_void) as (*mut u8); } cbData = cbData.wrapping_add(cbRealloc); memcpy( - pData.offset(offset as (isize)) as (*mut ::std::os::raw::c_void), - ptr as (*const ::std::os::raw::c_void), + pData.offset(offset as (isize)) as (*mut c_void), + ptr as (*const c_void), len, ); offset = offset.wrapping_add(len); @@ -1425,35 +1259,34 @@ pub unsafe extern "C" fn ykpiv_util_read_msroots( if _currentBlock == 21 { } else if _currentBlock == 15 { *data = pData; - pData = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + pData = 0i32 as (*mut c_void) as (*mut u8); *data_len = offset; - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else if _currentBlock == 16 { - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else if _currentBlock == 17 { - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else if _currentBlock == 18 { - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } else { - res = Enum5::YKPIV_OK; + res = ErrorKind::YKPIV_OK; } } } if !pData.is_null() { - _ykpiv_free(state, pData as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, pData as (*mut c_void)); } _ykpiv_end_transaction(state); res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_write_msroots( +pub fn ykpiv_util_write_msroots( mut state: *mut ykpiv_state, mut data: *mut u8, mut data_len: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf: [u8; 3063]; let mut offset: usize = 0usize; let mut data_offset: usize = 0usize; @@ -1461,27 +1294,26 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots( let mut n_objs: usize = 0usize; let mut i: u32 = 0u32; let mut cb_obj_max: usize = _obj_size_max(state); - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == data || 0usize == data_len { - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) != data || 0usize != data_len - { - res = Enum5::YKPIV_GENERIC_ERROR; + if 0i32 as (*mut c_void) as (*mut u8) == data || 0usize == data_len { + if 0i32 as (*mut c_void) as (*mut u8) != data || 0usize != data_len { + res = ErrorKind::YKPIV_GENERIC_ERROR; } else { res = _ykpiv_save_object( state, 0x5fff11i32, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0i32 as (*mut c_void) as (*mut u8), 0usize, ); } @@ -1490,7 +1322,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots( .wrapping_div(cb_obj_max.wrapping_sub((2i32 + 2i32) as (usize))) .wrapping_add(1usize); if n_objs > 5usize { - res = Enum5::YKPIV_SIZE_ERROR; + res = ErrorKind::YKPIV_SIZE_ERROR; } else { i = 0u32; 'loop5: loop { @@ -1519,9 +1351,8 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots( data_chunk, ) as (usize)); memcpy( - buf.as_mut_ptr().offset(offset as (isize)) - as (*mut ::std::os::raw::c_void), - data.offset(data_offset as (isize)) as (*const ::std::os::raw::c_void), + buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void), + data.offset(data_offset as (isize)) as (*const c_void), data_chunk, ); offset = offset.wrapping_add(data_chunk); @@ -1531,7 +1362,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots( buf.as_mut_ptr(), offset, ); - if Enum5::YKPIV_OK as (i32) != res as (i32) { + if ErrorKind::YKPIV_OK as (i32) != res as (i32) { break; } data_offset = data_offset.wrapping_add(data_chunk); @@ -1545,29 +1376,7 @@ pub unsafe extern "C" fn ykpiv_util_write_msroots( } } -#[derive(Clone, Copy)] -#[repr(i32)] -pub enum _setting_source_t { - SETTING_SOURCE_USER, - SETTING_SOURCE_ADMIN, - SETTING_SOURCE_DEFAULT, -} - -#[derive(Copy)] -#[repr(C)] -pub struct _setting_bool_t { - pub value: bool, - pub source: _setting_source_t, -} - -impl Clone for _setting_bool_t { - fn clone(&self) -> Self { - *self - } -} - -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_generate_key( +pub unsafe fn ykpiv_util_generate_key( mut state: *mut ykpiv_state, mut slot: u8, mut algorithm: u8, @@ -1579,45 +1388,35 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( mut exp_len: *mut usize, mut point: *mut *mut u8, mut point_len: *mut usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut in_data: [u8; 11]; let mut in_ptr: *mut u8 = in_data.as_mut_ptr(); let mut data: [u8; 1024]; let mut templ: *mut u8 = 0i32 as (*mut u8); - let mut recv_len: usize = ::std::mem::size_of::<[u8; 1024]>(); + let mut recv_len: usize = mem::size_of::<[u8; 1024]>(); let mut sw: i32; - let mut ptr_modulus: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut ptr_modulus: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_modulus: usize = 0usize; - let mut ptr_exp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut ptr_exp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_exp: usize = 0usize; - let mut ptr_point: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut ptr_point: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_point: usize = 0usize; - let mut setting_roca = _setting_bool_t { + let mut setting_roca = SettingBool { value: false, - source: _setting_source_t::SETTING_SOURCE_DEFAULT, + source: SettingSource::SETTING_SOURCE_DEFAULT, }; - let mut sz_setting_roca: *const u8 = (*b"Enable_Unsafe_Keygen_ROCA\0").as_ptr(); - let mut sz_roca_format - : *const u8 - = (*b"YubiKey serial number %u is affected by vulnerability CVE-2017-15361 (ROCA) and should be replaced. On-chip key generation %s See YSA-2017-01 for additional information on device replacement and mitigation assistance.\n\0").as_ptr( - ); - let mut sz_roca_allow_user: *const u8 = - (*b"was permitted by an end-user configuration setting, but is not recommended.\0") - .as_ptr(); - let mut sz_roca_allow_admin: *const u8 = - (*b"was permitted by an administrator configuration setting, but is not recommended.\0") - .as_ptr(); - let mut sz_roca_block_user: *const u8 = - (*b"was blocked due to an end-user configuration setting.\0").as_ptr(); - let mut sz_roca_block_admin: *const u8 = - (*b"was blocked due to an administrator configuration setting.\0").as_ptr(); - let mut sz_roca_default - : *const u8 - = (*b"was permitted by default, but is not recommended. The default behavior will change in a future Yubico release.\0").as_ptr( - ); + let sz_setting_roca: &str = "Enable_Unsafe_Keygen_ROCA"; + let sz_roca_allow_user: &str = + "was permitted by an end-user configuration setting, but is not recommended."; + let sz_roca_allow_admin: &str = + "was permitted by an administrator configuration setting, but is not recommended."; + let sz_roca_block_user: &str = "was blocked due to an end-user configuration setting."; + let sz_roca_block_admin: &str = "was blocked due to an administrator configuration setting."; + let sz_roca_default: &str = "was permitted by default, but is not recommended. The default behavior will change in a future Yubico release."; + if state.is_null() { - Enum5::YKPIV_ARGUMENT_ERROR + ErrorKind::YKPIV_ARGUMENT_ERROR } else { if ykpiv_util_devicemodel(state) == (0x594b0000i32 | 0x34i32) as (u32) && (algorithm as (i32) == 0x6i32 || algorithm as (i32) == 0x7i32) @@ -1626,72 +1425,76 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( && ((*state).ver.minor as (i32) < 3i32 || (*state).ver.minor as (i32) == 3i32 && ((*state).ver.patch as (i32) < 5i32)) { - let mut psz_msg: *const u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*const u8); - setting_roca = setting_get_bool(sz_setting_roca, true); + let setting_name = CString::new(sz_setting_roca).unwrap(); + setting_roca = setting_get_bool(setting_name.as_ptr(), true); let switch9 = setting_roca.source; - if switch9 as (i32) == _setting_source_t::SETTING_SOURCE_USER as (i32) { - psz_msg = if setting_roca.value { + + let psz_msg = if switch9 as (i32) == SettingSource::SETTING_SOURCE_USER as (i32) { + if setting_roca.value { sz_roca_allow_user } else { sz_roca_block_user - }; - } else if switch9 as (i32) == _setting_source_t::SETTING_SOURCE_ADMIN as (i32) { - psz_msg = if setting_roca.value { + } + } else if switch9 as (i32) == SettingSource::SETTING_SOURCE_ADMIN as (i32) { + if setting_roca.value { sz_roca_allow_admin } else { sz_roca_block_admin - }; + } } else { - psz_msg = sz_roca_default; - } - fprintf(__stderrp, sz_roca_format, (*state).serial, psz_msg); + sz_roca_default + }; + + eprintln!( + "YubiKey serial number {} is affected by vulnerability CVE-2017-15361 \ + (ROCA) and should be replaced. On-chip key generation {} See \ + YSA-2017-01 \ + for additional information on device replacement and mitigation assistance", + (*state).serial, + psz_msg + ); + if !setting_roca.value { - return Enum5::YKPIV_NOT_SUPPORTED; + return ErrorKind::YKPIV_NOT_SUPPORTED; } } } if algorithm as (i32) == 0x14i32 || algorithm as (i32) == 0x11i32 { if point.is_null() || point_len.is_null() { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Invalid output parameter for ECC algorithm\0").as_ptr(), - ); + eprintln!("Invalid output parameter for ECC algorithm",); } - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } else { - *point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *point = 0i32 as (*mut c_void) as (*mut u8); *point_len = 0usize; } } else if algorithm as (i32) == 0x7i32 || algorithm as (i32) == 0x6i32 { if modulus.is_null() || modulus_len.is_null() || exp.is_null() || exp_len.is_null() { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Invalid output parameter for RSA algorithm\0").as_ptr(), - ); + eprintln!("Invalid output parameter for RSA algorithm",); } - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } else { - *modulus = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *modulus = 0i32 as (*mut c_void) as (*mut u8); *modulus_len = 0usize; - *exp = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *exp = 0i32 as (*mut c_void) as (*mut u8); *exp_len = 0usize; } } else { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Invalid algorithm specified\0").as_ptr()); + eprintln!("Invalid algorithm specified"); } - return Enum5::YKPIV_GENERIC_ERROR; + return ErrorKind::YKPIV_GENERIC_ERROR; } - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -1723,9 +1526,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( _old } = algorithm; if in_data[4usize] as (i32) == 0i32 { - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Unexpected algorithm.\n\0").as_ptr()); + eprintln!("Unexpected algorithm.\n"); } } else { if pin_policy as (i32) != 0i32 { @@ -1768,13 +1571,13 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( _old } = touch_policy; } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_transfer_data( state, templ as (*const u8), in_data.as_mut_ptr() as (*const u8), (in_ptr as (isize)).wrapping_sub(in_data.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize), + / mem::size_of::() as (isize), data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), @@ -1783,46 +1586,37 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( } as (i32) { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Failed to communicate.\n\0").as_ptr()); + eprintln!("Failed to communicate.\n"); } } else if sw != 0x9000i32 { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Failed to generate new key (\0").as_ptr()); + eprintln!("Failed to generate new key ("); } if sw == 0x6b00i32 { - res = Enum5::YKPIV_KEY_ERROR; + res = ErrorKind::YKPIV_KEY_ERROR; if (*state).verbose != 0 { - fprintf(__stderrp, (*b"incorrect slot)\n\0").as_ptr()); + eprintln!("incorrect slot)\n"); } } else if sw == 0x6a80i32 { - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; if (*state).verbose != 0 { if pin_policy as (i32) != 0i32 { - fprintf( - __stderrp, - (*b"pin policy not supported?)\n\0").as_ptr(), - ); + eprintln!("pin policy not supported?)\n",); } else if touch_policy as (i32) != 0i32 { - fprintf( - __stderrp, - (*b"touch policy not supported?)\n\0").as_ptr(), - ); + eprintln!("touch policy not supported?)\n",); } else { - fprintf( - __stderrp, - (*b"algorithm not supported?)\n\0").as_ptr(), - ); + eprintln!("algorithm not supported?)\n",); } } } else if sw == 0x6982i32 { - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; if (*state).verbose != 0 { - fprintf(__stderrp, (*b"not authenticated)\n\0").as_ptr()); + eprintln!("not authenticated)"); } } else { - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; if (*state).verbose != 0 { - fprintf(__stderrp, (*b"error %x)\n\0").as_ptr(), sw); + eprintln!("error {:x})", sw); } } } else if 0x6i32 == algorithm as (i32) || 0x7i32 == algorithm as (i32) { @@ -1830,13 +1624,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( let mut len: usize = 0usize; if *data_ptr as (i32) != 0x81i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to parse public key structure (modulus).\n\0") - .as_ptr(), - ); + eprintln!("Failed to parse public key structure (modulus)."); } - res = Enum5::YKPIV_PARSE_ERROR; + res = ErrorKind::YKPIV_PARSE_ERROR; } else { data_ptr = data_ptr.offset(1isize); data_ptr = data_ptr.offset(_ykpiv_get_length( @@ -1844,33 +1634,26 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( &mut len as (*mut usize), ) as (isize)); cb_modulus = len; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { + if 0i32 as (*mut c_void) as (*mut u8) == { ptr_modulus = _ykpiv_alloc(state, cb_modulus) as (*mut u8); ptr_modulus } { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to allocate memory for modulus.\n\0").as_ptr(), - ); + eprintln!("Failed to allocate memory for modulus."); } - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { memcpy( - ptr_modulus as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), + ptr_modulus as (*mut c_void), + data_ptr as (*const c_void), cb_modulus, ); data_ptr = data_ptr.offset(len as (isize)); if *data_ptr as (i32) != 0x82i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to parse public key structure (public exponent).\n\0").as_ptr( - ) - ); + eprintln!("Failed to parse public key structure (public exponent)."); } - res = Enum5::YKPIV_PARSE_ERROR; + res = ErrorKind::YKPIV_PARSE_ERROR; } else { data_ptr = data_ptr.offset(1isize); data_ptr = data_ptr.offset(_ykpiv_get_length( @@ -1879,31 +1662,27 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( ) as (isize)); cb_exp = len; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { + if 0i32 as (*mut c_void) as (*mut u8) == { ptr_exp = _ykpiv_alloc(state, cb_exp) as (*mut u8); ptr_exp } { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to allocate memory for public exponent.\n\0").as_ptr( - ) - ); + eprintln!( + "Failed to allocate memory for public exponent." + ); } - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { memcpy( - ptr_exp as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), + ptr_exp as (*mut c_void), + data_ptr as (*const c_void), cb_exp, ); *modulus = ptr_modulus; - ptr_modulus = - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + ptr_modulus = 0i32 as (*mut c_void) as (*mut u8); *modulus_len = cb_modulus; *exp = ptr_exp; - ptr_exp = - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + ptr_exp = 0i32 as (*mut c_void) as (*mut u8); *exp_len = cb_exp; } } @@ -1925,12 +1704,9 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( != 0x86i32 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to parse public key structure.\n\0").as_ptr(), - ); + eprintln!("Failed to parse public key structure.\n",); } - res = Enum5::YKPIV_PARSE_ERROR; + res = ErrorKind::YKPIV_PARSE_ERROR; } else if *{ let _old = data_ptr; data_ptr = data_ptr.offset(1isize); @@ -1939,50 +1715,46 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( != len { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Unexpected length.\n\0").as_ptr()); + eprintln!("Unexpected length.\n"); } - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; } else { cb_point = len; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == { + if 0i32 as (*mut c_void) as (*mut u8) == { ptr_point = _ykpiv_alloc(state, cb_point) as (*mut u8); ptr_point } { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"Failed to allocate memory for public point.\n\0") - .as_ptr(), - ); + eprintln!("Failed to allocate memory for public point."); } - res = Enum5::YKPIV_MEMORY_ERROR; + res = ErrorKind::YKPIV_MEMORY_ERROR; } else { memcpy( - ptr_point as (*mut ::std::os::raw::c_void), - data_ptr as (*const ::std::os::raw::c_void), + ptr_point as (*mut c_void), + data_ptr as (*const c_void), cb_point, ); *point = ptr_point; - ptr_point = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + ptr_point = 0i32 as (*mut c_void) as (*mut u8); *point_len = cb_point; } } } else { if (*state).verbose != 0 { - fprintf(__stderrp, (*b"Wrong algorithm.\n\0").as_ptr()); + eprintln!("Wrong algorithm."); } - res = Enum5::YKPIV_ALGORITHM_ERROR; + res = ErrorKind::YKPIV_ALGORITHM_ERROR; } } } if !ptr_modulus.is_null() { - _ykpiv_free(state, modulus as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, modulus as (*mut c_void)); } if !ptr_exp.is_null() { - _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, ptr_exp as (*mut c_void)); } if !ptr_point.is_null() { - _ykpiv_free(state, ptr_exp as (*mut ::std::os::raw::c_void)); + _ykpiv_free(state, ptr_exp as (*mut c_void)); } _ykpiv_end_transaction(state); res @@ -1992,6 +1764,7 @@ pub unsafe extern "C" fn ykpiv_util_generate_key( #[derive(Clone, Copy)] #[repr(i32)] +#[allow(non_camel_case_types)] pub enum Enum10 { YKPIV_CONFIG_MGM_MANUAL = 0i32, YKPIV_CONFIG_MGM_DERIVED = 1i32, @@ -2014,39 +1787,38 @@ impl Clone for _ykpiv_config { } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_get_config( +pub fn ykpiv_util_get_config( mut state: *mut ykpiv_state, mut config: *mut _ykpiv_config, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut data = [0u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_item: usize = 0usize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_config) == config { - Enum5::YKPIV_GENERIC_ERROR + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if 0i32 as (*mut c_void) as (*mut _ykpiv_config) == config { + ErrorKind::YKPIV_GENERIC_ERROR } else { (*config).protected_data_available = 0u8; (*config).puk_blocked = 0u8; (*config).puk_noblock_on_upgrade = 0u8; (*config).pin_last_changed = 0u32; (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_MANUAL; - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _read_metadata( state, 0x80u8, @@ -2054,7 +1826,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config( &mut cb_data as (*mut usize), ) as (i32) { - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2070,7 +1842,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config( (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_PROTECTED; } } - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2081,17 +1853,13 @@ pub unsafe extern "C" fn ykpiv_util_get_config( { if (*config).mgm_type as (i32) != Enum10::YKPIV_CONFIG_MGM_MANUAL as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"conflicting types of mgm key administration configured\n\0").as_ptr( - ) - ); + eprintln!("conflicting types of mgm key administration configured"); } } else { (*config).mgm_type = Enum10::YKPIV_CONFIG_MGM_DERIVED; } } - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2102,24 +1870,19 @@ pub unsafe extern "C" fn ykpiv_util_get_config( { if 4usize != cb_item { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"pin timestamp in admin metadata is an invalid size\0") - .as_ptr(), - ); + eprintln!("pin timestamp in admin metadata is an invalid size"); } } else { memcpy( - &mut (*config).pin_last_changed as (*mut u32) - as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), + &mut (*config).pin_last_changed as (*mut u32) as (*mut c_void), + p_item as (*const c_void), cb_item, ); } } } - cb_data = ::std::mem::size_of::<[u8; 3072]>(); - if Enum5::YKPIV_OK as (i32) + cb_data = mem::size_of::<[u8; 3072]>(); + if ErrorKind::YKPIV_OK as (i32) == _read_metadata( state, 0x88u8, @@ -2128,7 +1891,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config( ) as (i32) { (*config).protected_data_available = 1u8; - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2141,7 +1904,7 @@ pub unsafe extern "C" fn ykpiv_util_get_config( (*config).puk_noblock_on_upgrade = 1u8; } } - if Enum5::YKPIV_OK as (i32) + if ErrorKind::YKPIV_OK as (i32) == _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2154,10 +1917,8 @@ pub unsafe extern "C" fn ykpiv_util_get_config( != Enum10::YKPIV_CONFIG_MGM_PROTECTED as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"conflicting types of mgm key administration configured - protected mgm exists\n\0").as_ptr( - ) + eprintln!( + "conflicting types of mgm key administration configured - protected mgm exists" ); } } @@ -2171,28 +1932,27 @@ pub unsafe extern "C" fn ykpiv_util_get_config( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_state) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut ykrc: Enum5 = Enum5::YKPIV_OK; +pub fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_state) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut ykrc: ErrorKind = ErrorKind::YKPIV_OK; let mut data = [0u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut tnow: isize = 0isize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut tnow: time_t = 0; + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _read_metadata( state, 0x80u8, @@ -2204,37 +1964,29 @@ pub unsafe extern "C" fn ykpiv_util_set_pin_last_changed(mut state: *mut ykpiv_s { cb_data = 0usize; } - tnow = time(0i32 as (*mut ::std::os::raw::c_void) as (*mut isize)); - if Enum5::YKPIV_OK as (i32) != { + tnow = time(0 as *mut time_t); + if ErrorKind::YKPIV_OK as (i32) != { res = _set_metadata_item( data.as_mut_ptr(), &mut cb_data as (*mut usize), 3063usize, 0x83u8, - &mut tnow as (*mut isize) as (*mut u8), + mem::transmute(&mut tnow), 4usize, ); res } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not set pin timestamp, err = %d\n\0").as_ptr(), - res as (i32), - ); + eprintln!("could not set pin timestamp, err = {}\n", res as (i32),); } - } else if Enum5::YKPIV_OK as (i32) != { + } else if ErrorKind::YKPIV_OK as (i32) != { res = _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data); res } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not write admin data, err = %d\n\0").as_ptr(), - res as (i32), - ); + eprintln!("could not write admin data, err = {}", res as (i32),); } } } @@ -2262,39 +2014,38 @@ pub enum Enum11 { PKCS5_GENERAL_ERROR = -1i32, } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_get_derived_mgm( +pub fn ykpiv_util_get_derived_mgm( mut state: *mut ykpiv_state, mut pin: *const u8, pin_len: usize, mut mgm: *mut _ykpiv_mgm, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut p5rc: Enum11 = Enum11::PKCS5_OK; let mut data = [0u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_item: usize = 0usize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) == pin + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if 0i32 as (*mut c_void) as (*const u8) == pin || 0usize == pin_len - || 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm + || 0i32 as (*mut c_void) as (*mut _ykpiv_mgm) == mgm { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = _read_metadata( state, 0x80u8, @@ -2304,7 +2055,7 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm( res } as (i32) { - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2317,14 +2068,12 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm( { if cb_item != 16usize { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"derived mgm salt exists, but is incorrect size = %lu\n\0") - .as_ptr(), + eprintln!( + "derived mgm salt exists, but is incorrect size = {}", cb_item, ); } - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } else if Enum11::PKCS5_OK as (i32) != { p5rc = pkcs5_pbkdf2_sha1( pin, @@ -2333,19 +2082,15 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm( cb_item, 10000usize, (*mgm).data.as_mut_ptr() as (*const u8), - ::std::mem::size_of::<[u8; 24]>(), + mem::size_of::<[u8; 24]>(), ); p5rc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"pbkdf2 failure, err = %d\n\0").as_ptr(), - p5rc as (i32), - ); + eprintln!("pbkdf2 failure, err = {}", p5rc as (i32)); } - res = Enum5::YKPIV_GENERIC_ERROR; + res = ErrorKind::YKPIV_GENERIC_ERROR; } } } @@ -2355,33 +2100,32 @@ pub unsafe extern "C" fn ykpiv_util_get_derived_mgm( } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_get_protected_mgm( +pub fn ykpiv_util_get_protected_mgm( mut state: *mut ykpiv_state, mut mgm: *mut _ykpiv_mgm, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut data = [0u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_item: usize = 0usize; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut _ykpiv_mgm) == mgm { - Enum5::YKPIV_GENERIC_ERROR - } else if Enum5::YKPIV_OK as (i32) != { + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR + } else if 0i32 as (*mut c_void) as (*mut _ykpiv_mgm) == mgm { + ErrorKind::YKPIV_GENERIC_ERROR + } else if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - Enum5::YKPIV_PCSC_ERROR + ErrorKind::YKPIV_PCSC_ERROR } else { - if !(Enum5::YKPIV_OK as (i32) != { + if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) { - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _read_metadata( state, 0x88u8, @@ -2392,13 +2136,9 @@ pub unsafe extern "C" fn ykpiv_util_get_protected_mgm( } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not read protected data, err = %d\n\0").as_ptr(), - res as (i32), - ); + eprintln!("could not read protected data, err = {}", res as (i32),); } - } else if Enum5::YKPIV_OK as (i32) != { + } else if ErrorKind::YKPIV_OK as (i32) != { res = _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2410,72 +2150,69 @@ pub unsafe extern "C" fn ykpiv_util_get_protected_mgm( } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not read protected mgm from metadata, err = %d\n\0").as_ptr(), + eprintln!( + "could not read protected mgm from metadata, err = {}", res as (i32), ); } - } else if cb_item != ::std::mem::size_of::<[u8; 24]>() { + } else if cb_item != mem::size_of::<[u8; 24]>() { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"protected data contains mgm, but is the wrong size = %lu\n\0").as_ptr(), + eprintln!( + "protected data contains mgm, but is the wrong size = {}", cb_item, ); } - res = Enum5::YKPIV_AUTHENTICATION_ERROR; + res = ErrorKind::YKPIV_AUTHENTICATION_ERROR; } else { memcpy( - (*mgm).data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), + (*mgm).data.as_mut_ptr() as (*mut c_void), + p_item as (*const c_void), cb_item, ); } } memset_s( - data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 3072]>(), + data.as_mut_ptr() as (*mut c_void), + mem::size_of::<[u8; 3072]>(), 0i32, - ::std::mem::size_of::<[u8; 3072]>(), + mem::size_of::<[u8; 3072]>(), ); _ykpiv_end_transaction(state); res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( +pub fn ykpiv_util_set_protected_mgm( mut state: *mut ykpiv_state, mut mgm: *mut _ykpiv_mgm, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut ykrc: Enum5 = Enum5::YKPIV_OK; + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut ykrc: ErrorKind = ErrorKind::YKPIV_OK; let mut prngrc: Enum7 = Enum7::PRNG_OK; let mut fGenerate: bool = false; let mut mgm_key: [u8; 24]; let mut i: usize = 0usize; let mut data = [0u8; 3072]; - let mut cb_data: usize = ::std::mem::size_of::<[u8; 3072]>(); - let mut p_item: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut cb_data: usize = mem::size_of::<[u8; 3072]>(); + let mut p_item: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_item: usize = 0usize; let mut flags_1: u8 = 0u8; - if 0i32 as (*mut ::std::os::raw::c_void) as (*mut ykpiv_state) == state { - Enum5::YKPIV_GENERIC_ERROR + if 0i32 as (*mut c_void) as (*mut ykpiv_state) == state { + ErrorKind::YKPIV_GENERIC_ERROR } else { if mgm.is_null() { fGenerate = true; } else { fGenerate = true; memcpy( - mgm_key.as_mut_ptr() as (*mut ::std::os::raw::c_void), - (*mgm).data.as_mut_ptr() as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 24]>(), + mgm_key.as_mut_ptr() as (*mut c_void), + (*mgm).data.as_mut_ptr() as (*const c_void), + mem::size_of::<[u8; 24]>(), ); i = 0usize; 'loop3: loop { - if !(i < ::std::mem::size_of::<[u8; 24]>()) { + if !(i < mem::size_of::<[u8; 24]>()) { _currentBlock = 8; break; } @@ -2490,13 +2227,13 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( fGenerate = false; } } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_begin_transaction(state); res } as (i32) { - res = Enum5::YKPIV_PCSC_ERROR; - } else if !(Enum5::YKPIV_OK as (i32) != { + res = ErrorKind::YKPIV_PCSC_ERROR; + } else if !(ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_ensure_application_selected(state); res } as (i32)) @@ -2504,10 +2241,8 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( 'loop10: loop { if fGenerate { if Enum7::PRNG_OK as (i32) != { - prngrc = _ykpiv_prng_generate( - mgm_key.as_mut_ptr(), - ::std::mem::size_of::<[u8; 24]>(), - ); + prngrc = + _ykpiv_prng_generate(mgm_key.as_mut_ptr(), mem::size_of::<[u8; 24]>()); prngrc } as (i32) { @@ -2515,12 +2250,12 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( break; } } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = ykpiv_set_mgmkey(state, mgm_key.as_mut_ptr() as (*const u8)); ykrc } as (i32) { - if Enum5::YKPIV_KEY_ERROR as (i32) != ykrc as (i32) { + if ErrorKind::YKPIV_KEY_ERROR as (i32) != ykrc as (i32) { _currentBlock = 44; break; } @@ -2535,12 +2270,12 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( if _currentBlock == 16 { if !mgm.is_null() { memcpy( - (*mgm).data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - mgm_key.as_mut_ptr() as (*const ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 24]>(), + (*mgm).data.as_mut_ptr() as (*mut c_void), + mgm_key.as_mut_ptr() as (*const c_void), + mem::size_of::<[u8; 24]>(), ); } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _read_metadata( state, 0x88u8, @@ -2552,39 +2287,31 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( { cb_data = 0usize; } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _set_metadata_item( data.as_mut_ptr(), &mut cb_data as (*mut usize), 3063usize, 0x89u8, mgm_key.as_mut_ptr(), - ::std::mem::size_of::<[u8; 24]>(), + mem::size_of::<[u8; 24]>(), ); ykrc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not set protected mgm item, err = %d\n\0").as_ptr(), - ykrc as (i32), - ); + eprintln!("could not set protected mgm item, err = {}", ykrc as (i32),); _currentBlock = 26; } else { _currentBlock = 26; } - } else if Enum5::YKPIV_OK as (i32) != { + } else if ErrorKind::YKPIV_OK as (i32) != { ykrc = _write_metadata(state, 0x88u8, data.as_mut_ptr(), cb_data); ykrc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not write protected data, err = %d\n\0").as_ptr(), - ykrc as (i32), - ); + eprintln!("could not write protected data, err = {}", ykrc as (i32),); _currentBlock = 51; } else { _currentBlock = 51; @@ -2594,8 +2321,8 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( } if _currentBlock == 51 { } else { - cb_data = ::std::mem::size_of::<[u8; 3072]>(); - if Enum5::YKPIV_OK as (i32) != { + cb_data = mem::size_of::<[u8; 3072]>(); + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _read_metadata( state, 0x80u8, @@ -2607,7 +2334,7 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( { cb_data = 0usize; } else { - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _get_metadata_item( data.as_mut_ptr(), cb_data, @@ -2619,142 +2346,116 @@ pub unsafe extern "C" fn ykpiv_util_set_protected_mgm( } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"admin data exists, but flags are not present\n\0").as_ptr(), - ); + eprintln!("admin data exists, but flags are not present",); } } - if cb_item == ::std::mem::size_of::() { + if cb_item == mem::size_of::() { memcpy( - &mut flags_1 as (*mut u8) as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), + &mut flags_1 as (*mut u8) as (*mut c_void), + p_item as (*const c_void), cb_item, ); } else if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"admin data flags are an incorrect size = %lu\n\0").as_ptr(), - cb_item, - ); + eprintln!("admin data flags are an incorrect size = {}", cb_item,); } - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _set_metadata_item( data.as_mut_ptr(), &mut cb_data as (*mut usize), 3063usize, 0x82u8, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), + 0i32 as (*mut c_void) as (*mut u8), 0usize, ); ykrc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not unset derived mgm salt, err = %d\n\0").as_ptr(), + eprintln!( + "could not unset derived mgm salt, err = {}", ykrc as (i32), ); } } } flags_1 = (flags_1 as (i32) | 0x2i32) as (u8); - if Enum5::YKPIV_OK as (i32) != { + if ErrorKind::YKPIV_OK as (i32) != { ykrc = _set_metadata_item( data.as_mut_ptr(), &mut cb_data as (*mut usize), 3063usize, 0x81u8, &mut flags_1 as (*mut u8), - ::std::mem::size_of::(), + mem::size_of::(), ); ykrc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not set admin flags item, err = %d\n\0").as_ptr(), - ykrc as (i32), - ); + eprintln!("could not set admin flags item, err = {}", ykrc as (i32),); } - } else if Enum5::YKPIV_OK as (i32) != { + } else if ErrorKind::YKPIV_OK as (i32) != { ykrc = _write_metadata(state, 0x80u8, data.as_mut_ptr(), cb_data); ykrc } as (i32) { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not write admin data, err = %d\n\0").as_ptr(), - ykrc as (i32), - ); + eprintln!("could not write admin data, err = {}", ykrc as (i32),); } } } } else if _currentBlock == 44 { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not set new derived mgm key, err = %d\n\0").as_ptr(), - ykrc as (i32), - ); + eprintln!("could not set new derived mgm key, err = {}", ykrc as (i32),); } res = ykrc; } else { if (*state).verbose != 0 { - fprintf( - __stderrp, - (*b"could not generate new mgm, err = %d\n\0").as_ptr(), - prngrc as (i32), - ); + eprintln!("could not generate new mgm, err = {}", prngrc as (i32),); } - res = Enum5::YKPIV_RANDOMNESS_ERROR; + res = ErrorKind::YKPIV_RANDOMNESS_ERROR; } } memset_s( - data.as_mut_ptr() as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 3072]>(), + data.as_mut_ptr() as (*mut c_void), + mem::size_of::<[u8; 3072]>(), 0i32, - ::std::mem::size_of::<[u8; 3072]>(), + mem::size_of::<[u8; 3072]>(), ); memset_s( - mgm_key.as_mut_ptr() as (*mut ::std::os::raw::c_void), - ::std::mem::size_of::<[u8; 24]>(), + mgm_key.as_mut_ptr() as (*mut c_void), + mem::size_of::<[u8; 24]>(), 0i32, - ::std::mem::size_of::<[u8; 24]>(), + mem::size_of::<[u8; 24]>(), ); _ykpiv_end_transaction(state); res } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_reset(mut state: *mut ykpiv_state) -> Enum5 { +pub fn ykpiv_util_reset(mut state: *mut ykpiv_state) -> ErrorKind { let mut templ: *mut u8 = 0i32 as (*mut u8); let mut data: [u8; 255]; - let mut recv_len: usize = ::std::mem::size_of::<[u8; 255]>(); - let mut res: Enum5; + let mut recv_len: usize = mem::size_of::<[u8; 255]>(); + let mut res: ErrorKind; let mut sw: i32; res = ykpiv_transfer_data( state, templ as (*const u8), - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8), + 0i32 as (*mut c_void) as (*const u8), 0isize, data.as_mut_ptr(), &mut recv_len as (*mut usize), &mut sw as (*mut i32), ); - if Enum5::YKPIV_OK as (i32) == res as (i32) && (0x9000i32 == sw) { - Enum5::YKPIV_OK + if ErrorKind::YKPIV_OK as (i32) == res as (i32) && (0x9000i32 == sw) { + ErrorKind::YKPIV_OK } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } } -#[no_mangle] -pub unsafe extern "C" fn ykpiv_util_slot_object(mut slot: u8) -> u32 { +pub fn ykpiv_util_slot_object(mut slot: u8) -> u32 { let mut object_id: i32 = -1i32; if slot as (i32) == 0xf9i32 { object_id = 0x5fff01i32; @@ -2772,20 +2473,20 @@ pub unsafe extern "C" fn ykpiv_util_slot_object(mut slot: u8) -> u32 { object_id as (u32) } -unsafe extern "C" fn _read_certificate( +unsafe fn _read_certificate( mut state: *mut ykpiv_state, mut slot: u8, mut buf: *mut u8, mut buf_len: *mut usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut ptr: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut ptr: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut object_id: i32 = ykpiv_util_slot_object(slot) as (i32); let mut len: usize = 0usize; if -1i32 == object_id { - Enum5::YKPIV_INVALID_OBJECT + ErrorKind::YKPIV_INVALID_OBJECT } else { - if Enum5::YKPIV_OK as (i32) == { + if ErrorKind::YKPIV_OK as (i32) == { res = _ykpiv_fetch_object(state, object_id, buf, buf_len); res } as (i32) @@ -2793,7 +2494,7 @@ unsafe extern "C" fn _read_certificate( ptr = buf; if *buf_len < 2usize { *buf_len = 0usize; - return Enum5::YKPIV_OK; + return ErrorKind::YKPIV_OK; } else if *{ let _old = ptr; ptr = ptr.offset(1isize); @@ -2807,18 +2508,13 @@ unsafe extern "C" fn _read_certificate( if len > (*buf_len).wrapping_sub( ((ptr as (isize)).wrapping_sub(buf as (isize)) - / ::std::mem::size_of::() as (isize)) - as (usize), + / mem::size_of::() as (isize)) as (usize), ) { *buf_len = 0usize; - return Enum5::YKPIV_OK; + return ErrorKind::YKPIV_OK; } else { - memmove( - buf as (*mut ::std::os::raw::c_void), - ptr as (*const ::std::os::raw::c_void), - len, - ); + memmove(buf as (*mut c_void), ptr as (*const c_void), len); *buf_len = len; } } @@ -2829,38 +2525,33 @@ unsafe extern "C" fn _read_certificate( } } -unsafe extern "C" fn _write_certificate( +unsafe fn _write_certificate( mut state: *mut ykpiv_state, mut slot: u8, mut data: *mut u8, mut data_len: usize, mut certinfo: u8, -) -> Enum5 { +) -> ErrorKind { let mut buf: [u8; 3063]; let mut object_id: i32 = ykpiv_util_slot_object(slot) as (i32); let mut offset: usize = 0usize; let mut req_len: usize = 0usize; if -1i32 == object_id { - Enum5::YKPIV_INVALID_OBJECT - } else if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) == data || 0usize == data_len { - (if 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8) != data || 0usize != data_len { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_INVALID_OBJECT + } else if 0i32 as (*mut c_void) as (*mut u8) == data || 0usize == data_len { + (if 0i32 as (*mut c_void) as (*mut u8) != data || 0usize != data_len { + ErrorKind::YKPIV_GENERIC_ERROR } else { - _ykpiv_save_object( - state, - object_id, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize, - ) + _ykpiv_save_object(state, object_id, 0i32 as (*mut c_void) as (*mut u8), 0usize) }) } else { req_len = (1i32 + 3i32 + 2i32) as (usize); req_len = req_len.wrapping_add(_ykpiv_set_length(buf.as_mut_ptr(), data_len) as (usize)); req_len = req_len.wrapping_add(data_len); (if req_len < data_len { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else if req_len > _obj_size_max(state) { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR } else { buf[{ let _old = offset; @@ -2872,8 +2563,8 @@ unsafe extern "C" fn _write_certificate( data_len, ) as (usize)); memcpy( - buf.as_mut_ptr().offset(offset as (isize)) as (*mut ::std::os::raw::c_void), - data as (*const ::std::os::raw::c_void), + buf.as_mut_ptr().offset(offset as (isize)) as (*mut c_void), + data as (*const c_void), data_len, ); offset = offset.wrapping_add(data_len); @@ -2911,21 +2602,21 @@ unsafe extern "C" fn _write_certificate( } } -unsafe extern "C" fn _get_metadata_item( +unsafe fn _get_metadata_item( mut data: *mut u8, mut cb_data: usize, mut tag: u8, mut pp_item: *mut *mut u8, mut pcb_item: *mut usize, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut p_temp: *mut u8 = data; let mut cb_temp: usize = 0usize; let mut tag_temp: u8 = 0u8; if data.is_null() || pp_item.is_null() || pcb_item.is_null() { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { - *pp_item = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + *pp_item = 0i32 as (*mut c_void) as (*mut u8); *pcb_item = 0usize; 'loop2: loop { if !(p_temp < data.offset(cb_data as (isize))) { @@ -2940,7 +2631,7 @@ unsafe extern "C" fn _get_metadata_item( if !_ykpiv_has_valid_length( p_temp as (*const u8), ((data.offset(cb_data as (isize)) as (isize)).wrapping_sub(p_temp as (isize)) - / ::std::mem::size_of::() as (isize)) as (usize), + / mem::size_of::() as (isize)) as (usize), ) { _currentBlock = 9; break; @@ -2959,17 +2650,17 @@ unsafe extern "C" fn _get_metadata_item( (if p_temp < data.offset(cb_data as (isize)) { *pp_item = p_temp; *pcb_item = cb_temp; - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR }) } else { - Enum5::YKPIV_SIZE_ERROR + ErrorKind::YKPIV_SIZE_ERROR }) } } -unsafe extern "C" fn _get_length_size(mut length: usize) -> i32 { +unsafe fn _get_length_size(mut length: usize) -> i32 { if length < 0x80usize { 1i32 } else if length < 0xffusize { @@ -2979,23 +2670,23 @@ unsafe extern "C" fn _get_length_size(mut length: usize) -> i32 { } } -unsafe extern "C" fn _set_metadata_item( +unsafe fn _set_metadata_item( mut data: *mut u8, mut pcb_data: *mut usize, mut cb_data_max: usize, mut tag: u8, mut p_item: *mut u8, mut cb_item: usize, -) -> Enum5 { +) -> ErrorKind { let mut _currentBlock; let mut p_temp: *mut u8 = data; let mut cb_temp: usize = 0usize; let mut tag_temp: u8 = 0u8; let mut cb_len: usize = 0usize; - let mut p_next: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); + let mut p_next: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_moved: isize = 0isize; if data.is_null() || pcb_data.is_null() { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { 'loop1: loop { if !(p_temp < data.offset(*pcb_data as (isize))) { @@ -3018,12 +2709,12 @@ unsafe extern "C" fn _set_metadata_item( } (if _currentBlock == 2 { (if cb_item == 0usize { - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK } else { p_temp = data.offset(*pcb_data as (isize)); cb_len = _get_length_size(cb_item) as (usize); (if (*pcb_data).wrapping_add(cb_len).wrapping_add(cb_item) > cb_data_max { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { *{ let _old = p_temp; @@ -3031,23 +2722,15 @@ unsafe extern "C" fn _set_metadata_item( _old } = tag; p_temp = p_temp.offset(_ykpiv_set_length(p_temp, cb_item) as (isize)); - memcpy( - p_temp as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), - cb_item, - ); + memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item); *pcb_data = (*pcb_data).wrapping_add(1usize.wrapping_add(cb_len).wrapping_add(cb_item)); - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) }) } else if cb_temp == cb_item { - memcpy( - p_temp as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), - cb_item, - ); - Enum5::YKPIV_OK + memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item); + ErrorKind::YKPIV_OK } else { p_next = p_temp.offset(cb_temp as (isize)); cb_moved = cb_item as (isize) - cb_temp as (isize) @@ -3058,63 +2741,58 @@ unsafe extern "C" fn _set_metadata_item( } as (isize) - cb_len as (isize)); (if (*pcb_data).wrapping_add(cb_moved as (usize)) > cb_data_max { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { memmove( - p_next.offset(cb_moved) as (*mut ::std::os::raw::c_void), - p_next as (*const ::std::os::raw::c_void), + p_next.offset(cb_moved) as (*mut c_void), + p_next as (*const c_void), (*pcb_data).wrapping_sub( ((p_next as (isize)).wrapping_sub(data as (isize)) - / ::std::mem::size_of::() as (isize)) - as (usize), + / mem::size_of::() as (isize)) as (usize), ), ); *pcb_data = (*pcb_data).wrapping_add(cb_moved as (usize)); if cb_item != 0usize { p_temp = p_temp.offset(-(cb_len as (isize))); p_temp = p_temp.offset(_ykpiv_set_length(p_temp, cb_item) as (isize)); - memcpy( - p_temp as (*mut ::std::os::raw::c_void), - p_item as (*const ::std::os::raw::c_void), - cb_item, - ); + memcpy(p_temp as (*mut c_void), p_item as (*const c_void), cb_item); } - Enum5::YKPIV_OK + ErrorKind::YKPIV_OK }) }) } } -unsafe extern "C" fn _read_metadata( +unsafe fn _read_metadata( mut state: *mut ykpiv_state, mut tag: u8, mut data: *mut u8, mut pcb_data: *mut usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; - let mut p_temp: *mut u8 = 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8); +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; + let mut p_temp: *mut u8 = 0i32 as (*mut c_void) as (*mut u8); let mut cb_temp: usize = 0usize; let mut obj_id: i32 = 0i32; if data.is_null() || pcb_data.is_null() || 3072usize > *pcb_data { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { if tag as (i32) == 0x88i32 { obj_id = 0x5fc109i32; } else if tag as (i32) == 0x80i32 { obj_id = 0x5fff00i32; } else { - return Enum5::YKPIV_INVALID_OBJECT; + return ErrorKind::YKPIV_INVALID_OBJECT; } cb_temp = *pcb_data; *pcb_data = 0usize; - (if Enum5::YKPIV_OK as (i32) != { + (if ErrorKind::YKPIV_OK as (i32) != { res = _ykpiv_fetch_object(state, obj_id, data, &mut cb_temp as (*mut usize)); res } as (i32) { res } else if cb_temp < 2usize { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { p_temp = data; (if tag as (i32) @@ -3124,59 +2802,49 @@ unsafe extern "C" fn _read_metadata( _old } as (i32) { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { p_temp = p_temp.offset(_ykpiv_get_length(p_temp as (*const u8), pcb_data) as (isize)); (if *pcb_data > cb_temp.wrapping_sub( ((p_temp as (isize)).wrapping_sub(data as (isize)) - / ::std::mem::size_of::() as (isize)) - as (usize), + / mem::size_of::() as (isize)) as (usize), ) { *pcb_data = 0usize; - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { - memmove( - data as (*mut ::std::os::raw::c_void), - p_temp as (*const ::std::os::raw::c_void), - *pcb_data, - ); - Enum5::YKPIV_OK + memmove(data as (*mut c_void), p_temp as (*const c_void), *pcb_data); + ErrorKind::YKPIV_OK }) }) }) } } -unsafe extern "C" fn _write_metadata( +unsafe fn _write_metadata( mut state: *mut ykpiv_state, mut tag: u8, mut data: *mut u8, mut cb_data: usize, -) -> Enum5 { - let mut res: Enum5 = Enum5::YKPIV_OK; +) -> ErrorKind { + let mut res: ErrorKind = ErrorKind::YKPIV_OK; let mut buf = [0u8; 3063]; let mut pTemp: *mut u8 = buf.as_mut_ptr(); let mut obj_id: i32 = 0i32; if cb_data > _obj_size_max(state).wrapping_sub((2i32 + 2i32) as (usize)) { - Enum5::YKPIV_GENERIC_ERROR + ErrorKind::YKPIV_GENERIC_ERROR } else { if tag as (i32) == 0x88i32 { obj_id = 0x5fc109i32; } else if tag as (i32) == 0x80i32 { obj_id = 0x5fff00i32; } else { - return Enum5::YKPIV_INVALID_OBJECT; + return ErrorKind::YKPIV_INVALID_OBJECT; } if data.is_null() || 0usize == cb_data { - res = _ykpiv_save_object( - state, - obj_id, - 0i32 as (*mut ::std::os::raw::c_void) as (*mut u8), - 0usize, - ); + res = _ykpiv_save_object(state, obj_id, 0i32 as (*mut c_void) as (*mut u8), 0usize); } else { *{ let _old = pTemp; @@ -3184,18 +2852,14 @@ unsafe extern "C" fn _write_metadata( _old } = tag; pTemp = pTemp.offset(_ykpiv_set_length(pTemp, cb_data) as (isize)); - memcpy( - pTemp as (*mut ::std::os::raw::c_void), - data as (*const ::std::os::raw::c_void), - cb_data, - ); + memcpy(pTemp as (*mut c_void), data as (*const c_void), cb_data); pTemp = pTemp.offset(cb_data as (isize)); res = _ykpiv_save_object( state, obj_id, buf.as_mut_ptr(), ((pTemp as (isize)).wrapping_sub(buf.as_mut_ptr() as (isize)) - / ::std::mem::size_of::() as (isize)) as (usize), + / mem::size_of::() as (isize)) as (usize), ); } res diff --git a/src/version.rs b/src/version.rs deleted file mode 100644 index 0994608..0000000 --- a/src/version.rs +++ /dev/null @@ -1,193 +0,0 @@ -// Copyright (c) 2014-2016 Yubico AB -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -extern "C" { - fn strcmp(__s1: *const u8, __s2: *const u8) -> i32; - fn strcspn(__s: *const u8, __charset: *const u8) -> usize; - fn strncmp(__s1: *const u8, __s2: *const u8, __n: usize) -> i32; - fn strspn(__s: *const u8, __charset: *const u8) -> usize; -} - -unsafe extern "C" fn my_strverscmp(mut s1: *const u8, mut s2: *const u8) -> i32 { - let mut _currentBlock; - static mut digits: *const u8 = (*b"0123456789\0").as_ptr(); - let mut p1: usize; - let mut p2: usize; - p1 = strcspn(s1, digits); - p2 = strcspn(s2, digits); - 'loop1: loop { - if !(p1 == p2 - && (*s1.offset(p1 as (isize)) as (i32) != b'\0' as (i32)) - && (*s2.offset(p2 as (isize)) as (i32) != b'\0' as (i32))) - { - _currentBlock = 2; - break; - } - let mut ret: i32; - let mut lz1: i32; - let mut lz2: i32; - if { - ret = strncmp(s1, s2, p1); - ret - } != 0i32 - { - _currentBlock = 37; - break; - } - s1 = s1.offset(p1 as (isize)); - s2 = s2.offset(p2 as (isize)); - lz1 = { - lz2 = 0i32; - lz2 - }; - if *s1 as (i32) == b'0' as (i32) { - lz1 = 1i32; - } - if *s2 as (i32) == b'0' as (i32) { - lz2 = 1i32; - } - if lz1 > lz2 { - _currentBlock = 36; - break; - } - if lz1 < lz2 { - _currentBlock = 35; - break; - } - if lz1 == 1i32 { - _currentBlock = 11; - } else { - _currentBlock = 23; - } - 'loop11: loop { - if _currentBlock == 11 { - if *s1 as (i32) == b'0' as (i32) && (*s2 as (i32) == b'0' as (i32)) { - s1 = s1.offset(1isize); - s2 = s2.offset(1isize); - _currentBlock = 11; - } else { - p1 = strspn(s1, digits); - p2 = strspn(s2, digits); - if p1 == 0usize && (p2 > 0usize) { - _currentBlock = 33; - break 'loop1; - } - if p2 == 0usize && (p1 > 0usize) { - _currentBlock = 32; - break 'loop1; - } - if *s1 as (i32) != *s2 as (i32) - && (*s1 as (i32) != b'0' as (i32)) - && (*s2 as (i32) != b'0' as (i32)) - { - if p1 < p2 { - _currentBlock = 31; - break 'loop1; - } - if p1 > p2 { - _currentBlock = 30; - break 'loop1; - } else { - _currentBlock = 23; - } - } else { - if p1 < p2 { - ret = strncmp(s1, s2, p1); - } else if p1 > p2 { - ret = strncmp(s1, s2, p2); - } - if ret != 0i32 { - _currentBlock = 20; - break 'loop1; - } else { - _currentBlock = 23; - } - } - } - } else { - p1 = strspn(s1, digits); - p2 = strspn(s2, digits); - if p1 < p2 { - _currentBlock = 29; - break 'loop1; - } else { - break; - } - } - } - if p1 > p2 { - _currentBlock = 28; - break; - } - if { - ret = strncmp(s1, s2, p1); - ret - } != 0i32 - { - _currentBlock = 27; - break; - } - s1 = s1.offset(p1 as (isize)); - s2 = s2.offset(p2 as (isize)); - p1 = strcspn(s1, digits); - p2 = strcspn(s2, digits); - } - if _currentBlock == 2 { - strcmp(s1, s2) - } else if _currentBlock == 20 { - ret - } else if _currentBlock == 27 { - ret - } else if _currentBlock == 28 { - 1i32 - } else if _currentBlock == 29 { - -1i32 - } else if _currentBlock == 30 { - -1i32 - } else if _currentBlock == 31 { - 1i32 - } else if _currentBlock == 32 { - -1i32 - } else if _currentBlock == 33 { - 1i32 - } else if _currentBlock == 35 { - 1i32 - } else if _currentBlock == 36 { - -1i32 - } else { - ret - } -} - -#[no_mangle] -pub unsafe extern "C" fn ykpiv_check_version(mut req_version: *const u8) -> *const u8 { - if req_version.is_null() || my_strverscmp(req_version, (*b"@VERSION@\0").as_ptr()) <= 0i32 { - (*b"@VERSION@\0").as_ptr() - } else { - 0i32 as (*mut ::std::os::raw::c_void) as (*const u8) - } -}