← Back to branch summary

~bibledit/bibledit/client

« back to all changes in this revision

Viewing changes to mbedtls_2.x/md.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:
mbedtls_2.x/md.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
 
 * \file mbedtls_md.c
16
 
 *
17
 
 * \brief Generic message digest wrapper for mbed TLS
18
 
 *
19
 
 * \author Adriaan de Jong <dejong@fox-it.com>
20
 
 *
21
 
 *  Copyright The Mbed TLS Contributors
22
 
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
23
 
 *
24
 
 *  This file is provided under the Apache License 2.0, or the
25
 
 *  GNU General Public License v2.0 or later.
26
 
 *
27
 
 *  **********
28
 
 *  Apache License 2.0:
29
 
 *
30
 
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
31
 
 *  not use this file except in compliance with the License.
32
 
 *  You may obtain a copy of the License at
33
 
 *
34
 
 *  http://www.apache.org/licenses/LICENSE-2.0
35
 
 *
36
 
 *  Unless required by applicable law or agreed to in writing, software
37
 
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
38
 
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
39
 
 *  See the License for the specific language governing permissions and
40
 
 *  limitations under the License.
41
 
 *
42
 
 *  **********
43
 
 *
44
 
 *  **********
45
 
 *  GNU General Public License v2.0 or later:
46
 
 *
47
 
 *  This program is free software; you can redistribute it and/or modify
48
 
 *  it under the terms of the GNU General Public License as published by
49
 
 *  the Free Software Foundation; either version 2 of the License, or
50
 
 *  (at your option) any later version.
51
 
 *
52
 
 *  This program is distributed in the hope that it will be useful,
53
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
54
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
55
 
 *  GNU General Public License for more details.
56
 
 *
57
 
 *  You should have received a copy of the GNU General Public License along
58
 
 *  with this program; if not, write to the Free Software Foundation, Inc.,
59
 
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
60
 
 *
61
 
 *  **********
62
 
 */
63
 
 
64
 
#if !defined(MBEDTLS_CONFIG_FILE)
65
 
#include "mbedtls/config.h"
66
 
#else
67
 
#include MBEDTLS_CONFIG_FILE
68
 
#endif
69
 
 
70
 
#if defined(MBEDTLS_MD_C)
71
 
 
72
 
#include "mbedtls/md.h"
73
 
#include "mbedtls/md_internal.h"
74
 
#include "mbedtls/platform_util.h"
75
 
 
76
 
#if defined(MBEDTLS_PLATFORM_C)
77
 
#include "mbedtls/platform.h"
78
 
#else
79
 
#include <stdlib.h>
80
 
#define mbedtls_calloc    calloc
81
 
#define mbedtls_free       free
82
 
#endif
83
 
 
84
 
#include <string.h>
85
 
 
86
 
#if defined(MBEDTLS_FS_IO)
87
 
#include <stdio.h>
88
 
#endif
89
 
 
90
 
/*
91
 
 * Reminder: update profiles in x509_crt.c when adding a new hash!
92
 
 */
93
 
static const int supported_digests[] = {
94
 
 
95
 
#if defined(MBEDTLS_SHA512_C)
96
 
        MBEDTLS_MD_SHA512,
97
 
        MBEDTLS_MD_SHA384,
98
 
#endif
99
 
 
100
 
#if defined(MBEDTLS_SHA256_C)
101
 
        MBEDTLS_MD_SHA256,
102
 
        MBEDTLS_MD_SHA224,
103
 
#endif
104
 
 
105
 
#if defined(MBEDTLS_SHA1_C)
106
 
        MBEDTLS_MD_SHA1,
107
 
#endif
108
 
 
109
 
#if defined(MBEDTLS_RIPEMD160_C)
110
 
        MBEDTLS_MD_RIPEMD160,
111
 
#endif
112
 
 
113
 
#if defined(MBEDTLS_MD5_C)
114
 
        MBEDTLS_MD_MD5,
115
 
#endif
116
 
 
117
 
#if defined(MBEDTLS_MD4_C)
118
 
        MBEDTLS_MD_MD4,
119
 
#endif
120
 
 
121
 
#if defined(MBEDTLS_MD2_C)
122
 
        MBEDTLS_MD_MD2,
123
 
#endif
124
 
 
125
 
        MBEDTLS_MD_NONE
126
 
};
127
 
 
128
 
const int *mbedtls_md_list( void )
129
 
{
130
 
    return( supported_digests );
131
 
}
132
 
 
133
 
const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
134
 
{
135
 
    if( NULL == md_name )
136
 
        return( NULL );
137
 
 
138
 
    /* Get the appropriate digest information */
139
 
#if defined(MBEDTLS_MD2_C)
140
 
    if( !strcmp( "MD2", md_name ) )
141
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
142
 
#endif
143
 
#if defined(MBEDTLS_MD4_C)
144
 
    if( !strcmp( "MD4", md_name ) )
145
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_MD4 );
146
 
