common.h

Go to the documentation of this file.

        /*
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#pragma once
 
#include "cracen_psa.h"
#include "sxsymcrypt/internal.h"
 
#include <stddef.h>
#include <stdint.h>
#include <zephyr/sys/util.h>
#include <silexpk/sxbuf/sxbufop.h>
#include <sxsymcrypt/hashdefs.h>
#include <silexpk/core.h>
 
#define CRACEN_PSA_IS_KEY_FLAG(flag, attr) ((flag) == (psa_get_key_usage_flags((attr)) & (flag)))
#define CRACEN_PSA_IS_KEY_TYPE(flag, attr) ((flag) == (psa_get_key_type((attr)) & (flag)))
 
#if defined(__has_builtin) && __has_builtin(__builtin_abs)
#define cracen_abs(x) __builtin_abs(x)
#else
#define cracen_abs(x) ((x) < 0 ? -(x) : (x))
#endif
 
 
typedef struct {
        uint8_t slot_number;
        uint8_t owner_id;
} ikg_opaque_key;
 
__must_check psa_status_t silex_statuscodes_to_psa(int sx_status);
 
__must_check psa_status_t
cracen_hash_get_algo(psa_algorithm_t alg, const struct sxhashalg **sx_hash_algo);
 
__must_check psa_status_t
cracen_xof_get_algo(psa_algorithm_t alg, const struct sxhashalg **sx_xof_algo);
 
psa_status_t cracen_rnd_in_range(uint8_t *n, size_t sz, const uint8_t *upperlimit,
                                 size_t retrylimit);
 
void cracen_xorbytes(uint8_t *a, const uint8_t *b, size_t sz);
 
psa_status_t cracen_load_keyref(const psa_key_attributes_t *attributes, const uint8_t *key_buffer,
                                size_t key_buffer_size, struct sxkeyref *k);
 
int cracen_prepare_ik_key(const uint8_t *user_data);
 
void cracen_be_add(uint8_t *v, size_t v_size, size_t summand);
 
int cracen_be_sub(const uint8_t *a, const uint8_t *b, uint8_t *c, size_t sz);
 
void cracen_be_rshift(const uint8_t *a, int n, uint8_t *r, size_t sz);
 
int cracen_be_cmp(const uint8_t *a, const uint8_t *b, size_t sz, int carry);
 
void cracen_be_xor(uint8_t *buf, size_t buf_sz, size_t xor_val);
 
static inline void cracen_put_le16(uint16_t val, uint8_t *dst)
{
        dst[0] = val;
        dst[1] = val >> 8;
}
 
static inline uint16_t cracen_get_le16(const uint8_t *src)
{
        return ((uint16_t)src[1] << 8) | src[0];
}
 
static inline void cracen_put_le32(uint32_t val, uint8_t *dst)
{
        cracen_put_le16(val, dst);
        cracen_put_le16(val >> 16, &dst[2]);
}
 
static inline uint32_t cracen_get_le32(const uint8_t src[4])
{
        return ((uint32_t)cracen_get_le16(&src[2]) << 16) | cracen_get_le16(&src[0]);
}
 
int cracen_hash_all_inputs_with_context(struct sxhash *sxhashopctx, const uint8_t *inputs[],
                                        const size_t input_lengths[], size_t input_count,
                                        const struct sxhashalg *hashalg, uint8_t *digest);
 
int cracen_hash_input_with_context(struct sxhash *hashopctx, const uint8_t *input,
                                   const size_t input_length, const struct sxhashalg *hashalg,
                                   uint8_t *digest);
 
int cracen_hash_all_inputs(const uint8_t *inputs[], const size_t input_lengths[],
                           size_t input_count, const struct sxhashalg *hashalg, uint8_t *digest);
 
int cracen_hash_input(const uint8_t *input, const size_t input_length,
                      const struct sxhashalg *hashalg, uint8_t *digest);
 
int cracen_get_rnd_in_range(const uint8_t *n, size_t nsz, uint8_t *out);