← Back to branch summary

~bibledit/bibledit/client

« back to all changes in this revision

Viewing changes to mbedtls2/pk.c

  • Committer: Teus Benschop
  • Date: 2024-08-17 17:08:44 UTC
  • Revision ID: teusjannette@gmail.com-20240817170844-0qf789ywtms3hyz7
new upstream version

Show diffs side-by-side

added added

removed removed

Lines of Context:
mbedtls2/pk.c
 
1
#pragma clang diagnostic ignored "-Wunknown-warning-option"
 
2
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
3
#pragma clang diagnostic ignored "-Wsign-conversion"
 
4
 
 
5
#pragma GCC diagnostic ignored "-Wconversion"
 
6
 
 
7
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
8
#pragma clang diagnostic ignored "-Wsign-conversion"
 
9
 
 
10
#pragma GCC diagnostic ignored "-Wconversion"
 
11
 
 
12
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
13
#pragma clang diagnostic ignored "-Wsign-conversion"
 
14
/*
 
15
 *  Public Key abstraction layer
 
16
 *
 
17
 *  Copyright The Mbed TLS Contributors
 
18
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
 
19
 *
 
20
 *  This file is provided under the Apache License 2.0, or the
 
21
 *  GNU General Public License v2.0 or later.
 
22
 *
 
23
 *  **********
 
24
 *  Apache License 2.0:
 
25
 *
 
26
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 
27
 *  not use this file except in compliance with the License.
 
28
 *  You may obtain a copy of the License at
 
29
 *
 
30
 *  http://www.apache.org/licenses/LICENSE-2.0
 
31
 *
 
32
 *  Unless required by applicable law or agreed to in writing, software
 
33
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
34
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
35
 *  See the License for the specific language governing permissions and
 
36
 *  limitations under the License.
 
37
 *
 
38
 *  **********
 
39
 *
 
40
 *  **********
 
41
 *  GNU General Public License v2.0 or later:
 
42
 *
 
43
 *  This program is free software; you can redistribute it and/or modify
 
44
 *  it under the terms of the GNU General Public License as published by
 
45
 *  the Free Software Foundation; either version 2 of the License, or
 
46
 *  (at your option) any later version.
 
47
 *
 
48
 *  This program is distributed in the hope that it will be useful,
 
49
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
50
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
51
 *  GNU General Public License for more details.
 
52
 *
 
53
 *  You should have received a copy of the GNU General Public License along
 
54
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 
55
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
56
 *
 
57
 *  **********
 
58
 */
 
59
 
 
60
#if !defined(MBEDTLS_CONFIG_FILE)
 
61
#include "mbedtls/config.h"
 
62
#else
 
63
#include MBEDTLS_CONFIG_FILE
 
64
#endif
 
65
 
 
66
#if defined(MBEDTLS_PK_C)
 
67
#include "mbedtls/pk.h"
 
68
#include "mbedtls/pk_internal.h"
 
69
 
 
70
#include "mbedtls/platform_util.h"
 
71
 
 
72
#if defined(MBEDTLS_RSA_C)
 
73
#include "mbedtls/rsa.h"
 
74
#endif
 
75
#if defined(MBEDTLS_ECP_C)
 
76
#include "mbedtls/ecp.h"
 
77
#endif
 
78
#if defined(MBEDTLS_ECDSA_C)
 
79
#include "mbedtls/ecdsa.h"
 
80
#endif
 
81
 
 
82
#include <limits.h>
 
83
#include <stdint.h>
 
84
 
 
85
/* Parameter validation macros based on platform_util.h */
 
86
#define PK_VALIDATE_RET( cond )    \
 
87
    MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_PK_BAD_INPUT_DATA )
 
88
#define PK_VALIDATE( cond )        \
 
89
    MBEDTLS_INTERNAL_VALIDATE( cond )
 
90
 
 
91
/*
 
92
 * Initialise a mbedtls_pk_context
 
93
 */
 
94
void mbedtls_pk_init( mbedtls_pk_context *ctx )
 
95
{
 
96
    PK_VALIDATE( ctx != NULL );
 
97
 
 
98
    ctx->pk_info = NULL;
 
99
    ctx->pk_ctx = NULL;
 
100
}
 
101
 
 
102
/*
 
103
 * Free (the components of) a mbedtls_pk_context
 
104
 */
 
105
void mbedtls_pk_free( mbedtls_pk_context *ctx )
 
