← Back to branch summary

~bibledit/bibledit/client

« back to all changes in this revision

Viewing changes to mbedtls2/pk_wrap.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_wrap.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: wrapper functions
 
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_internal.h"
 
68
 
 
69
/* Even if RSA not activated, for the sake of RSA-alt */
 
70
#include "mbedtls/rsa.h"
 
71
 
 
72
#include <string.h>
 
73
 
 
74
#if defined(MBEDTLS_ECP_C)
 
75
#include "mbedtls/ecp.h"
 
76
#endif
 
77
 
 
78
#if defined(MBEDTLS_ECDSA_C)
 
79
#include "mbedtls/ecdsa.h"
 
80
#endif
 
81
 
 
82
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
 
83
#include "mbedtls/platform_util.h"
 
84
#endif
 
85
 
 
86
#if defined(MBEDTLS_PLATFORM_C)
 
87
#include "mbedtls/platform.h"
 
88
#else
 
89
#include <stdlib.h>
 
90
#define mbedtls_calloc    calloc
 
91
#define mbedtls_free       free
 
92
#endif
 
93
 
 
94
#include <limits.h>
 
95
#include <stdint.h>
 
96
 
 
97
#if defined(MBEDTLS_RSA_C)
 
98
static int rsa_can_do( mbedtls_pk_type_t type )
 
99
{
 
100
    return( type == MBEDTLS_PK_RSA ||
 
101
            type == MBEDTLS_PK_RSASSA_PSS );
 
102
}
 
103
 
 
104
static size_t rsa_get_bitlen( const void *ctx )
 
105
{
 
106
    const mbedtls_rsa_context * rsa = (const mbedtls_rsa_context *) ctx;
 
107
    return( 8 * mbedtls_rsa_get_len( rsa ) );
 
108
}
 
109
 
 
110
static int rsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
111
                   const unsigned char *hash, size_t hash_len,
 
112
                   const unsigned char *sig, size_t sig_len )
 
113
{
 
114
    int ret;
 
115
    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
 
116
    size_t rsa_len = mbedtls_rsa_get_len( rsa );
 
117
 
 
118
#if SIZE_MAX > UINT_MAX
 
119
    if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
 
120
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
121
#endif /* SIZE_MAX > UINT_MAX */
 
122
 
 
123
    if( sig_len < rsa_len )
 
124
        return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
 
125
 
 
126
    if( ( ret = mbedtls_rsa_pkcs1_verify( rsa, NULL, NULL,
 
127
                                  MBEDTLS_RSA_PUBLIC, md_alg,
 
128
                                  (unsigned int) hash_len, hash, sig ) ) != 0 )
 
129
        return( ret );
 
130
 
 
131
    /* The buffer contains a valid signature followed by extra data.
 
132
     * We have a special error code for that so that so that callers can
 
133
     * use mbedtls_pk_verify() to check "Does the buffer start with a
 
134
     * valid signature?" and not just "Does the buffer contain a valid
 
135
     * signature?". */
 
136
    if( sig_len > rsa_len )
 
137
        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
 
138
 
 
139
    return( 0 );
 
140
}
 
141
 
 
142
static int rsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
143
                   const unsigned char *hash, size_t hash_len,
 
144
                   unsigned char *sig, size_t *sig_len,
 
145
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
146
{
 
147
    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
 
148
 
 
149
#if SIZE_MAX > UINT_MAX
 
150
    if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
 
151
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
152
#endif /* SIZE_MAX > UINT_MAX */
 
153
 
 
154
    *sig_len = mbedtls_rsa_get_len( rsa );
 
155
 
 
156
    return( mbedtls_rsa_pkcs1_sign( rsa, f_rng, p_rng, MBEDTLS_RSA_PRIVATE,
 
157
                md_alg, (unsigned int) hash_len, hash, sig ) );
 
158
}
 
