Rename default_object_* methods to default_key_*

Refactor the ObjectFactory trait to rename the default helper methods
from `default_object_*` to `default_key_*`. This affects the create,
generate, derive, and unwrap functions.

Update all implementation files and call sites to use the new method
names, aligning with the terminology used for key operations.

Co-authored-by: Gemini <gemini@google.com>
Signed-off-by: Simo Sorce <simo@redhat.com>

Author: simo5

src/aes.rs

@@ -127,7 +127,7 @@ impl ObjectFactory for AesKeyFactory {
     /// code and additionally ensures the key size is one of the AES allowed
     /// sizes (currently 128, 192 or 256 bits).
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
         let len = self.get_key_buffer_len(&obj)?;
         check_key_len(len)?;
         obj.ensure_ulong(CKA_VALUE_LEN, CK_ULONG::try_from(len)?)?;
@@ -171,7 +171,7 @@ impl ObjectFactory for AesKeyFactory {
 
     /// The AES derive adds key length checks on top of the generic secret
     /// derive helper
-    fn default_object_derive(
+    fn default_key_derive(
         &self,
         template: &[CK_ATTRIBUTE],
         origin: &Object,
@@ -303,7 +303,7 @@ impl Mechanism for AesMechanism {
         if mech.mechanism != CKM_AES_KEY_GEN {
             return Err(CKR_MECHANISM_INVALID)?;
         }
-        let mut key = AES_KEY_FACTORY.default_object_generate(template)?;
+        let mut key = AES_KEY_FACTORY.default_key_generate(template)?;
         key.ensure_ulong(CKA_CLASS, CKO_SECRET_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
         key.ensure_ulong(CKA_KEY_TYPE, CKK_AES)
@@ -621,12 +621,11 @@ impl Derive for AesKDFOperation<'_> {
             return Err(CKR_OPERATION_NOT_INITIALIZED)?;
         }
         self.finalized = true;
-
         key.check_key_ops(CKO_SECRET_KEY, CKK_AES, CKA_DERIVE)?;
 
         let factory =
             objfactories.get_obj_factory_from_key_template(template)?;
-        let mut obj = factory.default_object_derive(template, key)?;
+        let mut obj = factory.default_key_derive(template, key)?;
 
         let mechanism = CK_MECHANISM {
             mechanism: self.mech,

src/ec/ecdsa.rs

@@ -139,17 +139,16 @@ impl ECDSAPubFactory {
         factory
     }
 }
-
 impl ObjectFactory for ECDSAPubFactory {
     /// Creates an EC Public-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates the Public Point Format and that its size
     /// is consistent with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.3:
          * CKA_EC_PARAMS, Byte array,
@@ -252,17 +251,16 @@ impl ECDSAPrivFactory {
         factory
     }
 }
-
 impl ObjectFactory for ECDSAPrivFactory {
     /// Creates an ECDSA Private-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates that the private key size is consistent
     /// with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.4:
          * CKA_EC_PARAMS, Byte array,
@@ -350,7 +348,7 @@ impl PrivKeyFactory for ECDSAPrivFactory {
         data: Vec<u8>,
         template: &[CK_ATTRIBUTE],
     ) -> Result<Object> {
-        import_from_wrapped(CKK_EC, data, self.default_object_unwrap(template)?)
+        import_from_wrapped(CKK_EC, data, self.default_key_unwrap(template)?)
     }
 }
 
@@ -425,7 +423,7 @@ impl Mechanism for EcdsaMechanism {
         prikey_template: &[CK_ATTRIBUTE],
     ) -> Result<(Object, Object)> {
         let mut pubkey =
-            PUBLIC_KEY_FACTORY.default_object_generate(pubkey_template)?;
+            PUBLIC_KEY_FACTORY.default_key_generate(pubkey_template)?;
         pubkey
             .ensure_ulong(CKA_CLASS, CKO_PUBLIC_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
@@ -434,7 +432,7 @@ impl Mechanism for EcdsaMechanism {
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
 
         let mut privkey =
-            PRIVATE_KEY_FACTORY.default_object_generate(prikey_template)?;
+            PRIVATE_KEY_FACTORY.default_key_generate(prikey_template)?;
         privkey
             .ensure_ulong(CKA_CLASS, CKO_PRIVATE_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;

src/ec/eddsa.rs

@@ -120,17 +120,16 @@ impl EDDSAPubFactory {
         factory
     }
 }
-
 impl ObjectFactory for EDDSAPubFactory {
     /// Creates a CKK_EC_EDWARDS Public-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates the Public Point Format and that its size
     /// is consistent with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.5:
          * CKA_EC_PARAMS, Byte array,
@@ -238,17 +237,16 @@ impl EDDSAPrivFactory {
         factory
     }
 }
-
 impl ObjectFactory for EDDSAPrivFactory {
     /// Creates an EdDSA Private-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates that the private key size is consistent
     /// with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.6:
          * CKA_EC_PARAMS, Byte array,
@@ -327,12 +325,13 @@ impl PrivKeyFactory for EDDSAPrivFactory {
         import_from_wrapped(
             CKK_EC_EDWARDS,
             data,
-            self.default_object_unwrap(template)?,
+            self.default_key_unwrap(template)?,
         )
     }
 }
 
 /// Object that represents EdDSA related mechanisms
+
 #[derive(Debug)]
 struct EddsaMechanism {
     info: CK_MECHANISM_INFO,
@@ -398,7 +397,7 @@ impl Mechanism for EddsaMechanism {
         prikey_template: &[CK_ATTRIBUTE],
     ) -> Result<(Object, Object)> {
         let mut pubkey =
-            PUBLIC_KEY_FACTORY.default_object_generate(pubkey_template)?;
+            PUBLIC_KEY_FACTORY.default_key_generate(pubkey_template)?;
         pubkey
             .ensure_ulong(CKA_CLASS, CKO_PUBLIC_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
@@ -407,7 +406,7 @@ impl Mechanism for EddsaMechanism {
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
 
         let mut privkey =
-            PRIVATE_KEY_FACTORY.default_object_generate(prikey_template)?;
+            PRIVATE_KEY_FACTORY.default_key_generate(prikey_template)?;
         privkey
             .ensure_ulong(CKA_CLASS, CKO_PRIVATE_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;

src/ec/montgomery.rs

@@ -114,17 +114,16 @@ impl ECMontgomeryPubFactory {
         factory
     }
 }
-
 impl ObjectFactory for ECMontgomeryPubFactory {
     /// Creates an EC-Montgomery Public-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates the Public Point Format and that its size
     /// is consistent with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.7:
          * CKA_EC_PARAMS, Byte array,
@@ -223,17 +222,16 @@ impl ECMontgomeryPrivFactory {
         factory
     }
 }
-
 impl ObjectFactory for ECMontgomeryPrivFactory {
     /// Creates an EC-Montgomery Private-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates that the private key size is consistent
     /// with the EC Parameters provided
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         /* According to PKCS#11 v3.1 6.3.8:
          * CKA_EC_PARAMS, Byte array,
@@ -312,12 +310,13 @@ impl PrivKeyFactory for ECMontgomeryPrivFactory {
         import_from_wrapped(
             CKK_EC_MONTGOMERY,
             data,
-            self.default_object_unwrap(template)?,
+            self.default_key_unwrap(template)?,
         )
     }
 }
 
 /// Object that represents CKK_EC_MONTGOMERY related mechanisms
+
 #[derive(Debug)]
 struct ECMontgomeryMechanism {
     info: CK_MECHANISM_INFO,
@@ -335,7 +334,7 @@ impl Mechanism for ECMontgomeryMechanism {
         prikey_template: &[CK_ATTRIBUTE],
     ) -> Result<(Object, Object)> {
         let mut pubkey =
-            PUBLIC_KEY_FACTORY.default_object_generate(pubkey_template)?;
+            PUBLIC_KEY_FACTORY.default_key_generate(pubkey_template)?;
         pubkey
             .ensure_ulong(CKA_CLASS, CKO_PUBLIC_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
@@ -344,7 +343,7 @@ impl Mechanism for ECMontgomeryMechanism {
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
 
         let mut privkey =
-            PRIVATE_KEY_FACTORY.default_object_generate(prikey_template)?;
+            PRIVATE_KEY_FACTORY.default_key_generate(prikey_template)?;
         privkey
             .ensure_ulong(CKA_CLASS, CKO_PRIVATE_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;

src/ffdh.rs

@@ -136,17 +136,16 @@ impl FFDHPubFactory {
         factory
     }
 }
-
 impl ObjectFactory for FFDHPubFactory {
     /// Creates an FFDH Public-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates that the key is based on a well known
     /// group based on safe primes
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
         let group = ffdh_groups::get_group_name(&obj)?;
         ffdh_public_key_info(group, &mut obj)?;
         Ok(obj)
@@ -202,17 +201,16 @@ impl FFDHPrivFactory {
         factory
     }
 }
-
 impl ObjectFactory for FFDHPrivFactory {
     /// Creates an FFDH Private-Key Object from a template
     ///
     /// Validates that the provided attributes are consistent with the
-    /// factory via [ObjectFactory::default_object_create()]
+    /// factory via [ObjectFactory::default_key_create()]
     ///
     /// Additionally validates that the key is based on a well known
     /// group based on safe primes
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let obj = self.default_object_create(template)?;
+        let obj = self.default_key_create(template)?;
         let _ = ffdh_groups::get_group_name(&obj)?;
 
         Ok(obj)
@@ -279,7 +277,7 @@ impl Mechanism for FFDHMechanism {
         prikey_template: &[CK_ATTRIBUTE],
     ) -> Result<(Object, Object)> {
         let mut pubkey =
-            PUBLIC_KEY_FACTORY.default_object_generate(pubkey_template)?;
+            PUBLIC_KEY_FACTORY.default_key_generate(pubkey_template)?;
         pubkey
             .ensure_ulong(CKA_CLASS, CKO_PUBLIC_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
@@ -288,7 +286,7 @@ impl Mechanism for FFDHMechanism {
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
 
         let mut privkey =
-            PRIVATE_KEY_FACTORY.default_object_generate(prikey_template)?;
+            PRIVATE_KEY_FACTORY.default_key_generate(prikey_template)?;
         privkey
             .ensure_ulong(CKA_CLASS, CKO_PRIVATE_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;

src/hash.rs

@@ -362,12 +362,11 @@ impl Derive for HashKDFOperation {
                         .as_secret_key_factory()?
                         .recommend_key_size(hashsize)?,
                 )?;
-
                 tmpl.add_ulong(CKA_VALUE_LEN, &keysize);
             }
         }
 
-        let mut obj = factory.default_object_derive(tmpl.as_slice(), key)?;
+        let mut obj = factory.default_key_derive(tmpl.as_slice(), key)?;
 
         let mut dkm = vec![0u8; hashsize];
         op.digest(

src/mldsa.rs

@@ -180,11 +180,11 @@ impl MlDsaPubFactory {
 impl ObjectFactory for MlDsaPubFactory {
     /// Creates a ML-DSA public key object
     ///
-    /// Uses [ObjectFactory::default_object_create()]
+    /// Uses [ObjectFactory::default_key_create()]
     ///
     /// Checks the import is consistent via helper function
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         mldsa_pub_check_import(&mut obj)?;
 
@@ -315,11 +315,11 @@ impl MlDsaPrivFactory {
 impl ObjectFactory for MlDsaPrivFactory {
     /// Creates a ML-DSA private key object
     ///
-    /// Uses [ObjectFactory::default_object_create()]
+    /// Uses [ObjectFactory::default_key_create()]
     ///
     /// Checks the import is consistent via helper function
     fn create(&self, template: &[CK_ATTRIBUTE]) -> Result<Object> {
-        let mut obj = self.default_object_create(template)?;
+        let mut obj = self.default_key_create(template)?;
 
         mldsa_priv_check_import(&mut obj)?;
 
@@ -441,7 +441,7 @@ impl Mechanism for MlDsaMechanism {
         prikey_template: &[CK_ATTRIBUTE],
     ) -> Result<(Object, Object)> {
         let mut pubkey =
-            PUBLIC_KEY_FACTORY.default_object_generate(pubkey_template)?;
+            PUBLIC_KEY_FACTORY.default_key_generate(pubkey_template)?;
         pubkey
             .ensure_ulong(CKA_CLASS, CKO_PUBLIC_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;
@@ -458,7 +458,7 @@ impl Mechanism for MlDsaMechanism {
         };
 
         let mut privkey =
-            PRIVATE_KEY_FACTORY.default_object_generate(prikey_template)?;
+            PRIVATE_KEY_FACTORY.default_key_generate(prikey_template)?;
         privkey
             .ensure_ulong(CKA_CLASS, CKO_PRIVATE_KEY)
             .map_err(|_| CKR_TEMPLATE_INCONSISTENT)?;