106
{
 
107
    if( ctx == NULL )
 
108
        return;
 
109
 
 
110
    if ( ctx->pk_info != NULL )
 
111
        ctx->pk_info->ctx_free_func( ctx->pk_ctx );
 
112
 
 
113
    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_pk_context ) );
 
114
}
 
115
 
 
116
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
117
/*
 
118
 * Initialize a restart context
 
119
 */
 
120
void mbedtls_pk_restart_init( mbedtls_pk_restart_ctx *ctx )
 
121
{
 
122
    PK_VALIDATE( ctx != NULL );
 
123
    ctx->pk_info = NULL;
 
124
    ctx->rs_ctx = NULL;
 
125
}
 
126
 
 
127
/*
 
128
 * Free the components of a restart context
 
129
 */
 
130
void mbedtls_pk_restart_free( mbedtls_pk_restart_ctx *ctx )
 
131
{
 
132
    if( ctx == NULL || ctx->pk_info == NULL ||
 
133
        ctx->pk_info->rs_free_func == NULL )
 
134
    {
 
135
        return;
 
136
    }
 
137
 
 
138
    ctx->pk_info->rs_free_func( ctx->rs_ctx );
 
139
 
 
140
    ctx->pk_info = NULL;
 
141
    ctx->rs_ctx = NULL;
 
142
}
 
143
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
144
 
 
145
/*
 
146
 * Get pk_info structure from type
 
147
 */
 
148
const mbedtls_pk_info_t * mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type )
 
149
{
 
150
    switch( pk_type ) {
 
151
#if defined(MBEDTLS_RSA_C)
 
152
        case MBEDTLS_PK_RSA:
 
153
            return( &mbedtls_rsa_info );
 
154
#endif
 
155
#if defined(MBEDTLS_ECP_C)
 
156
        case MBEDTLS_PK_ECKEY:
 
157
            return( &mbedtls_eckey_info );
 
158
        case MBEDTLS_PK_ECKEY_DH:
 
159
            return( &mbedtls_eckeydh_info );
 
160
#endif
 
161
#if defined(MBEDTLS_ECDSA_C)
 
162
        case MBEDTLS_PK_ECDSA:
 
163
            return( &mbedtls_ecdsa_info );
 
164
#endif
 
165
        /* MBEDTLS_PK_RSA_ALT omitted on purpose */
 
166
        default:
 
167
            return( NULL );
 
168
    }
 
169
}
 
170
 
 
171
/*
 
172
 * Initialise context
 
173
 */
 
174
int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
 
175
{
 
176
    PK_VALIDATE_RET( ctx != NULL );
 
177
    if( info == NULL || ctx->pk_info != NULL )
 
178
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
179
 
 
180
    if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
 
181
        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
 
182
 
 
183
    ctx->pk_info = info;
 
184
 
 
185
    return( 0 );
 
186
}
 
187
 
 
188
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
 
189
/*
 
190
 * Initialize an RSA-alt context
 
191
 */
 
192
int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *ctx, void * key,
 
193
                         mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
 
194
                         mbedtls_pk_rsa_alt_sign_func sign_func,
 
195
                         mbedtls_pk_rsa_alt_key_len_func key_len_func )
 
196
{
 
197
    mbedtls_rsa_alt_context *rsa_alt;
 
198
    const mbedtls_pk_info_t *info = &mbedtls_rsa_alt_info;
 
199
 
 
200
    PK_VALIDATE_RET( ctx != NULL );
 
201
    if( ctx->pk_info != NULL )
 
202
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
203
 
 
204
    if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
 
205
        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
 
206
 
 
207
    ctx->pk_info = info;
 
208
 
 
209
    rsa_alt = (mbedtls_rsa_alt_context *) ctx->pk_ctx;
 
210
 
 
211
    rsa_alt->key = key;
 
212
    rsa_alt->decrypt_func = decrypt_func;
 
213
    rsa_alt->sign_func = sign_func;
 
214
    rsa_alt->key_len_func = key_len_func;
 
215
 
 
216
    return( 0 );
 
217
}
 
218
#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
 
219
 
 
220
/*
 
221
 * Tell if a PK can do the operations of the given type
 
222
 */
 
223
int mbedtls_pk_can_do( const mbedtls_pk_context *ctx, mbedtls_pk_type_t type )
 
224
{
 
225
    /* A context with null pk_info is not set up yet and can't do anything.
 
226
     * For backward compatibility, also accept NULL instead of a context
 
227
     * pointer. */
 
228
    if( ctx == NULL || ctx->pk_info == NULL )
 
229
        return( 0 );
 
230
 
 
231
    return( ctx->pk_info->can_do( type ) );
 
232
}
 