159
 
 
160
static int rsa_decrypt_wrap( void *ctx,
 
161
                    const unsigned char *input, size_t ilen,
 
162
                    unsigned char *output, size_t *olen, size_t osize,
 
163
                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
164
{
 
165
    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
 
166
 
 
167
    if( ilen != mbedtls_rsa_get_len( rsa ) )
 
168
        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
 
169
 
 
170
    return( mbedtls_rsa_pkcs1_decrypt( rsa, f_rng, p_rng,
 
171
                MBEDTLS_RSA_PRIVATE, olen, input, output, osize ) );
 
172
}
 
173
 
 
174
static int rsa_encrypt_wrap( void *ctx,
 
175
                    const unsigned char *input, size_t ilen,
 
176
                    unsigned char *output, size_t *olen, size_t osize,
 
177
                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
178
{
 
179
    mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ctx;
 
180
    *olen = mbedtls_rsa_get_len( rsa );
 
181
 
 
182
    if( *olen > osize )
 
183
        return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
 
184
 
 
185
    return( mbedtls_rsa_pkcs1_encrypt( rsa, f_rng, p_rng, MBEDTLS_RSA_PUBLIC,
 
186
                                       ilen, input, output ) );
 
187
}
 
188
 
 
189
static int rsa_check_pair_wrap( const void *pub, const void *prv )
 
190
{
 
191
    return( mbedtls_rsa_check_pub_priv( (const mbedtls_rsa_context *) pub,
 
192
                                (const mbedtls_rsa_context *) prv ) );
 
193
}
 
194
 
 
195
static void *rsa_alloc_wrap( void )
 
196
{
 
197
    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_rsa_context ) );
 
198
 
 
199
    if( ctx != NULL )
 
200
        mbedtls_rsa_init( (mbedtls_rsa_context *) ctx, 0, 0 );
 
201
 
 
202
    return( ctx );
 
203
}
 
204
 
 
205
static void rsa_free_wrap( void *ctx )
 
206
{
 
207
    mbedtls_rsa_free( (mbedtls_rsa_context *) ctx );
 
208
    mbedtls_free( ctx );
 
209
}
 
210
 
 
211
static void rsa_debug( const void *ctx, mbedtls_pk_debug_item *items )
 
212
{
 
213
    items->type = MBEDTLS_PK_DEBUG_MPI;
 
214
    items->name = "rsa.N";
 
215
    items->value = &( ((mbedtls_rsa_context *) ctx)->N );
 
216
 
 
217
    items++;
 
218
 
 
219
    items->type = MBEDTLS_PK_DEBUG_MPI;
 
220
    items->name = "rsa.E";
 
221
    items->value = &( ((mbedtls_rsa_context *) ctx)->E );
 
222
}
 
223
 
 
224
const mbedtls_pk_info_t mbedtls_rsa_info = {
 
225
    MBEDTLS_PK_RSA,
 
226
    "RSA",
 
227
    rsa_get_bitlen,
 
228
    rsa_can_do,
 
229
    rsa_verify_wrap,
 
230
    rsa_sign_wrap,
 
231
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
232
    NULL,
 
233
    NULL,
 
234
#endif
 
235
    rsa_decrypt_wrap,
 
236
    rsa_encrypt_wrap,
 
237
    rsa_check_pair_wrap,
 
238
    rsa_alloc_wrap,
 
239
    rsa_free_wrap,
 
240
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
241
    NULL,
 
242
    NULL,
 
243
#endif
 
244
    rsa_debug,
 
245
};
 
246
#endif /* MBEDTLS_RSA_C */
 
247
 
 
248
#if defined(MBEDTLS_ECP_C)
 
249
/*
 
250
 * Generic EC key
 
251
 */
 
252
static int eckey_can_do( mbedtls_pk_type_t type )
 
253
{
 
254
    return( type == MBEDTLS_PK_ECKEY ||
 
255
            type == MBEDTLS_PK_ECKEY_DH ||
 
256
            type == MBEDTLS_PK_ECDSA );
 
257
}
 
258
 
 
259
static size_t eckey_get_bitlen( const void *ctx )
 
