third_party/mbedtls/repo/library/pkcs5.c

   1 /**
   2  * \file pkcs5.c
   3  *
   4  * \brief PKCS#5 functions
   5  *
   6  * \author Mathias Olsson <mathias@kompetensum.com>
   7  *
   8  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
   9  *  SPDX-License-Identifier: Apache-2.0
  10  *
  11  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
  12  *  not use this file except in compliance with the License.
  13  *  You may obtain a copy of the License at
  14  *
  15  *  http://www.apache.org/licenses/LICENSE-2.0
  16  *
  17  *  Unless required by applicable law or agreed to in writing, software
  18  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  19  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  *  See the License for the specific language governing permissions and
  21  *  limitations under the License.
  22  *
  23  *  This file is part of mbed TLS (https://tls.mbed.org)
  24  */
  25 /*
  26  * PKCS#5 includes PBKDF2 and more
  27  *
  28  * http://tools.ietf.org/html/rfc2898 (Specification)
  29  * http://tools.ietf.org/html/rfc6070 (Test vectors)
  30  */
  31
  32 #if !defined(MBEDTLS_CONFIG_FILE)
  33 #include "mbedtls/config.h"
  34 #else
  35 #include MBEDTLS_CONFIG_FILE
  36 #endif
  37
  38 #if defined(MBEDTLS_PKCS5_C)
  39
  40 #include "mbedtls/pkcs5.h"
  41
  42 #if defined(MBEDTLS_ASN1_PARSE_C)
  43 #include "mbedtls/asn1.h"
  44 #include "mbedtls/cipher.h"
  45 #include "mbedtls/oid.h"
  46 #endif /* MBEDTLS_ASN1_PARSE_C */
  47
  48 #include <string.h>
  49
  50 #if defined(MBEDTLS_PLATFORM_C)
  51 #include "mbedtls/platform.h"
  52 #else
  53 #include <stdio.h>
  54 #define mbedtls_printf printf
  55 #endif
  56
  57 #if defined(MBEDTLS_ASN1_PARSE_C)
  58 static int pkcs5_parse_pbkdf2_params( const mbedtls_asn1_buf *params,
  59                                       mbedtls_asn1_buf *salt, int *iterations,
  60                                       int *keylen, mbedtls_md_type_t *md_type )
  61 {
  62     int ret;
  63     mbedtls_asn1_buf prf_alg_oid;
  64     unsigned char *p = params->p;
  65     const unsigned char *end = params->p + params->len;
  66
  67     if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
  68         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
  69                 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  70     /*
  71      *  PBKDF2-params ::= SEQUENCE {
  72      *    salt              OCTET STRING,
  73      *    iterationCount    INTEGER,
  74      *    keyLength         INTEGER OPTIONAL
  75      *    prf               AlgorithmIdentifier DEFAULT algid-hmacWithSHA1
  76      *  }
  77      *
  78      */
  79     if( ( ret = mbedtls_asn1_get_tag( &p, end, &salt->len,
  80                                       MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
  81         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
  82
  83     salt->p = p;
  84     p += salt->len;
  85
  86     if( ( ret = mbedtls_asn1_get_int( &p, end, iterations ) ) != 0 )
  87         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
  88
  89     if( p == end )
  90         return( 0 );
  91
  92     if( ( ret = mbedtls_asn1_get_int( &p, end, keylen ) ) != 0 )
  93     {
  94         if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
  95             return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
  96     }
  97
  98     if( p == end )
  99         return( 0 );
 100
 101     if( ( ret = mbedtls_asn1_get_alg_null( &p, end, &prf_alg_oid ) ) != 0 )
 102         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
 103
 104     if( mbedtls_oid_get_md_hmac( &prf_alg_oid, md_type ) != 0 )
 105         return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
 106
 107     if( p != end )
 108         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
 109                 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
 110
 111     return( 0 );
 112 }
 113
 114 int mbedtls_pkcs5_pbes2( const mbedtls_asn1_buf *pbe_params, int mode,
 115                  const unsigned char *pwd,  size_t pwdlen,
 116                  const unsigned char *data, size_t datalen,
 117                  unsigned char *output )
 118 {
 119     int ret, iterations = 0, keylen = 0;
 120     unsigned char *p, *end;
 121     mbedtls_asn1_buf kdf_alg_oid, enc_scheme_oid, kdf_alg_params, enc_scheme_params;
 122     mbedtls_asn1_buf salt;
 123     mbedtls_md_type_t md_type = MBEDTLS_MD_SHA1;
 124     unsigned char key[32], iv[32];
 125     size_t olen = 0;
 126     const mbedtls_md_info_t *md_info;
 127     const mbedtls_cipher_info_t *cipher_info;
 128     mbedtls_md_context_t md_ctx;
 129     mbedtls_cipher_type_t cipher_alg;
 130     mbedtls_cipher_context_t cipher_ctx;
 131
 132     p = pbe_params->p;
 133     end = p + pbe_params->len;
 134
 135     /*
 136      *  PBES2-params ::= SEQUENCE {
 137      *    keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},
 138      *    encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}
 139      *  }
 140      */
 141     if( pbe_params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
 142         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
 143                 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
 144
 145     if( ( ret = mbedtls_asn1_get_alg( &p, end, &kdf_alg_oid,
 146                                       &kdf_alg_params ) ) != 0 )
 147         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
 148
 149     // Only PBKDF2 supported at the moment
 150     //
 151     if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS5_PBKDF2, &kdf_alg_oid ) != 0 )
 152         return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
 153
 154     if( ( ret = pkcs5_parse_pbkdf2_params( &kdf_alg_params,
 155                                            &salt, &iterations, &keylen,
 156                                            &md_type ) ) != 0 )
 157     {
 158         return( ret );
 159     }
 160
 161     md_info = mbedtls_md_info_from_type( md_type );
 162     if( md_info == NULL )
 163         return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
 164
 165     if( ( ret = mbedtls_asn1_get_alg( &p, end, &enc_scheme_oid,
 166                               &enc_scheme_params ) ) != 0 )
 167     {
 168         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
 169     }
 170
 171     if( mbedtls_oid_get_cipher_alg( &enc_scheme_oid, &cipher_alg ) != 0 )
 172         return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
 173
 174     cipher_info = mbedtls_cipher_info_from_type( cipher_alg );
 175     if( cipher_info == NULL )
 176         return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
 177
 178     /*
 179      * The value of keylen from pkcs5_parse_pbkdf2_params() is ignored
 180      * since it is optional and we don't know if it was set or not
 181      */
 182     keylen = cipher_info->key_bitlen / 8;
 183
 184     if( enc_scheme_params.tag != MBEDTLS_ASN1_OCTET_STRING ||
 185         enc_scheme_params.len != cipher_info->iv_size )
 186     {
 187         return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT );
 188     }
 189
 190     mbedtls_md_init( &md_ctx );
 191     mbedtls_cipher_init( &cipher_ctx );
 192
 193     memcpy( iv, enc_scheme_params.p, enc_scheme_params.len );
 194
 195     if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
 196         goto exit;
 197
 198     if( ( ret = mbedtls_pkcs5_pbkdf2_hmac( &md_ctx, pwd, pwdlen, salt.p, salt.len,
 199                                    iterations, keylen, key ) ) != 0 )
 200     {
 201         goto exit;
 202     }
 203
 204     if( ( ret = mbedtls_cipher_setup( &cipher_ctx, cipher_info ) ) != 0 )
 205         goto exit;
 206
 207     if( ( ret = mbedtls_cipher_setkey( &cipher_ctx, key, 8 * keylen,
 208                                        (mbedtls_operation_t) mode ) ) != 0 )
 209         goto exit;
 210
 211     if( ( ret = mbedtls_cipher_crypt( &cipher_ctx, iv, enc_scheme_params.len,
 212                               data, datalen, output, &olen ) ) != 0 )
 213         ret = MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH;
 214
 215 exit:
 216     mbedtls_md_free( &md_ctx );
 217     mbedtls_cipher_free( &cipher_ctx );
 218
 219     return( ret );
 220 }
 221 #endif /* MBEDTLS_ASN1_PARSE_C */
 222
 223 int mbedtls_pkcs5_pbkdf2_hmac( mbedtls_md_context_t *ctx,
 224                        const unsigned char *password,
 225                        size_t plen, const unsigned char *salt, size_t slen,
 226                        unsigned int iteration_count,
 227                        uint32_t key_length, unsigned char *output )
 228 {
 229     int ret, j;
 230     unsigned int i;
 231     unsigned char md1[MBEDTLS_MD_MAX_SIZE];
 232     unsigned char work[MBEDTLS_MD_MAX_SIZE];
 233     unsigned char md_size = mbedtls_md_get_size( ctx->md_info );
 234     size_t use_len;
 235     unsigned char *out_p = output;
 236     unsigned char counter[4];
 237
 238     memset( counter, 0, 4 );
 239     counter[3] = 1;
 240
 241 #if UINT_MAX > 0xFFFFFFFF
 242     if( iteration_count > 0xFFFFFFFF )
 243         return( MBEDTLS_ERR_PKCS5_BAD_INPUT_DATA );
 244 #endif
 245
 246     while( key_length )
 247     {
 248         // U1 ends up in work
 249         //
 250         if( ( ret = mbedtls_md_hmac_starts( ctx, password, plen ) ) != 0 )
 251             return( ret );
 252
 253         if( ( ret = mbedtls_md_hmac_update( ctx, salt, slen ) ) != 0 )
 254             return( ret );
 255
 256         if( ( ret = mbedtls_md_hmac_update( ctx, counter, 4 ) ) != 0 )
 257             return( ret );
 258
 259         if( ( ret = mbedtls_md_hmac_finish( ctx, work ) ) != 0 )
 260             return( ret );
 261
 262         memcpy( md1, work, md_size );
 263
 264         for( i = 1; i < iteration_count; i++ )
 265         {
 266             // U2 ends up in md1
 267             //
 268             if( ( ret = mbedtls_md_hmac_starts( ctx, password, plen ) ) != 0 )
 269                 return( ret );
 270
 271             if( ( ret = mbedtls_md_hmac_update( ctx, md1, md_size ) ) != 0 )
 272                 return( ret );
 273
 274             if( ( ret = mbedtls_md_hmac_finish( ctx, md1 ) ) != 0 )
 275                 return( ret );
 276
 277             // U1 xor U2
 278             //
 279             for( j = 0; j < md_size; j++ )
 280                 work[j] ^= md1[j];
 281         }
 282
 283         use_len = ( key_length < md_size ) ? key_length : md_size;
 284         memcpy( out_p, work, use_len );
 285
 286         key_length -= (uint32_t) use_len;
 287         out_p += use_len;
 288
 289         for( i = 4; i > 0; i-- )
 290             if( ++counter[i - 1] != 0 )
 291                 break;
 292     }
 293
 294     return( 0 );
 295 }
 296
 297 #if defined(MBEDTLS_SELF_TEST)
 298
 299 #if !defined(MBEDTLS_SHA1_C)
 300 int mbedtls_pkcs5_self_test( int verbose )
 301 {
 302     if( verbose != 0 )
 303         mbedtls_printf( "  PBKDF2 (SHA1): skipped\n\n" );
 304
 305     return( 0 );
 306 }
 307 #else
 308
 309 #define MAX_TESTS   6
 310
 311 static const size_t plen_test_data[MAX_TESTS] =
 312     { 8, 8, 8, 24, 9 };
 313
 314 static const unsigned char password_test_data[MAX_TESTS][32] =
 315 {
 316     "password",
 317     "password",
 318     "password",
 319     "passwordPASSWORDpassword",
 320     "pass\0word",
 321 };
 322
 323 static const size_t slen_test_data[MAX_TESTS] =
 324     { 4, 4, 4, 36, 5 };
 325
 326 static const unsigned char salt_test_data[MAX_TESTS][40] =
 327 {
 328     "salt",
 329     "salt",
 330     "salt",
 331     "saltSALTsaltSALTsaltSALTsaltSALTsalt",
 332     "sa\0lt",
 333 };
 334
 335 static const uint32_t it_cnt_test_data[MAX_TESTS] =
 336     { 1, 2, 4096, 4096, 4096 };
 337
 338 static const uint32_t key_len_test_data[MAX_TESTS] =
 339     { 20, 20, 20, 25, 16 };
 340
 341 static const unsigned char result_key_test_data[MAX_TESTS][32] =
 342 {
 343     { 0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71,
 344       0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06,
 345       0x2f, 0xe0, 0x37, 0xa6 },
 346     { 0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c,
 347       0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0,
 348       0xd8, 0xde, 0x89, 0x57 },
 349     { 0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a,
 350       0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0,
 351       0x65, 0xa4, 0x29, 0xc1 },
 352     { 0x3d, 0x2e, 0xec, 0x4f, 0xe4, 0x1c, 0x84, 0x9b,
 353       0x80, 0xc8, 0xd8, 0x36, 0x62, 0xc0, 0xe4, 0x4a,
 354       0x8b, 0x29, 0x1a, 0x96, 0x4c, 0xf2, 0xf0, 0x70,
 355       0x38 },
 356     { 0x56, 0xfa, 0x6a, 0xa7, 0x55, 0x48, 0x09, 0x9d,
 357       0xcc, 0x37, 0xd7, 0xf0, 0x34, 0x25, 0xe0, 0xc3 },
 358 };
 359
 360 int mbedtls_pkcs5_self_test( int verbose )
 361 {
 362     mbedtls_md_context_t sha1_ctx;
 363     const mbedtls_md_info_t *info_sha1;
 364     int ret, i;
 365     unsigned char key[64];
 366
 367     mbedtls_md_init( &sha1_ctx );
 368
 369     info_sha1 = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
 370     if( info_sha1 == NULL )
 371     {
 372         ret = 1;
 373         goto exit;
 374     }
 375
 376     if( ( ret = mbedtls_md_setup( &sha1_ctx, info_sha1, 1 ) ) != 0 )
 377     {
 378         ret = 1;
 379         goto exit;
 380     }
 381
 382     for( i = 0; i < MAX_TESTS; i++ )
 383     {
 384         if( verbose != 0 )
 385             mbedtls_printf( "  PBKDF2 (SHA1) #%d: ", i );
 386
 387         ret = mbedtls_pkcs5_pbkdf2_hmac( &sha1_ctx, password_test_data[i],
 388                                          plen_test_data[i], salt_test_data[i],
 389                                          slen_test_data[i], it_cnt_test_data[i],
 390                                          key_len_test_data[i], key );
 391         if( ret != 0 ||
 392             memcmp( result_key_test_data[i], key, key_len_test_data[i] ) != 0 )
 393         {
 394             if( verbose != 0 )
 395                 mbedtls_printf( "failed\n" );
 396
 397             ret = 1;
 398             goto exit;
 399         }
 400
 401         if( verbose != 0 )
 402             mbedtls_printf( "passed\n" );
 403     }
 404
 405     if( verbose != 0 )
 406         mbedtls_printf( "\n" );
 407
 408 exit:
 409     mbedtls_md_free( &sha1_ctx );
 410
 411     return( ret );
 412 }
 413 #endif /* MBEDTLS_SHA1_C */
 414
 415 #endif /* MBEDTLS_SELF_TEST */
 416
 417 #endif /* MBEDTLS_PKCS5_C */