crypto_service.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
#ifndef CRYPTO_SERVICE_H__
#define CRYPTO_SERVICE_H__
 
#include <psa/crypto.h>
 
psa_status_t ssf_psa_crypto_init(void);
 
psa_status_t ssf_psa_get_key_attributes(mbedtls_svc_key_id_t key, psa_key_attributes_t *attributes);
 
psa_status_t ssf_psa_reset_key_attributes(psa_key_attributes_t *attributes);
 
psa_status_t ssf_psa_purge_key(mbedtls_svc_key_id_t key);
 
psa_status_t ssf_psa_copy_key(mbedtls_svc_key_id_t source_key,
                              const psa_key_attributes_t *attributes,
                              mbedtls_svc_key_id_t *target_key);
 
psa_status_t ssf_psa_destroy_key(mbedtls_svc_key_id_t key);
 
psa_status_t ssf_psa_import_key(const psa_key_attributes_t *attributes, const uint8_t *data,
                                size_t data_length, mbedtls_svc_key_id_t *key);
 
psa_status_t ssf_psa_export_key(mbedtls_svc_key_id_t key, uint8_t *data, size_t data_size,
                                size_t *data_length);
 
psa_status_t ssf_psa_export_public_key(mbedtls_svc_key_id_t key, uint8_t *data, size_t data_size,
                                       size_t *data_length);
 
psa_status_t ssf_psa_hash_compute(psa_algorithm_t alg, const uint8_t *input, size_t input_length,
                                  uint8_t *hash, size_t hash_size, size_t *hash_length);
 
psa_status_t ssf_psa_hash_compare(psa_algorithm_t alg, const uint8_t *input, size_t input_length,
                                  const uint8_t *hash, size_t hash_length);
 
psa_status_t ssf_psa_hash_setup(mbedtls_psa_client_handle_t *p_handle, psa_algorithm_t alg);
 
psa_status_t ssf_psa_hash_update(mbedtls_psa_client_handle_t *p_handle, const uint8_t *input,
                                 size_t input_length);
 
psa_status_t ssf_psa_hash_finish(mbedtls_psa_client_handle_t *p_handle, uint8_t *hash,
                                 size_t hash_size, size_t *hash_length);
 
psa_status_t ssf_psa_hash_verify(mbedtls_psa_client_handle_t *p_handle, const uint8_t *hash,
                                 size_t hash_length);
 