260
{
 
261
    return( ((mbedtls_ecp_keypair *) ctx)->grp.pbits );
 
262
}
 
263
 
 
264
#if defined(MBEDTLS_ECDSA_C)
 
265
/* Forward declarations */
 
266
static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
267
                       const unsigned char *hash, size_t hash_len,
 
268
                       const unsigned char *sig, size_t sig_len );
 
269
 
 
270
static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
271
                   const unsigned char *hash, size_t hash_len,
 
272
                   unsigned char *sig, size_t *sig_len,
 
273
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
 
274
 
 
275
static int eckey_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
276
                       const unsigned char *hash, size_t hash_len,
 
277
                       const unsigned char *sig, size_t sig_len )
 
278
{
 
279
    int ret;
 
280
    mbedtls_ecdsa_context ecdsa;
 
281
 
 
282
    mbedtls_ecdsa_init( &ecdsa );
 
283
 
 
284
    if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
 
285
        ret = ecdsa_verify_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len );
 
286
 
 
287
    mbedtls_ecdsa_free( &ecdsa );
 
288
 
 
289
    return( ret );
 
290
}
 
291
 
 
292
static int eckey_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
293
                   const unsigned char *hash, size_t hash_len,
 
294
                   unsigned char *sig, size_t *sig_len,
 
295
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
296
{
 
297
    int ret;
 
298
    mbedtls_ecdsa_context ecdsa;
 
299
 
 
300
    mbedtls_ecdsa_init( &ecdsa );
 
301
 
 
302
    if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
 
303
        ret = ecdsa_sign_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len,
 
304
                               f_rng, p_rng );
 
305
 
 
306
    mbedtls_ecdsa_free( &ecdsa );
 
307
 
 
308
    return( ret );
 
309
}
 
310
 
 
311
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
312
/* Forward declarations */
 
313
static int ecdsa_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
314
                       const unsigned char *hash, size_t hash_len,
 
315
                       const unsigned char *sig, size_t sig_len,
 
316
                       void *rs_ctx );
 
317
 
 
318
static int ecdsa_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
319
                   const unsigned char *hash, size_t hash_len,
 
320
                   unsigned char *sig, size_t *sig_len,
 
321
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
 
322
                   void *rs_ctx );
 
323
 
 
324
/*
 
325
 * Restart context for ECDSA operations with ECKEY context
 
326
 *
 
327
 * We need to store an actual ECDSA context, as we need to pass the same to
 
328
 * the underlying ecdsa function, so we can't create it on the fly every time.
 
329
 */
 
330
typedef struct
 
331
{
 
332
    mbedtls_ecdsa_restart_ctx ecdsa_rs;
 
333
    mbedtls_ecdsa_context ecdsa_ctx;
 
334
} eckey_restart_ctx;
 
335
 
 
336
static void *eckey_rs_alloc( void )
 
337
{
 
338
    eckey_restart_ctx *rs_ctx;
 
339
 
 
340
    void *ctx = mbedtls_calloc( 1, sizeof( eckey_restart_ctx ) );
 
341
 
 
342
    if( ctx != NULL )
 
343
    {
 
344
        rs_ctx = ctx;
 
345
        mbedtls_ecdsa_restart_init( &rs_ctx->ecdsa_rs );
 
346
        mbedtls_ecdsa_init( &rs_ctx->ecdsa_ctx );
 
347
    }
 
348
 
 
349
    return( ctx );
 
350
}
 
351
 
 
352
static void eckey_rs_free( void *ctx )
 
353
{
 
354
    eckey_restart_ctx *rs_ctx;
 
355
 
 
356
    if( ctx == NULL)
 
357
        return;
 
358
 
 
359
    rs_ctx = ctx;
 
360
    mbedtls_ecdsa_restart_free( &rs_ctx->ecdsa_rs );
 
361
    mbedtls_ecdsa_free( &rs_ctx->ecdsa_ctx );
 
362
 
 
363
    mbedtls_free( ctx );
 
364
}
 
