git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/pkcs5.c

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