Make UtcTime conversion fallible

In the initial implementation, any parsing error was silently
converted to None, which indicates the token doesn't have a clock.

Signed-off-by: Keith Koskie <[email protected]>

Author: vkkoskie

cryptoki/src/context/slot_token_management.rs

@@ -8,7 +8,7 @@ use crate::label_from_str;
 use crate::mechanism::{MechanismInfo, MechanismType};
 use crate::slot::{Slot, SlotInfo, TokenInfo};
 use cryptoki_sys::{CK_BBOOL, CK_MECHANISM_INFO, CK_SLOT_INFO, CK_TOKEN_INFO};
-use std::convert::TryInto;
+use std::convert::{TryFrom, TryInto};
 
 use crate::error::RvError::BufferTooSmall;
 
@@ -102,7 +102,7 @@ pub(super) fn get_token_info(ctx: &Pkcs11, slot: Slot) -> Result<TokenInfo> {
             &mut token_info,
         ))
         .into_result()?;
-        Ok(TokenInfo::from(token_info))
+        TokenInfo::try_from(token_info)
     }
 }
 

cryptoki/src/error/mod.rs

@@ -29,6 +29,12 @@ pub enum Error {
     /// Error when converting a slice to an array
     TryFromSlice(std::array::TryFromSliceError),
 
+    /// Error when converting a numerical str to an integral value
+    ParseInt(core::num::ParseIntError),
+
+    /// Error converting into a type assuming valid UTF-8
+    Utf8(std::str::Utf8Error),
+
     /// Error with nul characters in Strings
     NulError(std::ffi::NulError),
 
@@ -50,6 +56,8 @@ impl fmt::Display for Error {
             Error::NotSupported => write!(f, "Feature not supported"),
             Error::TryFromInt(e) => write!(f, "Conversion between integers failed ({})", e),
             Error::TryFromSlice(e) => write!(f, "Error converting slice to array ({})", e),
+            Error::ParseInt(e) => write!(f, "Error parsing string as integer ({})", e),
+            Error::Utf8(e) => write!(f, "Invalid UTF-8 ({})", e),
             Error::NulError(e) => write!(f, "An interior nul byte was found ({})", e),
             Error::NullFunctionPointer => write!(f, "Calling a NULL function pointer"),
             Error::InvalidValue => write!(f, "The value is not one of the expected options"),
@@ -64,6 +72,8 @@ impl std::error::Error for Error {
             Error::LibraryLoading(e) => Some(e),
             Error::TryFromInt(e) => Some(e),
             Error::TryFromSlice(e) => Some(e),
+            Error::ParseInt(e) => Some(e),
+            Error::Utf8(e) => Some(e),
             Error::NulError(e) => Some(e),
             Error::Pkcs11(_)
             | Error::NotSupported
@@ -92,6 +102,18 @@ impl From<std::array::TryFromSliceError> for Error {
     }
 }
 
+impl From<core::num::ParseIntError> for Error {
+    fn from(err: core::num::ParseIntError) -> Error {
+        Error::ParseInt(err)
+    }
+}
+
+impl From<std::str::Utf8Error> for Error {
+    fn from(err: std::str::Utf8Error) -> Error {
+        Error::Utf8(err)
+    }
+}
+
 impl From<std::ffi::NulError> for Error {
     fn from(err: std::ffi::NulError) -> Error {
         Error::NulError(err)

cryptoki/src/slot/token_info.rs

@@ -2,11 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //! PKCS11 Token info and associated flags
 
+use crate::error::{Error, Result};
 use crate::flag::{CkFlags, FlagBit};
 use crate::string_from_blank_padded;
 use crate::types::{convert_utc_time, maybe_unlimited};
 use crate::types::{MaybeUnavailable, UtcTime, Version};
 use cryptoki_sys::*;
+use std::convert::TryFrom;
 use std::fmt::{self, Debug, Formatter};
 
 const RNG: FlagBit<TokenInfo> = FlagBit::new(CKF_RNG);
@@ -411,15 +413,16 @@ impl TokenInfo {
 }
 
 #[doc(hidden)]
-impl From<CK_TOKEN_INFO> for TokenInfo {
-    fn from(val: CK_TOKEN_INFO) -> Self {
+impl TryFrom<CK_TOKEN_INFO> for TokenInfo {
+    type Error = Error;
+    fn try_from(val: CK_TOKEN_INFO) -> Result<Self> {
         let flags = CkFlags::from(val.flags);
         let utc_time = if flags.contains(CLOCK_ON_TOKEN) {
-            convert_utc_time(val.utcTime)
+            convert_utc_time(val.utcTime)?
         } else {
             None
         };
-        Self {
+        Ok(Self {
             label: string_from_blank_padded(&val.label),
             manufacturer_id: string_from_blank_padded(&val.manufacturerID),
             model: string_from_blank_padded(&val.model),
@@ -438,7 +441,7 @@ impl From<CK_TOKEN_INFO> for TokenInfo {
             hardware_version: val.hardwareVersion.into(),
             firmware_version: val.firmwareVersion.into(),
             utc_time,
-        }
+        })
     }
 }
 

cryptoki/src/types.rs

@@ -289,24 +289,17 @@ impl fmt::Display for UtcTime {
 }
 
 // UTC time has the format YYYYMMDDhhmmss00 as ASCII digits
-pub(crate) fn convert_utc_time(orig: [u8; 16]) -> Option<UtcTime> {
-    // skip check of reserved padding chars
-    for c in orig[0..14].iter() {
-        if !c.is_ascii_digit() {
-            return None;
-        }
-    }
+pub(crate) fn convert_utc_time(orig: [u8; 16]) -> Result<Option<UtcTime>> {
     // Note: No validaiton of these values beyond being ASCII digits
     // because PKCS#11 doesn't impose any such restrictions.
-    // Unwraps are safe here because of the digit check above.
-    Some(UtcTime {
-        year: std::str::from_utf8(&orig[0..4]).unwrap().parse().unwrap(),
-        month: std::str::from_utf8(&orig[4..6]).unwrap().parse().unwrap(),
-        day: std::str::from_utf8(&orig[6..8]).unwrap().parse().unwrap(),
-        hour: std::str::from_utf8(&orig[8..10]).unwrap().parse().unwrap(),
-        minute: std::str::from_utf8(&orig[10..12]).unwrap().parse().unwrap(),
-        second: std::str::from_utf8(&orig[12..14]).unwrap().parse().unwrap(),
-    })
+    Ok(Some(UtcTime {
+        year: std::str::from_utf8(&orig[0..4])?.parse()?,
+        month: std::str::from_utf8(&orig[4..6])?.parse()?,
+        day: std::str::from_utf8(&orig[6..8])?.parse()?,
+        hour: std::str::from_utf8(&orig[8..10])?.parse()?,
+        minute: std::str::from_utf8(&orig[10..12])?.parse()?,
+        second: std::str::from_utf8(&orig[12..14])?.parse()?,
+    }))
 }
 
 #[cfg(test)]
@@ -328,7 +321,7 @@ mod test {
             0x31, 0x39, 0x37, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
             0x30, 0x30,
         ];
-        let valid = convert_utc_time(valid).unwrap();
+        let valid = convert_utc_time(valid).unwrap().unwrap();
         assert_eq!(valid.year, UTC_TIME.year);
         assert_eq!(valid.month, UTC_TIME.month);
         assert_eq!(valid.day, UTC_TIME.day);
@@ -344,7 +337,7 @@ mod test {
             0x30, 0x30,
         ];
         let invalid = convert_utc_time(invalid);
-        assert!(invalid.is_none());
+        assert!(invalid.is_err());
     }
 
     #[test]