#endif
147
 
#if defined(MBEDTLS_MD5_C)
148
 
    if( !strcmp( "MD5", md_name ) )
149
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
150
 
#endif
151
 
#if defined(MBEDTLS_RIPEMD160_C)
152
 
    if( !strcmp( "RIPEMD160", md_name ) )
153
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
154
 
#endif
155
 
#if defined(MBEDTLS_SHA1_C)
156
 
    if( !strcmp( "SHA1", md_name ) || !strcmp( "SHA", md_name ) )
157
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
158
 
#endif
159
 
#if defined(MBEDTLS_SHA256_C)
160
 
    if( !strcmp( "SHA224", md_name ) )
161
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
162
 
    if( !strcmp( "SHA256", md_name ) )
163
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
164
 
#endif
165
 
#if defined(MBEDTLS_SHA512_C)
166
 
    if( !strcmp( "SHA384", md_name ) )
167
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
168
 
    if( !strcmp( "SHA512", md_name ) )
169
 
        return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
170
 
#endif
171
 
    return( NULL );
172
 
}
173
 
 
174
 
const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
175
 
{
176
 
    switch( md_type )
177
 
    {
178
 
#if defined(MBEDTLS_MD2_C)
179
 
        case MBEDTLS_MD_MD2:
180
 
            return( &mbedtls_md2_info );
181
 
#endif
182
 
#if defined(MBEDTLS_MD4_C)
183
 
        case MBEDTLS_MD_MD4:
184
 
            return( &mbedtls_md4_info );
185
 
#endif
186
 
#if defined(MBEDTLS_MD5_C)
187
 
        case MBEDTLS_MD_MD5:
188
 
            return( &mbedtls_md5_info );
189
 
#endif
190
 
#if defined(MBEDTLS_RIPEMD160_C)
191
 
        case MBEDTLS_MD_RIPEMD160:
192
 
            return( &mbedtls_ripemd160_info );
193
 
#endif
194
 
#if defined(MBEDTLS_SHA1_C)
195
 
        case MBEDTLS_MD_SHA1:
196
 
            return( &mbedtls_sha1_info );
197
 
#endif
198
 
#if defined(MBEDTLS_SHA256_C)
199
 
        case MBEDTLS_MD_SHA224:
200
 
            return( &mbedtls_sha224_info );
201
 
        case MBEDTLS_MD_SHA256:
202
 
            return( &mbedtls_sha256_info );
203
 
#endif
204
 
#if defined(MBEDTLS_SHA512_C)
205
 
        case MBEDTLS_MD_SHA384:
206
 
            return( &mbedtls_sha384_info );
207
 
        case MBEDTLS_MD_SHA512:
208
 
            return( &mbedtls_sha512_info );
209
 
#endif
210
 
        default:
211
 
            return( NULL );
212
 
    }
213
 
}
214
 
 
215
 
void mbedtls_md_init( mbedtls_md_context_t *ctx )
216
 
{
217
 
    memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
218
 
}
219
 
 
220
 
void mbedtls_md_free( mbedtls_md_context_t *ctx )
221
 
{
222
 
    if( ctx == NULL || ctx->md_info == NULL )
223
 
        return;
224
 
 
225
 
    if( ctx->md_ctx != NULL )
226
 
        ctx->md_info->ctx_free_func( ctx->md_ctx );
227
 
 
228
 
    if( ctx->hmac_ctx != NULL )
229
 
    {
230
 
        mbedtls_platform_zeroize( ctx->hmac_ctx,
231
 
                                  2 * ctx->md_info->block_size );
232
 
        mbedtls_free( ctx->hmac_ctx );
233
 
    }
234
 
 
235
 
    mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
236
 
}
237
 
 
238
 
int mbedtls_md_clone( mbedtls_md_context_t *dst,
239
 
                      const mbedtls_md_context_t *src )
240
 
{
241
 
    if( dst == NULL || dst->md_info == NULL ||
242
 
        src == NULL || src->md_info == NULL ||
243
 
        dst->md_info != src->md_info )
244
 
    {
245
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
246
 
    }
247
 
 
248
 
    dst->md_info->clone_func( dst->md_ctx, src->md_ctx );
249
 
 
250
 
    return( 0 );
251
 
}
252
 
 
253
 
#if ! defined(MBEDTLS_DEPRECATED_REMOVED)
254
 
int mbedtls_md_init_ctx( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info )
255
 
{
256
 
    return mbedtls_md_setup( ctx, md_info, 1 );
257
 
}
258
 
#endif
259
 
 
260
 
int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
261
 