233
 
 
234
/*
 
235
 * Helper for mbedtls_pk_sign and mbedtls_pk_verify
 
236
 */
 
237
static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
 
238
{
 
239
    const mbedtls_md_info_t *md_info;
 
240
 
 
241
    if( *hash_len != 0 && md_alg == MBEDTLS_MD_NONE )
 
242
        return( 0 );
 
243
 
 
244
    if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
 
245
        return( -1 );
 
246
 
 
247
    if ( *hash_len != 0 && *hash_len < mbedtls_md_get_size( md_info ) )
 
248
        return ( -1 );
 
249
 
 
250
    *hash_len = mbedtls_md_get_size( md_info );
 
251
    return( 0 );
 
252
}
 
253
 
 
254
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
255
/*
 
256
 * Helper to set up a restart context if needed
 
257
 */
 
258
static int pk_restart_setup( mbedtls_pk_restart_ctx *ctx,
 
259
                             const mbedtls_pk_info_t *info )
 
260
{
 
261
    /* Don't do anything if already set up or invalid */
 
262
    if( ctx == NULL || ctx->pk_info != NULL )
 
263
        return( 0 );
 
264
 
 
265
    /* Should never happen when we're called */
 
266
    if( info->rs_alloc_func == NULL || info->rs_free_func == NULL )
 
267
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
268
 
 
269
    if( ( ctx->rs_ctx = info->rs_alloc_func() ) == NULL )
 
270
        return( MBEDTLS_ERR_PK_ALLOC_FAILED );
 
271
 
 
272
    ctx->pk_info = info;
 
273
 
 
274
    return( 0 );
 
275
}
 
276
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
277
 
 
278
/*
 
279
 * Verify a signature (restartable)
 
280
 */
 
281
int mbedtls_pk_verify_restartable( mbedtls_pk_context *ctx,
 
282
               mbedtls_md_type_t md_alg,
 
283
               const unsigned char *hash, size_t hash_len,
 
284
               const unsigned char *sig, size_t sig_len,
 
285
               mbedtls_pk_restart_ctx *rs_ctx )
 
286
{
 
287
    PK_VALIDATE_RET( ctx != NULL );
 
288
    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
 
289
                     hash != NULL );
 
290
    PK_VALIDATE_RET( sig != NULL );
 
291
 
 
292
    if( ctx->pk_info == NULL ||
 
293
        pk_hashlen_helper( md_alg, &hash_len ) != 0 )
 
294
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
295
 
 
296
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
297
    /* optimization: use non-restartable version if restart disabled */
 
298
    if( rs_ctx != NULL &&
 
299
        mbedtls_ecp_restart_is_enabled() &&
 
300
        ctx->pk_info->verify_rs_func != NULL )
 
301
    {
 
302
        int ret;
 
303
 
 
304
        if( ( ret = pk_restart_setup( rs_ctx, ctx->pk_info ) ) != 0 )
 
305
            return( ret );
 
306
 
 
307
        ret = ctx->pk_info->verify_rs_func( ctx->pk_ctx,
 
308
                   md_alg, hash, hash_len, sig, sig_len, rs_ctx->rs_ctx );
 
309
 
 
310
        if( ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
 
311
            mbedtls_pk_restart_free( rs_ctx );
 
312
 
 
313
        return( ret );
 
314
    }
 
315
#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
316
    (void) rs_ctx;
 
317
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
318
 
 
319
    if( ctx->pk_info->verify_func == NULL )
 
320
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
321
 
 
322
    return( ctx->pk_info->verify_func( ctx->pk_ctx, md_alg, hash, hash_len,
 
323
                                       sig, sig_len ) );
 
324
}
 
325
 
 
326
/*
 
327
 * Verify a signature
 
328
 */
 
329
int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
 
330
               const unsigned char *hash, size_t hash_len,
 
331
               const unsigned char *sig, size_t sig_len )
 
332
{
 
333
    return( mbedtls_pk_verify_restartable( ctx, md_alg, hash, hash_len,
 
334
                                           sig, sig_len, NULL ) );
 
335
}
 
336
 
 
337
/*
 
338
 * Verify a signature with options
 
339
 */
 
340
int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
 
341
                   mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
 
342
                   const unsigned char *hash, size_t hash_len,
 
343
                   const unsigned char *sig, size_t sig_len )
 
344
{
 
345
    PK_VALIDATE_RET( ctx != NULL );
 
346
    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
 
347
                     hash != NULL );
 
348
    PK_VALIDATE_RET( sig != NULL );
 
