Tweaks to pass CI tests

Signed-off-by: Samuel Bailey <samuel.bailey@arm.com>

Author: sbailey-arm

Cargo.lock

@@ -0,0 +1,3 @@
+#![allow(clippy::multiple_crate_versions)]
+
+fn main() {}

build.rs

@@ -7,11 +7,9 @@ use crate::key_info_managers::KeyTriple;
 use log::{error, info};
 use parsec_interface::operations::{psa_sign_hash, psa_verify_hash};
 use parsec_interface::requests::{ProviderID, ResponseStatus, Result};
-use psa_crypto::operations::key_management as new_key_management;
 use psa_crypto::operations::asym_signature;
 use psa_crypto::types::key;
 
-#[allow(unused)]
 impl MbedProvider {
     pub(super) fn psa_sign_hash_internal(
         &self,
@@ -38,20 +36,17 @@ impl MbedProvider {
         //   * self.key_slot_semaphore prevents overflowing key slots
 
         let id = key::Id::from_persistent_key_id(key_id);
-        let key_attributes = new_key_management::get_key_attributes(id)?;
+        let key_attributes = key::Attributes::from_key_id(id)?;
         let buffer_size = utils::psa_asymmetric_sign_output_size(&key_attributes)?;
         let mut signature = vec![0u8; buffer_size];
-        let mut signature_size = 0;
 
-        match asym_signature::sign_hash(id, alg, &hash, &mut signature)
-            {
+        match asym_signature::sign_hash(id, alg, &hash, &mut signature) {
             Ok(size) => {
                 let mut res = psa_sign_hash::Result {
                     signature: Vec::new(),
                 };
                 res.signature.resize(size, 0);
-                res.signature
-                    .copy_from_slice(&signature[0..size]);
+                res.signature.copy_from_slice(&signature[0..size]);
                 Ok(res)
             }
             Err(error) => {

src/providers/mbed_provider/asym_sign.rs

@@ -0,0 +1,6 @@
+// Copyright 2019 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+
+pub use super::key::{psa_key_id_t, PSA_KEY_ID_USER_MAX, PSA_KEY_ID_USER_MIN};
+
+pub const PSA_KEY_SLOT_COUNT: isize = 32;

src/providers/mbed_provider/constants.rs

@@ -1,6 +1,6 @@
 // Copyright 2020 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
-use super::utils;
+use super::{constants, utils};
 use super::{LocalIdStore, MbedProvider};
 use crate::authenticators::ApplicationName;
 use crate::key_info_managers;
@@ -20,7 +20,7 @@ use psa_crypto::types::key;
 pub fn get_key_id(
     key_triple: &KeyTriple,
     store_handle: &dyn ManageKeyInfo,
-) -> Result<key::key_id_type> {
+) -> Result<key::psa_key_id_t> {
     match store_handle.get(key_triple) {
         Ok(Some(key_info)) => {
             if key_info.id.len() == 4 {
@@ -43,13 +43,13 @@ fn create_key_id(
     key_attributes: Attributes,
     store_handle: &mut dyn ManageKeyInfo,
     local_ids_handle: &mut LocalIdStore,
-) -> Result<key::key_id_type> {
-    let mut key_id = rand::random::<key::key_id_type>();
+) -> Result<key::psa_key_id_t> {
+    let mut key_id = rand::random::<key::psa_key_id_t>();
     while local_ids_handle.contains(&key_id)
-        || key_id == 0
-        || key_id > key::PSA_MAX_PERSISTENT_KEY_IDENTIFIER
+        || key_id < constants::PSA_KEY_ID_USER_MIN
+        || key_id > constants::PSA_KEY_ID_USER_MAX
     {
-        key_id = rand::random::<key::key_id_type>();
+        key_id = rand::random::<key::psa_key_id_t>();
     }
     let key_info = KeyInfo {
         id: key_id.to_ne_bytes().to_vec(),
@@ -70,7 +70,7 @@ fn create_key_id(
 
 fn remove_key_id(
     key_triple: &KeyTriple,
-    key_id: key::key_id_type,
+    key_id: key::psa_key_id_t,
     store_handle: &mut dyn ManageKeyInfo,
     local_ids_handle: &mut LocalIdStore,
 ) -> Result<()> {
@@ -213,7 +213,7 @@ impl MbedProvider {
         //   * self.key_handle_mutex prevents concurrent accesses
         //   * self.key_slot_semaphore prevents overflowing key slots
         let id = key::Id::from_persistent_key_id(key_id);
-        let key_attributes = new_key_management::get_key_attributes(id)?;
+        let key_attributes = key::Attributes::from_key_id(id)?;
         let buffer_size = utils::psa_export_public_key_size(&key_attributes)?;
         let mut buffer = vec![0u8; buffer_size];
 
@@ -251,18 +251,20 @@ impl MbedProvider {
         //   * self.key_handle_mutex prevents concurrent accesses
         //   * self.key_slot_semaphore prevents overflowing key slots
         let id = key::Id::from_persistent_key_id(key_id);
-        unsafe { destroy_key_status = new_key_management::destroy(id); }
+        unsafe {
+            destroy_key_status = new_key_management::destroy(id);
+        }
 
         match destroy_key_status {
             Ok(()) => {
                 remove_key_id(
-                &key_triple,
-                key_id,
-                &mut *store_handle,
-                &mut local_ids_handle,
+                    &key_triple,
+                    key_id,
+                    &mut *store_handle,
+                    &mut local_ids_handle,
                 )?;
                 Ok(psa_destroy_key::Result {})
-            },
+            }
             Err(error) => {
                 let error = ResponseStatus::from(error);
                 error!("Destroy key status: {}", error);

src/providers/mbed_provider/key_management.rs

@@ -10,8 +10,8 @@ use parsec_interface::operations::{
     psa_destroy_key, psa_export_public_key, psa_generate_key, psa_import_key, psa_sign_hash,
     psa_verify_hash,
 };
-use psa_crypto::types::{status, key};
 use parsec_interface::requests::{Opcode, ProviderID, ResponseStatus, Result};
+use psa_crypto::types::{key, status};
 use std::collections::HashSet;
 use std::io::{Error, ErrorKind};
 use std::sync::{Arc, Mutex, RwLock};
@@ -26,13 +26,13 @@ use uuid::Uuid;
     trivial_casts
 )]
 #[allow(clippy::all)]
-
 mod asym_sign;
 #[allow(dead_code)]
+mod constants;
 mod key_management;
 mod utils;
 
-type LocalIdStore = HashSet<key::key_id_type>;
+type LocalIdStore = HashSet<key::psa_key_id_t>;
 
 const SUPPORTED_OPCODES: [Opcode; 6] = [
     Opcode::PsaGenerateKey,
@@ -82,7 +82,7 @@ impl MbedProvider {
             key_info_store,
             local_ids: RwLock::new(HashSet::new()),
             key_handle_mutex: Mutex::new(()),
-            key_slot_semaphore: Semaphore::new(key::PSA_KEY_SLOT_COUNT),
+            key_slot_semaphore: Semaphore::new(constants::PSA_KEY_SLOT_COUNT),
         };
         {
             // The local scope allows to drop store_handle and local_ids_handle in order to return
@@ -120,13 +120,11 @@ impl MbedProvider {
                         // * the Mbed Crypto library has been initialized
                         // * this code is executed only by the main thread
                         let pc_key_id = key::Id::from_persistent_key_id(key_id);
-                        match psa_crypto::operations::key_management::get_key_attributes(pc_key_id) {
+                        match key::Attributes::from_key_id(pc_key_id) {
                             Ok(_) => {
                                 let _ = local_ids_handle.insert(key_id);
                             }
-                            Err(status::Error::DoesNotExist) => {
-                                to_remove.push(key_triple.clone())
-                            }
+                            Err(status::Error::DoesNotExist) => to_remove.push(key_triple.clone()),
                             Err(e) => {
                                 error!("Error {} when opening a persistent Mbed Crypto key.", e);
                                 return None;
@@ -221,13 +219,6 @@ impl Provide for MbedProvider {
     }
 }
 
-impl Drop for MbedProvider {
-    fn drop(&mut self) {
-        // Safety: the Provider was initialized with psa_crypto_init
-        psa_crypto::drop();
-    }
-}
-
 #[derive(Default, Derivative)]
 #[derivative(Debug)]
 pub struct MbedProviderBuilder {

src/providers/mbed_provider/mod.rs

@@ -1,8 +1,8 @@
 // Copyright 2019 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
-use psa_crypto::types::key;
 use parsec_interface::operations::psa_key_attributes::Type;
 use parsec_interface::requests::{ResponseStatus, Result};
+use psa_crypto::types::key;
 
 macro_rules! bits_to_bytes {
     ($size:expr) => {
@@ -14,8 +14,8 @@ macro_rules! bits_to_bytes {
 /// Implementing `PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE` as defined in `crypto_sizes.h` (Mbed Crypto).
 pub fn psa_asymmetric_sign_output_size(key_attrs: &key::Attributes) -> Result<usize> {
     match key_attrs.key_type {
-        Type::RsaKeyPair => Ok(usize::from(bits_to_bytes!(key_attrs.bits))),
-        Type::EccKeyPair{ .. } => Ok(usize::from(bits_to_bytes!(key_attrs.bits) * 2)),
+        Type::RsaKeyPair => Ok(bits_to_bytes!(key_attrs.bits)),
+        Type::EccKeyPair { .. } => Ok(bits_to_bytes!(key_attrs.bits) * 2),
         _ => Err(ResponseStatus::PsaErrorNotSupported),
     }
 }
@@ -30,9 +30,7 @@ pub fn psa_export_public_key_size(key_attrs: &key::Attributes) -> Result<usize>
     };
 
     match key_attrs.key_type {
-        Type::RsaPublicKey | Type::RsaKeyPair => Ok(usize::from(
-            export_asn1_int_max_size!(key_attrs.bits) + 11,
-        )),
+        Type::RsaPublicKey | Type::RsaKeyPair => Ok(export_asn1_int_max_size!(key_attrs.bits) + 11),
         _ => Err(ResponseStatus::PsaErrorNotSupported),
     }
-}
+}