365
 
 
366
static int eckey_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
367
                       const unsigned char *hash, size_t hash_len,
 
368
                       const unsigned char *sig, size_t sig_len,
 
369
                       void *rs_ctx )
 
370
{
 
371
    int ret;
 
372
    eckey_restart_ctx *rs = rs_ctx;
 
373
 
 
374
    /* Should never happen */
 
375
    if( rs == NULL )
 
376
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
377
 
 
378
    /* set up our own sub-context if needed (that is, on first run) */
 
379
    if( rs->ecdsa_ctx.grp.pbits == 0 )
 
380
        MBEDTLS_MPI_CHK( mbedtls_ecdsa_from_keypair( &rs->ecdsa_ctx, ctx ) );
 
381
 
 
382
    MBEDTLS_MPI_CHK( ecdsa_verify_rs_wrap( &rs->ecdsa_ctx,
 
383
                                           md_alg, hash, hash_len,
 
384
                                           sig, sig_len, &rs->ecdsa_rs ) );
 
385
 
 
386
cleanup:
 
387
    return( ret );
 
388
}
 
389
 
 
390
static int eckey_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
391
                   const unsigned char *hash, size_t hash_len,
 
392
                   unsigned char *sig, size_t *sig_len,
 
393
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
 
394
                       void *rs_ctx )
 
395
{
 
396
    int ret;
 
397
    eckey_restart_ctx *rs = rs_ctx;
 
398
 
 
399
    /* Should never happen */
 
400
    if( rs == NULL )
 
401
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
402
 
 
403
    /* set up our own sub-context if needed (that is, on first run) */
 
404
    if( rs->ecdsa_ctx.grp.pbits == 0 )
 
405
        MBEDTLS_MPI_CHK( mbedtls_ecdsa_from_keypair( &rs->ecdsa_ctx, ctx ) );
 
406
 
 
407
    MBEDTLS_MPI_CHK( ecdsa_sign_rs_wrap( &rs->ecdsa_ctx, md_alg,
 
408
                                         hash, hash_len, sig, sig_len,
 
409
                                         f_rng, p_rng, &rs->ecdsa_rs ) );
 
410
 
 
411
cleanup:
 
412
    return( ret );
 
413
}
 
414
#endif /* MBEDTLS_ECP_RESTARTABLE */
 
415
#endif /* MBEDTLS_ECDSA_C */
 
416
 
 
417
static int eckey_check_pair( const void *pub, const void *prv )
 
418
{
 
419
    return( mbedtls_ecp_check_pub_priv( (const mbedtls_ecp_keypair *) pub,
 
420
                                (const mbedtls_ecp_keypair *) prv ) );
 
421
}
 
422
 
 
423
static void *eckey_alloc_wrap( void )
 
424
{
 
425
    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecp_keypair ) );
 
426
 
 
427
    if( ctx != NULL )
 
428
        mbedtls_ecp_keypair_init( ctx );
 
429
 
 
430
    return( ctx );
 
431
}
 
432
 
 
433
static void eckey_free_wrap( void *ctx )
 
434
{
 
435
    mbedtls_ecp_keypair_free( (mbedtls_ecp_keypair *) ctx );
 
436
    mbedtls_free( ctx );
 
437
}
 
438
 
 
439
static void eckey_debug( const void *ctx, mbedtls_pk_debug_item *items )
 
440
{
 
441
    items->type = MBEDTLS_PK_DEBUG_ECP;
 
442
    items->name = "eckey.Q";
 
443
    items->value = &( ((mbedtls_ecp_keypair *) ctx)->Q );
 
444
}
 