349
 
 
350
    if( ctx->pk_info == NULL )
 
351
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
352
 
 
353
    if( ! mbedtls_pk_can_do( ctx, type ) )
 
354
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
355
 
 
356
    if( type == MBEDTLS_PK_RSASSA_PSS )
 
357
    {
 
358
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21)
 
359
        int ret;
 
360
        const mbedtls_pk_rsassa_pss_options *pss_opts;
 
361
 
 
362
#if SIZE_MAX > UINT_MAX
 
363
        if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
 
364
            return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
365
#endif /* SIZE_MAX > UINT_MAX */
 
366
 
 
367
        if( options == NULL )
 
368
            return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
369
 
 
370
        pss_opts = (const mbedtls_pk_rsassa_pss_options *) options;
 
371
 
 
372
        if( sig_len < mbedtls_pk_get_len( ctx ) )
 
373
            return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
 
374
 
 
375
        ret = mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_pk_rsa( *ctx ),
 
376
                NULL, NULL, MBEDTLS_RSA_PUBLIC,
 
377
                md_alg, (unsigned int) hash_len, hash,
 
378
                pss_opts->mgf1_hash_id,
 
379
                pss_opts->expected_salt_len,
 
380
                sig );
 
381
        if( ret != 0 )
 
382
            return( ret );
 
383
 
 
384
        if( sig_len > mbedtls_pk_get_len( ctx ) )
 
385
            return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
 
386
 
 
387
        return( 0 );
 
388
#else
 
389
        return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
 
390
#endif /* MBEDTLS_RSA_C && MBEDTLS_PKCS1_V21 */
 
391
    }
 
392
 
 
393
    /* General case: no options */
 
394
    if( options != NULL )
 
395
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
396
 
 
397
    return( mbedtls_pk_verify( ctx, md_alg, hash, hash_len, sig, sig_len ) );
 
398
}
 
399
 
 
400
/*
 
401
 * Make a signature (restartable)
 
402
 */
 
403
int mbedtls_pk_sign_restartable( mbedtls_pk_context *ctx,
 
404
             mbedtls_md_type_t md_alg,
 
405
             const unsigned char *hash, size_t hash_len,
 
406
             unsigned char *sig, size_t *sig_len,
 
407
             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
 
408
             mbedtls_pk_restart_ctx *rs_ctx )
 
409
{
 
410
    PK_VALIDATE_RET( ctx != NULL );
 
411
    PK_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE && hash_len == 0 ) ||
 
412
                     hash != NULL );
 
413
    PK_VALIDATE_RET( sig != NULL );
 
414
 
 
415
    if( ctx->pk_info == NULL ||
 
416
        pk_hashlen_helper( md_alg, &hash_len ) != 0 )
 
417
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
418
 
 
419
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
420
    /* optimization: use non-restartable version if restart disabled */
 
421
    if( rs_ctx != NULL &&
 
422
        mbedtls_ecp_restart_is_enabled() &&
 
423
        ctx->pk_info->sign_rs_func != NULL )
 
424
    {
 
425
        int ret;
 
426
 
 
427
        if( ( ret = pk_restart_setup( rs_ctx, ctx->pk_info ) ) != 0 )
 
428
            return( ret );
 
429
 
 
430
        ret = ctx->pk_info->sign_rs_func( ctx->pk_ctx, md_alg,
 
431
                hash, hash_len, sig, sig_len, f_rng, p_rng, rs_ctx->rs_ctx );
 
432
 
 
433
        if( ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
 
434
            mbedtls_pk_restart_free( rs_ctx );
 
435
 
 
436
        return( ret );
 
437
    }
 
438
#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
439
    (void) rs_ctx;
 
440
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
 
441
 
 
442
    if( ctx->pk_info->sign_func == NULL )
 
443
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
444
 
 
445
    return( ctx->pk_info->sign_func( ctx->pk_ctx, md_alg, hash, hash_len,
 
446
                                     sig, sig_len, f_rng, p_rng ) );
 
447
}
 
448
 
 
449
/*
 
450
 * Make a signature
 
451
 */
 
452
int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
 
453
             const unsigned char *hash, size_t hash_len,
 
454
             unsigned char *sig, size_t *sig_len,
 
455
             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
456
{
 
457
    return( mbedtls_pk_sign_restartable( ctx, md_alg, hash, hash_len,
 
458
                                         sig, sig_len, f_rng, p_rng, NULL ) );
 
459
}
 
460
 
 
461
/*
 
462
 * Decrypt message
 
463
 */
 
464
int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
 
465
                const unsigned char *input, size_t ilen,
 
