library/pkcs12.c - security/mbedtls - Rivoreo Source Code Repositories

 /*
  *  PKCS#12 Personal Information Exchange Syntax
  *
  *  Copyright (C) 2006-2013, Brainspark B.V.
  *
  *  This file is part of PolarSSL (http://www.polarssl.org)
  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
  *
  *  All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License along
  *  with this program; if not, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 /*
  *  The PKCS #12 Personal Information Exchange Syntax Standard v1.1
  *
  *  http://www.rsa.com/rsalabs/pkcs/files/h11301-wp-pkcs-12v1-1-personal-information-exchange-syntax.pdf
  *  ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-12/pkcs-12v1-1.asn
  */

 #include "polarssl/config.h"

 #if defined(POLARSSL_PKCS12_C)

 #include "polarssl/pkcs12.h"
 #include "polarssl/asn1.h"

 #if defined(POLARSSL_ARC4_C)
 #include "polarssl/arc4.h"
 #endif

 #if defined(POLARSSL_DES_C)
 #include "polarssl/des.h"
 #endif

 static int pkcs12_parse_pbe_params( unsigned char **p,
                                     const unsigned char *end,
                                     asn1_buf *salt, int *iterations )
 {
     int ret;
     size_t len = 0;

     /*
      *  pkcs-12PbeParams ::= SEQUENCE {
      *    salt          OCTET STRING,
      *    iterations    INTEGER
      *  }
      *
      */
     if( ( ret = asn1_get_tag( p, end, &len,
             ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
     {
         return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );
     }

     end = *p + len;

     if( ( ret = asn1_get_tag( p, end, &salt->len, ASN1_OCTET_STRING ) ) != 0 )
         return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );

     salt->p = *p;
     *p += salt->len;

     if( ( ret = asn1_get_int( p, end, iterations ) ) != 0 )
         return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );

     if( *p != end )
         return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT +
                 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );

     return( 0 );
 }

 static int pkcs12_pbe_derive_key_iv( asn1_buf *pbe_params,
                                      const unsigned char *pwd,  size_t pwdlen,
                                      unsigned char *key, size_t keylen,
                                      unsigned char *iv,  size_t ivlen )
 {
     int ret, iterations;
     asn1_buf salt;
     size_t i;
     unsigned char *p, *end;
     unsigned char unipwd[258];

     memset(&salt, 0, sizeof(asn1_buf));
     memset(&unipwd, 0, sizeof(unipwd));

     p = pbe_params->p;
     end = p + pbe_params->len;

     if( ( ret = pkcs12_parse_pbe_params( &p, end, &salt, &iterations ) ) != 0 )
         return( ret );

     for(i = 0; i < pwdlen; i++)
         unipwd[i * 2 + 1] = pwd[i];

     if( ( ret = pkcs12_derivation( key, keylen, unipwd, pwdlen * 2 + 2,
                                    salt.p, salt.len, POLARSSL_MD_SHA1,
                                    PKCS12_DERIVE_KEY, iterations ) ) != 0 )
     {
         return( ret );
     }

     if( iv == NULL || ivlen == 0 )
         return( 0 );

     if( ( ret = pkcs12_derivation( iv, ivlen, unipwd, pwdlen * 2 + 2,
                                    salt.p, salt.len, POLARSSL_MD_SHA1,
                                    PKCS12_DERIVE_IV, iterations ) ) != 0 )
     {
         return( ret );
     }
     return( 0 );
 }

 int pkcs12_pbe_sha1_rc4_128( asn1_buf *pbe_params, int mode,
                              const unsigned char *pwd,  size_t pwdlen,
                              const unsigned char *data, size_t len,
                              unsigned char *output )
 {
 #if !defined(POLARSSL_ARC4_C)
     ((void) pbe_params);
     ((void) mode);
     ((void) pwd);
     ((void) pwdlen);
     ((void) data);
     ((void) len);
     ((void) output);
     return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
 #else
     int ret;
     unsigned char key[16];
     arc4_context ctx;
     ((void) mode);

     if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
                                           key, 16, NULL, 0 ) ) != 0 )
     {
         return( ret );
     }

     arc4_setup( &ctx, key, 16 );
     if( ( ret = arc4_crypt( &ctx, len, data, output ) ) != 0 )
         return( ret );

     return( 0 );
 #endif /* POLARSSL_ARC4_C */
 }

 int pkcs12_pbe_sha1_des2_ede_cbc( asn1_buf *pbe_params, int mode,
                                   const unsigned char *pwd,  size_t pwdlen,
                                   const unsigned char *data, size_t len,
                                   unsigned char *output )
 {
 #if !defined(POLARSSL_DES_C)
     ((void) pbe_params);
     ((void) mode);
     ((void) pwd);
     ((void) pwdlen);
     ((void) data);
     ((void) len);
     ((void) output);
     return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
 #else
     int ret;
     unsigned char key[16];
     unsigned char iv[8];
     des3_context ctx;

     if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
                                           key, 16, iv, 8 ) ) != 0 )
     {
         return( ret );
     }

     if( mode == PKCS12_PBE_ENCRYPT )
     {
         des3_set2key_enc( &ctx, key );
         des3_crypt_cbc( &ctx, DES_ENCRYPT, len, iv, data, output );
     }
     else
     {
         des3_set2key_dec( &ctx, key );
         des3_crypt_cbc( &ctx, DES_DECRYPT, len, iv, data, output );
     }

     return( 0 );
 #endif /* POLARSSL_DES_C */
 }

 int pkcs12_pbe_sha1_des3_ede_cbc( asn1_buf *pbe_params, int mode,
                                   const unsigned char *pwd,  size_t pwdlen,
                                   const unsigned char *data, size_t len,
                                   unsigned char *output )
 {
 #if !defined(POLARSSL_DES_C)
     ((void) pbe_params);
     ((void) mode);
     ((void) pwd);
     ((void) pwdlen);
     ((void) data);
     ((void) len);
     ((void) output);
     return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
 #else
     int ret;
     unsigned char key[24];
     unsigned char iv[8];
     des3_context ctx;

     if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
                                           key, 24, iv, 8 ) ) != 0 )
     {
         return( ret );
     }

     if( mode == PKCS12_PBE_ENCRYPT )
     {
         des3_set3key_enc( &ctx, key );
         des3_crypt_cbc( &ctx, DES_ENCRYPT, len, iv, data, output );
     }
     else
     {
         des3_set3key_dec( &ctx, key );
         des3_crypt_cbc( &ctx, DES_DECRYPT, len, iv, data, output );
     }

     return( 0 );
 #endif /* POLARSSL_DES_C */
 }

 static void pkcs12_fill_buffer( unsigned char *data, size_t data_len,
                                 const unsigned char *filler, size_t fill_len )
 {
     unsigned char *p = data;
     size_t use_len;

     while( data_len > 0 )
     {
         use_len = ( data_len > fill_len ) ? fill_len : data_len;
         memcpy( p, filler, use_len );
         p += use_len;
         data_len -= use_len;
     }
 }

 int pkcs12_derivation( unsigned char *data, size_t datalen,
                        const unsigned char *pwd, size_t pwdlen,
                        const unsigned char *salt, size_t saltlen,
                        md_type_t md_type, int id, int iterations )
 {
     int ret, i;
     unsigned int j;

     unsigned char diversifier[128];
     unsigned char salt_block[128], pwd_block[128], hash_block[128];
     unsigned char hash_output[POLARSSL_MD_MAX_SIZE];
     unsigned char *p;
     unsigned char c;

     size_t hlen, use_len, v;

     const md_info_t *md_info;
     md_context_t md_ctx;

     // This version only allows max of 64 bytes of password or salt
     if( datalen > 128 || pwdlen > 64 || saltlen > 64 )
         return( POLARSSL_ERR_PKCS12_BAD_INPUT_DATA );

     md_info = md_info_from_type( md_type );
     if( md_info == NULL )
         return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );

     if ( ( ret = md_init_ctx( &md_ctx, md_info ) ) != 0 )
         return( ret );
     hlen = md_get_size( md_info );

     if( hlen <= 32 )
         v = 64;
     else
         v = 128;

     memset( diversifier, (unsigned char) id, v );

     pkcs12_fill_buffer( salt_block, v, salt, saltlen );
     pkcs12_fill_buffer( pwd_block,  v, pwd,  pwdlen  );

     p = data;
     while( datalen > 0 )
     {
         // Calculate hash( diversifier || salt_block || pwd_block )
         if( ( ret = md_starts( &md_ctx ) ) != 0 )
             return( ret );

         if( ( ret = md_update( &md_ctx, diversifier, v ) ) != 0 )
             return( ret );

         if( ( ret = md_update( &md_ctx, salt_block, v ) ) != 0 )
             return( ret );

         if( ( ret = md_update( &md_ctx, pwd_block, v ) ) != 0 )
             return( ret );

         if( ( ret = md_finish( &md_ctx, hash_output ) ) != 0 )
             return( ret );

         // Perform remaining ( iterations - 1 ) recursive hash calculations
         for( i = 1; i < iterations; i++ )
         {
             if( ( ret = md( md_info, hash_output, hlen, hash_output ) ) != 0 )
                 return( ret );
         }

         use_len = ( datalen > hlen ) ? hlen : datalen;
         memcpy( p, hash_output, use_len );
         datalen -= use_len;
         p += use_len;

         if( datalen == 0 )
             break;

         // Concatenating copies of hash_output into hash_block (B)
         pkcs12_fill_buffer( hash_block, v, hash_output, hlen );

         // B += 1
         for( i = v; i > 0; i-- )
             if( ++hash_block[i - 1] != 0 )
                 break;

         // salt_block += B
         c = 0;
         for( i = v; i > 0; i-- )
         {
             j = salt_block[i - 1] + hash_block[i - 1] + c;
             c = (unsigned char) (j >> 8);
             salt_block[i - 1] = j & 0xFF;
         }

         // pwd_block  += B
         c = 0;
         for( i = v; i > 0; i-- )
         {
             j = pwd_block[i - 1] + hash_block[i - 1] + c;
             c = (unsigned char) (j >> 8);
             pwd_block[i - 1] = j & 0xFF;
         }
     }

     return( 0 );
 }

 #endif /* POLARSSL_PKCS12_C */
	/*
	* PKCS#12 Personal Information Exchange Syntax
	*
	* Copyright (C) 2006-2013, Brainspark B.V.
	*
	* This file is part of PolarSSL (http://www.polarssl.org)
	* Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
	*
	* All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	*/
	/*
	* The PKCS #12 Personal Information Exchange Syntax Standard v1.1
	*
	* http://www.rsa.com/rsalabs/pkcs/files/h11301-wp-pkcs-12v1-1-personal-information-exchange-syntax.pdf
	* ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-12/pkcs-12v1-1.asn
	*/

	#include "polarssl/config.h"

	#if defined(POLARSSL_PKCS12_C)

	#include "polarssl/pkcs12.h"
	#include "polarssl/asn1.h"

	#if defined(POLARSSL_ARC4_C)
	#include "polarssl/arc4.h"
	#endif

	#if defined(POLARSSL_DES_C)
	#include "polarssl/des.h"
	#endif

	static int pkcs12_parse_pbe_params( unsigned char **p,
	const unsigned char *end,
	asn1_buf salt, int iterations )
	{
	int ret;
	size_t len = 0;

	/*
	* pkcs-12PbeParams ::= SEQUENCE {
	* salt OCTET STRING,
	* iterations INTEGER
	* }
	*
	*/
	if( ( ret = asn1_get_tag( p, end, &len,
	ASN1_CONSTRUCTED \| ASN1_SEQUENCE ) ) != 0 )
	{
	return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );
	}

	end = *p + len;

	if( ( ret = asn1_get_tag( p, end, &salt->len, ASN1_OCTET_STRING ) ) != 0 )
	return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );

	salt->p = *p;
	*p += salt->len;

	if( ( ret = asn1_get_int( p, end, iterations ) ) != 0 )
	return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );

	if( *p != end )
	return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT +
	POLARSSL_ERR_ASN1_LENGTH_MISMATCH );

	return( 0 );
	}

	static int pkcs12_pbe_derive_key_iv( asn1_buf *pbe_params,
	const unsigned char *pwd, size_t pwdlen,
	unsigned char *key, size_t keylen,
	unsigned char *iv, size_t ivlen )
	{
	int ret, iterations;
	asn1_buf salt;
	size_t i;
	unsigned char p, end;
	unsigned char unipwd[258];

	memset(&salt, 0, sizeof(asn1_buf));
	memset(&unipwd, 0, sizeof(unipwd));

	p = pbe_params->p;
	end = p + pbe_params->len;

	if( ( ret = pkcs12_parse_pbe_params( &p, end, &salt, &iterations ) ) != 0 )
	return( ret );

	for(i = 0; i < pwdlen; i++)
	unipwd[i * 2 + 1] = pwd[i];

	if( ( ret = pkcs12_derivation( key, keylen, unipwd, pwdlen * 2 + 2,
	salt.p, salt.len, POLARSSL_MD_SHA1,
	PKCS12_DERIVE_KEY, iterations ) ) != 0 )
	{
	return( ret );
	}

	if( iv == NULL \|\| ivlen == 0 )
	return( 0 );

	if( ( ret = pkcs12_derivation( iv, ivlen, unipwd, pwdlen * 2 + 2,
	salt.p, salt.len, POLARSSL_MD_SHA1,
	PKCS12_DERIVE_IV, iterations ) ) != 0 )
	{
	return( ret );
	}
	return( 0 );
	}

	int pkcs12_pbe_sha1_rc4_128( asn1_buf *pbe_params, int mode,
	const unsigned char *pwd, size_t pwdlen,
	const unsigned char *data, size_t len,
	unsigned char *output )
	{
	#if !defined(POLARSSL_ARC4_C)
	((void) pbe_params);
	((void) mode);
	((void) pwd);
	((void) pwdlen);
	((void) data);
	((void) len);
	((void) output);
	return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
	#else
	int ret;
	unsigned char key[16];
	arc4_context ctx;
	((void) mode);

	if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
	key, 16, NULL, 0 ) ) != 0 )
	{
	return( ret );
	}

	arc4_setup( &ctx, key, 16 );
	if( ( ret = arc4_crypt( &ctx, len, data, output ) ) != 0 )
	return( ret );

	return( 0 );
	#endif /* POLARSSL_ARC4_C */
	}

	int pkcs12_pbe_sha1_des2_ede_cbc( asn1_buf *pbe_params, int mode,
	const unsigned char *pwd, size_t pwdlen,
	const unsigned char *data, size_t len,
	unsigned char *output )
	{
	#if !defined(POLARSSL_DES_C)
	((void) pbe_params);
	((void) mode);
	((void) pwd);
	((void) pwdlen);
	((void) data);
	((void) len);
	((void) output);
	return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
	#else
	int ret;
	unsigned char key[16];
	unsigned char iv[8];
	des3_context ctx;

	if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
	key, 16, iv, 8 ) ) != 0 )
	{
	return( ret );
	}

	if( mode == PKCS12_PBE_ENCRYPT )
	{
	des3_set2key_enc( &ctx, key );
	des3_crypt_cbc( &ctx, DES_ENCRYPT, len, iv, data, output );
	}
	else
	{
	des3_set2key_dec( &ctx, key );
	des3_crypt_cbc( &ctx, DES_DECRYPT, len, iv, data, output );
	}

	return( 0 );
	#endif /* POLARSSL_DES_C */
	}

	int pkcs12_pbe_sha1_des3_ede_cbc( asn1_buf *pbe_params, int mode,
	const unsigned char *pwd, size_t pwdlen,
	const unsigned char *data, size_t len,
	unsigned char *output )
	{
	#if !defined(POLARSSL_DES_C)
	((void) pbe_params);
	((void) mode);
	((void) pwd);
	((void) pwdlen);
	((void) data);
	((void) len);
	((void) output);
	return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
	#else
	int ret;
	unsigned char key[24];
	unsigned char iv[8];
	des3_context ctx;

	if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, pwd, pwdlen,
	key, 24, iv, 8 ) ) != 0 )
	{
	return( ret );
	}

	if( mode == PKCS12_PBE_ENCRYPT )
	{
	des3_set3key_enc( &ctx, key );
	des3_crypt_cbc( &ctx, DES_ENCRYPT, len, iv, data, output );
	}
	else
	{
	des3_set3key_dec( &ctx, key );
	des3_crypt_cbc( &ctx, DES_DECRYPT, len, iv, data, output );
	}

	return( 0 );
	#endif /* POLARSSL_DES_C */
	}

	static void pkcs12_fill_buffer( unsigned char *data, size_t data_len,
	const unsigned char *filler, size_t fill_len )
	{
	unsigned char *p = data;
	size_t use_len;

	while( data_len > 0 )
	{
	use_len = ( data_len > fill_len ) ? fill_len : data_len;
	memcpy( p, filler, use_len );
	p += use_len;
	data_len -= use_len;
	}
	}

	int pkcs12_derivation( unsigned char *data, size_t datalen,
	const unsigned char *pwd, size_t pwdlen,
	const unsigned char *salt, size_t saltlen,
	md_type_t md_type, int id, int iterations )
	{
	int ret, i;
	unsigned int j;

	unsigned char diversifier[128];
	unsigned char salt_block[128], pwd_block[128], hash_block[128];
	unsigned char hash_output[POLARSSL_MD_MAX_SIZE];
	unsigned char *p;
	unsigned char c;

	size_t hlen, use_len, v;

	const md_info_t *md_info;
	md_context_t md_ctx;

	// This version only allows max of 64 bytes of password or salt
	if( datalen > 128 \|\| pwdlen > 64 \|\| saltlen > 64 )
	return( POLARSSL_ERR_PKCS12_BAD_INPUT_DATA );

	md_info = md_info_from_type( md_type );
	if( md_info == NULL )
	return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );

	if ( ( ret = md_init_ctx( &md_ctx, md_info ) ) != 0 )
	return( ret );
	hlen = md_get_size( md_info );

	if( hlen <= 32 )
	v = 64;
	else
	v = 128;

	memset( diversifier, (unsigned char) id, v );

	pkcs12_fill_buffer( salt_block, v, salt, saltlen );
	pkcs12_fill_buffer( pwd_block, v, pwd, pwdlen );

	p = data;
	while( datalen > 0 )
	{
	// Calculate hash( diversifier \|\| salt_block \|\| pwd_block )
	if( ( ret = md_starts( &md_ctx ) ) != 0 )
	return( ret );

	if( ( ret = md_update( &md_ctx, diversifier, v ) ) != 0 )
	return( ret );

	if( ( ret = md_update( &md_ctx, salt_block, v ) ) != 0 )
	return( ret );

	if( ( ret = md_update( &md_ctx, pwd_block, v ) ) != 0 )
	return( ret );

	if( ( ret = md_finish( &md_ctx, hash_output ) ) != 0 )
	return( ret );

	// Perform remaining ( iterations - 1 ) recursive hash calculations
	for( i = 1; i < iterations; i++ )
	{
	if( ( ret = md( md_info, hash_output, hlen, hash_output ) ) != 0 )
	return( ret );
	}

	use_len = ( datalen > hlen ) ? hlen : datalen;
	memcpy( p, hash_output, use_len );
	datalen -= use_len;
	p += use_len;

	if( datalen == 0 )
	break;

	// Concatenating copies of hash_output into hash_block (B)
	pkcs12_fill_buffer( hash_block, v, hash_output, hlen );

	// B += 1
	for( i = v; i > 0; i-- )
	if( ++hash_block[i - 1] != 0 )
	break;

	// salt_block += B
	c = 0;
	for( i = v; i > 0; i-- )
	{
	j = salt_block[i - 1] + hash_block[i - 1] + c;
	c = (unsigned char) (j >> 8);
	salt_block[i - 1] = j & 0xFF;
	}

	// pwd_block += B
	c = 0;
	for( i = v; i > 0; i-- )
	{
	j = pwd_block[i - 1] + hash_block[i - 1] + c;
	c = (unsigned char) (j >> 8);
	pwd_block[i - 1] = j & 0xFF;
	}
	}

	return( 0 );
	}

	#endif /* POLARSSL_PKCS12_C */