445
 
 
446
const mbedtls_pk_info_t mbedtls_eckey_info = {
 
447
    MBEDTLS_PK_ECKEY,
 
448
    "EC",
 
449
    eckey_get_bitlen,
 
450
    eckey_can_do,
 
451
#if defined(MBEDTLS_ECDSA_C)
 
452
    eckey_verify_wrap,
 
453
    eckey_sign_wrap,
 
454
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
455
    eckey_verify_rs_wrap,
 
456
    eckey_sign_rs_wrap,
 
457
#endif
 
458
#else /* MBEDTLS_ECDSA_C */
 
459
    NULL,
 
460
    NULL,
 
461
#endif /* MBEDTLS_ECDSA_C */
 
462
    NULL,
 
463
    NULL,
 
464
    eckey_check_pair,
 
465
    eckey_alloc_wrap,
 
466
    eckey_free_wrap,
 
467
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
468
    eckey_rs_alloc,
 
469
    eckey_rs_free,
 
470
#endif
 
471
    eckey_debug,
 
472
};
 
473
 
 
474
/*
 
475
 * EC key restricted to ECDH
 
476
 */
 
477
static int eckeydh_can_do( mbedtls_pk_type_t type )
 
478
{
 
479
    return( type == MBEDTLS_PK_ECKEY ||
 
480
            type == MBEDTLS_PK_ECKEY_DH );
 
481
}
 
482
 
 
483
const mbedtls_pk_info_t mbedtls_eckeydh_info = {
 
484
    MBEDTLS_PK_ECKEY_DH,
 
485
    "EC_DH",
 
486
    eckey_get_bitlen,         /* Same underlying key structure */
 
487
    eckeydh_can_do,
 
488
    NULL,
 
489
    NULL,
 
490
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
491
    NULL,
 
492
    NULL,
 
493
#endif
 
494
    NULL,
 
495
    NULL,
 
496
    eckey_check_pair,
 
497
    eckey_alloc_wrap,       /* Same underlying key structure */
 
498
    eckey_free_wrap,        /* Same underlying key structure */
 
499
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
500
    NULL,
 
501
    NULL,
 
502
#endif
 
503
    eckey_debug,            /* Same underlying key structure */
 
504
};
 
505
#endif /* MBEDTLS_ECP_C */
 
506
 
 
507
#if defined(MBEDTLS_ECDSA_C)
 
508
static int ecdsa_can_do( mbedtls_pk_type_t type )
 
509
{
 
510
    return( type == MBEDTLS_PK_ECDSA );
 
511
}
 
512
 
 
513
static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
514
                       const unsigned char *hash, size_t hash_len,
 
515
                       const unsigned char *sig, size_t sig_len )
 
516
{
 
517
    int ret;
 
518
    ((void) md_alg);
 
519
 
 
520
    ret = mbedtls_ecdsa_read_signature( (mbedtls_ecdsa_context *) ctx,
 
521
                                hash, hash_len, sig, sig_len );
 
522
 
 
523
    if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
 
524
        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
 
525
 
 
526
    return( ret );
 
527
}
 
528
 
 
529
static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
530
                   const unsigned char *hash, size_t hash_len,
 
531
                   unsigned char *sig, size_t *sig_len,
 
532
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
533
{
 
534
    return( mbedtls_ecdsa_write_signature( (mbedtls_ecdsa_context *) ctx,
 
535
                md_alg, hash, hash_len, sig, sig_len, f_rng, p_rng ) );
 
536
}
 
537
 
 
538
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
539
static int ecdsa_verify_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
540
                       const unsigned char *hash, size_t hash_len,
 
541
                       const unsigned char *sig, size_t sig_len,
 
542
                       void *rs_ctx )
 
543
{
 
544
    int ret;
 
545
    ((void) md_alg);
 
546
 
 
547
    ret = mbedtls_ecdsa_read_signature_restartable(
 
548
            (mbedtls_ecdsa_context *) ctx,
 
549
            hash, hash_len, sig, sig_len,
 
550
            (mbedtls_ecdsa_restart_ctx *) rs_ctx );
 
551
 
 
552
    if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
 
553
        return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
 
554
 
 
555
    return( ret );
 
556
}
 