466
                unsigned char *output, size_t *olen, size_t osize,
 
467
                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
468
{
 
469
    PK_VALIDATE_RET( ctx != NULL );
 
470
    PK_VALIDATE_RET( input != NULL || ilen == 0 );
 
471
    PK_VALIDATE_RET( output != NULL || osize == 0 );
 
472
    PK_VALIDATE_RET( olen != NULL );
 
473
 
 
474
    if( ctx->pk_info == NULL )
 
475
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
476
 
 
477
    if( ctx->pk_info->decrypt_func == NULL )
 
478
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
479
 
 
480
    return( ctx->pk_info->decrypt_func( ctx->pk_ctx, input, ilen,
 
481
                output, olen, osize, f_rng, p_rng ) );
 
482
}
 
483
 
 
484
/*
 
485
 * Encrypt message
 
486
 */
 
487
int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
 
488
                const unsigned char *input, size_t ilen,
 
489
                unsigned char *output, size_t *olen, size_t osize,
 
490
                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
491
{
 
492
    PK_VALIDATE_RET( ctx != NULL );
 
493
    PK_VALIDATE_RET( input != NULL || ilen == 0 );
 
494
    PK_VALIDATE_RET( output != NULL || osize == 0 );
 
495
    PK_VALIDATE_RET( olen != NULL );
 
496
 
 
497
    if( ctx->pk_info == NULL )
 
498
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
499
 
 
500
    if( ctx->pk_info->encrypt_func == NULL )
 
501
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
502
 
 
503
    return( ctx->pk_info->encrypt_func( ctx->pk_ctx, input, ilen,
 
504
                output, olen, osize, f_rng, p_rng ) );
 
505
}
 
506
 
 
507
/*
 
508
 * Check public-private key pair
 
509
 */
 
510
int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv )
 
511
{
 
512
    PK_VALIDATE_RET( pub != NULL );
 
513
    PK_VALIDATE_RET( prv != NULL );
 
514
 
 
515
    if( pub->pk_info == NULL ||
 
516
        prv->pk_info == NULL ||
 
517
        prv->pk_info->check_pair_func == NULL )
 
518
    {
 
519
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
520
    }
 
521
 
 
522
    if( prv->pk_info->type == MBEDTLS_PK_RSA_ALT )
 
523
    {
 
524
        if( pub->pk_info->type != MBEDTLS_PK_RSA )
 
525
            return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
526
    }
 
527
    else
 
528
    {
 
529
        if( pub->pk_info != prv->pk_info )
 
530
            return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
531
    }
 
532
 
 
533
    return( prv->pk_info->check_pair_func( pub->pk_ctx, prv->pk_ctx ) );
 
534
}
 
535
 
 
536
/*
 
537
 * Get key size in bits
 
538
 */
 
539
size_t mbedtls_pk_get_bitlen( const mbedtls_pk_context *ctx )
 
540
{
 
541
    /* For backward compatibility, accept NULL or a context that
 
542
     * isn't set up yet, and return a fake value that should be safe. */
 
543
    if( ctx == NULL || ctx->pk_info == NULL )
 
544
        return( 0 );
 
545
 
 
546
    return( ctx->pk_info->get_bitlen( ctx->pk_ctx ) );
 
547
}
 
548
 
 
549
/*
 
550
 * Export debug information
 
551
 */
 
552
int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items )
 
553
{
 
554
    PK_VALIDATE_RET( ctx != NULL );
 
555
    if( ctx->pk_info == NULL )
 
556
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
557
 
 
558
    if( ctx->pk_info->debug_func == NULL )
 
559
        return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
 
560
 
 
561
    ctx->pk_info->debug_func( ctx->pk_ctx, items );
 
562
    return( 0 );
 
563
}
 
564
 
 
565
/*
 
566
 * Access the PK type name
 
567
 */
 
568
const char *mbedtls_pk_get_name( const mbedtls_pk_context *ctx )
 
569
{
 
570
    if( ctx == NULL || ctx->pk_info == NULL )
 
571
        return( "invalid PK" );
 
572
 
 
573
    return( ctx->pk_info->name );
 
574
}
 
575
 
 
576
/*
 
577
 * Access the PK type
 
578
 */
 
579
mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx )
 
580
{
 
581
    if( ctx == NULL || ctx->pk_info == NULL )
 
582
        return( MBEDTLS_PK_NONE );
 
583
 
 
584
    return( ctx->pk_info->type );
 
585
}
 
586
 
 
587
#endif /* MBEDTLS_PK_C */