{
262
 
    if( md_info == NULL || ctx == NULL )
263
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
264
 
 
265
 
    if( ( ctx->md_ctx = md_info->ctx_alloc_func() ) == NULL )
266
 
        return( MBEDTLS_ERR_MD_ALLOC_FAILED );
267
 
 
268
 
    if( hmac != 0 )
269
 
    {
270
 
        ctx->hmac_ctx = mbedtls_calloc( 2, md_info->block_size );
271
 
        if( ctx->hmac_ctx == NULL )
272
 
        {
273
 
            md_info->ctx_free_func( ctx->md_ctx );
274
 
            return( MBEDTLS_ERR_MD_ALLOC_FAILED );
275
 
        }
276
 
    }
277
 
 
278
 
    ctx->md_info = md_info;
279
 
 
280
 
    return( 0 );
281
 
}
282
 
 
283
 
int mbedtls_md_starts( mbedtls_md_context_t *ctx )
284
 
{
285
 
    if( ctx == NULL || ctx->md_info == NULL )
286
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
287
 
 
288
 
    return( ctx->md_info->starts_func( ctx->md_ctx ) );
289
 
}
290
 
 
291
 
int mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
292
 
{
293
 
    if( ctx == NULL || ctx->md_info == NULL )
294
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
295
 
 
296
 
    return( ctx->md_info->update_func( ctx->md_ctx, input, ilen ) );
297
 
}
298
 
 
299
 
int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
300
 
{
301
 
    if( ctx == NULL || ctx->md_info == NULL )
302
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
303
 
 
304
 
    return( ctx->md_info->finish_func( ctx->md_ctx, output ) );
305
 
}
306
 
 
307
 
int mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
308
 
            unsigned char *output )
309
 
{
310
 
    if( md_info == NULL )
311
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
312
 
 
313
 
    return( md_info->digest_func( input, ilen, output ) );
314
 
}
315
 
 
316
 
#if defined(MBEDTLS_FS_IO)
317
 
int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
318
 
