psa_crypto_slot_management.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 HAW Hamburg
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "clist.h"
#include "psa_crypto_se_management.h"
 
#define PSA_PROTECTED_KEY_COUNT         (CONFIG_PSA_PROTECTED_KEY_COUNT)
 
#define PSA_ASYMMETRIC_KEYPAIR_COUNT    (CONFIG_PSA_ASYMMETRIC_KEYPAIR_COUNT)
 
#define PSA_SINGLE_KEY_COUNT            (CONFIG_PSA_SINGLE_KEY_COUNT)
 
#define PSA_KEY_SLOT_COUNT              (PSA_PROTECTED_KEY_COUNT + \
                                         PSA_ASYMMETRIC_KEYPAIR_COUNT + \
                                         PSA_SINGLE_KEY_COUNT)
 
#define PSA_KEY_ID_VOLATILE_MIN (PSA_KEY_ID_VENDOR_MIN)
 
#define PSA_KEY_ID_VOLATILE_MAX (PSA_KEY_ID_VENDOR_MAX)
 
typedef struct {
    clist_node_t node;                          
    size_t lock_count;                          
    psa_key_attributes_t attr;                  
#if PSA_SINGLE_KEY_COUNT
    struct key_data {
        uint8_t data[PSA_MAX_KEY_DATA_SIZE];    
        size_t data_len;                        
    } key;                                      
#endif /* PSA_SINGLE_KEY_COUNT */
} psa_key_slot_t;
 
#if PSA_PROTECTED_KEY_COUNT
typedef struct {
    clist_node_t node;
    size_t lock_count;
    psa_key_attributes_t attr;
    struct prot_key_data {
        psa_key_slot_number_t slot_number;
#if IS_USED(MODULE_PSA_ASYMMETRIC)
        uint8_t pubkey_data[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE];
        size_t pubkey_data_len;
#endif
    } key;
} psa_prot_key_slot_t;
#endif /* PSA_PROTECTED_KEY_COUNT */
 
#if PSA_ASYMMETRIC_KEYPAIR_COUNT
typedef struct {
    clist_node_t node;
    size_t lock_count;
    psa_key_attributes_t attr;
    struct key_pair_data {
        uint8_t privkey_data[PSA_BITS_TO_BYTES(PSA_MAX_PRIV_KEY_SIZE)];
        size_t privkey_data_len;
        uint8_t pubkey_data[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE];
        size_t pubkey_data_len;
    } key;
} psa_key_pair_slot_t;
#endif /* PSA_ASYMMETRIC_KEYPAIR_COUNT */
 
void psa_init_key_slots(void);
 
static inline int psa_key_id_is_volatile(psa_key_id_t key_id)
{
    return ((key_id >= PSA_KEY_ID_VOLATILE_MIN) &&
            (key_id <= PSA_KEY_ID_VOLATILE_MAX));
}
 
static inline int psa_is_key_slot_locked(psa_key_slot_t *slot)
{
    return (slot->lock_count > 0);
}
 
psa_key_slot_number_t * psa_key_slot_get_slot_number(const psa_key_slot_t *slot);
 
static inline int psa_key_lifetime_is_external(psa_key_lifetime_t lifetime)
{
    return (PSA_KEY_LIFETIME_GET_LOCATION(lifetime) != PSA_KEY_LOCATION_LOCAL_STORAGE);
}
 
psa_status_t psa_wipe_key_slot(psa_key_slot_t *slot);
 
void psa_wipe_all_key_slots(void);
 
psa_status_t psa_get_and_lock_key_slot(psa_key_id_t id, psa_key_slot_t **slot);
 
psa_status_t psa_persist_key_slot_in_storage(psa_key_slot_t *slot);
 
psa_status_t psa_allocate_empty_key_slot(   psa_key_id_t *id,
                                            const psa_key_attributes_t *attr,
                                            psa_key_slot_t **p_slot);
 
psa_status_t psa_lock_key_slot(psa_key_slot_t *slot);
 
psa_status_t psa_unlock_key_slot(psa_key_slot_t *slot);
 
psa_status_t psa_validate_key_location( psa_key_lifetime_t lifetime,
                                        psa_se_drv_data_t **driver);
 
psa_status_t psa_validate_key_persistence(psa_key_lifetime_t lifetime);
 
int psa_is_valid_key_id(psa_key_id_t id, int vendor);
 
size_t psa_get_key_data_from_key_slot(const psa_key_slot_t *slot,
                                    uint8_t **key_data,
                                    size_t **key_bytes);
 
void psa_get_public_key_data_from_key_slot( const psa_key_slot_t *slot,
                                            uint8_t **pubkey_data,
                                            size_t **pubkey_data_len);
 
#ifdef __cplusplus
}
#endif