mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-30 11:04:17 +01:00
b699f07af0
Change psa_get_domain_parameters() and psa_set_domain_parameters() to access a psa_key_attributes_t structure rather than a key handle. In psa_get_key_attributes(), treat the RSA public exponent as a domain parameter and read it out. This is in preparation for removing the `extra` parameter of psa_generate_key() and setting the RSA public exponent for key generation via domain parameters. In this commit, the default public exponent 65537 is not treated specially, which allows us to verify that test code that should be calling psa_reset_key_attributes() after retrieving the attributes of an RSA key is doing so properly (if it wasn't, there would be a memory leak), even if the test data happens to use an RSA key with the default public exponent.
363 lines
9.5 KiB
C
363 lines
9.5 KiB
C
/**
|
|
* \file psa/crypto_struct.h
|
|
*
|
|
* \brief PSA cryptography module: Mbed TLS structured type implementations
|
|
*
|
|
* \note This file may not be included directly. Applications must
|
|
* include psa/crypto.h.
|
|
*
|
|
* This file contains the definitions of some data structures with
|
|
* implementation-specific definitions.
|
|
*
|
|
* In implementations with isolation between the application and the
|
|
* cryptography module, it is expected that the front-end and the back-end
|
|
* would have different versions of this file.
|
|
*/
|
|
/*
|
|
* Copyright (C) 2018, ARM Limited, All Rights Reserved
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* This file is part of mbed TLS (https://tls.mbed.org)
|
|
*/
|
|
|
|
#ifndef PSA_CRYPTO_STRUCT_H
|
|
#define PSA_CRYPTO_STRUCT_H
|
|
|
|
/* Include the Mbed TLS configuration file, the way Mbed TLS does it
|
|
* in each of its header files. */
|
|
#if !defined(MBEDTLS_CONFIG_FILE)
|
|
#include "../mbedtls/config.h"
|
|
#else
|
|
#include MBEDTLS_CONFIG_FILE
|
|
#endif
|
|
|
|
#include "mbedtls/cipher.h"
|
|
#include "mbedtls/cmac.h"
|
|
#include "mbedtls/gcm.h"
|
|
#include "mbedtls/md.h"
|
|
#include "mbedtls/md2.h"
|
|
#include "mbedtls/md4.h"
|
|
#include "mbedtls/md5.h"
|
|
#include "mbedtls/ripemd160.h"
|
|
#include "mbedtls/sha1.h"
|
|
#include "mbedtls/sha256.h"
|
|
#include "mbedtls/sha512.h"
|
|
|
|
struct psa_hash_operation_s
|
|
{
|
|
psa_algorithm_t alg;
|
|
union
|
|
{
|
|
unsigned dummy; /* Make the union non-empty even with no supported algorithms. */
|
|
#if defined(MBEDTLS_MD2_C)
|
|
mbedtls_md2_context md2;
|
|
#endif
|
|
#if defined(MBEDTLS_MD4_C)
|
|
mbedtls_md4_context md4;
|
|
#endif
|
|
#if defined(MBEDTLS_MD5_C)
|
|
mbedtls_md5_context md5;
|
|
#endif
|
|
#if defined(MBEDTLS_RIPEMD160_C)
|
|
mbedtls_ripemd160_context ripemd160;
|
|
#endif
|
|
#if defined(MBEDTLS_SHA1_C)
|
|
mbedtls_sha1_context sha1;
|
|
#endif
|
|
#if defined(MBEDTLS_SHA256_C)
|
|
mbedtls_sha256_context sha256;
|
|
#endif
|
|
#if defined(MBEDTLS_SHA512_C)
|
|
mbedtls_sha512_context sha512;
|
|
#endif
|
|
} ctx;
|
|
};
|
|
|
|
#define PSA_HASH_OPERATION_INIT {0, {0}}
|
|
static inline struct psa_hash_operation_s psa_hash_operation_init( void )
|
|
{
|
|
const struct psa_hash_operation_s v = PSA_HASH_OPERATION_INIT;
|
|
return( v );
|
|
}
|
|
|
|
#if defined(MBEDTLS_MD_C)
|
|
typedef struct
|
|
{
|
|
/** The hash context. */
|
|
struct psa_hash_operation_s hash_ctx;
|
|
/** The HMAC part of the context. */
|
|
uint8_t opad[PSA_HMAC_MAX_HASH_BLOCK_SIZE];
|
|
} psa_hmac_internal_data;
|
|
#endif /* MBEDTLS_MD_C */
|
|
|
|
struct psa_mac_operation_s
|
|
{
|
|
psa_algorithm_t alg;
|
|
unsigned int key_set : 1;
|
|
unsigned int iv_required : 1;
|
|
unsigned int iv_set : 1;
|
|
unsigned int has_input : 1;
|
|
unsigned int is_sign : 1;
|
|
uint8_t mac_size;
|
|
union
|
|
{
|
|
unsigned dummy; /* Make the union non-empty even with no supported algorithms. */
|
|
#if defined(MBEDTLS_MD_C)
|
|
psa_hmac_internal_data hmac;
|
|
#endif
|
|
#if defined(MBEDTLS_CMAC_C)
|
|
mbedtls_cipher_context_t cmac;
|
|
#endif
|
|
} ctx;
|
|
};
|
|
|
|
#define PSA_MAC_OPERATION_INIT {0, 0, 0, 0, 0, 0, 0, {0}}
|
|
static inline struct psa_mac_operation_s psa_mac_operation_init( void )
|
|
{
|
|
const struct psa_mac_operation_s v = PSA_MAC_OPERATION_INIT;
|
|
return( v );
|
|
}
|
|
|
|
struct psa_cipher_operation_s
|
|
{
|
|
psa_algorithm_t alg;
|
|
unsigned int key_set : 1;
|
|
unsigned int iv_required : 1;
|
|
unsigned int iv_set : 1;
|
|
uint8_t iv_size;
|
|
uint8_t block_size;
|
|
union
|
|
{
|
|
unsigned dummy; /* Enable easier initializing of the union. */
|
|
mbedtls_cipher_context_t cipher;
|
|
} ctx;
|
|
};
|
|
|
|
#define PSA_CIPHER_OPERATION_INIT {0, 0, 0, 0, 0, 0, {0}}
|
|
static inline struct psa_cipher_operation_s psa_cipher_operation_init( void )
|
|
{
|
|
const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT;
|
|
return( v );
|
|
}
|
|
|
|
struct psa_aead_operation_s
|
|
{
|
|
psa_algorithm_t alg;
|
|
unsigned int key_set : 1;
|
|
unsigned int iv_set : 1;
|
|
uint8_t iv_size;
|
|
uint8_t block_size;
|
|
union
|
|
{
|
|
unsigned dummy; /* Enable easier initializing of the union. */
|
|
mbedtls_cipher_context_t cipher;
|
|
} ctx;
|
|
};
|
|
|
|
#define PSA_AEAD_OPERATION_INIT {0, 0, 0, 0, 0, {0}}
|
|
static inline struct psa_aead_operation_s psa_aead_operation_init( void )
|
|
{
|
|
const struct psa_aead_operation_s v = PSA_AEAD_OPERATION_INIT;
|
|
return( v );
|
|
}
|
|
|
|
#if defined(MBEDTLS_MD_C)
|
|
typedef struct
|
|
{
|
|
uint8_t *info;
|
|
size_t info_length;
|
|
psa_hmac_internal_data hmac;
|
|
uint8_t prk[PSA_HASH_MAX_SIZE];
|
|
uint8_t output_block[PSA_HASH_MAX_SIZE];
|
|
#if PSA_HASH_MAX_SIZE > 0xff
|
|
#error "PSA_HASH_MAX_SIZE does not fit in uint8_t"
|
|
#endif
|
|
uint8_t offset_in_block;
|
|
uint8_t block_number;
|
|
unsigned int state : 2;
|
|
unsigned int info_set : 1;
|
|
} psa_hkdf_generator_t;
|
|
#endif /* MBEDTLS_MD_C */
|
|
|
|
#if defined(MBEDTLS_MD_C)
|
|
typedef struct psa_tls12_prf_generator_s
|
|
{
|
|
/* The TLS 1.2 PRF uses the key for each HMAC iteration,
|
|
* hence we must store it for the lifetime of the generator.
|
|
* This is different from HKDF, where the key is only used
|
|
* in the extraction phase, but not during expansion. */
|
|
unsigned char *key;
|
|
size_t key_len;
|
|
|
|
/* `A(i) + seed` in the notation of RFC 5246, Sect. 5 */
|
|
uint8_t *Ai_with_seed;
|
|
size_t Ai_with_seed_len;
|
|
|
|
/* `HMAC_hash( prk, A(i) + seed )` in the notation of RFC 5246, Sect. 5. */
|
|
uint8_t output_block[PSA_HASH_MAX_SIZE];
|
|
|
|
#if PSA_HASH_MAX_SIZE > 0xff
|
|
#error "PSA_HASH_MAX_SIZE does not fit in uint8_t"
|
|
#endif
|
|
|
|
/* Indicates how many bytes in the current HMAC block have
|
|
* already been read by the user. */
|
|
uint8_t offset_in_block;
|
|
|
|
/* The 1-based number of the block. */
|
|
uint8_t block_number;
|
|
|
|
} psa_tls12_prf_generator_t;
|
|
#endif /* MBEDTLS_MD_C */
|
|
|
|
struct psa_crypto_generator_s
|
|
{
|
|
psa_algorithm_t alg;
|
|
size_t capacity;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
uint8_t *data;
|
|
size_t size;
|
|
} buffer;
|
|
#if defined(MBEDTLS_MD_C)
|
|
psa_hkdf_generator_t hkdf;
|
|
psa_tls12_prf_generator_t tls12_prf;
|
|
#endif
|
|
} ctx;
|
|
};
|
|
|
|
#define PSA_CRYPTO_GENERATOR_INIT {0, 0, {{0, 0}}}
|
|
static inline struct psa_crypto_generator_s psa_crypto_generator_init( void )
|
|
{
|
|
const struct psa_crypto_generator_s v = PSA_CRYPTO_GENERATOR_INIT;
|
|
return( v );
|
|
}
|
|
|
|
struct psa_key_policy_s
|
|
{
|
|
psa_key_usage_t usage;
|
|
psa_algorithm_t alg;
|
|
};
|
|
typedef struct psa_key_policy_s psa_key_policy_t;
|
|
|
|
#define PSA_KEY_POLICY_INIT {0, 0}
|
|
static inline struct psa_key_policy_s psa_key_policy_init( void )
|
|
{
|
|
const struct psa_key_policy_s v = PSA_KEY_POLICY_INIT;
|
|
return( v );
|
|
}
|
|
|
|
struct psa_key_attributes_s
|
|
{
|
|
psa_key_id_t id;
|
|
psa_key_lifetime_t lifetime;
|
|
psa_key_policy_t policy;
|
|
psa_key_type_t type;
|
|
size_t bits;
|
|
void *domain_parameters;
|
|
size_t domain_parameters_size;
|
|
};
|
|
|
|
#define PSA_KEY_ATTRIBUTES_INIT {0, 0, {0, 0}, 0, 0, NULL, 0}
|
|
static inline struct psa_key_attributes_s psa_key_attributes_init( void )
|
|
{
|
|
const struct psa_key_attributes_s v = PSA_KEY_ATTRIBUTES_INIT;
|
|
return( v );
|
|
}
|
|
|
|
static inline void psa_make_key_persistent(psa_key_attributes_t *attributes,
|
|
psa_key_id_t id,
|
|
psa_key_lifetime_t lifetime)
|
|
{
|
|
attributes->id = id;
|
|
attributes->lifetime = lifetime;
|
|
}
|
|
|
|
static inline psa_key_id_t psa_get_key_id(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->id );
|
|
}
|
|
|
|
static inline psa_key_lifetime_t psa_get_key_lifetime(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->lifetime );
|
|
}
|
|
|
|
static inline void psa_set_key_usage_flags(psa_key_attributes_t *attributes,
|
|
psa_key_usage_t usage_flags)
|
|
{
|
|
attributes->policy.usage = usage_flags;
|
|
}
|
|
|
|
static inline psa_key_usage_t psa_get_key_usage_flags(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->policy.usage );
|
|
}
|
|
|
|
static inline void psa_set_key_algorithm(psa_key_attributes_t *attributes,
|
|
psa_algorithm_t alg)
|
|
{
|
|
attributes->policy.alg = alg;
|
|
}
|
|
|
|
static inline psa_algorithm_t psa_get_key_algorithm(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->policy.alg );
|
|
}
|
|
|
|
static inline void psa_set_key_type(psa_key_attributes_t *attributes,
|
|
psa_key_type_t type)
|
|
{
|
|
if( attributes->domain_parameters == NULL )
|
|
{
|
|
/* Common case: quick path */
|
|
attributes->type = type;
|
|
}
|
|
else
|
|
{
|
|
/* Call the bigger function to free the old domain paramteres.
|
|
* Ignore any errors which may arise due to type requiring
|
|
* non-default domain parameters, since this function can't
|
|
* report errors. */
|
|
(void) psa_set_key_domain_parameters( attributes, type, NULL, 0 );
|
|
}
|
|
}
|
|
|
|
static inline psa_key_type_t psa_get_key_type(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->type );
|
|
}
|
|
|
|
static inline void psa_set_key_bits(psa_key_attributes_t *attributes,
|
|
size_t bits)
|
|
{
|
|
attributes->bits = bits;
|
|
}
|
|
|
|
static inline size_t psa_get_key_bits(
|
|
const psa_key_attributes_t *attributes)
|
|
{
|
|
return( attributes->bits );
|
|
}
|
|
|
|
#endif /* PSA_CRYPTO_STRUCT_H */
|