EL4121 Embedded System / mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

features/mbedtls/src/pk.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /*
be_bryan 0:b74591d5ab33 2 * Public Key abstraction layer
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
be_bryan 0:b74591d5ab33 5 * SPDX-License-Identifier: Apache-2.0
be_bryan 0:b74591d5ab33 6 *
be_bryan 0:b74591d5ab33 7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
be_bryan 0:b74591d5ab33 8 * not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 9 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 10 *
be_bryan 0:b74591d5ab33 11 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 12 *
be_bryan 0:b74591d5ab33 13 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
be_bryan 0:b74591d5ab33 15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 16 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 17 * limitations under the License.
be_bryan 0:b74591d5ab33 18 *
be_bryan 0:b74591d5ab33 19 * This file is part of mbed TLS (https://tls.mbed.org)
be_bryan 0:b74591d5ab33 20 */
be_bryan 0:b74591d5ab33 21
be_bryan 0:b74591d5ab33 22 #if !defined(MBEDTLS_CONFIG_FILE)
be_bryan 0:b74591d5ab33 23 #include "mbedtls/config.h"
be_bryan 0:b74591d5ab33 24 #else
be_bryan 0:b74591d5ab33 25 #include MBEDTLS_CONFIG_FILE
be_bryan 0:b74591d5ab33 26 #endif
be_bryan 0:b74591d5ab33 27
be_bryan 0:b74591d5ab33 28 #if defined(MBEDTLS_PK_C)
be_bryan 0:b74591d5ab33 29 #include "mbedtls/pk.h"
be_bryan 0:b74591d5ab33 30 #include "mbedtls/pk_internal.h"
be_bryan 0:b74591d5ab33 31
be_bryan 0:b74591d5ab33 32 #include "mbedtls/bignum.h"
be_bryan 0:b74591d5ab33 33
be_bryan 0:b74591d5ab33 34 #if defined(MBEDTLS_RSA_C)
be_bryan 0:b74591d5ab33 35 #include "mbedtls/rsa.h"
be_bryan 0:b74591d5ab33 36 #endif
be_bryan 0:b74591d5ab33 37 #if defined(MBEDTLS_ECP_C)
be_bryan 0:b74591d5ab33 38 #include "mbedtls/ecp.h"
be_bryan 0:b74591d5ab33 39 #endif
be_bryan 0:b74591d5ab33 40 #if defined(MBEDTLS_ECDSA_C)
be_bryan 0:b74591d5ab33 41 #include "mbedtls/ecdsa.h"
be_bryan 0:b74591d5ab33 42 #endif
be_bryan 0:b74591d5ab33 43
be_bryan 0:b74591d5ab33 44 #include <limits.h>
be_bryan 0:b74591d5ab33 45
be_bryan 0:b74591d5ab33 46 /* Implementation that should never be optimized out by the compiler */
be_bryan 0:b74591d5ab33 47 static void mbedtls_zeroize( void *v, size_t n ) {
be_bryan 0:b74591d5ab33 48 volatile unsigned char *p = v; while( n-- ) *p++ = 0;
be_bryan 0:b74591d5ab33 49 }
be_bryan 0:b74591d5ab33 50
be_bryan 0:b74591d5ab33 51 /*
be_bryan 0:b74591d5ab33 52 * Initialise a mbedtls_pk_context
be_bryan 0:b74591d5ab33 53 */
be_bryan 0:b74591d5ab33 54 void mbedtls_pk_init( mbedtls_pk_context *ctx )
be_bryan 0:b74591d5ab33 55 {
be_bryan 0:b74591d5ab33 56 if( ctx == NULL )
be_bryan 0:b74591d5ab33 57 return;
be_bryan 0:b74591d5ab33 58
be_bryan 0:b74591d5ab33 59 ctx->pk_info = NULL;
be_bryan 0:b74591d5ab33 60 ctx->pk_ctx = NULL;
be_bryan 0:b74591d5ab33 61 }
be_bryan 0:b74591d5ab33 62
be_bryan 0:b74591d5ab33 63 /*
be_bryan 0:b74591d5ab33 64 * Free (the components of) a mbedtls_pk_context
be_bryan 0:b74591d5ab33 65 */
be_bryan 0:b74591d5ab33 66 void mbedtls_pk_free( mbedtls_pk_context *ctx )
be_bryan 0:b74591d5ab33 67 {
be_bryan 0:b74591d5ab33 68 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 69 return;
be_bryan 0:b74591d5ab33 70
be_bryan 0:b74591d5ab33 71 ctx->pk_info->ctx_free_func( ctx->pk_ctx );
be_bryan 0:b74591d5ab33 72
be_bryan 0:b74591d5ab33 73 mbedtls_zeroize( ctx, sizeof( mbedtls_pk_context ) );
be_bryan 0:b74591d5ab33 74 }
be_bryan 0:b74591d5ab33 75
be_bryan 0:b74591d5ab33 76 /*
be_bryan 0:b74591d5ab33 77 * Get pk_info structure from type
be_bryan 0:b74591d5ab33 78 */
be_bryan 0:b74591d5ab33 79 const mbedtls_pk_info_t * mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type )
be_bryan 0:b74591d5ab33 80 {
be_bryan 0:b74591d5ab33 81 switch( pk_type ) {
be_bryan 0:b74591d5ab33 82 #if defined(MBEDTLS_RSA_C)
be_bryan 0:b74591d5ab33 83 case MBEDTLS_PK_RSA:
be_bryan 0:b74591d5ab33 84 return( &mbedtls_rsa_info );
be_bryan 0:b74591d5ab33 85 #endif
be_bryan 0:b74591d5ab33 86 #if defined(MBEDTLS_ECP_C)
be_bryan 0:b74591d5ab33 87 case MBEDTLS_PK_ECKEY:
be_bryan 0:b74591d5ab33 88 return( &mbedtls_eckey_info );
be_bryan 0:b74591d5ab33 89 case MBEDTLS_PK_ECKEY_DH:
be_bryan 0:b74591d5ab33 90 return( &mbedtls_eckeydh_info );
be_bryan 0:b74591d5ab33 91 #endif
be_bryan 0:b74591d5ab33 92 #if defined(MBEDTLS_ECDSA_C)
be_bryan 0:b74591d5ab33 93 case MBEDTLS_PK_ECDSA:
be_bryan 0:b74591d5ab33 94 return( &mbedtls_ecdsa_info );
be_bryan 0:b74591d5ab33 95 #endif
be_bryan 0:b74591d5ab33 96 /* MBEDTLS_PK_RSA_ALT omitted on purpose */
be_bryan 0:b74591d5ab33 97 default:
be_bryan 0:b74591d5ab33 98 return( NULL );
be_bryan 0:b74591d5ab33 99 }
be_bryan 0:b74591d5ab33 100 }
be_bryan 0:b74591d5ab33 101
be_bryan 0:b74591d5ab33 102 /*
be_bryan 0:b74591d5ab33 103 * Initialise context
be_bryan 0:b74591d5ab33 104 */
be_bryan 0:b74591d5ab33 105 int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
be_bryan 0:b74591d5ab33 106 {
be_bryan 0:b74591d5ab33 107 if( ctx == NULL || info == NULL || ctx->pk_info != NULL )
be_bryan 0:b74591d5ab33 108 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 109
be_bryan 0:b74591d5ab33 110 if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
be_bryan 0:b74591d5ab33 111 return( MBEDTLS_ERR_PK_ALLOC_FAILED );
be_bryan 0:b74591d5ab33 112
be_bryan 0:b74591d5ab33 113 ctx->pk_info = info;
be_bryan 0:b74591d5ab33 114
be_bryan 0:b74591d5ab33 115 return( 0 );
be_bryan 0:b74591d5ab33 116 }
be_bryan 0:b74591d5ab33 117
be_bryan 0:b74591d5ab33 118 #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
be_bryan 0:b74591d5ab33 119 /*
be_bryan 0:b74591d5ab33 120 * Initialize an RSA-alt context
be_bryan 0:b74591d5ab33 121 */
be_bryan 0:b74591d5ab33 122 int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *ctx, void * key,
be_bryan 0:b74591d5ab33 123 mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
be_bryan 0:b74591d5ab33 124 mbedtls_pk_rsa_alt_sign_func sign_func,
be_bryan 0:b74591d5ab33 125 mbedtls_pk_rsa_alt_key_len_func key_len_func )
be_bryan 0:b74591d5ab33 126 {
be_bryan 0:b74591d5ab33 127 mbedtls_rsa_alt_context *rsa_alt;
be_bryan 0:b74591d5ab33 128 const mbedtls_pk_info_t *info = &mbedtls_rsa_alt_info;
be_bryan 0:b74591d5ab33 129
be_bryan 0:b74591d5ab33 130 if( ctx == NULL || ctx->pk_info != NULL )
be_bryan 0:b74591d5ab33 131 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 132
be_bryan 0:b74591d5ab33 133 if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
be_bryan 0:b74591d5ab33 134 return( MBEDTLS_ERR_PK_ALLOC_FAILED );
be_bryan 0:b74591d5ab33 135
be_bryan 0:b74591d5ab33 136 ctx->pk_info = info;
be_bryan 0:b74591d5ab33 137
be_bryan 0:b74591d5ab33 138 rsa_alt = (mbedtls_rsa_alt_context *) ctx->pk_ctx;
be_bryan 0:b74591d5ab33 139
be_bryan 0:b74591d5ab33 140 rsa_alt->key = key;
be_bryan 0:b74591d5ab33 141 rsa_alt->decrypt_func = decrypt_func;
be_bryan 0:b74591d5ab33 142 rsa_alt->sign_func = sign_func;
be_bryan 0:b74591d5ab33 143 rsa_alt->key_len_func = key_len_func;
be_bryan 0:b74591d5ab33 144
be_bryan 0:b74591d5ab33 145 return( 0 );
be_bryan 0:b74591d5ab33 146 }
be_bryan 0:b74591d5ab33 147 #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
be_bryan 0:b74591d5ab33 148
be_bryan 0:b74591d5ab33 149 /*
be_bryan 0:b74591d5ab33 150 * Tell if a PK can do the operations of the given type
be_bryan 0:b74591d5ab33 151 */
be_bryan 0:b74591d5ab33 152 int mbedtls_pk_can_do( const mbedtls_pk_context *ctx, mbedtls_pk_type_t type )
be_bryan 0:b74591d5ab33 153 {
be_bryan 0:b74591d5ab33 154 /* null or NONE context can't do anything */
be_bryan 0:b74591d5ab33 155 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 156 return( 0 );
be_bryan 0:b74591d5ab33 157
be_bryan 0:b74591d5ab33 158 return( ctx->pk_info->can_do( type ) );
be_bryan 0:b74591d5ab33 159 }
be_bryan 0:b74591d5ab33 160
be_bryan 0:b74591d5ab33 161 /*
be_bryan 0:b74591d5ab33 162 * Helper for mbedtls_pk_sign and mbedtls_pk_verify
be_bryan 0:b74591d5ab33 163 */
be_bryan 0:b74591d5ab33 164 static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
be_bryan 0:b74591d5ab33 165 {
be_bryan 0:b74591d5ab33 166 const mbedtls_md_info_t *md_info;
be_bryan 0:b74591d5ab33 167
be_bryan 0:b74591d5ab33 168 if( *hash_len != 0 )
be_bryan 0:b74591d5ab33 169 return( 0 );
be_bryan 0:b74591d5ab33 170
be_bryan 0:b74591d5ab33 171 if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
be_bryan 0:b74591d5ab33 172 return( -1 );
be_bryan 0:b74591d5ab33 173
be_bryan 0:b74591d5ab33 174 *hash_len = mbedtls_md_get_size( md_info );
be_bryan 0:b74591d5ab33 175 return( 0 );
be_bryan 0:b74591d5ab33 176 }
be_bryan 0:b74591d5ab33 177
be_bryan 0:b74591d5ab33 178 /*
be_bryan 0:b74591d5ab33 179 * Verify a signature
be_bryan 0:b74591d5ab33 180 */
be_bryan 0:b74591d5ab33 181 int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
be_bryan 0:b74591d5ab33 182 const unsigned char *hash, size_t hash_len,
be_bryan 0:b74591d5ab33 183 const unsigned char *sig, size_t sig_len )
be_bryan 0:b74591d5ab33 184 {
be_bryan 0:b74591d5ab33 185 if( ctx == NULL || ctx->pk_info == NULL ||
be_bryan 0:b74591d5ab33 186 pk_hashlen_helper( md_alg, &hash_len ) != 0 )
be_bryan 0:b74591d5ab33 187 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 188
be_bryan 0:b74591d5ab33 189 if( ctx->pk_info->verify_func == NULL )
be_bryan 0:b74591d5ab33 190 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 191
be_bryan 0:b74591d5ab33 192 return( ctx->pk_info->verify_func( ctx->pk_ctx, md_alg, hash, hash_len,
be_bryan 0:b74591d5ab33 193 sig, sig_len ) );
be_bryan 0:b74591d5ab33 194 }
be_bryan 0:b74591d5ab33 195
be_bryan 0:b74591d5ab33 196 /*
be_bryan 0:b74591d5ab33 197 * Verify a signature with options
be_bryan 0:b74591d5ab33 198 */
be_bryan 0:b74591d5ab33 199 int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
be_bryan 0:b74591d5ab33 200 mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
be_bryan 0:b74591d5ab33 201 const unsigned char *hash, size_t hash_len,
be_bryan 0:b74591d5ab33 202 const unsigned char *sig, size_t sig_len )
be_bryan 0:b74591d5ab33 203 {
be_bryan 0:b74591d5ab33 204 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 205 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 206
be_bryan 0:b74591d5ab33 207 if( ! mbedtls_pk_can_do( ctx, type ) )
be_bryan 0:b74591d5ab33 208 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 209
be_bryan 0:b74591d5ab33 210 if( type == MBEDTLS_PK_RSASSA_PSS )
be_bryan 0:b74591d5ab33 211 {
be_bryan 0:b74591d5ab33 212 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21)
be_bryan 0:b74591d5ab33 213 int ret;
be_bryan 0:b74591d5ab33 214 const mbedtls_pk_rsassa_pss_options *pss_opts;
be_bryan 0:b74591d5ab33 215
be_bryan 0:b74591d5ab33 216 #if defined(MBEDTLS_HAVE_INT64)
be_bryan 0:b74591d5ab33 217 if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
be_bryan 0:b74591d5ab33 218 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 219 #endif /* MBEDTLS_HAVE_INT64 */
be_bryan 0:b74591d5ab33 220
be_bryan 0:b74591d5ab33 221 if( options == NULL )
be_bryan 0:b74591d5ab33 222 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 223
be_bryan 0:b74591d5ab33 224 pss_opts = (const mbedtls_pk_rsassa_pss_options *) options;
be_bryan 0:b74591d5ab33 225
be_bryan 0:b74591d5ab33 226 if( sig_len < mbedtls_pk_get_len( ctx ) )
be_bryan 0:b74591d5ab33 227 return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
be_bryan 0:b74591d5ab33 228
be_bryan 0:b74591d5ab33 229 ret = mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_pk_rsa( *ctx ),
be_bryan 0:b74591d5ab33 230 NULL, NULL, MBEDTLS_RSA_PUBLIC,
be_bryan 0:b74591d5ab33 231 md_alg, (unsigned int) hash_len, hash,
be_bryan 0:b74591d5ab33 232 pss_opts->mgf1_hash_id,
be_bryan 0:b74591d5ab33 233 pss_opts->expected_salt_len,
be_bryan 0:b74591d5ab33 234 sig );
be_bryan 0:b74591d5ab33 235 if( ret != 0 )
be_bryan 0:b74591d5ab33 236 return( ret );
be_bryan 0:b74591d5ab33 237
be_bryan 0:b74591d5ab33 238 if( sig_len > mbedtls_pk_get_len( ctx ) )
be_bryan 0:b74591d5ab33 239 return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
be_bryan 0:b74591d5ab33 240
be_bryan 0:b74591d5ab33 241 return( 0 );
be_bryan 0:b74591d5ab33 242 #else
be_bryan 0:b74591d5ab33 243 return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
be_bryan 0:b74591d5ab33 244 #endif /* MBEDTLS_RSA_C && MBEDTLS_PKCS1_V21 */
be_bryan 0:b74591d5ab33 245 }
be_bryan 0:b74591d5ab33 246
be_bryan 0:b74591d5ab33 247 /* General case: no options */
be_bryan 0:b74591d5ab33 248 if( options != NULL )
be_bryan 0:b74591d5ab33 249 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 250
be_bryan 0:b74591d5ab33 251 return( mbedtls_pk_verify( ctx, md_alg, hash, hash_len, sig, sig_len ) );
be_bryan 0:b74591d5ab33 252 }
be_bryan 0:b74591d5ab33 253
be_bryan 0:b74591d5ab33 254 /*
be_bryan 0:b74591d5ab33 255 * Make a signature
be_bryan 0:b74591d5ab33 256 */
be_bryan 0:b74591d5ab33 257 int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
be_bryan 0:b74591d5ab33 258 const unsigned char *hash, size_t hash_len,
be_bryan 0:b74591d5ab33 259 unsigned char *sig, size_t *sig_len,
be_bryan 0:b74591d5ab33 260 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
be_bryan 0:b74591d5ab33 261 {
be_bryan 0:b74591d5ab33 262 if( ctx == NULL || ctx->pk_info == NULL ||
be_bryan 0:b74591d5ab33 263 pk_hashlen_helper( md_alg, &hash_len ) != 0 )
be_bryan 0:b74591d5ab33 264 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 265
be_bryan 0:b74591d5ab33 266 if( ctx->pk_info->sign_func == NULL )
be_bryan 0:b74591d5ab33 267 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 268
be_bryan 0:b74591d5ab33 269 return( ctx->pk_info->sign_func( ctx->pk_ctx, md_alg, hash, hash_len,
be_bryan 0:b74591d5ab33 270 sig, sig_len, f_rng, p_rng ) );
be_bryan 0:b74591d5ab33 271 }
be_bryan 0:b74591d5ab33 272
be_bryan 0:b74591d5ab33 273 /*
be_bryan 0:b74591d5ab33 274 * Decrypt message
be_bryan 0:b74591d5ab33 275 */
be_bryan 0:b74591d5ab33 276 int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
be_bryan 0:b74591d5ab33 277 const unsigned char *input, size_t ilen,
be_bryan 0:b74591d5ab33 278 unsigned char *output, size_t *olen, size_t osize,
be_bryan 0:b74591d5ab33 279 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
be_bryan 0:b74591d5ab33 280 {
be_bryan 0:b74591d5ab33 281 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 282 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 283
be_bryan 0:b74591d5ab33 284 if( ctx->pk_info->decrypt_func == NULL )
be_bryan 0:b74591d5ab33 285 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 286
be_bryan 0:b74591d5ab33 287 return( ctx->pk_info->decrypt_func( ctx->pk_ctx, input, ilen,
be_bryan 0:b74591d5ab33 288 output, olen, osize, f_rng, p_rng ) );
be_bryan 0:b74591d5ab33 289 }
be_bryan 0:b74591d5ab33 290
be_bryan 0:b74591d5ab33 291 /*
be_bryan 0:b74591d5ab33 292 * Encrypt message
be_bryan 0:b74591d5ab33 293 */
be_bryan 0:b74591d5ab33 294 int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
be_bryan 0:b74591d5ab33 295 const unsigned char *input, size_t ilen,
be_bryan 0:b74591d5ab33 296 unsigned char *output, size_t *olen, size_t osize,
be_bryan 0:b74591d5ab33 297 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
be_bryan 0:b74591d5ab33 298 {
be_bryan 0:b74591d5ab33 299 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 300 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 301
be_bryan 0:b74591d5ab33 302 if( ctx->pk_info->encrypt_func == NULL )
be_bryan 0:b74591d5ab33 303 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 304
be_bryan 0:b74591d5ab33 305 return( ctx->pk_info->encrypt_func( ctx->pk_ctx, input, ilen,
be_bryan 0:b74591d5ab33 306 output, olen, osize, f_rng, p_rng ) );
be_bryan 0:b74591d5ab33 307 }
be_bryan 0:b74591d5ab33 308
be_bryan 0:b74591d5ab33 309 /*
be_bryan 0:b74591d5ab33 310 * Check public-private key pair
be_bryan 0:b74591d5ab33 311 */
be_bryan 0:b74591d5ab33 312 int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv )
be_bryan 0:b74591d5ab33 313 {
be_bryan 0:b74591d5ab33 314 if( pub == NULL || pub->pk_info == NULL ||
be_bryan 0:b74591d5ab33 315 prv == NULL || prv->pk_info == NULL ||
be_bryan 0:b74591d5ab33 316 prv->pk_info->check_pair_func == NULL )
be_bryan 0:b74591d5ab33 317 {
be_bryan 0:b74591d5ab33 318 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 319 }
be_bryan 0:b74591d5ab33 320
be_bryan 0:b74591d5ab33 321 if( prv->pk_info->type == MBEDTLS_PK_RSA_ALT )
be_bryan 0:b74591d5ab33 322 {
be_bryan 0:b74591d5ab33 323 if( pub->pk_info->type != MBEDTLS_PK_RSA )
be_bryan 0:b74591d5ab33 324 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 325 }
be_bryan 0:b74591d5ab33 326 else
be_bryan 0:b74591d5ab33 327 {
be_bryan 0:b74591d5ab33 328 if( pub->pk_info != prv->pk_info )
be_bryan 0:b74591d5ab33 329 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 330 }
be_bryan 0:b74591d5ab33 331
be_bryan 0:b74591d5ab33 332 return( prv->pk_info->check_pair_func( pub->pk_ctx, prv->pk_ctx ) );
be_bryan 0:b74591d5ab33 333 }
be_bryan 0:b74591d5ab33 334
be_bryan 0:b74591d5ab33 335 /*
be_bryan 0:b74591d5ab33 336 * Get key size in bits
be_bryan 0:b74591d5ab33 337 */
be_bryan 0:b74591d5ab33 338 size_t mbedtls_pk_get_bitlen( const mbedtls_pk_context *ctx )
be_bryan 0:b74591d5ab33 339 {
be_bryan 0:b74591d5ab33 340 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 341 return( 0 );
be_bryan 0:b74591d5ab33 342
be_bryan 0:b74591d5ab33 343 return( ctx->pk_info->get_bitlen( ctx->pk_ctx ) );
be_bryan 0:b74591d5ab33 344 }
be_bryan 0:b74591d5ab33 345
be_bryan 0:b74591d5ab33 346 /*
be_bryan 0:b74591d5ab33 347 * Export debug information
be_bryan 0:b74591d5ab33 348 */
be_bryan 0:b74591d5ab33 349 int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items )
be_bryan 0:b74591d5ab33 350 {
be_bryan 0:b74591d5ab33 351 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 352 return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
be_bryan 0:b74591d5ab33 353
be_bryan 0:b74591d5ab33 354 if( ctx->pk_info->debug_func == NULL )
be_bryan 0:b74591d5ab33 355 return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
be_bryan 0:b74591d5ab33 356
be_bryan 0:b74591d5ab33 357 ctx->pk_info->debug_func( ctx->pk_ctx, items );
be_bryan 0:b74591d5ab33 358 return( 0 );
be_bryan 0:b74591d5ab33 359 }
be_bryan 0:b74591d5ab33 360
be_bryan 0:b74591d5ab33 361 /*
be_bryan 0:b74591d5ab33 362 * Access the PK type name
be_bryan 0:b74591d5ab33 363 */
be_bryan 0:b74591d5ab33 364 const char *mbedtls_pk_get_name( const mbedtls_pk_context *ctx )
be_bryan 0:b74591d5ab33 365 {
be_bryan 0:b74591d5ab33 366 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 367 return( "invalid PK" );
be_bryan 0:b74591d5ab33 368
be_bryan 0:b74591d5ab33 369 return( ctx->pk_info->name );
be_bryan 0:b74591d5ab33 370 }
be_bryan 0:b74591d5ab33 371
be_bryan 0:b74591d5ab33 372 /*
be_bryan 0:b74591d5ab33 373 * Access the PK type
be_bryan 0:b74591d5ab33 374 */
be_bryan 0:b74591d5ab33 375 mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx )
be_bryan 0:b74591d5ab33 376 {
be_bryan 0:b74591d5ab33 377 if( ctx == NULL || ctx->pk_info == NULL )
be_bryan 0:b74591d5ab33 378 return( MBEDTLS_PK_NONE );
be_bryan 0:b74591d5ab33 379
be_bryan 0:b74591d5ab33 380 return( ctx->pk_info->type );
be_bryan 0:b74591d5ab33 381 }
be_bryan 0:b74591d5ab33 382
be_bryan 0:b74591d5ab33 383 #endif /* MBEDTLS_PK_C */