Info flags refactor

cryptoki-sys/pkcs11.h

@@ -293,6 +293,7 @@ struct ck_token_info
 #define CKF_SO_PIN_FINAL_TRY			(1UL << 21)
 #define CKF_SO_PIN_LOCKED			(1UL << 22)
 #define CKF_SO_PIN_TO_BE_CHANGED		(1UL << 23)
+#define CKF_ERROR_STATE		(1UL << 24)
 
 #define CK_UNAVAILABLE_INFORMATION	((unsigned long)-1L)
 #define CK_EFFECTIVELY_INFINITE		(0UL)
@@ -1044,6 +1045,8 @@ struct ck_aes_cbc_encrypt_data_params {
 #define CKF_EXTENSION		((unsigned long) (1UL << 31))
 
 #define CKF_EC_F_P		(1UL << 20)
+#define CKF_EC_F_2M		(1UL << 21)
+#define CKF_EC_ECPARAMETERS	(1UL << 22)
 #define CKF_EC_NAMEDCURVE	(1UL << 23)
 #define CKF_EC_UNCOMPRESS	(1UL << 24)
 #define CKF_EC_COMPRESS		(1UL << 25)

cryptoki-sys/src/lib.rs

@@ -124,6 +124,7 @@ pub const CKF_SO_PIN_COUNT_LOW: CK_FLAGS = 0x00100000;
 pub const CKF_SO_PIN_FINAL_TRY: CK_FLAGS = 0x00200000;
 pub const CKF_SO_PIN_LOCKED: CK_FLAGS = 0x00400000;
 pub const CKF_SO_PIN_TO_BE_CHANGED: CK_FLAGS = 0x00800000;
+pub const CKF_ERROR_STATE: CK_FLAGS = 0x01000000;
 pub const CK_UNAVAILABLE_INFORMATION: CK_ULONG = !0;
 pub const CK_EFFECTIVELY_INFINITE: CK_ULONG = 0;
 pub const CK_INVALID_HANDLE: CK_ULONG = 0;
@@ -689,6 +690,8 @@ pub const CKF_UNWRAP: CK_FLAGS = 0x00040000;
 pub const CKF_DERIVE: CK_FLAGS = 0x00080000;
 pub const CKF_EXTENSION: CK_FLAGS = 0x80000000;
 pub const CKF_EC_F_P: CK_FLAGS = 0x00100000;
+pub const CKF_EC_F_2M: CK_FLAGS = 0x00200000;
+pub const CKF_EC_ECPARAMETERS: CK_FLAGS = 0x00400000;
 pub const CKF_EC_NAMEDCURVE: CK_FLAGS = 0x00800000;
 pub const CKF_EC_UNCOMPRESS: CK_FLAGS = 0x01000000;
 pub const CKF_EC_COMPRESS: CK_FLAGS = 0x02000000;

cryptoki/Cargo.toml

@@ -12,6 +12,7 @@ repository = "https://github.com/parallaxsecond/rust-cryptoki"
 documentation = "https://docs.rs/crate/cryptoki"
 
 [dependencies]
+bitflags = "1.3"
 libloading = "0.7.0"
 log = "0.4.14"
 derivative = "2.2.0"

cryptoki/src/context/general_purpose.rs

@@ -5,6 +5,7 @@
 use crate::context::{CInitializeArgs, Info, Pkcs11};
 use crate::error::{Result, Rv};
 use cryptoki_sys::{CK_C_INITIALIZE_ARGS, CK_INFO};
+use std::convert::TryFrom;
 
 // See public docs on stub in parent mod.rs
 #[inline(always)]
@@ -26,6 +27,6 @@ pub(super) fn get_library_info(ctx: &Pkcs11) -> Result<Info> {
     let mut info = CK_INFO::default();
     unsafe {
         Rv::from(get_pkcs11!(ctx, C_GetInfo)(&mut info)).into_result()?;
-        Ok(Info::new(info))
+        Info::try_from(info)
     }
 }

cryptoki/src/context/info.rs

@@ -2,58 +2,63 @@
 // SPDX-License-Identifier: Apache-2.0
 //! PKCS11 library information
 
+use crate::error::{Error, Result};
 use crate::string_from_blank_padded;
 use crate::types::Version;
 use cryptoki_sys::*;
-use std::ops::Deref;
+use std::convert::TryFrom;
 
-#[derive(Debug, Clone, Copy)]
-/// Type identifying the PKCS#11 library information
+#[derive(Debug, Clone)]
+/// General information about the Cryptoki (PKCS#11 library)
 pub struct Info {
-    val: CK_INFO,
+    cryptoki_version: Version,
+    manufacturer_id: String,
+    // flags
+    library_description: String,
+    library_version: Version,
 }
 
 impl Info {
-    pub(crate) fn new(val: CK_INFO) -> Self {
-        Self { val }
-    }
-
-    /// Returns the version of Cryptoki that the library is compatible with
+    /// Returns the version of Cryptoki interface for compatibility with future
+    /// revisions
     pub fn cryptoki_version(&self) -> Version {
-        self.val.cryptokiVersion.into()
+        self.cryptoki_version
     }
 
-    /// Returns the flags of the library (should be zero!)
-    pub fn flags(&self) -> CK_FLAGS {
-        self.val.flags
+    /// ID of the Cryptoki library manufacturer
+    ///
+    /// **[Conformance](crate#conformance-notes):**
+    /// This string is maximally 32 bytes (*not* chars) as UTF-8
+    pub fn manufacturer_id(&self) -> &str {
+        &self.manufacturer_id
     }
 
-    /// Returns the description of the library
-    pub fn library_description(&self) -> String {
-        string_from_blank_padded(&self.val.libraryDescription)
+    /// Description of the library
+    ///
+    /// **[Conformance](crate#conformance-notes):**
+    /// This string is maximally 32 bytes (*not* chars) as UTF-8
+    pub fn library_description(&self) -> &str {
+        &self.library_description
     }
 
-    /// Returns the version of the library
+    /// Cryptoki library version number
     pub fn library_version(&self) -> Version {
-        self.val.libraryVersion.into()
-    }
-
-    /// Returns the manufacturer of the library
-    pub fn manufacturer_id(&self) -> String {
-        string_from_blank_padded(&self.val.manufacturerID)
-    }
-}
-
-impl Deref for Info {
-    type Target = CK_INFO;
-
-    fn deref(&self) -> &Self::Target {
-        &self.val
+        self.library_version
     }
 }
 
-impl From<Info> for CK_INFO {
-    fn from(info: Info) -> Self {
-        *info
+#[doc(hidden)]
+impl TryFrom<CK_INFO> for Info {
+    type Error = Error;
+    fn try_from(val: CK_INFO) -> Result<Self> {
+        if val.flags != 0 {
+            return Err(Error::InvalidValue);
+        }
+        Ok(Self {
+            cryptoki_version: val.cryptokiVersion.into(),
+            manufacturer_id: string_from_blank_padded(&val.manufacturerID),
+            library_description: string_from_blank_padded(&val.libraryDescription),
+            library_version: val.libraryVersion.into(),
+        })
     }
 }

cryptoki/src/context/locking.rs

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 //! Locking related type
 
-use super::InitializeFlags;
+use cryptoki_sys::{CKF_OS_LOCKING_OK, CK_FLAGS};
+
 use std::ptr;
 
 /// Argument for the initialize function
@@ -16,12 +17,12 @@ pub enum CInitializeArgs {
 
 impl From<CInitializeArgs> for cryptoki_sys::CK_C_INITIALIZE_ARGS {
     fn from(c_initialize_args: CInitializeArgs) -> Self {
-        let mut flags = InitializeFlags::default();
+        let mut flags = CK_FLAGS::default();
         match c_initialize_args {
             CInitializeArgs::OsThreads => {
-                let _ = flags.set_os_locking_ok(true);
+                flags |= CKF_OS_LOCKING_OK;
                 Self {
-                    flags: flags.into(),
+                    flags,
                     CreateMutex: None,
                     DestroyMutex: None,
                     LockMutex: None,

cryptoki/src/context/mod.rs

@@ -13,20 +13,19 @@ macro_rules! get_pkcs11 {
     };
 }
 
-mod flags;
 mod general_purpose;
 mod info;
 mod locking;
 mod session_management;
 mod slot_token_management;
 
-pub use flags::*;
+use cryptoki_sys::{CK_FALSE, CK_TRUE};
 pub use info::*;
 pub use locking::*;
 
 use crate::error::{Error, Result, Rv};
 use crate::mechanism::{MechanismInfo, MechanismType};
-use crate::session::{Session, SessionFlags};
+use crate::session::Session;
 use crate::slot::{Slot, SlotInfo, TokenInfo};
 
 use derivative::Derivative;
@@ -117,7 +116,7 @@ impl Pkcs11 {
 
     /// Get all slots available with a token
     pub fn get_slots_with_token(&self) -> Result<Vec<Slot>> {
-        slot_token_management::get_slots_with_token(self)
+        slot_token_management::get_slots(self, CK_TRUE)
     }
 
     /// Get all slots available with a token
@@ -127,7 +126,7 @@ impl Pkcs11 {
 
     /// Get all slots
     pub fn get_all_slots(&self) -> Result<Vec<Slot>> {
-        slot_token_management::get_all_slots(self)
+        slot_token_management::get_slots(self, CK_FALSE)
     }
 
     /// Initialize a token
@@ -158,7 +157,7 @@ impl Pkcs11 {
     }
 
     /// Open a new session with no callback set
-    pub fn open_session_no_callback(&self, slot_id: Slot, flags: SessionFlags) -> Result<Session> {
-        session_management::open_session_no_callback(self, slot_id, flags)
+    pub fn open_session_no_callback(&self, slot_id: Slot, read_write: bool) -> Result<Session> {
+        session_management::open_session_no_callback(self, slot_id, read_write)
     }
 }

cryptoki/src/context/session_management.rs

@@ -2,25 +2,31 @@
 // SPDX-License-Identifier: Apache-2.0
 //! Session management functions
 
+use cryptoki_sys::{CKF_RW_SESSION, CKF_SERIAL_SESSION};
+
 use crate::context::Pkcs11;
 use crate::error::{Result, Rv};
-use crate::session::{Session, SessionFlags};
+use crate::session::Session;
 use crate::slot::Slot;
 use std::convert::TryInto;
-
 // See public docs on stub in parent mod.rs
 #[inline(always)]
 pub(super) fn open_session_no_callback(
     ctx: &Pkcs11,
     slot_id: Slot,
-    flags: SessionFlags,
+    read_write: bool,
 ) -> Result<Session> {
     let mut session_handle = 0;
 
+    let flags = if read_write {
+        CKF_SERIAL_SESSION | CKF_RW_SESSION
+    } else {
+        CKF_SERIAL_SESSION
+    };
     unsafe {
         Rv::from(get_pkcs11!(ctx, C_OpenSession)(
             slot_id.try_into()?,
-            flags.into(),
+            flags,
             // TODO: abstract those types or create new functions for callbacks
             std::ptr::null_mut(),
             None,