Support encoding an owner in key file IDs

gilles-peskine-arm · gilles-peskine-arm · commit 2c1c33b3f000 · 2019-02-19T14:03:32.000+01:00
Differentiate between _key identifiers_, which are always `uint32_t`,
and _key file identifiers_, which are platform-dependent. Normally,
the two are the same.

In `psa/crypto_platform.h`, define `psa_app_key_id_t` (which is always
32 bits, the standard key identifier type) and
`psa_key_file_id_t` (which will be different in some service builds).
A subsequent commit will introduce a platform where the two are different.

It would make sense for the function declarations in `psa/crypto.h` to
use `psa_key_file_id_t`. However this file is currently part of the
PSA Crypto API specification, so it must stick to the standard type
`psa_key_id_t`. Hence, as long as the specification and Mbed Crypto
are not separate, use the implementation-specific file
`psa/crypto_platform.h` to define `psa_key_id_t` as `psa_key_file_id_t`.

In the library, systematically use `psa_key_file_id_t`.

    perl -i -pe 's/psa_key_id_t/psa_key_file_id_t/g' library/*.[hc]
diff --git a/include/psa/crypto_platform.h b/include/psa/crypto_platform.h
@@ -49,4 +49,27 @@
 /* Integral type representing a key handle. */
 typedef uint16_t psa_key_handle_t;
 
+/* This implementation distinguishes *application key identifiers*, which
+ * are the key identifiers specified by the application, from
+ * *key file identifiers*, which are the key identifiers that the library
+ * sees internally. The two types can be different if there is a remote
+ * call layer between the application and the library which supports
+ * multiple client applications that do not have access to each others'
+ * keys. The point of having different types is that the key file
+ * identifier may encode not only the key identifier specified by the
+ * application, but also the the identity of the application.
+ *
+ * Note that this is an internal concept of the library and the remote
+ * call layer. The application itself never sees anything other than
+ * #psa_app_key_id_t with its standard definition.
+ */
+
+/* The application key identifier is always what the application sees as
+ * #psa_key_id_t. */
+typedef uint32_t psa_app_key_id_t;
+
+/* By default, a key file identifier is just the application key identifier. */
+typedef psa_app_key_id_t psa_key_file_id_t;
+#define PSA_KEY_FILE_GET_KEY_ID( id ) ( id )
+
 #endif /* PSA_CRYPTO_PLATFORM_H */
diff --git a/library/psa_crypto_core.h b/library/psa_crypto_core.h
@@ -41,7 +41,7 @@ typedef struct
     psa_key_type_t type;
     psa_key_policy_t policy;
     psa_key_lifetime_t lifetime;
