Add CKO_MECHANISM objects and add CKA_UNIQUE_ID to all objects

Cargo.toml

@@ -71,7 +71,7 @@ serde_json = "1.0.104"
 serial_test = "3.1.1"
 simplelog = { version = "0.12.2", default-features = false, optional = true }
 toml = { version = "0.9", default-features = false, features = ["display", "parse", "serde"] }
-uuid = { version = "1.4.1", features = ["v4"] }
+uuid = { version = "1.4.1", features = ["v4", "v8"] }
 ossl.workspace = true
 
 [dev-dependencies]

src/aes.rs

@@ -93,14 +93,16 @@ pub(crate) fn check_key_len(len: usize) -> Result<()> {
 /// methods for generic manipulation of AES key objects (generation, derivation, wrapping ...)
 ///
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct AesKeyFactory {
     data: ObjectFactoryData,
 }
 
 impl AesKeyFactory {
     fn new() -> AesKeyFactory {
-        let mut factory: AesKeyFactory = Default::default();
+        let mut factory: AesKeyFactory = AesKeyFactory {
+            data: ObjectFactoryData::new(CKO_SECRET_KEY),
+        };
 
         factory.add_common_secret_key_attrs();
 

src/ec/ecdsa.rs

@@ -110,15 +110,17 @@ pub fn register(mechs: &mut Mechanisms, ot: &mut ObjectFactories) {
 }
 
 /// The ECDSA Public-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ECDSAPubFactory {
     data: ObjectFactoryData,
 }
 
 impl ECDSAPubFactory {
     /// Initializes a new ECDSA Public-Key factory
     pub fn new() -> ECDSAPubFactory {
-        let mut factory: ECDSAPubFactory = Default::default();
+        let mut factory: ECDSAPubFactory = ECDSAPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -221,15 +223,17 @@ impl PubKeyFactory for ECDSAPubFactory {
 }
 
 /// The ECDSA Private-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ECDSAPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl ECDSAPrivFactory {
     /// Initializes a new ECDSA Private-Key factory
     pub fn new() -> ECDSAPrivFactory {
-        let mut factory: ECDSAPrivFactory = Default::default();
+        let mut factory: ECDSAPrivFactory = ECDSAPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();
 

src/ec/eddsa.rs

@@ -91,15 +91,17 @@ pub fn register(mechs: &mut Mechanisms, ot: &mut ObjectFactories) {
 }
 
 /// The EdDSA-Edwards Public-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct EDDSAPubFactory {
     data: ObjectFactoryData,
 }
 
 impl EDDSAPubFactory {
     /// Initializes a new EdDSA Public-Key factory
     pub fn new() -> EDDSAPubFactory {
-        let mut factory: EDDSAPubFactory = Default::default();
+        let mut factory: EDDSAPubFactory = EDDSAPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -198,15 +200,17 @@ impl PubKeyFactory for EDDSAPubFactory {
 }
 
 /// The EdDSA Private-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct EDDSAPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl EDDSAPrivFactory {
     /// Initializes a new EdDSA Private-Key factory
     pub fn new() -> EDDSAPrivFactory {
-        let mut factory: EDDSAPrivFactory = Default::default();
+        let mut factory: EDDSAPrivFactory = EDDSAPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();
 

src/ec/montgomery.rs

@@ -85,15 +85,17 @@ pub fn register(mechs: &mut Mechanisms, ot: &mut ObjectFactories) {
 }
 
 /// The EC-Montgomery Public-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ECMontgomeryPubFactory {
     data: ObjectFactoryData,
 }
 
 impl ECMontgomeryPubFactory {
     /// Initializes a new EC-Montgomery Public-Key factory
     pub fn new() -> ECMontgomeryPubFactory {
-        let mut factory: ECMontgomeryPubFactory = Default::default();
+        let mut factory: ECMontgomeryPubFactory = ECMontgomeryPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -192,15 +194,17 @@ impl PubKeyFactory for ECMontgomeryPubFactory {
 }
 
 /// The EC-Montgomery Private-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ECMontgomeryPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl ECMontgomeryPrivFactory {
     /// Initializes a new EC-Montgomery Private-Key factory
     pub fn new() -> ECMontgomeryPrivFactory {
-        let mut factory: ECMontgomeryPrivFactory = Default::default();
+        let mut factory: ECMontgomeryPrivFactory = ECMontgomeryPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();
 

src/ffdh.rs

@@ -104,15 +104,17 @@ fn ffdh_public_key_info(
 }
 
 /// The FFDH Public-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct FFDHPubFactory {
     data: ObjectFactoryData,
 }
 
 impl FFDHPubFactory {
     /// Initializes a new FFDH Public-Key factory
     pub fn new() -> FFDHPubFactory {
-        let mut factory: FFDHPubFactory = Default::default();
+        let mut factory: FFDHPubFactory = FFDHPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -164,15 +166,17 @@ impl CommonKeyFactory for FFDHPubFactory {}
 impl PubKeyFactory for FFDHPubFactory {}
 
 /// The FFDH Private-Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct FFDHPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl FFDHPrivFactory {
     /// Initializes a new FFDH Private-Key factory
     pub fn new() -> FFDHPrivFactory {
-        let mut factory: FFDHPrivFactory = Default::default();
+        let mut factory: FFDHPrivFactory = FFDHPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();
 

src/fips/indicators.rs

@@ -24,15 +24,17 @@ use crate::Token;
 pub const KRF_FIPS: CK_ULONG = 1;
 
 /// The Validation Object factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ValidationFactory {
     data: ObjectFactoryData,
 }
 
 impl ValidationFactory {
     /// Initializes the validation object factory
     fn new() -> ValidationFactory {
-        let mut factory: ValidationFactory = Default::default();
+        let mut factory: ValidationFactory = ValidationFactory {
+            data: ObjectFactoryData::new(CKO_VALIDATION),
+        };
 
         factory.add_common_storage_attrs(false);
 
@@ -112,13 +114,12 @@ pub(crate) static VALIDATION_FACTORY: LazyLock<Box<dyn ObjectFactory>> =
 ///
 /// This is generally done only once at token initialization
 pub fn insert_fips_validation(token: &mut Token) -> Result<()> {
-    let mut obj = Object::new();
+    let mut obj = Object::new(CKO_VALIDATION);
     obj.set_attr(Attribute::from_bool(CKA_TOKEN, false))?;
     obj.set_attr(Attribute::from_bool(CKA_DESTROYABLE, false))?;
     obj.set_attr(Attribute::from_bool(CKA_MODIFIABLE, false))?;
     obj.set_attr(Attribute::from_bool(CKA_PRIVATE, false))?;
     obj.set_attr(Attribute::from_bool(CKA_SENSITIVE, false))?;
-    obj.set_attr(Attribute::from_ulong(CKA_CLASS, CKO_VALIDATION))?;
     obj.set_attr(Attribute::from_ulong(
         CKA_VALIDATION_TYPE,
         CKV_TYPE_SOFTWARE,
@@ -161,8 +162,8 @@ pub fn insert_fips_validation(token: &mut Token) -> Result<()> {
         String::from(""),
     ))?;
 
-    /* generate a unique id */
-    obj.generate_unique();
+    /* generate a unique but stable id */
+    obj.generate_stable_unique(1);
 
     /* invalid session handle will prevent it from being removed when
      * session objects are cleared on session closings */

src/fips/kats.rs

@@ -64,8 +64,7 @@ pub static HMAC_SELFTEST: LazyLock<FIPSSelftest> = LazyLock::new(|| {
 });
 
 fn secret_key_object(secret: Vec<u8>) -> Result<Object> {
-    let mut key = Object::new();
-    key.set_attr(Attribute::from_ulong(CKA_CLASS, CKO_SECRET_KEY))?;
+    let mut key = Object::new(CKO_SECRET_KEY);
     key.set_attr(Attribute::from_ulong(CKA_KEY_TYPE, CKK_GENERIC_SECRET))?;
     key.set_attr(Attribute::from_ulong(
         CKA_VALUE_LEN,

src/mldsa.rs

@@ -148,15 +148,17 @@ fn mldsa_pub_check_import(obj: &Object) -> Result<()> {
 }
 
 /// The ML-DSA Public Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct MlDsaPubFactory {
     data: ObjectFactoryData,
 }
 
 impl MlDsaPubFactory {
     /// Initializes a ML-DSA Public Key Factory
     pub fn new() -> MlDsaPubFactory {
-        let mut factory: MlDsaPubFactory = Default::default();
+        let mut factory: MlDsaPubFactory = MlDsaPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -278,15 +280,17 @@ fn mldsa_priv_check_import(obj: &mut Object) -> Result<()> {
 }
 
 /// The ML-DSA Private Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct MlDsaPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl MlDsaPrivFactory {
     /// Initializes a ML-DSA Private Key Factory
     pub fn new() -> MlDsaPrivFactory {
-        let mut factory: MlDsaPrivFactory = Default::default();
+        let mut factory: MlDsaPrivFactory = MlDsaPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();
 

src/mlkem.rs

@@ -141,15 +141,17 @@ fn mlkem_pub_check_import(obj: &Object) -> Result<()> {
 }
 
 /// The ML-KEM Public Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct MlKemPubFactory {
     data: ObjectFactoryData,
 }
 
 impl MlKemPubFactory {
     /// Initializes a ML-KEM Public Key Factory
     pub fn new() -> MlKemPubFactory {
-        let mut factory: MlKemPubFactory = Default::default();
+        let mut factory: MlKemPubFactory = MlKemPubFactory {
+            data: ObjectFactoryData::new(CKO_PUBLIC_KEY),
+        };
 
         factory.add_common_public_key_attrs();
 
@@ -271,15 +273,17 @@ fn mlkem_priv_check_import(obj: &mut Object) -> Result<()> {
 }
 
 /// The ML-KEM Private Key Factory
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct MlKemPrivFactory {
     data: ObjectFactoryData,
 }
 
 impl MlKemPrivFactory {
     /// Initializes a ML-KEM Private Key Factory
     pub fn new() -> MlKemPrivFactory {
-        let mut factory: MlKemPrivFactory = Default::default();
+        let mut factory: MlKemPrivFactory = MlKemPrivFactory {
+            data: ObjectFactoryData::new(CKO_PRIVATE_KEY),
+        };
 
         factory.add_common_private_key_attrs();