{
319
 
    int ret;
320
 
    FILE *f;
321
 
    size_t n;
322
 
    mbedtls_md_context_t ctx;
323
 
    unsigned char buf[1024];
324
 
 
325
 
    if( md_info == NULL )
326
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
327
 
 
328
 
    if( ( f = fopen( path, "rb" ) ) == NULL )
329
 
        return( MBEDTLS_ERR_MD_FILE_IO_ERROR );
330
 
 
331
 
    mbedtls_md_init( &ctx );
332
 
 
333
 
    if( ( ret = mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
334
 
        goto cleanup;
335
 
 
336
 
    if( ( ret = md_info->starts_func( ctx.md_ctx ) ) != 0 )
337
 
        goto cleanup;
338
 
 
339
 
    while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
340
 
        if( ( ret = md_info->update_func( ctx.md_ctx, buf, n ) ) != 0 )
341
 
            goto cleanup;
342
 
 
343
 
    if( ferror( f ) != 0 )
344
 
        ret = MBEDTLS_ERR_MD_FILE_IO_ERROR;
345
 
    else
346
 
        ret = md_info->finish_func( ctx.md_ctx, output );
347
 
 
348
 
cleanup:
349
 
    mbedtls_platform_zeroize( buf, sizeof( buf ) );
350
 
    fclose( f );
351
 
    mbedtls_md_free( &ctx );
352
 
 
353
 
    return( ret );
354
 
}
355
 
#endif /* MBEDTLS_FS_IO */
356
 
 
357
 
int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
358
 
{
359
 
    int ret;
360
 
    unsigned char sum[MBEDTLS_MD_MAX_SIZE];
361
 
    unsigned char *ipad, *opad;
362
 
    size_t i;
363
 
 
364
 
    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
365
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
366
 
 
367
 
    if( keylen > (size_t) ctx->md_info->block_size )
368
 
    {
369
 
        if( ( ret = ctx->md_info->starts_func( ctx->md_ctx ) ) != 0 )
370
 
            goto cleanup;
371
 
        if( ( ret = ctx->md_info->update_func( ctx->md_ctx, key, keylen ) ) != 0 )
372
 
            goto cleanup;
373
 
        if( ( ret = ctx->md_info->finish_func( ctx->md_ctx, sum ) ) != 0 )
374
 
            goto cleanup;
375
 
 
376
 
        keylen = ctx->md_info->size;
377
 
        key = sum;
378
 
    }
379
 
 
380
 
    ipad = (unsigned char *) ctx->hmac_ctx;
381
 
    opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
382
 
 
383
 
    memset( ipad, 0x36, ctx->md_info->block_size );
384
 
    memset( opad, 0x5C, ctx->md_info->block_size );
385
 
 
386
 
    for( i = 0; i < keylen; i++ )
387
 
    {
388
 
        ipad[i] = (unsigned char)( ipad[i] ^ key[i] );
389
 
        opad[i] = (unsigned char)( opad[i] ^ key[i] );
390
 
    }
391
 
 
392
 
    if( ( ret = ctx->md_info->starts_func( ctx->md_ctx ) ) != 0 )
393
 
        goto cleanup;
394
 
    if( ( ret = ctx->md_info->update_func( ctx->md_ctx, ipad,
395
 
                                           ctx->md_info->block_size ) ) != 0 )
396
 
        goto cleanup;
397
 
 
398
 
cleanup:
399
 
    mbedtls_platform_zeroize( sum, sizeof( sum ) );
400
 
 
401
 
    return( ret );
402
 
}
403
 
 
404
 
int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
405
 
{
406
 
    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
407
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
408
 
 
409
 
    return( ctx->md_info->update_func( ctx->md_ctx, input, ilen ) );
410
 
}
411
 
 
412
 
int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
413
 
{
414
 
    int ret;
415
 
    unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
416
 
    unsigned char *opad;
417
 
 
418
 
    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
419
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
420
 
 
421
 
    opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
422
 
 
423
 
    if( ( ret = ctx->md_info->finish_func( ctx->md_ctx, tmp ) ) != 0 )
424
 
        return( ret );
425
 
    if( ( ret = ctx->md_info->starts_func( ctx->md_ctx ) ) != 0 )
426
 
        return( ret );
427
 
    if( ( ret = ctx->md_info->update_func( ctx->md_ctx, opad,
428
 
                                           ctx->md_info->block_size ) ) != 0 )
429
 
        return( ret );
430
 
    if( ( ret = ctx->md_info->update_func( ctx->md_ctx, tmp,
431
 
                                           ctx->md_info->size ) ) != 0 )
432
 
        return( ret );
433
 
    return( ctx->md_info->finish_func( ctx->md_ctx, output ) );
434
 
}
435
 
 
436
 
int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
437
 
{
438
 
    int ret;
439
 
    unsigned char *ipad;
440
 
 
441
 
    if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
442
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
443
 
 
444
 
    ipad = (unsigned char *) ctx->hmac_ctx;
445
 
 
446
 
    if( ( ret = ctx->md_info->starts_func( ctx->md_ctx ) ) != 0 )
447
 
        return( ret );
448
 
    return( ctx->md_info->update_func( ctx->md_ctx, ipad,
449
 
                                       ctx->md_info->block_size ) );
450
 
}
451
 
 
452
 
int mbedtls_md_hmac( const mbedtls_md_info_t *md_info,
453
 
                     const unsigned char *key, size_t keylen,
454
 
                     const unsigned char *input, size_t ilen,
455
 
                     unsigned char *output )
456
 
{
457
 
    mbedtls_md_context_t ctx;
458
 
    int ret;
459
 
 
460
 
    if( md_info == NULL )
461
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
462
 
 
463
 
    mbedtls_md_init( &ctx );
464
 
 
465
 
    if( ( ret = mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
466
 
        goto cleanup;
467
 
 
468
 
    if( ( ret = mbedtls_md_hmac_starts( &ctx, key, keylen ) ) != 0 )
469
 
        goto cleanup;
470
 
    if( ( ret = mbedtls_md_hmac_update( &ctx, input, ilen ) ) != 0 )
471
 
        goto cleanup;
472
 
    if( ( ret = mbedtls_md_hmac_finish( &ctx, output ) ) != 0 )
473
 
        goto cleanup;
474
 
 
475
 
cleanup:
476
 
    mbedtls_md_free( &ctx );
477
 
 
478
 
    return( ret );
479
 
}
480
 
 
481
 
int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
482
 
{
483
 
    if( ctx == NULL || ctx->md_info == NULL )
484
 
        return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
485
 
 
486
 
    return( ctx->md_info->process_func( ctx->md_ctx, data ) );
487
 
}
488
 
 
489
 
unsigned char mbedtls_md_get_size( const mbedtls_md_info_t *md_info )
490
 
{
491
 
    if( md_info == NULL )
492
 
        return( 0 );
493
 
 
494
 
    return md_info->size;
495
 
}
496
 
 
497
 
mbedtls_md_type_t mbedtls_md_get_type( const mbedtls_md_info_t *md_info )
498
 
{
499
 
    if( md_info == NULL )
500
 
        return( MBEDTLS_MD_NONE );
501
 
 
502
 
    return md_info->type;
503
 
}
504
 
 
505
 
const char *mbedtls_md_get_name( const mbedtls_md_info_t *md_info )
506
 
{
507
 
    if( md_info == NULL )
508
 
        return( NULL );
509
 
 
510
 
    return md_info->name;
511
 
}
512
 
 
513
 
#endif /* MBEDTLS_MD_C */