-    psa_key_id_t persistent_storage_id;
+    psa_key_file_id_t persistent_storage_id;
     unsigned allocated : 1;
     union
     {
diff --git a/library/psa_crypto_slot_management.c b/library/psa_crypto_slot_management.c
@@ -194,8 +194,9 @@ static psa_status_t psa_load_persistent_key_into_slot( psa_key_slot_t *p_slot )
  *
  * \return          1 if \p key_id is acceptable, otherwise 0.
  */
-static int psa_is_key_id_valid( psa_key_id_t key_id )
+static int psa_is_key_id_valid( psa_key_file_id_t file_id )
 {
+    psa_app_key_id_t key_id = PSA_KEY_FILE_GET_KEY_ID( file_id );
     /* Reject id=0 because by general library conventions, 0 is an invalid
      * value wherever possible. */
     if( key_id == 0 )
@@ -226,7 +227,7 @@ static int psa_is_key_id_valid( psa_key_id_t key_id )
  * \retval #PSA_ERROR_STORAGE_FAILURE
  */
 static psa_status_t psa_internal_make_key_persistent( psa_key_handle_t handle,
-                                                      psa_key_id_t id )
+                                                      psa_key_file_id_t id )
 {
 #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
     psa_key_slot_t *slot;
@@ -253,7 +254,7 @@ static psa_status_t psa_internal_make_key_persistent( psa_key_handle_t handle,
 }
 
 static psa_status_t persistent_key_setup( psa_key_lifetime_t lifetime,
-                                          psa_key_id_t id,
+                                          psa_key_file_id_t id,
                                           psa_key_handle_t *handle,
                                           psa_status_t wanted_load_status )
 {
@@ -278,14 +279,14 @@ static psa_status_t persistent_key_setup( psa_key_lifetime_t lifetime,
 }
 
 psa_status_t psa_open_key( psa_key_lifetime_t lifetime,
-                           psa_key_id_t id,
+                           psa_key_file_id_t id,
                            psa_key_handle_t *handle )
 {
     return( persistent_key_setup( lifetime, id, handle, PSA_SUCCESS ) );
 }
 
 psa_status_t psa_create_key( psa_key_lifetime_t lifetime,
-                             psa_key_id_t id,
+                             psa_key_file_id_t id,
                              psa_key_handle_t *handle )
 {
     psa_status_t status;
diff --git a/library/psa_crypto_storage.c b/library/psa_crypto_storage.c
@@ -148,7 +148,7 @@ psa_status_t psa_parse_key_data_from_storage( const uint8_t *storage_data,
     return( PSA_SUCCESS );
 }
 
-psa_status_t psa_save_persistent_key( const psa_key_id_t key,
+psa_status_t psa_save_persistent_key( const psa_key_file_id_t key,
                                       const psa_key_type_t type,
                                       const psa_key_policy_t *policy,
                                       const uint8_t *data,
@@ -186,7 +186,7 @@ void psa_free_persistent_key_data( uint8_t *key_data, size_t key_data_length )
     mbedtls_free( key_data );
 }
 
-psa_status_t psa_load_persistent_key( psa_key_id_t key,
+psa_status_t psa_load_persistent_key( psa_key_file_id_t key,
                                       psa_key_type_t *type,
                                       psa_key_policy_t *policy,
                                       uint8_t **data,
diff --git a/library/psa_crypto_storage.h b/library/psa_crypto_storage.h
@@ -86,7 +86,7 @@ extern "C" {
  * \retval PSA_ERROR_STORAGE_FAILURE
  * \retval PSA_ERROR_ALREADY_EXISTS
  */
-psa_status_t psa_save_persistent_key( const psa_key_id_t key,
+psa_status_t psa_save_persistent_key( const psa_key_file_id_t key,
                                       const psa_key_type_t type,
                                       const psa_key_policy_t *policy,
                                       const uint8_t *data,
@@ -117,7 +117,7 @@ psa_status_t psa_save_persistent_key( const psa_key_id_t key,
  * \retval PSA_ERROR_STORAGE_FAILURE
  * \retval PSA_ERROR_DOES_NOT_EXIST
  */
-psa_status_t psa_load_persistent_key( psa_key_id_t key,
+psa_status_t psa_load_persistent_key( psa_key_file_id_t key,
                                       psa_key_type_t *type,
                                       psa_key_policy_t *policy,
                                       uint8_t **data,
@@ -134,7 +134,7 @@ psa_status_t psa_load_persistent_key( psa_key_id_t key,
  *         or the key did not exist.
  * \retval PSA_ERROR_STORAGE_FAILURE
  */
-psa_status_t psa_destroy_persistent_key( const psa_key_id_t key );
+psa_status_t psa_destroy_persistent_key( const psa_key_file_id_t key );
 
 /**
  * \brief Free the temporary buffer allocated by psa_load_persistent_key().
diff --git a/library/psa_crypto_storage_backend.h b/library/psa_crypto_storage_backend.h
@@ -56,7 +56,7 @@ extern "C" {
  * \retval PSA_ERROR_STORAGE_FAILURE
  * \retval PSA_ERROR_DOES_NOT_EXIST
  */
-psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
+psa_status_t psa_crypto_storage_load( const psa_key_file_id_t key, uint8_t *data,
                                       size_t data_size );
 
 /**
@@ -75,7 +75,7 @@ psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
  * \retval PSA_ERROR_STORAGE_FAILURE
  * \retval PSA_ERROR_ALREADY_EXISTS
  */
-psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_store( const psa_key_file_id_t key,
                                        const uint8_t *data,
                                        size_t data_length );
 
@@ -92,7 +92,7 @@ psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
  * \retval 1
  *         Persistent data present for slot number
  */
-int psa_is_key_present_in_storage( const psa_key_id_t key );
+int psa_is_key_present_in_storage( const psa_key_file_id_t key );
 
 /**
  * \brief Get data length for given key slot number.
@@ -104,7 +104,7 @@ int psa_is_key_present_in_storage( const psa_key_id_t key );
  * \retval PSA_SUCCESS
  * \retval PSA_ERROR_STORAGE_FAILURE
  */
-psa_status_t psa_crypto_storage_get_data_length( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_get_data_length( const psa_key_file_id_t key,
                                                  size_t *data_length );
 
 
diff --git a/library/psa_crypto_storage_file.c b/library/psa_crypto_storage_file.c
@@ -49,7 +49,7 @@
 
 enum { MAX_LOCATION_LEN = sizeof(CRYPTO_STORAGE_FILE_LOCATION) + 40 };
 
-static void key_id_to_location( const psa_key_id_t key,
+static void key_id_to_location( const psa_key_file_id_t key,
                                 char *location,
                                 size_t location_size )
 {
@@ -58,7 +58,7 @@ static void key_id_to_location( const psa_key_id_t key,
                       (unsigned long) key );
 }
 
-psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
+psa_status_t psa_crypto_storage_load( const psa_key_file_id_t key, uint8_t *data,
                                       size_t data_size )
 {
     psa_status_t status = PSA_SUCCESS;
@@ -83,7 +83,7 @@ psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
     return( status );
 }
 
-int psa_is_key_present_in_storage( const psa_key_id_t key )
+int psa_is_key_present_in_storage( const psa_key_file_id_t key )
 {
     char slot_location[MAX_LOCATION_LEN];
     FILE *file;
@@ -101,7 +101,7 @@ int psa_is_key_present_in_storage( const psa_key_id_t key )
     return( 1 );
 }
 
-psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_store( const psa_key_file_id_t key,
                                        const uint8_t *data,
                                        size_t data_length )
 {
@@ -156,7 +156,7 @@ psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
     return( status );
 }
 
-psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )
+psa_status_t psa_destroy_persistent_key( const psa_key_file_id_t key )
 {
     FILE *file;
     char slot_location[MAX_LOCATION_LEN];
@@ -175,7 +175,7 @@ psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )
     return( PSA_SUCCESS );
 }
 
-psa_status_t psa_crypto_storage_get_data_length( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_get_data_length( const psa_key_file_id_t key,
                                                  size_t *data_length )
 {
     psa_status_t status = PSA_SUCCESS;
diff --git a/library/psa_crypto_storage_its.c b/library/psa_crypto_storage_its.c
@@ -36,12 +36,12 @@
 #include "mbedtls/platform.h"
 #endif
 
-static psa_storage_uid_t psa_its_identifier_of_slot( psa_key_id_t key )
+static psa_storage_uid_t psa_its_identifier_of_slot( psa_key_file_id_t key )
 {
     return( key );
 }
 
-psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
+psa_status_t psa_crypto_storage_load( const psa_key_file_id_t key, uint8_t *data,
                                       size_t data_size )
 {
     psa_status_t status;
@@ -57,7 +57,7 @@ psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,
     return( status );
 }
 
-int psa_is_key_present_in_storage( const psa_key_id_t key )
+int psa_is_key_present_in_storage( const psa_key_file_id_t key )
 {
     psa_status_t ret;
     psa_storage_uid_t data_identifier = psa_its_identifier_of_slot( key );
@@ -70,7 +70,7 @@ int psa_is_key_present_in_storage( const psa_key_id_t key )
     return( 1 );
 }
 
-psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_store( const psa_key_file_id_t key,
                                        const uint8_t *data,
                                        size_t data_length )
 {
@@ -105,7 +105,7 @@ psa_status_t psa_crypto_storage_store( const psa_key_id_t key,
     return( status );
 }
 
-psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )
+psa_status_t psa_destroy_persistent_key( const psa_key_file_id_t key )
 {
     psa_status_t ret;
     psa_storage_uid_t data_identifier = psa_its_identifier_of_slot( key );
@@ -125,7 +125,7 @@ psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )
     return( PSA_SUCCESS );
 }
 
-psa_status_t psa_crypto_storage_get_data_length( const psa_key_id_t key,
+psa_status_t psa_crypto_storage_get_data_length( const psa_key_file_id_t key,
                                                  size_t *data_length )
 {
     psa_status_t status;

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ typedef struct`
`41`	`41`	`psa_key_type_t type;`
`42`	`42`	`psa_key_policy_t policy;`
`43`	`43`	`psa_key_lifetime_t lifetime;`
`44`		`- psa_key_id_t persistent_storage_id;`
	`44`	`+ psa_key_file_id_t persistent_storage_id;`
`45`	`45`	`unsigned allocated : 1;`
`46`	`46`	`union`
`47`	`47`	`{`
Original file line number	Diff line number	Diff line change
`@@ -194,8 +194,9 @@ static psa_status_t psa_load_persistent_key_into_slot( psa_key_slot_t *p_slot )`
`194`	`194`	`*`
`195`	`195`	`* \return 1 if \p key_id is acceptable, otherwise 0.`
`196`	`196`	`*/`
`197`		`-static int psa_is_key_id_valid( psa_key_id_t key_id )`
	`197`	`+static int psa_is_key_id_valid( psa_key_file_id_t file_id )`
`198`	`198`	`{`
	`199`	`+ psa_app_key_id_t key_id = PSA_KEY_FILE_GET_KEY_ID( file_id );`
`199`	`200`	`/* Reject id=0 because by general library conventions, 0 is an invalid`
`200`	`201`	`* value wherever possible. */`
`201`	`202`	`if( key_id == 0 )`
`@@ -226,7 +227,7 @@ static int psa_is_key_id_valid( psa_key_id_t key_id )`
`226`	`227`	`* \retval #PSA_ERROR_STORAGE_FAILURE`
`227`	`228`	`*/`
`228`	`229`	`static psa_status_t psa_internal_make_key_persistent( psa_key_handle_t handle,`
`229`		`- psa_key_id_t id )`
	`230`	`+ psa_key_file_id_t id )`
`230`	`231`	`{`
`231`	`232`	`#if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)`
`232`	`233`	`psa_key_slot_t *slot;`
`@@ -253,7 +254,7 @@ static psa_status_t psa_internal_make_key_persistent( psa_key_handle_t handle,`
`253`	`254`	`}`
`254`	`255`
`255`	`256`	`static psa_status_t persistent_key_setup( psa_key_lifetime_t lifetime,`
`256`		`- psa_key_id_t id,`
	`257`	`+ psa_key_file_id_t id,`
`257`	`258`	`psa_key_handle_t *handle,`
`258`	`259`	`psa_status_t wanted_load_status )`
`259`	`260`	`{`
`@@ -278,14 +279,14 @@ static psa_status_t persistent_key_setup( psa_key_lifetime_t lifetime,`
`278`	`279`	`}`
`279`	`280`
`280`	`281`	`psa_status_t psa_open_key( psa_key_lifetime_t lifetime,`
`281`		`- psa_key_id_t id,`
	`282`	`+ psa_key_file_id_t id,`
`282`	`283`	`psa_key_handle_t *handle )`
`283`	`284`	`{`
`284`	`285`	`return( persistent_key_setup( lifetime, id, handle, PSA_SUCCESS ) );`
`285`	`286`	`}`
`286`	`287`
`287`	`288`	`psa_status_t psa_create_key( psa_key_lifetime_t lifetime,`
`288`		`- psa_key_id_t id,`
	`289`	`+ psa_key_file_id_t id,`
`289`	`290`	`psa_key_handle_t *handle )`
`290`	`291`	`{`
`291`	`292`	`psa_status_t status;`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@`
`49`	`49`
`50`	`50`	`enum { MAX_LOCATION_LEN = sizeof(CRYPTO_STORAGE_FILE_LOCATION) + 40 };`
`51`	`51`
`52`		`-static void key_id_to_location( const psa_key_id_t key,`
	`52`	`+static void key_id_to_location( const psa_key_file_id_t key,`
`53`	`53`	`char *location,`
`54`	`54`	`size_t location_size )`
`55`	`55`	`{`
`@@ -58,7 +58,7 @@ static void key_id_to_location( const psa_key_id_t key,`
`58`	`58`	`(unsigned long) key );`
`59`	`59`	`}`
`60`	`60`
`61`		`-psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,`
	`61`	`+psa_status_t psa_crypto_storage_load( const psa_key_file_id_t key, uint8_t *data,`
`62`	`62`	`size_t data_size )`
`63`	`63`	`{`
`64`	`64`	`psa_status_t status = PSA_SUCCESS;`
`@@ -83,7 +83,7 @@ psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,`
`83`	`83`	`return( status );`
`84`	`84`	`}`
`85`	`85`
`86`		`-int psa_is_key_present_in_storage( const psa_key_id_t key )`
	`86`	`+int psa_is_key_present_in_storage( const psa_key_file_id_t key )`
`87`	`87`	`{`
`88`	`88`	`char slot_location[MAX_LOCATION_LEN];`
`89`	`89`	`FILE *file;`
`@@ -101,7 +101,7 @@ int psa_is_key_present_in_storage( const psa_key_id_t key )`
`101`	`101`	`return( 1 );`
`102`	`102`	`}`
`103`	`103`
`104`		`-psa_status_t psa_crypto_storage_store( const psa_key_id_t key,`
	`104`	`+psa_status_t psa_crypto_storage_store( const psa_key_file_id_t key,`
`105`	`105`	`const uint8_t *data,`
`106`	`106`	`size_t data_length )`
`107`	`107`	`{`
`@@ -156,7 +156,7 @@ psa_status_t psa_crypto_storage_store( const psa_key_id_t key,`
`156`	`156`	`return( status );`
`157`	`157`	`}`
`158`	`158`
`159`		`-psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )`
	`159`	`+psa_status_t psa_destroy_persistent_key( const psa_key_file_id_t key )`
`160`	`160`	`{`
`161`	`161`	`FILE *file;`
`162`	`162`	`char slot_location[MAX_LOCATION_LEN];`
`@@ -175,7 +175,7 @@ psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )`
`175`	`175`	`return( PSA_SUCCESS );`
`176`	`176`	`}`
`177`	`177`
`178`		`-psa_status_t psa_crypto_storage_get_data_length( const psa_key_id_t key,`
	`178`	`+psa_status_t psa_crypto_storage_get_data_length( const psa_key_file_id_t key,`
`179`	`179`	`size_t *data_length )`
`180`	`180`	`{`
`181`	`181`	`psa_status_t status = PSA_SUCCESS;`
Original file line number	Diff line number	Diff line change
`@@ -36,12 +36,12 @@`
`36`	`36`	`#include "mbedtls/platform.h"`
`37`	`37`	`#endif`
`38`	`38`
`39`		`-static psa_storage_uid_t psa_its_identifier_of_slot( psa_key_id_t key )`
	`39`	`+static psa_storage_uid_t psa_its_identifier_of_slot( psa_key_file_id_t key )`
`40`	`40`	`{`
`41`	`41`	`return( key );`
`42`	`42`	`}`
`43`	`43`
`44`		`-psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,`
	`44`	`+psa_status_t psa_crypto_storage_load( const psa_key_file_id_t key, uint8_t *data,`
`45`	`45`	`size_t data_size )`
`46`	`46`	`{`
`47`	`47`	`psa_status_t status;`
`@@ -57,7 +57,7 @@ psa_status_t psa_crypto_storage_load( const psa_key_id_t key, uint8_t *data,`
`57`	`57`	`return( status );`
`58`	`58`	`}`
`59`	`59`
`60`		`-int psa_is_key_present_in_storage( const psa_key_id_t key )`
	`60`	`+int psa_is_key_present_in_storage( const psa_key_file_id_t key )`
`61`	`61`	`{`
`62`	`62`	`psa_status_t ret;`
`63`	`63`	`psa_storage_uid_t data_identifier = psa_its_identifier_of_slot( key );`
`@@ -70,7 +70,7 @@ int psa_is_key_present_in_storage( const psa_key_id_t key )`
`70`	`70`	`return( 1 );`
`71`	`71`	`}`
`72`	`72`
`73`		`-psa_status_t psa_crypto_storage_store( const psa_key_id_t key,`
	`73`	`+psa_status_t psa_crypto_storage_store( const psa_key_file_id_t key,`
`74`	`74`	`const uint8_t *data,`
`75`	`75`	`size_t data_length )`
`76`	`76`	`{`
`@@ -105,7 +105,7 @@ psa_status_t psa_crypto_storage_store( const psa_key_id_t key,`
`105`	`105`	`return( status );`
`106`	`106`	`}`
`107`	`107`
`108`		`-psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )`
	`108`	`+psa_status_t psa_destroy_persistent_key( const psa_key_file_id_t key )`
`109`	`109`	`{`
`110`	`110`	`psa_status_t ret;`
`111`	`111`	`psa_storage_uid_t data_identifier = psa_its_identifier_of_slot( key );`
`@@ -125,7 +125,7 @@ psa_status_t psa_destroy_persistent_key( const psa_key_id_t key )`
`125`	`125`	`return( PSA_SUCCESS );`
`126`	`126`	`}`
`127`	`127`
`128`		`-psa_status_t psa_crypto_storage_get_data_length( const psa_key_id_t key,`
	`128`	`+psa_status_t psa_crypto_storage_get_data_length( const psa_key_file_id_t key,`
`129`	`129`	`size_t *data_length )`
`130`	`130`	`{`
`131`	`131`	`psa_status_t status;`