557
 
 
558
static int ecdsa_sign_rs_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
559
                   const unsigned char *hash, size_t hash_len,
 
560
                   unsigned char *sig, size_t *sig_len,
 
561
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
 
562
                   void *rs_ctx )
 
563
{
 
564
    return( mbedtls_ecdsa_write_signature_restartable(
 
565
                (mbedtls_ecdsa_context *) ctx,
 
566
                md_alg, hash, hash_len, sig, sig_len, f_rng, p_rng,
 
567
                (mbedtls_ecdsa_restart_ctx *) rs_ctx ) );
 
568
 
 
569
}
 
570
#endif /* MBEDTLS_ECP_RESTARTABLE */
 
571
 
 
572
static void *ecdsa_alloc_wrap( void )
 
573
{
 
574
    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecdsa_context ) );
 
575
 
 
576
    if( ctx != NULL )
 
577
        mbedtls_ecdsa_init( (mbedtls_ecdsa_context *) ctx );
 
578
 
 
579
    return( ctx );
 
580
}
 
581
 
 
582
static void ecdsa_free_wrap( void *ctx )
 
583
{
 
584
    mbedtls_ecdsa_free( (mbedtls_ecdsa_context *) ctx );
 
585
    mbedtls_free( ctx );
 
586
}
 
587
 
 
588
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
589
static void *ecdsa_rs_alloc( void )
 
590
{
 
591
    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ecdsa_restart_ctx ) );
 
592
 
 
593
    if( ctx != NULL )
 
594
        mbedtls_ecdsa_restart_init( ctx );
 
595
 
 
596
    return( ctx );
 
597
}
 
598
 
 
599
static void ecdsa_rs_free( void *ctx )
 
600
{
 
601
    mbedtls_ecdsa_restart_free( ctx );
 
602
    mbedtls_free( ctx );
 
603
}
 
604
#endif /* MBEDTLS_ECP_RESTARTABLE */
 
605
 
 
606
const mbedtls_pk_info_t mbedtls_ecdsa_info = {
 
607
    MBEDTLS_PK_ECDSA,
 
608
    "ECDSA",
 
609
    eckey_get_bitlen,     /* Compatible key structures */
 
610
    ecdsa_can_do,
 
611
    ecdsa_verify_wrap,
 
612
    ecdsa_sign_wrap,
 
613
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
614
    ecdsa_verify_rs_wrap,
 
615
    ecdsa_sign_rs_wrap,
 
616
#endif
 
617
    NULL,
 
618
    NULL,
 
619
    eckey_check_pair,   /* Compatible key structures */
 
620
    ecdsa_alloc_wrap,
 
621
    ecdsa_free_wrap,
 
622
#if defined(MBEDTLS_ECP_RESTARTABLE)
 
623
    ecdsa_rs_alloc,
 
624
    ecdsa_rs_free,
 
625
#endif
 
626
    eckey_debug,        /* Compatible key structures */
 
627
};
 
628
#endif /* MBEDTLS_ECDSA_C */
 
629
 
 
630
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
 
631
/*
 
632
 * Support for alternative RSA-private implementations
 
633
 */
 
634
 
 
635
static int rsa_alt_can_do( mbedtls_pk_type_t type )
 
636
{
 
637
    return( type == MBEDTLS_PK_RSA );
 
638
}
 
639
 
 
640
static size_t rsa_alt_get_bitlen( const void *ctx )
 
641
{
 
642
    const mbedtls_rsa_alt_context *rsa_alt = (const mbedtls_rsa_alt_context *) ctx;
 
643
 
 
644
    return( 8 * rsa_alt->key_len_func( rsa_alt->key ) );
 
645
}
 
646
 
 
647
static int rsa_alt_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
 
648
                   const unsigned char *hash, size_t hash_len,
 
649
                   unsigned char *sig, size_t *sig_len,
 
650
                   int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