psa_status_t ssf_psa_hash_abort(mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_hash_clone(mbedtls_psa_client_handle_t handle,
                                mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_mac_compute(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                 const uint8_t *input, size_t input_length, uint8_t *mac,
                                 size_t mac_size, size_t *mac_length);
 
psa_status_t ssf_psa_mac_verify(mbedtls_svc_key_id_t key, psa_algorithm_t alg, const uint8_t *input,
                                size_t input_length, const uint8_t *mac, size_t mac_length);
 
psa_status_t ssf_psa_mac_sign_setup(mbedtls_psa_client_handle_t *p_handle, mbedtls_svc_key_id_t key,
                                    psa_algorithm_t alg);
 
psa_status_t ssf_psa_mac_verify_setup(mbedtls_psa_client_handle_t *p_handle,
                                      mbedtls_svc_key_id_t key, psa_algorithm_t alg);
 
psa_status_t ssf_psa_mac_update(mbedtls_psa_client_handle_t *p_handle, const uint8_t *input,
                                size_t input_length);
 
psa_status_t ssf_psa_mac_sign_finish(mbedtls_psa_client_handle_t *p_handle, uint8_t *mac,
                                     size_t mac_size, size_t *mac_length);
 
psa_status_t ssf_psa_mac_verify_finish(mbedtls_psa_client_handle_t *p_handle, const uint8_t *mac,
                                       size_t mac_length);
 
psa_status_t ssf_psa_mac_abort(mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_cipher_encrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                    const uint8_t *input, size_t input_length, uint8_t *output,
                                    size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_cipher_decrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                    const uint8_t *input, size_t input_length, uint8_t *output,
                                    size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_cipher_encrypt_setup(mbedtls_psa_client_handle_t *p_handle,
                                          mbedtls_svc_key_id_t key, psa_algorithm_t alg);
 
psa_status_t ssf_psa_cipher_decrypt_setup(mbedtls_psa_client_handle_t *p_handle,
                                          mbedtls_svc_key_id_t key, psa_algorithm_t alg);
 
psa_status_t ssf_psa_cipher_generate_iv(mbedtls_psa_client_handle_t *p_handle, uint8_t *iv,
                                        size_t iv_size, size_t *iv_length);
 
psa_status_t ssf_psa_cipher_set_iv(mbedtls_psa_client_handle_t *p_handle, const uint8_t *iv,
                                   size_t iv_length);
 
psa_status_t ssf_psa_cipher_update(mbedtls_psa_client_handle_t *p_handle, const uint8_t *input,
                                   size_t input_length, uint8_t *output, size_t output_size,
                                   size_t *output_length);
 
psa_status_t ssf_psa_cipher_finish(mbedtls_psa_client_handle_t *p_handle, uint8_t *output,
                                   size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_cipher_abort(mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_aead_encrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                  const uint8_t *nonce, size_t nonce_length,
                                  const uint8_t *additional_data, size_t additional_data_length,
                                  const uint8_t *plaintext, size_t plaintext_length,
                                  uint8_t *ciphertext, size_t ciphertext_size,
                                  size_t *ciphertext_length);
 
psa_status_t ssf_psa_aead_decrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                  const uint8_t *nonce, size_t nonce_length,
                                  const uint8_t *additional_data, size_t additional_data_length,
                                  const uint8_t *ciphertext, size_t ciphertext_length,
                                  uint8_t *plaintext, size_t plaintext_size,
                                  size_t *plaintext_length);
 
psa_status_t ssf_psa_aead_encrypt_setup(mbedtls_psa_client_handle_t *p_handle,
                                        mbedtls_svc_key_id_t key, psa_algorithm_t alg);
 
psa_status_t ssf_psa_aead_decrypt_setup(mbedtls_psa_client_handle_t *p_handle,
                                        mbedtls_svc_key_id_t key, psa_algorithm_t alg);
 
psa_status_t ssf_psa_aead_generate_nonce(mbedtls_psa_client_handle_t *p_handle, uint8_t *nonce,
                                         size_t nonce_size, size_t *nonce_length);
 
psa_status_t ssf_psa_aead_set_nonce(mbedtls_psa_client_handle_t *p_handle, const uint8_t *nonce,
                                    size_t nonce_length);
 
psa_status_t ssf_psa_aead_set_lengths(mbedtls_psa_client_handle_t *p_handle, size_t ad_length,
                                      size_t plaintext_length);
 
psa_status_t ssf_psa_aead_update_ad(mbedtls_psa_client_handle_t *p_handle, const uint8_t *input,
                                    size_t input_length);
 
psa_status_t ssf_psa_aead_update(mbedtls_psa_client_handle_t *p_handle, const uint8_t *input,
                                 size_t input_length, uint8_t *output, size_t output_size,
                                 size_t *output_length);
 
psa_status_t ssf_psa_aead_finish(mbedtls_psa_client_handle_t *p_handle, uint8_t *ciphertext,
                                 size_t ciphertext_size, size_t *ciphertext_length, uint8_t *tag,
                                 size_t tag_size, size_t *tag_length);
 
psa_status_t ssf_psa_aead_verify(mbedtls_psa_client_handle_t *p_handle, uint8_t *plaintext,
                                 size_t plaintext_size, size_t *plaintext_length,
                                 const uint8_t *tag, size_t tag_length);
 
psa_status_t ssf_psa_aead_abort(mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_sign_message(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                  const uint8_t *input, size_t input_length, uint8_t *signature,
                                  size_t signature_size, size_t *signature_length);
 
psa_status_t ssf_psa_verify_message(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                    const uint8_t *input, size_t input_length,
                                    const uint8_t *signature, size_t signature_length);
 
psa_status_t ssf_psa_sign_hash(mbedtls_svc_key_id_t key, psa_algorithm_t alg, const uint8_t *hash,
                               size_t hash_length, uint8_t *signature, size_t signature_size,
                               size_t *signature_length);
 
psa_status_t ssf_psa_verify_hash(mbedtls_svc_key_id_t key, psa_algorithm_t alg, const uint8_t *hash,
                                 size_t hash_length, const uint8_t *signature,
                                 size_t signature_length);
 
psa_status_t ssf_psa_asymmetric_encrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                        const uint8_t *input, size_t input_length,
                                        const uint8_t *salt, size_t salt_length, uint8_t *output,
                                        size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_asymmetric_decrypt(mbedtls_svc_key_id_t key, psa_algorithm_t alg,
                                        const uint8_t *input, size_t input_length,
                                        const uint8_t *salt, size_t salt_length, uint8_t *output,
                                        size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_key_derivation_setup(mbedtls_psa_client_handle_t *p_handle,
                                          psa_algorithm_t alg);
 
psa_status_t ssf_psa_key_derivation_get_capacity(mbedtls_psa_client_handle_t handle,
                                                 size_t *capacity);
 
psa_status_t ssf_psa_key_derivation_set_capacity(mbedtls_psa_client_handle_t *p_handle,
                                                 size_t capacity);
 
psa_status_t ssf_psa_key_derivation_input_bytes(mbedtls_psa_client_handle_t *p_handle,
                                                psa_key_derivation_step_t step, const uint8_t *data,
                                                size_t data_length);
 
psa_status_t ssf_psa_key_derivation_input_integer(mbedtls_psa_client_handle_t *p_handle,
                                                  psa_key_derivation_step_t step, uint64_t value);
 
psa_status_t ssf_psa_key_derivation_input_key(mbedtls_psa_client_handle_t *p_handle,
                                              psa_key_derivation_step_t step,
                                              mbedtls_svc_key_id_t key);
 
psa_status_t ssf_psa_key_derivation_key_agreement(mbedtls_psa_client_handle_t *p_handle,
                                                  psa_key_derivation_step_t step,
                                                  mbedtls_svc_key_id_t private_key,
                                                  const uint8_t *peer_key, size_t peer_key_length);
 
psa_status_t ssf_psa_key_derivation_output_bytes(mbedtls_psa_client_handle_t *p_handle,
                                                 uint8_t *output, size_t output_length);
 
psa_status_t ssf_psa_key_derivation_output_key(const psa_key_attributes_t *attributes,
                                               mbedtls_psa_client_handle_t *p_handle,
                                               mbedtls_svc_key_id_t *key);
 
psa_status_t ssf_psa_key_derivation_abort(mbedtls_psa_client_handle_t *p_handle);
 
psa_status_t ssf_psa_raw_key_agreement(psa_algorithm_t alg, mbedtls_svc_key_id_t private_key,
                                       const uint8_t *peer_key, size_t peer_key_length,
                                       uint8_t *output, size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_generate_random(uint8_t *output, size_t output_size);
 
psa_status_t ssf_psa_generate_key(const psa_key_attributes_t *attributes,
                                  mbedtls_svc_key_id_t *key);
 
psa_status_t ssf_psa_pake_setup(mbedtls_psa_client_handle_t *p_handle,
                                mbedtls_svc_key_id_t password_key,
                                const psa_pake_cipher_suite_t *cipher_suite);
 
psa_status_t ssf_psa_pake_set_role(mbedtls_psa_client_handle_t *p_handle, psa_pake_role_t role);
 
psa_status_t ssf_psa_pake_set_user(mbedtls_psa_client_handle_t *p_handle, const uint8_t *user_id,
                                   size_t user_id_len);
 
psa_status_t ssf_psa_pake_set_peer(mbedtls_psa_client_handle_t *p_handle, const uint8_t *peer_id,
                                   size_t peer_id_len);
 
psa_status_t ssf_psa_pake_set_context(mbedtls_psa_client_handle_t *p_handle, const uint8_t *context,
                                      size_t context_len);
 
psa_status_t ssf_psa_pake_output(mbedtls_psa_client_handle_t *p_handle, psa_pake_step_t step,
                                 uint8_t *output, size_t output_size, size_t *output_length);
 
psa_status_t ssf_psa_pake_input(mbedtls_psa_client_handle_t *p_handle, psa_pake_step_t step,
                                const uint8_t *input, size_t input_length);
 
psa_status_t ssf_psa_pake_get_shared_key(mbedtls_psa_client_handle_t *p_handle,
                                         const psa_key_attributes_t *attributes,
                                         mbedtls_svc_key_id_t *key);
 
psa_status_t ssf_psa_pake_abort(mbedtls_psa_client_handle_t *p_handle);
 
#endif /* CRYPTO_SERVICE_H__ */