651
{
 
652
    mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
 
653
 
 
654
#if SIZE_MAX > UINT_MAX
 
655
    if( UINT_MAX < hash_len )
 
656
        return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 
657
#endif /* SIZE_MAX > UINT_MAX */
 
658
 
 
659
    *sig_len = rsa_alt->key_len_func( rsa_alt->key );
 
660
 
 
661
    return( rsa_alt->sign_func( rsa_alt->key, f_rng, p_rng, MBEDTLS_RSA_PRIVATE,
 
662
                md_alg, (unsigned int) hash_len, hash, sig ) );
 
663
}
 
664
 
 
665
static int rsa_alt_decrypt_wrap( void *ctx,
 
666
                    const unsigned char *input, size_t ilen,
 
667
                    unsigned char *output, size_t *olen, size_t osize,
 
668
                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
 
669
{
 
670
    mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
 
671
 
 
672
    ((void) f_rng);
 
673
    ((void) p_rng);
 
674
 
 
675
    if( ilen != rsa_alt->key_len_func( rsa_alt->key ) )
 
676
        return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
 
677
 
 
678
    return( rsa_alt->decrypt_func( rsa_alt->key,
 
679
                MBEDTLS_RSA_PRIVATE, olen, input, output, osize ) );
 
680
}
 
681
 
 
682
#if defined(MBEDTLS_RSA_C)
 
683
static int rsa_alt_check_pair( const void *pub, const void *prv )
 
684
{
 
685
    unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
 
686
    unsigned char hash[32];
 
687
    size_t sig_len = 0;
 
688
    int ret;
 
689
 
 
690
    if( rsa_alt_get_bitlen( prv ) != rsa_get_bitlen( pub ) )
 
691
        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
 
692
 
 
693
    memset( hash, 0x2a, sizeof( hash ) );
 
694
 
 
695
    if( ( ret = rsa_alt_sign_wrap( (void *) prv, MBEDTLS_MD_NONE,
 
696
                                   hash, sizeof( hash ),
 
697
                                   sig, &sig_len, NULL, NULL ) ) != 0 )
 
698
    {
 
699
        return( ret );
 
700
    }
 
701
 
 
702
    if( rsa_verify_wrap( (void *) pub, MBEDTLS_MD_NONE,
 
703
                         hash, sizeof( hash ), sig, sig_len ) != 0 )
 
704
    {
 
705
        return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
 
706
    }
 
707
 
 
708
    return( 0 );
 
709
}
 
710
#endif /* MBEDTLS_RSA_C */
 
711
 
 
712
static void *rsa_alt_alloc_wrap( void )
 
713
{
 
714
    void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_rsa_alt_context ) );
 
715
 
 
716
    if( ctx != NULL )
 
717
        memset( ctx, 0, sizeof( mbedtls_rsa_alt_context ) );
 
718
 
 
719
    return( ctx );
 
720
}
 
721
 
 
722
static void rsa_alt_free_wrap( void *ctx )
 
723
{
 
724
    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_rsa_alt_context ) );
 
725
    mbedtls_free( ctx );
 
726
}
 
727
 
 
728
const mbedtls_pk_info_t mbedtls_rsa_alt_info = {
 
729
    MBEDTLS_PK_RSA_ALT,
 
730
    "RSA-alt",
 
731
    rsa_alt_get_bitlen,
 
732
    rsa_alt_can_do,
 
733
    NULL,
 
734
    rsa_alt_sign_wrap,
 
735
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
736
    NULL,
 
737
    NULL,
 
738
#endif
 
739
    rsa_alt_decrypt_wrap,
 
740
    NULL,
 
741
#if defined(MBEDTLS_RSA_C)
 
742
    rsa_alt_check_pair,
 
743
#else
 
744
    NULL,
 
745
#endif
 
746
    rsa_alt_alloc_wrap,
 
747
    rsa_alt_free_wrap,
 
748
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 
749
    NULL,
 
750
    NULL,
 
751
#endif
 
752
    NULL,
 
753
};
 
754
 
 
755
#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
 
756
 
 
757
#endif /* MBEDTLS_PK_C */