The Great Renaming
A simple execution of tmp/invoke-rename.pl
diff --git a/library/aes.c b/library/aes.c
index 4567534..9780e8f 100644
--- a/library/aes.c
+++ b/library/aes.c
@@ -26,37 +26,37 @@
* http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
#include <string.h>
#include "mbedtls/aes.h"
-#if defined(POLARSSL_PADLOCK_C)
+#if defined(MBEDTLS_PADLOCK_C)
#include "mbedtls/padlock.h"
#endif
-#if defined(POLARSSL_AESNI_C)
+#if defined(MBEDTLS_AESNI_C)
#include "mbedtls/aesni.h"
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if !defined(POLARSSL_AES_ALT)
+#if !defined(MBEDTLS_AES_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -83,12 +83,12 @@
}
#endif
-#if defined(POLARSSL_PADLOCK_C) && \
- ( defined(POLARSSL_HAVE_X86) || defined(PADLOCK_ALIGN16) )
+#if defined(MBEDTLS_PADLOCK_C) && \
+ ( defined(MBEDTLS_HAVE_X86) || defined(MBEDTLS_PADLOCK_ALIGN16) )
static int aes_padlock_ace = -1;
#endif
-#if defined(POLARSSL_AES_ROM_TABLES)
+#if defined(MBEDTLS_AES_ROM_TABLES)
/*
* Forward S-box
*/
@@ -353,7 +353,7 @@
0x0000001B, 0x00000036
};
-#else /* POLARSSL_AES_ROM_TABLES */
+#else /* MBEDTLS_AES_ROM_TABLES */
/*
* Forward S-box & tables
@@ -463,31 +463,31 @@
}
}
-#endif /* POLARSSL_AES_ROM_TABLES */
+#endif /* MBEDTLS_AES_ROM_TABLES */
-void aes_init( aes_context *ctx )
+void mbedtls_aes_init( mbedtls_aes_context *ctx )
{
- memset( ctx, 0, sizeof( aes_context ) );
+ memset( ctx, 0, sizeof( mbedtls_aes_context ) );
}
-void aes_free( aes_context *ctx )
+void mbedtls_aes_free( mbedtls_aes_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( aes_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_aes_context ) );
}
/*
* AES key schedule (encryption)
*/
-int aes_setkey_enc( aes_context *ctx, const unsigned char *key,
+int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keysize )
{
unsigned int i;
uint32_t *RK;
-#if !defined(POLARSSL_AES_ROM_TABLES)
+#if !defined(MBEDTLS_AES_ROM_TABLES)
if( aes_init_done == 0 )
{
aes_gen_tables();
@@ -501,22 +501,22 @@
case 128: ctx->nr = 10; break;
case 192: ctx->nr = 12; break;
case 256: ctx->nr = 14; break;
- default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+ default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
-#if defined(POLARSSL_PADLOCK_C) && defined(PADLOCK_ALIGN16)
+#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
- aes_padlock_ace = padlock_supports( PADLOCK_ACE );
+ aes_padlock_ace = mbedtls_padlock_supports( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
- ctx->rk = RK = PADLOCK_ALIGN16( ctx->buf );
+ ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
-#if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
- if( aesni_supports( POLARSSL_AESNI_AES ) )
- return( aesni_setkey_enc( (unsigned char *) ctx->rk, key, keysize ) );
+#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
+ if( mbedtls_aesni_supports( MBEDTLS_AESNI_AES ) )
+ return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keysize ) );
#endif
for( i = 0; i < ( keysize >> 5 ); i++ )
@@ -593,36 +593,36 @@
/*
* AES key schedule (decryption)
*/
-int aes_setkey_dec( aes_context *ctx, const unsigned char *key,
+int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keysize )
{
int i, j, ret;
- aes_context cty;
+ mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
- aes_init( &cty );
+ mbedtls_aes_init( &cty );
-#if defined(POLARSSL_PADLOCK_C) && defined(PADLOCK_ALIGN16)
+#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
- aes_padlock_ace = padlock_supports( PADLOCK_ACE );
+ aes_padlock_ace = mbedtls_padlock_supports( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
- ctx->rk = RK = PADLOCK_ALIGN16( ctx->buf );
+ ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keysize */
- if( ( ret = aes_setkey_enc( &cty, key, keysize ) ) != 0 )
+ if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keysize ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
-#if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
- if( aesni_supports( POLARSSL_AESNI_AES ) )
+#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
+ if( mbedtls_aesni_supports( MBEDTLS_AESNI_AES ) )
{
- aesni_inverse_key( (unsigned char *) ctx->rk,
+ mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
@@ -652,7 +652,7 @@
*RK++ = *SK++;
exit:
- aes_free( &cty );
+ mbedtls_aes_free( &cty );
return( ret );
}
@@ -706,7 +706,7 @@
/*
* AES-ECB block encryption/decryption
*/
-int aes_crypt_ecb( aes_context *ctx,
+int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
@@ -714,15 +714,15 @@
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
-#if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
- if( aesni_supports( POLARSSL_AESNI_AES ) )
- return( aesni_crypt_ecb( ctx, mode, input, output ) );
+#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
+ if( mbedtls_aesni_supports( MBEDTLS_AESNI_AES ) )
+ return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
#endif
-#if defined(POLARSSL_PADLOCK_C) && defined(POLARSSL_HAVE_X86)
+#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
- if( padlock_xcryptecb( ctx, mode, input, output ) == 0 )
+ if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
@@ -738,7 +738,7 @@
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
- if( mode == AES_DECRYPT )
+ if( mode == MBEDTLS_AES_DECRYPT )
{
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
@@ -772,7 +772,7 @@
( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
}
- else /* AES_ENCRYPT */
+ else /* MBEDTLS_AES_ENCRYPT */
{
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
@@ -815,11 +815,11 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* AES-CBC buffer encryption/decryption
*/
-int aes_crypt_cbc( aes_context *ctx,
+int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
@@ -830,12 +830,12 @@
unsigned char temp[16];
if( length % 16 )
- return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
+ return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
-#if defined(POLARSSL_PADLOCK_C) && defined(POLARSSL_HAVE_X86)
+#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
- if( padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
+ if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
@@ -844,12 +844,12 @@
}
#endif
- if( mode == AES_DECRYPT )
+ if( mode == MBEDTLS_AES_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
- aes_crypt_ecb( ctx, mode, input, output );
+ mbedtls_aes_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
@@ -868,7 +868,7 @@
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- aes_crypt_ecb( ctx, mode, output, output );
+ mbedtls_aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
@@ -879,13 +879,13 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* AES-CFB128 buffer encryption/decryption
*/
-int aes_crypt_cfb128( aes_context *ctx,
+int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
@@ -896,12 +896,12 @@
int c;
size_t n = *iv_off;
- if( mode == AES_DECRYPT )
+ if( mode == MBEDTLS_AES_DECRYPT )
{
while( length-- )
{
if( n == 0 )
- aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+ mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
c = *input++;
*output++ = (unsigned char)( c ^ iv[n] );
@@ -915,7 +915,7 @@
while( length-- )
{
if( n == 0 )
- aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+ mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
@@ -931,7 +931,7 @@
/*
* AES-CFB8 buffer encryption/decryption
*/
-int aes_crypt_cfb8( aes_context *ctx,
+int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
@@ -944,14 +944,14 @@
while( length-- )
{
memcpy( ov, iv, 16 );
- aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+ mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
- if( mode == AES_DECRYPT )
+ if( mode == MBEDTLS_AES_DECRYPT )
ov[16] = *input;
c = *output++ = (unsigned char)( iv[0] ^ *input++ );
- if( mode == AES_ENCRYPT )
+ if( mode == MBEDTLS_AES_ENCRYPT )
ov[16] = c;
memcpy( iv, ov + 1, 16 );
@@ -959,13 +959,13 @@
return( 0 );
}
-#endif /*POLARSSL_CIPHER_MODE_CFB */
+#endif /*MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* AES-CTR buffer encryption/decryption
*/
-int aes_crypt_ctr( aes_context *ctx,
+int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
@@ -979,7 +979,7 @@
while( length-- )
{
if( n == 0 ) {
- aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
+ mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );
for( i = 16; i > 0; i-- )
if( ++nonce_counter[i - 1] != 0 )
@@ -995,11 +995,11 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#endif /* !POLARSSL_AES_ALT */
+#endif /* !MBEDTLS_AES_ALT */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* AES test vectors from:
*
@@ -1025,7 +1025,7 @@
0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const unsigned char aes_test_cbc_dec[3][16] =
{
{ 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
@@ -1045,9 +1045,9 @@
{ 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* AES-CFB128 test vectors from:
*
@@ -1111,9 +1111,9 @@
0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }
};
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* AES-CTR test vectors from:
*
@@ -1174,32 +1174,32 @@
static const int aes_test_ctr_len[3] =
{ 16, 32, 36 };
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
/*
* Checkup routine
*/
-int aes_self_test( int verbose )
+int mbedtls_aes_self_test( int verbose )
{
int ret = 0, i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char iv[16];
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[16];
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR) || defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB)
size_t offset;
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
int len;
unsigned char nonce_counter[16];
unsigned char stream_block[16];
#endif
- aes_context ctx;
+ mbedtls_aes_context ctx;
memset( key, 0, 32 );
- aes_init( &ctx );
+ mbedtls_aes_init( &ctx );
/*
* ECB mode
@@ -1210,22 +1210,22 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " AES-ECB-%3d (%s): ", 128 + u * 64,
- ( v == AES_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " AES-ECB-%3d (%s): ", 128 + u * 64,
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( buf, 0, 16 );
- if( v == AES_DECRYPT )
+ if( v == MBEDTLS_AES_DECRYPT )
{
- aes_setkey_dec( &ctx, key, 128 + u * 64 );
+ mbedtls_aes_setkey_dec( &ctx, key, 128 + u * 64 );
for( j = 0; j < 10000; j++ )
- aes_crypt_ecb( &ctx, v, buf, buf );
+ mbedtls_aes_crypt_ecb( &ctx, v, buf, buf );
if( memcmp( buf, aes_test_ecb_dec[u], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1233,15 +1233,15 @@
}
else
{
- aes_setkey_enc( &ctx, key, 128 + u * 64 );
+ mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
for( j = 0; j < 10000; j++ )
- aes_crypt_ecb( &ctx, v, buf, buf );
+ mbedtls_aes_crypt_ecb( &ctx, v, buf, buf );
if( memcmp( buf, aes_test_ecb_enc[u], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1249,13 +1249,13 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
@@ -1265,24 +1265,24 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " AES-CBC-%3d (%s): ", 128 + u * 64,
- ( v == AES_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " AES-CBC-%3d (%s): ", 128 + u * 64,
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( iv , 0, 16 );
memset( prv, 0, 16 );
memset( buf, 0, 16 );
- if( v == AES_DECRYPT )
+ if( v == MBEDTLS_AES_DECRYPT )
{
- aes_setkey_dec( &ctx, key, 128 + u * 64 );
+ mbedtls_aes_setkey_dec( &ctx, key, 128 + u * 64 );
for( j = 0; j < 10000; j++ )
- aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
+ mbedtls_aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
if( memcmp( buf, aes_test_cbc_dec[u], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1290,13 +1290,13 @@
}
else
{
- aes_setkey_enc( &ctx, key, 128 + u * 64 );
+ mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
for( j = 0; j < 10000; j++ )
{
unsigned char tmp[16];
- aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
+ mbedtls_aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
memcpy( tmp, prv, 16 );
memcpy( prv, buf, 16 );
@@ -1306,7 +1306,7 @@
if( memcmp( prv, aes_test_cbc_enc[u], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1314,14 +1314,14 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+ mbedtls_printf( "\n" );
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* CFB128 mode
*/
@@ -1331,24 +1331,24 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " AES-CFB128-%3d (%s): ", 128 + u * 64,
- ( v == AES_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " AES-CFB128-%3d (%s): ", 128 + u * 64,
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, aes_test_cfb128_iv, 16 );
memcpy( key, aes_test_cfb128_key[u], 16 + u * 8 );
offset = 0;
- aes_setkey_enc( &ctx, key, 128 + u * 64 );
+ mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
- if( v == AES_DECRYPT )
+ if( v == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_cfb128_ct[u], 64 );
- aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
+ mbedtls_aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
if( memcmp( buf, aes_test_cfb128_pt, 64 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1357,12 +1357,12 @@
else
{
memcpy( buf, aes_test_cfb128_pt, 64 );
- aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
+ mbedtls_aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
if( memcmp( buf, aes_test_cfb128_ct[u], 64 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1370,14 +1370,14 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+ mbedtls_printf( "\n" );
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* CTR mode
*/
@@ -1387,27 +1387,27 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " AES-CTR-128 (%s): ",
- ( v == AES_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " AES-CTR-128 (%s): ",
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
memcpy( key, aes_test_ctr_key[u], 16 );
offset = 0;
- aes_setkey_enc( &ctx, key, 128 );
+ mbedtls_aes_setkey_enc( &ctx, key, 128 );
- if( v == AES_DECRYPT )
+ if( v == MBEDTLS_AES_DECRYPT )
{
len = aes_test_ctr_len[u];
memcpy( buf, aes_test_ctr_ct[u], len );
- aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
+ mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, aes_test_ctr_pt[u], len ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1418,13 +1418,13 @@
len = aes_test_ctr_len[u];
memcpy( buf, aes_test_ctr_pt[u], len );
- aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
+ mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, aes_test_ctr_ct[u], len ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
@@ -1432,21 +1432,21 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+ mbedtls_printf( "\n" );
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
ret = 0;
exit:
- aes_free( &ctx );
+ mbedtls_aes_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
diff --git a/library/aesni.c b/library/aesni.c
index a6897b2..ff6c71d 100644
--- a/library/aesni.c
+++ b/library/aesni.c
@@ -25,24 +25,24 @@
* [CLMUL-WP] http://software.intel.com/en-us/articles/intel-carry-less-multiplication-instruction-and-its-usage-for-computing-the-gcm-mode/
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_AESNI_C)
+#if defined(MBEDTLS_AESNI_C)
#include "mbedtls/aesni.h"
#include <string.h>
-#if defined(POLARSSL_HAVE_X86_64)
+#if defined(MBEDTLS_HAVE_X86_64)
/*
* AES-NI support detection routine
*/
-int aesni_supports( unsigned int what )
+int mbedtls_aesni_supports( unsigned int what )
{
static int done = 0;
static unsigned int c = 0;
@@ -89,7 +89,7 @@
/*
* AES-NI AES-ECB block en(de)cryption
*/
-int aesni_crypt_ecb( aes_context *ctx,
+int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
@@ -135,7 +135,7 @@
* GCM multiplication: c = a times b in GF(2^128)
* Based on [CLMUL-WP] algorithms 1 (with equation 27) and 5.
*/
-void aesni_gcm_mult( unsigned char c[16],
+void mbedtls_aesni_gcm_mult( unsigned char c[16],
const unsigned char a[16],
const unsigned char b[16] )
{
@@ -246,7 +246,7 @@
/*
* Compute decryption round keys from encryption round keys
*/
-void aesni_inverse_key( unsigned char *invkey,
+void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
@@ -423,7 +423,7 @@
/*
* Main "loop" - Generating one more key than necessary,
- * see definition of aes_context.buf
+ * see definition of mbedtls_aes_context.buf
*/
"2: \n\t"
AESKEYGENA xmm1_xmm2 ",0x01 \n\tcall 1b \n\t"
@@ -441,7 +441,7 @@
/*
* Key expansion, wrapper
*/
-int aesni_setkey_enc( unsigned char *rk,
+int mbedtls_aesni_setkey_enc( unsigned char *rk,
const unsigned char *key,
size_t bits )
{
@@ -450,12 +450,12 @@
case 128: aesni_setkey_enc_128( rk, key ); break;
case 192: aesni_setkey_enc_192( rk, key ); break;
case 256: aesni_setkey_enc_256( rk, key ); break;
- default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+ default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
return( 0 );
}
-#endif /* POLARSSL_HAVE_X86_64 */
+#endif /* MBEDTLS_HAVE_X86_64 */
-#endif /* POLARSSL_AESNI_C */
+#endif /* MBEDTLS_AESNI_C */
diff --git a/library/arc4.c b/library/arc4.c
index e790579..f11b5d6 100644
--- a/library/arc4.c
+++ b/library/arc4.c
@@ -25,51 +25,51 @@
* http://groups.google.com/group/sci.crypt/msg/10a300c9d21afca0
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ARC4_C)
+#if defined(MBEDTLS_ARC4_C)
#include "mbedtls/arc4.h"
#include <string.h>
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if !defined(POLARSSL_ARC4_ALT)
+#if !defined(MBEDTLS_ARC4_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-void arc4_init( arc4_context *ctx )
+void mbedtls_arc4_init( mbedtls_arc4_context *ctx )
{
- memset( ctx, 0, sizeof( arc4_context ) );
+ memset( ctx, 0, sizeof( mbedtls_arc4_context ) );
}
-void arc4_free( arc4_context *ctx )
+void mbedtls_arc4_free( mbedtls_arc4_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( arc4_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_arc4_context ) );
}
/*
* ARC4 key schedule
*/
-void arc4_setup( arc4_context *ctx, const unsigned char *key,
+void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
unsigned int keylen )
{
int i, j, a;
@@ -99,7 +99,7 @@
/*
* ARC4 cipher function
*/
-int arc4_crypt( arc4_context *ctx, size_t length, const unsigned char *input,
+int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
unsigned char *output )
{
int x, y, a, b;
@@ -128,9 +128,9 @@
return( 0 );
}
-#endif /* !POLARSSL_ARC4_ALT */
+#endif /* !MBEDTLS_ARC4_ALT */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* ARC4 tests vectors as posted by Eric Rescorla in sep. 1994:
*
@@ -160,47 +160,47 @@
/*
* Checkup routine
*/
-int arc4_self_test( int verbose )
+int mbedtls_arc4_self_test( int verbose )
{
int i, ret = 0;
unsigned char ibuf[8];
unsigned char obuf[8];
- arc4_context ctx;
+ mbedtls_arc4_context ctx;
- arc4_init( &ctx );
+ mbedtls_arc4_init( &ctx );
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
- polarssl_printf( " ARC4 test #%d: ", i + 1 );
+ mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ibuf, arc4_test_pt[i], 8 );
- arc4_setup( &ctx, arc4_test_key[i], 8 );
- arc4_crypt( &ctx, 8, ibuf, obuf );
+ mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
+ mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );
if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- arc4_free( &ctx );
+ mbedtls_arc4_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_ARC4_C */
+#endif /* MBEDTLS_ARC4_C */
diff --git a/library/asn1parse.c b/library/asn1parse.c
index 202a6ce..a399a7f 100644
--- a/library/asn1parse.c
+++ b/library/asn1parse.c
@@ -20,44 +20,44 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ASN1_PARSE_C)
+#if defined(MBEDTLS_ASN1_PARSE_C)
#include "mbedtls/asn1.h"
#include <string.h>
-#if defined(POLARSSL_BIGNUM_C)
+#if defined(MBEDTLS_BIGNUM_C)
#include "mbedtls/bignum.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
* ASN.1 DER decoding routines
*/
-int asn1_get_len( unsigned char **p,
+int mbedtls_asn1_get_len( unsigned char **p,
const unsigned char *end,
size_t *len )
{
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( ( **p & 0x80 ) == 0 )
*len = *(*p)++;
@@ -67,7 +67,7 @@
{
case 1:
if( ( end - *p ) < 2 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = (*p)[1];
(*p) += 2;
@@ -75,7 +75,7 @@
case 2:
if( ( end - *p ) < 3 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
(*p) += 3;
@@ -83,7 +83,7 @@
case 3:
if( ( end - *p ) < 4 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 16 ) |
( (size_t)(*p)[2] << 8 ) | (*p)[3];
@@ -92,7 +92,7 @@
case 4:
if( ( end - *p ) < 5 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
( (size_t)(*p)[3] << 8 ) | (*p)[4];
@@ -100,43 +100,43 @@
break;
default:
- return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
}
}
if( *len > (size_t) ( end - *p ) )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
return( 0 );
}
-int asn1_get_tag( unsigned char **p,
+int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
- return( POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
- return( asn1_get_len( p, end, len ) );
+ return( mbedtls_asn1_get_len( p, end, len ) );
}
-int asn1_get_bool( unsigned char **p,
+int mbedtls_asn1_get_bool( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len, ASN1_BOOLEAN ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
return( ret );
if( len != 1 )
- return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = ( **p != 0 ) ? 1 : 0;
(*p)++;
@@ -144,18 +144,18 @@
return( 0 );
}
-int asn1_get_int( unsigned char **p,
+int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
if( len > sizeof( int ) || ( **p & 0x80 ) != 0 )
- return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = 0;
@@ -168,43 +168,43 @@
return( 0 );
}
-#if defined(POLARSSL_BIGNUM_C)
-int asn1_get_mpi( unsigned char **p,
+#if defined(MBEDTLS_BIGNUM_C)
+int mbedtls_asn1_get_mpi( unsigned char **p,
const unsigned char *end,
- mpi *X )
+ mbedtls_mpi *X )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
- ret = mpi_read_binary( X, *p, len );
+ ret = mbedtls_mpi_read_binary( X, *p, len );
*p += len;
return( ret );
}
-#endif /* POLARSSL_BIGNUM_C */
+#endif /* MBEDTLS_BIGNUM_C */
-int asn1_get_bitstring( unsigned char **p, const unsigned char *end,
- asn1_bitstring *bs)
+int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
+ mbedtls_asn1_bitstring *bs)
{
int ret;
/* Certificate type is a single byte bitstring */
- if( ( ret = asn1_get_tag( p, end, &bs->len, ASN1_BIT_STRING ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
return( ret );
/* Check length, subtract one for actual bit string length */
if( bs->len < 1 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
bs->len -= 1;
/* Get number of unused bits, ensure unused bits <= 7 */
bs->unused_bits = **p;
if( bs->unused_bits > 7 )
- return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
(*p)++;
/* Get actual bitstring */
@@ -212,7 +212,7 @@
*p += bs->len;
if( *p != end )
- return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -220,16 +220,16 @@
/*
* Get a bit string without unused bits
*/
-int asn1_get_bitstring_null( unsigned char **p, const unsigned char *end,
+int mbedtls_asn1_get_bitstring_null( unsigned char **p, const unsigned char *end,
size_t *len )
{
int ret;
- if( ( ret = asn1_get_tag( p, end, len, ASN1_BIT_STRING ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
return( ret );
if( (*len)-- < 2 || *(*p)++ != 0 )
- return( POLARSSL_ERR_ASN1_INVALID_DATA );
+ return( MBEDTLS_ERR_ASN1_INVALID_DATA );
return( 0 );
}
@@ -239,29 +239,29 @@
/*
* Parses and splits an ASN.1 "SEQUENCE OF <tag>"
*/
-int asn1_get_sequence_of( unsigned char **p,
+int mbedtls_asn1_get_sequence_of( unsigned char **p,
const unsigned char *end,
- asn1_sequence *cur,
+ mbedtls_asn1_sequence *cur,
int tag)
{
int ret;
size_t len;
- asn1_buf *buf;
+ mbedtls_asn1_buf *buf;
/* Get main sequence tag */
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
if( *p + len != end )
- return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
buf = &(cur->buf);
buf->tag = **p;
- if( ( ret = asn1_get_tag( p, end, &buf->len, tag ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &buf->len, tag ) ) != 0 )
return( ret );
buf->p = *p;
@@ -270,12 +270,12 @@
/* Allocate and assign next pointer */
if( *p < end )
{
- cur->next = polarssl_malloc( sizeof( asn1_sequence ) );
+ cur->next = mbedtls_malloc( sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
- return( POLARSSL_ERR_ASN1_MALLOC_FAILED );
+ return( MBEDTLS_ERR_ASN1_MALLOC_FAILED );
- memset( cur->next, 0, sizeof( asn1_sequence ) );
+ memset( cur->next, 0, sizeof( mbedtls_asn1_sequence ) );
cur = cur->next;
}
@@ -285,29 +285,29 @@
cur->next = NULL;
if( *p != end )
- return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-int asn1_get_alg( unsigned char **p,
+int mbedtls_asn1_get_alg( unsigned char **p,
const unsigned char *end,
- asn1_buf *alg, asn1_buf *params )
+ mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
alg->tag = **p;
end = *p + len;
- if( ( ret = asn1_get_tag( p, end, &alg->len, ASN1_OID ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &alg->len, MBEDTLS_ASN1_OID ) ) != 0 )
return( ret );
alg->p = *p;
@@ -315,67 +315,67 @@
if( *p == end )
{
- polarssl_zeroize( params, sizeof(asn1_buf) );
+ mbedtls_zeroize( params, sizeof(mbedtls_asn1_buf) );
return( 0 );
}
params->tag = **p;
(*p)++;
- if( ( ret = asn1_get_len( p, end, ¶ms->len ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_len( p, end, ¶ms->len ) ) != 0 )
return( ret );
params->p = *p;
*p += params->len;
if( *p != end )
- return( POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-int asn1_get_alg_null( unsigned char **p,
+int mbedtls_asn1_get_alg_null( unsigned char **p,
const unsigned char *end,
- asn1_buf *alg )
+ mbedtls_asn1_buf *alg )
{
int ret;
- asn1_buf params;
+ mbedtls_asn1_buf params;
- memset( ¶ms, 0, sizeof(asn1_buf) );
+ memset( ¶ms, 0, sizeof(mbedtls_asn1_buf) );
- if( ( ret = asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
return( ret );
- if( ( params.tag != ASN1_NULL && params.tag != 0 ) || params.len != 0 )
- return( POLARSSL_ERR_ASN1_INVALID_DATA );
+ if( ( params.tag != MBEDTLS_ASN1_NULL && params.tag != 0 ) || params.len != 0 )
+ return( MBEDTLS_ERR_ASN1_INVALID_DATA );
return( 0 );
}
-void asn1_free_named_data( asn1_named_data *cur )
+void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *cur )
{
if( cur == NULL )
return;
- polarssl_free( cur->oid.p );
- polarssl_free( cur->val.p );
+ mbedtls_free( cur->oid.p );
+ mbedtls_free( cur->val.p );
- polarssl_zeroize( cur, sizeof( asn1_named_data ) );
+ mbedtls_zeroize( cur, sizeof( mbedtls_asn1_named_data ) );
}
-void asn1_free_named_data_list( asn1_named_data **head )
+void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head )
{
- asn1_named_data *cur;
+ mbedtls_asn1_named_data *cur;
while( ( cur = *head ) != NULL )
{
*head = cur->next;
- asn1_free_named_data( cur );
- polarssl_free( cur );
+ mbedtls_asn1_free_named_data( cur );
+ mbedtls_free( cur );
}
}
-asn1_named_data *asn1_find_named_data( asn1_named_data *list,
+mbedtls_asn1_named_data *mbedtls_asn1_find_named_data( mbedtls_asn1_named_data *list,
const char *oid, size_t len )
{
while( list != NULL )
@@ -392,4 +392,4 @@
return( list );
}
-#endif /* POLARSSL_ASN1_PARSE_C */
+#endif /* MBEDTLS_ASN1_PARSE_C */
diff --git a/library/asn1write.c b/library/asn1write.c
index a5a35f6..5219fcf 100644
--- a/library/asn1write.c
+++ b/library/asn1write.c
@@ -20,32 +20,32 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ASN1_WRITE_C)
+#if defined(MBEDTLS_ASN1_WRITE_C)
#include "mbedtls/asn1write.h"
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-int asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
+int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
@@ -54,7 +54,7 @@
if( len <= 0xFF )
{
if( *p - start < 2 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
*--(*p) = 0x81;
@@ -62,7 +62,7 @@
}
if( *p - start < 3 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
// We assume we never have lengths larger than 65535 bytes
//
@@ -73,23 +73,23 @@
return( 3 );
}
-int asn1_write_tag( unsigned char **p, unsigned char *start, unsigned char tag )
+int mbedtls_asn1_write_tag( unsigned char **p, unsigned char *start, unsigned char tag )
{
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = tag;
return( 1 );
}
-int asn1_write_raw_buffer( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_raw_buffer( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
size_t len = 0;
if( *p - start < (int) size )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size;
(*p) -= len;
@@ -98,21 +98,21 @@
return( (int) len );
}
-#if defined(POLARSSL_BIGNUM_C)
-int asn1_write_mpi( unsigned char **p, unsigned char *start, const mpi *X )
+#if defined(MBEDTLS_BIGNUM_C)
+int mbedtls_asn1_write_mpi( unsigned char **p, unsigned char *start, const mbedtls_mpi *X )
{
int ret;
size_t len = 0;
// Write the MPI
//
- len = mpi_size( X );
+ len = mbedtls_mpi_size( X );
if( *p - start < (int) len )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
(*p) -= len;
- MPI_CHK( mpi_write_binary( X, *p, len ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( X, *p, len ) );
// DER format assumes 2s complement for numbers, so the leftmost bit
// should be 0 for positive numbers and 1 for negative numbers.
@@ -120,50 +120,50 @@
if( X->s ==1 && **p & 0x80 )
{
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = 0x00;
len += 1;
}
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_INTEGER ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_INTEGER ) );
ret = (int) len;
cleanup:
return( ret );
}
-#endif /* POLARSSL_BIGNUM_C */
+#endif /* MBEDTLS_BIGNUM_C */
-int asn1_write_null( unsigned char **p, unsigned char *start )
+int mbedtls_asn1_write_null( unsigned char **p, unsigned char *start )
{
int ret;
size_t len = 0;
// Write NULL
//
- ASN1_CHK_ADD( len, asn1_write_len( p, start, 0) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_NULL ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, 0) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_NULL ) );
return( (int) len );
}
-int asn1_write_oid( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_oid( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) oid, oid_len ) );
- ASN1_CHK_ADD( len , asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len , asn1_write_tag( p, start, ASN1_OID ) );
+ MBEDTLS_ASN1_CHK_ADD( len , mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len , mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OID ) );
return( (int) len );
}
-int asn1_write_algorithm_identifier( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_algorithm_identifier( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len,
size_t par_len )
{
@@ -171,37 +171,37 @@
size_t len = 0;
if( par_len == 0 )
- ASN1_CHK_ADD( len, asn1_write_null( p, start ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_null( p, start ) );
else
len += par_len;
- ASN1_CHK_ADD( len, asn1_write_oid( p, start, oid, oid_len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( p, start, oid, oid_len ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
-int asn1_write_bool( unsigned char **p, unsigned char *start, int boolean )
+int mbedtls_asn1_write_bool( unsigned char **p, unsigned char *start, int boolean )
{
int ret;
size_t len = 0;
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (boolean) ? 1 : 0;
len++;
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_BOOLEAN ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BOOLEAN ) );
return( (int) len );
}
-int asn1_write_int( unsigned char **p, unsigned char *start, int val )
+int mbedtls_asn1_write_int( unsigned char **p, unsigned char *start, int val )
{
int ret;
size_t len = 0;
@@ -211,7 +211,7 @@
// should be 0 for positive numbers and 1 for negative numbers.
//
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len += 1;
*--(*p) = val;
@@ -219,49 +219,49 @@
if( val > 0 && **p & 0x80 )
{
if( *p - start < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = 0x00;
len += 1;
}
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_INTEGER ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_INTEGER ) );
return( (int) len );
}
-int asn1_write_printable_string( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_printable_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_PRINTABLE_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_PRINTABLE_STRING ) );
return( (int) len );
}
-int asn1_write_ia5_string( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_ia5_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_IA5_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_IA5_STRING ) );
return( (int) len );
}
-int asn1_write_bitstring( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_bitstring( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t bits )
{
int ret;
@@ -272,7 +272,7 @@
// Calculate byte length
//
if( *p - start < (int) size + 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size + 1;
(*p) -= size;
@@ -282,58 +282,58 @@
//
*--(*p) = (unsigned char) (size * 8 - bits);
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_BIT_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BIT_STRING ) );
return( (int) len );
}
-int asn1_write_octet_string( unsigned char **p, unsigned char *start,
+int mbedtls_asn1_write_octet_string( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start, buf, size ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, buf, size ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_OCTET_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OCTET_STRING ) );
return( (int) len );
}
-asn1_named_data *asn1_store_named_data( asn1_named_data **head,
+mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **head,
const char *oid, size_t oid_len,
const unsigned char *val,
size_t val_len )
{
- asn1_named_data *cur;
+ mbedtls_asn1_named_data *cur;
- if( ( cur = asn1_find_named_data( *head, oid, oid_len ) ) == NULL )
+ if( ( cur = mbedtls_asn1_find_named_data( *head, oid, oid_len ) ) == NULL )
{
// Add new entry if not present yet based on OID
//
- if( ( cur = polarssl_malloc( sizeof(asn1_named_data) ) ) == NULL )
+ if( ( cur = mbedtls_malloc( sizeof(mbedtls_asn1_named_data) ) ) == NULL )
return( NULL );
- memset( cur, 0, sizeof(asn1_named_data) );
+ memset( cur, 0, sizeof(mbedtls_asn1_named_data) );
cur->oid.len = oid_len;
- cur->oid.p = polarssl_malloc( oid_len );
+ cur->oid.p = mbedtls_malloc( oid_len );
if( cur->oid.p == NULL )
{
- polarssl_free( cur );
+ mbedtls_free( cur );
return( NULL );
}
memcpy( cur->oid.p, oid, oid_len );
cur->val.len = val_len;
- cur->val.p = polarssl_malloc( val_len );
+ cur->val.p = mbedtls_malloc( val_len );
if( cur->val.p == NULL )
{
- polarssl_free( cur->oid.p );
- polarssl_free( cur );
+ mbedtls_free( cur->oid.p );
+ mbedtls_free( cur );
return( NULL );
}
@@ -344,15 +344,15 @@
{
// Enlarge existing value buffer if needed
//
- polarssl_free( cur->val.p );
+ mbedtls_free( cur->val.p );
cur->val.p = NULL;
cur->val.len = val_len;
- cur->val.p = polarssl_malloc( val_len );
+ cur->val.p = mbedtls_malloc( val_len );
if( cur->val.p == NULL )
{
- polarssl_free( cur->oid.p );
- polarssl_free( cur );
+ mbedtls_free( cur->oid.p );
+ mbedtls_free( cur );
return( NULL );
}
}
@@ -362,4 +362,4 @@
return( cur );
}
-#endif /* POLARSSL_ASN1_WRITE_C */
+#endif /* MBEDTLS_ASN1_WRITE_C */
diff --git a/library/base64.c b/library/base64.c
index 5af79df..e0a6f18 100644
--- a/library/base64.c
+++ b/library/base64.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_BASE64_C)
+#if defined(MBEDTLS_BASE64_C)
#include "mbedtls/base64.h"
@@ -37,15 +37,15 @@
#include <inttypes.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
static const unsigned char base64_enc_map[64] =
{
@@ -78,7 +78,7 @@
/*
* Encode a buffer into base64 format
*/
-int base64_encode( unsigned char *dst, size_t *dlen,
+int mbedtls_base64_encode( unsigned char *dst, size_t *dlen,
const unsigned char *src, size_t slen )
{
size_t i, n;
@@ -103,7 +103,7 @@
if( *dlen < n + 1 )
{
*dlen = n + 1;
- return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
}
n = ( slen / 3 ) * 3;
@@ -144,7 +144,7 @@
/*
* Decode a base64-formatted buffer
*/
-int base64_decode( unsigned char *dst, size_t *dlen,
+int mbedtls_base64_decode( unsigned char *dst, size_t *dlen,
const unsigned char *src, size_t slen )
{
size_t i, n;
@@ -175,16 +175,16 @@
/* Space inside a line is an error */
if( x != 0 )
- return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+ return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
if( src[i] == '=' && ++j > 2 )
- return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+ return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
if( src[i] > 127 || base64_dec_map[src[i]] == 127 )
- return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+ return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
if( base64_dec_map[src[i]] < 64 && j != 0 )
- return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+ return( MBEDTLS_ERR_BASE64_INVALID_CHARACTER );
n++;
}
@@ -198,7 +198,7 @@
if( dst == NULL || *dlen < n )
{
*dlen = n;
- return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
}
for( j = 3, n = x = 0, p = dst; i > 0; i--, src++ )
@@ -223,7 +223,7 @@
return( 0 );
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
static const unsigned char base64_test_dec[64] =
{
@@ -244,48 +244,48 @@
/*
* Checkup routine
*/
-int base64_self_test( int verbose )
+int mbedtls_base64_self_test( int verbose )
{
size_t len;
const unsigned char *src;
unsigned char buffer[128];
if( verbose != 0 )
- polarssl_printf( " Base64 encoding test: " );
+ mbedtls_printf( " Base64 encoding test: " );
len = sizeof( buffer );
src = base64_test_dec;
- if( base64_encode( buffer, &len, src, 64 ) != 0 ||
+ if( mbedtls_base64_encode( buffer, &len, src, 64 ) != 0 ||
memcmp( base64_test_enc, buffer, 88 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n Base64 decoding test: " );
+ mbedtls_printf( "passed\n Base64 decoding test: " );
len = sizeof( buffer );
src = base64_test_enc;
- if( base64_decode( buffer, &len, src, 88 ) != 0 ||
+ if( mbedtls_base64_decode( buffer, &len, src, 88 ) != 0 ||
memcmp( base64_test_dec, buffer, 64 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n\n" );
+ mbedtls_printf( "passed\n\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_BASE64_C */
+#endif /* MBEDTLS_BASE64_C */
diff --git a/library/bignum.c b/library/bignum.c
index 8a751a3..45f9667 100644
--- a/library/bignum.c
+++ b/library/bignum.c
@@ -23,39 +23,39 @@
* This MPI implementation is based on:
*
* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
- * http://www.stillhq.com/extracted/gnupg-api/mpi/
+ * http://www.stillhq.com/extracted/gnupg-api/mbedtls_mpi/
* http://math.libtomcrypt.com/files/tommath.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_BIGNUM_C)
+#if defined(MBEDTLS_BIGNUM_C)
#include "mbedtls/bignum.h"
#include "mbedtls/bn_mul.h"
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
#include <stdlib.h>
-#define polarssl_printf printf
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_printf printf
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#define ciL (sizeof(t_uint)) /* chars in limb */
+#define ciL (sizeof(mbedtls_mpi_uint)) /* chars in limb */
#define biL (ciL << 3) /* bits in limb */
#define biH (ciL << 2) /* half limb size */
@@ -68,7 +68,7 @@
/*
* Initialize one MPI
*/
-void mpi_init( mpi *X )
+void mbedtls_mpi_init( mbedtls_mpi *X )
{
if( X == NULL )
return;
@@ -81,15 +81,15 @@
/*
* Unallocate one MPI
*/
-void mpi_free( mpi *X )
+void mbedtls_mpi_free( mbedtls_mpi *X )
{
if( X == NULL )
return;
if( X->p != NULL )
{
- polarssl_zeroize( X->p, X->n * ciL );
- polarssl_free( X->p );
+ mbedtls_zeroize( X->p, X->n * ciL );
+ mbedtls_free( X->p );
}
X->s = 1;
@@ -100,25 +100,25 @@
/*
* Enlarge to the specified number of limbs
*/
-int mpi_grow( mpi *X, size_t nblimbs )
+int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs )
{
- t_uint *p;
+ mbedtls_mpi_uint *p;
- if( nblimbs > POLARSSL_MPI_MAX_LIMBS )
- return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+ if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
+ return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
if( X->n < nblimbs )
{
- if( ( p = polarssl_malloc( nblimbs * ciL ) ) == NULL )
- return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+ if( ( p = mbedtls_malloc( nblimbs * ciL ) ) == NULL )
+ return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
memset( p, 0, nblimbs * ciL );
if( X->p != NULL )
{
memcpy( p, X->p, X->n * ciL );
- polarssl_zeroize( X->p, X->n * ciL );
- polarssl_free( X->p );
+ mbedtls_zeroize( X->p, X->n * ciL );
+ mbedtls_free( X->p );
}
X->n = nblimbs;
@@ -132,14 +132,14 @@
* Resize down as much as possible,
* while keeping at least the specified number of limbs
*/
-int mpi_shrink( mpi *X, size_t nblimbs )
+int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs )
{
- t_uint *p;
+ mbedtls_mpi_uint *p;
size_t i;
/* Actually resize up in this case */
if( X->n <= nblimbs )
- return( mpi_grow( X, nblimbs ) );
+ return( mbedtls_mpi_grow( X, nblimbs ) );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
@@ -149,16 +149,16 @@
if( i < nblimbs )
i = nblimbs;
- if( ( p = polarssl_malloc( i * ciL ) ) == NULL )
- return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+ if( ( p = mbedtls_malloc( i * ciL ) ) == NULL )
+ return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
memset( p, 0, i * ciL );
if( X->p != NULL )
{
memcpy( p, X->p, i * ciL );
- polarssl_zeroize( X->p, X->n * ciL );
- polarssl_free( X->p );
+ mbedtls_zeroize( X->p, X->n * ciL );
+ mbedtls_free( X->p );
}
X->n = i;
@@ -170,7 +170,7 @@
/*
* Copy the contents of Y into X
*/
-int mpi_copy( mpi *X, const mpi *Y )
+int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y )
{
int ret;
size_t i;
@@ -180,7 +180,7 @@
if( Y->p == NULL )
{
- mpi_free( X );
+ mbedtls_mpi_free( X );
return( 0 );
}
@@ -191,7 +191,7 @@
X->s = Y->s;
- MPI_CHK( mpi_grow( X, i ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i ) );
memset( X->p, 0, X->n * ciL );
memcpy( X->p, Y->p, i * ciL );
@@ -204,13 +204,13 @@
/*
* Swap the contents of X and Y
*/
-void mpi_swap( mpi *X, mpi *Y )
+void mbedtls_mpi_swap( mbedtls_mpi *X, mbedtls_mpi *Y )
{
- mpi T;
+ mbedtls_mpi T;
- memcpy( &T, X, sizeof( mpi ) );
- memcpy( X, Y, sizeof( mpi ) );
- memcpy( Y, &T, sizeof( mpi ) );
+ memcpy( &T, X, sizeof( mbedtls_mpi ) );
+ memcpy( X, Y, sizeof( mbedtls_mpi ) );
+ memcpy( Y, &T, sizeof( mbedtls_mpi ) );
}
/*
@@ -218,7 +218,7 @@
* about whether the assignment was made or not.
* (Leaking information about the respective sizes of X and Y is ok however.)
*/
-int mpi_safe_cond_assign( mpi *X, const mpi *Y, unsigned char assign )
+int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X, const mbedtls_mpi *Y, unsigned char assign )
{
int ret = 0;
size_t i;
@@ -226,7 +226,7 @@
/* make sure assign is 0 or 1 */
assign = ( assign != 0 );
- MPI_CHK( mpi_grow( X, Y->n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
X->s = X->s * ( 1 - assign ) + Y->s * assign;
@@ -246,11 +246,11 @@
* Here it is not ok to simply swap the pointers, which whould lead to
* different memory access patterns when X and Y are used afterwards.
*/
-int mpi_safe_cond_swap( mpi *X, mpi *Y, unsigned char swap )
+int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char swap )
{
int ret, s;
size_t i;
- t_uint tmp;
+ mbedtls_mpi_uint tmp;
if( X == Y )
return( 0 );
@@ -258,8 +258,8 @@
/* make sure swap is 0 or 1 */
swap = ( swap != 0 );
- MPI_CHK( mpi_grow( X, Y->n ) );
- MPI_CHK( mpi_grow( Y, X->n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( Y, X->n ) );
s = X->s;
X->s = X->s * ( 1 - swap ) + Y->s * swap;
@@ -280,11 +280,11 @@
/*
* Set value from integer
*/
-int mpi_lset( mpi *X, t_sint z )
+int mbedtls_mpi_lset( mbedtls_mpi *X, mbedtls_mpi_sint z )
{
int ret;
- MPI_CHK( mpi_grow( X, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, 1 ) );
memset( X->p, 0, X->n * ciL );
X->p[0] = ( z < 0 ) ? -z : z;
@@ -298,7 +298,7 @@
/*
* Get a specific bit
*/
-int mpi_get_bit( const mpi *X, size_t pos )
+int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos )
{
if( X->n * biL <= pos )
return( 0 );
@@ -309,25 +309,25 @@
/*
* Set a bit to a specific value of 0 or 1
*/
-int mpi_set_bit( mpi *X, size_t pos, unsigned char val )
+int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
if( val != 0 && val != 1 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0 )
return( 0 );
- MPI_CHK( mpi_grow( X, off + 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, off + 1 ) );
}
- X->p[off] &= ~( (t_uint) 0x01 << idx );
- X->p[off] |= (t_uint) val << idx;
+ X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx );
+ X->p[off] |= (mbedtls_mpi_uint) val << idx;
cleanup:
@@ -337,7 +337,7 @@
/*
* Return the number of least significant bits
*/
-size_t mpi_lsb( const mpi *X )
+size_t mbedtls_mpi_lsb( const mbedtls_mpi *X )
{
size_t i, j, count = 0;
@@ -352,7 +352,7 @@
/*
* Return the number of most significant bits
*/
-size_t mpi_msb( const mpi *X )
+size_t mbedtls_mpi_msb( const mbedtls_mpi *X )
{
size_t i, j;
@@ -370,15 +370,15 @@
/*
* Return the total size in bytes
*/
-size_t mpi_size( const mpi *X )
+size_t mbedtls_mpi_size( const mbedtls_mpi *X )
{
- return( ( mpi_msb( X ) + 7 ) >> 3 );
+ return( ( mbedtls_mpi_msb( X ) + 7 ) >> 3 );
}
/*
* Convert an ASCII character to digit value
*/
-static int mpi_get_digit( t_uint *d, int radix, char c )
+static int mpi_get_digit( mbedtls_mpi_uint *d, int radix, char c )
{
*d = 255;
@@ -386,8 +386,8 @@
if( c >= 0x41 && c <= 0x46 ) *d = c - 0x37;
if( c >= 0x61 && c <= 0x66 ) *d = c - 0x57;
- if( *d >= (t_uint) radix )
- return( POLARSSL_ERR_MPI_INVALID_CHARACTER );
+ if( *d >= (mbedtls_mpi_uint) radix )
+ return( MBEDTLS_ERR_MPI_INVALID_CHARACTER );
return( 0 );
}
@@ -395,17 +395,17 @@
/*
* Import from an ASCII string
*/
-int mpi_read_string( mpi *X, int radix, const char *s )
+int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
{
int ret;
size_t i, j, slen, n;
- t_uint d;
- mpi T;
+ mbedtls_mpi_uint d;
+ mbedtls_mpi T;
if( radix < 2 || radix > 16 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- mpi_init( &T );
+ mbedtls_mpi_init( &T );
slen = strlen( s );
@@ -413,8 +413,8 @@
{
n = BITS_TO_LIMBS( slen << 2 );
- MPI_CHK( mpi_grow( X, n ) );
- MPI_CHK( mpi_lset( X, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = slen, j = 0; i > 0; i--, j++ )
{
@@ -424,13 +424,13 @@
break;
}
- MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
+ MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );
}
}
else
{
- MPI_CHK( mpi_lset( X, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = 0; i < slen; i++ )
{
@@ -440,23 +440,23 @@
continue;
}
- MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
- MPI_CHK( mpi_mul_int( &T, X, radix ) );
+ MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) );
if( X->s == 1 )
{
- MPI_CHK( mpi_add_int( X, &T, d ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) );
}
else
{
- MPI_CHK( mpi_sub_int( X, &T, d ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( X, &T, d ) );
}
}
}
cleanup:
- mpi_free( &T );
+ mbedtls_mpi_free( &T );
return( ret );
}
@@ -464,19 +464,19 @@
/*
* Helper to write the digits high-order first
*/
-static int mpi_write_hlp( mpi *X, int radix, char **p )
+static int mpi_write_hlp( mbedtls_mpi *X, int radix, char **p )
{
int ret;
- t_uint r;
+ mbedtls_mpi_uint r;
if( radix < 2 || radix > 16 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- MPI_CHK( mpi_mod_int( &r, X, radix ) );
- MPI_CHK( mpi_div_int( X, NULL, X, radix ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
- if( mpi_cmp_int( X, 0 ) != 0 )
- MPI_CHK( mpi_write_hlp( X, radix, p ) );
+ if( mbedtls_mpi_cmp_int( X, 0 ) != 0 )
+ MBEDTLS_MPI_CHK( mpi_write_hlp( X, radix, p ) );
if( r < 10 )
*(*p)++ = (char)( r + 0x30 );
@@ -491,17 +491,17 @@
/*
* Export into an ASCII string
*/
-int mpi_write_string( const mpi *X, int radix, char *s, size_t *slen )
+int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix, char *s, size_t *slen )
{
int ret = 0;
size_t n;
char *p;
- mpi T;
+ mbedtls_mpi T;
if( radix < 2 || radix > 16 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- n = mpi_msb( X );
+ n = mbedtls_mpi_msb( X );
if( radix >= 4 ) n >>= 1;
if( radix >= 16 ) n >>= 1;
n += 3;
@@ -509,11 +509,11 @@
if( *slen < n )
{
*slen = n;
- return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
p = s;
- mpi_init( &T );
+ mbedtls_mpi_init( &T );
if( X->s == -1 )
*p++ = '-';
@@ -540,12 +540,12 @@
}
else
{
- MPI_CHK( mpi_copy( &T, X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );
if( T.s == -1 )
T.s = 1;
- MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
+ MBEDTLS_MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
}
*p++ = '\0';
@@ -553,33 +553,33 @@
cleanup:
- mpi_free( &T );
+ mbedtls_mpi_free( &T );
return( ret );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* Read X from an opened file
*/
-int mpi_read_file( mpi *X, int radix, FILE *fin )
+int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin )
{
- t_uint d;
+ mbedtls_mpi_uint d;
size_t slen;
char *p;
/*
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
- char s[ POLARSSL_MPI_RW_BUFFER_SIZE ];
+ char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
memset( s, 0, sizeof( s ) );
if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
- return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
slen = strlen( s );
if( slen == sizeof( s ) - 2 )
- return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
if( s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
if( s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
@@ -589,13 +589,13 @@
if( mpi_get_digit( &d, radix, *p ) != 0 )
break;
- return( mpi_read_string( X, radix, p + 1 ) );
+ return( mbedtls_mpi_read_string( X, radix, p + 1 ) );
}
/*
* Write X into an opened file (or stdout if fout == NULL)
*/
-int mpi_write_file( const char *p, const mpi *X, int radix, FILE *fout )
+int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X, int radix, FILE *fout )
{
int ret;
size_t n, slen, plen;
@@ -603,13 +603,13 @@
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
- char s[ POLARSSL_MPI_RW_BUFFER_SIZE ];
+ char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
n = sizeof( s );
memset( s, 0, n );
n -= 2;
- MPI_CHK( mpi_write_string( X, radix, s, (size_t *) &n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_string( X, radix, s, (size_t *) &n ) );
if( p == NULL ) p = "";
@@ -622,21 +622,21 @@
{
if( fwrite( p, 1, plen, fout ) != plen ||
fwrite( s, 1, slen, fout ) != slen )
- return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
}
else
- polarssl_printf( "%s%s", p, s );
+ mbedtls_printf( "%s%s", p, s );
cleanup:
return( ret );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
/*
* Import X from unsigned binary data, big endian
*/
-int mpi_read_binary( mpi *X, const unsigned char *buf, size_t buflen )
+int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf, size_t buflen )
{
int ret;
size_t i, j, n;
@@ -645,11 +645,11 @@
if( buf[n] != 0 )
break;
- MPI_CHK( mpi_grow( X, CHARS_TO_LIMBS( buflen - n ) ) );
- MPI_CHK( mpi_lset( X, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, CHARS_TO_LIMBS( buflen - n ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = buflen, j = 0; i > n; i--, j++ )
- X->p[j / ciL] |= ((t_uint) buf[i - 1]) << ((j % ciL) << 3);
+ X->p[j / ciL] |= ((mbedtls_mpi_uint) buf[i - 1]) << ((j % ciL) << 3);
cleanup:
@@ -659,14 +659,14 @@
/*
* Export X into unsigned binary data, big endian
*/
-int mpi_write_binary( const mpi *X, unsigned char *buf, size_t buflen )
+int mbedtls_mpi_write_binary( const mbedtls_mpi *X, unsigned char *buf, size_t buflen )
{
size_t i, j, n;
- n = mpi_size( X );
+ n = mbedtls_mpi_size( X );
if( buflen < n )
- return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
memset( buf, 0, buflen );
@@ -679,19 +679,19 @@
/*
* Left-shift: X <<= count
*/
-int mpi_shift_l( mpi *X, size_t count )
+int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count )
{
int ret;
size_t i, v0, t1;
- t_uint r0 = 0, r1;
+ mbedtls_mpi_uint r0 = 0, r1;
v0 = count / (biL );
t1 = count & (biL - 1);
- i = mpi_msb( X ) + count;
+ i = mbedtls_mpi_msb( X ) + count;
if( X->n * biL < i )
- MPI_CHK( mpi_grow( X, BITS_TO_LIMBS( i ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, BITS_TO_LIMBS( i ) ) );
ret = 0;
@@ -729,16 +729,16 @@
/*
* Right-shift: X >>= count
*/
-int mpi_shift_r( mpi *X, size_t count )
+int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count )
{
size_t i, v0, v1;
- t_uint r0 = 0, r1;
+ mbedtls_mpi_uint r0 = 0, r1;
v0 = count / biL;
v1 = count & (biL - 1);
if( v0 > X->n || ( v0 == X->n && v1 > 0 ) )
- return mpi_lset( X, 0 );
+ return mbedtls_mpi_lset( X, 0 );
/*
* shift by count / limb_size
@@ -772,7 +772,7 @@
/*
* Compare unsigned values
*/
-int mpi_cmp_abs( const mpi *X, const mpi *Y )
+int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
@@ -802,7 +802,7 @@
/*
* Compare signed values
*/
-int mpi_cmp_mpi( const mpi *X, const mpi *Y )
+int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
@@ -835,35 +835,35 @@
/*
* Compare signed values
*/
-int mpi_cmp_int( const mpi *X, t_sint z )
+int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z )
{
- mpi Y;
- t_uint p[1];
+ mbedtls_mpi Y;
+ mbedtls_mpi_uint p[1];
*p = ( z < 0 ) ? -z : z;
Y.s = ( z < 0 ) ? -1 : 1;
Y.n = 1;
Y.p = p;
- return( mpi_cmp_mpi( X, &Y ) );
+ return( mbedtls_mpi_cmp_mpi( X, &Y ) );
}
/*
* Unsigned addition: X = |A| + |B| (HAC 14.7)
*/
-int mpi_add_abs( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
size_t i, j;
- t_uint *o, *p, c;
+ mbedtls_mpi_uint *o, *p, c;
if( X == B )
{
- const mpi *T = A; A = X; B = T;
+ const mbedtls_mpi *T = A; A = X; B = T;
}
if( X != A )
- MPI_CHK( mpi_copy( X, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
/*
* X should always be positive as a result of unsigned additions.
@@ -874,7 +874,7 @@
if( B->p[j - 1] != 0 )
break;
- MPI_CHK( mpi_grow( X, j ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
o = B->p; p = X->p; c = 0;
@@ -888,7 +888,7 @@
{
if( i >= X->n )
{
- MPI_CHK( mpi_grow( X, i + 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + 1 ) );
p = X->p + i;
}
@@ -901,12 +901,12 @@
}
/*
- * Helper for mpi subtraction
+ * Helper for mbedtls_mpi subtraction
*/
-static void mpi_sub_hlp( size_t n, t_uint *s, t_uint *d )
+static void mpi_sub_hlp( size_t n, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d )
{
size_t i;
- t_uint c, z;
+ mbedtls_mpi_uint c, z;
for( i = c = 0; i < n; i++, s++, d++ )
{
@@ -924,25 +924,25 @@
/*
* Unsigned subtraction: X = |A| - |B| (HAC 14.9)
*/
-int mpi_sub_abs( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
- mpi TB;
+ mbedtls_mpi TB;
int ret;
size_t n;
- if( mpi_cmp_abs( A, B ) < 0 )
- return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+ if( mbedtls_mpi_cmp_abs( A, B ) < 0 )
+ return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
- mpi_init( &TB );
+ mbedtls_mpi_init( &TB );
if( X == B )
{
- MPI_CHK( mpi_copy( &TB, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
B = &TB;
}
if( X != A )
- MPI_CHK( mpi_copy( X, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
/*
* X should always be positive as a result of unsigned subtractions.
@@ -959,7 +959,7 @@
cleanup:
- mpi_free( &TB );
+ mbedtls_mpi_free( &TB );
return( ret );
}
@@ -967,26 +967,26 @@
/*
* Signed addition: X = A + B
*/
-int mpi_add_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s < 0 )
{
- if( mpi_cmp_abs( A, B ) >= 0 )
+ if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
- MPI_CHK( mpi_sub_abs( X, A, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
- MPI_CHK( mpi_sub_abs( X, B, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
X->s = -s;
}
}
else
{
- MPI_CHK( mpi_add_abs( X, A, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
X->s = s;
}
@@ -998,26 +998,26 @@
/*
* Signed subtraction: X = A - B
*/
-int mpi_sub_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s > 0 )
{
- if( mpi_cmp_abs( A, B ) >= 0 )
+ if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
- MPI_CHK( mpi_sub_abs( X, A, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
- MPI_CHK( mpi_sub_abs( X, B, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
X->s = -s;
}
}
else
{
- MPI_CHK( mpi_add_abs( X, A, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
X->s = s;
}
@@ -1029,37 +1029,37 @@
/*
* Signed addition: X = A + b
*/
-int mpi_add_int( mpi *X, const mpi *A, t_sint b )
+int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
- mpi _B;
- t_uint p[1];
+ mbedtls_mpi _B;
+ mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
- return( mpi_add_mpi( X, A, &_B ) );
+ return( mbedtls_mpi_add_mpi( X, A, &_B ) );
}
/*
* Signed subtraction: X = A - b
*/
-int mpi_sub_int( mpi *X, const mpi *A, t_sint b )
+int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
- mpi _B;
- t_uint p[1];
+ mbedtls_mpi _B;
+ mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
- return( mpi_sub_mpi( X, A, &_B ) );
+ return( mbedtls_mpi_sub_mpi( X, A, &_B ) );
}
/*
- * Helper for mpi multiplication
+ * Helper for mbedtls_mpi multiplication
*/
static
#if defined(__APPLE__) && defined(__arm__)
@@ -1069,9 +1069,9 @@
*/
__attribute__ ((noinline))
#endif
-void mpi_mul_hlp( size_t i, t_uint *s, t_uint *d, t_uint b )
+void mpi_mul_hlp( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )
{
- t_uint c = 0, t = 0;
+ mbedtls_mpi_uint c = 0, t = 0;
#if defined(MULADDC_HUIT)
for( ; i >= 8; i -= 8 )
@@ -1133,16 +1133,16 @@
/*
* Baseline multiplication: X = A * B (HAC 14.12)
*/
-int mpi_mul_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_mul_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
size_t i, j;
- mpi TA, TB;
+ mbedtls_mpi TA, TB;
- mpi_init( &TA ); mpi_init( &TB );
+ mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
- if( X == A ) { MPI_CHK( mpi_copy( &TA, A ) ); A = &TA; }
- if( X == B ) { MPI_CHK( mpi_copy( &TB, B ) ); B = &TB; }
+ if( X == A ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) ); A = &TA; }
+ if( X == B ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) ); B = &TB; }
for( i = A->n; i > 0; i-- )
if( A->p[i - 1] != 0 )
@@ -1152,8 +1152,8 @@
if( B->p[j - 1] != 0 )
break;
- MPI_CHK( mpi_grow( X, i + j ) );
- MPI_CHK( mpi_lset( X, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + j ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i++; j > 0; j-- )
mpi_mul_hlp( i - 1, A->p, X->p + j - 1, B->p[j - 1] );
@@ -1162,7 +1162,7 @@
cleanup:
- mpi_free( &TB ); mpi_free( &TA );
+ mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TA );
return( ret );
}
@@ -1170,69 +1170,69 @@
/*
* Baseline multiplication: X = A * b
*/
-int mpi_mul_int( mpi *X, const mpi *A, t_uint b )
+int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_uint b )
{
- mpi _B;
- t_uint p[1];
+ mbedtls_mpi _B;
+ mbedtls_mpi_uint p[1];
_B.s = 1;
_B.n = 1;
_B.p = p;
p[0] = b;
- return( mpi_mul_mpi( X, A, &_B ) );
+ return( mbedtls_mpi_mul_mpi( X, A, &_B ) );
}
/*
- * Division by mpi: A = Q * B + R (HAC 14.20)
+ * Division by mbedtls_mpi: A = Q * B + R (HAC 14.20)
*/
-int mpi_div_mpi( mpi *Q, mpi *R, const mpi *A, const mpi *B )
+int mbedtls_mpi_div_mpi( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
size_t i, n, t, k;
- mpi X, Y, Z, T1, T2;
+ mbedtls_mpi X, Y, Z, T1, T2;
- if( mpi_cmp_int( B, 0 ) == 0 )
- return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
+ if( mbedtls_mpi_cmp_int( B, 0 ) == 0 )
+ return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
- mpi_init( &T1 ); mpi_init( &T2 );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
+ mbedtls_mpi_init( &T1 ); mbedtls_mpi_init( &T2 );
- if( mpi_cmp_abs( A, B ) < 0 )
+ if( mbedtls_mpi_cmp_abs( A, B ) < 0 )
{
- if( Q != NULL ) MPI_CHK( mpi_lset( Q, 0 ) );
- if( R != NULL ) MPI_CHK( mpi_copy( R, A ) );
+ if( Q != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_lset( Q, 0 ) );
+ if( R != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, A ) );
return( 0 );
}
- MPI_CHK( mpi_copy( &X, A ) );
- MPI_CHK( mpi_copy( &Y, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &X, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, B ) );
X.s = Y.s = 1;
- MPI_CHK( mpi_grow( &Z, A->n + 2 ) );
- MPI_CHK( mpi_lset( &Z, 0 ) );
- MPI_CHK( mpi_grow( &T1, 2 ) );
- MPI_CHK( mpi_grow( &T2, 3 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &Z, A->n + 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Z, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T1, 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T2, 3 ) );
- k = mpi_msb( &Y ) % biL;
+ k = mbedtls_mpi_msb( &Y ) % biL;
if( k < biL - 1 )
{
k = biL - 1 - k;
- MPI_CHK( mpi_shift_l( &X, k ) );
- MPI_CHK( mpi_shift_l( &Y, k ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &X, k ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, k ) );
}
else k = 0;
n = X.n - 1;
t = Y.n - 1;
- MPI_CHK( mpi_shift_l( &Y, biL * ( n - t ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, biL * ( n - t ) ) );
- while( mpi_cmp_mpi( &X, &Y ) >= 0 )
+ while( mbedtls_mpi_cmp_mpi( &X, &Y ) >= 0 )
{
Z.p[n - t]++;
- MPI_CHK( mpi_sub_mpi( &X, &X, &Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &Y ) );
}
- MPI_CHK( mpi_shift_r( &Y, biL * ( n - t ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, biL * ( n - t ) ) );
for( i = n; i > t ; i-- )
{
@@ -1240,22 +1240,22 @@
Z.p[i - t - 1] = ~0;
else
{
-#if defined(POLARSSL_HAVE_UDBL)
- t_udbl r;
+#if defined(MBEDTLS_HAVE_UDBL)
+ mbedtls_t_udbl r;
- r = (t_udbl) X.p[i] << biL;
- r |= (t_udbl) X.p[i - 1];
+ r = (mbedtls_t_udbl) X.p[i] << biL;
+ r |= (mbedtls_t_udbl) X.p[i - 1];
r /= Y.p[t];
- if( r > ( (t_udbl) 1 << biL ) - 1 )
- r = ( (t_udbl) 1 << biL ) - 1;
+ if( r > ( (mbedtls_t_udbl) 1 << biL ) - 1 )
+ r = ( (mbedtls_t_udbl) 1 << biL ) - 1;
- Z.p[i - t - 1] = (t_uint) r;
+ Z.p[i - t - 1] = (mbedtls_mpi_uint) r;
#else
/*
* __udiv_qrnnd_c, from gmp/longlong.h
*/
- t_uint q0, q1, r0, r1;
- t_uint d0, d1, d, m;
+ mbedtls_mpi_uint q0, q1, r0, r1;
+ mbedtls_mpi_uint d0, d1, d, m;
d = Y.p[t];
d0 = ( d << biH ) >> biH;
@@ -1290,7 +1290,7 @@
r0 -= m;
Z.p[i - t - 1] = ( q1 << biH ) | q0;
-#endif /* POLARSSL_HAVE_UDBL && !64-bit Apple with Clang 5.0 */
+#endif /* MBEDTLS_HAVE_UDBL && !64-bit Apple with Clang 5.0 */
}
Z.p[i - t - 1]++;
@@ -1298,51 +1298,51 @@
{
Z.p[i - t - 1]--;
- MPI_CHK( mpi_lset( &T1, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T1, 0 ) );
T1.p[0] = ( t < 1 ) ? 0 : Y.p[t - 1];
T1.p[1] = Y.p[t];
- MPI_CHK( mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
- MPI_CHK( mpi_lset( &T2, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T2, 0 ) );
T2.p[0] = ( i < 2 ) ? 0 : X.p[i - 2];
T2.p[1] = ( i < 1 ) ? 0 : X.p[i - 1];
T2.p[2] = X.p[i];
}
- while( mpi_cmp_mpi( &T1, &T2 ) > 0 );
+ while( mbedtls_mpi_cmp_mpi( &T1, &T2 ) > 0 );
- MPI_CHK( mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
- MPI_CHK( mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
- MPI_CHK( mpi_sub_mpi( &X, &X, &T1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T1 ) );
- if( mpi_cmp_int( &X, 0 ) < 0 )
+ if( mbedtls_mpi_cmp_int( &X, 0 ) < 0 )
{
- MPI_CHK( mpi_copy( &T1, &Y ) );
- MPI_CHK( mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
- MPI_CHK( mpi_add_mpi( &X, &X, &T1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T1, &Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &X, &X, &T1 ) );
Z.p[i - t - 1]--;
}
}
if( Q != NULL )
{
- MPI_CHK( mpi_copy( Q, &Z ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Q, &Z ) );
Q->s = A->s * B->s;
}
if( R != NULL )
{
- MPI_CHK( mpi_shift_r( &X, k ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &X, k ) );
X.s = A->s;
- MPI_CHK( mpi_copy( R, &X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, &X ) );
- if( mpi_cmp_int( R, 0 ) == 0 )
+ if( mbedtls_mpi_cmp_int( R, 0 ) == 0 )
R->s = 1;
}
cleanup:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
- mpi_free( &T1 ); mpi_free( &T2 );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
+ mbedtls_mpi_free( &T1 ); mbedtls_mpi_free( &T2 );
return( ret );
}
@@ -1350,36 +1350,36 @@
/*
* Division by int: A = Q * b + R
*/
-int mpi_div_int( mpi *Q, mpi *R, const mpi *A, t_sint b )
+int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
- mpi _B;
- t_uint p[1];
+ mbedtls_mpi _B;
+ mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
- return( mpi_div_mpi( Q, R, A, &_B ) );
+ return( mbedtls_mpi_div_mpi( Q, R, A, &_B ) );
}
/*
* Modulo: R = A mod B
*/
-int mpi_mod_mpi( mpi *R, const mpi *A, const mpi *B )
+int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
- if( mpi_cmp_int( B, 0 ) < 0 )
- return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+ if( mbedtls_mpi_cmp_int( B, 0 ) < 0 )
+ return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
- MPI_CHK( mpi_div_mpi( NULL, R, A, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( NULL, R, A, B ) );
- while( mpi_cmp_int( R, 0 ) < 0 )
- MPI_CHK( mpi_add_mpi( R, R, B ) );
+ while( mbedtls_mpi_cmp_int( R, 0 ) < 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( R, R, B ) );
- while( mpi_cmp_mpi( R, B ) >= 0 )
- MPI_CHK( mpi_sub_mpi( R, R, B ) );
+ while( mbedtls_mpi_cmp_mpi( R, B ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( R, R, B ) );
cleanup:
@@ -1389,16 +1389,16 @@
/*
* Modulo: r = A mod b
*/
-int mpi_mod_int( t_uint *r, const mpi *A, t_sint b )
+int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
size_t i;
- t_uint x, y, z;
+ mbedtls_mpi_uint x, y, z;
if( b == 0 )
- return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
+ return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
if( b < 0 )
- return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+ return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
/*
* handle trivial cases
@@ -1446,9 +1446,9 @@
/*
* Fast Montgomery initialization (thanks to Tom St Denis)
*/
-static void mpi_montg_init( t_uint *mm, const mpi *N )
+static void mpi_montg_init( mbedtls_mpi_uint *mm, const mbedtls_mpi *N )
{
- t_uint x, m0 = N->p[0];
+ mbedtls_mpi_uint x, m0 = N->p[0];
unsigned int i;
x = m0;
@@ -1463,11 +1463,11 @@
/*
* Montgomery multiplication: A = A * B * R^-1 mod N (HAC 14.36)
*/
-static void mpi_montmul( mpi *A, const mpi *B, const mpi *N, t_uint mm,
- const mpi *T )
+static void mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm,
+ const mbedtls_mpi *T )
{
size_t i, n, m;
- t_uint u0, u1, *d;
+ mbedtls_mpi_uint u0, u1, *d;
memset( T->p, 0, T->n * ciL );
@@ -1491,7 +1491,7 @@
memcpy( A->p, d, ( n + 1 ) * ciL );
- if( mpi_cmp_abs( A, N ) >= 0 )
+ if( mbedtls_mpi_cmp_abs( A, N ) >= 0 )
mpi_sub_hlp( n, N->p, A->p );
else
/* prevent timing attacks */
@@ -1501,10 +1501,10 @@
/*
* Montgomery reduction: A = A * R^-1 mod N
*/
-static void mpi_montred( mpi *A, const mpi *N, t_uint mm, const mpi *T )
+static void mpi_montred( mbedtls_mpi *A, const mbedtls_mpi *N, mbedtls_mpi_uint mm, const mbedtls_mpi *T )
{
- t_uint z = 1;
- mpi U;
+ mbedtls_mpi_uint z = 1;
+ mbedtls_mpi U;
U.n = U.s = (int) z;
U.p = &z;
@@ -1515,42 +1515,42 @@
/*
* Sliding-window exponentiation: X = A^E mod N (HAC 14.85)
*/
-int mpi_exp_mod( mpi *X, const mpi *A, const mpi *E, const mpi *N, mpi *_RR )
+int mbedtls_mpi_exp_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *E, const mbedtls_mpi *N, mbedtls_mpi *_RR )
{
int ret;
size_t wbits, wsize, one = 1;
size_t i, j, nblimbs;
size_t bufsize, nbits;
- t_uint ei, mm, state;
- mpi RR, T, W[ 2 << POLARSSL_MPI_WINDOW_SIZE ], Apos;
+ mbedtls_mpi_uint ei, mm, state;
+ mbedtls_mpi RR, T, W[ 2 << MBEDTLS_MPI_WINDOW_SIZE ], Apos;
int neg;
- if( mpi_cmp_int( N, 0 ) < 0 || ( N->p[0] & 1 ) == 0 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( N, 0 ) < 0 || ( N->p[0] & 1 ) == 0 )
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- if( mpi_cmp_int( E, 0 ) < 0 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( E, 0 ) < 0 )
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
/*
* Init temps and window size
*/
mpi_montg_init( &mm, N );
- mpi_init( &RR ); mpi_init( &T );
- mpi_init( &Apos );
+ mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &T );
+ mbedtls_mpi_init( &Apos );
memset( W, 0, sizeof( W ) );
- i = mpi_msb( E );
+ i = mbedtls_mpi_msb( E );
wsize = ( i > 671 ) ? 6 : ( i > 239 ) ? 5 :
( i > 79 ) ? 4 : ( i > 23 ) ? 3 : 1;
- if( wsize > POLARSSL_MPI_WINDOW_SIZE )
- wsize = POLARSSL_MPI_WINDOW_SIZE;
+ if( wsize > MBEDTLS_MPI_WINDOW_SIZE )
+ wsize = MBEDTLS_MPI_WINDOW_SIZE;
j = N->n + 1;
- MPI_CHK( mpi_grow( X, j ) );
- MPI_CHK( mpi_grow( &W[1], j ) );
- MPI_CHK( mpi_grow( &T, j * 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1], j ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T, j * 2 ) );
/*
* Compensate for negative A (and correct at the end)
@@ -1558,7 +1558,7 @@
neg = ( A->s == -1 );
if( neg )
{
- MPI_CHK( mpi_copy( &Apos, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Apos, A ) );
Apos.s = 1;
A = &Apos;
}
@@ -1568,30 +1568,30 @@
*/
if( _RR == NULL || _RR->p == NULL )
{
- MPI_CHK( mpi_lset( &RR, 1 ) );
- MPI_CHK( mpi_shift_l( &RR, N->n * 2 * biL ) );
- MPI_CHK( mpi_mod_mpi( &RR, &RR, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &RR, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &RR, N->n * 2 * biL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &RR, &RR, N ) );
if( _RR != NULL )
- memcpy( _RR, &RR, sizeof( mpi ) );
+ memcpy( _RR, &RR, sizeof( mbedtls_mpi ) );
}
else
- memcpy( &RR, _RR, sizeof( mpi ) );
+ memcpy( &RR, _RR, sizeof( mbedtls_mpi ) );
/*
* W[1] = A * R^2 * R^-1 mod N = A * R mod N
*/
- if( mpi_cmp_mpi( A, N ) >= 0 )
- MPI_CHK( mpi_mod_mpi( &W[1], A, N ) );
+ if( mbedtls_mpi_cmp_mpi( A, N ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &W[1], A, N ) );
else
- MPI_CHK( mpi_copy( &W[1], A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[1], A ) );
mpi_montmul( &W[1], &RR, N, mm, &T );
/*
* X = R^2 * R^-1 mod N = R mod N
*/
- MPI_CHK( mpi_copy( X, &RR ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &RR ) );
mpi_montred( X, N, mm, &T );
if( wsize > 1 )
@@ -1601,8 +1601,8 @@
*/
j = one << ( wsize - 1 );
- MPI_CHK( mpi_grow( &W[j], N->n + 1 ) );
- MPI_CHK( mpi_copy( &W[j], &W[1] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[j], N->n + 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[j], &W[1] ) );
for( i = 0; i < wsize - 1; i++ )
mpi_montmul( &W[j], &W[j], N, mm, &T );
@@ -1612,8 +1612,8 @@
*/
for( i = j + 1; i < ( one << wsize ); i++ )
{
- MPI_CHK( mpi_grow( &W[i], N->n + 1 ) );
- MPI_CHK( mpi_copy( &W[i], &W[i - 1] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[i], N->n + 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[i], &W[i - 1] ) );
mpi_montmul( &W[i], &W[1], N, mm, &T );
}
@@ -1634,7 +1634,7 @@
nblimbs--;
- bufsize = sizeof( t_uint ) << 3;
+ bufsize = sizeof( mbedtls_mpi_uint ) << 3;
}
bufsize--;
@@ -1704,18 +1704,18 @@
if( neg )
{
X->s = -1;
- MPI_CHK( mpi_add_mpi( X, N, X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( X, N, X ) );
}
cleanup:
for( i = ( one << ( wsize - 1 ) ); i < ( one << wsize ); i++ )
- mpi_free( &W[i] );
+ mbedtls_mpi_free( &W[i] );
- mpi_free( &W[1] ); mpi_free( &T ); mpi_free( &Apos );
+ mbedtls_mpi_free( &W[1] ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &Apos );
if( _RR == NULL || _RR->p == NULL )
- mpi_free( &RR );
+ mbedtls_mpi_free( &RR );
return( ret );
}
@@ -1723,51 +1723,51 @@
/*
* Greatest common divisor: G = gcd(A, B) (HAC 14.54)
*/
-int mpi_gcd( mpi *G, const mpi *A, const mpi *B )
+int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
size_t lz, lzt;
- mpi TG, TA, TB;
+ mbedtls_mpi TG, TA, TB;
- mpi_init( &TG ); mpi_init( &TA ); mpi_init( &TB );
+ mbedtls_mpi_init( &TG ); mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
- MPI_CHK( mpi_copy( &TA, A ) );
- MPI_CHK( mpi_copy( &TB, B ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
- lz = mpi_lsb( &TA );
- lzt = mpi_lsb( &TB );
+ lz = mbedtls_mpi_lsb( &TA );
+ lzt = mbedtls_mpi_lsb( &TB );
if( lzt < lz )
lz = lzt;
- MPI_CHK( mpi_shift_r( &TA, lz ) );
- MPI_CHK( mpi_shift_r( &TB, lz ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, lz ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, lz ) );
TA.s = TB.s = 1;
- while( mpi_cmp_int( &TA, 0 ) != 0 )
+ while( mbedtls_mpi_cmp_int( &TA, 0 ) != 0 )
{
- MPI_CHK( mpi_shift_r( &TA, mpi_lsb( &TA ) ) );
- MPI_CHK( mpi_shift_r( &TB, mpi_lsb( &TB ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, mbedtls_mpi_lsb( &TA ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, mbedtls_mpi_lsb( &TB ) ) );
- if( mpi_cmp_mpi( &TA, &TB ) >= 0 )
+ if( mbedtls_mpi_cmp_mpi( &TA, &TB ) >= 0 )
{
- MPI_CHK( mpi_sub_abs( &TA, &TA, &TB ) );
- MPI_CHK( mpi_shift_r( &TA, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TA, &TA, &TB ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, 1 ) );
}
else
{
- MPI_CHK( mpi_sub_abs( &TB, &TB, &TA ) );
- MPI_CHK( mpi_shift_r( &TB, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TB, &TB, &TA ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, 1 ) );
}
}
- MPI_CHK( mpi_shift_l( &TB, lz ) );
- MPI_CHK( mpi_copy( G, &TB ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &TB, lz ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( G, &TB ) );
cleanup:
- mpi_free( &TG ); mpi_free( &TA ); mpi_free( &TB );
+ mbedtls_mpi_free( &TG ); mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TB );
return( ret );
}
@@ -1779,18 +1779,18 @@
* regardless of the platform endianness (useful when f_rng is actually
* deterministic, eg for tests).
*/
-int mpi_fill_random( mpi *X, size_t size,
+int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE];
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
- if( size > POLARSSL_MPI_MAX_SIZE )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ if( size > MBEDTLS_MPI_MAX_SIZE )
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- MPI_CHK( f_rng( p_rng, buf, size ) );
- MPI_CHK( mpi_read_binary( X, buf, size ) );
+ MBEDTLS_MPI_CHK( f_rng( p_rng, buf, size ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( X, buf, size ) );
cleanup:
return( ret );
@@ -1799,99 +1799,99 @@
/*
* Modular inverse: X = A^-1 mod N (HAC 14.61 / 14.64)
*/
-int mpi_inv_mod( mpi *X, const mpi *A, const mpi *N )
+int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
{
int ret;
- mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
+ mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
- if( mpi_cmp_int( N, 0 ) <= 0 )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 )
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- mpi_init( &TA ); mpi_init( &TU ); mpi_init( &U1 ); mpi_init( &U2 );
- mpi_init( &G ); mpi_init( &TB ); mpi_init( &TV );
- mpi_init( &V1 ); mpi_init( &V2 );
+ mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TU ); mbedtls_mpi_init( &U1 ); mbedtls_mpi_init( &U2 );
+ mbedtls_mpi_init( &G ); mbedtls_mpi_init( &TB ); mbedtls_mpi_init( &TV );
+ mbedtls_mpi_init( &V1 ); mbedtls_mpi_init( &V2 );
- MPI_CHK( mpi_gcd( &G, A, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, A, N ) );
- if( mpi_cmp_int( &G, 1 ) != 0 )
+ if( mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
{
- ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
+ ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
goto cleanup;
}
- MPI_CHK( mpi_mod_mpi( &TA, A, N ) );
- MPI_CHK( mpi_copy( &TU, &TA ) );
- MPI_CHK( mpi_copy( &TB, N ) );
- MPI_CHK( mpi_copy( &TV, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &TA, A, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TU, &TA ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TV, N ) );
- MPI_CHK( mpi_lset( &U1, 1 ) );
- MPI_CHK( mpi_lset( &U2, 0 ) );
- MPI_CHK( mpi_lset( &V1, 0 ) );
- MPI_CHK( mpi_lset( &V2, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U1, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U2, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V1, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V2, 1 ) );
do
{
while( ( TU.p[0] & 1 ) == 0 )
{
- MPI_CHK( mpi_shift_r( &TU, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TU, 1 ) );
if( ( U1.p[0] & 1 ) != 0 || ( U2.p[0] & 1 ) != 0 )
{
- MPI_CHK( mpi_add_mpi( &U1, &U1, &TB ) );
- MPI_CHK( mpi_sub_mpi( &U2, &U2, &TA ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &U1, &U1, &TB ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &TA ) );
}
- MPI_CHK( mpi_shift_r( &U1, 1 ) );
- MPI_CHK( mpi_shift_r( &U2, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U1, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U2, 1 ) );
}
while( ( TV.p[0] & 1 ) == 0 )
{
- MPI_CHK( mpi_shift_r( &TV, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TV, 1 ) );
if( ( V1.p[0] & 1 ) != 0 || ( V2.p[0] & 1 ) != 0 )
{
- MPI_CHK( mpi_add_mpi( &V1, &V1, &TB ) );
- MPI_CHK( mpi_sub_mpi( &V2, &V2, &TA ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, &TB ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &TA ) );
}
- MPI_CHK( mpi_shift_r( &V1, 1 ) );
- MPI_CHK( mpi_shift_r( &V2, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V1, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V2, 1 ) );
}
- if( mpi_cmp_mpi( &TU, &TV ) >= 0 )
+ if( mbedtls_mpi_cmp_mpi( &TU, &TV ) >= 0 )
{
- MPI_CHK( mpi_sub_mpi( &TU, &TU, &TV ) );
- MPI_CHK( mpi_sub_mpi( &U1, &U1, &V1 ) );
- MPI_CHK( mpi_sub_mpi( &U2, &U2, &V2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TU, &TU, &TV ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U1, &U1, &V1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &V2 ) );
}
else
{
- MPI_CHK( mpi_sub_mpi( &TV, &TV, &TU ) );
- MPI_CHK( mpi_sub_mpi( &V1, &V1, &U1 ) );
- MPI_CHK( mpi_sub_mpi( &V2, &V2, &U2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TV, &TV, &TU ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, &U1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &U2 ) );
}
}
- while( mpi_cmp_int( &TU, 0 ) != 0 );
+ while( mbedtls_mpi_cmp_int( &TU, 0 ) != 0 );
- while( mpi_cmp_int( &V1, 0 ) < 0 )
- MPI_CHK( mpi_add_mpi( &V1, &V1, N ) );
+ while( mbedtls_mpi_cmp_int( &V1, 0 ) < 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, N ) );
- while( mpi_cmp_mpi( &V1, N ) >= 0 )
- MPI_CHK( mpi_sub_mpi( &V1, &V1, N ) );
+ while( mbedtls_mpi_cmp_mpi( &V1, N ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, N ) );
- MPI_CHK( mpi_copy( X, &V1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &V1 ) );
cleanup:
- mpi_free( &TA ); mpi_free( &TU ); mpi_free( &U1 ); mpi_free( &U2 );
- mpi_free( &G ); mpi_free( &TB ); mpi_free( &TV );
- mpi_free( &V1 ); mpi_free( &V2 );
+ mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TU ); mbedtls_mpi_free( &U1 ); mbedtls_mpi_free( &U2 );
+ mbedtls_mpi_free( &G ); mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TV );
+ mbedtls_mpi_free( &V1 ); mbedtls_mpi_free( &V2 );
return( ret );
}
-#if defined(POLARSSL_GENPRIME)
+#if defined(MBEDTLS_GENPRIME)
static const int small_prime[] =
{
@@ -1924,27 +1924,27 @@
* Return values:
* 0: no small factor (possible prime, more tests needed)
* 1: certain prime
- * POLARSSL_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
+ * MBEDTLS_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
* other negative: error
*/
-static int mpi_check_small_factors( const mpi *X )
+static int mpi_check_small_factors( const mbedtls_mpi *X )
{
int ret = 0;
size_t i;
- t_uint r;
+ mbedtls_mpi_uint r;
if( ( X->p[0] & 1 ) == 0 )
- return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+ return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
for( i = 0; small_prime[i] > 0; i++ )
{
- if( mpi_cmp_int( X, small_prime[i] ) <= 0 )
+ if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
return( 1 );
- MPI_CHK( mpi_mod_int( &r, X, small_prime[i] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, small_prime[i] ) );
if( r == 0 )
- return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+ return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
}
cleanup:
@@ -1954,27 +1954,27 @@
/*
* Miller-Rabin pseudo-primality test (HAC 4.24)
*/
-static int mpi_miller_rabin( const mpi *X,
+static int mpi_miller_rabin( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t i, j, n, s;
- mpi W, R, T, A, RR;
+ mbedtls_mpi W, R, T, A, RR;
- mpi_init( &W ); mpi_init( &R ); mpi_init( &T ); mpi_init( &A );
- mpi_init( &RR );
+ mbedtls_mpi_init( &W ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &T ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init( &RR );
/*
* W = |X| - 1
* R = W >> lsb( W )
*/
- MPI_CHK( mpi_sub_int( &W, X, 1 ) );
- s = mpi_lsb( &W );
- MPI_CHK( mpi_copy( &R, &W ) );
- MPI_CHK( mpi_shift_r( &R, s ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &W, X, 1 ) );
+ s = mbedtls_mpi_lsb( &W );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R, &W ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &R, s ) );
- i = mpi_msb( X );
+ i = mbedtls_mpi_msb( X );
/*
* HAC, table 4.4
*/
@@ -1987,34 +1987,34 @@
/*
* pick a random A, 1 < A < |X| - 1
*/
- MPI_CHK( mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
- if( mpi_cmp_mpi( &A, &W ) >= 0 )
+ if( mbedtls_mpi_cmp_mpi( &A, &W ) >= 0 )
{
- j = mpi_msb( &A ) - mpi_msb( &W );
- MPI_CHK( mpi_shift_r( &A, j + 1 ) );
+ j = mbedtls_mpi_msb( &A ) - mbedtls_mpi_msb( &W );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &A, j + 1 ) );
}
A.p[0] |= 3;
/*
* A = A^R mod |X|
*/
- MPI_CHK( mpi_exp_mod( &A, &A, &R, X, &RR ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &A, &A, &R, X, &RR ) );
- if( mpi_cmp_mpi( &A, &W ) == 0 ||
- mpi_cmp_int( &A, 1 ) == 0 )
+ if( mbedtls_mpi_cmp_mpi( &A, &W ) == 0 ||
+ mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
continue;
j = 1;
- while( j < s && mpi_cmp_mpi( &A, &W ) != 0 )
+ while( j < s && mbedtls_mpi_cmp_mpi( &A, &W ) != 0 )
{
/*
* A = A * A mod |X|
*/
- MPI_CHK( mpi_mul_mpi( &T, &A, &A ) );
- MPI_CHK( mpi_mod_mpi( &A, &T, X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &A, &A ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &A, &T, X ) );
- if( mpi_cmp_int( &A, 1 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
break;
j++;
@@ -2023,17 +2023,17 @@
/*
* not prime if A != |X| - 1 or A == 1
*/
- if( mpi_cmp_mpi( &A, &W ) != 0 ||
- mpi_cmp_int( &A, 1 ) == 0 )
+ if( mbedtls_mpi_cmp_mpi( &A, &W ) != 0 ||
+ mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
{
- ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
+ ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
break;
}
}
cleanup:
- mpi_free( &W ); mpi_free( &R ); mpi_free( &T ); mpi_free( &A );
- mpi_free( &RR );
+ mbedtls_mpi_free( &W ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free( &RR );
return( ret );
}
@@ -2041,22 +2041,22 @@
/*
* Pseudo-primality test: small factors, then Miller-Rabin
*/
-int mpi_is_prime( const mpi *X,
+int mbedtls_mpi_is_prime( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- mpi XX;
+ mbedtls_mpi XX;
XX.s = 1;
XX.n = X->n;
XX.p = X->p;
- if( mpi_cmp_int( &XX, 0 ) == 0 ||
- mpi_cmp_int( &XX, 1 ) == 0 )
- return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+ if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
+ mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )
+ return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
- if( mpi_cmp_int( &XX, 2 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &XX, 2 ) == 0 )
return( 0 );
if( ( ret = mpi_check_small_factors( &XX ) ) != 0 )
@@ -2073,38 +2073,38 @@
/*
* Prime number generation
*/
-int mpi_gen_prime( mpi *X, size_t nbits, int dh_flag,
+int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int dh_flag,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t k, n;
- t_uint r;
- mpi Y;
+ mbedtls_mpi_uint r;
+ mbedtls_mpi Y;
- if( nbits < 3 || nbits > POLARSSL_MPI_MAX_BITS )
- return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+ if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS )
+ return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- mpi_init( &Y );
+ mbedtls_mpi_init( &Y );
n = BITS_TO_LIMBS( nbits );
- MPI_CHK( mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
- k = mpi_msb( X );
- if( k < nbits ) MPI_CHK( mpi_shift_l( X, nbits - k ) );
- if( k > nbits ) MPI_CHK( mpi_shift_r( X, k - nbits ) );
+ k = mbedtls_mpi_msb( X );
+ if( k < nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( X, nbits - k ) );
+ if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits ) );
X->p[0] |= 3;
if( dh_flag == 0 )
{
- while( ( ret = mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
+ while( ( ret = mbedtls_mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
{
- if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
+ if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
- MPI_CHK( mpi_add_int( X, X, 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 2 ) );
}
}
else
@@ -2114,15 +2114,15 @@
* is X = 2 mod 3 (which is equivalent to Y = 2 mod 3).
* Make sure it is satisfied, while keeping X = 3 mod 4
*/
- MPI_CHK( mpi_mod_int( &r, X, 3 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) );
if( r == 0 )
- MPI_CHK( mpi_add_int( X, X, 8 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) );
else if( r == 1 )
- MPI_CHK( mpi_add_int( X, X, 4 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) );
/* Set Y = (X-1) / 2, which is X / 2 because X is odd */
- MPI_CHK( mpi_copy( &Y, X ) );
- MPI_CHK( mpi_shift_r( &Y, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, 1 ) );
while( 1 )
{
@@ -2138,7 +2138,7 @@
break;
}
- if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
+ if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
/*
@@ -2146,21 +2146,21 @@
* Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3)
* so up Y by 6 and X by 12.
*/
- MPI_CHK( mpi_add_int( X, X, 12 ) );
- MPI_CHK( mpi_add_int( &Y, &Y, 6 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 12 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6 ) );
}
}
cleanup:
- mpi_free( &Y );
+ mbedtls_mpi_free( &Y );
return( ret );
}
-#endif /* POLARSSL_GENPRIME */
+#endif /* MBEDTLS_GENPRIME */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#define GCD_PAIR_COUNT 3
@@ -2174,34 +2174,34 @@
/*
* Checkup routine
*/
-int mpi_self_test( int verbose )
+int mbedtls_mpi_self_test( int verbose )
{
int ret, i;
- mpi A, E, N, X, Y, U, V;
+ mbedtls_mpi A, E, N, X, Y, U, V;
- mpi_init( &A ); mpi_init( &E ); mpi_init( &N ); mpi_init( &X );
- mpi_init( &Y ); mpi_init( &U ); mpi_init( &V );
+ mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N ); mbedtls_mpi_init( &X );
+ mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &U ); mbedtls_mpi_init( &V );
- MPI_CHK( mpi_read_string( &A, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &A, 16,
"EFE021C2645FD1DC586E69184AF4A31E" \
"D5F53E93B5F123FA41680867BA110131" \
"944FE7952E2517337780CB0DB80E61AA" \
"E7C8DDC6C5C6AADEB34EB38A2F40D5E6" ) );
- MPI_CHK( mpi_read_string( &E, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &E, 16,
"B2E7EFD37075B9F03FF989C7C5051C20" \
"34D2A323810251127E7BF8625A4F49A5" \
"F3E27F4DA8BD59C47D6DAABA4C8127BD" \
"5B5C25763222FEFCCFC38B832366C29E" ) );
- MPI_CHK( mpi_read_string( &N, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &N, 16,
"0066A198186C18C10B2F5ED9B522752A" \
"9830B69916E535C8F047518A889A43A5" \
"94B6BED27A168D31D4A52F88925AA8F5" ) );
- MPI_CHK( mpi_mul_mpi( &X, &A, &N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &A, &N ) );
- MPI_CHK( mpi_read_string( &U, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"602AB7ECA597A3D6B56FF9829A5E8B85" \
"9E857EA95A03512E2BAE7391688D264A" \
"A5663B0341DB9CCFD2C4C5F421FEC814" \
@@ -2211,104 +2211,104 @@
"30879B56C61DE584A0F53A2447A51E" ) );
if( verbose != 0 )
- polarssl_printf( " MPI test #1 (mul_mpi): " );
+ mbedtls_printf( " MPI test #1 (mul_mpi): " );
- if( mpi_cmp_mpi( &X, &U ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
- MPI_CHK( mpi_div_mpi( &X, &Y, &A, &N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &X, &Y, &A, &N ) );
- MPI_CHK( mpi_read_string( &U, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"256567336059E52CAE22925474705F39A94" ) );
- MPI_CHK( mpi_read_string( &V, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &V, 16,
"6613F26162223DF488E9CD48CC132C7A" \
"0AC93C701B001B092E4E5B9F73BCD27B" \
"9EE50D0657C77F374E903CDFA4C642" ) );
if( verbose != 0 )
- polarssl_printf( " MPI test #2 (div_mpi): " );
+ mbedtls_printf( " MPI test #2 (div_mpi): " );
- if( mpi_cmp_mpi( &X, &U ) != 0 ||
- mpi_cmp_mpi( &Y, &V ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 ||
+ mbedtls_mpi_cmp_mpi( &Y, &V ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
- MPI_CHK( mpi_exp_mod( &X, &A, &E, &N, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &X, &A, &E, &N, NULL ) );
- MPI_CHK( mpi_read_string( &U, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"36E139AEA55215609D2816998ED020BB" \
"BD96C37890F65171D948E9BC7CBAA4D9" \
"325D24D6A3C12710F10A09FA08AB87" ) );
if( verbose != 0 )
- polarssl_printf( " MPI test #3 (exp_mod): " );
+ mbedtls_printf( " MPI test #3 (exp_mod): " );
- if( mpi_cmp_mpi( &X, &U ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
- MPI_CHK( mpi_inv_mod( &X, &A, &N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &X, &A, &N ) );
- MPI_CHK( mpi_read_string( &U, 16,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"003A0AAEDD7E784FC07D8F9EC6E3BFD5" \
"C3DBA76456363A10869622EAC2DD84EC" \
"C5B8A74DAC4D09E03B5E0BE779F2DF61" ) );
if( verbose != 0 )
- polarssl_printf( " MPI test #4 (inv_mod): " );
+ mbedtls_printf( " MPI test #4 (inv_mod): " );
- if( mpi_cmp_mpi( &X, &U ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " MPI test #5 (simple gcd): " );
+ mbedtls_printf( " MPI test #5 (simple gcd): " );
for( i = 0; i < GCD_PAIR_COUNT; i++ )
{
- MPI_CHK( mpi_lset( &X, gcd_pairs[i][0] ) );
- MPI_CHK( mpi_lset( &Y, gcd_pairs[i][1] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &X, gcd_pairs[i][0] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Y, gcd_pairs[i][1] ) );
- MPI_CHK( mpi_gcd( &A, &X, &Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &A, &X, &Y ) );
- if( mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
+ if( mbedtls_mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed at %d\n", i );
+ mbedtls_printf( "failed at %d\n", i );
ret = 1;
goto cleanup;
@@ -2316,22 +2316,22 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
cleanup:
if( ret != 0 && verbose != 0 )
- polarssl_printf( "Unexpected error, return code = %08X\n", ret );
+ mbedtls_printf( "Unexpected error, return code = %08X\n", ret );
- mpi_free( &A ); mpi_free( &E ); mpi_free( &N ); mpi_free( &X );
- mpi_free( &Y ); mpi_free( &U ); mpi_free( &V );
+ mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N ); mbedtls_mpi_free( &X );
+ mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &U ); mbedtls_mpi_free( &V );
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_BIGNUM_C */
+#endif /* MBEDTLS_BIGNUM_C */
diff --git a/library/blowfish.c b/library/blowfish.c
index 76ceb86..84cf0d8 100644
--- a/library/blowfish.c
+++ b/library/blowfish.c
@@ -26,22 +26,22 @@
*
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_BLOWFISH_C)
+#if defined(MBEDTLS_BLOWFISH_C)
#include "mbedtls/blowfish.h"
#include <string.h>
-#if !defined(POLARSSL_BLOWFISH_ALT)
+#if !defined(MBEDTLS_BLOWFISH_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -68,7 +68,7 @@
}
#endif
-static const uint32_t P[BLOWFISH_ROUNDS + 2] = {
+static const uint32_t P[MBEDTLS_BLOWFISH_ROUNDS + 2] = {
0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L,
0xA4093822L, 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L,
0x452821E6L, 0x38D01377L, 0xBE5466CFL, 0x34E90C6CL,
@@ -79,7 +79,7 @@
/* declarations of data at the end of this file */
static const uint32_t S[4][256];
-static uint32_t F( blowfish_context *ctx, uint32_t x )
+static uint32_t F( mbedtls_blowfish_context *ctx, uint32_t x )
{
unsigned short a, b, c, d;
uint32_t y;
@@ -98,7 +98,7 @@
return( y );
}
-static void blowfish_enc( blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
+static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
@@ -106,7 +106,7 @@
Xl = *xl;
Xr = *xr;
- for( i = 0; i < BLOWFISH_ROUNDS; ++i )
+ for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
@@ -120,14 +120,14 @@
Xl = Xr;
Xr = temp;
- Xr = Xr ^ ctx->P[BLOWFISH_ROUNDS];
- Xl = Xl ^ ctx->P[BLOWFISH_ROUNDS + 1];
+ Xr = Xr ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS];
+ Xl = Xl ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS + 1];
*xl = Xl;
*xr = Xr;
}
-static void blowfish_dec( blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
+static void blowfish_dec( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
@@ -135,7 +135,7 @@
Xl = *xl;
Xr = *xr;
- for( i = BLOWFISH_ROUNDS + 1; i > 1; --i )
+ for( i = MBEDTLS_BLOWFISH_ROUNDS + 1; i > 1; --i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
@@ -156,32 +156,32 @@
*xr = Xr;
}
-void blowfish_init( blowfish_context *ctx )
+void mbedtls_blowfish_init( mbedtls_blowfish_context *ctx )
{
- memset( ctx, 0, sizeof( blowfish_context ) );
+ memset( ctx, 0, sizeof( mbedtls_blowfish_context ) );
}
-void blowfish_free( blowfish_context *ctx )
+void mbedtls_blowfish_free( mbedtls_blowfish_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( blowfish_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_blowfish_context ) );
}
/*
* Blowfish key schedule
*/
-int blowfish_setkey( blowfish_context *ctx, const unsigned char *key,
+int mbedtls_blowfish_setkey( mbedtls_blowfish_context *ctx, const unsigned char *key,
unsigned int keysize )
{
unsigned int i, j, k;
uint32_t data, datal, datar;
- if( keysize < BLOWFISH_MIN_KEY || keysize > BLOWFISH_MAX_KEY ||
+ if( keysize < MBEDTLS_BLOWFISH_MIN_KEY || keysize > MBEDTLS_BLOWFISH_MAX_KEY ||
( keysize % 8 ) )
{
- return( POLARSSL_ERR_BLOWFISH_INVALID_KEY_LENGTH );
+ return( MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH );
}
keysize >>= 3;
@@ -193,7 +193,7 @@
}
j = 0;
- for( i = 0; i < BLOWFISH_ROUNDS + 2; ++i )
+ for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS + 2; ++i )
{
data = 0x00000000;
for( k = 0; k < 4; ++k )
@@ -208,7 +208,7 @@
datal = 0x00000000;
datar = 0x00000000;
- for( i = 0; i < BLOWFISH_ROUNDS + 2; i += 2 )
+ for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS + 2; i += 2 )
{
blowfish_enc( ctx, &datal, &datar );
ctx->P[i] = datal;
@@ -230,21 +230,21 @@
/*
* Blowfish-ECB block encryption/decryption
*/
-int blowfish_crypt_ecb( blowfish_context *ctx,
+int mbedtls_blowfish_crypt_ecb( mbedtls_blowfish_context *ctx,
int mode,
- const unsigned char input[BLOWFISH_BLOCKSIZE],
- unsigned char output[BLOWFISH_BLOCKSIZE] )
+ const unsigned char input[MBEDTLS_BLOWFISH_BLOCKSIZE],
+ unsigned char output[MBEDTLS_BLOWFISH_BLOCKSIZE] )
{
uint32_t X0, X1;
GET_UINT32_BE( X0, input, 0 );
GET_UINT32_BE( X1, input, 4 );
- if( mode == BLOWFISH_DECRYPT )
+ if( mode == MBEDTLS_BLOWFISH_DECRYPT )
{
blowfish_dec( ctx, &X0, &X1 );
}
- else /* BLOWFISH_ENCRYPT */
+ else /* MBEDTLS_BLOWFISH_ENCRYPT */
{
blowfish_enc( ctx, &X0, &X1 );
}
@@ -255,87 +255,87 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* Blowfish-CBC buffer encryption/decryption
*/
-int blowfish_crypt_cbc( blowfish_context *ctx,
+int mbedtls_blowfish_crypt_cbc( mbedtls_blowfish_context *ctx,
int mode,
size_t length,
- unsigned char iv[BLOWFISH_BLOCKSIZE],
+ unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
unsigned char *output )
{
int i;
- unsigned char temp[BLOWFISH_BLOCKSIZE];
+ unsigned char temp[MBEDTLS_BLOWFISH_BLOCKSIZE];
- if( length % BLOWFISH_BLOCKSIZE )
- return( POLARSSL_ERR_BLOWFISH_INVALID_INPUT_LENGTH );
+ if( length % MBEDTLS_BLOWFISH_BLOCKSIZE )
+ return( MBEDTLS_ERR_BLOWFISH_INVALID_INPUT_LENGTH );
- if( mode == BLOWFISH_DECRYPT )
+ if( mode == MBEDTLS_BLOWFISH_DECRYPT )
{
while( length > 0 )
{
- memcpy( temp, input, BLOWFISH_BLOCKSIZE );
- blowfish_crypt_ecb( ctx, mode, input, output );
+ memcpy( temp, input, MBEDTLS_BLOWFISH_BLOCKSIZE );
+ mbedtls_blowfish_crypt_ecb( ctx, mode, input, output );
- for( i = 0; i < BLOWFISH_BLOCKSIZE;i++ )
+ for( i = 0; i < MBEDTLS_BLOWFISH_BLOCKSIZE;i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
- memcpy( iv, temp, BLOWFISH_BLOCKSIZE );
+ memcpy( iv, temp, MBEDTLS_BLOWFISH_BLOCKSIZE );
- input += BLOWFISH_BLOCKSIZE;
- output += BLOWFISH_BLOCKSIZE;
- length -= BLOWFISH_BLOCKSIZE;
+ input += MBEDTLS_BLOWFISH_BLOCKSIZE;
+ output += MBEDTLS_BLOWFISH_BLOCKSIZE;
+ length -= MBEDTLS_BLOWFISH_BLOCKSIZE;
}
}
else
{
while( length > 0 )
{
- for( i = 0; i < BLOWFISH_BLOCKSIZE; i++ )
+ for( i = 0; i < MBEDTLS_BLOWFISH_BLOCKSIZE; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- blowfish_crypt_ecb( ctx, mode, output, output );
- memcpy( iv, output, BLOWFISH_BLOCKSIZE );
+ mbedtls_blowfish_crypt_ecb( ctx, mode, output, output );
+ memcpy( iv, output, MBEDTLS_BLOWFISH_BLOCKSIZE );
- input += BLOWFISH_BLOCKSIZE;
- output += BLOWFISH_BLOCKSIZE;
- length -= BLOWFISH_BLOCKSIZE;
+ input += MBEDTLS_BLOWFISH_BLOCKSIZE;
+ output += MBEDTLS_BLOWFISH_BLOCKSIZE;
+ length -= MBEDTLS_BLOWFISH_BLOCKSIZE;
}
}
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* Blowfish CFB buffer encryption/decryption
*/
-int blowfish_crypt_cfb64( blowfish_context *ctx,
+int mbedtls_blowfish_crypt_cfb64( mbedtls_blowfish_context *ctx,
int mode,
size_t length,
size_t *iv_off,
- unsigned char iv[BLOWFISH_BLOCKSIZE],
+ unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
unsigned char *output )
{
int c;
size_t n = *iv_off;
- if( mode == BLOWFISH_DECRYPT )
+ if( mode == MBEDTLS_BLOWFISH_DECRYPT )
{
while( length-- )
{
if( n == 0 )
- blowfish_crypt_ecb( ctx, BLOWFISH_ENCRYPT, iv, iv );
+ mbedtls_blowfish_crypt_ecb( ctx, MBEDTLS_BLOWFISH_ENCRYPT, iv, iv );
c = *input++;
*output++ = (unsigned char)( c ^ iv[n] );
iv[n] = (unsigned char) c;
- n = ( n + 1 ) % BLOWFISH_BLOCKSIZE;
+ n = ( n + 1 ) % MBEDTLS_BLOWFISH_BLOCKSIZE;
}
}
else
@@ -343,11 +343,11 @@
while( length-- )
{
if( n == 0 )
- blowfish_crypt_ecb( ctx, BLOWFISH_ENCRYPT, iv, iv );
+ mbedtls_blowfish_crypt_ecb( ctx, MBEDTLS_BLOWFISH_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
- n = ( n + 1 ) % BLOWFISH_BLOCKSIZE;
+ n = ( n + 1 ) % MBEDTLS_BLOWFISH_BLOCKSIZE;
}
}
@@ -355,17 +355,17 @@
return( 0 );
}
-#endif /*POLARSSL_CIPHER_MODE_CFB */
+#endif /*MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* Blowfish CTR buffer encryption/decryption
*/
-int blowfish_crypt_ctr( blowfish_context *ctx,
+int mbedtls_blowfish_crypt_ctr( mbedtls_blowfish_context *ctx,
size_t length,
size_t *nc_off,
- unsigned char nonce_counter[BLOWFISH_BLOCKSIZE],
- unsigned char stream_block[BLOWFISH_BLOCKSIZE],
+ unsigned char nonce_counter[MBEDTLS_BLOWFISH_BLOCKSIZE],
+ unsigned char stream_block[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
unsigned char *output )
{
@@ -375,24 +375,24 @@
while( length-- )
{
if( n == 0 ) {
- blowfish_crypt_ecb( ctx, BLOWFISH_ENCRYPT, nonce_counter,
+ mbedtls_blowfish_crypt_ecb( ctx, MBEDTLS_BLOWFISH_ENCRYPT, nonce_counter,
stream_block );
- for( i = BLOWFISH_BLOCKSIZE; i > 0; i-- )
+ for( i = MBEDTLS_BLOWFISH_BLOCKSIZE; i > 0; i-- )
if( ++nonce_counter[i - 1] != 0 )
break;
}
c = *input++;
*output++ = (unsigned char)( c ^ stream_block[n] );
- n = ( n + 1 ) % BLOWFISH_BLOCKSIZE;
+ n = ( n + 1 ) % MBEDTLS_BLOWFISH_BLOCKSIZE;
}
*nc_off = n;
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
static const uint32_t S[4][256] = {
{ 0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L,
@@ -653,5 +653,5 @@
0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L, 0x3AC372E6L }
};
-#endif /* !POLARSSL_BLOWFISH_ALT */
-#endif /* POLARSSL_BLOWFISH_C */
+#endif /* !MBEDTLS_BLOWFISH_ALT */
+#endif /* MBEDTLS_BLOWFISH_C */
diff --git a/library/camellia.c b/library/camellia.c
index 1aa6516..c9df94a 100644
--- a/library/camellia.c
+++ b/library/camellia.c
@@ -26,31 +26,31 @@
* http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/01espec.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_CAMELLIA_C)
+#if defined(MBEDTLS_CAMELLIA_C)
#include "mbedtls/camellia.h"
#include <string.h>
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if !defined(POLARSSL_CAMELLIA_ALT)
+#if !defined(MBEDTLS_CAMELLIA_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -87,7 +87,7 @@
{ 0xb0, 0x56, 0x88, 0xc2, 0xb3, 0xe6, 0xc1, 0xfd }
};
-#if defined(POLARSSL_CAMELLIA_SMALL_MEMORY)
+#if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
static const unsigned char FSb[256] =
{
@@ -114,7 +114,7 @@
#define SBOX3(n) (unsigned char)((FSb[(n)] >> 1 ^ FSb[(n)] << 7) & 0xff)
#define SBOX4(n) FSb[((n) << 1 ^ (n) >> 7) &0xff]
-#else /* POLARSSL_CAMELLIA_SMALL_MEMORY */
+#else /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
static const unsigned char FSb[256] =
{
@@ -201,7 +201,7 @@
#define SBOX3(n) FSb3[(n)]
#define SBOX4(n) FSb4[(n)]
-#endif /* POLARSSL_CAMELLIA_SMALL_MEMORY */
+#endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
static const unsigned char shifts[2][4][4] =
{
@@ -324,23 +324,23 @@
z[1] ^= I0;
}
-void camellia_init( camellia_context *ctx )
+void mbedtls_camellia_init( mbedtls_camellia_context *ctx )
{
- memset( ctx, 0, sizeof( camellia_context ) );
+ memset( ctx, 0, sizeof( mbedtls_camellia_context ) );
}
-void camellia_free( camellia_context *ctx )
+void mbedtls_camellia_free( mbedtls_camellia_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( camellia_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_camellia_context ) );
}
/*
* Camellia key schedule (encryption)
*/
-int camellia_setkey_enc( camellia_context *ctx, const unsigned char *key,
+int mbedtls_camellia_setkey_enc( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keysize )
{
int idx;
@@ -361,7 +361,7 @@
case 128: ctx->nr = 3; idx = 0; break;
case 192:
case 256: ctx->nr = 4; idx = 1; break;
- default : return( POLARSSL_ERR_CAMELLIA_INVALID_KEY_LENGTH );
+ default : return( MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH );
}
for( i = 0; i < keysize / 8; ++i )
@@ -445,19 +445,19 @@
/*
* Camellia key schedule (decryption)
*/
-int camellia_setkey_dec( camellia_context *ctx, const unsigned char *key,
+int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keysize )
{
int idx, ret;
size_t i;
- camellia_context cty;
+ mbedtls_camellia_context cty;
uint32_t *RK;
uint32_t *SK;
- camellia_init( &cty );
+ mbedtls_camellia_init( &cty );
/* Also checks keysize */
- if( ( ret = camellia_setkey_enc( &cty, key, keysize ) ) != 0 )
+ if( ( ret = mbedtls_camellia_setkey_enc( &cty, key, keysize ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
@@ -485,7 +485,7 @@
*RK++ = *SK++;
exit:
- camellia_free( &cty );
+ mbedtls_camellia_free( &cty );
return( ret );
}
@@ -493,7 +493,7 @@
/*
* Camellia-ECB block encryption/decryption
*/
-int camellia_crypt_ecb( camellia_context *ctx,
+int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
@@ -552,11 +552,11 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* Camellia-CBC buffer encryption/decryption
*/
-int camellia_crypt_cbc( camellia_context *ctx,
+int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
@@ -567,14 +567,14 @@
unsigned char temp[16];
if( length % 16 )
- return( POLARSSL_ERR_CAMELLIA_INVALID_INPUT_LENGTH );
+ return( MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH );
- if( mode == CAMELLIA_DECRYPT )
+ if( mode == MBEDTLS_CAMELLIA_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
- camellia_crypt_ecb( ctx, mode, input, output );
+ mbedtls_camellia_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
@@ -593,7 +593,7 @@
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- camellia_crypt_ecb( ctx, mode, output, output );
+ mbedtls_camellia_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
@@ -604,13 +604,13 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* Camellia-CFB128 buffer encryption/decryption
*/
-int camellia_crypt_cfb128( camellia_context *ctx,
+int mbedtls_camellia_crypt_cfb128( mbedtls_camellia_context *ctx,
int mode,
size_t length,
size_t *iv_off,
@@ -621,12 +621,12 @@
int c;
size_t n = *iv_off;
- if( mode == CAMELLIA_DECRYPT )
+ if( mode == MBEDTLS_CAMELLIA_DECRYPT )
{
while( length-- )
{
if( n == 0 )
- camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, iv, iv );
+ mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, iv, iv );
c = *input++;
*output++ = (unsigned char)( c ^ iv[n] );
@@ -640,7 +640,7 @@
while( length-- )
{
if( n == 0 )
- camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, iv, iv );
+ mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
@@ -652,13 +652,13 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* Camellia-CTR buffer encryption/decryption
*/
-int camellia_crypt_ctr( camellia_context *ctx,
+int mbedtls_camellia_crypt_ctr( mbedtls_camellia_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
@@ -672,7 +672,7 @@
while( length-- )
{
if( n == 0 ) {
- camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, nonce_counter,
+ mbedtls_camellia_crypt_ecb( ctx, MBEDTLS_CAMELLIA_ENCRYPT, nonce_counter,
stream_block );
for( i = 16; i > 0; i-- )
@@ -689,10 +689,10 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
-#endif /* !POLARSSL_CAMELLIA_ALT */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
+#endif /* !MBEDTLS_CAMELLIA_ALT */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* Camellia test vectors from:
@@ -762,7 +762,7 @@
}
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
#define CAMELLIA_TESTS_CBC 3
static const unsigned char camellia_test_cbc_key[3][32] =
@@ -824,9 +824,9 @@
0x33, 0x30, 0xCD, 0xF1, 0xB1, 0x86, 0x0A, 0x83 }
}
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* Camellia-CTR test vectors from:
*
@@ -887,28 +887,28 @@
static const int camellia_test_ctr_len[3] =
{ 16, 32, 36 };
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
/*
* Checkup routine
*/
-int camellia_self_test( int verbose )
+int mbedtls_camellia_self_test( int verbose )
{
int i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char src[16];
unsigned char dst[16];
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[16];
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
size_t offset, len;
unsigned char nonce_counter[16];
unsigned char stream_block[16];
#endif
- camellia_context ctx;
+ mbedtls_camellia_context ctx;
memset( key, 0, 32 );
@@ -917,41 +917,41 @@
v = j & 1;
if( verbose != 0 )
- polarssl_printf( " CAMELLIA-ECB-%3d (%s): ", 128 + u * 64,
- (v == CAMELLIA_DECRYPT) ? "dec" : "enc");
+ mbedtls_printf( " CAMELLIA-ECB-%3d (%s): ", 128 + u * 64,
+ (v == MBEDTLS_CAMELLIA_DECRYPT) ? "dec" : "enc");
for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) {
memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u );
- if( v == CAMELLIA_DECRYPT ) {
- camellia_setkey_dec( &ctx, key, 128 + u * 64 );
+ if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
+ mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
memcpy( src, camellia_test_ecb_cipher[u][i], 16 );
memcpy( dst, camellia_test_ecb_plain[i], 16 );
- } else { /* CAMELLIA_ENCRYPT */
- camellia_setkey_enc( &ctx, key, 128 + u * 64 );
+ } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
+ mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
memcpy( src, camellia_test_ecb_plain[i], 16 );
memcpy( dst, camellia_test_ecb_cipher[u][i], 16 );
}
- camellia_crypt_ecb( &ctx, v, src, buf );
+ mbedtls_camellia_crypt_ecb( &ctx, v, src, buf );
if( memcmp( buf, dst, 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
@@ -961,51 +961,51 @@
v = j & 1;
if( verbose != 0 )
- polarssl_printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64,
- ( v == CAMELLIA_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64,
+ ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
memcpy( src, camellia_test_cbc_iv, 16 );
memcpy( dst, camellia_test_cbc_iv, 16 );
memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u );
- if( v == CAMELLIA_DECRYPT ) {
- camellia_setkey_dec( &ctx, key, 128 + u * 64 );
+ if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
+ mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
} else {
- camellia_setkey_enc( &ctx, key, 128 + u * 64 );
+ mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
}
for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) {
- if( v == CAMELLIA_DECRYPT ) {
+ if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
memcpy( iv , src, 16 );
memcpy( src, camellia_test_cbc_cipher[u][i], 16 );
memcpy( dst, camellia_test_cbc_plain[i], 16 );
- } else { /* CAMELLIA_ENCRYPT */
+ } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
memcpy( iv , dst, 16 );
memcpy( src, camellia_test_cbc_plain[i], 16 );
memcpy( dst, camellia_test_cbc_cipher[u][i], 16 );
}
- camellia_crypt_cbc( &ctx, v, 16, iv, src, buf );
+ mbedtls_camellia_crypt_cbc( &ctx, v, 16, iv, src, buf );
if( memcmp( buf, dst, 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* CTR mode
*/
@@ -1015,27 +1015,27 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " CAMELLIA-CTR-128 (%s): ",
- ( v == CAMELLIA_DECRYPT ) ? "dec" : "enc" );
+ mbedtls_printf( " CAMELLIA-CTR-128 (%s): ",
+ ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 );
memcpy( key, camellia_test_ctr_key[u], 16 );
offset = 0;
- camellia_setkey_enc( &ctx, key, 128 );
+ mbedtls_camellia_setkey_enc( &ctx, key, 128 );
- if( v == CAMELLIA_DECRYPT )
+ if( v == MBEDTLS_CAMELLIA_DECRYPT )
{
len = camellia_test_ctr_len[u];
memcpy( buf, camellia_test_ctr_ct[u], len );
- camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
+ mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, camellia_test_ctr_pt[u], len ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
@@ -1045,29 +1045,29 @@
len = camellia_test_ctr_len[u];
memcpy( buf, camellia_test_ctr_pt[u], len );
- camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
+ mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, camellia_test_ctr_ct[u], len ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+ mbedtls_printf( "\n" );
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_CAMELLIA_C */
diff --git a/library/ccm.c b/library/ccm.c
index 6f3db01..72eed38 100644
--- a/library/ccm.c
+++ b/library/ccm.c
@@ -29,29 +29,29 @@
* RFC 5116 "An Interface and Algorithms for Authenticated Encryption"
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
#include "mbedtls/ccm.h"
#include <string.h>
-#if defined(POLARSSL_SELF_TEST) && defined(POLARSSL_AES_C)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST && POLARSSL_AES_C */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -61,28 +61,28 @@
/*
* Initialize context
*/
-int ccm_init( ccm_context *ctx, cipher_id_t cipher,
+int mbedtls_ccm_init( mbedtls_ccm_context *ctx, mbedtls_cipher_id_t cipher,
const unsigned char *key, unsigned int keysize )
{
int ret;
- const cipher_info_t *cipher_info;
+ const mbedtls_cipher_info_t *cipher_info;
- memset( ctx, 0, sizeof( ccm_context ) );
+ memset( ctx, 0, sizeof( mbedtls_ccm_context ) );
- cipher_init( &ctx->cipher_ctx );
+ mbedtls_cipher_init( &ctx->cipher_ctx );
- cipher_info = cipher_info_from_values( cipher, keysize, POLARSSL_MODE_ECB );
+ cipher_info = mbedtls_cipher_info_from_values( cipher, keysize, MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
if( cipher_info->block_size != 16 )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
- if( ( ret = cipher_init_ctx( &ctx->cipher_ctx, cipher_info ) ) != 0 )
+ if( ( ret = mbedtls_cipher_init_ctx( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
- if( ( ret = cipher_setkey( &ctx->cipher_ctx, key, keysize,
- POLARSSL_ENCRYPT ) ) != 0 )
+ if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keysize,
+ MBEDTLS_ENCRYPT ) ) != 0 )
{
return( ret );
}
@@ -93,10 +93,10 @@
/*
* Free context
*/
-void ccm_free( ccm_context *ctx )
+void mbedtls_ccm_free( mbedtls_ccm_context *ctx )
{
- cipher_free( &ctx->cipher_ctx );
- polarssl_zeroize( ctx, sizeof( ccm_context ) );
+ mbedtls_cipher_free( &ctx->cipher_ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_ccm_context ) );
}
/*
@@ -112,7 +112,7 @@
for( i = 0; i < 16; i++ ) \
y[i] ^= b[i]; \
\
- if( ( ret = cipher_update( &ctx->cipher_ctx, y, 16, y, &olen ) ) != 0 ) \
+ if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, y, 16, y, &olen ) ) != 0 ) \
return( ret );
/*
@@ -121,7 +121,7 @@
* This avoids allocating one more 16 bytes buffer while allowing src == dst.
*/
#define CTR_CRYPT( dst, src, len ) \
- if( ( ret = cipher_update( &ctx->cipher_ctx, ctr, 16, b, &olen ) ) != 0 ) \
+ if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctr, 16, b, &olen ) ) != 0 ) \
return( ret ); \
\
for( i = 0; i < len; i++ ) \
@@ -130,7 +130,7 @@
/*
* Authenticated encryption or decryption
*/
-static int ccm_auth_crypt( ccm_context *ctx, int mode, size_t length,
+static int ccm_auth_crypt( mbedtls_ccm_context *ctx, int mode, size_t length,
const unsigned char *iv, size_t iv_len,
const unsigned char *add, size_t add_len,
const unsigned char *input, unsigned char *output,
@@ -152,14 +152,14 @@
* 'length' checked later (when writing it to the first block)
*/
if( tag_len < 4 || tag_len > 16 || tag_len % 2 != 0 )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
/* Also implies q is within bounds */
if( iv_len < 7 || iv_len > 13 )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
if( add_len > 0xFF00 )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
/*
* First block B_0:
@@ -184,7 +184,7 @@
b[15-i] = (unsigned char)( len_left & 0xFF );
if( len_left > 0 )
- return( POLARSSL_ERR_CCM_BAD_INPUT );
+ return( MBEDTLS_ERR_CCM_BAD_INPUT );
/* Start CBC-MAC with first block */
@@ -298,7 +298,7 @@
/*
* Authenticated encryption
*/
-int ccm_encrypt_and_tag( ccm_context *ctx, size_t length,
+int mbedtls_ccm_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length,
const unsigned char *iv, size_t iv_len,
const unsigned char *add, size_t add_len,
const unsigned char *input, unsigned char *output,
@@ -311,7 +311,7 @@
/*
* Authenticated decryption
*/
-int ccm_auth_decrypt( ccm_context *ctx, size_t length,
+int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
const unsigned char *iv, size_t iv_len,
const unsigned char *add, size_t add_len,
const unsigned char *input, unsigned char *output,
@@ -335,15 +335,15 @@
if( diff != 0 )
{
- polarssl_zeroize( output, length );
- return( POLARSSL_ERR_CCM_AUTH_FAILED );
+ mbedtls_zeroize( output, length );
+ return( MBEDTLS_ERR_CCM_AUTH_FAILED );
}
return( 0 );
}
-#if defined(POLARSSL_SELF_TEST) && defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
/*
* Examples 1 to 3 from SP800-38C Appendix C
*/
@@ -391,17 +391,17 @@
0x48, 0x43, 0x92, 0xfb, 0xc1, 0xb0, 0x99, 0x51 }
};
-int ccm_self_test( int verbose )
+int mbedtls_ccm_self_test( int verbose )
{
- ccm_context ctx;
+ mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
- if( ccm_init( &ctx, POLARSSL_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
+ if( mbedtls_ccm_init( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( " CCM: setup failed" );
+ mbedtls_printf( " CCM: setup failed" );
return( 1 );
}
@@ -409,9 +409,9 @@
for( i = 0; i < NB_TESTS; i++ )
{
if( verbose != 0 )
- polarssl_printf( " CCM-AES #%u: ", (unsigned int) i + 1 );
+ mbedtls_printf( " CCM-AES #%u: ", (unsigned int) i + 1 );
- ret = ccm_encrypt_and_tag( &ctx, msg_len[i],
+ ret = mbedtls_ccm_encrypt_and_tag( &ctx, msg_len[i],
iv, iv_len[i], ad, add_len[i],
msg, out,
out + msg_len[i], tag_len[i] );
@@ -420,12 +420,12 @@
memcmp( out, res[i], msg_len[i] + tag_len[i] ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- ret = ccm_auth_decrypt( &ctx, msg_len[i],
+ ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len[i],
iv, iv_len[i], ad, add_len[i],
res[i], out,
res[i] + msg_len[i], tag_len[i] );
@@ -434,23 +434,23 @@
memcmp( out, msg, msg_len[i] ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
- ccm_free( &ctx );
+ mbedtls_ccm_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST && POLARSSL_AES_C */
+#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
diff --git a/library/certs.c b/library/certs.c
index 13f89e0..8c7ec8f 100644
--- a/library/certs.c
+++ b/library/certs.c
@@ -20,17 +20,17 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
#include "mbedtls/certs.h"
-#if defined(POLARSSL_CERTS_C)
+#if defined(MBEDTLS_CERTS_C)
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#define TEST_CA_CRT_EC \
"-----BEGIN CERTIFICATE-----\r\n" \
"MIICUjCCAdegAwIBAgIJAMFD4n5iQ8zoMAoGCCqGSM49BAMCMD4xCzAJBgNVBAYT\r\n" \
@@ -47,9 +47,9 @@
"t4d0PCu412mUC6Nnd7izvtE2MgIxAP1nnJQjZ8BWukszFQDG48wxCCyci9qpdSMv\r\n" \
"uCjn8pwUOkABXK8Mss90fzCfCEOtIA==\r\n" \
"-----END CERTIFICATE-----\r\n"
-const char test_ca_crt_ec[] = TEST_CA_CRT_EC;
+const char mbedtls_test_ca_crt_ec[] = TEST_CA_CRT_EC;
-const char test_ca_key_ec[] =
+const char mbedtls_test_ca_key_ec[] =
"-----BEGIN EC PRIVATE KEY-----\r\n"
"Proc-Type: 4,ENCRYPTED\r\n"
"DEK-Info: DES-EDE3-CBC,307EAB469933D64E\r\n"
@@ -60,9 +60,9 @@
"a77x/sY1Bvii8S9/XhDTb6pTMx06wzrm\r\n"
"-----END EC PRIVATE KEY-----\r\n";
-const char test_ca_pwd_ec[] = "PolarSSLTest";
+const char mbedtls_test_ca_pwd_ec[] = "PolarSSLTest";
-const char test_srv_crt_ec[] =
+const char mbedtls_test_srv_crt_ec[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIICHzCCAaWgAwIBAgIBCTAKBggqhkjOPQQDAjA+MQswCQYDVQQGEwJOTDERMA8G\r\n"
"A1UEChMIUG9sYXJTU0wxHDAaBgNVBAMTE1BvbGFyc3NsIFRlc3QgRUMgQ0EwHhcN\r\n"
@@ -78,14 +78,14 @@
"fGa5kHvHARBPc8YAIVIqDvHH1Q==\r\n"
"-----END CERTIFICATE-----\r\n";
-const char test_srv_key_ec[] =
+const char mbedtls_test_srv_key_ec[] =
"-----BEGIN EC PRIVATE KEY-----\r\n"
"MHcCAQEEIPEqEyB2AnCoPL/9U/YDHvdqXYbIogTywwyp6/UfDw6noAoGCCqGSM49\r\n"
"AwEHoUQDQgAEN8xW2XYJHlpyPsdZLf8gbu58+QaRdNCtFLX3aCJZYpJO5QDYIxH/\r\n"
"6i/SNF1dFr2KiMJrdw1VzYoqDvoByLTt/w==\r\n"
"-----END EC PRIVATE KEY-----\r\n";
-const char test_cli_crt_ec[] =
+const char mbedtls_test_cli_crt_ec[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIICLDCCAbKgAwIBAgIBDTAKBggqhkjOPQQDAjA+MQswCQYDVQQGEwJOTDERMA8G\r\n"
"A1UEChMIUG9sYXJTU0wxHDAaBgNVBAMTE1BvbGFyc3NsIFRlc3QgRUMgQ0EwHhcN\r\n"
@@ -101,25 +101,25 @@
"LwjQje5PDGHfd3h9tP38Qknu5bJqws0md2KOKHyeV0U=\r\n"
"-----END CERTIFICATE-----\r\n";
-const char test_cli_key_ec[] =
+const char mbedtls_test_cli_key_ec[] =
"-----BEGIN EC PRIVATE KEY-----\r\n"
"MHcCAQEEIPb3hmTxZ3/mZI3vyk7p3U3wBf+WIop6hDhkFzJhmLcqoAoGCCqGSM49\r\n"
"AwEHoUQDQgAEV+WusXPf06y7k7iB/xKu7uZTrM5VU/Y0Dswu42MlC9+Y4vNcYDaW\r\n"
"wNUYFHDlf5/VS0UY5bBs1Vz4lo+HcKPkxw==\r\n"
"-----END EC PRIVATE KEY-----\r\n";
-const size_t test_ca_crt_ec_len = sizeof( test_ca_crt_ec );
-const size_t test_ca_key_ec_len = sizeof( test_ca_key_ec );
-const size_t test_ca_pwd_ec_len = sizeof( test_ca_pwd_ec ) - 1;
-const size_t test_srv_crt_ec_len = sizeof( test_srv_crt_ec );
-const size_t test_srv_key_ec_len = sizeof( test_srv_key_ec );
-const size_t test_cli_crt_ec_len = sizeof( test_cli_crt_ec );
-const size_t test_cli_key_ec_len = sizeof( test_cli_key_ec );
+const size_t mbedtls_test_ca_crt_ec_len = sizeof( mbedtls_test_ca_crt_ec );
+const size_t mbedtls_test_ca_key_ec_len = sizeof( mbedtls_test_ca_key_ec );
+const size_t mbedtls_test_ca_pwd_ec_len = sizeof( mbedtls_test_ca_pwd_ec ) - 1;
+const size_t mbedtls_test_srv_crt_ec_len = sizeof( mbedtls_test_srv_crt_ec );
+const size_t mbedtls_test_srv_key_ec_len = sizeof( mbedtls_test_srv_key_ec );
+const size_t mbedtls_test_cli_crt_ec_len = sizeof( mbedtls_test_cli_crt_ec );
+const size_t mbedtls_test_cli_key_ec_len = sizeof( mbedtls_test_cli_key_ec );
#else
#define TEST_CA_CRT_EC
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#define TEST_CA_CRT_RSA \
"-----BEGIN CERTIFICATE-----\r\n" \
"MIIDhzCCAm+gAwIBAgIBADANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJOTDER\r\n" \
@@ -142,9 +142,9 @@
"m/UTSLBNFNHesiTZeH31NcxYGdHSme9Nc/gfidRa0FLOCfWxRlFqAI47zG9jAQCZ\r\n" \
"7Z2mCGDNMhjQc+BYcdnl0lPXjdDK6V0qCg1dVewhUBcW5gZKzV7e9+DpVA==\r\n" \
"-----END CERTIFICATE-----\r\n"
-const char test_ca_crt_rsa[] = TEST_CA_CRT_RSA;
+const char mbedtls_test_ca_crt_rsa[] = TEST_CA_CRT_RSA;
-const char test_ca_key_rsa[] =
+const char mbedtls_test_ca_key_rsa[] =
"-----BEGIN RSA PRIVATE KEY-----\r\n"
"Proc-Type: 4,ENCRYPTED\r\n"
"DEK-Info: DES-EDE3-CBC,A8A95B05D5B7206B\r\n"
@@ -176,9 +176,9 @@
"P/eQiddSf0brnpiLJRh7qZrl9XuqYdpUqnoEdMAfotDOID8OtV7gt8a48ad8VPW2\r\n"
"-----END RSA PRIVATE KEY-----\r\n";
-const char test_ca_pwd_rsa[] = "PolarSSLTest";
+const char mbedtls_test_ca_pwd_rsa[] = "PolarSSLTest";
-const char test_srv_crt_rsa[] =
+const char mbedtls_test_srv_crt_rsa[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIDNzCCAh+gAwIBAgIBAjANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJOTDER\r\n"
"MA8GA1UEChMIUG9sYXJTU0wxGTAXBgNVBAMTEFBvbGFyU1NMIFRlc3QgQ0EwHhcN\r\n"
@@ -200,7 +200,7 @@
"zhuYwjVuX6JHG0c=\r\n"
"-----END CERTIFICATE-----\r\n";
-const char test_srv_key_rsa[] =
+const char mbedtls_test_srv_key_rsa[] =
"-----BEGIN RSA PRIVATE KEY-----\r\n"
"MIIEpAIBAAKCAQEAwU2j3efNHdEE10lyuJmsDnjkOjxKzzoTFtBa5M2jAIin7h5r\r\n"
"lqdStJDvLXJ6PiSa/LY0rCT1d+AmZIycsCh9odrqjObJHJa8/sEEUrM21KP64bF2\r\n"
@@ -229,7 +229,7 @@
"TB6l9VGoxJL4fyHnZb8L5gGvnB1bbD8cL6YPaDiOhcRseC9vBiEuVg==\r\n"
"-----END RSA PRIVATE KEY-----\r\n";
-const char test_cli_crt_rsa[] =
+const char mbedtls_test_cli_crt_rsa[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIDPzCCAiegAwIBAgIBBDANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJOTDER\r\n"
"MA8GA1UEChMIUG9sYXJTU0wxGTAXBgNVBAMTEFBvbGFyU1NMIFRlc3QgQ0EwHhcN\r\n"
@@ -251,7 +251,7 @@
"D+stpAKiQLAWaAusIWKYEyw9MQ==\r\n"
"-----END CERTIFICATE-----\r\n";
-const char test_cli_key_rsa[] =
+const char mbedtls_test_cli_key_rsa[] =
"-----BEGIN RSA PRIVATE KEY-----\r\n"
"MIIEpAIBAAKCAQEAyHTEzLn5tXnpRdkUYLB9u5Pyax6fM60Nj4o8VmXl3ETZzGaF\r\n"
"B9X4J7BKNdBjngpuG7fa8H6r7gwQk4ZJGDTzqCrSV/Uu1C93KYRhTYJQj6eVSHD1\r\n"
@@ -280,83 +280,83 @@
"8u4ytY0F+Vlanj5lm3TaoHSVF1+NWPyOTiwevIECGKwSxvlki4fDAA==\r\n"
"-----END RSA PRIVATE KEY-----\r\n";
-const size_t test_ca_crt_rsa_len = sizeof( test_ca_crt_rsa );
-const size_t test_ca_key_rsa_len = sizeof( test_ca_key_rsa );
-const size_t test_ca_pwd_rsa_len = sizeof( test_ca_pwd_rsa ) - 1;
-const size_t test_srv_crt_rsa_len = sizeof( test_srv_crt_rsa );
-const size_t test_srv_key_rsa_len = sizeof( test_srv_key_rsa );
-const size_t test_cli_crt_rsa_len = sizeof( test_cli_crt_rsa );
-const size_t test_cli_key_rsa_len = sizeof( test_cli_key_rsa );
+const size_t mbedtls_test_ca_crt_rsa_len = sizeof( mbedtls_test_ca_crt_rsa );
+const size_t mbedtls_test_ca_key_rsa_len = sizeof( mbedtls_test_ca_key_rsa );
+const size_t mbedtls_test_ca_pwd_rsa_len = sizeof( mbedtls_test_ca_pwd_rsa ) - 1;
+const size_t mbedtls_test_srv_crt_rsa_len = sizeof( mbedtls_test_srv_crt_rsa );
+const size_t mbedtls_test_srv_key_rsa_len = sizeof( mbedtls_test_srv_key_rsa );
+const size_t mbedtls_test_cli_crt_rsa_len = sizeof( mbedtls_test_cli_crt_rsa );
+const size_t mbedtls_test_cli_key_rsa_len = sizeof( mbedtls_test_cli_key_rsa );
#else
#define TEST_CA_CRT_RSA
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_DHM_C)
-const char test_dhm_params[] =
+#if defined(MBEDTLS_DHM_C)
+const char mbedtls_test_dhm_params[] =
"-----BEGIN DH PARAMETERS-----\r\n"
"MIGHAoGBAJ419DBEOgmQTzo5qXl5fQcN9TN455wkOL7052HzxxRVMyhYmwQcgJvh\r\n"
"1sa18fyfR9OiVEMYglOpkqVoGLN7qd5aQNNi5W7/C+VBdHTBJcGZJyyP5B3qcz32\r\n"
"9mLJKudlVudV0Qxk5qUJaPZ/xupz0NyoVpviuiBOI1gNi8ovSXWzAgEC\r\n"
"-----END DH PARAMETERS-----\r\n";
-const size_t test_dhm_params_len = sizeof( test_dhm_params );
+const size_t mbedtls_test_dhm_params_len = sizeof( mbedtls_test_dhm_params );
#endif
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
/* Concatenation of all available CA certificates */
-const char test_cas_pem[] = TEST_CA_CRT_RSA TEST_CA_CRT_EC;
-const size_t test_cas_pem_len = sizeof( test_cas_pem );
+const char mbedtls_test_cas_pem[] = TEST_CA_CRT_RSA TEST_CA_CRT_EC;
+const size_t mbedtls_test_cas_pem_len = sizeof( mbedtls_test_cas_pem );
#endif
/* List of all available CA certificates */
-const char * test_cas[] = {
-#if defined(POLARSSL_RSA_C)
- test_ca_crt_rsa,
+const char * mbedtls_test_cas[] = {
+#if defined(MBEDTLS_RSA_C)
+ mbedtls_test_ca_crt_rsa,
#endif
-#if defined(POLARSSL_ECDSA_C)
- test_ca_crt_ec,
+#if defined(MBEDTLS_ECDSA_C)
+ mbedtls_test_ca_crt_ec,
#endif
NULL
};
-const size_t test_cas_len[] = {
-#if defined(POLARSSL_RSA_C)
- sizeof( test_ca_crt_rsa_len ),
+const size_t mbedtls_test_cas_len[] = {
+#if defined(MBEDTLS_RSA_C)
+ sizeof( mbedtls_test_ca_crt_rsa_len ),
#endif
-#if defined(POLARSSL_ECDSA_C)
- sizeof( test_ca_crt_ec_len ),
+#if defined(MBEDTLS_ECDSA_C)
+ sizeof( mbedtls_test_ca_crt_ec_len ),
#endif
0
};
-#if defined(POLARSSL_RSA_C)
-const char *test_ca_crt = test_ca_crt_rsa;
-const char *test_ca_key = test_ca_key_rsa;
-const char *test_ca_pwd = test_ca_pwd_rsa;
-const char *test_srv_crt = test_srv_crt_rsa;
-const char *test_srv_key = test_srv_key_rsa;
-const char *test_cli_crt = test_cli_crt_rsa;
-const char *test_cli_key = test_cli_key_rsa;
-const size_t test_ca_crt_len = sizeof( test_ca_crt_rsa );
-const size_t test_ca_key_len = sizeof( test_ca_key_rsa );
-const size_t test_ca_pwd_len = sizeof( test_ca_pwd_rsa ) - 1;
-const size_t test_srv_crt_len = sizeof( test_srv_crt_rsa );
-const size_t test_srv_key_len = sizeof( test_srv_key_rsa );
-const size_t test_cli_crt_len = sizeof( test_cli_crt_rsa );
-const size_t test_cli_key_len = sizeof( test_cli_key_rsa );
-#else /* ! POLARSSL_RSA_C, so POLARSSL_ECDSA_C */
-const char *test_ca_crt = test_ca_crt_ec;
-const char *test_ca_key = test_ca_key_ec;
-const char *test_ca_pwd = test_ca_pwd_ec;
-const char *test_srv_crt = test_srv_crt_ec;
-const char *test_srv_key = test_srv_key_ec;
-const char *test_cli_crt = test_cli_crt_ec;
-const char *test_cli_key = test_cli_key_ec;
-const size_t test_ca_crt_len = sizeof( test_ca_crt_ec );
-const size_t test_ca_key_len = sizeof( test_ca_key_ec );
-const size_t test_ca_pwd_len = sizeof( test_ca_pwd_ec ) - 1;
-const size_t test_srv_crt_len = sizeof( test_srv_crt_ec );
-const size_t test_srv_key_len = sizeof( test_srv_key_ec );
-const size_t test_cli_crt_len = sizeof( test_cli_crt_ec );
-const size_t test_cli_key_len = sizeof( test_cli_key_ec );
-#endif /* POLARSSL_RSA_C */
+#if defined(MBEDTLS_RSA_C)
+const char *mbedtls_test_ca_crt = mbedtls_test_ca_crt_rsa;
+const char *mbedtls_test_ca_key = mbedtls_test_ca_key_rsa;
+const char *mbedtls_test_ca_pwd = mbedtls_test_ca_pwd_rsa;
+const char *mbedtls_test_srv_crt = mbedtls_test_srv_crt_rsa;
+const char *mbedtls_test_srv_key = mbedtls_test_srv_key_rsa;
+const char *mbedtls_test_cli_crt = mbedtls_test_cli_crt_rsa;
+const char *mbedtls_test_cli_key = mbedtls_test_cli_key_rsa;
+const size_t mbedtls_test_ca_crt_len = sizeof( mbedtls_test_ca_crt_rsa );
+const size_t mbedtls_test_ca_key_len = sizeof( mbedtls_test_ca_key_rsa );
+const size_t mbedtls_test_ca_pwd_len = sizeof( mbedtls_test_ca_pwd_rsa ) - 1;
+const size_t mbedtls_test_srv_crt_len = sizeof( mbedtls_test_srv_crt_rsa );
+const size_t mbedtls_test_srv_key_len = sizeof( mbedtls_test_srv_key_rsa );
+const size_t mbedtls_test_cli_crt_len = sizeof( mbedtls_test_cli_crt_rsa );
+const size_t mbedtls_test_cli_key_len = sizeof( mbedtls_test_cli_key_rsa );
+#else /* ! MBEDTLS_RSA_C, so MBEDTLS_ECDSA_C */
+const char *mbedtls_test_ca_crt = mbedtls_test_ca_crt_ec;
+const char *mbedtls_test_ca_key = mbedtls_test_ca_key_ec;
+const char *mbedtls_test_ca_pwd = mbedtls_test_ca_pwd_ec;
+const char *mbedtls_test_srv_crt = mbedtls_test_srv_crt_ec;
+const char *mbedtls_test_srv_key = mbedtls_test_srv_key_ec;
+const char *mbedtls_test_cli_crt = mbedtls_test_cli_crt_ec;
+const char *mbedtls_test_cli_key = mbedtls_test_cli_key_ec;
+const size_t mbedtls_test_ca_crt_len = sizeof( mbedtls_test_ca_crt_ec );
+const size_t mbedtls_test_ca_key_len = sizeof( mbedtls_test_ca_key_ec );
+const size_t mbedtls_test_ca_pwd_len = sizeof( mbedtls_test_ca_pwd_ec ) - 1;
+const size_t mbedtls_test_srv_crt_len = sizeof( mbedtls_test_srv_crt_ec );
+const size_t mbedtls_test_srv_key_len = sizeof( mbedtls_test_srv_key_ec );
+const size_t mbedtls_test_cli_crt_len = sizeof( mbedtls_test_cli_crt_ec );
+const size_t mbedtls_test_cli_key_len = sizeof( mbedtls_test_cli_key_ec );
+#endif /* MBEDTLS_RSA_C */
-#endif /* POLARSSL_CERTS_C */
+#endif /* MBEDTLS_CERTS_C */
diff --git a/library/cipher.c b/library/cipher.c
index e04b5b6..d16893b 100644
--- a/library/cipher.c
+++ b/library/cipher.c
@@ -24,13 +24,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_CIPHER_C)
+#if defined(MBEDTLS_CIPHER_C)
#include "mbedtls/cipher.h"
#include "mbedtls/cipher_wrap.h"
@@ -38,16 +38,16 @@
#include <stdlib.h>
#include <string.h>
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
#include "mbedtls/gcm.h"
#endif
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
#include "mbedtls/ccm.h"
#endif
-#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER)
-#define POLARSSL_CIPHER_MODE_STREAM
+#if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#define MBEDTLS_CIPHER_MODE_STREAM
#endif
#if defined(_MSC_VER) && !defined strcasecmp && !defined(EFIX64) && \
@@ -56,21 +56,21 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
static int supported_init = 0;
-const int *cipher_list( void )
+const int *mbedtls_cipher_list( void )
{
- const cipher_definition_t *def;
+ const mbedtls_cipher_definition_t *def;
int *type;
if( ! supported_init )
{
- def = cipher_definitions;
- type = supported_ciphers;
+ def = mbedtls_cipher_definitions;
+ type = mbedtls_cipher_supported;
while( def->type != 0 )
*type++ = (*def++).type;
@@ -80,41 +80,41 @@
supported_init = 1;
}
- return( supported_ciphers );
+ return( mbedtls_cipher_supported );
}
-const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type )
+const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type )
{
- const cipher_definition_t *def;
+ const mbedtls_cipher_definition_t *def;
- for( def = cipher_definitions; def->info != NULL; def++ )
+ for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
if( def->type == cipher_type )
return( def->info );
return( NULL );
}
-const cipher_info_t *cipher_info_from_string( const char *cipher_name )
+const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name )
{
- const cipher_definition_t *def;
+ const mbedtls_cipher_definition_t *def;
if( NULL == cipher_name )
return( NULL );
- for( def = cipher_definitions; def->info != NULL; def++ )
+ for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
if( ! strcasecmp( def->info->name, cipher_name ) )
return( def->info );
return( NULL );
}
-const cipher_info_t *cipher_info_from_values( const cipher_id_t cipher_id,
+const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_length,
- const cipher_mode_t mode )
+ const mbedtls_cipher_mode_t mode )
{
- const cipher_definition_t *def;
+ const mbedtls_cipher_definition_t *def;
- for( def = cipher_definitions; def->info != NULL; def++ )
+ for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
if( def->info->base->cipher == cipher_id &&
def->info->key_length == (unsigned) key_length &&
def->info->mode == mode )
@@ -123,12 +123,12 @@
return( NULL );
}
-void cipher_init( cipher_context_t *ctx )
+void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx )
{
- memset( ctx, 0, sizeof( cipher_context_t ) );
+ memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
}
-void cipher_free( cipher_context_t *ctx )
+void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx )
{
if( ctx == NULL )
return;
@@ -136,45 +136,45 @@
if( ctx->cipher_ctx )
ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
- polarssl_zeroize( ctx, sizeof(cipher_context_t) );
+ mbedtls_zeroize( ctx, sizeof(mbedtls_cipher_context_t) );
}
-int cipher_init_ctx( cipher_context_t *ctx, const cipher_info_t *cipher_info )
+int mbedtls_cipher_init_ctx( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
{
if( NULL == cipher_info || NULL == ctx )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- memset( ctx, 0, sizeof( cipher_context_t ) );
+ memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
- return( POLARSSL_ERR_CIPHER_ALLOC_FAILED );
+ return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
ctx->cipher_info = cipher_info;
-#if defined(POLARSSL_CIPHER_MODE_WITH_PADDING)
+#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/*
* Ignore possible errors caused by a cipher mode that doesn't use padding
*/
-#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
- (void) cipher_set_padding_mode( ctx, POLARSSL_PADDING_PKCS7 );
+#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
+ (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_PKCS7 );
#else
- (void) cipher_set_padding_mode( ctx, POLARSSL_PADDING_NONE );
+ (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_NONE );
#endif
-#endif /* POLARSSL_CIPHER_MODE_WITH_PADDING */
+#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
return( 0 );
}
-int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
- int key_length, const operation_t operation )
+int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
+ int key_length, const mbedtls_operation_t operation )
{
if( NULL == ctx || NULL == ctx->cipher_info )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- if( ( ctx->cipher_info->flags & POLARSSL_CIPHER_VARIABLE_KEY_LEN ) == 0 &&
+ if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ) == 0 &&
(int) ctx->cipher_info->key_length != key_length )
{
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
ctx->key_length = key_length;
@@ -183,34 +183,34 @@
/*
* For CFB and CTR mode always use the encryption key schedule
*/
- if( POLARSSL_ENCRYPT == operation ||
- POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
- POLARSSL_MODE_CTR == ctx->cipher_info->mode )
+ if( MBEDTLS_ENCRYPT == operation ||
+ MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
+ MBEDTLS_MODE_CTR == ctx->cipher_info->mode )
{
return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
ctx->key_length );
}
- if( POLARSSL_DECRYPT == operation )
+ if( MBEDTLS_DECRYPT == operation )
return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
ctx->key_length );
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
-int cipher_set_iv( cipher_context_t *ctx,
+int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len )
{
size_t actual_iv_size;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* avoid buffer overflow in ctx->iv */
- if( iv_len > POLARSSL_MAX_IV_LENGTH )
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ if( iv_len > MBEDTLS_MAX_IV_LENGTH )
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
- if( ( ctx->cipher_info->flags & POLARSSL_CIPHER_VARIABLE_IV_LEN ) != 0 )
+ if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_IV_LEN ) != 0 )
actual_iv_size = iv_len;
else
{
@@ -218,7 +218,7 @@
/* avoid reading past the end of input buffer */
if( actual_iv_size > iv_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
memcpy( ctx->iv, iv, actual_iv_size );
@@ -227,49 +227,49 @@
return( 0 );
}
-int cipher_reset( cipher_context_t *ctx )
+int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx )
{
if( NULL == ctx || NULL == ctx->cipher_info )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
ctx->unprocessed_len = 0;
return( 0 );
}
-#if defined(POLARSSL_GCM_C)
-int cipher_update_ad( cipher_context_t *ctx,
+#if defined(MBEDTLS_GCM_C)
+int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
const unsigned char *ad, size_t ad_len )
{
if( NULL == ctx || NULL == ctx->cipher_info )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
+ if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
- return gcm_starts( (gcm_context *) ctx->cipher_ctx, ctx->operation,
+ return mbedtls_gcm_starts( (mbedtls_gcm_context *) ctx->cipher_ctx, ctx->operation,
ctx->iv, ctx->iv_size, ad, ad_len );
}
return( 0 );
}
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-int cipher_update( cipher_context_t *ctx, const unsigned char *input,
+int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
size_t ilen, unsigned char *output, size_t *olen )
{
int ret;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
{
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
*olen = 0;
- if( ctx->cipher_info->mode == POLARSSL_MODE_ECB )
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_ECB )
{
- if( ilen != cipher_get_block_size( ctx ) )
- return( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED );
+ if( ilen != mbedtls_cipher_get_block_size( ctx ) )
+ return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
*olen = ilen;
@@ -282,33 +282,33 @@
return( 0 );
}
-#if defined(POLARSSL_GCM_C)
- if( ctx->cipher_info->mode == POLARSSL_MODE_GCM )
+#if defined(MBEDTLS_GCM_C)
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_GCM )
{
*olen = ilen;
- return gcm_update( (gcm_context *) ctx->cipher_ctx, ilen, input,
+ return mbedtls_gcm_update( (mbedtls_gcm_context *) ctx->cipher_ctx, ilen, input,
output );
}
#endif
if( input == output &&
- ( ctx->unprocessed_len != 0 || ilen % cipher_get_block_size( ctx ) ) )
+ ( ctx->unprocessed_len != 0 || ilen % mbedtls_cipher_get_block_size( ctx ) ) )
{
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- if( ctx->cipher_info->mode == POLARSSL_MODE_CBC )
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_CBC )
{
size_t copy_len = 0;
/*
* If there is not enough data for a full block, cache it.
*/
- if( ( ctx->operation == POLARSSL_DECRYPT &&
- ilen + ctx->unprocessed_len <= cipher_get_block_size( ctx ) ) ||
- ( ctx->operation == POLARSSL_ENCRYPT &&
- ilen + ctx->unprocessed_len < cipher_get_block_size( ctx ) ) )
+ if( ( ctx->operation == MBEDTLS_DECRYPT &&
+ ilen + ctx->unprocessed_len <= mbedtls_cipher_get_block_size( ctx ) ) ||
+ ( ctx->operation == MBEDTLS_ENCRYPT &&
+ ilen + ctx->unprocessed_len < mbedtls_cipher_get_block_size( ctx ) ) )
{
memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
ilen );
@@ -322,20 +322,20 @@
*/
if( ctx->unprocessed_len != 0 )
{
- copy_len = cipher_get_block_size( ctx ) - ctx->unprocessed_len;
+ copy_len = mbedtls_cipher_get_block_size( ctx ) - ctx->unprocessed_len;
memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
copy_len );
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
- ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
+ ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
- *olen += cipher_get_block_size( ctx );
- output += cipher_get_block_size( ctx );
+ *olen += mbedtls_cipher_get_block_size( ctx );
+ output += mbedtls_cipher_get_block_size( ctx );
ctx->unprocessed_len = 0;
input += copy_len;
@@ -347,9 +347,9 @@
*/
if( 0 != ilen )
{
- copy_len = ilen % cipher_get_block_size( ctx );
- if( copy_len == 0 && ctx->operation == POLARSSL_DECRYPT )
- copy_len = cipher_get_block_size( ctx );
+ copy_len = ilen % mbedtls_cipher_get_block_size( ctx );
+ if( copy_len == 0 && ctx->operation == MBEDTLS_DECRYPT )
+ copy_len = mbedtls_cipher_get_block_size( ctx );
memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
copy_len );
@@ -374,10 +374,10 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
- if( ctx->cipher_info->mode == POLARSSL_MODE_CFB )
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_CFB )
{
if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
@@ -390,10 +390,10 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
- if( ctx->cipher_info->mode == POLARSSL_MODE_CTR )
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_CTR )
{
if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
ilen, &ctx->unprocessed_len, ctx->iv,
@@ -406,10 +406,10 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
- if( ctx->cipher_info->mode == POLARSSL_MODE_STREAM )
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
+ if( ctx->cipher_info->mode == MBEDTLS_MODE_STREAM )
{
if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
ilen, input, output ) ) )
@@ -421,13 +421,13 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_STREAM */
+#endif /* MBEDTLS_CIPHER_MODE_STREAM */
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
-#if defined(POLARSSL_CIPHER_MODE_WITH_PADDING)
-#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
+#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
+#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
/*
* PKCS7 (and PKCS5) padding: fill with ll bytes, with ll = padding_len
*/
@@ -448,7 +448,7 @@
unsigned char padding_len, bad = 0;
if( NULL == input || NULL == data_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
padding_len = input[input_len - 1];
*data_len = input_len - padding_len;
@@ -463,11 +463,11 @@
for( i = 0; i < input_len; i++ )
bad |= ( input[i] ^ padding_len ) * ( i >= pad_idx );
- return( POLARSSL_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
+ return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
}
-#endif /* POLARSSL_CIPHER_PADDING_PKCS7 */
+#endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
-#if defined(POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS)
+#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
/*
* One and zeros padding: fill with 80 00 ... 00
*/
@@ -489,7 +489,7 @@
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_len = 0;
@@ -501,12 +501,12 @@
bad &= ( input[i-1] ^ 0x80 ) | ( done == prev_done );
}
- return( POLARSSL_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
+ return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
}
-#endif /* POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS */
+#endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN)
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
/*
* Zeros and len padding: fill with 00 ... 00 ll, where ll is padding length
*/
@@ -528,7 +528,7 @@
unsigned char padding_len, bad = 0;
if( NULL == input || NULL == data_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
padding_len = input[input_len - 1];
*data_len = input_len - padding_len;
@@ -542,11 +542,11 @@
for( i = 0; i < input_len - 1; i++ )
bad |= input[i] * ( i >= pad_idx );
- return( POLARSSL_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
+ return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
}
-#endif /* POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN */
+#endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS)
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
/*
* Zero padding: fill with 00 ... 00
*/
@@ -566,7 +566,7 @@
unsigned char done = 0, prev_done;
if( NULL == input || NULL == data_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*data_len = 0;
for( i = input_len; i > 0; i-- )
@@ -578,70 +578,70 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_PADDING_ZEROS */
+#endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
/*
* No padding: don't pad :)
*
- * There is no add_padding function (check for NULL in cipher_finish)
+ * There is no add_padding function (check for NULL in mbedtls_cipher_finish)
* but a trivial get_padding function
*/
static int get_no_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
if( NULL == input || NULL == data_len )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*data_len = input_len;
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_WITH_PADDING */
+#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-int cipher_finish( cipher_context_t *ctx,
+int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
- if( POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
- POLARSSL_MODE_CTR == ctx->cipher_info->mode ||
- POLARSSL_MODE_GCM == ctx->cipher_info->mode ||
- POLARSSL_MODE_STREAM == ctx->cipher_info->mode )
+ if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
+ MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
+ MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
+ MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
{
return( 0 );
}
- if( POLARSSL_MODE_ECB == ctx->cipher_info->mode )
+ if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
{
if( ctx->unprocessed_len != 0 )
- return( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED );
+ return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- if( POLARSSL_MODE_CBC == ctx->cipher_info->mode )
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
{
int ret = 0;
- if( POLARSSL_ENCRYPT == ctx->operation )
+ if( MBEDTLS_ENCRYPT == ctx->operation )
{
/* check for 'no padding' mode */
if( NULL == ctx->add_padding )
{
if( 0 != ctx->unprocessed_len )
- return( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED );
+ return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
- ctx->add_padding( ctx->unprocessed_data, cipher_get_iv_size( ctx ),
+ ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
ctx->unprocessed_len );
}
- else if( cipher_get_block_size( ctx ) != ctx->unprocessed_len )
+ else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
{
/*
* For decrypt operations, expect a full block,
@@ -650,118 +650,118 @@
if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
return( 0 );
- return( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED );
+ return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
}
/* cipher block */
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
- ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
+ ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
/* Set output size for decryption */
- if( POLARSSL_DECRYPT == ctx->operation )
- return ctx->get_padding( output, cipher_get_block_size( ctx ),
+ if( MBEDTLS_DECRYPT == ctx->operation )
+ return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
olen );
/* Set output size for encryption */
- *olen = cipher_get_block_size( ctx );
+ *olen = mbedtls_cipher_get_block_size( ctx );
return( 0 );
}
#else
((void) output);
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
-#if defined(POLARSSL_CIPHER_MODE_WITH_PADDING)
-int cipher_set_padding_mode( cipher_context_t *ctx, cipher_padding_t mode )
+#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
+int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode )
{
if( NULL == ctx ||
- POLARSSL_MODE_CBC != ctx->cipher_info->mode )
+ MBEDTLS_MODE_CBC != ctx->cipher_info->mode )
{
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
switch( mode )
{
-#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
- case POLARSSL_PADDING_PKCS7:
+#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
+ case MBEDTLS_PADDING_PKCS7:
ctx->add_padding = add_pkcs_padding;
ctx->get_padding = get_pkcs_padding;
break;
#endif
-#if defined(POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS)
- case POLARSSL_PADDING_ONE_AND_ZEROS:
+#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
+ case MBEDTLS_PADDING_ONE_AND_ZEROS:
ctx->add_padding = add_one_and_zeros_padding;
ctx->get_padding = get_one_and_zeros_padding;
break;
#endif
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN)
- case POLARSSL_PADDING_ZEROS_AND_LEN:
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
+ case MBEDTLS_PADDING_ZEROS_AND_LEN:
ctx->add_padding = add_zeros_and_len_padding;
ctx->get_padding = get_zeros_and_len_padding;
break;
#endif
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS)
- case POLARSSL_PADDING_ZEROS:
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
+ case MBEDTLS_PADDING_ZEROS:
ctx->add_padding = add_zeros_padding;
ctx->get_padding = get_zeros_padding;
break;
#endif
- case POLARSSL_PADDING_NONE:
+ case MBEDTLS_PADDING_NONE:
ctx->add_padding = NULL;
ctx->get_padding = get_no_padding;
break;
default:
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_WITH_PADDING */
+#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
-#if defined(POLARSSL_GCM_C)
-int cipher_write_tag( cipher_context_t *ctx,
+#if defined(MBEDTLS_GCM_C)
+int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- if( POLARSSL_ENCRYPT != ctx->operation )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ if( MBEDTLS_ENCRYPT != ctx->operation )
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
- return gcm_finish( (gcm_context *) ctx->cipher_ctx, tag, tag_len );
+ if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
+ return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len );
return( 0 );
}
-int cipher_check_tag( cipher_context_t *ctx,
+int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
const unsigned char *tag, size_t tag_len )
{
int ret;
if( NULL == ctx || NULL == ctx->cipher_info ||
- POLARSSL_DECRYPT != ctx->operation )
+ MBEDTLS_DECRYPT != ctx->operation )
{
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
- if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
+ if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
unsigned char check_tag[16];
size_t i;
int diff;
if( tag_len > sizeof( check_tag ) )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- if( 0 != ( ret = gcm_finish( (gcm_context *) ctx->cipher_ctx,
+ if( 0 != ( ret = mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx,
check_tag, tag_len ) ) )
{
return( ret );
@@ -772,19 +772,19 @@
diff |= tag[i] ^ check_tag[i];
if( diff != 0 )
- return( POLARSSL_ERR_CIPHER_AUTH_FAILED );
+ return( MBEDTLS_ERR_CIPHER_AUTH_FAILED );
return( 0 );
}
return( 0 );
}
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
/*
* Packet-oriented wrapper for non-AEAD modes
*/
-int cipher_crypt( cipher_context_t *ctx,
+int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
@@ -792,16 +792,16 @@
int ret;
size_t finish_olen;
- if( ( ret = cipher_set_iv( ctx, iv, iv_len ) ) != 0 )
+ if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv_len ) ) != 0 )
return( ret );
- if( ( ret = cipher_reset( ctx ) ) != 0 )
+ if( ( ret = mbedtls_cipher_reset( ctx ) ) != 0 )
return( ret );
- if( ( ret = cipher_update( ctx, input, ilen, output, olen ) ) != 0 )
+ if( ( ret = mbedtls_cipher_update( ctx, input, ilen, output, olen ) ) != 0 )
return( ret );
- if( ( ret = cipher_finish( ctx, output + *olen, &finish_olen ) ) != 0 )
+ if( ( ret = mbedtls_cipher_finish( ctx, output + *olen, &finish_olen ) ) != 0 )
return( ret );
*olen += finish_olen;
@@ -809,84 +809,84 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_AEAD)
+#if defined(MBEDTLS_CIPHER_MODE_AEAD)
/*
* Packet-oriented encryption for AEAD modes
*/
-int cipher_auth_encrypt( cipher_context_t *ctx,
+int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen,
unsigned char *tag, size_t tag_len )
{
-#if defined(POLARSSL_GCM_C)
- if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
+#if defined(MBEDTLS_GCM_C)
+ if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
*olen = ilen;
- return( gcm_crypt_and_tag( ctx->cipher_ctx, GCM_ENCRYPT, ilen,
+ return( mbedtls_gcm_crypt_and_tag( ctx->cipher_ctx, MBEDTLS_GCM_ENCRYPT, ilen,
iv, iv_len, ad, ad_len, input, output,
tag_len, tag ) );
}
-#endif /* POLARSSL_GCM_C */
-#if defined(POLARSSL_CCM_C)
- if( POLARSSL_MODE_CCM == ctx->cipher_info->mode )
+#endif /* MBEDTLS_GCM_C */
+#if defined(MBEDTLS_CCM_C)
+ if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
{
*olen = ilen;
- return( ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
+ return( mbedtls_ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len, input, output,
tag, tag_len ) );
}
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
/*
* Packet-oriented decryption for AEAD modes
*/
-int cipher_auth_decrypt( cipher_context_t *ctx,
+int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen,
const unsigned char *tag, size_t tag_len )
{
-#if defined(POLARSSL_GCM_C)
- if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
+#if defined(MBEDTLS_GCM_C)
+ if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
- ret = gcm_auth_decrypt( ctx->cipher_ctx, ilen,
+ ret = mbedtls_gcm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
tag, tag_len, input, output );
- if( ret == POLARSSL_ERR_GCM_AUTH_FAILED )
- ret = POLARSSL_ERR_CIPHER_AUTH_FAILED;
+ if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
+ ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
-#endif /* POLARSSL_GCM_C */
-#if defined(POLARSSL_CCM_C)
- if( POLARSSL_MODE_CCM == ctx->cipher_info->mode )
+#endif /* MBEDTLS_GCM_C */
+#if defined(MBEDTLS_CCM_C)
+ if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
- ret = ccm_auth_decrypt( ctx->cipher_ctx, ilen,
+ ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
input, output, tag, tag_len );
- if( ret == POLARSSL_ERR_CCM_AUTH_FAILED )
- ret = POLARSSL_ERR_CIPHER_AUTH_FAILED;
+ if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
+ ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
- return( POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
-#endif /* POLARSSL_CIPHER_MODE_AEAD */
+#endif /* MBEDTLS_CIPHER_MODE_AEAD */
-#endif /* POLARSSL_CIPHER_C */
+#endif /* MBEDTLS_CIPHER_C */
diff --git a/library/cipher_wrap.c b/library/cipher_wrap.c
index 4478cc8..ebc3c4f 100644
--- a/library/cipher_wrap.c
+++ b/library/cipher_wrap.c
@@ -24,164 +24,164 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_CIPHER_C)
+#if defined(MBEDTLS_CIPHER_C)
#include "mbedtls/cipher_wrap.h"
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
#include "mbedtls/aes.h"
#endif
-#if defined(POLARSSL_ARC4_C)
+#if defined(MBEDTLS_ARC4_C)
#include "mbedtls/arc4.h"
#endif
-#if defined(POLARSSL_CAMELLIA_C)
+#if defined(MBEDTLS_CAMELLIA_C)
#include "mbedtls/camellia.h"
#endif
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
#include "mbedtls/des.h"
#endif
-#if defined(POLARSSL_BLOWFISH_C)
+#if defined(MBEDTLS_BLOWFISH_C)
#include "mbedtls/blowfish.h"
#endif
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
#include "mbedtls/gcm.h"
#endif
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
#include "mbedtls/ccm.h"
#endif
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#include <string.h>
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
/* shared by all GCM ciphers */
static void *gcm_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( gcm_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_gcm_context ) );
}
static void gcm_ctx_free( void *ctx )
{
- gcm_free( ctx );
- polarssl_free( ctx );
+ mbedtls_gcm_free( ctx );
+ mbedtls_free( ctx );
}
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
/* shared by all CCM ciphers */
static void *ccm_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( ccm_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_ccm_context ) );
}
static void ccm_ctx_free( void *ctx )
{
- ccm_free( ctx );
- polarssl_free( ctx );
+ mbedtls_ccm_free( ctx );
+ mbedtls_free( ctx );
}
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
-static int aes_crypt_ecb_wrap( void *ctx, operation_t operation,
+static int aes_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
- return aes_crypt_ecb( (aes_context *) ctx, operation, input, output );
+ return mbedtls_aes_crypt_ecb( (mbedtls_aes_context *) ctx, operation, input, output );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static int aes_crypt_cbc_wrap( void *ctx, operation_t operation, size_t length,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static int aes_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
- return aes_crypt_cbc( (aes_context *) ctx, operation, length, iv, input,
+ return mbedtls_aes_crypt_cbc( (mbedtls_aes_context *) ctx, operation, length, iv, input,
output );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static int aes_crypt_cfb128_wrap( void *ctx, operation_t operation,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, size_t *iv_off, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
- return aes_crypt_cfb128( (aes_context *) ctx, operation, length, iv_off, iv,
+ return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
unsigned char *nonce_counter, unsigned char *stream_block,
const unsigned char *input, unsigned char *output )
{
- return aes_crypt_ctr( (aes_context *) ctx, length, nc_off, nonce_counter,
+ return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
stream_block, input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return aes_setkey_dec( (aes_context *) ctx, key, key_length );
+ return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_length );
}
static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return aes_setkey_enc( (aes_context *) ctx, key, key_length );
+ return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_length );
}
static void * aes_ctx_alloc( void )
{
- aes_context *aes = polarssl_malloc( sizeof( aes_context ) );
+ mbedtls_aes_context *aes = mbedtls_malloc( sizeof( mbedtls_aes_context ) );
if( aes == NULL )
return( NULL );
- aes_init( aes );
+ mbedtls_aes_init( aes );
return( aes );
}
static void aes_ctx_free( void *ctx )
{
- aes_free( (aes_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_aes_free( (mbedtls_aes_context *) ctx );
+ mbedtls_free( ctx );
}
-static const cipher_base_t aes_info = {
- POLARSSL_CIPHER_ID_AES,
+static const mbedtls_cipher_base_t aes_info = {
+ MBEDTLS_CIPHER_ID_AES,
aes_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
aes_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
aes_crypt_cfb128_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
aes_crypt_ctr_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
aes_setkey_enc_wrap,
@@ -190,9 +190,9 @@
aes_ctx_free
};
-static const cipher_info_t aes_128_ecb_info = {
- POLARSSL_CIPHER_AES_128_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t aes_128_ecb_info = {
+ MBEDTLS_CIPHER_AES_128_ECB,
+ MBEDTLS_MODE_ECB,
128,
"AES-128-ECB",
16,
@@ -201,9 +201,9 @@
&aes_info
};
-static const cipher_info_t aes_192_ecb_info = {
- POLARSSL_CIPHER_AES_192_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t aes_192_ecb_info = {
+ MBEDTLS_CIPHER_AES_192_ECB,
+ MBEDTLS_MODE_ECB,
192,
"AES-192-ECB",
16,
@@ -212,9 +212,9 @@
&aes_info
};
-static const cipher_info_t aes_256_ecb_info = {
- POLARSSL_CIPHER_AES_256_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t aes_256_ecb_info = {
+ MBEDTLS_CIPHER_AES_256_ECB,
+ MBEDTLS_MODE_ECB,
256,
"AES-256-ECB",
16,
@@ -223,10 +223,10 @@
&aes_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t aes_128_cbc_info = {
- POLARSSL_CIPHER_AES_128_CBC,
- POLARSSL_MODE_CBC,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t aes_128_cbc_info = {
+ MBEDTLS_CIPHER_AES_128_CBC,
+ MBEDTLS_MODE_CBC,
128,
"AES-128-CBC",
16,
@@ -235,9 +235,9 @@
&aes_info
};
-static const cipher_info_t aes_192_cbc_info = {
- POLARSSL_CIPHER_AES_192_CBC,
- POLARSSL_MODE_CBC,
+static const mbedtls_cipher_info_t aes_192_cbc_info = {
+ MBEDTLS_CIPHER_AES_192_CBC,
+ MBEDTLS_MODE_CBC,
192,
"AES-192-CBC",
16,
@@ -246,9 +246,9 @@
&aes_info
};
-static const cipher_info_t aes_256_cbc_info = {
- POLARSSL_CIPHER_AES_256_CBC,
- POLARSSL_MODE_CBC,
+static const mbedtls_cipher_info_t aes_256_cbc_info = {
+ MBEDTLS_CIPHER_AES_256_CBC,
+ MBEDTLS_MODE_CBC,
256,
"AES-256-CBC",
16,
@@ -256,12 +256,12 @@
16,
&aes_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static const cipher_info_t aes_128_cfb128_info = {
- POLARSSL_CIPHER_AES_128_CFB128,
- POLARSSL_MODE_CFB,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static const mbedtls_cipher_info_t aes_128_cfb128_info = {
+ MBEDTLS_CIPHER_AES_128_CFB128,
+ MBEDTLS_MODE_CFB,
128,
"AES-128-CFB128",
16,
@@ -270,9 +270,9 @@
&aes_info
};
-static const cipher_info_t aes_192_cfb128_info = {
- POLARSSL_CIPHER_AES_192_CFB128,
- POLARSSL_MODE_CFB,
+static const mbedtls_cipher_info_t aes_192_cfb128_info = {
+ MBEDTLS_CIPHER_AES_192_CFB128,
+ MBEDTLS_MODE_CFB,
192,
"AES-192-CFB128",
16,
@@ -281,9 +281,9 @@
&aes_info
};
-static const cipher_info_t aes_256_cfb128_info = {
- POLARSSL_CIPHER_AES_256_CFB128,
- POLARSSL_MODE_CFB,
+static const mbedtls_cipher_info_t aes_256_cfb128_info = {
+ MBEDTLS_CIPHER_AES_256_CFB128,
+ MBEDTLS_MODE_CFB,
256,
"AES-256-CFB128",
16,
@@ -291,12 +291,12 @@
16,
&aes_info
};
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
-static const cipher_info_t aes_128_ctr_info = {
- POLARSSL_CIPHER_AES_128_CTR,
- POLARSSL_MODE_CTR,
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+static const mbedtls_cipher_info_t aes_128_ctr_info = {
+ MBEDTLS_CIPHER_AES_128_CTR,
+ MBEDTLS_MODE_CTR,
128,
"AES-128-CTR",
16,
@@ -305,9 +305,9 @@
&aes_info
};
-static const cipher_info_t aes_192_ctr_info = {
- POLARSSL_CIPHER_AES_192_CTR,
- POLARSSL_MODE_CTR,
+static const mbedtls_cipher_info_t aes_192_ctr_info = {
+ MBEDTLS_CIPHER_AES_192_CTR,
+ MBEDTLS_MODE_CTR,
192,
"AES-192-CTR",
16,
@@ -316,9 +316,9 @@
&aes_info
};
-static const cipher_info_t aes_256_ctr_info = {
- POLARSSL_CIPHER_AES_256_CTR,
- POLARSSL_MODE_CTR,
+static const mbedtls_cipher_info_t aes_256_ctr_info = {
+ MBEDTLS_CIPHER_AES_256_CTR,
+ MBEDTLS_MODE_CTR,
256,
"AES-256-CTR",
16,
@@ -326,29 +326,29 @@
16,
&aes_info
};
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return gcm_init( (gcm_context *) ctx, POLARSSL_CIPHER_ID_AES,
+ return mbedtls_gcm_init( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
key, key_length );
}
-static const cipher_base_t gcm_aes_info = {
- POLARSSL_CIPHER_ID_AES,
+static const mbedtls_cipher_base_t gcm_aes_info = {
+ MBEDTLS_CIPHER_ID_AES,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
gcm_aes_setkey_wrap,
@@ -357,61 +357,61 @@
gcm_ctx_free,
};
-static const cipher_info_t aes_128_gcm_info = {
- POLARSSL_CIPHER_AES_128_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t aes_128_gcm_info = {
+ MBEDTLS_CIPHER_AES_128_GCM,
+ MBEDTLS_MODE_GCM,
128,
"AES-128-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
-static const cipher_info_t aes_192_gcm_info = {
- POLARSSL_CIPHER_AES_192_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t aes_192_gcm_info = {
+ MBEDTLS_CIPHER_AES_192_GCM,
+ MBEDTLS_MODE_GCM,
192,
"AES-192-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
-static const cipher_info_t aes_256_gcm_info = {
- POLARSSL_CIPHER_AES_256_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t aes_256_gcm_info = {
+ MBEDTLS_CIPHER_AES_256_GCM,
+ MBEDTLS_MODE_GCM,
256,
"AES-256-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return ccm_init( (ccm_context *) ctx, POLARSSL_CIPHER_ID_AES,
+ return mbedtls_ccm_init( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
key, key_length );
}
-static const cipher_base_t ccm_aes_info = {
- POLARSSL_CIPHER_ID_AES,
+static const mbedtls_cipher_base_t ccm_aes_info = {
+ MBEDTLS_CIPHER_ID_AES,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
ccm_aes_setkey_wrap,
@@ -420,125 +420,125 @@
ccm_ctx_free,
};
-static const cipher_info_t aes_128_ccm_info = {
- POLARSSL_CIPHER_AES_128_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t aes_128_ccm_info = {
+ MBEDTLS_CIPHER_AES_128_CCM,
+ MBEDTLS_MODE_CCM,
128,
"AES-128-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
-static const cipher_info_t aes_192_ccm_info = {
- POLARSSL_CIPHER_AES_192_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t aes_192_ccm_info = {
+ MBEDTLS_CIPHER_AES_192_CCM,
+ MBEDTLS_MODE_CCM,
192,
"AES-192-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
-static const cipher_info_t aes_256_ccm_info = {
- POLARSSL_CIPHER_AES_256_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t aes_256_ccm_info = {
+ MBEDTLS_CIPHER_AES_256_CCM,
+ MBEDTLS_MODE_CCM,
256,
"AES-256-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
+#if defined(MBEDTLS_CAMELLIA_C)
-static int camellia_crypt_ecb_wrap( void *ctx, operation_t operation,
+static int camellia_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
- return camellia_crypt_ecb( (camellia_context *) ctx, operation, input,
+ return mbedtls_camellia_crypt_ecb( (mbedtls_camellia_context *) ctx, operation, input,
output );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static int camellia_crypt_cbc_wrap( void *ctx, operation_t operation,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static int camellia_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
- return camellia_crypt_cbc( (camellia_context *) ctx, operation, length, iv,
+ return mbedtls_camellia_crypt_cbc( (mbedtls_camellia_context *) ctx, operation, length, iv,
input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static int camellia_crypt_cfb128_wrap( void *ctx, operation_t operation,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static int camellia_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, size_t *iv_off, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
- return camellia_crypt_cfb128( (camellia_context *) ctx, operation, length,
+ return mbedtls_camellia_crypt_cfb128( (mbedtls_camellia_context *) ctx, operation, length,
iv_off, iv, input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
static int camellia_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
unsigned char *nonce_counter, unsigned char *stream_block,
const unsigned char *input, unsigned char *output )
{
- return camellia_crypt_ctr( (camellia_context *) ctx, length, nc_off,
+ return mbedtls_camellia_crypt_ctr( (mbedtls_camellia_context *) ctx, length, nc_off,
nonce_counter, stream_block, input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
static int camellia_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return camellia_setkey_dec( (camellia_context *) ctx, key, key_length );
+ return mbedtls_camellia_setkey_dec( (mbedtls_camellia_context *) ctx, key, key_length );
}
static int camellia_setkey_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return camellia_setkey_enc( (camellia_context *) ctx, key, key_length );
+ return mbedtls_camellia_setkey_enc( (mbedtls_camellia_context *) ctx, key, key_length );
}
static void * camellia_ctx_alloc( void )
{
- camellia_context *ctx;
- ctx = polarssl_malloc( sizeof( camellia_context ) );
+ mbedtls_camellia_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_camellia_context ) );
if( ctx == NULL )
return( NULL );
- camellia_init( ctx );
+ mbedtls_camellia_init( ctx );
return( ctx );
}
static void camellia_ctx_free( void *ctx )
{
- camellia_free( (camellia_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_camellia_free( (mbedtls_camellia_context *) ctx );
+ mbedtls_free( ctx );
}
-static const cipher_base_t camellia_info = {
- POLARSSL_CIPHER_ID_CAMELLIA,
+static const mbedtls_cipher_base_t camellia_info = {
+ MBEDTLS_CIPHER_ID_CAMELLIA,
camellia_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
camellia_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
camellia_crypt_cfb128_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
camellia_crypt_ctr_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
camellia_setkey_enc_wrap,
@@ -547,9 +547,9 @@
camellia_ctx_free
};
-static const cipher_info_t camellia_128_ecb_info = {
- POLARSSL_CIPHER_CAMELLIA_128_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t camellia_128_ecb_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_ECB,
+ MBEDTLS_MODE_ECB,
128,
"CAMELLIA-128-ECB",
16,
@@ -558,9 +558,9 @@
&camellia_info
};
-static const cipher_info_t camellia_192_ecb_info = {
- POLARSSL_CIPHER_CAMELLIA_192_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t camellia_192_ecb_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_ECB,
+ MBEDTLS_MODE_ECB,
192,
"CAMELLIA-192-ECB",
16,
@@ -569,9 +569,9 @@
&camellia_info
};
-static const cipher_info_t camellia_256_ecb_info = {
- POLARSSL_CIPHER_CAMELLIA_256_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t camellia_256_ecb_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_ECB,
+ MBEDTLS_MODE_ECB,
256,
"CAMELLIA-256-ECB",
16,
@@ -580,10 +580,10 @@
&camellia_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t camellia_128_cbc_info = {
- POLARSSL_CIPHER_CAMELLIA_128_CBC,
- POLARSSL_MODE_CBC,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t camellia_128_cbc_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC,
+ MBEDTLS_MODE_CBC,
128,
"CAMELLIA-128-CBC",
16,
@@ -592,9 +592,9 @@
&camellia_info
};
-static const cipher_info_t camellia_192_cbc_info = {
- POLARSSL_CIPHER_CAMELLIA_192_CBC,
- POLARSSL_MODE_CBC,
+static const mbedtls_cipher_info_t camellia_192_cbc_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_CBC,
+ MBEDTLS_MODE_CBC,
192,
"CAMELLIA-192-CBC",
16,
@@ -603,9 +603,9 @@
&camellia_info
};
-static const cipher_info_t camellia_256_cbc_info = {
- POLARSSL_CIPHER_CAMELLIA_256_CBC,
- POLARSSL_MODE_CBC,
+static const mbedtls_cipher_info_t camellia_256_cbc_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC,
+ MBEDTLS_MODE_CBC,
256,
"CAMELLIA-256-CBC",
16,
@@ -613,12 +613,12 @@
16,
&camellia_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static const cipher_info_t camellia_128_cfb128_info = {
- POLARSSL_CIPHER_CAMELLIA_128_CFB128,
- POLARSSL_MODE_CFB,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
+ MBEDTLS_MODE_CFB,
128,
"CAMELLIA-128-CFB128",
16,
@@ -627,9 +627,9 @@
&camellia_info
};
-static const cipher_info_t camellia_192_cfb128_info = {
- POLARSSL_CIPHER_CAMELLIA_192_CFB128,
- POLARSSL_MODE_CFB,
+static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
+ MBEDTLS_MODE_CFB,
192,
"CAMELLIA-192-CFB128",
16,
@@ -638,9 +638,9 @@
&camellia_info
};
-static const cipher_info_t camellia_256_cfb128_info = {
- POLARSSL_CIPHER_CAMELLIA_256_CFB128,
- POLARSSL_MODE_CFB,
+static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
+ MBEDTLS_MODE_CFB,
256,
"CAMELLIA-256-CFB128",
16,
@@ -648,12 +648,12 @@
16,
&camellia_info
};
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
-static const cipher_info_t camellia_128_ctr_info = {
- POLARSSL_CIPHER_CAMELLIA_128_CTR,
- POLARSSL_MODE_CTR,
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+static const mbedtls_cipher_info_t camellia_128_ctr_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_CTR,
+ MBEDTLS_MODE_CTR,
128,
"CAMELLIA-128-CTR",
16,
@@ -662,9 +662,9 @@
&camellia_info
};
-static const cipher_info_t camellia_192_ctr_info = {
- POLARSSL_CIPHER_CAMELLIA_192_CTR,
- POLARSSL_MODE_CTR,
+static const mbedtls_cipher_info_t camellia_192_ctr_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_CTR,
+ MBEDTLS_MODE_CTR,
192,
"CAMELLIA-192-CTR",
16,
@@ -673,9 +673,9 @@
&camellia_info
};
-static const cipher_info_t camellia_256_ctr_info = {
- POLARSSL_CIPHER_CAMELLIA_256_CTR,
- POLARSSL_MODE_CTR,
+static const mbedtls_cipher_info_t camellia_256_ctr_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_CTR,
+ MBEDTLS_MODE_CTR,
256,
"CAMELLIA-256-CTR",
16,
@@ -683,29 +683,29 @@
16,
&camellia_info
};
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
static int gcm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return gcm_init( (gcm_context *) ctx, POLARSSL_CIPHER_ID_CAMELLIA,
+ return mbedtls_gcm_init( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
key, key_length );
}
-static const cipher_base_t gcm_camellia_info = {
- POLARSSL_CIPHER_ID_CAMELLIA,
+static const mbedtls_cipher_base_t gcm_camellia_info = {
+ MBEDTLS_CIPHER_ID_CAMELLIA,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
gcm_camellia_setkey_wrap,
@@ -714,61 +714,61 @@
gcm_ctx_free,
};
-static const cipher_info_t camellia_128_gcm_info = {
- POLARSSL_CIPHER_CAMELLIA_128_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t camellia_128_gcm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM,
+ MBEDTLS_MODE_GCM,
128,
"CAMELLIA-128-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_camellia_info
};
-static const cipher_info_t camellia_192_gcm_info = {
- POLARSSL_CIPHER_CAMELLIA_192_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t camellia_192_gcm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_GCM,
+ MBEDTLS_MODE_GCM,
192,
"CAMELLIA-192-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_camellia_info
};
-static const cipher_info_t camellia_256_gcm_info = {
- POLARSSL_CIPHER_CAMELLIA_256_GCM,
- POLARSSL_MODE_GCM,
+static const mbedtls_cipher_info_t camellia_256_gcm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM,
+ MBEDTLS_MODE_GCM,
256,
"CAMELLIA-256-GCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_camellia_info
};
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
static int ccm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return ccm_init( (ccm_context *) ctx, POLARSSL_CIPHER_ID_CAMELLIA,
+ return mbedtls_ccm_init( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
key, key_length );
}
-static const cipher_base_t ccm_camellia_info = {
- POLARSSL_CIPHER_ID_CAMELLIA,
+static const mbedtls_cipher_base_t ccm_camellia_info = {
+ MBEDTLS_CIPHER_ID_CAMELLIA,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
ccm_camellia_setkey_wrap,
@@ -777,82 +777,82 @@
ccm_ctx_free,
};
-static const cipher_info_t camellia_128_ccm_info = {
- POLARSSL_CIPHER_CAMELLIA_128_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t camellia_128_ccm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_128_CCM,
+ MBEDTLS_MODE_CCM,
128,
"CAMELLIA-128-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_camellia_info
};
-static const cipher_info_t camellia_192_ccm_info = {
- POLARSSL_CIPHER_CAMELLIA_192_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t camellia_192_ccm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_192_CCM,
+ MBEDTLS_MODE_CCM,
192,
"CAMELLIA-192-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_camellia_info
};
-static const cipher_info_t camellia_256_ccm_info = {
- POLARSSL_CIPHER_CAMELLIA_256_CCM,
- POLARSSL_MODE_CCM,
+static const mbedtls_cipher_info_t camellia_256_ccm_info = {
+ MBEDTLS_CIPHER_CAMELLIA_256_CCM,
+ MBEDTLS_MODE_CCM,
256,
"CAMELLIA-256-CCM",
12,
- POLARSSL_CIPHER_VARIABLE_IV_LEN,
+ MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_camellia_info
};
-#endif /* POLARSSL_CCM_C */
+#endif /* MBEDTLS_CCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
-static int des_crypt_ecb_wrap( void *ctx, operation_t operation,
+static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
((void) operation);
- return des_crypt_ecb( (des_context *) ctx, input, output );
+ return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output );
}
-static int des3_crypt_ecb_wrap( void *ctx, operation_t operation,
+static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
((void) operation);
- return des3_crypt_ecb( (des3_context *) ctx, input, output );
+ return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static int des_crypt_cbc_wrap( void *ctx, operation_t operation, size_t length,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
- return des_crypt_cbc( (des_context *) ctx, operation, length, iv, input,
+ return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input,
output );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static int des3_crypt_cbc_wrap( void *ctx, operation_t operation, size_t length,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
- return des3_crypt_cbc( (des3_context *) ctx, operation, length, iv, input,
+ return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input,
output );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
static int des_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
((void) key_length);
- return des_setkey_dec( (des_context *) ctx, key );
+ return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key );
}
static int des_setkey_enc_wrap( void *ctx, const unsigned char *key,
@@ -860,7 +860,7 @@
{
((void) key_length);
- return des_setkey_enc( (des_context *) ctx, key );
+ return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key );
}
static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key,
@@ -868,7 +868,7 @@
{
((void) key_length);
- return des3_set2key_dec( (des3_context *) ctx, key );
+ return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key );
}
static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key,
@@ -876,7 +876,7 @@
{
((void) key_length);
- return des3_set2key_enc( (des3_context *) ctx, key );
+ return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key );
}
static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key,
@@ -884,7 +884,7 @@
{
((void) key_length);
- return des3_set3key_dec( (des3_context *) ctx, key );
+ return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key );
}
static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key,
@@ -892,59 +892,59 @@
{
((void) key_length);
- return des3_set3key_enc( (des3_context *) ctx, key );
+ return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key );
}
static void * des_ctx_alloc( void )
{
- des_context *des = polarssl_malloc( sizeof( des_context ) );
+ mbedtls_des_context *des = mbedtls_malloc( sizeof( mbedtls_des_context ) );
if( des == NULL )
return( NULL );
- des_init( des );
+ mbedtls_des_init( des );
return( des );
}
static void des_ctx_free( void *ctx )
{
- des_free( (des_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_des_free( (mbedtls_des_context *) ctx );
+ mbedtls_free( ctx );
}
static void * des3_ctx_alloc( void )
{
- des3_context *des3;
- des3 = polarssl_malloc( sizeof( des3_context ) );
+ mbedtls_des3_context *des3;
+ des3 = mbedtls_malloc( sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
- des3_init( des3 );
+ mbedtls_des3_init( des3 );
return( des3 );
}
static void des3_ctx_free( void *ctx )
{
- des3_free( (des3_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_des3_free( (mbedtls_des3_context *) ctx );
+ mbedtls_free( ctx );
}
-static const cipher_base_t des_info = {
- POLARSSL_CIPHER_ID_DES,
+static const mbedtls_cipher_base_t des_info = {
+ MBEDTLS_CIPHER_ID_DES,
des_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
des_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des_setkey_enc_wrap,
@@ -953,10 +953,10 @@
des_ctx_free
};
-static const cipher_info_t des_ecb_info = {
- POLARSSL_CIPHER_DES_ECB,
- POLARSSL_MODE_ECB,
- POLARSSL_KEY_LENGTH_DES,
+static const mbedtls_cipher_info_t des_ecb_info = {
+ MBEDTLS_CIPHER_DES_ECB,
+ MBEDTLS_MODE_ECB,
+ MBEDTLS_KEY_LENGTH_DES,
"DES-ECB",
8,
0,
@@ -964,32 +964,32 @@
&des_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t des_cbc_info = {
- POLARSSL_CIPHER_DES_CBC,
- POLARSSL_MODE_CBC,
- POLARSSL_KEY_LENGTH_DES,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t des_cbc_info = {
+ MBEDTLS_CIPHER_DES_CBC,
+ MBEDTLS_MODE_CBC,
+ MBEDTLS_KEY_LENGTH_DES,
"DES-CBC",
8,
0,
8,
&des_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-static const cipher_base_t des_ede_info = {
- POLARSSL_CIPHER_ID_DES,
+static const mbedtls_cipher_base_t des_ede_info = {
+ MBEDTLS_CIPHER_ID_DES,
des3_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
des3_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des3_set2key_enc_wrap,
@@ -998,10 +998,10 @@
des3_ctx_free
};
-static const cipher_info_t des_ede_ecb_info = {
- POLARSSL_CIPHER_DES_EDE_ECB,
- POLARSSL_MODE_ECB,
- POLARSSL_KEY_LENGTH_DES_EDE,
+static const mbedtls_cipher_info_t des_ede_ecb_info = {
+ MBEDTLS_CIPHER_DES_EDE_ECB,
+ MBEDTLS_MODE_ECB,
+ MBEDTLS_KEY_LENGTH_DES_EDE,
"DES-EDE-ECB",
8,
0,
@@ -1009,32 +1009,32 @@
&des_ede_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t des_ede_cbc_info = {
- POLARSSL_CIPHER_DES_EDE_CBC,
- POLARSSL_MODE_CBC,
- POLARSSL_KEY_LENGTH_DES_EDE,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t des_ede_cbc_info = {
+ MBEDTLS_CIPHER_DES_EDE_CBC,
+ MBEDTLS_MODE_CBC,
+ MBEDTLS_KEY_LENGTH_DES_EDE,
"DES-EDE-CBC",
8,
0,
8,
&des_ede_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-static const cipher_base_t des_ede3_info = {
- POLARSSL_CIPHER_ID_DES,
+static const mbedtls_cipher_base_t des_ede3_info = {
+ MBEDTLS_CIPHER_ID_DES,
des3_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
des3_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des3_set3key_enc_wrap,
@@ -1043,107 +1043,107 @@
des3_ctx_free
};
-static const cipher_info_t des_ede3_ecb_info = {
- POLARSSL_CIPHER_DES_EDE3_ECB,
- POLARSSL_MODE_ECB,
- POLARSSL_KEY_LENGTH_DES_EDE3,
+static const mbedtls_cipher_info_t des_ede3_ecb_info = {
+ MBEDTLS_CIPHER_DES_EDE3_ECB,
+ MBEDTLS_MODE_ECB,
+ MBEDTLS_KEY_LENGTH_DES_EDE3,
"DES-EDE3-ECB",
8,
0,
8,
&des_ede3_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t des_ede3_cbc_info = {
- POLARSSL_CIPHER_DES_EDE3_CBC,
- POLARSSL_MODE_CBC,
- POLARSSL_KEY_LENGTH_DES_EDE3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t des_ede3_cbc_info = {
+ MBEDTLS_CIPHER_DES_EDE3_CBC,
+ MBEDTLS_MODE_CBC,
+ MBEDTLS_KEY_LENGTH_DES_EDE3,
"DES-EDE3-CBC",
8,
0,
8,
&des_ede3_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_BLOWFISH_C)
+#if defined(MBEDTLS_BLOWFISH_C)
-static int blowfish_crypt_ecb_wrap( void *ctx, operation_t operation,
+static int blowfish_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
- return blowfish_crypt_ecb( (blowfish_context *) ctx, operation, input,
+ return mbedtls_blowfish_crypt_ecb( (mbedtls_blowfish_context *) ctx, operation, input,
output );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static int blowfish_crypt_cbc_wrap( void *ctx, operation_t operation,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static int blowfish_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, unsigned char *iv, const unsigned char *input,
unsigned char *output )
{
- return blowfish_crypt_cbc( (blowfish_context *) ctx, operation, length, iv,
+ return mbedtls_blowfish_crypt_cbc( (mbedtls_blowfish_context *) ctx, operation, length, iv,
input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static int blowfish_crypt_cfb64_wrap( void *ctx, operation_t operation,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static int blowfish_crypt_cfb64_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, size_t *iv_off, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
- return blowfish_crypt_cfb64( (blowfish_context *) ctx, operation, length,
+ return mbedtls_blowfish_crypt_cfb64( (mbedtls_blowfish_context *) ctx, operation, length,
iv_off, iv, input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
static int blowfish_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
unsigned char *nonce_counter, unsigned char *stream_block,
const unsigned char *input, unsigned char *output )
{
- return blowfish_crypt_ctr( (blowfish_context *) ctx, length, nc_off,
+ return mbedtls_blowfish_crypt_ctr( (mbedtls_blowfish_context *) ctx, length, nc_off,
nonce_counter, stream_block, input, output );
}
-#endif /* POLARSSL_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
static int blowfish_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
- return blowfish_setkey( (blowfish_context *) ctx, key, key_length );
+ return mbedtls_blowfish_setkey( (mbedtls_blowfish_context *) ctx, key, key_length );
}
static void * blowfish_ctx_alloc( void )
{
- blowfish_context *ctx;
- ctx = polarssl_malloc( sizeof( blowfish_context ) );
+ mbedtls_blowfish_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
- blowfish_init( ctx );
+ mbedtls_blowfish_init( ctx );
return( ctx );
}
static void blowfish_ctx_free( void *ctx )
{
- blowfish_free( (blowfish_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_blowfish_free( (mbedtls_blowfish_context *) ctx );
+ mbedtls_free( ctx );
}
-static const cipher_base_t blowfish_info = {
- POLARSSL_CIPHER_ID_BLOWFISH,
+static const mbedtls_cipher_base_t blowfish_info = {
+ MBEDTLS_CIPHER_ID_BLOWFISH,
blowfish_crypt_ecb_wrap,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
blowfish_crypt_cbc_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
blowfish_crypt_cfb64_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
blowfish_crypt_ctr_wrap,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
blowfish_setkey_wrap,
@@ -1152,63 +1152,63 @@
blowfish_ctx_free
};
-static const cipher_info_t blowfish_ecb_info = {
- POLARSSL_CIPHER_BLOWFISH_ECB,
- POLARSSL_MODE_ECB,
+static const mbedtls_cipher_info_t blowfish_ecb_info = {
+ MBEDTLS_CIPHER_BLOWFISH_ECB,
+ MBEDTLS_MODE_ECB,
128,
"BLOWFISH-ECB",
8,
- POLARSSL_CIPHER_VARIABLE_KEY_LEN,
+ MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-static const cipher_info_t blowfish_cbc_info = {
- POLARSSL_CIPHER_BLOWFISH_CBC,
- POLARSSL_MODE_CBC,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+static const mbedtls_cipher_info_t blowfish_cbc_info = {
+ MBEDTLS_CIPHER_BLOWFISH_CBC,
+ MBEDTLS_MODE_CBC,
128,
"BLOWFISH-CBC",
8,
- POLARSSL_CIPHER_VARIABLE_KEY_LEN,
+ MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
-static const cipher_info_t blowfish_cfb64_info = {
- POLARSSL_CIPHER_BLOWFISH_CFB64,
- POLARSSL_MODE_CFB,
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+static const mbedtls_cipher_info_t blowfish_cfb64_info = {
+ MBEDTLS_CIPHER_BLOWFISH_CFB64,
+ MBEDTLS_MODE_CFB,
128,
"BLOWFISH-CFB64",
8,
- POLARSSL_CIPHER_VARIABLE_KEY_LEN,
+ MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
-#endif /* POLARSSL_CIPHER_MODE_CFB */
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
-static const cipher_info_t blowfish_ctr_info = {
- POLARSSL_CIPHER_BLOWFISH_CTR,
- POLARSSL_MODE_CTR,
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+static const mbedtls_cipher_info_t blowfish_ctr_info = {
+ MBEDTLS_CIPHER_BLOWFISH_CTR,
+ MBEDTLS_MODE_CTR,
128,
"BLOWFISH-CTR",
8,
- POLARSSL_CIPHER_VARIABLE_KEY_LEN,
+ MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
-#endif /* POLARSSL_CIPHER_MODE_CTR */
-#endif /* POLARSSL_BLOWFISH_C */
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
+#endif /* MBEDTLS_BLOWFISH_C */
-#if defined(POLARSSL_ARC4_C)
+#if defined(MBEDTLS_ARC4_C)
static int arc4_crypt_stream_wrap( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
{
- return( arc4_crypt( (arc4_context *) ctx, length, input, output ) );
+ return( mbedtls_arc4_crypt( (mbedtls_arc4_context *) ctx, length, input, output ) );
}
static int arc4_setkey_wrap( void *ctx, const unsigned char *key,
@@ -1216,44 +1216,44 @@
{
/* we get key_length in bits, arc4 expects it in bytes */
if( key_length % 8 != 0 )
- return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
- arc4_setup( (arc4_context *) ctx, key, key_length / 8 );
+ mbedtls_arc4_setup( (mbedtls_arc4_context *) ctx, key, key_length / 8 );
return( 0 );
}
static void * arc4_ctx_alloc( void )
{
- arc4_context *ctx;
- ctx = polarssl_malloc( sizeof( arc4_context ) );
+ mbedtls_arc4_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_arc4_context ) );
if( ctx == NULL )
return( NULL );
- arc4_init( ctx );
+ mbedtls_arc4_init( ctx );
return( ctx );
}
static void arc4_ctx_free( void *ctx )
{
- arc4_free( (arc4_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_arc4_free( (mbedtls_arc4_context *) ctx );
+ mbedtls_free( ctx );
}
-static const cipher_base_t arc4_base_info = {
- POLARSSL_CIPHER_ID_ARC4,
+static const mbedtls_cipher_base_t arc4_base_info = {
+ MBEDTLS_CIPHER_ID_ARC4,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
arc4_crypt_stream_wrap,
#endif
arc4_setkey_wrap,
@@ -1262,9 +1262,9 @@
arc4_ctx_free
};
-static const cipher_info_t arc4_128_info = {
- POLARSSL_CIPHER_ARC4_128,
- POLARSSL_MODE_STREAM,
+static const mbedtls_cipher_info_t arc4_128_info = {
+ MBEDTLS_CIPHER_ARC4_128,
+ MBEDTLS_MODE_STREAM,
128,
"ARC4-128",
0,
@@ -1272,9 +1272,9 @@
1,
&arc4_base_info
};
-#endif /* POLARSSL_ARC4_C */
+#endif /* MBEDTLS_ARC4_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
static int null_crypt_stream( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
@@ -1304,19 +1304,19 @@
((void) ctx);
}
-static const cipher_base_t null_base_info = {
- POLARSSL_CIPHER_ID_NULL,
+static const mbedtls_cipher_base_t null_base_info = {
+ MBEDTLS_CIPHER_ID_NULL,
NULL,
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
-#if defined(POLARSSL_CIPHER_MODE_STREAM)
+#if defined(MBEDTLS_CIPHER_MODE_STREAM)
null_crypt_stream,
#endif
null_setkey,
@@ -1325,9 +1325,9 @@
null_ctx_free
};
-static const cipher_info_t null_cipher_info = {
- POLARSSL_CIPHER_NULL,
- POLARSSL_MODE_STREAM,
+static const mbedtls_cipher_info_t null_cipher_info = {
+ MBEDTLS_CIPHER_NULL,
+ MBEDTLS_MODE_STREAM,
0,
"NULL",
0,
@@ -1335,108 +1335,108 @@
1,
&null_base_info
};
-#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
+#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
-const cipher_definition_t cipher_definitions[] =
+const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
{
-#if defined(POLARSSL_AES_C)
- { POLARSSL_CIPHER_AES_128_ECB, &aes_128_ecb_info },
- { POLARSSL_CIPHER_AES_192_ECB, &aes_192_ecb_info },
- { POLARSSL_CIPHER_AES_256_ECB, &aes_256_ecb_info },
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { POLARSSL_CIPHER_AES_128_CBC, &aes_128_cbc_info },
- { POLARSSL_CIPHER_AES_192_CBC, &aes_192_cbc_info },
- { POLARSSL_CIPHER_AES_256_CBC, &aes_256_cbc_info },
+#if defined(MBEDTLS_AES_C)
+ { MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info },
+ { MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info },
+ { MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info },
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info },
+ { MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info },
+ { MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
- { POLARSSL_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
- { POLARSSL_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
- { POLARSSL_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+ { MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
+ { MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
+ { MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
- { POLARSSL_CIPHER_AES_128_CTR, &aes_128_ctr_info },
- { POLARSSL_CIPHER_AES_192_CTR, &aes_192_ctr_info },
- { POLARSSL_CIPHER_AES_256_CTR, &aes_256_ctr_info },
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+ { MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info },
+ { MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info },
+ { MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info },
#endif
-#if defined(POLARSSL_GCM_C)
- { POLARSSL_CIPHER_AES_128_GCM, &aes_128_gcm_info },
- { POLARSSL_CIPHER_AES_192_GCM, &aes_192_gcm_info },
- { POLARSSL_CIPHER_AES_256_GCM, &aes_256_gcm_info },
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
+ { MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
+ { MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
#endif
-#if defined(POLARSSL_CCM_C)
- { POLARSSL_CIPHER_AES_128_CCM, &aes_128_ccm_info },
- { POLARSSL_CIPHER_AES_192_CCM, &aes_192_ccm_info },
- { POLARSSL_CIPHER_AES_256_CCM, &aes_256_ccm_info },
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
+ { MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
+ { MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
#endif
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_ARC4_C)
- { POLARSSL_CIPHER_ARC4_128, &arc4_128_info },
+#if defined(MBEDTLS_ARC4_C)
+ { MBEDTLS_CIPHER_ARC4_128, &arc4_128_info },
#endif
-#if defined(POLARSSL_BLOWFISH_C)
- { POLARSSL_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info },
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { POLARSSL_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info },
+#if defined(MBEDTLS_BLOWFISH_C)
+ { MBEDTLS_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info },
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
- { POLARSSL_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info },
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+ { MBEDTLS_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
- { POLARSSL_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info },
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+ { MBEDTLS_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info },
#endif
-#endif /* POLARSSL_BLOWFISH_C */
+#endif /* MBEDTLS_BLOWFISH_C */
-#if defined(POLARSSL_CAMELLIA_C)
- { POLARSSL_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
- { POLARSSL_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
- { POLARSSL_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { POLARSSL_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
- { POLARSSL_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
- { POLARSSL_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
+#if defined(MBEDTLS_CAMELLIA_C)
+ { MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CFB)
- { POLARSSL_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
- { POLARSSL_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
- { POLARSSL_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+ { MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
#endif
-#if defined(POLARSSL_CIPHER_MODE_CTR)
- { POLARSSL_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
- { POLARSSL_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
- { POLARSSL_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+ { MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
#endif
-#if defined(POLARSSL_GCM_C)
- { POLARSSL_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
- { POLARSSL_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
- { POLARSSL_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
#endif
-#if defined(POLARSSL_CCM_C)
- { POLARSSL_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
- { POLARSSL_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
- { POLARSSL_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
+ { MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
+ { MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
#endif
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
- { POLARSSL_CIPHER_DES_ECB, &des_ecb_info },
- { POLARSSL_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
- { POLARSSL_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { POLARSSL_CIPHER_DES_CBC, &des_cbc_info },
- { POLARSSL_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
- { POLARSSL_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
+#if defined(MBEDTLS_DES_C)
+ { MBEDTLS_CIPHER_DES_ECB, &des_ecb_info },
+ { MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
+ { MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_CIPHER_DES_CBC, &des_cbc_info },
+ { MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
+ { MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
#endif
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
- { POLARSSL_CIPHER_NULL, &null_cipher_info },
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+ { MBEDTLS_CIPHER_NULL, &null_cipher_info },
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
- { POLARSSL_CIPHER_NONE, NULL }
+ { MBEDTLS_CIPHER_NONE, NULL }
};
-#define NUM_CIPHERS sizeof cipher_definitions / sizeof cipher_definitions[0]
-int supported_ciphers[NUM_CIPHERS];
+#define NUM_CIPHERS sizeof mbedtls_cipher_definitions / sizeof mbedtls_cipher_definitions[0]
+int mbedtls_cipher_supported[NUM_CIPHERS];
-#endif /* POLARSSL_CIPHER_C */
+#endif /* MBEDTLS_CIPHER_C */
diff --git a/library/ctr_drbg.c b/library/ctr_drbg.c
index aee3833..355d0f4 100644
--- a/library/ctr_drbg.c
+++ b/library/ctr_drbg.c
@@ -25,33 +25,33 @@
* http://csrc.nist.gov/publications/nistpubs/800-90/SP800-90revised_March2007.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_CTR_DRBG_C)
+#if defined(MBEDTLS_CTR_DRBG_C)
#include "mbedtls/ctr_drbg.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -59,8 +59,8 @@
* Non-public function wrapped by ctr_crbg_init(). Necessary to allow NIST
* tests to succeed (which require known length fixed entropy)
*/
-int ctr_drbg_init_entropy_len(
- ctr_drbg_context *ctx,
+int mbedtls_ctr_drbg_init_entropy_len(
+ mbedtls_ctr_drbg_context *ctx,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
@@ -68,60 +68,60 @@
size_t entropy_len )
{
int ret;
- unsigned char key[CTR_DRBG_KEYSIZE];
+ unsigned char key[MBEDTLS_CTR_DRBG_KEYSIZE];
- memset( ctx, 0, sizeof(ctr_drbg_context) );
- memset( key, 0, CTR_DRBG_KEYSIZE );
+ memset( ctx, 0, sizeof(mbedtls_ctr_drbg_context) );
+ memset( key, 0, MBEDTLS_CTR_DRBG_KEYSIZE );
- aes_init( &ctx->aes_ctx );
+ mbedtls_aes_init( &ctx->aes_ctx );
ctx->f_entropy = f_entropy;
ctx->p_entropy = p_entropy;
ctx->entropy_len = entropy_len;
- ctx->reseed_interval = CTR_DRBG_RESEED_INTERVAL;
+ ctx->reseed_interval = MBEDTLS_CTR_DRBG_RESEED_INTERVAL;
/*
* Initialize with an empty key
*/
- aes_setkey_enc( &ctx->aes_ctx, key, CTR_DRBG_KEYBITS );
+ mbedtls_aes_setkey_enc( &ctx->aes_ctx, key, MBEDTLS_CTR_DRBG_KEYBITS );
- if( ( ret = ctr_drbg_reseed( ctx, custom, len ) ) != 0 )
+ if( ( ret = mbedtls_ctr_drbg_reseed( ctx, custom, len ) ) != 0 )
return( ret );
return( 0 );
}
-int ctr_drbg_init( ctr_drbg_context *ctx,
+int mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *ctx,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
size_t len )
{
- return( ctr_drbg_init_entropy_len( ctx, f_entropy, p_entropy, custom, len,
- CTR_DRBG_ENTROPY_LEN ) );
+ return( mbedtls_ctr_drbg_init_entropy_len( ctx, f_entropy, p_entropy, custom, len,
+ MBEDTLS_CTR_DRBG_ENTROPY_LEN ) );
}
-void ctr_drbg_free( ctr_drbg_context *ctx )
+void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx )
{
if( ctx == NULL )
return;
- aes_free( &ctx->aes_ctx );
- polarssl_zeroize( ctx, sizeof( ctr_drbg_context ) );
+ mbedtls_aes_free( &ctx->aes_ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_ctr_drbg_context ) );
}
-void ctr_drbg_set_prediction_resistance( ctr_drbg_context *ctx, int resistance )
+void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx, int resistance )
{
ctx->prediction_resistance = resistance;
}
-void ctr_drbg_set_entropy_len( ctr_drbg_context *ctx, size_t len )
+void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx, size_t len )
{
ctx->entropy_len = len;
}
-void ctr_drbg_set_reseed_interval( ctr_drbg_context *ctx, int interval )
+void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx, int interval )
{
ctx->reseed_interval = interval;
}
@@ -129,21 +129,21 @@
static int block_cipher_df( unsigned char *output,
const unsigned char *data, size_t data_len )
{
- unsigned char buf[CTR_DRBG_MAX_SEED_INPUT + CTR_DRBG_BLOCKSIZE + 16];
- unsigned char tmp[CTR_DRBG_SEEDLEN];
- unsigned char key[CTR_DRBG_KEYSIZE];
- unsigned char chain[CTR_DRBG_BLOCKSIZE];
+ unsigned char buf[MBEDTLS_CTR_DRBG_MAX_SEED_INPUT + MBEDTLS_CTR_DRBG_BLOCKSIZE + 16];
+ unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
+ unsigned char key[MBEDTLS_CTR_DRBG_KEYSIZE];
+ unsigned char chain[MBEDTLS_CTR_DRBG_BLOCKSIZE];
unsigned char *p, *iv;
- aes_context aes_ctx;
+ mbedtls_aes_context aes_ctx;
int i, j;
size_t buf_len, use_len;
- if( data_len > CTR_DRBG_MAX_SEED_INPUT )
- return( POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ if( data_len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
+ return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
- memset( buf, 0, CTR_DRBG_MAX_SEED_INPUT + CTR_DRBG_BLOCKSIZE + 16 );
- aes_init( &aes_ctx );
+ memset( buf, 0, MBEDTLS_CTR_DRBG_MAX_SEED_INPUT + MBEDTLS_CTR_DRBG_BLOCKSIZE + 16 );
+ mbedtls_aes_init( &aes_ctx );
/*
* Construct IV (16 bytes) and S in buffer
@@ -152,44 +152,44 @@
* data || 0x80
* (Total is padded to a multiple of 16-bytes with zeroes)
*/
- p = buf + CTR_DRBG_BLOCKSIZE;
+ p = buf + MBEDTLS_CTR_DRBG_BLOCKSIZE;
*p++ = ( data_len >> 24 ) & 0xff;
*p++ = ( data_len >> 16 ) & 0xff;
*p++ = ( data_len >> 8 ) & 0xff;
*p++ = ( data_len ) & 0xff;
p += 3;
- *p++ = CTR_DRBG_SEEDLEN;
+ *p++ = MBEDTLS_CTR_DRBG_SEEDLEN;
memcpy( p, data, data_len );
p[data_len] = 0x80;
- buf_len = CTR_DRBG_BLOCKSIZE + 8 + data_len + 1;
+ buf_len = MBEDTLS_CTR_DRBG_BLOCKSIZE + 8 + data_len + 1;
- for( i = 0; i < CTR_DRBG_KEYSIZE; i++ )
+ for( i = 0; i < MBEDTLS_CTR_DRBG_KEYSIZE; i++ )
key[i] = i;
- aes_setkey_enc( &aes_ctx, key, CTR_DRBG_KEYBITS );
+ mbedtls_aes_setkey_enc( &aes_ctx, key, MBEDTLS_CTR_DRBG_KEYBITS );
/*
- * Reduce data to CTR_DRBG_SEEDLEN bytes of data
+ * Reduce data to MBEDTLS_CTR_DRBG_SEEDLEN bytes of data
*/
- for( j = 0; j < CTR_DRBG_SEEDLEN; j += CTR_DRBG_BLOCKSIZE )
+ for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
p = buf;
- memset( chain, 0, CTR_DRBG_BLOCKSIZE );
+ memset( chain, 0, MBEDTLS_CTR_DRBG_BLOCKSIZE );
use_len = buf_len;
while( use_len > 0 )
{
- for( i = 0; i < CTR_DRBG_BLOCKSIZE; i++ )
+ for( i = 0; i < MBEDTLS_CTR_DRBG_BLOCKSIZE; i++ )
chain[i] ^= p[i];
- p += CTR_DRBG_BLOCKSIZE;
- use_len -= ( use_len >= CTR_DRBG_BLOCKSIZE ) ?
- CTR_DRBG_BLOCKSIZE : use_len;
+ p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
+ use_len -= ( use_len >= MBEDTLS_CTR_DRBG_BLOCKSIZE ) ?
+ MBEDTLS_CTR_DRBG_BLOCKSIZE : use_len;
- aes_crypt_ecb( &aes_ctx, AES_ENCRYPT, chain, chain );
+ mbedtls_aes_crypt_ecb( &aes_ctx, MBEDTLS_AES_ENCRYPT, chain, chain );
}
- memcpy( tmp + j, chain, CTR_DRBG_BLOCKSIZE );
+ memcpy( tmp + j, chain, MBEDTLS_CTR_DRBG_BLOCKSIZE );
/*
* Update IV
@@ -200,87 +200,87 @@
/*
* Do final encryption with reduced data
*/
- aes_setkey_enc( &aes_ctx, tmp, CTR_DRBG_KEYBITS );
- iv = tmp + CTR_DRBG_KEYSIZE;
+ mbedtls_aes_setkey_enc( &aes_ctx, tmp, MBEDTLS_CTR_DRBG_KEYBITS );
+ iv = tmp + MBEDTLS_CTR_DRBG_KEYSIZE;
p = output;
- for( j = 0; j < CTR_DRBG_SEEDLEN; j += CTR_DRBG_BLOCKSIZE )
+ for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
- aes_crypt_ecb( &aes_ctx, AES_ENCRYPT, iv, iv );
- memcpy( p, iv, CTR_DRBG_BLOCKSIZE );
- p += CTR_DRBG_BLOCKSIZE;
+ mbedtls_aes_crypt_ecb( &aes_ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
+ memcpy( p, iv, MBEDTLS_CTR_DRBG_BLOCKSIZE );
+ p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
}
- aes_free( &aes_ctx );
+ mbedtls_aes_free( &aes_ctx );
return( 0 );
}
-static int ctr_drbg_update_internal( ctr_drbg_context *ctx,
- const unsigned char data[CTR_DRBG_SEEDLEN] )
+static int ctr_drbg_update_internal( mbedtls_ctr_drbg_context *ctx,
+ const unsigned char data[MBEDTLS_CTR_DRBG_SEEDLEN] )
{
- unsigned char tmp[CTR_DRBG_SEEDLEN];
+ unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = tmp;
int i, j;
- memset( tmp, 0, CTR_DRBG_SEEDLEN );
+ memset( tmp, 0, MBEDTLS_CTR_DRBG_SEEDLEN );
- for( j = 0; j < CTR_DRBG_SEEDLEN; j += CTR_DRBG_BLOCKSIZE )
+ for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
/*
* Increase counter
*/
- for( i = CTR_DRBG_BLOCKSIZE; i > 0; i-- )
+ for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- )
if( ++ctx->counter[i - 1] != 0 )
break;
/*
* Crypt counter block
*/
- aes_crypt_ecb( &ctx->aes_ctx, AES_ENCRYPT, ctx->counter, p );
+ mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT, ctx->counter, p );
- p += CTR_DRBG_BLOCKSIZE;
+ p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
}
- for( i = 0; i < CTR_DRBG_SEEDLEN; i++ )
+ for( i = 0; i < MBEDTLS_CTR_DRBG_SEEDLEN; i++ )
tmp[i] ^= data[i];
/*
* Update key and counter
*/
- aes_setkey_enc( &ctx->aes_ctx, tmp, CTR_DRBG_KEYBITS );
- memcpy( ctx->counter, tmp + CTR_DRBG_KEYSIZE, CTR_DRBG_BLOCKSIZE );
+ mbedtls_aes_setkey_enc( &ctx->aes_ctx, tmp, MBEDTLS_CTR_DRBG_KEYBITS );
+ memcpy( ctx->counter, tmp + MBEDTLS_CTR_DRBG_KEYSIZE, MBEDTLS_CTR_DRBG_BLOCKSIZE );
return( 0 );
}
-void ctr_drbg_update( ctr_drbg_context *ctx,
+void mbedtls_ctr_drbg_update( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional, size_t add_len )
{
- unsigned char add_input[CTR_DRBG_SEEDLEN];
+ unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
if( add_len > 0 )
{
/* MAX_INPUT would be more logical here, but we have to match
* block_cipher_df()'s limits since we can't propagate errors */
- if( add_len > CTR_DRBG_MAX_SEED_INPUT )
- add_len = CTR_DRBG_MAX_SEED_INPUT;
+ if( add_len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
+ add_len = MBEDTLS_CTR_DRBG_MAX_SEED_INPUT;
block_cipher_df( add_input, additional, add_len );
ctr_drbg_update_internal( ctx, add_input );
}
}
-int ctr_drbg_reseed( ctr_drbg_context *ctx,
+int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional, size_t len )
{
- unsigned char seed[CTR_DRBG_MAX_SEED_INPUT];
+ unsigned char seed[MBEDTLS_CTR_DRBG_MAX_SEED_INPUT];
size_t seedlen = 0;
- if( ctx->entropy_len + len > CTR_DRBG_MAX_SEED_INPUT )
- return( POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ if( ctx->entropy_len + len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
+ return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
- memset( seed, 0, CTR_DRBG_MAX_SEED_INPUT );
+ memset( seed, 0, MBEDTLS_CTR_DRBG_MAX_SEED_INPUT );
/*
* Gather entropy_len bytes of entropy to seed state
@@ -288,7 +288,7 @@
if( 0 != ctx->f_entropy( ctx->p_entropy, seed,
ctx->entropy_len ) )
{
- return( POLARSSL_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED );
}
seedlen += ctx->entropy_len;
@@ -316,30 +316,30 @@
return( 0 );
}
-int ctr_drbg_random_with_add( void *p_rng,
+int mbedtls_ctr_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t output_len,
const unsigned char *additional, size_t add_len )
{
int ret = 0;
- ctr_drbg_context *ctx = (ctr_drbg_context *) p_rng;
- unsigned char add_input[CTR_DRBG_SEEDLEN];
+ mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng;
+ unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = output;
- unsigned char tmp[CTR_DRBG_BLOCKSIZE];
+ unsigned char tmp[MBEDTLS_CTR_DRBG_BLOCKSIZE];
int i;
size_t use_len;
- if( output_len > CTR_DRBG_MAX_REQUEST )
- return( POLARSSL_ERR_CTR_DRBG_REQUEST_TOO_BIG );
+ if( output_len > MBEDTLS_CTR_DRBG_MAX_REQUEST )
+ return( MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG );
- if( add_len > CTR_DRBG_MAX_INPUT )
- return( POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ if( add_len > MBEDTLS_CTR_DRBG_MAX_INPUT )
+ return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
- memset( add_input, 0, CTR_DRBG_SEEDLEN );
+ memset( add_input, 0, MBEDTLS_CTR_DRBG_SEEDLEN );
if( ctx->reseed_counter > ctx->reseed_interval ||
ctx->prediction_resistance )
{
- if( ( ret = ctr_drbg_reseed( ctx, additional, add_len ) ) != 0 )
+ if( ( ret = mbedtls_ctr_drbg_reseed( ctx, additional, add_len ) ) != 0 )
return( ret );
add_len = 0;
@@ -356,16 +356,16 @@
/*
* Increase counter
*/
- for( i = CTR_DRBG_BLOCKSIZE; i > 0; i-- )
+ for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- )
if( ++ctx->counter[i - 1] != 0 )
break;
/*
* Crypt counter block
*/
- aes_crypt_ecb( &ctx->aes_ctx, AES_ENCRYPT, ctx->counter, tmp );
+ mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT, ctx->counter, tmp );
- use_len = ( output_len > CTR_DRBG_BLOCKSIZE ) ? CTR_DRBG_BLOCKSIZE :
+ use_len = ( output_len > MBEDTLS_CTR_DRBG_BLOCKSIZE ) ? MBEDTLS_CTR_DRBG_BLOCKSIZE :
output_len;
/*
* Copy random block to destination
@@ -382,27 +382,27 @@
return( 0 );
}
-int ctr_drbg_random( void *p_rng, unsigned char *output, size_t output_len )
+int mbedtls_ctr_drbg_random( void *p_rng, unsigned char *output, size_t output_len )
{
- return ctr_drbg_random_with_add( p_rng, output, output_len, NULL, 0 );
+ return mbedtls_ctr_drbg_random_with_add( p_rng, output, output_len, NULL, 0 );
}
-#if defined(POLARSSL_FS_IO)
-int ctr_drbg_write_seed_file( ctr_drbg_context *ctx, const char *path )
+#if defined(MBEDTLS_FS_IO)
+int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path )
{
- int ret = POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR;
+ int ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR;
FILE *f;
- unsigned char buf[ CTR_DRBG_MAX_INPUT ];
+ unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "wb" ) ) == NULL )
- return( POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
- if( ( ret = ctr_drbg_random( ctx, buf, CTR_DRBG_MAX_INPUT ) ) != 0 )
+ if( ( ret = mbedtls_ctr_drbg_random( ctx, buf, MBEDTLS_CTR_DRBG_MAX_INPUT ) ) != 0 )
goto exit;
- if( fwrite( buf, 1, CTR_DRBG_MAX_INPUT, f ) != CTR_DRBG_MAX_INPUT )
+ if( fwrite( buf, 1, MBEDTLS_CTR_DRBG_MAX_INPUT, f ) != MBEDTLS_CTR_DRBG_MAX_INPUT )
{
- ret = POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR;
+ ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR;
goto exit;
}
@@ -413,40 +413,40 @@
return( ret );
}
-int ctr_drbg_update_seed_file( ctr_drbg_context *ctx, const char *path )
+int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path )
{
FILE *f;
size_t n;
- unsigned char buf[ CTR_DRBG_MAX_INPUT ];
+ unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
n = (size_t) ftell( f );
fseek( f, 0, SEEK_SET );
- if( n > CTR_DRBG_MAX_INPUT )
+ if( n > MBEDTLS_CTR_DRBG_MAX_INPUT )
{
fclose( f );
- return( POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
}
if( fread( buf, 1, n, f ) != n )
{
fclose( f );
- return( POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
}
fclose( f );
- ctr_drbg_update( ctx, buf, n );
+ mbedtls_ctr_drbg_update( ctx, buf, n );
- return( ctr_drbg_write_seed_file( ctx, path ) );
+ return( mbedtls_ctr_drbg_write_seed_file( ctx, path ) );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
static const unsigned char entropy_source_pr[96] =
{ 0xc1, 0x80, 0x81, 0xa6, 0x5d, 0x44, 0x02, 0x16,
@@ -501,57 +501,57 @@
#define CHK( c ) if( (c) != 0 ) \
{ \
if( verbose != 0 ) \
- polarssl_printf( "failed\n" ); \
+ mbedtls_printf( "failed\n" ); \
return( 1 ); \
}
/*
* Checkup routine
*/
-int ctr_drbg_self_test( int verbose )
+int mbedtls_ctr_drbg_self_test( int verbose )
{
- ctr_drbg_context ctx;
+ mbedtls_ctr_drbg_context ctx;
unsigned char buf[16];
/*
* Based on a NIST CTR_DRBG test vector (PR = True)
*/
if( verbose != 0 )
- polarssl_printf( " CTR_DRBG (PR = TRUE) : " );
+ mbedtls_printf( " CTR_DRBG (PR = TRUE) : " );
test_offset = 0;
- CHK( ctr_drbg_init_entropy_len( &ctx, ctr_drbg_self_test_entropy,
+ CHK( mbedtls_ctr_drbg_init_entropy_len( &ctx, ctr_drbg_self_test_entropy,
(void *) entropy_source_pr, nonce_pers_pr, 16, 32 ) );
- ctr_drbg_set_prediction_resistance( &ctx, CTR_DRBG_PR_ON );
- CHK( ctr_drbg_random( &ctx, buf, CTR_DRBG_BLOCKSIZE ) );
- CHK( ctr_drbg_random( &ctx, buf, CTR_DRBG_BLOCKSIZE ) );
- CHK( memcmp( buf, result_pr, CTR_DRBG_BLOCKSIZE ) );
+ mbedtls_ctr_drbg_set_prediction_resistance( &ctx, MBEDTLS_CTR_DRBG_PR_ON );
+ CHK( mbedtls_ctr_drbg_random( &ctx, buf, MBEDTLS_CTR_DRBG_BLOCKSIZE ) );
+ CHK( mbedtls_ctr_drbg_random( &ctx, buf, MBEDTLS_CTR_DRBG_BLOCKSIZE ) );
+ CHK( memcmp( buf, result_pr, MBEDTLS_CTR_DRBG_BLOCKSIZE ) );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
/*
* Based on a NIST CTR_DRBG test vector (PR = FALSE)
*/
if( verbose != 0 )
- polarssl_printf( " CTR_DRBG (PR = FALSE): " );
+ mbedtls_printf( " CTR_DRBG (PR = FALSE): " );
test_offset = 0;
- CHK( ctr_drbg_init_entropy_len( &ctx, ctr_drbg_self_test_entropy,
+ CHK( mbedtls_ctr_drbg_init_entropy_len( &ctx, ctr_drbg_self_test_entropy,
(void *) entropy_source_nopr, nonce_pers_nopr, 16, 32 ) );
- CHK( ctr_drbg_random( &ctx, buf, 16 ) );
- CHK( ctr_drbg_reseed( &ctx, NULL, 0 ) );
- CHK( ctr_drbg_random( &ctx, buf, 16 ) );
+ CHK( mbedtls_ctr_drbg_random( &ctx, buf, 16 ) );
+ CHK( mbedtls_ctr_drbg_reseed( &ctx, NULL, 0 ) );
+ CHK( mbedtls_ctr_drbg_random( &ctx, buf, 16 ) );
CHK( memcmp( buf, result_nopr, 16 ) );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_CTR_DRBG_C */
+#endif /* MBEDTLS_CTR_DRBG_C */
diff --git a/library/debug.c b/library/debug.c
index ade98d4..8dae2ed 100644
--- a/library/debug.c
+++ b/library/debug.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_DEBUG_C)
+#if defined(MBEDTLS_DEBUG_C)
#include "mbedtls/debug.h"
@@ -44,26 +44,26 @@
#endif
#endif /* _MSC_VER */
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
-#define polarssl_snprintf snprintf
+#define mbedtls_snprintf snprintf
#endif
-static int debug_log_mode = POLARSSL_DEBUG_DFL_MODE;
+static int debug_log_mode = MBEDTLS_DEBUG_DFL_MODE;
static int debug_threshold = 0;
-void debug_set_log_mode( int log_mode )
+void mbedtls_debug_set_log_mode( int log_mode )
{
debug_log_mode = log_mode;
}
-void debug_set_threshold( int threshold )
+void mbedtls_debug_set_threshold( int threshold )
{
debug_threshold = threshold;
}
-char *debug_fmt( const char *format, ... )
+char *mbedtls_debug_fmt( const char *format, ... )
{
va_list argp;
static char str[512];
@@ -77,7 +77,7 @@
return( str );
}
-void debug_print_msg( const ssl_context *ssl, int level,
+void mbedtls_debug_print_msg( const mbedtls_ssl_context *ssl, int level,
const char *file, int line, const char *text )
{
char str[512];
@@ -86,18 +86,18 @@
if( ssl->f_dbg == NULL || level > debug_threshold )
return;
- if( debug_log_mode == POLARSSL_DEBUG_LOG_RAW )
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_RAW )
{
ssl->f_dbg( ssl->p_dbg, level, text );
return;
}
- polarssl_snprintf( str, maxlen, "%s(%04d): %s\n", file, line, text );
+ mbedtls_snprintf( str, maxlen, "%s(%04d): %s\n", file, line, text );
str[maxlen] = '\0';
ssl->f_dbg( ssl->p_dbg, level, str );
}
-void debug_print_ret( const ssl_context *ssl, int level,
+void mbedtls_debug_print_ret( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
const char *text, int ret )
{
@@ -108,17 +108,17 @@
if( ssl->f_dbg == NULL || level > debug_threshold )
return;
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
- polarssl_snprintf( str + idx, maxlen - idx, "%s() returned %d (-0x%04x)\n",
+ mbedtls_snprintf( str + idx, maxlen - idx, "%s() returned %d (-0x%04x)\n",
text, ret, -ret );
str[maxlen] = '\0';
ssl->f_dbg( ssl->p_dbg, level, str );
}
-void debug_print_buf( const ssl_context *ssl, int level,
+void mbedtls_debug_print_buf( const mbedtls_ssl_context *ssl, int level,
const char *file, int line, const char *text,
const unsigned char *buf, size_t len )
{
@@ -129,10 +129,10 @@
if( ssl->f_dbg == NULL || level > debug_threshold )
return;
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
- polarssl_snprintf( str + idx, maxlen - idx, "dumping '%s' (%u bytes)\n",
+ mbedtls_snprintf( str + idx, maxlen - idx, "dumping '%s' (%u bytes)\n",
text, (unsigned int) len );
str[maxlen] = '\0';
@@ -149,22 +149,22 @@
{
if( i > 0 )
{
- polarssl_snprintf( str + idx, maxlen - idx, " %s\n", txt );
+ mbedtls_snprintf( str + idx, maxlen - idx, " %s\n", txt );
ssl->f_dbg( ssl->p_dbg, level, str );
idx = 0;
memset( txt, 0, sizeof( txt ) );
}
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
- idx += polarssl_snprintf( str + idx, maxlen - idx, "%04x: ",
+ idx += mbedtls_snprintf( str + idx, maxlen - idx, "%04x: ",
(unsigned int) i );
}
- idx += polarssl_snprintf( str + idx, maxlen - idx, " %02x",
+ idx += mbedtls_snprintf( str + idx, maxlen - idx, " %02x",
(unsigned int) buf[i] );
txt[i % 16] = ( buf[i] > 31 && buf[i] < 127 ) ? buf[i] : '.' ;
}
@@ -172,17 +172,17 @@
if( len > 0 )
{
for( /* i = i */; i % 16 != 0; i++ )
- idx += polarssl_snprintf( str + idx, maxlen - idx, " " );
+ idx += mbedtls_snprintf( str + idx, maxlen - idx, " " );
- polarssl_snprintf( str + idx, maxlen - idx, " %s\n", txt );
+ mbedtls_snprintf( str + idx, maxlen - idx, " %s\n", txt );
ssl->f_dbg( ssl->p_dbg, level, str );
}
}
-#if defined(POLARSSL_ECP_C)
-void debug_print_ecp( const ssl_context *ssl, int level,
+#if defined(MBEDTLS_ECP_C)
+void mbedtls_debug_print_ecp( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
- const char *text, const ecp_point *X )
+ const char *text, const mbedtls_ecp_point *X )
{
char str[512];
int maxlen = sizeof( str ) - 1;
@@ -190,20 +190,20 @@
if( ssl->f_dbg == NULL || level > debug_threshold )
return;
- polarssl_snprintf( str, maxlen, "%s(X)", text );
+ mbedtls_snprintf( str, maxlen, "%s(X)", text );
str[maxlen] = '\0';
- debug_print_mpi( ssl, level, file, line, str, &X->X );
+ mbedtls_debug_print_mpi( ssl, level, file, line, str, &X->X );
- polarssl_snprintf( str, maxlen, "%s(Y)", text );
+ mbedtls_snprintf( str, maxlen, "%s(Y)", text );
str[maxlen] = '\0';
- debug_print_mpi( ssl, level, file, line, str, &X->Y );
+ mbedtls_debug_print_mpi( ssl, level, file, line, str, &X->Y );
}
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
-#if defined(POLARSSL_BIGNUM_C)
-void debug_print_mpi( const ssl_context *ssl, int level,
+#if defined(MBEDTLS_BIGNUM_C)
+void mbedtls_debug_print_mpi( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
- const char *text, const mpi *X )
+ const char *text, const mbedtls_mpi *X )
{
char str[512];
int j, k, maxlen = sizeof( str ) - 1, zeros = 1;
@@ -216,15 +216,15 @@
if( X->p[n] != 0 )
break;
- for( j = ( sizeof(t_uint) << 3 ) - 1; j >= 0; j-- )
+ for( j = ( sizeof(mbedtls_mpi_uint) << 3 ) - 1; j >= 0; j-- )
if( ( ( X->p[n] >> j ) & 1 ) != 0 )
break;
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
- polarssl_snprintf( str + idx, maxlen - idx, "value of '%s' (%d bits) is:\n",
- text, (int) ( ( n * ( sizeof(t_uint) << 3 ) ) + j + 1 ) );
+ mbedtls_snprintf( str + idx, maxlen - idx, "value of '%s' (%d bits) is:\n",
+ text, (int) ( ( n * ( sizeof(mbedtls_mpi_uint) << 3 ) ) + j + 1 ) );
str[maxlen] = '\0';
ssl->f_dbg( ssl->p_dbg, level, str );
@@ -235,7 +235,7 @@
if( zeros && X->p[i - 1] == 0 )
continue;
- for( k = sizeof( t_uint ) - 1; k >= 0; k-- )
+ for( k = sizeof( mbedtls_mpi_uint ) - 1; k >= 0; k-- )
{
if( zeros && ( ( X->p[i - 1] >> ( k << 3 ) ) & 0xFF ) == 0 )
continue;
@@ -246,16 +246,16 @@
{
if( j > 0 )
{
- polarssl_snprintf( str + idx, maxlen - idx, "\n" );
+ mbedtls_snprintf( str + idx, maxlen - idx, "\n" );
ssl->f_dbg( ssl->p_dbg, level, str );
idx = 0;
}
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
}
- idx += polarssl_snprintf( str + idx, maxlen - idx, " %02x", (unsigned int)
+ idx += mbedtls_snprintf( str + idx, maxlen - idx, " %02x", (unsigned int)
( X->p[i - 1] >> ( k << 3 ) ) & 0xFF );
j++;
@@ -265,59 +265,59 @@
if( zeros == 1 )
{
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
{
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
}
- idx += polarssl_snprintf( str + idx, maxlen - idx, " 00" );
+ idx += mbedtls_snprintf( str + idx, maxlen - idx, " 00" );
}
- polarssl_snprintf( str + idx, maxlen - idx, "\n" );
+ mbedtls_snprintf( str + idx, maxlen - idx, "\n" );
ssl->f_dbg( ssl->p_dbg, level, str );
}
-#endif /* POLARSSL_BIGNUM_C */
+#endif /* MBEDTLS_BIGNUM_C */
-#if defined(POLARSSL_X509_CRT_PARSE_C)
-static void debug_print_pk( const ssl_context *ssl, int level,
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+static void debug_print_pk( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
- const char *text, const pk_context *pk )
+ const char *text, const mbedtls_pk_context *pk )
{
size_t i;
- pk_debug_item items[POLARSSL_PK_DEBUG_MAX_ITEMS];
+ mbedtls_pk_debug_item items[MBEDTLS_PK_DEBUG_MAX_ITEMS];
char name[16];
memset( items, 0, sizeof( items ) );
- if( pk_debug( pk, items ) != 0 )
+ if( mbedtls_pk_debug( pk, items ) != 0 )
{
- debug_print_msg( ssl, level, file, line, "invalid PK context" );
+ mbedtls_debug_print_msg( ssl, level, file, line, "invalid PK context" );
return;
}
- for( i = 0; i < POLARSSL_PK_DEBUG_MAX_ITEMS; i++ )
+ for( i = 0; i < MBEDTLS_PK_DEBUG_MAX_ITEMS; i++ )
{
- if( items[i].type == POLARSSL_PK_DEBUG_NONE )
+ if( items[i].type == MBEDTLS_PK_DEBUG_NONE )
return;
- polarssl_snprintf( name, sizeof( name ), "%s%s", text, items[i].name );
+ mbedtls_snprintf( name, sizeof( name ), "%s%s", text, items[i].name );
name[sizeof( name ) - 1] = '\0';
- if( items[i].type == POLARSSL_PK_DEBUG_MPI )
- debug_print_mpi( ssl, level, file, line, name, items[i].value );
+ if( items[i].type == MBEDTLS_PK_DEBUG_MPI )
+ mbedtls_debug_print_mpi( ssl, level, file, line, name, items[i].value );
else
-#if defined(POLARSSL_ECP_C)
- if( items[i].type == POLARSSL_PK_DEBUG_ECP )
- debug_print_ecp( ssl, level, file, line, name, items[i].value );
+#if defined(MBEDTLS_ECP_C)
+ if( items[i].type == MBEDTLS_PK_DEBUG_ECP )
+ mbedtls_debug_print_ecp( ssl, level, file, line, name, items[i].value );
else
#endif
- debug_print_msg( ssl, level, file, line, "should not happen" );
+ mbedtls_debug_print_msg( ssl, level, file, line, "should not happen" );
}
}
-void debug_print_crt( const ssl_context *ssl, int level,
+void mbedtls_debug_print_crt( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
- const char *text, const x509_crt *crt )
+ const char *text, const mbedtls_x509_crt *crt )
{
char str[1024], prefix[64];
int i = 0, maxlen = sizeof( prefix ) - 1, idx = 0;
@@ -325,9 +325,9 @@
if( ssl->f_dbg == NULL || crt == NULL || level > debug_threshold )
return;
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
{
- polarssl_snprintf( prefix, maxlen, "%s(%04d): ", file, line );
+ mbedtls_snprintf( prefix, maxlen, "%s(%04d): ", file, line );
prefix[maxlen] = '\0';
}
else
@@ -338,12 +338,12 @@
while( crt != NULL )
{
char buf[1024];
- x509_crt_info( buf, sizeof( buf ) - 1, prefix, crt );
+ mbedtls_x509_crt_info( buf, sizeof( buf ) - 1, prefix, crt );
- if( debug_log_mode == POLARSSL_DEBUG_LOG_FULL )
- idx = polarssl_snprintf( str, maxlen, "%s(%04d): ", file, line );
+ if( debug_log_mode == MBEDTLS_DEBUG_LOG_FULL )
+ idx = mbedtls_snprintf( str, maxlen, "%s(%04d): ", file, line );
- polarssl_snprintf( str + idx, maxlen - idx, "%s #%d:\n%s",
+ mbedtls_snprintf( str + idx, maxlen - idx, "%s #%d:\n%s",
text, ++i, buf );
str[maxlen] = '\0';
@@ -354,6 +354,6 @@
crt = crt->next;
}
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-#endif /* POLARSSL_DEBUG_C */
+#endif /* MBEDTLS_DEBUG_C */
diff --git a/library/des.c b/library/des.c
index be7348b..f669552 100644
--- a/library/des.c
+++ b/library/des.c
@@ -26,31 +26,31 @@
* http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
#include "mbedtls/des.h"
#include <string.h>
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if !defined(POLARSSL_DES_ALT)
+#if !defined(MBEDTLS_DES_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -307,30 +307,30 @@
#define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
-void des_init( des_context *ctx )
+void mbedtls_des_init( mbedtls_des_context *ctx )
{
- memset( ctx, 0, sizeof( des_context ) );
+ memset( ctx, 0, sizeof( mbedtls_des_context ) );
}
-void des_free( des_context *ctx )
+void mbedtls_des_free( mbedtls_des_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( des_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_des_context ) );
}
-void des3_init( des3_context *ctx )
+void mbedtls_des3_init( mbedtls_des3_context *ctx )
{
- memset( ctx, 0, sizeof( des3_context ) );
+ memset( ctx, 0, sizeof( mbedtls_des3_context ) );
}
-void des3_free( des3_context *ctx )
+void mbedtls_des3_free( mbedtls_des3_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( des3_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_des3_context ) );
}
static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
@@ -344,22 +344,22 @@
227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
254 };
-void des_key_set_parity( unsigned char key[DES_KEY_SIZE] )
+void mbedtls_des_key_set_parity( unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
- for( i = 0; i < DES_KEY_SIZE; i++ )
+ for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
key[i] = odd_parity_table[key[i] / 2];
}
/*
* Check the given key's parity, returns 1 on failure, 0 on SUCCESS
*/
-int des_key_check_key_parity( const unsigned char key[DES_KEY_SIZE] )
+int mbedtls_des_key_check_key_parity( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
- for( i = 0; i < DES_KEY_SIZE; i++ )
+ for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
if( key[i] != odd_parity_table[key[i] / 2] )
return( 1 );
@@ -389,7 +389,7 @@
#define WEAK_KEY_COUNT 16
-static const unsigned char weak_key_table[WEAK_KEY_COUNT][DES_KEY_SIZE] =
+static const unsigned char weak_key_table[WEAK_KEY_COUNT][MBEDTLS_DES_KEY_SIZE] =
{
{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
{ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
@@ -410,18 +410,18 @@
{ 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
};
-int des_key_check_weak( const unsigned char key[DES_KEY_SIZE] )
+int mbedtls_des_key_check_weak( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
for( i = 0; i < WEAK_KEY_COUNT; i++ )
- if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0 )
+ if( memcmp( weak_key_table[i], key, MBEDTLS_DES_KEY_SIZE) == 0 )
return( 1 );
return( 0 );
}
-static void des_setkey( uint32_t SK[32], const unsigned char key[DES_KEY_SIZE] )
+static void des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
@@ -493,7 +493,7 @@
/*
* DES key schedule (56-bit, encryption)
*/
-int des_setkey_enc( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
+int mbedtls_des_setkey_enc( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
des_setkey( ctx->sk, key );
@@ -503,7 +503,7 @@
/*
* DES key schedule (56-bit, decryption)
*/
-int des_setkey_dec( des_context *ctx, const unsigned char key[DES_KEY_SIZE] )
+int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
@@ -520,7 +520,7 @@
static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
- const unsigned char key[DES_KEY_SIZE*2] )
+ const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
@@ -546,13 +546,13 @@
/*
* Triple-DES key schedule (112-bit, encryption)
*/
-int des3_set2key_enc( des3_context *ctx,
- const unsigned char key[DES_KEY_SIZE * 2] )
+int mbedtls_des3_set2key_enc( mbedtls_des3_context *ctx,
+ const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
{
uint32_t sk[96];
des3_set2key( ctx->sk, sk, key );
- polarssl_zeroize( sk, sizeof( sk ) );
+ mbedtls_zeroize( sk, sizeof( sk ) );
return( 0 );
}
@@ -560,13 +560,13 @@
/*
* Triple-DES key schedule (112-bit, decryption)
*/
-int des3_set2key_dec( des3_context *ctx,
- const unsigned char key[DES_KEY_SIZE * 2] )
+int mbedtls_des3_set2key_dec( mbedtls_des3_context *ctx,
+ const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
{
uint32_t sk[96];
des3_set2key( sk, ctx->sk, key );
- polarssl_zeroize( sk, sizeof( sk ) );
+ mbedtls_zeroize( sk, sizeof( sk ) );
return( 0 );
}
@@ -597,13 +597,13 @@
/*
* Triple-DES key schedule (168-bit, encryption)
*/
-int des3_set3key_enc( des3_context *ctx,
- const unsigned char key[DES_KEY_SIZE * 3] )
+int mbedtls_des3_set3key_enc( mbedtls_des3_context *ctx,
+ const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
uint32_t sk[96];
des3_set3key( ctx->sk, sk, key );
- polarssl_zeroize( sk, sizeof( sk ) );
+ mbedtls_zeroize( sk, sizeof( sk ) );
return( 0 );
}
@@ -611,13 +611,13 @@
/*
* Triple-DES key schedule (168-bit, decryption)
*/
-int des3_set3key_dec( des3_context *ctx,
- const unsigned char key[DES_KEY_SIZE * 3] )
+int mbedtls_des3_set3key_dec( mbedtls_des3_context *ctx,
+ const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
uint32_t sk[96];
des3_set3key( sk, ctx->sk, key );
- polarssl_zeroize( sk, sizeof( sk ) );
+ mbedtls_zeroize( sk, sizeof( sk ) );
return( 0 );
}
@@ -625,7 +625,7 @@
/*
* DES-ECB block encryption/decryption
*/
-int des_crypt_ecb( des_context *ctx,
+int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
@@ -653,11 +653,11 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* DES-CBC buffer encryption/decryption
*/
-int des_crypt_cbc( des_context *ctx,
+int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
@@ -668,16 +668,16 @@
unsigned char temp[8];
if( length % 8 )
- return( POLARSSL_ERR_DES_INVALID_INPUT_LENGTH );
+ return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
- if( mode == DES_ENCRYPT )
+ if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- des_crypt_ecb( ctx, output, output );
+ mbedtls_des_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
@@ -685,12 +685,12 @@
length -= 8;
}
}
- else /* DES_DECRYPT */
+ else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
- des_crypt_ecb( ctx, input, output );
+ mbedtls_des_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
@@ -705,12 +705,12 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
/*
* 3DES-ECB block encryption/decryption
*/
-int des3_crypt_ecb( des3_context *ctx,
+int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
@@ -750,11 +750,11 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* 3DES-CBC buffer encryption/decryption
*/
-int des3_crypt_cbc( des3_context *ctx,
+int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
@@ -765,16 +765,16 @@
unsigned char temp[8];
if( length % 8 )
- return( POLARSSL_ERR_DES_INVALID_INPUT_LENGTH );
+ return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
- if( mode == DES_ENCRYPT )
+ if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- des3_crypt_ecb( ctx, output, output );
+ mbedtls_des3_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
@@ -782,12 +782,12 @@
length -= 8;
}
}
- else /* DES_DECRYPT */
+ else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
- des3_crypt_ecb( ctx, input, output );
+ mbedtls_des3_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
@@ -802,11 +802,11 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#endif /* !POLARSSL_DES_ALT */
+#endif /* !MBEDTLS_DES_ALT */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* DES and 3DES test vectors from:
*
@@ -838,7 +838,7 @@
{ 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
};
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const unsigned char des3_test_iv[8] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
@@ -857,24 +857,24 @@
{ 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
{ 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
};
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
/*
* Checkup routine
*/
-int des_self_test( int verbose )
+int mbedtls_des_self_test( int verbose )
{
int i, j, u, v, ret = 0;
- des_context ctx;
- des3_context ctx3;
+ mbedtls_des_context ctx;
+ mbedtls_des3_context ctx3;
unsigned char buf[8];
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[8];
unsigned char iv[8];
#endif
- des_init( &ctx );
- des3_init( &ctx3 );
+ mbedtls_des_init( &ctx );
+ mbedtls_des3_init( &ctx3 );
/*
* ECB mode
*/
@@ -884,36 +884,36 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " DES%c-ECB-%3d (%s): ",
+ mbedtls_printf( " DES%c-ECB-%3d (%s): ",
( u == 0 ) ? ' ' : '3', 56 + u * 56,
- ( v == DES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
memcpy( buf, des3_test_buf, 8 );
switch( i )
{
case 0:
- des_setkey_dec( &ctx, des3_test_keys );
+ mbedtls_des_setkey_dec( &ctx, des3_test_keys );
break;
case 1:
- des_setkey_enc( &ctx, des3_test_keys );
+ mbedtls_des_setkey_enc( &ctx, des3_test_keys );
break;
case 2:
- des3_set2key_dec( &ctx3, des3_test_keys );
+ mbedtls_des3_set2key_dec( &ctx3, des3_test_keys );
break;
case 3:
- des3_set2key_enc( &ctx3, des3_test_keys );
+ mbedtls_des3_set2key_enc( &ctx3, des3_test_keys );
break;
case 4:
- des3_set3key_dec( &ctx3, des3_test_keys );
+ mbedtls_des3_set3key_dec( &ctx3, des3_test_keys );
break;
case 5:
- des3_set3key_enc( &ctx3, des3_test_keys );
+ mbedtls_des3_set3key_enc( &ctx3, des3_test_keys );
break;
default:
@@ -923,31 +923,31 @@
for( j = 0; j < 10000; j++ )
{
if( u == 0 )
- des_crypt_ecb( &ctx, buf, buf );
+ mbedtls_des_crypt_ecb( &ctx, buf, buf );
else
- des3_crypt_ecb( &ctx3, buf, buf );
+ mbedtls_des3_crypt_ecb( &ctx3, buf, buf );
}
- if( ( v == DES_DECRYPT &&
+ if( ( v == MBEDTLS_DES_DECRYPT &&
memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
- ( v != DES_DECRYPT &&
+ ( v != MBEDTLS_DES_DECRYPT &&
memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
@@ -957,9 +957,9 @@
v = i & 1;
if( verbose != 0 )
- polarssl_printf( " DES%c-CBC-%3d (%s): ",
+ mbedtls_printf( " DES%c-CBC-%3d (%s): ",
( u == 0 ) ? ' ' : '3', 56 + u * 56,
- ( v == DES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, des3_test_iv, 8 );
memcpy( prv, des3_test_iv, 8 );
@@ -968,41 +968,41 @@
switch( i )
{
case 0:
- des_setkey_dec( &ctx, des3_test_keys );
+ mbedtls_des_setkey_dec( &ctx, des3_test_keys );
break;
case 1:
- des_setkey_enc( &ctx, des3_test_keys );
+ mbedtls_des_setkey_enc( &ctx, des3_test_keys );
break;
case 2:
- des3_set2key_dec( &ctx3, des3_test_keys );
+ mbedtls_des3_set2key_dec( &ctx3, des3_test_keys );
break;
case 3:
- des3_set2key_enc( &ctx3, des3_test_keys );
+ mbedtls_des3_set2key_enc( &ctx3, des3_test_keys );
break;
case 4:
- des3_set3key_dec( &ctx3, des3_test_keys );
+ mbedtls_des3_set3key_dec( &ctx3, des3_test_keys );
break;
case 5:
- des3_set3key_enc( &ctx3, des3_test_keys );
+ mbedtls_des3_set3key_enc( &ctx3, des3_test_keys );
break;
default:
return( 1 );
}
- if( v == DES_DECRYPT )
+ if( v == MBEDTLS_DES_DECRYPT )
{
for( j = 0; j < 10000; j++ )
{
if( u == 0 )
- des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
+ mbedtls_des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
else
- des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
+ mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
}
}
else
@@ -1012,9 +1012,9 @@
unsigned char tmp[8];
if( u == 0 )
- des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
+ mbedtls_des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
else
- des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
+ mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
memcpy( tmp, prv, 8 );
memcpy( prv, buf, 8 );
@@ -1024,33 +1024,33 @@
memcpy( buf, prv, 8 );
}
- if( ( v == DES_DECRYPT &&
+ if( ( v == MBEDTLS_DES_DECRYPT &&
memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
- ( v != DES_DECRYPT &&
+ ( v != MBEDTLS_DES_DECRYPT &&
memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- des_free( &ctx );
- des3_free( &ctx3 );
+ mbedtls_des_free( &ctx );
+ mbedtls_des3_free( &ctx3 );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_DES_C */
diff --git a/library/dhm.c b/library/dhm.c
index a71e52f..05cbbd9 100644
--- a/library/dhm.c
+++ b/library/dhm.c
@@ -25,61 +25,61 @@
* http://www.cacr.math.uwaterloo.ca/hac/ (chapter 12)
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_DHM_C)
+#if defined(MBEDTLS_DHM_C)
#include "mbedtls/dhm.h"
#include <string.h>
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_ASN1_PARSE_C)
+#if defined(MBEDTLS_ASN1_PARSE_C)
#include "mbedtls/asn1.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
#include <stdio.h>
-#define polarssl_printf printf
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_printf printf
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
- * helper to validate the mpi size and import it
+ * helper to validate the mbedtls_mpi size and import it
*/
-static int dhm_read_bignum( mpi *X,
+static int dhm_read_bignum( mbedtls_mpi *X,
unsigned char **p,
const unsigned char *end )
{
int ret, n;
if( end - *p < 2 )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
n = ( (*p)[0] << 8 ) | (*p)[1];
(*p) += 2;
if( (int)( end - *p ) < n )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
- if( ( ret = mpi_read_binary( X, *p, n ) ) != 0 )
- return( POLARSSL_ERR_DHM_READ_PARAMS_FAILED + ret );
+ if( ( ret = mbedtls_mpi_read_binary( X, *p, n ) ) != 0 )
+ return( MBEDTLS_ERR_DHM_READ_PARAMS_FAILED + ret );
(*p) += n;
@@ -95,36 +95,36 @@
* http://www.cl.cam.ac.uk/~rja14/Papers/psandqs.pdf
* http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2005-2643
*/
-static int dhm_check_range( const mpi *param, const mpi *P )
+static int dhm_check_range( const mbedtls_mpi *param, const mbedtls_mpi *P )
{
- mpi L, U;
- int ret = POLARSSL_ERR_DHM_BAD_INPUT_DATA;
+ mbedtls_mpi L, U;
+ int ret = MBEDTLS_ERR_DHM_BAD_INPUT_DATA;
- mpi_init( &L ); mpi_init( &U );
+ mbedtls_mpi_init( &L ); mbedtls_mpi_init( &U );
- MPI_CHK( mpi_lset( &L, 2 ) );
- MPI_CHK( mpi_sub_int( &U, P, 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &L, 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &U, P, 2 ) );
- if( mpi_cmp_mpi( param, &L ) >= 0 &&
- mpi_cmp_mpi( param, &U ) <= 0 )
+ if( mbedtls_mpi_cmp_mpi( param, &L ) >= 0 &&
+ mbedtls_mpi_cmp_mpi( param, &U ) <= 0 )
{
ret = 0;
}
cleanup:
- mpi_free( &L ); mpi_free( &U );
+ mbedtls_mpi_free( &L ); mbedtls_mpi_free( &U );
return( ret );
}
-void dhm_init( dhm_context *ctx )
+void mbedtls_dhm_init( mbedtls_dhm_context *ctx )
{
- memset( ctx, 0, sizeof( dhm_context ) );
+ memset( ctx, 0, sizeof( mbedtls_dhm_context ) );
}
/*
* Parse the ServerKeyExchange parameters
*/
-int dhm_read_params( dhm_context *ctx,
+int mbedtls_dhm_read_params( mbedtls_dhm_context *ctx,
unsigned char **p,
const unsigned char *end )
{
@@ -138,7 +138,7 @@
if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
return( ret );
- ctx->len = mpi_size( &ctx->P );
+ ctx->len = mbedtls_mpi_size( &ctx->P );
return( 0 );
}
@@ -146,7 +146,7 @@
/*
* Setup and write the ServerKeyExchange parameters
*/
-int dhm_make_params( dhm_context *ctx, int x_size,
+int mbedtls_dhm_make_params( mbedtls_dhm_context *ctx, int x_size,
unsigned char *output, size_t *olen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
@@ -155,28 +155,28 @@
size_t n1, n2, n3;
unsigned char *p;
- if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( &ctx->P, 0 ) == 0 )
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
/*
* Generate X as large as possible ( < P )
*/
do
{
- mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
+ mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
- while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
- MPI_CHK( mpi_shift_r( &ctx->X, 1 ) );
+ while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) );
if( count++ > 10 )
- return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED );
+ return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED );
}
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
/*
* Calculate GX = G^X mod P
*/
- MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
&ctx->P , &ctx->RP ) );
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
@@ -186,13 +186,13 @@
* export P, G, GX
*/
#define DHM_MPI_EXPORT(X,n) \
- MPI_CHK( mpi_write_binary( X, p + 2, n ) ); \
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( X, p + 2, n ) ); \
*p++ = (unsigned char)( n >> 8 ); \
*p++ = (unsigned char)( n ); p += n;
- n1 = mpi_size( &ctx->P );
- n2 = mpi_size( &ctx->G );
- n3 = mpi_size( &ctx->GX );
+ n1 = mbedtls_mpi_size( &ctx->P );
+ n2 = mbedtls_mpi_size( &ctx->G );
+ n3 = mbedtls_mpi_size( &ctx->GX );
p = output;
DHM_MPI_EXPORT( &ctx->P , n1 );
@@ -206,7 +206,7 @@
cleanup:
if( ret != 0 )
- return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED + ret );
+ return( MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED + ret );
return( 0 );
}
@@ -214,16 +214,16 @@
/*
* Import the peer's public value G^Y
*/
-int dhm_read_public( dhm_context *ctx,
+int mbedtls_dhm_read_public( mbedtls_dhm_context *ctx,
const unsigned char *input, size_t ilen )
{
int ret;
if( ctx == NULL || ilen < 1 || ilen > ctx->len )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
- if( ( ret = mpi_read_binary( &ctx->GY, input, ilen ) ) != 0 )
- return( POLARSSL_ERR_DHM_READ_PUBLIC_FAILED + ret );
+ if( ( ret = mbedtls_mpi_read_binary( &ctx->GY, input, ilen ) ) != 0 )
+ return( MBEDTLS_ERR_DHM_READ_PUBLIC_FAILED + ret );
return( 0 );
}
@@ -231,7 +231,7 @@
/*
* Create own private value X and export G^X
*/
-int dhm_make_public( dhm_context *ctx, int x_size,
+int mbedtls_dhm_make_public( mbedtls_dhm_context *ctx, int x_size,
unsigned char *output, size_t olen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
@@ -239,38 +239,38 @@
int ret, count = 0;
if( ctx == NULL || olen < 1 || olen > ctx->len )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
- if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( &ctx->P, 0 ) == 0 )
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
/*
* generate X and calculate GX = G^X mod P
*/
do
{
- mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
+ mbedtls_mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
- while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
- MPI_CHK( mpi_shift_r( &ctx->X, 1 ) );
+ while( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->X, 1 ) );
if( count++ > 10 )
- return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED );
+ return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED );
}
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
- MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
&ctx->P , &ctx->RP ) );
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
return( ret );
- MPI_CHK( mpi_write_binary( &ctx->GX, output, olen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->GX, output, olen ) );
cleanup:
if( ret != 0 )
- return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED + ret );
+ return( MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED + ret );
return( 0 );
}
@@ -281,7 +281,7 @@
* DSS, and other systems. In : Advances in Cryptology-CRYPTO'96. Springer
* Berlin Heidelberg, 1996. p. 104-113.
*/
-static int dhm_update_blinding( dhm_context *ctx,
+static int dhm_update_blinding( mbedtls_dhm_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret, count;
@@ -290,11 +290,11 @@
* Don't use any blinding the first time a particular X is used,
* but remember it to use blinding next time.
*/
- if( mpi_cmp_mpi( &ctx->X, &ctx->pX ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->pX ) != 0 )
{
- MPI_CHK( mpi_copy( &ctx->pX, &ctx->X ) );
- MPI_CHK( mpi_lset( &ctx->Vi, 1 ) );
- MPI_CHK( mpi_lset( &ctx->Vf, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &ctx->pX, &ctx->X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->Vi, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->Vf, 1 ) );
return( 0 );
}
@@ -303,13 +303,13 @@
* Ok, we need blinding. Can we re-use existing values?
* If yes, just update them by squaring them.
*/
- if( mpi_cmp_int( &ctx->Vi, 1 ) != 0 )
+ if( mbedtls_mpi_cmp_int( &ctx->Vi, 1 ) != 0 )
{
- MPI_CHK( mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) );
- MPI_CHK( mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->P ) );
- MPI_CHK( mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) );
- MPI_CHK( mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->P ) );
return( 0 );
}
@@ -322,19 +322,19 @@
count = 0;
do
{
- mpi_fill_random( &ctx->Vi, mpi_size( &ctx->P ), f_rng, p_rng );
+ mbedtls_mpi_fill_random( &ctx->Vi, mbedtls_mpi_size( &ctx->P ), f_rng, p_rng );
- while( mpi_cmp_mpi( &ctx->Vi, &ctx->P ) >= 0 )
- MPI_CHK( mpi_shift_r( &ctx->Vi, 1 ) );
+ while( mbedtls_mpi_cmp_mpi( &ctx->Vi, &ctx->P ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &ctx->Vi, 1 ) );
if( count++ > 10 )
- return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+ return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
}
- while( mpi_cmp_int( &ctx->Vi, 1 ) <= 0 );
+ while( mbedtls_mpi_cmp_int( &ctx->Vi, 1 ) <= 0 );
/* Vf = Vi^-X mod P */
- MPI_CHK( mpi_inv_mod( &ctx->Vf, &ctx->Vi, &ctx->P ) );
- MPI_CHK( mpi_exp_mod( &ctx->Vf, &ctx->Vf, &ctx->X, &ctx->P, &ctx->RP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->Vf, &ctx->Vi, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->Vf, &ctx->Vf, &ctx->X, &ctx->P, &ctx->RP ) );
cleanup:
return( ret );
@@ -343,52 +343,52 @@
/*
* Derive and export the shared secret (G^Y)^X mod P
*/
-int dhm_calc_secret( dhm_context *ctx,
+int mbedtls_dhm_calc_secret( mbedtls_dhm_context *ctx,
unsigned char *output, size_t *olen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- mpi GYb;
+ mbedtls_mpi GYb;
if( ctx == NULL || *olen < ctx->len )
- return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_DHM_BAD_INPUT_DATA );
if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
return( ret );
- mpi_init( &GYb );
+ mbedtls_mpi_init( &GYb );
/* Blind peer's value */
if( f_rng != NULL )
{
- MPI_CHK( dhm_update_blinding( ctx, f_rng, p_rng ) );
- MPI_CHK( mpi_mul_mpi( &GYb, &ctx->GY, &ctx->Vi ) );
- MPI_CHK( mpi_mod_mpi( &GYb, &GYb, &ctx->P ) );
+ MBEDTLS_MPI_CHK( dhm_update_blinding( ctx, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &GYb, &ctx->GY, &ctx->Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &GYb, &GYb, &ctx->P ) );
}
else
- MPI_CHK( mpi_copy( &GYb, &ctx->GY ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &GYb, &ctx->GY ) );
/* Do modular exponentiation */
- MPI_CHK( mpi_exp_mod( &ctx->K, &GYb, &ctx->X,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->K, &GYb, &ctx->X,
&ctx->P, &ctx->RP ) );
/* Unblind secret value */
if( f_rng != NULL )
{
- MPI_CHK( mpi_mul_mpi( &ctx->K, &ctx->K, &ctx->Vf ) );
- MPI_CHK( mpi_mod_mpi( &ctx->K, &ctx->K, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->K, &ctx->K, &ctx->Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->K, &ctx->K, &ctx->P ) );
}
- *olen = mpi_size( &ctx->K );
+ *olen = mbedtls_mpi_size( &ctx->K );
- MPI_CHK( mpi_write_binary( &ctx->K, output, *olen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &ctx->K, output, *olen ) );
cleanup:
- mpi_free( &GYb );
+ mbedtls_mpi_free( &GYb );
if( ret != 0 )
- return( POLARSSL_ERR_DHM_CALC_SECRET_FAILED + ret );
+ return( MBEDTLS_ERR_DHM_CALC_SECRET_FAILED + ret );
return( 0 );
}
@@ -396,32 +396,32 @@
/*
* Free the components of a DHM key
*/
-void dhm_free( dhm_context *ctx )
+void mbedtls_dhm_free( mbedtls_dhm_context *ctx )
{
- mpi_free( &ctx->pX); mpi_free( &ctx->Vf ); mpi_free( &ctx->Vi );
- mpi_free( &ctx->RP ); mpi_free( &ctx->K ); mpi_free( &ctx->GY );
- mpi_free( &ctx->GX ); mpi_free( &ctx->X ); mpi_free( &ctx->G );
- mpi_free( &ctx->P );
+ mbedtls_mpi_free( &ctx->pX); mbedtls_mpi_free( &ctx->Vf ); mbedtls_mpi_free( &ctx->Vi );
+ mbedtls_mpi_free( &ctx->RP ); mbedtls_mpi_free( &ctx->K ); mbedtls_mpi_free( &ctx->GY );
+ mbedtls_mpi_free( &ctx->GX ); mbedtls_mpi_free( &ctx->X ); mbedtls_mpi_free( &ctx->G );
+ mbedtls_mpi_free( &ctx->P );
- polarssl_zeroize( ctx, sizeof( dhm_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_dhm_context ) );
}
-#if defined(POLARSSL_ASN1_PARSE_C)
+#if defined(MBEDTLS_ASN1_PARSE_C)
/*
* Parse DHM parameters
*/
-int dhm_parse_dhm( dhm_context *dhm, const unsigned char *dhmin,
+int mbedtls_dhm_parse_dhm( mbedtls_dhm_context *dhm, const unsigned char *dhmin,
size_t dhminlen )
{
int ret;
size_t len;
unsigned char *p, *end;
-#if defined(POLARSSL_PEM_PARSE_C)
- pem_context pem;
+#if defined(MBEDTLS_PEM_PARSE_C)
+ mbedtls_pem_context pem;
- pem_init( &pem );
+ mbedtls_pem_init( &pem );
- ret = pem_read_buffer( &pem,
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN DH PARAMETERS-----",
"-----END DH PARAMETERS-----",
dhmin, NULL, 0, &dhminlen );
@@ -433,13 +433,13 @@
*/
dhminlen = pem.buflen;
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
goto exit;
p = ( ret == 0 ) ? pem.buf : (unsigned char *) dhmin;
#else
p = (unsigned char *) dhmin;
-#endif /* POLARSSL_PEM_PARSE_C */
+#endif /* MBEDTLS_PEM_PARSE_C */
end = p + dhminlen;
/*
@@ -448,44 +448,44 @@
* generator INTEGER, -- g
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- ret = POLARSSL_ERR_DHM_INVALID_FORMAT + ret;
+ ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + ret;
goto exit;
}
end = p + len;
- if( ( ret = asn1_get_mpi( &p, end, &dhm->P ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &dhm->G ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_mpi( &p, end, &dhm->P ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &dhm->G ) ) != 0 )
{
- ret = POLARSSL_ERR_DHM_INVALID_FORMAT + ret;
+ ret = MBEDTLS_ERR_DHM_INVALID_FORMAT + ret;
goto exit;
}
if( p != end )
{
- ret = POLARSSL_ERR_DHM_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH;
+ ret = MBEDTLS_ERR_DHM_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
goto exit;
}
ret = 0;
- dhm->len = mpi_size( &dhm->P );
+ dhm->len = mbedtls_mpi_size( &dhm->P );
exit:
-#if defined(POLARSSL_PEM_PARSE_C)
- pem_free( &pem );
+#if defined(MBEDTLS_PEM_PARSE_C)
+ mbedtls_pem_free( &pem );
#endif
if( ret != 0 )
- dhm_free( dhm );
+ mbedtls_dhm_free( dhm );
return( ret );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* Load all data from a file into a given buffer.
*/
@@ -495,30 +495,30 @@
long size;
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_DHM_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_DHM_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
if( ( size = ftell( f ) ) == -1 )
{
fclose( f );
- return( POLARSSL_ERR_DHM_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_DHM_FILE_IO_ERROR );
}
fseek( f, 0, SEEK_SET );
*n = (size_t) size;
if( *n + 1 == 0 ||
- ( *buf = polarssl_malloc( *n + 1 ) ) == NULL )
+ ( *buf = mbedtls_malloc( *n + 1 ) ) == NULL )
{
fclose( f );
- return( POLARSSL_ERR_DHM_MALLOC_FAILED );
+ return( MBEDTLS_ERR_DHM_MALLOC_FAILED );
}
if( fread( *buf, 1, *n, f ) != *n )
{
fclose( f );
- polarssl_free( *buf );
- return( POLARSSL_ERR_DHM_FILE_IO_ERROR );
+ mbedtls_free( *buf );
+ return( MBEDTLS_ERR_DHM_FILE_IO_ERROR );
}
fclose( f );
@@ -531,7 +531,7 @@
/*
* Load and parse DHM parameters
*/
-int dhm_parse_dhmfile( dhm_context *dhm, const char *path )
+int mbedtls_dhm_parse_dhmfile( mbedtls_dhm_context *dhm, const char *path )
{
int ret;
size_t n;
@@ -540,59 +540,59 @@
if( ( ret = load_file( path, &buf, &n ) ) != 0 )
return( ret );
- ret = dhm_parse_dhm( dhm, buf, n );
+ ret = mbedtls_dhm_parse_dhm( dhm, buf, n );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
-#endif /* POLARSSL_FS_IO */
-#endif /* POLARSSL_ASN1_PARSE_C */
+#endif /* MBEDTLS_FS_IO */
+#endif /* MBEDTLS_ASN1_PARSE_C */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#include "mbedtls/certs.h"
/*
* Checkup routine
*/
-int dhm_self_test( int verbose )
+int mbedtls_dhm_self_test( int verbose )
{
-#if defined(POLARSSL_CERTS_C)
+#if defined(MBEDTLS_CERTS_C)
int ret;
- dhm_context dhm;
+ mbedtls_dhm_context dhm;
- dhm_init( &dhm );
+ mbedtls_dhm_init( &dhm );
if( verbose != 0 )
- polarssl_printf( " DHM parameter load: " );
+ mbedtls_printf( " DHM parameter load: " );
- if( ( ret = dhm_parse_dhm( &dhm, (const unsigned char *) test_dhm_params,
- strlen( test_dhm_params ) ) ) != 0 )
+ if( ( ret = mbedtls_dhm_parse_dhm( &dhm, (const unsigned char *) mbedtls_test_dhm_params,
+ strlen( mbedtls_test_dhm_params ) ) ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n\n" );
+ mbedtls_printf( "passed\n\n" );
exit:
- dhm_free( &dhm );
+ mbedtls_dhm_free( &dhm );
return( ret );
#else
if( verbose != 0 )
- polarssl_printf( " DHM parameter load: skipped\n" );
+ mbedtls_printf( " DHM parameter load: skipped\n" );
return( 0 );
-#endif /* POLARSSL_CERTS_C */
+#endif /* MBEDTLS_CERTS_C */
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_DHM_C */
+#endif /* MBEDTLS_DHM_C */
diff --git a/library/ecdh.c b/library/ecdh.c
index d620108..8d88977 100644
--- a/library/ecdh.c
+++ b/library/ecdh.c
@@ -27,58 +27,58 @@
* RFC 4492
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ECDH_C)
+#if defined(MBEDTLS_ECDH_C)
#include "mbedtls/ecdh.h"
#include <string.h>
/*
- * Generate public key: simple wrapper around ecp_gen_keypair
+ * Generate public key: simple wrapper around mbedtls_ecp_gen_keypair
*/
-int ecdh_gen_public( ecp_group *grp, mpi *d, ecp_point *Q,
+int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp_point *Q,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
- return ecp_gen_keypair( grp, d, Q, f_rng, p_rng );
+ return mbedtls_ecp_gen_keypair( grp, d, Q, f_rng, p_rng );
}
/*
* Compute shared secret (SEC1 3.3.1)
*/
-int ecdh_compute_shared( ecp_group *grp, mpi *z,
- const ecp_point *Q, const mpi *d,
+int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z,
+ const mbedtls_ecp_point *Q, const mbedtls_mpi *d,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- ecp_point P;
+ mbedtls_ecp_point P;
- ecp_point_init( &P );
+ mbedtls_ecp_point_init( &P );
/*
* Make sure Q is a valid pubkey before using it
*/
- MPI_CHK( ecp_check_pubkey( grp, Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_check_pubkey( grp, Q ) );
- MPI_CHK( ecp_mul( grp, &P, d, Q, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( grp, &P, d, Q, f_rng, p_rng ) );
- if( ecp_is_zero( &P ) )
+ if( mbedtls_ecp_is_zero( &P ) )
{
- ret = POLARSSL_ERR_ECP_BAD_INPUT_DATA;
+ ret = MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
goto cleanup;
}
- MPI_CHK( mpi_copy( z, &P.X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( z, &P.X ) );
cleanup:
- ecp_point_free( &P );
+ mbedtls_ecp_point_free( &P );
return( ret );
}
@@ -86,27 +86,27 @@
/*
* Initialize context
*/
-void ecdh_init( ecdh_context *ctx )
+void mbedtls_ecdh_init( mbedtls_ecdh_context *ctx )
{
- memset( ctx, 0, sizeof( ecdh_context ) );
+ memset( ctx, 0, sizeof( mbedtls_ecdh_context ) );
}
/*
* Free context
*/
-void ecdh_free( ecdh_context *ctx )
+void mbedtls_ecdh_free( mbedtls_ecdh_context *ctx )
{
if( ctx == NULL )
return;
- ecp_group_free( &ctx->grp );
- ecp_point_free( &ctx->Q );
- ecp_point_free( &ctx->Qp );
- ecp_point_free( &ctx->Vi );
- ecp_point_free( &ctx->Vf );
- mpi_free( &ctx->d );
- mpi_free( &ctx->z );
- mpi_free( &ctx->_d );
+ mbedtls_ecp_group_free( &ctx->grp );
+ mbedtls_ecp_point_free( &ctx->Q );
+ mbedtls_ecp_point_free( &ctx->Qp );
+ mbedtls_ecp_point_free( &ctx->Vi );
+ mbedtls_ecp_point_free( &ctx->Vf );
+ mbedtls_mpi_free( &ctx->d );
+ mbedtls_mpi_free( &ctx->z );
+ mbedtls_mpi_free( &ctx->_d );
}
/*
@@ -116,7 +116,7 @@
* ECPoint public;
* } ServerECDHParams;
*/
-int ecdh_make_params( ecdh_context *ctx, size_t *olen,
+int mbedtls_ecdh_make_params( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
@@ -125,20 +125,20 @@
size_t grp_len, pt_len;
if( ctx == NULL || ctx->grp.pbits == 0 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) )
+ if( ( ret = mbedtls_ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) )
!= 0 )
return( ret );
- if( ( ret = ecp_tls_write_group( &ctx->grp, &grp_len, buf, blen ) )
+ if( ( ret = mbedtls_ecp_tls_write_group( &ctx->grp, &grp_len, buf, blen ) )
!= 0 )
return( ret );
buf += grp_len;
blen -= grp_len;
- if( ( ret = ecp_tls_write_point( &ctx->grp, &ctx->Q, ctx->point_format,
+ if( ( ret = mbedtls_ecp_tls_write_point( &ctx->grp, &ctx->Q, ctx->point_format,
&pt_len, buf, blen ) ) != 0 )
return( ret );
@@ -153,15 +153,15 @@
* ECPoint public;
* } ServerECDHParams;
*/
-int ecdh_read_params( ecdh_context *ctx,
+int mbedtls_ecdh_read_params( mbedtls_ecdh_context *ctx,
const unsigned char **buf, const unsigned char *end )
{
int ret;
- if( ( ret = ecp_tls_read_group( &ctx->grp, buf, end - *buf ) ) != 0 )
+ if( ( ret = mbedtls_ecp_tls_read_group( &ctx->grp, buf, end - *buf ) ) != 0 )
return( ret );
- if( ( ret = ecp_tls_read_point( &ctx->grp, &ctx->Qp, buf, end - *buf ) )
+ if( ( ret = mbedtls_ecp_tls_read_point( &ctx->grp, &ctx->Qp, buf, end - *buf ) )
!= 0 )
return( ret );
@@ -171,24 +171,24 @@
/*
* Get parameters from a keypair
*/
-int ecdh_get_params( ecdh_context *ctx, const ecp_keypair *key,
- ecdh_side side )
+int mbedtls_ecdh_get_params( mbedtls_ecdh_context *ctx, const mbedtls_ecp_keypair *key,
+ mbedtls_ecdh_side side )
{
int ret;
- if( ( ret = ecp_group_copy( &ctx->grp, &key->grp ) ) != 0 )
+ if( ( ret = mbedtls_ecp_group_copy( &ctx->grp, &key->grp ) ) != 0 )
return( ret );
/* If it's not our key, just import the public part as Qp */
- if( side == POLARSSL_ECDH_THEIRS )
- return( ecp_copy( &ctx->Qp, &key->Q ) );
+ if( side == MBEDTLS_ECDH_THEIRS )
+ return( mbedtls_ecp_copy( &ctx->Qp, &key->Q ) );
/* Our key: import public (as Q) and private parts */
- if( side != POLARSSL_ECDH_OURS )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( side != MBEDTLS_ECDH_OURS )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecp_copy( &ctx->Q, &key->Q ) ) != 0 ||
- ( ret = mpi_copy( &ctx->d, &key->d ) ) != 0 )
+ if( ( ret = mbedtls_ecp_copy( &ctx->Q, &key->Q ) ) != 0 ||
+ ( ret = mbedtls_mpi_copy( &ctx->d, &key->d ) ) != 0 )
return( ret );
return( 0 );
@@ -197,7 +197,7 @@
/*
* Setup and export the client public value
*/
-int ecdh_make_public( ecdh_context *ctx, size_t *olen,
+int mbedtls_ecdh_make_public( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
@@ -205,33 +205,33 @@
int ret;
if( ctx == NULL || ctx->grp.pbits == 0 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) )
+ if( ( ret = mbedtls_ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) )
!= 0 )
return( ret );
- return ecp_tls_write_point( &ctx->grp, &ctx->Q, ctx->point_format,
+ return mbedtls_ecp_tls_write_point( &ctx->grp, &ctx->Q, ctx->point_format,
olen, buf, blen );
}
/*
* Parse and import the client's public value
*/
-int ecdh_read_public( ecdh_context *ctx,
+int mbedtls_ecdh_read_public( mbedtls_ecdh_context *ctx,
const unsigned char *buf, size_t blen )
{
int ret;
const unsigned char *p = buf;
if( ctx == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecp_tls_read_point( &ctx->grp, &ctx->Qp, &p, blen ) ) != 0 )
+ if( ( ret = mbedtls_ecp_tls_read_point( &ctx->grp, &ctx->Qp, &p, blen ) ) != 0 )
return( ret );
if( (size_t)( p - buf ) != blen )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
return( 0 );
}
@@ -239,7 +239,7 @@
/*
* Derive and export the shared secret
*/
-int ecdh_calc_secret( ecdh_context *ctx, size_t *olen,
+int mbedtls_ecdh_calc_secret( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
@@ -247,19 +247,19 @@
int ret;
if( ctx == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecdh_compute_shared( &ctx->grp, &ctx->z, &ctx->Qp, &ctx->d,
+ if( ( ret = mbedtls_ecdh_compute_shared( &ctx->grp, &ctx->z, &ctx->Qp, &ctx->d,
f_rng, p_rng ) ) != 0 )
{
return( ret );
}
- if( mpi_size( &ctx->z ) > blen )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( mbedtls_mpi_size( &ctx->z ) > blen )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
*olen = ctx->grp.pbits / 8 + ( ( ctx->grp.pbits % 8 ) != 0 );
- return mpi_write_binary( &ctx->z, buf, *olen );
+ return mbedtls_mpi_write_binary( &ctx->z, buf, *olen );
}
-#endif /* POLARSSL_ECDH_C */
+#endif /* MBEDTLS_ECDH_C */
diff --git a/library/ecdsa.c b/library/ecdsa.c
index b4cdfca..0e864fc 100644
--- a/library/ecdsa.c
+++ b/library/ecdsa.c
@@ -26,20 +26,20 @@
* SEC1 http://www.secg.org/index.php?action=secg,docs_secg
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#include "mbedtls/ecdsa.h"
#include "mbedtls/asn1write.h"
#include <string.h>
-#if defined(POLARSSL_ECDSA_DETERMINISTIC)
+#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
#include "mbedtls/hmac_drbg.h"
#endif
@@ -47,20 +47,20 @@
* Derive a suitable integer for group grp from a buffer of length len
* SEC1 4.1.3 step 5 aka SEC1 4.1.4 step 3
*/
-static int derive_mpi( const ecp_group *grp, mpi *x,
+static int derive_mpi( const mbedtls_ecp_group *grp, mbedtls_mpi *x,
const unsigned char *buf, size_t blen )
{
int ret;
size_t n_size = ( grp->nbits + 7 ) / 8;
size_t use_size = blen > n_size ? n_size : blen;
- MPI_CHK( mpi_read_binary( x, buf, use_size ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( x, buf, use_size ) );
if( use_size * 8 > grp->nbits )
- MPI_CHK( mpi_shift_r( x, use_size * 8 - grp->nbits ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( x, use_size * 8 - grp->nbits ) );
/* While at it, reduce modulo N */
- if( mpi_cmp_mpi( x, &grp->N ) >= 0 )
- MPI_CHK( mpi_sub_mpi( x, x, &grp->N ) );
+ if( mbedtls_mpi_cmp_mpi( x, &grp->N ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( x, x, &grp->N ) );
cleanup:
return( ret );
@@ -70,20 +70,20 @@
* Compute ECDSA signature of a hashed message (SEC1 4.1.3)
* Obviously, compared to SEC1 4.1.3, we skip step 4 (hash message)
*/
-int ecdsa_sign( ecp_group *grp, mpi *r, mpi *s,
- const mpi *d, const unsigned char *buf, size_t blen,
+int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
+ const mbedtls_mpi *d, const unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret, key_tries, sign_tries, blind_tries;
- ecp_point R;
- mpi k, e, t;
+ mbedtls_ecp_point R;
+ mbedtls_mpi k, e, t;
/* Fail cleanly on curves such as Curve25519 that can't be used for ECDSA */
if( grp->N.p == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- ecp_point_init( &R );
- mpi_init( &k ); mpi_init( &e ); mpi_init( &t );
+ mbedtls_ecp_point_init( &R );
+ mbedtls_mpi_init( &k ); mbedtls_mpi_init( &e ); mbedtls_mpi_init( &t );
sign_tries = 0;
do
@@ -95,21 +95,21 @@
key_tries = 0;
do
{
- MPI_CHK( ecp_gen_keypair( grp, &k, &R, f_rng, p_rng ) );
- MPI_CHK( mpi_mod_mpi( r, &R.X, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_gen_keypair( grp, &k, &R, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( r, &R.X, &grp->N ) );
if( key_tries++ > 10 )
{
- ret = POLARSSL_ERR_ECP_RANDOM_FAILED;
+ ret = MBEDTLS_ERR_ECP_RANDOM_FAILED;
goto cleanup;
}
}
- while( mpi_cmp_int( r, 0 ) == 0 );
+ while( mbedtls_mpi_cmp_int( r, 0 ) == 0 );
/*
* Step 5: derive MPI from hashed message
*/
- MPI_CHK( derive_mpi( grp, &e, buf, blen ) );
+ MBEDTLS_MPI_CHK( derive_mpi( grp, &e, buf, blen ) );
/*
* Generate a random value to blind inv_mod in next step,
@@ -119,143 +119,143 @@
do
{
size_t n_size = ( grp->nbits + 7 ) / 8;
- MPI_CHK( mpi_fill_random( &t, n_size, f_rng, p_rng ) );
- MPI_CHK( mpi_shift_r( &t, 8 * n_size - grp->nbits ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &t, n_size, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &t, 8 * n_size - grp->nbits ) );
- /* See ecp_gen_keypair() */
+ /* See mbedtls_ecp_gen_keypair() */
if( ++blind_tries > 30 )
- return( POLARSSL_ERR_ECP_RANDOM_FAILED );
+ return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
}
- while( mpi_cmp_int( &t, 1 ) < 0 ||
- mpi_cmp_mpi( &t, &grp->N ) >= 0 );
+ while( mbedtls_mpi_cmp_int( &t, 1 ) < 0 ||
+ mbedtls_mpi_cmp_mpi( &t, &grp->N ) >= 0 );
/*
* Step 6: compute s = (e + r * d) / k = t (e + rd) / (kt) mod n
*/
- MPI_CHK( mpi_mul_mpi( s, r, d ) );
- MPI_CHK( mpi_add_mpi( &e, &e, s ) );
- MPI_CHK( mpi_mul_mpi( &e, &e, &t ) );
- MPI_CHK( mpi_mul_mpi( &k, &k, &t ) );
- MPI_CHK( mpi_inv_mod( s, &k, &grp->N ) );
- MPI_CHK( mpi_mul_mpi( s, s, &e ) );
- MPI_CHK( mpi_mod_mpi( s, s, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( s, r, d ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &e, &e, s ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &e, &e, &t ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &k, &k, &t ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( s, &k, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( s, s, &e ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( s, s, &grp->N ) );
if( sign_tries++ > 10 )
{
- ret = POLARSSL_ERR_ECP_RANDOM_FAILED;
+ ret = MBEDTLS_ERR_ECP_RANDOM_FAILED;
goto cleanup;
}
}
- while( mpi_cmp_int( s, 0 ) == 0 );
+ while( mbedtls_mpi_cmp_int( s, 0 ) == 0 );
cleanup:
- ecp_point_free( &R );
- mpi_free( &k ); mpi_free( &e ); mpi_free( &t );
+ mbedtls_ecp_point_free( &R );
+ mbedtls_mpi_free( &k ); mbedtls_mpi_free( &e ); mbedtls_mpi_free( &t );
return( ret );
}
-#if defined(POLARSSL_ECDSA_DETERMINISTIC)
+#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
/*
* Deterministic signature wrapper
*/
-int ecdsa_sign_det( ecp_group *grp, mpi *r, mpi *s,
- const mpi *d, const unsigned char *buf, size_t blen,
- md_type_t md_alg )
+int mbedtls_ecdsa_sign_det( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
+ const mbedtls_mpi *d, const unsigned char *buf, size_t blen,
+ mbedtls_md_type_t md_alg )
{
int ret;
- hmac_drbg_context rng_ctx;
- unsigned char data[2 * POLARSSL_ECP_MAX_BYTES];
+ mbedtls_hmac_drbg_context rng_ctx;
+ unsigned char data[2 * MBEDTLS_ECP_MAX_BYTES];
size_t grp_len = ( grp->nbits + 7 ) / 8;
- const md_info_t *md_info;
- mpi h;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_mpi h;
- if( ( md_info = md_info_from_type( md_alg ) ) == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- mpi_init( &h );
- memset( &rng_ctx, 0, sizeof( hmac_drbg_context ) );
+ mbedtls_mpi_init( &h );
+ memset( &rng_ctx, 0, sizeof( mbedtls_hmac_drbg_context ) );
/* Use private key and message hash (reduced) to initialize HMAC_DRBG */
- MPI_CHK( mpi_write_binary( d, data, grp_len ) );
- MPI_CHK( derive_mpi( grp, &h, buf, blen ) );
- MPI_CHK( mpi_write_binary( &h, data + grp_len, grp_len ) );
- hmac_drbg_init_buf( &rng_ctx, md_info, data, 2 * grp_len );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( d, data, grp_len ) );
+ MBEDTLS_MPI_CHK( derive_mpi( grp, &h, buf, blen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &h, data + grp_len, grp_len ) );
+ mbedtls_hmac_drbg_init_buf( &rng_ctx, md_info, data, 2 * grp_len );
- ret = ecdsa_sign( grp, r, s, d, buf, blen,
- hmac_drbg_random, &rng_ctx );
+ ret = mbedtls_ecdsa_sign( grp, r, s, d, buf, blen,
+ mbedtls_hmac_drbg_random, &rng_ctx );
cleanup:
- hmac_drbg_free( &rng_ctx );
- mpi_free( &h );
+ mbedtls_hmac_drbg_free( &rng_ctx );
+ mbedtls_mpi_free( &h );
return( ret );
}
-#endif /* POLARSSL_ECDSA_DETERMINISTIC */
+#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
/*
* Verify ECDSA signature of hashed message (SEC1 4.1.4)
* Obviously, compared to SEC1 4.1.3, we skip step 2 (hash message)
*/
-int ecdsa_verify( ecp_group *grp,
+int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp,
const unsigned char *buf, size_t blen,
- const ecp_point *Q, const mpi *r, const mpi *s)
+ const mbedtls_ecp_point *Q, const mbedtls_mpi *r, const mbedtls_mpi *s)
{
int ret;
- mpi e, s_inv, u1, u2;
- ecp_point R, P;
+ mbedtls_mpi e, s_inv, u1, u2;
+ mbedtls_ecp_point R, P;
- ecp_point_init( &R ); ecp_point_init( &P );
- mpi_init( &e ); mpi_init( &s_inv ); mpi_init( &u1 ); mpi_init( &u2 );
+ mbedtls_ecp_point_init( &R ); mbedtls_ecp_point_init( &P );
+ mbedtls_mpi_init( &e ); mbedtls_mpi_init( &s_inv ); mbedtls_mpi_init( &u1 ); mbedtls_mpi_init( &u2 );
/* Fail cleanly on curves such as Curve25519 that can't be used for ECDSA */
if( grp->N.p == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Step 1: make sure r and s are in range 1..n-1
*/
- if( mpi_cmp_int( r, 1 ) < 0 || mpi_cmp_mpi( r, &grp->N ) >= 0 ||
- mpi_cmp_int( s, 1 ) < 0 || mpi_cmp_mpi( s, &grp->N ) >= 0 )
+ if( mbedtls_mpi_cmp_int( r, 1 ) < 0 || mbedtls_mpi_cmp_mpi( r, &grp->N ) >= 0 ||
+ mbedtls_mpi_cmp_int( s, 1 ) < 0 || mbedtls_mpi_cmp_mpi( s, &grp->N ) >= 0 )
{
- ret = POLARSSL_ERR_ECP_VERIFY_FAILED;
+ ret = MBEDTLS_ERR_ECP_VERIFY_FAILED;
goto cleanup;
}
/*
* Additional precaution: make sure Q is valid
*/
- MPI_CHK( ecp_check_pubkey( grp, Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_check_pubkey( grp, Q ) );
/*
* Step 3: derive MPI from hashed message
*/
- MPI_CHK( derive_mpi( grp, &e, buf, blen ) );
+ MBEDTLS_MPI_CHK( derive_mpi( grp, &e, buf, blen ) );
/*
* Step 4: u1 = e / s mod n, u2 = r / s mod n
*/
- MPI_CHK( mpi_inv_mod( &s_inv, s, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &s_inv, s, &grp->N ) );
- MPI_CHK( mpi_mul_mpi( &u1, &e, &s_inv ) );
- MPI_CHK( mpi_mod_mpi( &u1, &u1, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &u1, &e, &s_inv ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &u1, &u1, &grp->N ) );
- MPI_CHK( mpi_mul_mpi( &u2, r, &s_inv ) );
- MPI_CHK( mpi_mod_mpi( &u2, &u2, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &u2, r, &s_inv ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &u2, &u2, &grp->N ) );
/*
* Step 5: R = u1 G + u2 Q
*
* Since we're not using any secret data, no need to pass a RNG to
- * ecp_mul() for countermesures.
+ * mbedtls_ecp_mul() for countermesures.
*/
- MPI_CHK( ecp_mul( grp, &R, &u1, &grp->G, NULL, NULL ) );
- MPI_CHK( ecp_mul( grp, &P, &u2, Q, NULL, NULL ) );
- MPI_CHK( ecp_add( grp, &R, &R, &P ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( grp, &R, &u1, &grp->G, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( grp, &P, &u2, Q, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_add( grp, &R, &R, &P ) );
- if( ecp_is_zero( &R ) )
+ if( mbedtls_ecp_is_zero( &R ) )
{
- ret = POLARSSL_ERR_ECP_VERIFY_FAILED;
+ ret = MBEDTLS_ERR_ECP_VERIFY_FAILED;
goto cleanup;
}
@@ -263,20 +263,20 @@
* Step 6: convert xR to an integer (no-op)
* Step 7: reduce xR mod n (gives v)
*/
- MPI_CHK( mpi_mod_mpi( &R.X, &R.X, &grp->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &R.X, &R.X, &grp->N ) );
/*
* Step 8: check if v (that is, R.X) is equal to r
*/
- if( mpi_cmp_mpi( &R.X, r ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &R.X, r ) != 0 )
{
- ret = POLARSSL_ERR_ECP_VERIFY_FAILED;
+ ret = MBEDTLS_ERR_ECP_VERIFY_FAILED;
goto cleanup;
}
cleanup:
- ecp_point_free( &R ); ecp_point_free( &P );
- mpi_free( &e ); mpi_free( &s_inv ); mpi_free( &u1 ); mpi_free( &u2 );
+ mbedtls_ecp_point_free( &R ); mbedtls_ecp_point_free( &P );
+ mbedtls_mpi_free( &e ); mbedtls_mpi_free( &s_inv ); mbedtls_mpi_free( &u1 ); mbedtls_mpi_free( &u2 );
return( ret );
}
@@ -284,20 +284,20 @@
/*
* Convert a signature (given by context) to ASN.1
*/
-static int ecdsa_signature_to_asn1( const mpi *r, const mpi *s,
+static int ecdsa_signature_to_asn1( const mbedtls_mpi *r, const mbedtls_mpi *s,
unsigned char *sig, size_t *slen )
{
int ret;
- unsigned char buf[POLARSSL_ECDSA_MAX_LEN];
+ unsigned char buf[MBEDTLS_ECDSA_MAX_LEN];
unsigned char *p = buf + sizeof( buf );
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_mpi( &p, buf, s ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &p, buf, r ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &p, buf, s ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &p, buf, r ) );
- ASN1_CHK_ADD( len, asn1_write_len( &p, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &p, buf,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &p, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &p, buf,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) );
memcpy( sig, p, len );
*slen = len;
@@ -308,48 +308,48 @@
/*
* Compute and write signature
*/
-int ecdsa_write_signature( ecdsa_context *ctx, md_type_t md_alg,
+int mbedtls_ecdsa_write_signature( mbedtls_ecdsa_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hlen,
unsigned char *sig, size_t *slen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- mpi r, s;
+ mbedtls_mpi r, s;
- mpi_init( &r );
- mpi_init( &s );
+ mbedtls_mpi_init( &r );
+ mbedtls_mpi_init( &s );
-#if defined(POLARSSL_ECDSA_DETERMINISTIC)
+#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
(void) f_rng;
(void) p_rng;
- MPI_CHK( ecdsa_sign_det( &ctx->grp, &r, &s, &ctx->d,
+ MBEDTLS_MPI_CHK( mbedtls_ecdsa_sign_det( &ctx->grp, &r, &s, &ctx->d,
hash, hlen, md_alg ) );
#else
(void) md_alg;
- MPI_CHK( ecdsa_sign( &ctx->grp, &r, &s, &ctx->d,
+ MBEDTLS_MPI_CHK( mbedtls_ecdsa_sign( &ctx->grp, &r, &s, &ctx->d,
hash, hlen, f_rng, p_rng ) );
#endif
- MPI_CHK( ecdsa_signature_to_asn1( &r, &s, sig, slen ) );
+ MBEDTLS_MPI_CHK( ecdsa_signature_to_asn1( &r, &s, sig, slen ) );
cleanup:
- mpi_free( &r );
- mpi_free( &s );
+ mbedtls_mpi_free( &r );
+ mbedtls_mpi_free( &s );
return( ret );
}
-#if ! defined(POLARSSL_DEPRECATED_REMOVED) && \
- defined(POLARSSL_ECDSA_DETERMINISTIC)
-int ecdsa_write_signature_det( ecdsa_context *ctx,
+#if ! defined(MBEDTLS_DEPRECATED_REMOVED) && \
+ defined(MBEDTLS_ECDSA_DETERMINISTIC)
+int mbedtls_ecdsa_write_signature_det( mbedtls_ecdsa_context *ctx,
const unsigned char *hash, size_t hlen,
unsigned char *sig, size_t *slen,
- md_type_t md_alg )
+ mbedtls_md_type_t md_alg )
{
- return( ecdsa_write_signature( ctx, md_alg, hash, hlen, sig, slen,
+ return( mbedtls_ecdsa_write_signature( ctx, md_alg, hash, hlen, sig, slen,
NULL, NULL ) );
}
#endif
@@ -357,7 +357,7 @@
/*
* Read and check signature
*/
-int ecdsa_read_signature( ecdsa_context *ctx,
+int mbedtls_ecdsa_read_signature( mbedtls_ecdsa_context *ctx,
const unsigned char *hash, size_t hlen,
const unsigned char *sig, size_t slen )
{
@@ -365,42 +365,42 @@
unsigned char *p = (unsigned char *) sig;
const unsigned char *end = sig + slen;
size_t len;
- mpi r, s;
+ mbedtls_mpi r, s;
- mpi_init( &r );
- mpi_init( &s );
+ mbedtls_mpi_init( &r );
+ mbedtls_mpi_init( &s );
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- ret += POLARSSL_ERR_ECP_BAD_INPUT_DATA;
+ ret += MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
goto cleanup;
}
if( p + len != end )
{
- ret = POLARSSL_ERR_ECP_BAD_INPUT_DATA +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH;
+ ret = MBEDTLS_ERR_ECP_BAD_INPUT_DATA +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
goto cleanup;
}
- if( ( ret = asn1_get_mpi( &p, end, &r ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &s ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_mpi( &p, end, &r ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &s ) ) != 0 )
{
- ret += POLARSSL_ERR_ECP_BAD_INPUT_DATA;
+ ret += MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
goto cleanup;
}
- if( ( ret = ecdsa_verify( &ctx->grp, hash, hlen,
+ if( ( ret = mbedtls_ecdsa_verify( &ctx->grp, hash, hlen,
&ctx->Q, &r, &s ) ) != 0 )
goto cleanup;
if( p != end )
- ret = POLARSSL_ERR_ECP_SIG_LEN_MISMATCH;
+ ret = MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH;
cleanup:
- mpi_free( &r );
- mpi_free( &s );
+ mbedtls_mpi_free( &r );
+ mbedtls_mpi_free( &s );
return( ret );
}
@@ -408,25 +408,25 @@
/*
* Generate key pair
*/
-int ecdsa_genkey( ecdsa_context *ctx, ecp_group_id gid,
+int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- return( ecp_use_known_dp( &ctx->grp, gid ) ||
- ecp_gen_keypair( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) );
+ return( mbedtls_ecp_use_known_dp( &ctx->grp, gid ) ||
+ mbedtls_ecp_gen_keypair( &ctx->grp, &ctx->d, &ctx->Q, f_rng, p_rng ) );
}
/*
- * Set context from an ecp_keypair
+ * Set context from an mbedtls_ecp_keypair
*/
-int ecdsa_from_keypair( ecdsa_context *ctx, const ecp_keypair *key )
+int mbedtls_ecdsa_from_keypair( mbedtls_ecdsa_context *ctx, const mbedtls_ecp_keypair *key )
{
int ret;
- if( ( ret = ecp_group_copy( &ctx->grp, &key->grp ) ) != 0 ||
- ( ret = mpi_copy( &ctx->d, &key->d ) ) != 0 ||
- ( ret = ecp_copy( &ctx->Q, &key->Q ) ) != 0 )
+ if( ( ret = mbedtls_ecp_group_copy( &ctx->grp, &key->grp ) ) != 0 ||
+ ( ret = mbedtls_mpi_copy( &ctx->d, &key->d ) ) != 0 ||
+ ( ret = mbedtls_ecp_copy( &ctx->Q, &key->Q ) ) != 0 )
{
- ecdsa_free( ctx );
+ mbedtls_ecdsa_free( ctx );
}
return( ret );
@@ -435,17 +435,17 @@
/*
* Initialize context
*/
-void ecdsa_init( ecdsa_context *ctx )
+void mbedtls_ecdsa_init( mbedtls_ecdsa_context *ctx )
{
- ecp_keypair_init( ctx );
+ mbedtls_ecp_keypair_init( ctx );
}
/*
* Free context
*/
-void ecdsa_free( ecdsa_context *ctx )
+void mbedtls_ecdsa_free( mbedtls_ecdsa_context *ctx )
{
- ecp_keypair_free( ctx );
+ mbedtls_ecp_keypair_free( ctx );
}
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
diff --git a/library/ecp.c b/library/ecp.c
index f04b6fe..6019500 100644
--- a/library/ecp.c
+++ b/library/ecp.c
@@ -41,26 +41,26 @@
* <http://eprint.iacr.org/2004/342.pdf>
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
#include <stdio.h>
-#define polarssl_printf printf
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_printf printf
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
#if defined(_MSC_VER) && !defined strcasecmp && !defined(EFIX64) && \
@@ -77,11 +77,11 @@
#endif /*_MSC_VER */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* Counts of point addition and doubling, and field multiplications.
* Used to test resistance of point multiplication to simple timing attacks.
@@ -89,25 +89,25 @@
static unsigned long add_count, dbl_count, mul_count;
#endif
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP224R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP256R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP384R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP521R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_BP256R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_BP384R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_BP512R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP192K1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP224K1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
-#define POLARSSL_ECP_SHORT_WEIERSTRASS
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_BP256R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_BP384R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_BP512R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+#define MBEDTLS_ECP_SHORT_WEIERSTRASS
#endif
-#if defined(POLARSSL_ECP_DP_M221_ENABLED) || \
- defined(POLARSSL_ECP_DP_M255_ENABLED) || \
- defined(POLARSSL_ECP_DP_M383_ENABLED) || \
- defined(POLARSSL_ECP_DP_M511_ENABLED)
-#define POLARSSL_ECP_MONTGOMERY
+#if defined(MBEDTLS_ECP_DP_M221_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_M255_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_M383_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_M511_ENABLED)
+#define MBEDTLS_ECP_MONTGOMERY
#endif
/*
@@ -115,9 +115,9 @@
*/
typedef enum
{
- POLARSSL_ECP_TYPE_NONE = 0,
- POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS, /* y^2 = x^3 + a x + b */
- POLARSSL_ECP_TYPE_MONTGOMERY, /* y^2 = x^3 + a x^2 + x */
+ MBEDTLS_ECP_TYPE_NONE = 0,
+ MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS, /* y^2 = x^3 + a x + b */
+ MBEDTLS_ECP_TYPE_MONTGOMERY, /* y^2 = x^3 + a x^2 + x */
} ecp_curve_type;
/*
@@ -130,53 +130,53 @@
* Curves are listed in order: largest curves first, and for a given size,
* fastest curves first. This provides the default order for the SSL module.
*/
-static const ecp_curve_info ecp_supported_curves[] =
+static const mbedtls_ecp_curve_info ecp_supported_curves[] =
{
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
- { POLARSSL_ECP_DP_SECP521R1, 25, 521, "secp521r1" },
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP521R1, 25, 521, "secp521r1" },
#endif
-#if defined(POLARSSL_ECP_DP_BP512R1_ENABLED)
- { POLARSSL_ECP_DP_BP512R1, 28, 512, "brainpoolP512r1" },
+#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
+ { MBEDTLS_ECP_DP_BP512R1, 28, 512, "brainpoolP512r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
- { POLARSSL_ECP_DP_SECP384R1, 24, 384, "secp384r1" },
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP384R1, 24, 384, "secp384r1" },
#endif
-#if defined(POLARSSL_ECP_DP_BP384R1_ENABLED)
- { POLARSSL_ECP_DP_BP384R1, 27, 384, "brainpoolP384r1" },
+#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
+ { MBEDTLS_ECP_DP_BP384R1, 27, 384, "brainpoolP384r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
- { POLARSSL_ECP_DP_SECP256R1, 23, 256, "secp256r1" },
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP256R1, 23, 256, "secp256r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
- { POLARSSL_ECP_DP_SECP256K1, 22, 256, "secp256k1" },
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP256K1, 22, 256, "secp256k1" },
#endif
-#if defined(POLARSSL_ECP_DP_BP256R1_ENABLED)
- { POLARSSL_ECP_DP_BP256R1, 26, 256, "brainpoolP256r1" },
+#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
+ { MBEDTLS_ECP_DP_BP256R1, 26, 256, "brainpoolP256r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
- { POLARSSL_ECP_DP_SECP224R1, 21, 224, "secp224r1" },
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP224R1, 21, 224, "secp224r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
- { POLARSSL_ECP_DP_SECP224K1, 20, 224, "secp224k1" },
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP224K1, 20, 224, "secp224k1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
- { POLARSSL_ECP_DP_SECP192R1, 19, 192, "secp192r1" },
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP192R1, 19, 192, "secp192r1" },
#endif
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
- { POLARSSL_ECP_DP_SECP192K1, 18, 192, "secp192k1" },
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
+ { MBEDTLS_ECP_DP_SECP192K1, 18, 192, "secp192k1" },
#endif
- { POLARSSL_ECP_DP_NONE, 0, 0, NULL },
+ { MBEDTLS_ECP_DP_NONE, 0, 0, NULL },
};
#define ECP_NB_CURVES sizeof( ecp_supported_curves ) / \
sizeof( ecp_supported_curves[0] )
-static ecp_group_id ecp_supported_grp_id[ECP_NB_CURVES];
+static mbedtls_ecp_group_id ecp_supported_grp_id[ECP_NB_CURVES];
/*
* List of supported curves and associated info
*/
-const ecp_curve_info *ecp_curve_list( void )
+const mbedtls_ecp_curve_info *mbedtls_ecp_curve_list( void )
{
return( ecp_supported_curves );
}
@@ -184,22 +184,22 @@
/*
* List of supported curves, group ID only
*/
-const ecp_group_id *ecp_grp_id_list( void )
+const mbedtls_ecp_group_id *mbedtls_ecp_grp_id_list( void )
{
static int init_done = 0;
if( ! init_done )
{
size_t i = 0;
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- for( curve_info = ecp_curve_list();
- curve_info->grp_id != POLARSSL_ECP_DP_NONE;
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
ecp_supported_grp_id[i++] = curve_info->grp_id;
}
- ecp_supported_grp_id[i] = POLARSSL_ECP_DP_NONE;
+ ecp_supported_grp_id[i] = MBEDTLS_ECP_DP_NONE;
init_done = 1;
}
@@ -210,12 +210,12 @@
/*
* Get the curve info for the internal identifier
*/
-const ecp_curve_info *ecp_curve_info_from_grp_id( ecp_group_id grp_id )
+const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id( mbedtls_ecp_group_id grp_id )
{
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- for( curve_info = ecp_curve_list();
- curve_info->grp_id != POLARSSL_ECP_DP_NONE;
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if( curve_info->grp_id == grp_id )
@@ -228,12 +228,12 @@
/*
* Get the curve info from the TLS identifier
*/
-const ecp_curve_info *ecp_curve_info_from_tls_id( uint16_t tls_id )
+const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_tls_id( uint16_t tls_id )
{
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- for( curve_info = ecp_curve_list();
- curve_info->grp_id != POLARSSL_ECP_DP_NONE;
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if( curve_info->tls_id == tls_id )
@@ -246,12 +246,12 @@
/*
* Get the curve info from the name
*/
-const ecp_curve_info *ecp_curve_info_from_name( const char *name )
+const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_name( const char *name )
{
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- for( curve_info = ecp_curve_list();
- curve_info->grp_id != POLARSSL_ECP_DP_NONE;
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if( strcasecmp( curve_info->name, name ) == 0 )
@@ -264,71 +264,71 @@
/*
* Get the type of a curve
*/
-static inline ecp_curve_type ecp_get_type( const ecp_group *grp )
+static inline ecp_curve_type ecp_get_type( const mbedtls_ecp_group *grp )
{
if( grp->G.X.p == NULL )
- return( POLARSSL_ECP_TYPE_NONE );
+ return( MBEDTLS_ECP_TYPE_NONE );
if( grp->G.Y.p == NULL )
- return( POLARSSL_ECP_TYPE_MONTGOMERY );
+ return( MBEDTLS_ECP_TYPE_MONTGOMERY );
else
- return( POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS );
+ return( MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS );
}
/*
* Initialize (the components of) a point
*/
-void ecp_point_init( ecp_point *pt )
+void mbedtls_ecp_point_init( mbedtls_ecp_point *pt )
{
if( pt == NULL )
return;
- mpi_init( &pt->X );
- mpi_init( &pt->Y );
- mpi_init( &pt->Z );
+ mbedtls_mpi_init( &pt->X );
+ mbedtls_mpi_init( &pt->Y );
+ mbedtls_mpi_init( &pt->Z );
}
/*
* Initialize (the components of) a group
*/
-void ecp_group_init( ecp_group *grp )
+void mbedtls_ecp_group_init( mbedtls_ecp_group *grp )
{
if( grp == NULL )
return;
- memset( grp, 0, sizeof( ecp_group ) );
+ memset( grp, 0, sizeof( mbedtls_ecp_group ) );
}
/*
* Initialize (the components of) a key pair
*/
-void ecp_keypair_init( ecp_keypair *key )
+void mbedtls_ecp_keypair_init( mbedtls_ecp_keypair *key )
{
if( key == NULL )
return;
- ecp_group_init( &key->grp );
- mpi_init( &key->d );
- ecp_point_init( &key->Q );
+ mbedtls_ecp_group_init( &key->grp );
+ mbedtls_mpi_init( &key->d );
+ mbedtls_ecp_point_init( &key->Q );
}
/*
* Unallocate (the components of) a point
*/
-void ecp_point_free( ecp_point *pt )
+void mbedtls_ecp_point_free( mbedtls_ecp_point *pt )
{
if( pt == NULL )
return;
- mpi_free( &( pt->X ) );
- mpi_free( &( pt->Y ) );
- mpi_free( &( pt->Z ) );
+ mbedtls_mpi_free( &( pt->X ) );
+ mbedtls_mpi_free( &( pt->Y ) );
+ mbedtls_mpi_free( &( pt->Z ) );
}
/*
* Unallocate (the components of) a group
*/
-void ecp_group_free( ecp_group *grp )
+void mbedtls_ecp_group_free( mbedtls_ecp_group *grp )
{
size_t i;
@@ -337,46 +337,46 @@
if( grp->h != 1 )
{
- mpi_free( &grp->P );
- mpi_free( &grp->A );
- mpi_free( &grp->B );
- ecp_point_free( &grp->G );
- mpi_free( &grp->N );
+ mbedtls_mpi_free( &grp->P );
+ mbedtls_mpi_free( &grp->A );
+ mbedtls_mpi_free( &grp->B );
+ mbedtls_ecp_point_free( &grp->G );
+ mbedtls_mpi_free( &grp->N );
}
if( grp->T != NULL )
{
for( i = 0; i < grp->T_size; i++ )
- ecp_point_free( &grp->T[i] );
- polarssl_free( grp->T );
+ mbedtls_ecp_point_free( &grp->T[i] );
+ mbedtls_free( grp->T );
}
- polarssl_zeroize( grp, sizeof( ecp_group ) );
+ mbedtls_zeroize( grp, sizeof( mbedtls_ecp_group ) );
}
/*
* Unallocate (the components of) a key pair
*/
-void ecp_keypair_free( ecp_keypair *key )
+void mbedtls_ecp_keypair_free( mbedtls_ecp_keypair *key )
{
if( key == NULL )
return;
- ecp_group_free( &key->grp );
- mpi_free( &key->d );
- ecp_point_free( &key->Q );
+ mbedtls_ecp_group_free( &key->grp );
+ mbedtls_mpi_free( &key->d );
+ mbedtls_ecp_point_free( &key->Q );
}
/*
* Copy the contents of a point
*/
-int ecp_copy( ecp_point *P, const ecp_point *Q )
+int mbedtls_ecp_copy( mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
- MPI_CHK( mpi_copy( &P->X, &Q->X ) );
- MPI_CHK( mpi_copy( &P->Y, &Q->Y ) );
- MPI_CHK( mpi_copy( &P->Z, &Q->Z ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->X, &Q->X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Y, &Q->Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Z, &Q->Z ) );
cleanup:
return( ret );
@@ -385,21 +385,21 @@
/*
* Copy the contents of a group object
*/
-int ecp_group_copy( ecp_group *dst, const ecp_group *src )
+int mbedtls_ecp_group_copy( mbedtls_ecp_group *dst, const mbedtls_ecp_group *src )
{
- return ecp_use_known_dp( dst, src->id );
+ return mbedtls_ecp_use_known_dp( dst, src->id );
}
/*
* Set point to zero
*/
-int ecp_set_zero( ecp_point *pt )
+int mbedtls_ecp_set_zero( mbedtls_ecp_point *pt )
{
int ret;
- MPI_CHK( mpi_lset( &pt->X , 1 ) );
- MPI_CHK( mpi_lset( &pt->Y , 1 ) );
- MPI_CHK( mpi_lset( &pt->Z , 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->X , 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Y , 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Z , 0 ) );
cleanup:
return( ret );
@@ -408,22 +408,22 @@
/*
* Tell if a point is zero
*/
-int ecp_is_zero( ecp_point *pt )
+int mbedtls_ecp_is_zero( mbedtls_ecp_point *pt )
{
- return( mpi_cmp_int( &pt->Z, 0 ) == 0 );
+ return( mbedtls_mpi_cmp_int( &pt->Z, 0 ) == 0 );
}
/*
* Import a non-zero point from ASCII strings
*/
-int ecp_point_read_string( ecp_point *P, int radix,
+int mbedtls_ecp_point_read_string( mbedtls_ecp_point *P, int radix,
const char *x, const char *y )
{
int ret;
- MPI_CHK( mpi_read_string( &P->X, radix, x ) );
- MPI_CHK( mpi_read_string( &P->Y, radix, y ) );
- MPI_CHK( mpi_lset( &P->Z, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &P->X, radix, x ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &P->Y, radix, y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &P->Z, 1 ) );
cleanup:
return( ret );
@@ -432,24 +432,24 @@
/*
* Export a point into unsigned binary data (SEC1 2.3.3)
*/
-int ecp_point_write_binary( const ecp_group *grp, const ecp_point *P,
+int mbedtls_ecp_point_write_binary( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *P,
int format, size_t *olen,
unsigned char *buf, size_t buflen )
{
int ret = 0;
size_t plen;
- if( format != POLARSSL_ECP_PF_UNCOMPRESSED &&
- format != POLARSSL_ECP_PF_COMPRESSED )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( format != MBEDTLS_ECP_PF_UNCOMPRESSED &&
+ format != MBEDTLS_ECP_PF_COMPRESSED )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Common case: P == 0
*/
- if( mpi_cmp_int( &P->Z, 0 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &P->Z, 0 ) == 0 )
{
if( buflen < 1 )
- return( POLARSSL_ERR_ECP_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x00;
*olen = 1;
@@ -457,28 +457,28 @@
return( 0 );
}
- plen = mpi_size( &grp->P );
+ plen = mbedtls_mpi_size( &grp->P );
- if( format == POLARSSL_ECP_PF_UNCOMPRESSED )
+ if( format == MBEDTLS_ECP_PF_UNCOMPRESSED )
{
*olen = 2 * plen + 1;
if( buflen < *olen )
- return( POLARSSL_ERR_ECP_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x04;
- MPI_CHK( mpi_write_binary( &P->X, buf + 1, plen ) );
- MPI_CHK( mpi_write_binary( &P->Y, buf + 1 + plen, plen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->Y, buf + 1 + plen, plen ) );
}
- else if( format == POLARSSL_ECP_PF_COMPRESSED )
+ else if( format == MBEDTLS_ECP_PF_COMPRESSED )
{
*olen = plen + 1;
if( buflen < *olen )
- return( POLARSSL_ERR_ECP_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
- buf[0] = 0x02 + mpi_get_bit( &P->Y, 0 );
- MPI_CHK( mpi_write_binary( &P->X, buf + 1, plen ) );
+ buf[0] = 0x02 + mbedtls_mpi_get_bit( &P->Y, 0 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
}
cleanup:
@@ -488,34 +488,34 @@
/*
* Import a point from unsigned binary data (SEC1 2.3.4)
*/
-int ecp_point_read_binary( const ecp_group *grp, ecp_point *pt,
+int mbedtls_ecp_point_read_binary( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt,
const unsigned char *buf, size_t ilen )
{
int ret;
size_t plen;
if( ilen < 1 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
if( buf[0] == 0x00 )
{
if( ilen == 1 )
- return( ecp_set_zero( pt ) );
+ return( mbedtls_ecp_set_zero( pt ) );
else
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
- plen = mpi_size( &grp->P );
+ plen = mbedtls_mpi_size( &grp->P );
if( buf[0] != 0x04 )
- return( POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
if( ilen != 2 * plen + 1 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- MPI_CHK( mpi_read_binary( &pt->X, buf + 1, plen ) );
- MPI_CHK( mpi_read_binary( &pt->Y, buf + 1 + plen, plen ) );
- MPI_CHK( mpi_lset( &pt->Z, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &pt->X, buf + 1, plen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &pt->Y, buf + 1 + plen, plen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Z, 1 ) );
cleanup:
return( ret );
@@ -527,7 +527,7 @@
* opaque point <1..2^8-1>;
* } ECPoint;
*/
-int ecp_tls_read_point( const ecp_group *grp, ecp_point *pt,
+int mbedtls_ecp_tls_read_point( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt,
const unsigned char **buf, size_t buf_len )
{
unsigned char data_len;
@@ -537,11 +537,11 @@
* We must have at least two bytes (1 for length, at least one for data)
*/
if( buf_len < 2 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
data_len = *(*buf)++;
if( data_len < 1 || data_len > buf_len - 1 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Save buffer start for read_binary and update buf
@@ -549,7 +549,7 @@
buf_start = *buf;
*buf += data_len;
- return ecp_point_read_binary( grp, pt, buf_start, data_len );
+ return mbedtls_ecp_point_read_binary( grp, pt, buf_start, data_len );
}
/*
@@ -558,7 +558,7 @@
* opaque point <1..2^8-1>;
* } ECPoint;
*/
-int ecp_tls_write_point( const ecp_group *grp, const ecp_point *pt,
+int mbedtls_ecp_tls_write_point( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt,
int format, size_t *olen,
unsigned char *buf, size_t blen )
{
@@ -568,9 +568,9 @@
* buffer length must be at least one, for our length byte
*/
if( blen < 1 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecp_point_write_binary( grp, pt, format,
+ if( ( ret = mbedtls_ecp_point_write_binary( grp, pt, format,
olen, buf + 1, blen - 1) ) != 0 )
return( ret );
@@ -586,23 +586,23 @@
/*
* Import an ECP group from ASCII strings, case A == -3
*/
-int ecp_group_read_string( ecp_group *grp, int radix,
+int mbedtls_ecp_group_read_string( mbedtls_ecp_group *grp, int radix,
const char *p, const char *b,
const char *gx, const char *gy, const char *n)
{
int ret;
- MPI_CHK( mpi_read_string( &grp->P, radix, p ) );
- MPI_CHK( mpi_read_string( &grp->B, radix, b ) );
- MPI_CHK( ecp_point_read_string( &grp->G, radix, gx, gy ) );
- MPI_CHK( mpi_read_string( &grp->N, radix, n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &grp->P, radix, p ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &grp->B, radix, b ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_point_read_string( &grp->G, radix, gx, gy ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &grp->N, radix, n ) );
- grp->pbits = mpi_msb( &grp->P );
- grp->nbits = mpi_msb( &grp->N );
+ grp->pbits = mbedtls_mpi_msb( &grp->P );
+ grp->nbits = mbedtls_mpi_msb( &grp->N );
cleanup:
if( ret != 0 )
- ecp_group_free( grp );
+ mbedtls_ecp_group_free( grp );
return( ret );
}
@@ -610,22 +610,22 @@
/*
* Set a group from an ECParameters record (RFC 4492)
*/
-int ecp_tls_read_group( ecp_group *grp, const unsigned char **buf, size_t len )
+int mbedtls_ecp_tls_read_group( mbedtls_ecp_group *grp, const unsigned char **buf, size_t len )
{
uint16_t tls_id;
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
/*
* We expect at least three bytes (see below)
*/
if( len < 3 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* First byte is curve_type; only named_curve is handled
*/
- if( *(*buf)++ != POLARSSL_ECP_TLS_NAMED_CURVE )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( *(*buf)++ != MBEDTLS_ECP_TLS_NAMED_CURVE )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Next two bytes are the namedcurve value
@@ -634,34 +634,34 @@
tls_id <<= 8;
tls_id |= *(*buf)++;
- if( ( curve_info = ecp_curve_info_from_tls_id( tls_id ) ) == NULL )
- return( POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE );
+ if( ( curve_info = mbedtls_ecp_curve_info_from_tls_id( tls_id ) ) == NULL )
+ return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
- return ecp_use_known_dp( grp, curve_info->grp_id );
+ return mbedtls_ecp_use_known_dp( grp, curve_info->grp_id );
}
/*
* Write the ECParameters record corresponding to a group (RFC 4492)
*/
-int ecp_tls_write_group( const ecp_group *grp, size_t *olen,
+int mbedtls_ecp_tls_write_group( const mbedtls_ecp_group *grp, size_t *olen,
unsigned char *buf, size_t blen )
{
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- if( ( curve_info = ecp_curve_info_from_grp_id( grp->id ) ) == NULL )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( ( curve_info = mbedtls_ecp_curve_info_from_grp_id( grp->id ) ) == NULL )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* We are going to write 3 bytes (see below)
*/
*olen = 3;
if( blen < *olen )
- return( POLARSSL_ERR_ECP_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
/*
* First byte is curve_type, always named_curve
*/
- *buf++ = POLARSSL_ECP_TLS_NAMED_CURVE;
+ *buf++ = MBEDTLS_ECP_TLS_NAMED_CURVE;
/*
* Next two bytes are the namedcurve value
@@ -673,34 +673,34 @@
}
/*
- * Wrapper around fast quasi-modp functions, with fall-back to mpi_mod_mpi.
- * See the documentation of struct ecp_group.
+ * Wrapper around fast quasi-modp functions, with fall-back to mbedtls_mpi_mod_mpi.
+ * See the documentation of struct mbedtls_ecp_group.
*
- * This function is in the critial loop for ecp_mul, so pay attention to perf.
+ * This function is in the critial loop for mbedtls_ecp_mul, so pay attention to perf.
*/
-static int ecp_modp( mpi *N, const ecp_group *grp )
+static int ecp_modp( mbedtls_mpi *N, const mbedtls_ecp_group *grp )
{
int ret;
if( grp->modp == NULL )
- return( mpi_mod_mpi( N, N, &grp->P ) );
+ return( mbedtls_mpi_mod_mpi( N, N, &grp->P ) );
/* N->s < 0 is a much faster test, which fails only if N is 0 */
- if( ( N->s < 0 && mpi_cmp_int( N, 0 ) != 0 ) ||
- mpi_msb( N ) > 2 * grp->pbits )
+ if( ( N->s < 0 && mbedtls_mpi_cmp_int( N, 0 ) != 0 ) ||
+ mbedtls_mpi_msb( N ) > 2 * grp->pbits )
{
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
- MPI_CHK( grp->modp( N ) );
+ MBEDTLS_MPI_CHK( grp->modp( N ) );
/* N->s < 0 is a much faster test, which fails only if N is 0 */
- while( N->s < 0 && mpi_cmp_int( N, 0 ) != 0 )
- MPI_CHK( mpi_add_mpi( N, N, &grp->P ) );
+ while( N->s < 0 && mbedtls_mpi_cmp_int( N, 0 ) != 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( N, N, &grp->P ) );
- while( mpi_cmp_mpi( N, &grp->P ) >= 0 )
+ while( mbedtls_mpi_cmp_mpi( N, &grp->P ) >= 0 )
/* we known P, N and the result are positive */
- MPI_CHK( mpi_sub_abs( N, N, &grp->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( N, N, &grp->P ) );
cleanup:
return( ret );
@@ -710,42 +710,42 @@
* Fast mod-p functions expect their argument to be in the 0..p^2 range.
*
* In order to guarantee that, we need to ensure that operands of
- * mpi_mul_mpi are in the 0..p range. So, after each operation we will
+ * mbedtls_mpi_mul_mpi are in the 0..p range. So, after each operation we will
* bring the result back to this range.
*
* The following macros are shortcuts for doing that.
*/
/*
- * Reduce a mpi mod p in-place, general case, to use after mpi_mul_mpi
+ * Reduce a mbedtls_mpi mod p in-place, general case, to use after mbedtls_mpi_mul_mpi
*/
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#define INC_MUL_COUNT mul_count++;
#else
#define INC_MUL_COUNT
#endif
-#define MOD_MUL( N ) do { MPI_CHK( ecp_modp( &N, grp ) ); INC_MUL_COUNT } \
+#define MOD_MUL( N ) do { MBEDTLS_MPI_CHK( ecp_modp( &N, grp ) ); INC_MUL_COUNT } \
while( 0 )
/*
- * Reduce a mpi mod p in-place, to use after mpi_sub_mpi
+ * Reduce a mbedtls_mpi mod p in-place, to use after mbedtls_mpi_sub_mpi
* N->s < 0 is a very fast test, which fails only if N is 0
*/
#define MOD_SUB( N ) \
- while( N.s < 0 && mpi_cmp_int( &N, 0 ) != 0 ) \
- MPI_CHK( mpi_add_mpi( &N, &N, &grp->P ) )
+ while( N.s < 0 && mbedtls_mpi_cmp_int( &N, 0 ) != 0 ) \
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &N, &N, &grp->P ) )
/*
- * Reduce a mpi mod p in-place, to use after mpi_add_mpi and mpi_mul_int.
+ * Reduce a mbedtls_mpi mod p in-place, to use after mbedtls_mpi_add_mpi and mbedtls_mpi_mul_int.
* We known P, N and the result are positive, so sub_abs is correct, and
* a bit faster.
*/
#define MOD_ADD( N ) \
- while( mpi_cmp_mpi( &N, &grp->P ) >= 0 ) \
- MPI_CHK( mpi_sub_abs( &N, &N, &grp->P ) )
+ while( mbedtls_mpi_cmp_mpi( &N, &grp->P ) >= 0 ) \
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &N, &N, &grp->P ) )
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
/*
* For curves in short Weierstrass form, we do all the internal operations in
* Jacobian coordinates.
@@ -758,37 +758,37 @@
* Normalize jacobian coordinates so that Z == 0 || Z == 1 (GECC 3.2.1)
* Cost: 1N := 1I + 3M + 1S
*/
-static int ecp_normalize_jac( const ecp_group *grp, ecp_point *pt )
+static int ecp_normalize_jac( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt )
{
int ret;
- mpi Zi, ZZi;
+ mbedtls_mpi Zi, ZZi;
- if( mpi_cmp_int( &pt->Z, 0 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &pt->Z, 0 ) == 0 )
return( 0 );
- mpi_init( &Zi ); mpi_init( &ZZi );
+ mbedtls_mpi_init( &Zi ); mbedtls_mpi_init( &ZZi );
/*
* X = X / Z^2 mod p
*/
- MPI_CHK( mpi_inv_mod( &Zi, &pt->Z, &grp->P ) );
- MPI_CHK( mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );
- MPI_CHK( mpi_mul_mpi( &pt->X, &pt->X, &ZZi ) ); MOD_MUL( pt->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &Zi, &pt->Z, &grp->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->X, &pt->X, &ZZi ) ); MOD_MUL( pt->X );
/*
* Y = Y / Z^3 mod p
*/
- MPI_CHK( mpi_mul_mpi( &pt->Y, &pt->Y, &ZZi ) ); MOD_MUL( pt->Y );
- MPI_CHK( mpi_mul_mpi( &pt->Y, &pt->Y, &Zi ) ); MOD_MUL( pt->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &ZZi ) ); MOD_MUL( pt->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &Zi ) ); MOD_MUL( pt->Y );
/*
* Z = 1
*/
- MPI_CHK( mpi_lset( &pt->Z, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Z, 1 ) );
cleanup:
- mpi_free( &Zi ); mpi_free( &ZZi );
+ mbedtls_mpi_free( &Zi ); mbedtls_mpi_free( &ZZi );
return( ret );
}
@@ -804,37 +804,37 @@
*
* Cost: 1N(t) := 1I + (6t - 3)M + 1S
*/
-static int ecp_normalize_jac_many( const ecp_group *grp,
- ecp_point *T[], size_t t_len )
+static int ecp_normalize_jac_many( const mbedtls_ecp_group *grp,
+ mbedtls_ecp_point *T[], size_t t_len )
{
int ret;
size_t i;
- mpi *c, u, Zi, ZZi;
+ mbedtls_mpi *c, u, Zi, ZZi;
if( t_len < 2 )
return( ecp_normalize_jac( grp, *T ) );
- if( ( c = polarssl_malloc( t_len * sizeof( mpi ) ) ) == NULL )
- return( POLARSSL_ERR_ECP_MALLOC_FAILED );
+ if( ( c = mbedtls_malloc( t_len * sizeof( mbedtls_mpi ) ) ) == NULL )
+ return( MBEDTLS_ERR_ECP_MALLOC_FAILED );
- mpi_init( &u ); mpi_init( &Zi ); mpi_init( &ZZi );
+ mbedtls_mpi_init( &u ); mbedtls_mpi_init( &Zi ); mbedtls_mpi_init( &ZZi );
for( i = 0; i < t_len; i++ )
- mpi_init( &c[i] );
+ mbedtls_mpi_init( &c[i] );
/*
* c[i] = Z_0 * ... * Z_i
*/
- MPI_CHK( mpi_copy( &c[0], &T[0]->Z ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &c[0], &T[0]->Z ) );
for( i = 1; i < t_len; i++ )
{
- MPI_CHK( mpi_mul_mpi( &c[i], &c[i-1], &T[i]->Z ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &c[i], &c[i-1], &T[i]->Z ) );
MOD_MUL( c[i] );
}
/*
* u = 1 / (Z_0 * ... * Z_n) mod P
*/
- MPI_CHK( mpi_inv_mod( &u, &c[t_len-1], &grp->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &u, &c[t_len-1], &grp->P ) );
for( i = t_len - 1; ; i-- )
{
@@ -843,21 +843,21 @@
* u = 1 / (Z_0 * ... * Z_i) mod P
*/
if( i == 0 ) {
- MPI_CHK( mpi_copy( &Zi, &u ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Zi, &u ) );
}
else
{
- MPI_CHK( mpi_mul_mpi( &Zi, &u, &c[i-1] ) ); MOD_MUL( Zi );
- MPI_CHK( mpi_mul_mpi( &u, &u, &T[i]->Z ) ); MOD_MUL( u );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Zi, &u, &c[i-1] ) ); MOD_MUL( Zi );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &u, &u, &T[i]->Z ) ); MOD_MUL( u );
}
/*
* proceed as in normalize()
*/
- MPI_CHK( mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );
- MPI_CHK( mpi_mul_mpi( &T[i]->X, &T[i]->X, &ZZi ) ); MOD_MUL( T[i]->X );
- MPI_CHK( mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &ZZi ) ); MOD_MUL( T[i]->Y );
- MPI_CHK( mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &Zi ) ); MOD_MUL( T[i]->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->X, &T[i]->X, &ZZi ) ); MOD_MUL( T[i]->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &ZZi ) ); MOD_MUL( T[i]->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &Zi ) ); MOD_MUL( T[i]->Y );
/*
* Post-precessing: reclaim some memory by shrinking coordinates
@@ -865,9 +865,9 @@
* - shrinking other coordinates, but still keeping the same number of
* limbs as P, as otherwise it will too likely be regrown too fast.
*/
- MPI_CHK( mpi_shrink( &T[i]->X, grp->P.n ) );
- MPI_CHK( mpi_shrink( &T[i]->Y, grp->P.n ) );
- mpi_free( &T[i]->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shrink( &T[i]->X, grp->P.n ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shrink( &T[i]->Y, grp->P.n ) );
+ mbedtls_mpi_free( &T[i]->Z );
if( i == 0 )
break;
@@ -875,10 +875,10 @@
cleanup:
- mpi_free( &u ); mpi_free( &Zi ); mpi_free( &ZZi );
+ mbedtls_mpi_free( &u ); mbedtls_mpi_free( &Zi ); mbedtls_mpi_free( &ZZi );
for( i = 0; i < t_len; i++ )
- mpi_free( &c[i] );
- polarssl_free( c );
+ mbedtls_mpi_free( &c[i] );
+ mbedtls_free( c );
return( ret );
}
@@ -887,23 +887,23 @@
* Conditional point inversion: Q -> -Q = (Q.X, -Q.Y, Q.Z) without leak.
* "inv" must be 0 (don't invert) or 1 (invert) or the result will be invalid
*/
-static int ecp_safe_invert_jac( const ecp_group *grp,
- ecp_point *Q,
+static int ecp_safe_invert_jac( const mbedtls_ecp_group *grp,
+ mbedtls_ecp_point *Q,
unsigned char inv )
{
int ret;
unsigned char nonzero;
- mpi mQY;
+ mbedtls_mpi mQY;
- mpi_init( &mQY );
+ mbedtls_mpi_init( &mQY );
/* Use the fact that -Q.Y mod P = P - Q.Y unless Q.Y == 0 */
- MPI_CHK( mpi_sub_mpi( &mQY, &grp->P, &Q->Y ) );
- nonzero = mpi_cmp_int( &Q->Y, 0 ) != 0;
- MPI_CHK( mpi_safe_cond_assign( &Q->Y, &mQY, inv & nonzero ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &mQY, &grp->P, &Q->Y ) );
+ nonzero = mbedtls_mpi_cmp_int( &Q->Y, 0 ) != 0;
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &Q->Y, &mQY, inv & nonzero ) );
cleanup:
- mpi_free( &mQY );
+ mbedtls_mpi_free( &mQY );
return( ret );
}
@@ -918,63 +918,63 @@
*
* Cost: 1D := 2M + 8S
*/
-static int ecp_double_jac( const ecp_group *grp, ecp_point *R,
- const ecp_point *P )
+static int ecp_double_jac( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point *P )
{
int ret;
- mpi T1, T2, T3, X3, Y3, Z3;
+ mbedtls_mpi T1, T2, T3, X3, Y3, Z3;
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
dbl_count++;
#endif
- mpi_init( &T1 ); mpi_init( &T2 ); mpi_init( &T3 );
- mpi_init( &X3 ); mpi_init( &Y3 ); mpi_init( &Z3 );
+ mbedtls_mpi_init( &T1 ); mbedtls_mpi_init( &T2 ); mbedtls_mpi_init( &T3 );
+ mbedtls_mpi_init( &X3 ); mbedtls_mpi_init( &Y3 ); mbedtls_mpi_init( &Z3 );
- MPI_CHK( mpi_mul_mpi( &T3, &P->X, &P->X ) ); MOD_MUL( T3 );
- MPI_CHK( mpi_mul_mpi( &T2, &P->Y, &P->Y ) ); MOD_MUL( T2 );
- MPI_CHK( mpi_mul_mpi( &Y3, &T2, &T2 ) ); MOD_MUL( Y3 );
- MPI_CHK( mpi_add_mpi( &X3, &P->X, &T2 ) ); MOD_ADD( X3 );
- MPI_CHK( mpi_mul_mpi( &X3, &X3, &X3 ) ); MOD_MUL( X3 );
- MPI_CHK( mpi_sub_mpi( &X3, &X3, &Y3 ) ); MOD_SUB( X3 );
- MPI_CHK( mpi_sub_mpi( &X3, &X3, &T3 ) ); MOD_SUB( X3 );
- MPI_CHK( mpi_mul_int( &T1, &X3, 2 ) ); MOD_ADD( T1 );
- MPI_CHK( mpi_mul_mpi( &Z3, &P->Z, &P->Z ) ); MOD_MUL( Z3 );
- MPI_CHK( mpi_mul_mpi( &X3, &Z3, &Z3 ) ); MOD_MUL( X3 );
- MPI_CHK( mpi_mul_int( &T3, &T3, 3 ) ); MOD_ADD( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &P->X, &P->X ) ); MOD_MUL( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T2, &P->Y, &P->Y ) ); MOD_MUL( T2 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Y3, &T2, &T2 ) ); MOD_MUL( Y3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &X3, &P->X, &T2 ) ); MOD_ADD( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X3, &X3, &X3 ) ); MOD_MUL( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X3, &X3, &Y3 ) ); MOD_SUB( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X3, &X3, &T3 ) ); MOD_SUB( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &X3, 2 ) ); MOD_ADD( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Z3, &P->Z, &P->Z ) ); MOD_MUL( Z3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X3, &Z3, &Z3 ) ); MOD_MUL( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T3, &T3, 3 ) ); MOD_ADD( T3 );
/* Special case for A = -3 */
if( grp->A.p == NULL )
{
- MPI_CHK( mpi_mul_int( &X3, &X3, 3 ) );
- X3.s = -1; /* mpi_mul_int doesn't handle negative numbers */
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &X3, &X3, 3 ) );
+ X3.s = -1; /* mbedtls_mpi_mul_int doesn't handle negative numbers */
MOD_SUB( X3 );
}
else
{
- MPI_CHK( mpi_mul_mpi( &X3, &X3, &grp->A ) ); MOD_MUL( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X3, &X3, &grp->A ) ); MOD_MUL( X3 );
}
- MPI_CHK( mpi_add_mpi( &T3, &T3, &X3 ) ); MOD_ADD( T3 );
- MPI_CHK( mpi_mul_mpi( &X3, &T3, &T3 ) ); MOD_MUL( X3 );
- MPI_CHK( mpi_sub_mpi( &X3, &X3, &T1 ) ); MOD_SUB( X3 );
- MPI_CHK( mpi_sub_mpi( &X3, &X3, &T1 ) ); MOD_SUB( X3 );
- MPI_CHK( mpi_sub_mpi( &T1, &T1, &X3 ) ); MOD_SUB( T1 );
- MPI_CHK( mpi_mul_mpi( &T1, &T3, &T1 ) ); MOD_MUL( T1 );
- MPI_CHK( mpi_mul_int( &T3, &Y3, 8 ) ); MOD_ADD( T3 );
- MPI_CHK( mpi_sub_mpi( &Y3, &T1, &T3 ) ); MOD_SUB( Y3 );
- MPI_CHK( mpi_add_mpi( &T1, &P->Y, &P->Z ) ); MOD_ADD( T1 );
- MPI_CHK( mpi_mul_mpi( &T1, &T1, &T1 ) ); MOD_MUL( T1 );
- MPI_CHK( mpi_sub_mpi( &T1, &T1, &T2 ) ); MOD_SUB( T1 );
- MPI_CHK( mpi_sub_mpi( &Z3, &T1, &Z3 ) ); MOD_SUB( Z3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &T3, &T3, &X3 ) ); MOD_ADD( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X3, &T3, &T3 ) ); MOD_MUL( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X3, &X3, &T1 ) ); MOD_SUB( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X3, &X3, &T1 ) ); MOD_SUB( X3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T1, &T1, &X3 ) ); MOD_SUB( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T3, &T1 ) ); MOD_MUL( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T3, &Y3, 8 ) ); MOD_ADD( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &Y3, &T1, &T3 ) ); MOD_SUB( Y3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &T1, &P->Y, &P->Z ) ); MOD_ADD( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T1, &T1 ) ); MOD_MUL( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T1, &T1, &T2 ) ); MOD_SUB( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &Z3, &T1, &Z3 ) ); MOD_SUB( Z3 );
- MPI_CHK( mpi_copy( &R->X, &X3 ) );
- MPI_CHK( mpi_copy( &R->Y, &Y3 ) );
- MPI_CHK( mpi_copy( &R->Z, &Z3 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->X, &X3 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Y, &Y3 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Z, &Z3 ) );
cleanup:
- mpi_free( &T1 ); mpi_free( &T2 ); mpi_free( &T3 );
- mpi_free( &X3 ); mpi_free( &Y3 ); mpi_free( &Z3 );
+ mbedtls_mpi_free( &T1 ); mbedtls_mpi_free( &T2 ); mbedtls_mpi_free( &T3 );
+ mbedtls_mpi_free( &X3 ); mbedtls_mpi_free( &Y3 ); mbedtls_mpi_free( &Z3 );
return( ret );
}
@@ -997,77 +997,77 @@
*
* Cost: 1A := 8M + 3S
*/
-static int ecp_add_mixed( const ecp_group *grp, ecp_point *R,
- const ecp_point *P, const ecp_point *Q )
+static int ecp_add_mixed( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
- mpi T1, T2, T3, T4, X, Y, Z;
+ mbedtls_mpi T1, T2, T3, T4, X, Y, Z;
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
add_count++;
#endif
/*
* Trivial cases: P == 0 or Q == 0 (case 1)
*/
- if( mpi_cmp_int( &P->Z, 0 ) == 0 )
- return( ecp_copy( R, Q ) );
+ if( mbedtls_mpi_cmp_int( &P->Z, 0 ) == 0 )
+ return( mbedtls_ecp_copy( R, Q ) );
- if( Q->Z.p != NULL && mpi_cmp_int( &Q->Z, 0 ) == 0 )
- return( ecp_copy( R, P ) );
+ if( Q->Z.p != NULL && mbedtls_mpi_cmp_int( &Q->Z, 0 ) == 0 )
+ return( mbedtls_ecp_copy( R, P ) );
/*
* Make sure Q coordinates are normalized
*/
- if( Q->Z.p != NULL && mpi_cmp_int( &Q->Z, 1 ) != 0 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( Q->Z.p != NULL && mbedtls_mpi_cmp_int( &Q->Z, 1 ) != 0 )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- mpi_init( &T1 ); mpi_init( &T2 ); mpi_init( &T3 ); mpi_init( &T4 );
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
+ mbedtls_mpi_init( &T1 ); mbedtls_mpi_init( &T2 ); mbedtls_mpi_init( &T3 ); mbedtls_mpi_init( &T4 );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
- MPI_CHK( mpi_mul_mpi( &T1, &P->Z, &P->Z ) ); MOD_MUL( T1 );
- MPI_CHK( mpi_mul_mpi( &T2, &T1, &P->Z ) ); MOD_MUL( T2 );
- MPI_CHK( mpi_mul_mpi( &T1, &T1, &Q->X ) ); MOD_MUL( T1 );
- MPI_CHK( mpi_mul_mpi( &T2, &T2, &Q->Y ) ); MOD_MUL( T2 );
- MPI_CHK( mpi_sub_mpi( &T1, &T1, &P->X ) ); MOD_SUB( T1 );
- MPI_CHK( mpi_sub_mpi( &T2, &T2, &P->Y ) ); MOD_SUB( T2 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &P->Z, &P->Z ) ); MOD_MUL( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T2, &T1, &P->Z ) ); MOD_MUL( T2 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T1, &Q->X ) ); MOD_MUL( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T2, &T2, &Q->Y ) ); MOD_MUL( T2 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T1, &T1, &P->X ) ); MOD_SUB( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T2, &T2, &P->Y ) ); MOD_SUB( T2 );
/* Special cases (2) and (3) */
- if( mpi_cmp_int( &T1, 0 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &T1, 0 ) == 0 )
{
- if( mpi_cmp_int( &T2, 0 ) == 0 )
+ if( mbedtls_mpi_cmp_int( &T2, 0 ) == 0 )
{
ret = ecp_double_jac( grp, R, P );
goto cleanup;
}
else
{
- ret = ecp_set_zero( R );
+ ret = mbedtls_ecp_set_zero( R );
goto cleanup;
}
}
- MPI_CHK( mpi_mul_mpi( &Z, &P->Z, &T1 ) ); MOD_MUL( Z );
- MPI_CHK( mpi_mul_mpi( &T3, &T1, &T1 ) ); MOD_MUL( T3 );
- MPI_CHK( mpi_mul_mpi( &T4, &T3, &T1 ) ); MOD_MUL( T4 );
- MPI_CHK( mpi_mul_mpi( &T3, &T3, &P->X ) ); MOD_MUL( T3 );
- MPI_CHK( mpi_mul_int( &T1, &T3, 2 ) ); MOD_ADD( T1 );
- MPI_CHK( mpi_mul_mpi( &X, &T2, &T2 ) ); MOD_MUL( X );
- MPI_CHK( mpi_sub_mpi( &X, &X, &T1 ) ); MOD_SUB( X );
- MPI_CHK( mpi_sub_mpi( &X, &X, &T4 ) ); MOD_SUB( X );
- MPI_CHK( mpi_sub_mpi( &T3, &T3, &X ) ); MOD_SUB( T3 );
- MPI_CHK( mpi_mul_mpi( &T3, &T3, &T2 ) ); MOD_MUL( T3 );
- MPI_CHK( mpi_mul_mpi( &T4, &T4, &P->Y ) ); MOD_MUL( T4 );
- MPI_CHK( mpi_sub_mpi( &Y, &T3, &T4 ) ); MOD_SUB( Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Z, &P->Z, &T1 ) ); MOD_MUL( Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T1, &T1 ) ); MOD_MUL( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T4, &T3, &T1 ) ); MOD_MUL( T4 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T3, &P->X ) ); MOD_MUL( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &T3, 2 ) ); MOD_ADD( T1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &T2, &T2 ) ); MOD_MUL( X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T1 ) ); MOD_SUB( X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T4 ) ); MOD_SUB( X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T3, &T3, &X ) ); MOD_SUB( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T3, &T2 ) ); MOD_MUL( T3 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T4, &T4, &P->Y ) ); MOD_MUL( T4 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &Y, &T3, &T4 ) ); MOD_SUB( Y );
- MPI_CHK( mpi_copy( &R->X, &X ) );
- MPI_CHK( mpi_copy( &R->Y, &Y ) );
- MPI_CHK( mpi_copy( &R->Z, &Z ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->X, &X ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Y, &Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Z, &Z ) );
cleanup:
- mpi_free( &T1 ); mpi_free( &T2 ); mpi_free( &T3 ); mpi_free( &T4 );
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
+ mbedtls_mpi_free( &T1 ); mbedtls_mpi_free( &T2 ); mbedtls_mpi_free( &T3 ); mbedtls_mpi_free( &T4 );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
return( ret );
}
@@ -1075,16 +1075,16 @@
/*
* Addition: R = P + Q, result's coordinates normalized
*/
-int ecp_add( const ecp_group *grp, ecp_point *R,
- const ecp_point *P, const ecp_point *Q )
+int mbedtls_ecp_add( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
- if( ecp_get_type( grp ) != POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
- return( POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE );
+ if( ecp_get_type( grp ) != MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
+ return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
- MPI_CHK( ecp_add_mixed( grp, R, P, Q ) );
- MPI_CHK( ecp_normalize_jac( grp, R ) );
+ MBEDTLS_MPI_CHK( ecp_add_mixed( grp, R, P, Q ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, R ) );
cleanup:
return( ret );
@@ -1093,27 +1093,27 @@
/*
* Subtraction: R = P - Q, result's coordinates normalized
*/
-int ecp_sub( const ecp_group *grp, ecp_point *R,
- const ecp_point *P, const ecp_point *Q )
+int mbedtls_ecp_sub( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
- ecp_point mQ;
+ mbedtls_ecp_point mQ;
- ecp_point_init( &mQ );
+ mbedtls_ecp_point_init( &mQ );
- if( ecp_get_type( grp ) != POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
- return( POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE );
+ if( ecp_get_type( grp ) != MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
+ return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
/* mQ = - Q */
- MPI_CHK( ecp_copy( &mQ, Q ) );
- if( mpi_cmp_int( &mQ.Y, 0 ) != 0 )
- MPI_CHK( mpi_sub_mpi( &mQ.Y, &grp->P, &mQ.Y ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_copy( &mQ, Q ) );
+ if( mbedtls_mpi_cmp_int( &mQ.Y, 0 ) != 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &mQ.Y, &grp->P, &mQ.Y ) );
- MPI_CHK( ecp_add_mixed( grp, R, P, &mQ ) );
- MPI_CHK( ecp_normalize_jac( grp, R ) );
+ MBEDTLS_MPI_CHK( ecp_add_mixed( grp, R, P, &mQ ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, R ) );
cleanup:
- ecp_point_free( &mQ );
+ mbedtls_ecp_point_free( &mQ );
return( ret );
}
@@ -1125,42 +1125,42 @@
*
* This countermeasure was first suggested in [2].
*/
-static int ecp_randomize_jac( const ecp_group *grp, ecp_point *pt,
+static int ecp_randomize_jac( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret;
- mpi l, ll;
+ mbedtls_mpi l, ll;
size_t p_size = ( grp->pbits + 7 ) / 8;
int count = 0;
- mpi_init( &l ); mpi_init( &ll );
+ mbedtls_mpi_init( &l ); mbedtls_mpi_init( &ll );
/* Generate l such that 1 < l < p */
do
{
- mpi_fill_random( &l, p_size, f_rng, p_rng );
+ mbedtls_mpi_fill_random( &l, p_size, f_rng, p_rng );
- while( mpi_cmp_mpi( &l, &grp->P ) >= 0 )
- MPI_CHK( mpi_shift_r( &l, 1 ) );
+ while( mbedtls_mpi_cmp_mpi( &l, &grp->P ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &l, 1 ) );
if( count++ > 10 )
- return( POLARSSL_ERR_ECP_RANDOM_FAILED );
+ return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
}
- while( mpi_cmp_int( &l, 1 ) <= 0 );
+ while( mbedtls_mpi_cmp_int( &l, 1 ) <= 0 );
/* Z = l * Z */
- MPI_CHK( mpi_mul_mpi( &pt->Z, &pt->Z, &l ) ); MOD_MUL( pt->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Z, &pt->Z, &l ) ); MOD_MUL( pt->Z );
/* X = l^2 * X */
- MPI_CHK( mpi_mul_mpi( &ll, &l, &l ) ); MOD_MUL( ll );
- MPI_CHK( mpi_mul_mpi( &pt->X, &pt->X, &ll ) ); MOD_MUL( pt->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ll, &l, &l ) ); MOD_MUL( ll );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->X, &pt->X, &ll ) ); MOD_MUL( pt->X );
/* Y = l^3 * Y */
- MPI_CHK( mpi_mul_mpi( &ll, &ll, &l ) ); MOD_MUL( ll );
- MPI_CHK( mpi_mul_mpi( &pt->Y, &pt->Y, &ll ) ); MOD_MUL( pt->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ll, &ll, &l ) ); MOD_MUL( ll );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &ll ) ); MOD_MUL( pt->Y );
cleanup:
- mpi_free( &l ); mpi_free( &ll );
+ mbedtls_mpi_free( &l ); mbedtls_mpi_free( &ll );
return( ret );
}
@@ -1168,15 +1168,15 @@
/*
* Check and define parameters used by the comb method (see below for details)
*/
-#if POLARSSL_ECP_WINDOW_SIZE < 2 || POLARSSL_ECP_WINDOW_SIZE > 7
-#error "POLARSSL_ECP_WINDOW_SIZE out of bounds"
+#if MBEDTLS_ECP_WINDOW_SIZE < 2 || MBEDTLS_ECP_WINDOW_SIZE > 7
+#error "MBEDTLS_ECP_WINDOW_SIZE out of bounds"
#endif
/* d = ceil( n / w ) */
-#define COMB_MAX_D ( POLARSSL_ECP_MAX_BITS + 1 ) / 2
+#define COMB_MAX_D ( MBEDTLS_ECP_MAX_BITS + 1 ) / 2
/* number of precomputed points */
-#define COMB_MAX_PRE ( 1 << ( POLARSSL_ECP_WINDOW_SIZE - 1 ) )
+#define COMB_MAX_PRE ( 1 << ( MBEDTLS_ECP_WINDOW_SIZE - 1 ) )
/*
* Compute the representation of m that will be used with our comb method.
@@ -1194,12 +1194,12 @@
* Calling conventions:
* - x is an array of size d + 1
* - w is the size, ie number of teeth, of the comb, and must be between
- * 2 and 7 (in practice, between 2 and POLARSSL_ECP_WINDOW_SIZE)
+ * 2 and 7 (in practice, between 2 and MBEDTLS_ECP_WINDOW_SIZE)
* - m is the MPI, expected to be odd and such that bitlength(m) <= w * d
* (the result will be incorrect if these assumptions are not satisfied)
*/
static void ecp_comb_fixed( unsigned char x[], size_t d,
- unsigned char w, const mpi *m )
+ unsigned char w, const mbedtls_mpi *m )
{
size_t i, j;
unsigned char c, cc, adjust;
@@ -1209,7 +1209,7 @@
/* First get the classical comb values (except for x_d = 0) */
for( i = 0; i < d; i++ )
for( j = 0; j < w; j++ )
- x[i] |= mpi_get_bit( m, i + d * j ) << j;
+ x[i] |= mbedtls_mpi_get_bit( m, i + d * j ) << j;
/* Now make sure x_1 .. x_d are odd */
c = 0;
@@ -1238,33 +1238,33 @@
*
* Cost: d(w-1) D + (2^{w-1} - 1) A + 1 N(w-1) + 1 N(2^{w-1} - 1)
*/
-static int ecp_precompute_comb( const ecp_group *grp,
- ecp_point T[], const ecp_point *P,
+static int ecp_precompute_comb( const mbedtls_ecp_group *grp,
+ mbedtls_ecp_point T[], const mbedtls_ecp_point *P,
unsigned char w, size_t d )
{
int ret;
unsigned char i, k;
size_t j;
- ecp_point *cur, *TT[COMB_MAX_PRE - 1];
+ mbedtls_ecp_point *cur, *TT[COMB_MAX_PRE - 1];
/*
* Set T[0] = P and
* T[2^{l-1}] = 2^{dl} P for l = 1 .. w-1 (this is not the final value)
*/
- MPI_CHK( ecp_copy( &T[0], P ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_copy( &T[0], P ) );
k = 0;
for( i = 1; i < ( 1U << ( w - 1 ) ); i <<= 1 )
{
cur = T + i;
- MPI_CHK( ecp_copy( cur, T + ( i >> 1 ) ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_copy( cur, T + ( i >> 1 ) ) );
for( j = 0; j < d; j++ )
- MPI_CHK( ecp_double_jac( grp, cur, cur ) );
+ MBEDTLS_MPI_CHK( ecp_double_jac( grp, cur, cur ) );
TT[k++] = cur;
}
- MPI_CHK( ecp_normalize_jac_many( grp, TT, k ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_jac_many( grp, TT, k ) );
/*
* Compute the remaining ones using the minimal number of additions
@@ -1276,12 +1276,12 @@
j = i;
while( j-- )
{
- MPI_CHK( ecp_add_mixed( grp, &T[i + j], &T[j], &T[i] ) );
+ MBEDTLS_MPI_CHK( ecp_add_mixed( grp, &T[i + j], &T[j], &T[i] ) );
TT[k++] = &T[i + j];
}
}
- MPI_CHK( ecp_normalize_jac_many( grp, TT, k ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_jac_many( grp, TT, k ) );
cleanup:
return( ret );
@@ -1290,8 +1290,8 @@
/*
* Select precomputed point: R = sign(i) * T[ abs(i) / 2 ]
*/
-static int ecp_select_comb( const ecp_group *grp, ecp_point *R,
- const ecp_point T[], unsigned char t_len,
+static int ecp_select_comb( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point T[], unsigned char t_len,
unsigned char i )
{
int ret;
@@ -1303,12 +1303,12 @@
/* Read the whole table to thwart cache-based timing attacks */
for( j = 0; j < t_len; j++ )
{
- MPI_CHK( mpi_safe_cond_assign( &R->X, &T[j].X, j == ii ) );
- MPI_CHK( mpi_safe_cond_assign( &R->Y, &T[j].Y, j == ii ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &R->X, &T[j].X, j == ii ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &R->Y, &T[j].Y, j == ii ) );
}
/* Safely invert result if i is "negative" */
- MPI_CHK( ecp_safe_invert_jac( grp, R, i >> 7 ) );
+ MBEDTLS_MPI_CHK( ecp_safe_invert_jac( grp, R, i >> 7 ) );
cleanup:
return( ret );
@@ -1320,34 +1320,34 @@
*
* Cost: d A + d D + 1 R
*/
-static int ecp_mul_comb_core( const ecp_group *grp, ecp_point *R,
- const ecp_point T[], unsigned char t_len,
+static int ecp_mul_comb_core( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_ecp_point T[], unsigned char t_len,
const unsigned char x[], size_t d,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
- ecp_point Txi;
+ mbedtls_ecp_point Txi;
size_t i;
- ecp_point_init( &Txi );
+ mbedtls_ecp_point_init( &Txi );
/* Start with a non-zero point and randomize its coordinates */
i = d;
- MPI_CHK( ecp_select_comb( grp, R, T, t_len, x[i] ) );
- MPI_CHK( mpi_lset( &R->Z, 1 ) );
+ MBEDTLS_MPI_CHK( ecp_select_comb( grp, R, T, t_len, x[i] ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &R->Z, 1 ) );
if( f_rng != 0 )
- MPI_CHK( ecp_randomize_jac( grp, R, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( ecp_randomize_jac( grp, R, f_rng, p_rng ) );
while( i-- != 0 )
{
- MPI_CHK( ecp_double_jac( grp, R, R ) );
- MPI_CHK( ecp_select_comb( grp, &Txi, T, t_len, x[i] ) );
- MPI_CHK( ecp_add_mixed( grp, R, R, &Txi ) );
+ MBEDTLS_MPI_CHK( ecp_double_jac( grp, R, R ) );
+ MBEDTLS_MPI_CHK( ecp_select_comb( grp, &Txi, T, t_len, x[i] ) );
+ MBEDTLS_MPI_CHK( ecp_add_mixed( grp, R, R, &Txi ) );
}
cleanup:
- ecp_point_free( &Txi );
+ mbedtls_ecp_point_free( &Txi );
return( ret );
}
@@ -1356,8 +1356,8 @@
* Multiplication using the comb method,
* for curves in short Weierstrass form
*/
-static int ecp_mul_comb( ecp_group *grp, ecp_point *R,
- const mpi *m, const ecp_point *P,
+static int ecp_mul_comb( mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_mpi *m, const mbedtls_ecp_point *P,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -1365,15 +1365,15 @@
unsigned char w, m_is_odd, p_eq_g, pre_len, i;
size_t d;
unsigned char k[COMB_MAX_D + 1];
- ecp_point *T;
- mpi M, mm;
+ mbedtls_ecp_point *T;
+ mbedtls_mpi M, mm;
- mpi_init( &M );
- mpi_init( &mm );
+ mbedtls_mpi_init( &M );
+ mbedtls_mpi_init( &mm );
/* we need N to be odd to trnaform m in an odd number, check now */
- if( mpi_get_bit( &grp->N, 0 ) != 1 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( mbedtls_mpi_get_bit( &grp->N, 0 ) != 1 )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Minimize the number of multiplications, that is minimize
@@ -1387,9 +1387,9 @@
* Just adding one avoids upping the cost of the first mul too much,
* and the memory cost too.
*/
-#if POLARSSL_ECP_FIXED_POINT_OPTIM == 1
- p_eq_g = ( mpi_cmp_mpi( &P->Y, &grp->G.Y ) == 0 &&
- mpi_cmp_mpi( &P->X, &grp->G.X ) == 0 );
+#if MBEDTLS_ECP_FIXED_POINT_OPTIM == 1
+ p_eq_g = ( mbedtls_mpi_cmp_mpi( &P->Y, &grp->G.Y ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &P->X, &grp->G.X ) == 0 );
if( p_eq_g )
w++;
#else
@@ -1400,8 +1400,8 @@
* Make sure w is within bounds.
* (The last test is useful only for very small curves in the test suite.)
*/
- if( w > POLARSSL_ECP_WINDOW_SIZE )
- w = POLARSSL_ECP_WINDOW_SIZE;
+ if( w > MBEDTLS_ECP_WINDOW_SIZE )
+ w = MBEDTLS_ECP_WINDOW_SIZE;
if( w >= grp->nbits )
w = 2;
@@ -1417,17 +1417,17 @@
if( T == NULL )
{
- T = polarssl_malloc( pre_len * sizeof( ecp_point ) );
+ T = mbedtls_malloc( pre_len * sizeof( mbedtls_ecp_point ) );
if( T == NULL )
{
- ret = POLARSSL_ERR_ECP_MALLOC_FAILED;
+ ret = MBEDTLS_ERR_ECP_MALLOC_FAILED;
goto cleanup;
}
for( i = 0; i < pre_len; i++ )
- ecp_point_init( &T[i] );
+ mbedtls_ecp_point_init( &T[i] );
- MPI_CHK( ecp_precompute_comb( grp, T, P, w, d ) );
+ MBEDTLS_MPI_CHK( ecp_precompute_comb( grp, T, P, w, d ) );
if( p_eq_g )
{
@@ -1440,44 +1440,44 @@
* Make sure M is odd (M = m or M = N - m, since N is odd)
* using the fact that m * P = - (N - m) * P
*/
- m_is_odd = ( mpi_get_bit( m, 0 ) == 1 );
- MPI_CHK( mpi_copy( &M, m ) );
- MPI_CHK( mpi_sub_mpi( &mm, &grp->N, m ) );
- MPI_CHK( mpi_safe_cond_assign( &M, &mm, ! m_is_odd ) );
+ m_is_odd = ( mbedtls_mpi_get_bit( m, 0 ) == 1 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &M, m ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &mm, &grp->N, m ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &M, &mm, ! m_is_odd ) );
/*
* Go for comb multiplication, R = M * P
*/
ecp_comb_fixed( k, d, w, &M );
- MPI_CHK( ecp_mul_comb_core( grp, R, T, pre_len, k, d, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( ecp_mul_comb_core( grp, R, T, pre_len, k, d, f_rng, p_rng ) );
/*
* Now get m * P from M * P and normalize it
*/
- MPI_CHK( ecp_safe_invert_jac( grp, R, ! m_is_odd ) );
- MPI_CHK( ecp_normalize_jac( grp, R ) );
+ MBEDTLS_MPI_CHK( ecp_safe_invert_jac( grp, R, ! m_is_odd ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, R ) );
cleanup:
if( T != NULL && ! p_eq_g )
{
for( i = 0; i < pre_len; i++ )
- ecp_point_free( &T[i] );
- polarssl_free( T );
+ mbedtls_ecp_point_free( &T[i] );
+ mbedtls_free( T );
}
- mpi_free( &M );
- mpi_free( &mm );
+ mbedtls_mpi_free( &M );
+ mbedtls_mpi_free( &mm );
if( ret != 0 )
- ecp_point_free( R );
+ mbedtls_ecp_point_free( R );
return( ret );
}
-#endif /* POLARSSL_ECP_SHORT_WEIERSTRASS */
+#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS */
-#if defined(POLARSSL_ECP_MONTGOMERY)
+#if defined(MBEDTLS_ECP_MONTGOMERY)
/*
* For Montgomery curves, we do all the internal arithmetic in projective
* coordinates. Import/export of points uses only the x coordinates, which is
@@ -1490,13 +1490,13 @@
* Normalize Montgomery x/z coordinates: X = X/Z, Z = 1
* Cost: 1M + 1I
*/
-static int ecp_normalize_mxz( const ecp_group *grp, ecp_point *P )
+static int ecp_normalize_mxz( const mbedtls_ecp_group *grp, mbedtls_ecp_point *P )
{
int ret;
- MPI_CHK( mpi_inv_mod( &P->Z, &P->Z, &grp->P ) );
- MPI_CHK( mpi_mul_mpi( &P->X, &P->X, &P->Z ) ); MOD_MUL( P->X );
- MPI_CHK( mpi_lset( &P->Z, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &P->Z, &P->Z, &grp->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &P->X, &P->X, &P->Z ) ); MOD_MUL( P->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &P->Z, 1 ) );
cleanup:
return( ret );
@@ -1510,34 +1510,34 @@
* This countermeasure was first suggested in [2].
* Cost: 2M
*/
-static int ecp_randomize_mxz( const ecp_group *grp, ecp_point *P,
+static int ecp_randomize_mxz( const mbedtls_ecp_group *grp, mbedtls_ecp_point *P,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret;
- mpi l;
+ mbedtls_mpi l;
size_t p_size = ( grp->pbits + 7 ) / 8;
int count = 0;
- mpi_init( &l );
+ mbedtls_mpi_init( &l );
/* Generate l such that 1 < l < p */
do
{
- mpi_fill_random( &l, p_size, f_rng, p_rng );
+ mbedtls_mpi_fill_random( &l, p_size, f_rng, p_rng );
- while( mpi_cmp_mpi( &l, &grp->P ) >= 0 )
- MPI_CHK( mpi_shift_r( &l, 1 ) );
+ while( mbedtls_mpi_cmp_mpi( &l, &grp->P ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &l, 1 ) );
if( count++ > 10 )
- return( POLARSSL_ERR_ECP_RANDOM_FAILED );
+ return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
}
- while( mpi_cmp_int( &l, 1 ) <= 0 );
+ while( mbedtls_mpi_cmp_int( &l, 1 ) <= 0 );
- MPI_CHK( mpi_mul_mpi( &P->X, &P->X, &l ) ); MOD_MUL( P->X );
- MPI_CHK( mpi_mul_mpi( &P->Z, &P->Z, &l ) ); MOD_MUL( P->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &P->X, &P->X, &l ) ); MOD_MUL( P->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &P->Z, &P->Z, &l ) ); MOD_MUL( P->Z );
cleanup:
- mpi_free( &l );
+ mbedtls_mpi_free( &l );
return( ret );
}
@@ -1557,41 +1557,41 @@
*
* Cost: 5M + 4S
*/
-static int ecp_double_add_mxz( const ecp_group *grp,
- ecp_point *R, ecp_point *S,
- const ecp_point *P, const ecp_point *Q,
- const mpi *d )
+static int ecp_double_add_mxz( const mbedtls_ecp_group *grp,
+ mbedtls_ecp_point *R, mbedtls_ecp_point *S,
+ const mbedtls_ecp_point *P, const mbedtls_ecp_point *Q,
+ const mbedtls_mpi *d )
{
int ret;
- mpi A, AA, B, BB, E, C, D, DA, CB;
+ mbedtls_mpi A, AA, B, BB, E, C, D, DA, CB;
- mpi_init( &A ); mpi_init( &AA ); mpi_init( &B );
- mpi_init( &BB ); mpi_init( &E ); mpi_init( &C );
- mpi_init( &D ); mpi_init( &DA ); mpi_init( &CB );
+ mbedtls_mpi_init( &A ); mbedtls_mpi_init( &AA ); mbedtls_mpi_init( &B );
+ mbedtls_mpi_init( &BB ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &C );
+ mbedtls_mpi_init( &D ); mbedtls_mpi_init( &DA ); mbedtls_mpi_init( &CB );
- MPI_CHK( mpi_add_mpi( &A, &P->X, &P->Z ) ); MOD_ADD( A );
- MPI_CHK( mpi_mul_mpi( &AA, &A, &A ) ); MOD_MUL( AA );
- MPI_CHK( mpi_sub_mpi( &B, &P->X, &P->Z ) ); MOD_SUB( B );
- MPI_CHK( mpi_mul_mpi( &BB, &B, &B ) ); MOD_MUL( BB );
- MPI_CHK( mpi_sub_mpi( &E, &AA, &BB ) ); MOD_SUB( E );
- MPI_CHK( mpi_add_mpi( &C, &Q->X, &Q->Z ) ); MOD_ADD( C );
- MPI_CHK( mpi_sub_mpi( &D, &Q->X, &Q->Z ) ); MOD_SUB( D );
- MPI_CHK( mpi_mul_mpi( &DA, &D, &A ) ); MOD_MUL( DA );
- MPI_CHK( mpi_mul_mpi( &CB, &C, &B ) ); MOD_MUL( CB );
- MPI_CHK( mpi_add_mpi( &S->X, &DA, &CB ) ); MOD_MUL( S->X );
- MPI_CHK( mpi_mul_mpi( &S->X, &S->X, &S->X ) ); MOD_MUL( S->X );
- MPI_CHK( mpi_sub_mpi( &S->Z, &DA, &CB ) ); MOD_SUB( S->Z );
- MPI_CHK( mpi_mul_mpi( &S->Z, &S->Z, &S->Z ) ); MOD_MUL( S->Z );
- MPI_CHK( mpi_mul_mpi( &S->Z, d, &S->Z ) ); MOD_MUL( S->Z );
- MPI_CHK( mpi_mul_mpi( &R->X, &AA, &BB ) ); MOD_MUL( R->X );
- MPI_CHK( mpi_mul_mpi( &R->Z, &grp->A, &E ) ); MOD_MUL( R->Z );
- MPI_CHK( mpi_add_mpi( &R->Z, &BB, &R->Z ) ); MOD_ADD( R->Z );
- MPI_CHK( mpi_mul_mpi( &R->Z, &E, &R->Z ) ); MOD_MUL( R->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &A, &P->X, &P->Z ) ); MOD_ADD( A );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &AA, &A, &A ) ); MOD_MUL( AA );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &B, &P->X, &P->Z ) ); MOD_SUB( B );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &BB, &B, &B ) ); MOD_MUL( BB );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &E, &AA, &BB ) ); MOD_SUB( E );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &C, &Q->X, &Q->Z ) ); MOD_ADD( C );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &D, &Q->X, &Q->Z ) ); MOD_SUB( D );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &DA, &D, &A ) ); MOD_MUL( DA );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &CB, &C, &B ) ); MOD_MUL( CB );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &S->X, &DA, &CB ) ); MOD_MUL( S->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S->X, &S->X, &S->X ) ); MOD_MUL( S->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &S->Z, &DA, &CB ) ); MOD_SUB( S->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S->Z, &S->Z, &S->Z ) ); MOD_MUL( S->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S->Z, d, &S->Z ) ); MOD_MUL( S->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &R->X, &AA, &BB ) ); MOD_MUL( R->X );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &R->Z, &grp->A, &E ) ); MOD_MUL( R->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &R->Z, &BB, &R->Z ) ); MOD_ADD( R->Z );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &R->Z, &E, &R->Z ) ); MOD_MUL( R->Z );
cleanup:
- mpi_free( &A ); mpi_free( &AA ); mpi_free( &B );
- mpi_free( &BB ); mpi_free( &E ); mpi_free( &C );
- mpi_free( &D ); mpi_free( &DA ); mpi_free( &CB );
+ mbedtls_mpi_free( &A ); mbedtls_mpi_free( &AA ); mbedtls_mpi_free( &B );
+ mbedtls_mpi_free( &BB ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &C );
+ mbedtls_mpi_free( &D ); mbedtls_mpi_free( &DA ); mbedtls_mpi_free( &CB );
return( ret );
}
@@ -1600,40 +1600,40 @@
* Multiplication with Montgomery ladder in x/z coordinates,
* for curves in Montgomery form
*/
-static int ecp_mul_mxz( ecp_group *grp, ecp_point *R,
- const mpi *m, const ecp_point *P,
+static int ecp_mul_mxz( mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_mpi *m, const mbedtls_ecp_point *P,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t i;
unsigned char b;
- ecp_point RP;
- mpi PX;
+ mbedtls_ecp_point RP;
+ mbedtls_mpi PX;
- ecp_point_init( &RP ); mpi_init( &PX );
+ mbedtls_ecp_point_init( &RP ); mbedtls_mpi_init( &PX );
/* Save PX and read from P before writing to R, in case P == R */
- MPI_CHK( mpi_copy( &PX, &P->X ) );
- MPI_CHK( ecp_copy( &RP, P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &PX, &P->X ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_copy( &RP, P ) );
/* Set R to zero in modified x/z coordinates */
- MPI_CHK( mpi_lset( &R->X, 1 ) );
- MPI_CHK( mpi_lset( &R->Z, 0 ) );
- mpi_free( &R->Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &R->X, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &R->Z, 0 ) );
+ mbedtls_mpi_free( &R->Y );
/* RP.X might be sligtly larger than P, so reduce it */
MOD_ADD( RP.X );
/* Randomize coordinates of the starting point */
if( f_rng != NULL )
- MPI_CHK( ecp_randomize_mxz( grp, &RP, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( ecp_randomize_mxz( grp, &RP, f_rng, p_rng ) );
/* Loop invariant: R = result so far, RP = R + P */
- i = mpi_msb( m ); /* one past the (zero-based) most significant bit */
+ i = mbedtls_mpi_msb( m ); /* one past the (zero-based) most significant bit */
while( i-- > 0 )
{
- b = mpi_get_bit( m, i );
+ b = mbedtls_mpi_get_bit( m, i );
/*
* if (b) R = 2R + P else R = 2R,
* which is:
@@ -1641,207 +1641,207 @@
* else double_add( R, RP, R, RP )
* but using safe conditional swaps to avoid leaks
*/
- MPI_CHK( mpi_safe_cond_swap( &R->X, &RP.X, b ) );
- MPI_CHK( mpi_safe_cond_swap( &R->Z, &RP.Z, b ) );
- MPI_CHK( ecp_double_add_mxz( grp, R, &RP, R, &RP, &PX ) );
- MPI_CHK( mpi_safe_cond_swap( &R->X, &RP.X, b ) );
- MPI_CHK( mpi_safe_cond_swap( &R->Z, &RP.Z, b ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_swap( &R->X, &RP.X, b ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_swap( &R->Z, &RP.Z, b ) );
+ MBEDTLS_MPI_CHK( ecp_double_add_mxz( grp, R, &RP, R, &RP, &PX ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_swap( &R->X, &RP.X, b ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_swap( &R->Z, &RP.Z, b ) );
}
- MPI_CHK( ecp_normalize_mxz( grp, R ) );
+ MBEDTLS_MPI_CHK( ecp_normalize_mxz( grp, R ) );
cleanup:
- ecp_point_free( &RP ); mpi_free( &PX );
+ mbedtls_ecp_point_free( &RP ); mbedtls_mpi_free( &PX );
return( ret );
}
-#endif /* POLARSSL_ECP_MONTGOMERY */
+#endif /* MBEDTLS_ECP_MONTGOMERY */
/*
* Multiplication R = m * P
*/
-int ecp_mul( ecp_group *grp, ecp_point *R,
- const mpi *m, const ecp_point *P,
+int mbedtls_ecp_mul( mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
+ const mbedtls_mpi *m, const mbedtls_ecp_point *P,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret;
/* Common sanity checks */
- if( mpi_cmp_int( &P->Z, 1 ) != 0 )
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ if( mbedtls_mpi_cmp_int( &P->Z, 1 ) != 0 )
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- if( ( ret = ecp_check_privkey( grp, m ) ) != 0 ||
- ( ret = ecp_check_pubkey( grp, P ) ) != 0 )
+ if( ( ret = mbedtls_ecp_check_privkey( grp, m ) ) != 0 ||
+ ( ret = mbedtls_ecp_check_pubkey( grp, P ) ) != 0 )
return( ret );
-#if defined(POLARSSL_ECP_MONTGOMERY)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_MONTGOMERY )
+#if defined(MBEDTLS_ECP_MONTGOMERY)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
return( ecp_mul_mxz( grp, R, m, P, f_rng, p_rng ) );
#endif
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
return( ecp_mul_comb( grp, R, m, P, f_rng, p_rng ) );
#endif
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
/*
* Check that an affine point is valid as a public key,
* short weierstrass curves (SEC1 3.2.3.1)
*/
-static int ecp_check_pubkey_sw( const ecp_group *grp, const ecp_point *pt )
+static int ecp_check_pubkey_sw( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt )
{
int ret;
- mpi YY, RHS;
+ mbedtls_mpi YY, RHS;
/* pt coordinates must be normalized for our checks */
- if( mpi_cmp_int( &pt->X, 0 ) < 0 ||
- mpi_cmp_int( &pt->Y, 0 ) < 0 ||
- mpi_cmp_mpi( &pt->X, &grp->P ) >= 0 ||
- mpi_cmp_mpi( &pt->Y, &grp->P ) >= 0 )
- return( POLARSSL_ERR_ECP_INVALID_KEY );
+ if( mbedtls_mpi_cmp_int( &pt->X, 0 ) < 0 ||
+ mbedtls_mpi_cmp_int( &pt->Y, 0 ) < 0 ||
+ mbedtls_mpi_cmp_mpi( &pt->X, &grp->P ) >= 0 ||
+ mbedtls_mpi_cmp_mpi( &pt->Y, &grp->P ) >= 0 )
+ return( MBEDTLS_ERR_ECP_INVALID_KEY );
- mpi_init( &YY ); mpi_init( &RHS );
+ mbedtls_mpi_init( &YY ); mbedtls_mpi_init( &RHS );
/*
* YY = Y^2
* RHS = X (X^2 + A) + B = X^3 + A X + B
*/
- MPI_CHK( mpi_mul_mpi( &YY, &pt->Y, &pt->Y ) ); MOD_MUL( YY );
- MPI_CHK( mpi_mul_mpi( &RHS, &pt->X, &pt->X ) ); MOD_MUL( RHS );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &YY, &pt->Y, &pt->Y ) ); MOD_MUL( YY );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &RHS, &pt->X, &pt->X ) ); MOD_MUL( RHS );
/* Special case for A = -3 */
if( grp->A.p == NULL )
{
- MPI_CHK( mpi_sub_int( &RHS, &RHS, 3 ) ); MOD_SUB( RHS );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &RHS, &RHS, 3 ) ); MOD_SUB( RHS );
}
else
{
- MPI_CHK( mpi_add_mpi( &RHS, &RHS, &grp->A ) ); MOD_ADD( RHS );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &RHS, &RHS, &grp->A ) ); MOD_ADD( RHS );
}
- MPI_CHK( mpi_mul_mpi( &RHS, &RHS, &pt->X ) ); MOD_MUL( RHS );
- MPI_CHK( mpi_add_mpi( &RHS, &RHS, &grp->B ) ); MOD_ADD( RHS );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &RHS, &RHS, &pt->X ) ); MOD_MUL( RHS );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &RHS, &RHS, &grp->B ) ); MOD_ADD( RHS );
- if( mpi_cmp_mpi( &YY, &RHS ) != 0 )
- ret = POLARSSL_ERR_ECP_INVALID_KEY;
+ if( mbedtls_mpi_cmp_mpi( &YY, &RHS ) != 0 )
+ ret = MBEDTLS_ERR_ECP_INVALID_KEY;
cleanup:
- mpi_free( &YY ); mpi_free( &RHS );
+ mbedtls_mpi_free( &YY ); mbedtls_mpi_free( &RHS );
return( ret );
}
-#endif /* POLARSSL_ECP_SHORT_WEIERSTRASS */
+#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS */
-#if defined(POLARSSL_ECP_MONTGOMERY)
+#if defined(MBEDTLS_ECP_MONTGOMERY)
/*
* Check validity of a public key for Montgomery curves with x-only schemes
*/
-static int ecp_check_pubkey_mx( const ecp_group *grp, const ecp_point *pt )
+static int ecp_check_pubkey_mx( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt )
{
/* [M255 p. 5] Just check X is the correct number of bytes */
- if( mpi_size( &pt->X ) > ( grp->nbits + 7 ) / 8 )
- return( POLARSSL_ERR_ECP_INVALID_KEY );
+ if( mbedtls_mpi_size( &pt->X ) > ( grp->nbits + 7 ) / 8 )
+ return( MBEDTLS_ERR_ECP_INVALID_KEY );
return( 0 );
}
-#endif /* POLARSSL_ECP_MONTGOMERY */
+#endif /* MBEDTLS_ECP_MONTGOMERY */
/*
* Check that a point is valid as a public key
*/
-int ecp_check_pubkey( const ecp_group *grp, const ecp_point *pt )
+int mbedtls_ecp_check_pubkey( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt )
{
/* Must use affine coordinates */
- if( mpi_cmp_int( &pt->Z, 1 ) != 0 )
- return( POLARSSL_ERR_ECP_INVALID_KEY );
+ if( mbedtls_mpi_cmp_int( &pt->Z, 1 ) != 0 )
+ return( MBEDTLS_ERR_ECP_INVALID_KEY );
-#if defined(POLARSSL_ECP_MONTGOMERY)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_MONTGOMERY )
+#if defined(MBEDTLS_ECP_MONTGOMERY)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
return( ecp_check_pubkey_mx( grp, pt ) );
#endif
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
return( ecp_check_pubkey_sw( grp, pt ) );
#endif
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
/*
- * Check that an mpi is valid as a private key
+ * Check that an mbedtls_mpi is valid as a private key
*/
-int ecp_check_privkey( const ecp_group *grp, const mpi *d )
+int mbedtls_ecp_check_privkey( const mbedtls_ecp_group *grp, const mbedtls_mpi *d )
{
-#if defined(POLARSSL_ECP_MONTGOMERY)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_MONTGOMERY )
+#if defined(MBEDTLS_ECP_MONTGOMERY)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
{
/* see [M255] page 5 */
- if( mpi_get_bit( d, 0 ) != 0 ||
- mpi_get_bit( d, 1 ) != 0 ||
- mpi_get_bit( d, 2 ) != 0 ||
- mpi_msb( d ) - 1 != grp->nbits ) /* mpi_msb is one-based! */
- return( POLARSSL_ERR_ECP_INVALID_KEY );
+ if( mbedtls_mpi_get_bit( d, 0 ) != 0 ||
+ mbedtls_mpi_get_bit( d, 1 ) != 0 ||
+ mbedtls_mpi_get_bit( d, 2 ) != 0 ||
+ mbedtls_mpi_msb( d ) - 1 != grp->nbits ) /* mbedtls_mpi_msb is one-based! */
+ return( MBEDTLS_ERR_ECP_INVALID_KEY );
else
return( 0 );
}
-#endif /* POLARSSL_ECP_MONTGOMERY */
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
+#endif /* MBEDTLS_ECP_MONTGOMERY */
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
{
/* see SEC1 3.2 */
- if( mpi_cmp_int( d, 1 ) < 0 ||
- mpi_cmp_mpi( d, &grp->N ) >= 0 )
- return( POLARSSL_ERR_ECP_INVALID_KEY );
+ if( mbedtls_mpi_cmp_int( d, 1 ) < 0 ||
+ mbedtls_mpi_cmp_mpi( d, &grp->N ) >= 0 )
+ return( MBEDTLS_ERR_ECP_INVALID_KEY );
else
return( 0 );
}
-#endif /* POLARSSL_ECP_SHORT_WEIERSTRASS */
+#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS */
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
/*
* Generate a keypair
*/
-int ecp_gen_keypair( ecp_group *grp, mpi *d, ecp_point *Q,
+int mbedtls_ecp_gen_keypair( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp_point *Q,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t n_size = ( grp->nbits + 7 ) / 8;
-#if defined(POLARSSL_ECP_MONTGOMERY)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_MONTGOMERY )
+#if defined(MBEDTLS_ECP_MONTGOMERY)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
{
/* [M225] page 5 */
size_t b;
- MPI_CHK( mpi_fill_random( d, n_size, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( d, n_size, f_rng, p_rng ) );
/* Make sure the most significant bit is nbits */
- b = mpi_msb( d ) - 1; /* mpi_msb is one-based */
+ b = mbedtls_mpi_msb( d ) - 1; /* mbedtls_mpi_msb is one-based */
if( b > grp->nbits )
- MPI_CHK( mpi_shift_r( d, b - grp->nbits ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, b - grp->nbits ) );
else
- MPI_CHK( mpi_set_bit( d, grp->nbits, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, grp->nbits, 1 ) );
/* Make sure the last three bits are unset */
- MPI_CHK( mpi_set_bit( d, 0, 0 ) );
- MPI_CHK( mpi_set_bit( d, 1, 0 ) );
- MPI_CHK( mpi_set_bit( d, 2, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 0, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 1, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 2, 0 ) );
}
else
-#endif /* POLARSSL_ECP_MONTGOMERY */
-#if defined(POLARSSL_ECP_SHORT_WEIERSTRASS)
- if( ecp_get_type( grp ) == POLARSSL_ECP_TYPE_SHORT_WEIERSTRASS )
+#endif /* MBEDTLS_ECP_MONTGOMERY */
+#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS)
+ if( ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
{
/* SEC1 3.2.1: Generate d such that 1 <= n < N */
int count = 0;
- unsigned char rnd[POLARSSL_ECP_MAX_BYTES];
+ unsigned char rnd[MBEDTLS_ECP_MAX_BYTES];
/*
* Match the procedure given in RFC 6979 (deterministic ECDSA):
@@ -1852,9 +1852,9 @@
*/
do
{
- MPI_CHK( f_rng( p_rng, rnd, n_size ) );
- MPI_CHK( mpi_read_binary( d, rnd, n_size ) );
- MPI_CHK( mpi_shift_r( d, 8 * n_size - grp->nbits ) );
+ MBEDTLS_MPI_CHK( f_rng( p_rng, rnd, n_size ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( d, rnd, n_size ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, 8 * n_size - grp->nbits ) );
/*
* Each try has at worst a probability 1/2 of failing (the msb has
@@ -1866,90 +1866,90 @@
* such as secp224k1 are actually very close to the worst case.
*/
if( ++count > 30 )
- return( POLARSSL_ERR_ECP_RANDOM_FAILED );
+ return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
}
- while( mpi_cmp_int( d, 1 ) < 0 ||
- mpi_cmp_mpi( d, &grp->N ) >= 0 );
+ while( mbedtls_mpi_cmp_int( d, 1 ) < 0 ||
+ mbedtls_mpi_cmp_mpi( d, &grp->N ) >= 0 );
}
else
-#endif /* POLARSSL_ECP_SHORT_WEIERSTRASS */
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS */
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
cleanup:
if( ret != 0 )
return( ret );
- return( ecp_mul( grp, Q, d, &grp->G, f_rng, p_rng ) );
+ return( mbedtls_ecp_mul( grp, Q, d, &grp->G, f_rng, p_rng ) );
}
/*
* Generate a keypair, prettier wrapper
*/
-int ecp_gen_key( ecp_group_id grp_id, ecp_keypair *key,
+int mbedtls_ecp_gen_key( mbedtls_ecp_group_id grp_id, mbedtls_ecp_keypair *key,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret;
- if( ( ret = ecp_use_known_dp( &key->grp, grp_id ) ) != 0 )
+ if( ( ret = mbedtls_ecp_use_known_dp( &key->grp, grp_id ) ) != 0 )
return( ret );
- return( ecp_gen_keypair( &key->grp, &key->d, &key->Q, f_rng, p_rng ) );
+ return( mbedtls_ecp_gen_keypair( &key->grp, &key->d, &key->Q, f_rng, p_rng ) );
}
/*
* Check a public-private key pair
*/
-int ecp_check_pub_priv( const ecp_keypair *pub, const ecp_keypair *prv )
+int mbedtls_ecp_check_pub_priv( const mbedtls_ecp_keypair *pub, const mbedtls_ecp_keypair *prv )
{
int ret;
- ecp_point Q;
- ecp_group grp;
+ mbedtls_ecp_point Q;
+ mbedtls_ecp_group grp;
- if( pub->grp.id == POLARSSL_ECP_DP_NONE ||
+ if( pub->grp.id == MBEDTLS_ECP_DP_NONE ||
pub->grp.id != prv->grp.id ||
- mpi_cmp_mpi( &pub->Q.X, &prv->Q.X ) ||
- mpi_cmp_mpi( &pub->Q.Y, &prv->Q.Y ) ||
- mpi_cmp_mpi( &pub->Q.Z, &prv->Q.Z ) )
+ mbedtls_mpi_cmp_mpi( &pub->Q.X, &prv->Q.X ) ||
+ mbedtls_mpi_cmp_mpi( &pub->Q.Y, &prv->Q.Y ) ||
+ mbedtls_mpi_cmp_mpi( &pub->Q.Z, &prv->Q.Z ) )
{
- return( POLARSSL_ERR_ECP_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
- ecp_point_init( &Q );
- ecp_group_init( &grp );
+ mbedtls_ecp_point_init( &Q );
+ mbedtls_ecp_group_init( &grp );
- /* ecp_mul() needs a non-const group... */
- ecp_group_copy( &grp, &prv->grp );
+ /* mbedtls_ecp_mul() needs a non-const group... */
+ mbedtls_ecp_group_copy( &grp, &prv->grp );
/* Also checks d is valid */
- MPI_CHK( ecp_mul( &grp, &Q, &prv->d, &prv->grp.G, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &Q, &prv->d, &prv->grp.G, NULL, NULL ) );
- if( mpi_cmp_mpi( &Q.X, &prv->Q.X ) ||
- mpi_cmp_mpi( &Q.Y, &prv->Q.Y ) ||
- mpi_cmp_mpi( &Q.Z, &prv->Q.Z ) )
+ if( mbedtls_mpi_cmp_mpi( &Q.X, &prv->Q.X ) ||
+ mbedtls_mpi_cmp_mpi( &Q.Y, &prv->Q.Y ) ||
+ mbedtls_mpi_cmp_mpi( &Q.Z, &prv->Q.Z ) )
{
- ret = POLARSSL_ERR_ECP_BAD_INPUT_DATA;
+ ret = MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
goto cleanup;
}
cleanup:
- ecp_point_free( &Q );
- ecp_group_free( &grp );
+ mbedtls_ecp_point_free( &Q );
+ mbedtls_ecp_group_free( &grp );
return( ret );
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* Checkup routine
*/
-int ecp_self_test( int verbose )
+int mbedtls_ecp_self_test( int verbose )
{
int ret;
size_t i;
- ecp_group grp;
- ecp_point R, P;
- mpi m;
+ mbedtls_ecp_group grp;
+ mbedtls_ecp_point R, P;
+ mbedtls_mpi m;
unsigned long add_c_prev, dbl_c_prev, mul_c_prev;
/* exponents especially adapted for secp192r1 */
const char *exponents[] =
@@ -1962,30 +1962,30 @@
"555555555555555555555555555555555555555555555555", /* 101010... */
};
- ecp_group_init( &grp );
- ecp_point_init( &R );
- ecp_point_init( &P );
- mpi_init( &m );
+ mbedtls_ecp_group_init( &grp );
+ mbedtls_ecp_point_init( &R );
+ mbedtls_ecp_point_init( &P );
+ mbedtls_mpi_init( &m );
/* Use secp192r1 if available, or any available curve */
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
- MPI_CHK( ecp_use_known_dp( &grp, POLARSSL_ECP_DP_SECP192R1 ) );
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+ MBEDTLS_MPI_CHK( mbedtls_ecp_use_known_dp( &grp, MBEDTLS_ECP_DP_SECP192R1 ) );
#else
- MPI_CHK( ecp_use_known_dp( &grp, ecp_curve_list()->grp_id ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_use_known_dp( &grp, mbedtls_ecp_curve_list()->grp_id ) );
#endif
if( verbose != 0 )
- polarssl_printf( " ECP test #1 (constant op_count, base point G): " );
+ mbedtls_printf( " ECP test #1 (constant op_count, base point G): " );
/* Do a dummy multiplication first to trigger precomputation */
- MPI_CHK( mpi_lset( &m, 2 ) );
- MPI_CHK( ecp_mul( &grp, &P, &m, &grp.G, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &m, 2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &P, &m, &grp.G, NULL, NULL ) );
add_count = 0;
dbl_count = 0;
mul_count = 0;
- MPI_CHK( mpi_read_string( &m, 16, exponents[0] ) );
- MPI_CHK( ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ )
{
@@ -1996,15 +1996,15 @@
dbl_count = 0;
mul_count = 0;
- MPI_CHK( mpi_read_string( &m, 16, exponents[i] ) );
- MPI_CHK( ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
if( add_count != add_c_prev ||
dbl_count != dbl_c_prev ||
mul_count != mul_c_prev )
{
if( verbose != 0 )
- polarssl_printf( "failed (%u)\n", (unsigned int) i );
+ mbedtls_printf( "failed (%u)\n", (unsigned int) i );
ret = 1;
goto cleanup;
@@ -2012,17 +2012,17 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " ECP test #2 (constant op_count, other point): " );
+ mbedtls_printf( " ECP test #2 (constant op_count, other point): " );
/* We computed P = 2G last time, use it */
add_count = 0;
dbl_count = 0;
mul_count = 0;
- MPI_CHK( mpi_read_string( &m, 16, exponents[0] ) );
- MPI_CHK( ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ )
{
@@ -2033,15 +2033,15 @@
dbl_count = 0;
mul_count = 0;
- MPI_CHK( mpi_read_string( &m, 16, exponents[i] ) );
- MPI_CHK( ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
if( add_count != add_c_prev ||
dbl_count != dbl_c_prev ||
mul_count != mul_c_prev )
{
if( verbose != 0 )
- polarssl_printf( "failed (%u)\n", (unsigned int) i );
+ mbedtls_printf( "failed (%u)\n", (unsigned int) i );
ret = 1;
goto cleanup;
@@ -2049,24 +2049,24 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
cleanup:
if( ret < 0 && verbose != 0 )
- polarssl_printf( "Unexpected error, return code = %08X\n", ret );
+ mbedtls_printf( "Unexpected error, return code = %08X\n", ret );
- ecp_group_free( &grp );
- ecp_point_free( &R );
- ecp_point_free( &P );
- mpi_free( &m );
+ mbedtls_ecp_group_free( &grp );
+ mbedtls_ecp_point_free( &R );
+ mbedtls_ecp_point_free( &P );
+ mbedtls_mpi_free( &m );
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
diff --git a/library/ecp_curves.c b/library/ecp_curves.c
index 893bfa9..4cac3ab 100644
--- a/library/ecp_curves.c
+++ b/library/ecp_curves.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
@@ -42,9 +42,9 @@
/*
* Conversion macros for embedded constants:
- * build lists of t_uint's from lists of unsigned char's grouped by 8, 4 or 2
+ * build lists of mbedtls_mpi_uint's from lists of unsigned char's grouped by 8, 4 or 2
*/
-#if defined(POLARSSL_HAVE_INT8)
+#if defined(MBEDTLS_HAVE_INT8)
#define BYTES_TO_T_UINT_8( a, b, c, d, e, f, g, h ) \
a, b, c, d, e, f, g, h
@@ -55,11 +55,11 @@
#define BYTES_TO_T_UINT_2( a, b ) \
a, b
-#elif defined(POLARSSL_HAVE_INT16)
+#elif defined(MBEDTLS_HAVE_INT16)
#define BYTES_TO_T_UINT_2( a, b ) \
- ( (t_uint) a << 0 ) | \
- ( (t_uint) b << 8 )
+ ( (mbedtls_mpi_uint) a << 0 ) | \
+ ( (mbedtls_mpi_uint) b << 8 )
#define BYTES_TO_T_UINT_4( a, b, c, d ) \
BYTES_TO_T_UINT_2( a, b ), \
@@ -71,13 +71,13 @@
BYTES_TO_T_UINT_2( e, f ), \
BYTES_TO_T_UINT_2( g, h )
-#elif defined(POLARSSL_HAVE_INT32)
+#elif defined(MBEDTLS_HAVE_INT32)
#define BYTES_TO_T_UINT_4( a, b, c, d ) \
- ( (t_uint) a << 0 ) | \
- ( (t_uint) b << 8 ) | \
- ( (t_uint) c << 16 ) | \
- ( (t_uint) d << 24 )
+ ( (mbedtls_mpi_uint) a << 0 ) | \
+ ( (mbedtls_mpi_uint) b << 8 ) | \
+ ( (mbedtls_mpi_uint) c << 16 ) | \
+ ( (mbedtls_mpi_uint) d << 24 )
#define BYTES_TO_T_UINT_2( a, b ) \
BYTES_TO_T_UINT_4( a, b, 0, 0 )
@@ -89,14 +89,14 @@
#else /* 64-bits */
#define BYTES_TO_T_UINT_8( a, b, c, d, e, f, g, h ) \
- ( (t_uint) a << 0 ) | \
- ( (t_uint) b << 8 ) | \
- ( (t_uint) c << 16 ) | \
- ( (t_uint) d << 24 ) | \
- ( (t_uint) e << 32 ) | \
- ( (t_uint) f << 40 ) | \
- ( (t_uint) g << 48 ) | \
- ( (t_uint) h << 56 )
+ ( (mbedtls_mpi_uint) a << 0 ) | \
+ ( (mbedtls_mpi_uint) b << 8 ) | \
+ ( (mbedtls_mpi_uint) c << 16 ) | \
+ ( (mbedtls_mpi_uint) d << 24 ) | \
+ ( (mbedtls_mpi_uint) e << 32 ) | \
+ ( (mbedtls_mpi_uint) f << 40 ) | \
+ ( (mbedtls_mpi_uint) g << 48 ) | \
+ ( (mbedtls_mpi_uint) h << 56 )
#define BYTES_TO_T_UINT_4( a, b, c, d ) \
BYTES_TO_T_UINT_8( a, b, c, d, 0, 0, 0, 0 )
@@ -104,7 +104,7 @@
#define BYTES_TO_T_UINT_2( a, b ) \
BYTES_TO_T_UINT_8( a, b, 0, 0, 0, 0, 0, 0 )
-#endif /* bits in t_uint */
+#endif /* bits in mbedtls_mpi_uint */
/*
* Note: the constants are in little-endian order
@@ -114,111 +114,111 @@
/*
* Domain parameters for secp192r1
*/
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
-static const t_uint secp192r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+static const mbedtls_mpi_uint secp192r1_p[] = {
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp192r1_b[] = {
+static const mbedtls_mpi_uint secp192r1_b[] = {
BYTES_TO_T_UINT_8( 0xB1, 0xB9, 0x46, 0xC1, 0xEC, 0xDE, 0xB8, 0xFE ),
BYTES_TO_T_UINT_8( 0x49, 0x30, 0x24, 0x72, 0xAB, 0xE9, 0xA7, 0x0F ),
BYTES_TO_T_UINT_8( 0xE7, 0x80, 0x9C, 0xE5, 0x19, 0x05, 0x21, 0x64 ),
};
-static const t_uint secp192r1_gx[] = {
+static const mbedtls_mpi_uint secp192r1_gx[] = {
BYTES_TO_T_UINT_8( 0x12, 0x10, 0xFF, 0x82, 0xFD, 0x0A, 0xFF, 0xF4 ),
BYTES_TO_T_UINT_8( 0x00, 0x88, 0xA1, 0x43, 0xEB, 0x20, 0xBF, 0x7C ),
BYTES_TO_T_UINT_8( 0xF6, 0x90, 0x30, 0xB0, 0x0E, 0xA8, 0x8D, 0x18 ),
};
-static const t_uint secp192r1_gy[] = {
+static const mbedtls_mpi_uint secp192r1_gy[] = {
BYTES_TO_T_UINT_8( 0x11, 0x48, 0x79, 0x1E, 0xA1, 0x77, 0xF9, 0x73 ),
BYTES_TO_T_UINT_8( 0xD5, 0xCD, 0x24, 0x6B, 0xED, 0x11, 0x10, 0x63 ),
BYTES_TO_T_UINT_8( 0x78, 0xDA, 0xC8, 0xFF, 0x95, 0x2B, 0x19, 0x07 ),
};
-static const t_uint secp192r1_n[] = {
+static const mbedtls_mpi_uint secp192r1_n[] = {
BYTES_TO_T_UINT_8( 0x31, 0x28, 0xD2, 0xB4, 0xB1, 0xC9, 0x6B, 0x14 ),
BYTES_TO_T_UINT_8( 0x36, 0xF8, 0xDE, 0x99, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP192R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
/*
* Domain parameters for secp224r1
*/
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
-static const t_uint secp224r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+static const mbedtls_mpi_uint secp224r1_p[] = {
BYTES_TO_T_UINT_8( 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 ),
};
-static const t_uint secp224r1_b[] = {
+static const mbedtls_mpi_uint secp224r1_b[] = {
BYTES_TO_T_UINT_8( 0xB4, 0xFF, 0x55, 0x23, 0x43, 0x39, 0x0B, 0x27 ),
BYTES_TO_T_UINT_8( 0xBA, 0xD8, 0xBF, 0xD7, 0xB7, 0xB0, 0x44, 0x50 ),
BYTES_TO_T_UINT_8( 0x56, 0x32, 0x41, 0xF5, 0xAB, 0xB3, 0x04, 0x0C ),
BYTES_TO_T_UINT_4( 0x85, 0x0A, 0x05, 0xB4 ),
};
-static const t_uint secp224r1_gx[] = {
+static const mbedtls_mpi_uint secp224r1_gx[] = {
BYTES_TO_T_UINT_8( 0x21, 0x1D, 0x5C, 0x11, 0xD6, 0x80, 0x32, 0x34 ),
BYTES_TO_T_UINT_8( 0x22, 0x11, 0xC2, 0x56, 0xD3, 0xC1, 0x03, 0x4A ),
BYTES_TO_T_UINT_8( 0xB9, 0x90, 0x13, 0x32, 0x7F, 0xBF, 0xB4, 0x6B ),
BYTES_TO_T_UINT_4( 0xBD, 0x0C, 0x0E, 0xB7 ),
};
-static const t_uint secp224r1_gy[] = {
+static const mbedtls_mpi_uint secp224r1_gy[] = {
BYTES_TO_T_UINT_8( 0x34, 0x7E, 0x00, 0x85, 0x99, 0x81, 0xD5, 0x44 ),
BYTES_TO_T_UINT_8( 0x64, 0x47, 0x07, 0x5A, 0xA0, 0x75, 0x43, 0xCD ),
BYTES_TO_T_UINT_8( 0xE6, 0xDF, 0x22, 0x4C, 0xFB, 0x23, 0xF7, 0xB5 ),
BYTES_TO_T_UINT_4( 0x88, 0x63, 0x37, 0xBD ),
};
-static const t_uint secp224r1_n[] = {
+static const mbedtls_mpi_uint secp224r1_n[] = {
BYTES_TO_T_UINT_8( 0x3D, 0x2A, 0x5C, 0x5C, 0x45, 0x29, 0xDD, 0x13 ),
BYTES_TO_T_UINT_8( 0x3E, 0xF0, 0xB8, 0xE0, 0xA2, 0x16, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_4( 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP224R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
/*
* Domain parameters for secp256r1
*/
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
-static const t_uint secp256r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+static const mbedtls_mpi_uint secp256r1_p[] = {
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ),
BYTES_TO_T_UINT_8( 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp256r1_b[] = {
+static const mbedtls_mpi_uint secp256r1_b[] = {
BYTES_TO_T_UINT_8( 0x4B, 0x60, 0xD2, 0x27, 0x3E, 0x3C, 0xCE, 0x3B ),
BYTES_TO_T_UINT_8( 0xF6, 0xB0, 0x53, 0xCC, 0xB0, 0x06, 0x1D, 0x65 ),
BYTES_TO_T_UINT_8( 0xBC, 0x86, 0x98, 0x76, 0x55, 0xBD, 0xEB, 0xB3 ),
BYTES_TO_T_UINT_8( 0xE7, 0x93, 0x3A, 0xAA, 0xD8, 0x35, 0xC6, 0x5A ),
};
-static const t_uint secp256r1_gx[] = {
+static const mbedtls_mpi_uint secp256r1_gx[] = {
BYTES_TO_T_UINT_8( 0x96, 0xC2, 0x98, 0xD8, 0x45, 0x39, 0xA1, 0xF4 ),
BYTES_TO_T_UINT_8( 0xA0, 0x33, 0xEB, 0x2D, 0x81, 0x7D, 0x03, 0x77 ),
BYTES_TO_T_UINT_8( 0xF2, 0x40, 0xA4, 0x63, 0xE5, 0xE6, 0xBC, 0xF8 ),
BYTES_TO_T_UINT_8( 0x47, 0x42, 0x2C, 0xE1, 0xF2, 0xD1, 0x17, 0x6B ),
};
-static const t_uint secp256r1_gy[] = {
+static const mbedtls_mpi_uint secp256r1_gy[] = {
BYTES_TO_T_UINT_8( 0xF5, 0x51, 0xBF, 0x37, 0x68, 0x40, 0xB6, 0xCB ),
BYTES_TO_T_UINT_8( 0xCE, 0x5E, 0x31, 0x6B, 0x57, 0x33, 0xCE, 0x2B ),
BYTES_TO_T_UINT_8( 0x16, 0x9E, 0x0F, 0x7C, 0x4A, 0xEB, 0xE7, 0x8E ),
BYTES_TO_T_UINT_8( 0x9B, 0x7F, 0x1A, 0xFE, 0xE2, 0x42, 0xE3, 0x4F ),
};
-static const t_uint secp256r1_n[] = {
+static const mbedtls_mpi_uint secp256r1_n[] = {
BYTES_TO_T_UINT_8( 0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3 ),
BYTES_TO_T_UINT_8( 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP256R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
/*
* Domain parameters for secp384r1
*/
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
-static const t_uint secp384r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+static const mbedtls_mpi_uint secp384r1_p[] = {
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
@@ -226,7 +226,7 @@
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp384r1_b[] = {
+static const mbedtls_mpi_uint secp384r1_b[] = {
BYTES_TO_T_UINT_8( 0xEF, 0x2A, 0xEC, 0xD3, 0xED, 0xC8, 0x85, 0x2A ),
BYTES_TO_T_UINT_8( 0x9D, 0xD1, 0x2E, 0x8A, 0x8D, 0x39, 0x56, 0xC6 ),
BYTES_TO_T_UINT_8( 0x5A, 0x87, 0x13, 0x50, 0x8F, 0x08, 0x14, 0x03 ),
@@ -234,7 +234,7 @@
BYTES_TO_T_UINT_8( 0x19, 0x2D, 0xF8, 0xE3, 0x6B, 0x05, 0x8E, 0x98 ),
BYTES_TO_T_UINT_8( 0xE4, 0xE7, 0x3E, 0xE2, 0xA7, 0x2F, 0x31, 0xB3 ),
};
-static const t_uint secp384r1_gx[] = {
+static const mbedtls_mpi_uint secp384r1_gx[] = {
BYTES_TO_T_UINT_8( 0xB7, 0x0A, 0x76, 0x72, 0x38, 0x5E, 0x54, 0x3A ),
BYTES_TO_T_UINT_8( 0x6C, 0x29, 0x55, 0xBF, 0x5D, 0xF2, 0x02, 0x55 ),
BYTES_TO_T_UINT_8( 0x38, 0x2A, 0x54, 0x82, 0xE0, 0x41, 0xF7, 0x59 ),
@@ -242,7 +242,7 @@
BYTES_TO_T_UINT_8( 0x74, 0xAD, 0x20, 0xF3, 0x1E, 0xC7, 0xB1, 0x8E ),
BYTES_TO_T_UINT_8( 0x37, 0x05, 0x8B, 0xBE, 0x22, 0xCA, 0x87, 0xAA ),
};
-static const t_uint secp384r1_gy[] = {
+static const mbedtls_mpi_uint secp384r1_gy[] = {
BYTES_TO_T_UINT_8( 0x5F, 0x0E, 0xEA, 0x90, 0x7C, 0x1D, 0x43, 0x7A ),
BYTES_TO_T_UINT_8( 0x9D, 0x81, 0x7E, 0x1D, 0xCE, 0xB1, 0x60, 0x0A ),
BYTES_TO_T_UINT_8( 0xC0, 0xB8, 0xF0, 0xB5, 0x13, 0x31, 0xDA, 0xE9 ),
@@ -250,7 +250,7 @@
BYTES_TO_T_UINT_8( 0x29, 0xDC, 0x92, 0x92, 0xBF, 0x98, 0x9E, 0x5D ),
BYTES_TO_T_UINT_8( 0x6F, 0x2C, 0x26, 0x96, 0x4A, 0xDE, 0x17, 0x36 ),
};
-static const t_uint secp384r1_n[] = {
+static const mbedtls_mpi_uint secp384r1_n[] = {
BYTES_TO_T_UINT_8( 0x73, 0x29, 0xC5, 0xCC, 0x6A, 0x19, 0xEC, 0xEC ),
BYTES_TO_T_UINT_8( 0x7A, 0xA7, 0xB0, 0x48, 0xB2, 0x0D, 0x1A, 0x58 ),
BYTES_TO_T_UINT_8( 0xDF, 0x2D, 0x37, 0xF4, 0x81, 0x4D, 0x63, 0xC7 ),
@@ -258,13 +258,13 @@
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
/*
* Domain parameters for secp521r1
*/
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
-static const t_uint secp521r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+static const mbedtls_mpi_uint secp521r1_p[] = {
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
@@ -275,7 +275,7 @@
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_2( 0xFF, 0x01 ),
};
-static const t_uint secp521r1_b[] = {
+static const mbedtls_mpi_uint secp521r1_b[] = {
BYTES_TO_T_UINT_8( 0x00, 0x3F, 0x50, 0x6B, 0xD4, 0x1F, 0x45, 0xEF ),
BYTES_TO_T_UINT_8( 0xF1, 0x34, 0x2C, 0x3D, 0x88, 0xDF, 0x73, 0x35 ),
BYTES_TO_T_UINT_8( 0x07, 0xBF, 0xB1, 0x3B, 0xBD, 0xC0, 0x52, 0x16 ),
@@ -286,7 +286,7 @@
BYTES_TO_T_UINT_8( 0x1F, 0x9A, 0x1C, 0x8E, 0x61, 0xB9, 0x3E, 0x95 ),
BYTES_TO_T_UINT_2( 0x51, 0x00 ),
};
-static const t_uint secp521r1_gx[] = {
+static const mbedtls_mpi_uint secp521r1_gx[] = {
BYTES_TO_T_UINT_8( 0x66, 0xBD, 0xE5, 0xC2, 0x31, 0x7E, 0x7E, 0xF9 ),
BYTES_TO_T_UINT_8( 0x9B, 0x42, 0x6A, 0x85, 0xC1, 0xB3, 0x48, 0x33 ),
BYTES_TO_T_UINT_8( 0xDE, 0xA8, 0xFF, 0xA2, 0x27, 0xC1, 0x1D, 0xFE ),
@@ -297,7 +297,7 @@
BYTES_TO_T_UINT_8( 0xCD, 0xE9, 0x04, 0x04, 0xB7, 0x06, 0x8E, 0x85 ),
BYTES_TO_T_UINT_2( 0xC6, 0x00 ),
};
-static const t_uint secp521r1_gy[] = {
+static const mbedtls_mpi_uint secp521r1_gy[] = {
BYTES_TO_T_UINT_8( 0x50, 0x66, 0xD1, 0x9F, 0x76, 0x94, 0xBE, 0x88 ),
BYTES_TO_T_UINT_8( 0x40, 0xC2, 0x72, 0xA2, 0x86, 0x70, 0x3C, 0x35 ),
BYTES_TO_T_UINT_8( 0x61, 0x07, 0xAD, 0x3F, 0x01, 0xB9, 0x50, 0xC5 ),
@@ -308,7 +308,7 @@
BYTES_TO_T_UINT_8( 0x04, 0xC0, 0x3B, 0x9A, 0x78, 0x6A, 0x29, 0x39 ),
BYTES_TO_T_UINT_2( 0x18, 0x01 ),
};
-static const t_uint secp521r1_n[] = {
+static const mbedtls_mpi_uint secp521r1_n[] = {
BYTES_TO_T_UINT_8( 0x09, 0x64, 0x38, 0x91, 0x1E, 0xB7, 0x6F, 0xBB ),
BYTES_TO_T_UINT_8( 0xAE, 0x47, 0x9C, 0x89, 0xB8, 0xC9, 0xB5, 0x3B ),
BYTES_TO_T_UINT_8( 0xD0, 0xA5, 0x09, 0xF7, 0x48, 0x01, 0xCC, 0x7F ),
@@ -319,150 +319,150 @@
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_2( 0xFF, 0x01 ),
};
-#endif /* POLARSSL_ECP_DP_SECP521R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
-static const t_uint secp192k1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
+static const mbedtls_mpi_uint secp192k1_p[] = {
BYTES_TO_T_UINT_8( 0x37, 0xEE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp192k1_a[] = {
+static const mbedtls_mpi_uint secp192k1_a[] = {
BYTES_TO_T_UINT_2( 0x00, 0x00 ),
};
-static const t_uint secp192k1_b[] = {
+static const mbedtls_mpi_uint secp192k1_b[] = {
BYTES_TO_T_UINT_2( 0x03, 0x00 ),
};
-static const t_uint secp192k1_gx[] = {
+static const mbedtls_mpi_uint secp192k1_gx[] = {
BYTES_TO_T_UINT_8( 0x7D, 0x6C, 0xE0, 0xEA, 0xB1, 0xD1, 0xA5, 0x1D ),
BYTES_TO_T_UINT_8( 0x34, 0xF4, 0xB7, 0x80, 0x02, 0x7D, 0xB0, 0x26 ),
BYTES_TO_T_UINT_8( 0xAE, 0xE9, 0x57, 0xC0, 0x0E, 0xF1, 0x4F, 0xDB ),
};
-static const t_uint secp192k1_gy[] = {
+static const mbedtls_mpi_uint secp192k1_gy[] = {
BYTES_TO_T_UINT_8( 0x9D, 0x2F, 0x5E, 0xD9, 0x88, 0xAA, 0x82, 0x40 ),
BYTES_TO_T_UINT_8( 0x34, 0x86, 0xBE, 0x15, 0xD0, 0x63, 0x41, 0x84 ),
BYTES_TO_T_UINT_8( 0xA7, 0x28, 0x56, 0x9C, 0x6D, 0x2F, 0x2F, 0x9B ),
};
-static const t_uint secp192k1_n[] = {
+static const mbedtls_mpi_uint secp192k1_n[] = {
BYTES_TO_T_UINT_8( 0x8D, 0xFD, 0xDE, 0x74, 0x6A, 0x46, 0x69, 0x0F ),
BYTES_TO_T_UINT_8( 0x17, 0xFC, 0xF2, 0x26, 0xFE, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP192K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
-static const t_uint secp224k1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
+static const mbedtls_mpi_uint secp224k1_p[] = {
BYTES_TO_T_UINT_8( 0x6D, 0xE5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_4( 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp224k1_a[] = {
+static const mbedtls_mpi_uint secp224k1_a[] = {
BYTES_TO_T_UINT_2( 0x00, 0x00 ),
};
-static const t_uint secp224k1_b[] = {
+static const mbedtls_mpi_uint secp224k1_b[] = {
BYTES_TO_T_UINT_2( 0x05, 0x00 ),
};
-static const t_uint secp224k1_gx[] = {
+static const mbedtls_mpi_uint secp224k1_gx[] = {
BYTES_TO_T_UINT_8( 0x5C, 0xA4, 0xB7, 0xB6, 0x0E, 0x65, 0x7E, 0x0F ),
BYTES_TO_T_UINT_8( 0xA9, 0x75, 0x70, 0xE4, 0xE9, 0x67, 0xA4, 0x69 ),
BYTES_TO_T_UINT_8( 0xA1, 0x28, 0xFC, 0x30, 0xDF, 0x99, 0xF0, 0x4D ),
BYTES_TO_T_UINT_4( 0x33, 0x5B, 0x45, 0xA1 ),
};
-static const t_uint secp224k1_gy[] = {
+static const mbedtls_mpi_uint secp224k1_gy[] = {
BYTES_TO_T_UINT_8( 0xA5, 0x61, 0x6D, 0x55, 0xDB, 0x4B, 0xCA, 0xE2 ),
BYTES_TO_T_UINT_8( 0x59, 0xBD, 0xB0, 0xC0, 0xF7, 0x19, 0xE3, 0xF7 ),
BYTES_TO_T_UINT_8( 0xD6, 0xFB, 0xCA, 0x82, 0x42, 0x34, 0xBA, 0x7F ),
BYTES_TO_T_UINT_4( 0xED, 0x9F, 0x08, 0x7E ),
};
-static const t_uint secp224k1_n[] = {
+static const mbedtls_mpi_uint secp224k1_n[] = {
BYTES_TO_T_UINT_8( 0xF7, 0xB1, 0x9F, 0x76, 0x71, 0xA9, 0xF0, 0xCA ),
BYTES_TO_T_UINT_8( 0x84, 0x61, 0xEC, 0xD2, 0xE8, 0xDC, 0x01, 0x00 ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ),
BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ),
};
-#endif /* POLARSSL_ECP_DP_SECP224K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
-static const t_uint secp256k1_p[] = {
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+static const mbedtls_mpi_uint secp256k1_p[] = {
BYTES_TO_T_UINT_8( 0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-static const t_uint secp256k1_a[] = {
+static const mbedtls_mpi_uint secp256k1_a[] = {
BYTES_TO_T_UINT_2( 0x00, 0x00 ),
};
-static const t_uint secp256k1_b[] = {
+static const mbedtls_mpi_uint secp256k1_b[] = {
BYTES_TO_T_UINT_2( 0x07, 0x00 ),
};
-static const t_uint secp256k1_gx[] = {
+static const mbedtls_mpi_uint secp256k1_gx[] = {
BYTES_TO_T_UINT_8( 0x98, 0x17, 0xF8, 0x16, 0x5B, 0x81, 0xF2, 0x59 ),
BYTES_TO_T_UINT_8( 0xD9, 0x28, 0xCE, 0x2D, 0xDB, 0xFC, 0x9B, 0x02 ),
BYTES_TO_T_UINT_8( 0x07, 0x0B, 0x87, 0xCE, 0x95, 0x62, 0xA0, 0x55 ),
BYTES_TO_T_UINT_8( 0xAC, 0xBB, 0xDC, 0xF9, 0x7E, 0x66, 0xBE, 0x79 ),
};
-static const t_uint secp256k1_gy[] = {
+static const mbedtls_mpi_uint secp256k1_gy[] = {
BYTES_TO_T_UINT_8( 0xB8, 0xD4, 0x10, 0xFB, 0x8F, 0xD0, 0x47, 0x9C ),
BYTES_TO_T_UINT_8( 0x19, 0x54, 0x85, 0xA6, 0x48, 0xB4, 0x17, 0xFD ),
BYTES_TO_T_UINT_8( 0xA8, 0x08, 0x11, 0x0E, 0xFC, 0xFB, 0xA4, 0x5D ),
BYTES_TO_T_UINT_8( 0x65, 0xC4, 0xA3, 0x26, 0x77, 0xDA, 0x3A, 0x48 ),
};
-static const t_uint secp256k1_n[] = {
+static const mbedtls_mpi_uint secp256k1_n[] = {
BYTES_TO_T_UINT_8( 0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF ),
BYTES_TO_T_UINT_8( 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA ),
BYTES_TO_T_UINT_8( 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),
};
-#endif /* POLARSSL_ECP_DP_SECP256K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
/*
* Domain parameters for brainpoolP256r1 (RFC 5639 3.4)
*/
-#if defined(POLARSSL_ECP_DP_BP256R1_ENABLED)
-static const t_uint brainpoolP256r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
+static const mbedtls_mpi_uint brainpoolP256r1_p[] = {
BYTES_TO_T_UINT_8( 0x77, 0x53, 0x6E, 0x1F, 0x1D, 0x48, 0x13, 0x20 ),
BYTES_TO_T_UINT_8( 0x28, 0x20, 0x26, 0xD5, 0x23, 0xF6, 0x3B, 0x6E ),
BYTES_TO_T_UINT_8( 0x72, 0x8D, 0x83, 0x9D, 0x90, 0x0A, 0x66, 0x3E ),
BYTES_TO_T_UINT_8( 0xBC, 0xA9, 0xEE, 0xA1, 0xDB, 0x57, 0xFB, 0xA9 ),
};
-static const t_uint brainpoolP256r1_a[] = {
+static const mbedtls_mpi_uint brainpoolP256r1_a[] = {
BYTES_TO_T_UINT_8( 0xD9, 0xB5, 0x30, 0xF3, 0x44, 0x4B, 0x4A, 0xE9 ),
BYTES_TO_T_UINT_8( 0x6C, 0x5C, 0xDC, 0x26, 0xC1, 0x55, 0x80, 0xFB ),
BYTES_TO_T_UINT_8( 0xE7, 0xFF, 0x7A, 0x41, 0x30, 0x75, 0xF6, 0xEE ),
BYTES_TO_T_UINT_8( 0x57, 0x30, 0x2C, 0xFC, 0x75, 0x09, 0x5A, 0x7D ),
};
-static const t_uint brainpoolP256r1_b[] = {
+static const mbedtls_mpi_uint brainpoolP256r1_b[] = {
BYTES_TO_T_UINT_8( 0xB6, 0x07, 0x8C, 0xFF, 0x18, 0xDC, 0xCC, 0x6B ),
BYTES_TO_T_UINT_8( 0xCE, 0xE1, 0xF7, 0x5C, 0x29, 0x16, 0x84, 0x95 ),
BYTES_TO_T_UINT_8( 0xBF, 0x7C, 0xD7, 0xBB, 0xD9, 0xB5, 0x30, 0xF3 ),
BYTES_TO_T_UINT_8( 0x44, 0x4B, 0x4A, 0xE9, 0x6C, 0x5C, 0xDC, 0x26 ),
};
-static const t_uint brainpoolP256r1_gx[] = {
+static const mbedtls_mpi_uint brainpoolP256r1_gx[] = {
BYTES_TO_T_UINT_8( 0x62, 0x32, 0xCE, 0x9A, 0xBD, 0x53, 0x44, 0x3A ),
BYTES_TO_T_UINT_8( 0xC2, 0x23, 0xBD, 0xE3, 0xE1, 0x27, 0xDE, 0xB9 ),
BYTES_TO_T_UINT_8( 0xAF, 0xB7, 0x81, 0xFC, 0x2F, 0x48, 0x4B, 0x2C ),
BYTES_TO_T_UINT_8( 0xCB, 0x57, 0x7E, 0xCB, 0xB9, 0xAE, 0xD2, 0x8B ),
};
-static const t_uint brainpoolP256r1_gy[] = {
+static const mbedtls_mpi_uint brainpoolP256r1_gy[] = {
BYTES_TO_T_UINT_8( 0x97, 0x69, 0x04, 0x2F, 0xC7, 0x54, 0x1D, 0x5C ),
BYTES_TO_T_UINT_8( 0x54, 0x8E, 0xED, 0x2D, 0x13, 0x45, 0x77, 0xC2 ),
BYTES_TO_T_UINT_8( 0xC9, 0x1D, 0x61, 0x14, 0x1A, 0x46, 0xF8, 0x97 ),
BYTES_TO_T_UINT_8( 0xFD, 0xC4, 0xDA, 0xC3, 0x35, 0xF8, 0x7E, 0x54 ),
};
-static const t_uint brainpoolP256r1_n[] = {
+static const mbedtls_mpi_uint brainpoolP256r1_n[] = {
BYTES_TO_T_UINT_8( 0xA7, 0x56, 0x48, 0x97, 0x82, 0x0E, 0x1E, 0x90 ),
BYTES_TO_T_UINT_8( 0xF7, 0xA6, 0x61, 0xB5, 0xA3, 0x7A, 0x39, 0x8C ),
BYTES_TO_T_UINT_8( 0x71, 0x8D, 0x83, 0x9D, 0x90, 0x0A, 0x66, 0x3E ),
BYTES_TO_T_UINT_8( 0xBC, 0xA9, 0xEE, 0xA1, 0xDB, 0x57, 0xFB, 0xA9 ),
};
-#endif /* POLARSSL_ECP_DP_BP256R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
/*
* Domain parameters for brainpoolP384r1 (RFC 5639 3.6)
*/
-#if defined(POLARSSL_ECP_DP_BP384R1_ENABLED)
-static const t_uint brainpoolP384r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
+static const mbedtls_mpi_uint brainpoolP384r1_p[] = {
BYTES_TO_T_UINT_8( 0x53, 0xEC, 0x07, 0x31, 0x13, 0x00, 0x47, 0x87 ),
BYTES_TO_T_UINT_8( 0x71, 0x1A, 0x1D, 0x90, 0x29, 0xA7, 0xD3, 0xAC ),
BYTES_TO_T_UINT_8( 0x23, 0x11, 0xB7, 0x7F, 0x19, 0xDA, 0xB1, 0x12 ),
@@ -470,7 +470,7 @@
BYTES_TO_T_UINT_8( 0xDF, 0x41, 0xE6, 0x50, 0x7E, 0x6F, 0x5D, 0x0F ),
BYTES_TO_T_UINT_8( 0x28, 0x6D, 0x38, 0xA3, 0x82, 0x1E, 0xB9, 0x8C ),
};
-static const t_uint brainpoolP384r1_a[] = {
+static const mbedtls_mpi_uint brainpoolP384r1_a[] = {
BYTES_TO_T_UINT_8( 0x26, 0x28, 0xCE, 0x22, 0xDD, 0xC7, 0xA8, 0x04 ),
BYTES_TO_T_UINT_8( 0xEB, 0xD4, 0x3A, 0x50, 0x4A, 0x81, 0xA5, 0x8A ),
BYTES_TO_T_UINT_8( 0x0F, 0xF9, 0x91, 0xBA, 0xEF, 0x65, 0x91, 0x13 ),
@@ -478,7 +478,7 @@
BYTES_TO_T_UINT_8( 0xA0, 0xAF, 0x05, 0xCE, 0x0A, 0x08, 0x72, 0x3C ),
BYTES_TO_T_UINT_8( 0x0C, 0x15, 0x8C, 0x3D, 0xC6, 0x82, 0xC3, 0x7B ),
};
-static const t_uint brainpoolP384r1_b[] = {
+static const mbedtls_mpi_uint brainpoolP384r1_b[] = {
BYTES_TO_T_UINT_8( 0x11, 0x4C, 0x50, 0xFA, 0x96, 0x86, 0xB7, 0x3A ),
BYTES_TO_T_UINT_8( 0x94, 0xC9, 0xDB, 0x95, 0x02, 0x39, 0xB4, 0x7C ),
BYTES_TO_T_UINT_8( 0xD5, 0x62, 0xEB, 0x3E, 0xA5, 0x0E, 0x88, 0x2E ),
@@ -486,7 +486,7 @@
BYTES_TO_T_UINT_8( 0x7C, 0x44, 0xF0, 0x16, 0x54, 0xB5, 0x39, 0x8B ),
BYTES_TO_T_UINT_8( 0x26, 0x28, 0xCE, 0x22, 0xDD, 0xC7, 0xA8, 0x04 ),
};
-static const t_uint brainpoolP384r1_gx[] = {
+static const mbedtls_mpi_uint brainpoolP384r1_gx[] = {
BYTES_TO_T_UINT_8( 0x1E, 0xAF, 0xD4, 0x47, 0xE2, 0xB2, 0x87, 0xEF ),
BYTES_TO_T_UINT_8( 0xAA, 0x46, 0xD6, 0x36, 0x34, 0xE0, 0x26, 0xE8 ),
BYTES_TO_T_UINT_8( 0xE8, 0x10, 0xBD, 0x0C, 0xFE, 0xCA, 0x7F, 0xDB ),
@@ -494,7 +494,7 @@
BYTES_TO_T_UINT_8( 0x6B, 0x3F, 0xC1, 0xB7, 0x81, 0x3A, 0xA6, 0xA2 ),
BYTES_TO_T_UINT_8( 0xFF, 0x45, 0xCF, 0x68, 0xF0, 0x64, 0x1C, 0x1D ),
};
-static const t_uint brainpoolP384r1_gy[] = {
+static const mbedtls_mpi_uint brainpoolP384r1_gy[] = {
BYTES_TO_T_UINT_8( 0x15, 0x53, 0x3C, 0x26, 0x41, 0x03, 0x82, 0x42 ),
BYTES_TO_T_UINT_8( 0x11, 0x81, 0x91, 0x77, 0x21, 0x46, 0x46, 0x0E ),
BYTES_TO_T_UINT_8( 0x28, 0x29, 0x91, 0xF9, 0x4F, 0x05, 0x9C, 0xE1 ),
@@ -502,7 +502,7 @@
BYTES_TO_T_UINT_8( 0x52, 0xD5, 0xCF, 0x95, 0x8E, 0xEB, 0xB1, 0x5C ),
BYTES_TO_T_UINT_8( 0xA4, 0xC2, 0xF9, 0x20, 0x75, 0x1D, 0xBE, 0x8A ),
};
-static const t_uint brainpoolP384r1_n[] = {
+static const mbedtls_mpi_uint brainpoolP384r1_n[] = {
BYTES_TO_T_UINT_8( 0x65, 0x65, 0x04, 0xE9, 0x02, 0x32, 0x88, 0x3B ),
BYTES_TO_T_UINT_8( 0x10, 0xC3, 0x7F, 0x6B, 0xAF, 0xB6, 0x3A, 0xCF ),
BYTES_TO_T_UINT_8( 0xA7, 0x25, 0x04, 0xAC, 0x6C, 0x6E, 0x16, 0x1F ),
@@ -510,13 +510,13 @@
BYTES_TO_T_UINT_8( 0xDF, 0x41, 0xE6, 0x50, 0x7E, 0x6F, 0x5D, 0x0F ),
BYTES_TO_T_UINT_8( 0x28, 0x6D, 0x38, 0xA3, 0x82, 0x1E, 0xB9, 0x8C ),
};
-#endif /* POLARSSL_ECP_DP_BP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
/*
* Domain parameters for brainpoolP512r1 (RFC 5639 3.7)
*/
-#if defined(POLARSSL_ECP_DP_BP512R1_ENABLED)
-static const t_uint brainpoolP512r1_p[] = {
+#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
+static const mbedtls_mpi_uint brainpoolP512r1_p[] = {
BYTES_TO_T_UINT_8( 0xF3, 0x48, 0x3A, 0x58, 0x56, 0x60, 0xAA, 0x28 ),
BYTES_TO_T_UINT_8( 0x85, 0xC6, 0x82, 0x2D, 0x2F, 0xFF, 0x81, 0x28 ),
BYTES_TO_T_UINT_8( 0xE6, 0x80, 0xA3, 0xE6, 0x2A, 0xA1, 0xCD, 0xAE ),
@@ -526,7 +526,7 @@
BYTES_TO_T_UINT_8( 0x07, 0xFC, 0xC9, 0x33, 0xAE, 0xE6, 0xD4, 0x3F ),
BYTES_TO_T_UINT_8( 0x8B, 0xC4, 0xE9, 0xDB, 0xB8, 0x9D, 0xDD, 0xAA ),
};
-static const t_uint brainpoolP512r1_a[] = {
+static const mbedtls_mpi_uint brainpoolP512r1_a[] = {
BYTES_TO_T_UINT_8( 0xCA, 0x94, 0xFC, 0x77, 0x4D, 0xAC, 0xC1, 0xE7 ),
BYTES_TO_T_UINT_8( 0xB9, 0xC7, 0xF2, 0x2B, 0xA7, 0x17, 0x11, 0x7F ),
BYTES_TO_T_UINT_8( 0xB5, 0xC8, 0x9A, 0x8B, 0xC9, 0xF1, 0x2E, 0x0A ),
@@ -536,7 +536,7 @@
BYTES_TO_T_UINT_8( 0xC5, 0x4C, 0x23, 0xAC, 0x45, 0x71, 0x32, 0xE2 ),
BYTES_TO_T_UINT_8( 0x89, 0x3B, 0x60, 0x8B, 0x31, 0xA3, 0x30, 0x78 ),
};
-static const t_uint brainpoolP512r1_b[] = {
+static const mbedtls_mpi_uint brainpoolP512r1_b[] = {
BYTES_TO_T_UINT_8( 0x23, 0xF7, 0x16, 0x80, 0x63, 0xBD, 0x09, 0x28 ),
BYTES_TO_T_UINT_8( 0xDD, 0xE5, 0xBA, 0x5E, 0xB7, 0x50, 0x40, 0x98 ),
BYTES_TO_T_UINT_8( 0x67, 0x3E, 0x08, 0xDC, 0xCA, 0x94, 0xFC, 0x77 ),
@@ -546,7 +546,7 @@
BYTES_TO_T_UINT_8( 0x5A, 0x5D, 0xED, 0x2D, 0xBC, 0x63, 0x98, 0xEA ),
BYTES_TO_T_UINT_8( 0xCA, 0x41, 0x34, 0xA8, 0x10, 0x16, 0xF9, 0x3D ),
};
-static const t_uint brainpoolP512r1_gx[] = {
+static const mbedtls_mpi_uint brainpoolP512r1_gx[] = {
BYTES_TO_T_UINT_8( 0x22, 0xF8, 0xB9, 0xBC, 0x09, 0x22, 0x35, 0x8B ),
BYTES_TO_T_UINT_8( 0x68, 0x5E, 0x6A, 0x40, 0x47, 0x50, 0x6D, 0x7C ),
BYTES_TO_T_UINT_8( 0x5F, 0x7D, 0xB9, 0x93, 0x7B, 0x68, 0xD1, 0x50 ),
@@ -556,7 +556,7 @@
BYTES_TO_T_UINT_8( 0x93, 0x6A, 0x4C, 0x9C, 0x2E, 0x32, 0x21, 0x5A ),
BYTES_TO_T_UINT_8( 0x64, 0xD9, 0x2E, 0xD8, 0xBD, 0xE4, 0xAE, 0x81 ),
};
-static const t_uint brainpoolP512r1_gy[] = {
+static const mbedtls_mpi_uint brainpoolP512r1_gy[] = {
BYTES_TO_T_UINT_8( 0x92, 0x08, 0xD8, 0x3A, 0x0F, 0x1E, 0xCD, 0x78 ),
BYTES_TO_T_UINT_8( 0x06, 0x54, 0xF0, 0xA8, 0x2F, 0x2B, 0xCA, 0xD1 ),
BYTES_TO_T_UINT_8( 0xAE, 0x63, 0x27, 0x8A, 0xD8, 0x4B, 0xCA, 0x5B ),
@@ -566,7 +566,7 @@
BYTES_TO_T_UINT_8( 0xFD, 0x22, 0x78, 0xCF, 0xA9, 0xBF, 0xEA, 0xC0 ),
BYTES_TO_T_UINT_8( 0xEC, 0x32, 0x63, 0x56, 0x5D, 0x38, 0xDE, 0x7D ),
};
-static const t_uint brainpoolP512r1_n[] = {
+static const mbedtls_mpi_uint brainpoolP512r1_n[] = {
BYTES_TO_T_UINT_8( 0x69, 0x00, 0xA9, 0x9C, 0x82, 0x96, 0x87, 0xB5 ),
BYTES_TO_T_UINT_8( 0xDD, 0xDA, 0x5D, 0x08, 0x81, 0xD3, 0xB1, 0x1D ),
BYTES_TO_T_UINT_8( 0x47, 0x10, 0xAC, 0x7F, 0x19, 0x61, 0x86, 0x41 ),
@@ -576,25 +576,25 @@
BYTES_TO_T_UINT_8( 0x07, 0xFC, 0xC9, 0x33, 0xAE, 0xE6, 0xD4, 0x3F ),
BYTES_TO_T_UINT_8( 0x8B, 0xC4, 0xE9, 0xDB, 0xB8, 0x9D, 0xDD, 0xAA ),
};
-#endif /* POLARSSL_ECP_DP_BP512R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
/*
* Create an MPI from embedded constants
- * (assumes len is an exact multiple of sizeof t_uint)
+ * (assumes len is an exact multiple of sizeof mbedtls_mpi_uint)
*/
-static inline void ecp_mpi_load( mpi *X, const t_uint *p, size_t len )
+static inline void ecp_mpi_load( mbedtls_mpi *X, const mbedtls_mpi_uint *p, size_t len )
{
X->s = 1;
- X->n = len / sizeof( t_uint );
- X->p = (t_uint *) p;
+ X->n = len / sizeof( mbedtls_mpi_uint );
+ X->p = (mbedtls_mpi_uint *) p;
}
/*
* Set an MPI to static value 1
*/
-static inline void ecp_mpi_set1( mpi *X )
+static inline void ecp_mpi_set1( mbedtls_mpi *X )
{
- static t_uint one[] = { 1 };
+ static mbedtls_mpi_uint one[] = { 1 };
X->s = 1;
X->n = 1;
X->p = one;
@@ -603,13 +603,13 @@
/*
* Make group available from embedded constants
*/
-static int ecp_group_load( ecp_group *grp,
- const t_uint *p, size_t plen,
- const t_uint *a, size_t alen,
- const t_uint *b, size_t blen,
- const t_uint *gx, size_t gxlen,
- const t_uint *gy, size_t gylen,
- const t_uint *n, size_t nlen)
+static int ecp_group_load( mbedtls_ecp_group *grp,
+ const mbedtls_mpi_uint *p, size_t plen,
+ const mbedtls_mpi_uint *a, size_t alen,
+ const mbedtls_mpi_uint *b, size_t blen,
+ const mbedtls_mpi_uint *gx, size_t gxlen,
+ const mbedtls_mpi_uint *gy, size_t gylen,
+ const mbedtls_mpi_uint *n, size_t nlen)
{
ecp_mpi_load( &grp->P, p, plen );
if( a != NULL )
@@ -621,49 +621,49 @@
ecp_mpi_load( &grp->G.Y, gy, gylen );
ecp_mpi_set1( &grp->G.Z );
- grp->pbits = mpi_msb( &grp->P );
- grp->nbits = mpi_msb( &grp->N );
+ grp->pbits = mbedtls_mpi_msb( &grp->P );
+ grp->nbits = mbedtls_mpi_msb( &grp->N );
grp->h = 1;
return( 0 );
}
-#if defined(POLARSSL_ECP_NIST_OPTIM)
+#if defined(MBEDTLS_ECP_NIST_OPTIM)
/* Forward declarations */
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
-static int ecp_mod_p192( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+static int ecp_mod_p192( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
-static int ecp_mod_p224( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+static int ecp_mod_p224( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
-static int ecp_mod_p256( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+static int ecp_mod_p256( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
-static int ecp_mod_p384( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+static int ecp_mod_p384( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
-static int ecp_mod_p521( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+static int ecp_mod_p521( mbedtls_mpi * );
#endif
#define NIST_MODP( P ) grp->modp = ecp_mod_ ## P;
#else
#define NIST_MODP( P )
-#endif /* POLARSSL_ECP_NIST_OPTIM */
+#endif /* MBEDTLS_ECP_NIST_OPTIM */
/* Additional forward declarations */
-#if defined(POLARSSL_ECP_DP_M255_ENABLED)
-static int ecp_mod_p255( mpi * );
+#if defined(MBEDTLS_ECP_DP_M255_ENABLED)
+static int ecp_mod_p255( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
-static int ecp_mod_p192k1( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
+static int ecp_mod_p192k1( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
-static int ecp_mod_p224k1( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
+static int ecp_mod_p224k1( mbedtls_mpi * );
#endif
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
-static int ecp_mod_p256k1( mpi * );
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+static int ecp_mod_p256k1( mbedtls_mpi * );
#endif
#define LOAD_GROUP_A( G ) ecp_group_load( grp, \
@@ -682,127 +682,127 @@
G ## _gy, sizeof( G ## _gy ), \
G ## _n, sizeof( G ## _n ) )
-#if defined(POLARSSL_ECP_DP_M255_ENABLED)
+#if defined(MBEDTLS_ECP_DP_M255_ENABLED)
/*
* Specialized function for creating the Curve25519 group
*/
-static int ecp_use_curve25519( ecp_group *grp )
+static int ecp_use_curve25519( mbedtls_ecp_group *grp )
{
int ret;
/* Actually ( A + 2 ) / 4 */
- MPI_CHK( mpi_read_string( &grp->A, 16, "01DB42" ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &grp->A, 16, "01DB42" ) );
/* P = 2^255 - 19 */
- MPI_CHK( mpi_lset( &grp->P, 1 ) );
- MPI_CHK( mpi_shift_l( &grp->P, 255 ) );
- MPI_CHK( mpi_sub_int( &grp->P, &grp->P, 19 ) );
- grp->pbits = mpi_msb( &grp->P );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &grp->P, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &grp->P, 255 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &grp->P, &grp->P, 19 ) );
+ grp->pbits = mbedtls_mpi_msb( &grp->P );
/* Y intentionaly not set, since we use x/z coordinates.
* This is used as a marker to identify Montgomery curves! */
- MPI_CHK( mpi_lset( &grp->G.X, 9 ) );
- MPI_CHK( mpi_lset( &grp->G.Z, 1 ) );
- mpi_free( &grp->G.Y );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &grp->G.X, 9 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &grp->G.Z, 1 ) );
+ mbedtls_mpi_free( &grp->G.Y );
/* Actually, the required msb for private keys */
grp->nbits = 254;
cleanup:
if( ret != 0 )
- ecp_group_free( grp );
+ mbedtls_ecp_group_free( grp );
return( ret );
}
-#endif /* POLARSSL_ECP_DP_M255_ENABLED */
+#endif /* MBEDTLS_ECP_DP_M255_ENABLED */
/*
* Set a group using well-known domain parameters
*/
-int ecp_use_known_dp( ecp_group *grp, ecp_group_id id )
+int mbedtls_ecp_use_known_dp( mbedtls_ecp_group *grp, mbedtls_ecp_group_id id )
{
- ecp_group_free( grp );
+ mbedtls_ecp_group_free( grp );
grp->id = id;
switch( id )
{
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
- case POLARSSL_ECP_DP_SECP192R1:
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP192R1:
NIST_MODP( p192 );
return( LOAD_GROUP( secp192r1 ) );
-#endif /* POLARSSL_ECP_DP_SECP192R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
- case POLARSSL_ECP_DP_SECP224R1:
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP224R1:
NIST_MODP( p224 );
return( LOAD_GROUP( secp224r1 ) );
-#endif /* POLARSSL_ECP_DP_SECP224R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
- case POLARSSL_ECP_DP_SECP256R1:
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP256R1:
NIST_MODP( p256 );
return( LOAD_GROUP( secp256r1 ) );
-#endif /* POLARSSL_ECP_DP_SECP256R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
- case POLARSSL_ECP_DP_SECP384R1:
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP384R1:
NIST_MODP( p384 );
return( LOAD_GROUP( secp384r1 ) );
-#endif /* POLARSSL_ECP_DP_SECP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
- case POLARSSL_ECP_DP_SECP521R1:
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP521R1:
NIST_MODP( p521 );
return( LOAD_GROUP( secp521r1 ) );
-#endif /* POLARSSL_ECP_DP_SECP521R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
- case POLARSSL_ECP_DP_SECP192K1:
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP192K1:
grp->modp = ecp_mod_p192k1;
return( LOAD_GROUP_A( secp192k1 ) );
-#endif /* POLARSSL_ECP_DP_SECP192K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
- case POLARSSL_ECP_DP_SECP224K1:
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP224K1:
grp->modp = ecp_mod_p224k1;
return( LOAD_GROUP_A( secp224k1 ) );
-#endif /* POLARSSL_ECP_DP_SECP224K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
- case POLARSSL_ECP_DP_SECP256K1:
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+ case MBEDTLS_ECP_DP_SECP256K1:
grp->modp = ecp_mod_p256k1;
return( LOAD_GROUP_A( secp256k1 ) );
-#endif /* POLARSSL_ECP_DP_SECP256K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP256R1_ENABLED)
- case POLARSSL_ECP_DP_BP256R1:
+#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
+ case MBEDTLS_ECP_DP_BP256R1:
return( LOAD_GROUP_A( brainpoolP256r1 ) );
-#endif /* POLARSSL_ECP_DP_BP256R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP384R1_ENABLED)
- case POLARSSL_ECP_DP_BP384R1:
+#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
+ case MBEDTLS_ECP_DP_BP384R1:
return( LOAD_GROUP_A( brainpoolP384r1 ) );
-#endif /* POLARSSL_ECP_DP_BP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP512R1_ENABLED)
- case POLARSSL_ECP_DP_BP512R1:
+#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
+ case MBEDTLS_ECP_DP_BP512R1:
return( LOAD_GROUP_A( brainpoolP512r1 ) );
-#endif /* POLARSSL_ECP_DP_BP512R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_M255_ENABLED)
- case POLARSSL_ECP_DP_M255:
+#if defined(MBEDTLS_ECP_DP_M255_ENABLED)
+ case MBEDTLS_ECP_DP_M255:
grp->modp = ecp_mod_p255;
return( ecp_use_curve25519( grp ) );
-#endif /* POLARSSL_ECP_DP_M255_ENABLED */
+#endif /* MBEDTLS_ECP_DP_M255_ENABLED */
default:
- ecp_group_free( grp );
- return( POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE );
+ mbedtls_ecp_group_free( grp );
+ return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
}
}
-#if defined(POLARSSL_ECP_NIST_OPTIM)
+#if defined(MBEDTLS_ECP_NIST_OPTIM)
/*
* Fast reduction modulo the primes used by the NIST curves.
*
@@ -813,7 +813,7 @@
* MPI remains loose, since these functions can be deactivated at will.
*/
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
/*
* Compared to the way things are presented in FIPS 186-3 D.2,
* we proceed in columns, from right (least significant chunk) to left,
@@ -822,16 +822,16 @@
* compared to the more straightforward, line-oriented approach.
*
* For this prime we need to handle data in chunks of 64 bits.
- * Since this is always a multiple of our basic t_uint, we can
- * use a t_uint * to designate such a chunk, and small loops to handle it.
+ * Since this is always a multiple of our basic mbedtls_mpi_uint, we can
+ * use a mbedtls_mpi_uint * to designate such a chunk, and small loops to handle it.
*/
/* Add 64-bit chunks (dst += src) and update carry */
-static inline void add64( t_uint *dst, t_uint *src, t_uint *carry )
+static inline void add64( mbedtls_mpi_uint *dst, mbedtls_mpi_uint *src, mbedtls_mpi_uint *carry )
{
unsigned char i;
- t_uint c = 0;
- for( i = 0; i < 8 / sizeof( t_uint ); i++, dst++, src++ )
+ mbedtls_mpi_uint c = 0;
+ for( i = 0; i < 8 / sizeof( mbedtls_mpi_uint ); i++, dst++, src++ )
{
*dst += c; c = ( *dst < c );
*dst += *src; c += ( *dst < *src );
@@ -840,17 +840,17 @@
}
/* Add carry to a 64-bit chunk and update carry */
-static inline void carry64( t_uint *dst, t_uint *carry )
+static inline void carry64( mbedtls_mpi_uint *dst, mbedtls_mpi_uint *carry )
{
unsigned char i;
- for( i = 0; i < 8 / sizeof( t_uint ); i++, dst++ )
+ for( i = 0; i < 8 / sizeof( mbedtls_mpi_uint ); i++, dst++ )
{
*dst += *carry;
*carry = ( *dst < *carry );
}
}
-#define WIDTH 8 / sizeof( t_uint )
+#define WIDTH 8 / sizeof( mbedtls_mpi_uint )
#define A( i ) N->p + i * WIDTH
#define ADD( i ) add64( p, A( i ), &c )
#define NEXT p += WIDTH; carry64( p, &c )
@@ -859,14 +859,14 @@
/*
* Fast quasi-reduction modulo p192 (FIPS 186-3 D.2.1)
*/
-static int ecp_mod_p192( mpi *N )
+static int ecp_mod_p192( mbedtls_mpi *N )
{
int ret;
- t_uint c = 0;
- t_uint *p, *end;
+ mbedtls_mpi_uint c = 0;
+ mbedtls_mpi_uint *p, *end;
/* Make sure we have enough blocks so that A(5) is legal */
- MPI_CHK( mpi_grow( N, 6 * WIDTH ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( N, 6 * WIDTH ) );
p = N->p;
end = p + N->n;
@@ -884,11 +884,11 @@
#undef ADD
#undef NEXT
#undef LAST
-#endif /* POLARSSL_ECP_DP_SECP192R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP256R1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
/*
* The reader is advised to first understand ecp_mod_p192() since the same
* general structure is used here, but with additional complications:
@@ -907,26 +907,26 @@
*/
#define LOAD32 cur = A( i );
-#if defined(POLARSSL_HAVE_INT8) /* 8 bit */
+#if defined(MBEDTLS_HAVE_INT8) /* 8 bit */
#define MAX32 N->n / 4
#define A( j ) (uint32_t)( N->p[4*j+0] ) | \
( N->p[4*j+1] << 8 ) | \
( N->p[4*j+2] << 16 ) | \
( N->p[4*j+3] << 24 )
-#define STORE32 N->p[4*i+0] = (t_uint)( cur ); \
- N->p[4*i+1] = (t_uint)( cur >> 8 ); \
- N->p[4*i+2] = (t_uint)( cur >> 16 ); \
- N->p[4*i+3] = (t_uint)( cur >> 24 );
+#define STORE32 N->p[4*i+0] = (mbedtls_mpi_uint)( cur ); \
+ N->p[4*i+1] = (mbedtls_mpi_uint)( cur >> 8 ); \
+ N->p[4*i+2] = (mbedtls_mpi_uint)( cur >> 16 ); \
+ N->p[4*i+3] = (mbedtls_mpi_uint)( cur >> 24 );
-#elif defined(POLARSSL_HAVE_INT16) /* 16 bit */
+#elif defined(MBEDTLS_HAVE_INT16) /* 16 bit */
#define MAX32 N->n / 2
#define A( j ) (uint32_t)( N->p[2*j] ) | ( N->p[2*j+1] << 16 )
-#define STORE32 N->p[2*i+0] = (t_uint)( cur ); \
- N->p[2*i+1] = (t_uint)( cur >> 16 );
+#define STORE32 N->p[2*i+0] = (mbedtls_mpi_uint)( cur ); \
+ N->p[2*i+1] = (mbedtls_mpi_uint)( cur >> 16 );
-#elif defined(POLARSSL_HAVE_INT32) /* 32 bit */
+#elif defined(MBEDTLS_HAVE_INT32) /* 32 bit */
#define MAX32 N->n
#define A( j ) N->p[j]
@@ -939,13 +939,13 @@
#define STORE32 \
if( i % 2 ) { \
N->p[i/2] &= 0x00000000FFFFFFFF; \
- N->p[i/2] |= ((t_uint) cur) << 32; \
+ N->p[i/2] |= ((mbedtls_mpi_uint) cur) << 32; \
} else { \
N->p[i/2] &= 0xFFFFFFFF00000000; \
- N->p[i/2] |= (t_uint) cur; \
+ N->p[i/2] |= (mbedtls_mpi_uint) cur; \
}
-#endif /* sizeof( t_uint ) */
+#endif /* sizeof( mbedtls_mpi_uint ) */
/*
* Helpers for addition and subtraction of chunks, with signed carry.
@@ -974,15 +974,15 @@
signed char c = 0, cc; \
uint32_t cur; \
size_t i = 0, bits = b; \
- mpi C; \
- t_uint Cp[ b / 8 / sizeof( t_uint) + 1 ]; \
+ mbedtls_mpi C; \
+ mbedtls_mpi_uint Cp[ b / 8 / sizeof( mbedtls_mpi_uint) + 1 ]; \
\
C.s = 1; \
- C.n = b / 8 / sizeof( t_uint) + 1; \
+ C.n = b / 8 / sizeof( mbedtls_mpi_uint) + 1; \
C.p = Cp; \
- memset( Cp, 0, C.n * sizeof( t_uint ) ); \
+ memset( Cp, 0, C.n * sizeof( mbedtls_mpi_uint ) ); \
\
- MPI_CHK( mpi_grow( N, b * 2 / 8 / sizeof( t_uint ) ) ); \
+ MBEDTLS_MPI_CHK( mbedtls_mpi_grow( N, b * 2 / 8 / sizeof( mbedtls_mpi_uint ) ) ); \
LOAD32;
#define NEXT \
@@ -1003,22 +1003,22 @@
* If the result is negative, we get it in the form
* c * 2^(bits + 32) + N, with c negative and N positive shorter than 'bits'
*/
-static inline int fix_negative( mpi *N, signed char c, mpi *C, size_t bits )
+static inline int fix_negative( mbedtls_mpi *N, signed char c, mbedtls_mpi *C, size_t bits )
{
int ret;
/* C = - c * 2^(bits + 32) */
-#if !defined(POLARSSL_HAVE_INT64)
+#if !defined(MBEDTLS_HAVE_INT64)
((void) bits);
#else
if( bits == 224 )
- C->p[ C->n - 1 ] = ((t_uint) -c) << 32;
+ C->p[ C->n - 1 ] = ((mbedtls_mpi_uint) -c) << 32;
else
#endif
- C->p[ C->n - 1 ] = (t_uint) -c;
+ C->p[ C->n - 1 ] = (mbedtls_mpi_uint) -c;
/* N = - ( C - N ) */
- MPI_CHK( mpi_sub_abs( N, C, N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( N, C, N ) );
N->s = -1;
cleanup:
@@ -1026,11 +1026,11 @@
return( ret );
}
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
/*
* Fast quasi-reduction modulo p224 (FIPS 186-3 D.2.2)
*/
-static int ecp_mod_p224( mpi *N )
+static int ecp_mod_p224( mbedtls_mpi *N )
{
INIT( 224 );
@@ -1045,13 +1045,13 @@
cleanup:
return( ret );
}
-#endif /* POLARSSL_ECP_DP_SECP224R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
/*
* Fast quasi-reduction modulo p256 (FIPS 186-3 D.2.3)
*/
-static int ecp_mod_p256( mpi *N )
+static int ecp_mod_p256( mbedtls_mpi *N )
{
INIT( 256 );
@@ -1082,13 +1082,13 @@
cleanup:
return( ret );
}
-#endif /* POLARSSL_ECP_DP_SECP256R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
/*
* Fast quasi-reduction modulo p384 (FIPS 186-3 D.2.4)
*/
-static int ecp_mod_p384( mpi *N )
+static int ecp_mod_p384( mbedtls_mpi *N )
{
INIT( 384 );
@@ -1131,7 +1131,7 @@
cleanup:
return( ret );
}
-#endif /* POLARSSL_ECP_DP_SECP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#undef A
#undef LOAD32
@@ -1141,21 +1141,21 @@
#undef NEXT
#undef LAST
-#endif /* POLARSSL_ECP_DP_SECP224R1_ENABLED ||
- POLARSSL_ECP_DP_SECP256R1_ENABLED ||
- POLARSSL_ECP_DP_SECP384R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED ||
+ MBEDTLS_ECP_DP_SECP256R1_ENABLED ||
+ MBEDTLS_ECP_DP_SECP384R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
/*
* Here we have an actual Mersenne prime, so things are more straightforward.
* However, chunks are aligned on a 'weird' boundary (521 bits).
*/
-/* Size of p521 in terms of t_uint */
-#define P521_WIDTH ( 521 / 8 / sizeof( t_uint ) + 1 )
+/* Size of p521 in terms of mbedtls_mpi_uint */
+#define P521_WIDTH ( 521 / 8 / sizeof( mbedtls_mpi_uint ) + 1 )
-/* Bits to keep in the most significant t_uint */
-#if defined(POLARSSL_HAVE_INT8)
+/* Bits to keep in the most significant mbedtls_mpi_uint */
+#if defined(MBEDTLS_HAVE_INT8)
#define P521_MASK 0x01
#else
#define P521_MASK 0x01FF
@@ -1165,13 +1165,13 @@
* Fast quasi-reduction modulo p521 (FIPS 186-3 D.2.5)
* Write N as A1 + 2^521 A0, return A0 + A1
*/
-static int ecp_mod_p521( mpi *N )
+static int ecp_mod_p521( mbedtls_mpi *N )
{
int ret;
size_t i;
- mpi M;
- t_uint Mp[P521_WIDTH + 1];
- /* Worst case for the size of M is when t_uint is 16 bits:
+ mbedtls_mpi M;
+ mbedtls_mpi_uint Mp[P521_WIDTH + 1];
+ /* Worst case for the size of M is when mbedtls_mpi_uint is 16 bits:
* we need to hold bits 513 to 1056, which is 34 limbs, that is
* P521_WIDTH + 1. Otherwise P521_WIDTH is enough. */
@@ -1184,8 +1184,8 @@
if( M.n > P521_WIDTH + 1 )
M.n = P521_WIDTH + 1;
M.p = Mp;
- memcpy( Mp, N->p + P521_WIDTH - 1, M.n * sizeof( t_uint ) );
- MPI_CHK( mpi_shift_r( &M, 521 % ( 8 * sizeof( t_uint ) ) ) );
+ memcpy( Mp, N->p + P521_WIDTH - 1, M.n * sizeof( mbedtls_mpi_uint ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, 521 % ( 8 * sizeof( mbedtls_mpi_uint ) ) ) );
/* N = A0 */
N->p[P521_WIDTH - 1] &= P521_MASK;
@@ -1193,7 +1193,7 @@
N->p[i] = 0;
/* N = A0 + A1 */
- MPI_CHK( mpi_add_abs( N, N, &M ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
cleanup:
return( ret );
@@ -1201,25 +1201,25 @@
#undef P521_WIDTH
#undef P521_MASK
-#endif /* POLARSSL_ECP_DP_SECP521R1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-#endif /* POLARSSL_ECP_NIST_OPTIM */
+#endif /* MBEDTLS_ECP_NIST_OPTIM */
-#if defined(POLARSSL_ECP_DP_M255_ENABLED)
+#if defined(MBEDTLS_ECP_DP_M255_ENABLED)
-/* Size of p255 in terms of t_uint */
-#define P255_WIDTH ( 255 / 8 / sizeof( t_uint ) + 1 )
+/* Size of p255 in terms of mbedtls_mpi_uint */
+#define P255_WIDTH ( 255 / 8 / sizeof( mbedtls_mpi_uint ) + 1 )
/*
* Fast quasi-reduction modulo p255 = 2^255 - 19
* Write N as A0 + 2^255 A1, return A0 + 19 * A1
*/
-static int ecp_mod_p255( mpi *N )
+static int ecp_mod_p255( mbedtls_mpi *N )
{
int ret;
size_t i;
- mpi M;
- t_uint Mp[P255_WIDTH + 2];
+ mbedtls_mpi M;
+ mbedtls_mpi_uint Mp[P255_WIDTH + 2];
if( N->n < P255_WIDTH )
return( 0 );
@@ -1231,27 +1231,27 @@
M.n = P255_WIDTH + 1;
M.p = Mp;
memset( Mp, 0, sizeof Mp );
- memcpy( Mp, N->p + P255_WIDTH - 1, M.n * sizeof( t_uint ) );
- MPI_CHK( mpi_shift_r( &M, 255 % ( 8 * sizeof( t_uint ) ) ) );
+ memcpy( Mp, N->p + P255_WIDTH - 1, M.n * sizeof( mbedtls_mpi_uint ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, 255 % ( 8 * sizeof( mbedtls_mpi_uint ) ) ) );
M.n++; /* Make room for multiplication by 19 */
/* N = A0 */
- MPI_CHK( mpi_set_bit( N, 255, 0 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( N, 255, 0 ) );
for( i = P255_WIDTH; i < N->n; i++ )
N->p[i] = 0;
/* N = A0 + 19 * A1 */
- MPI_CHK( mpi_mul_int( &M, &M, 19 ) );
- MPI_CHK( mpi_add_abs( N, N, &M ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &M, &M, 19 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
cleanup:
return( ret );
}
-#endif /* POLARSSL_ECP_DP_M255_ENABLED */
+#endif /* MBEDTLS_ECP_DP_M255_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP224K1_ENABLED) || \
- defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
/*
* Fast quasi-reduction modulo P = 2^s - R,
* with R about 33 bits, used by the Koblitz curves.
@@ -1259,15 +1259,15 @@
* Write N as A0 + 2^224 A1, return A0 + R * A1.
* Actually do two passes, since R is big.
*/
-#define P_KOBLITZ_MAX ( 256 / 8 / sizeof( t_uint ) ) // Max limbs in P
-#define P_KOBLITZ_R ( 8 / sizeof( t_uint ) ) // Limbs in R
-static inline int ecp_mod_koblitz( mpi *N, t_uint *Rp, size_t p_limbs,
- size_t adjust, size_t shift, t_uint mask )
+#define P_KOBLITZ_MAX ( 256 / 8 / sizeof( mbedtls_mpi_uint ) ) // Max limbs in P
+#define P_KOBLITZ_R ( 8 / sizeof( mbedtls_mpi_uint ) ) // Limbs in R
+static inline int ecp_mod_koblitz( mbedtls_mpi *N, mbedtls_mpi_uint *Rp, size_t p_limbs,
+ size_t adjust, size_t shift, mbedtls_mpi_uint mask )
{
int ret;
size_t i;
- mpi M, R;
- t_uint Mp[P_KOBLITZ_MAX + P_KOBLITZ_R];
+ mbedtls_mpi M, R;
+ mbedtls_mpi_uint Mp[P_KOBLITZ_MAX + P_KOBLITZ_R];
if( N->n < p_limbs )
return( 0 );
@@ -1286,9 +1286,9 @@
if( M.n > p_limbs + adjust )
M.n = p_limbs + adjust;
memset( Mp, 0, sizeof Mp );
- memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( t_uint ) );
+ memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( mbedtls_mpi_uint ) );
if( shift != 0 )
- MPI_CHK( mpi_shift_r( &M, shift ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, shift ) );
M.n += R.n - adjust; /* Make room for multiplication by R */
/* N = A0 */
@@ -1298,8 +1298,8 @@
N->p[i] = 0;
/* N = A0 + R * A1 */
- MPI_CHK( mpi_mul_mpi( &M, &M, &R ) );
- MPI_CHK( mpi_add_abs( N, N, &M ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &M, &M, &R ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
/* Second pass */
@@ -1308,9 +1308,9 @@
if( M.n > p_limbs + adjust )
M.n = p_limbs + adjust;
memset( Mp, 0, sizeof Mp );
- memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( t_uint ) );
+ memcpy( Mp, N->p + p_limbs - adjust, M.n * sizeof( mbedtls_mpi_uint ) );
if( shift != 0 )
- MPI_CHK( mpi_shift_r( &M, shift ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &M, shift ) );
M.n += R.n - adjust; /* Make room for multiplication by R */
/* N = A0 */
@@ -1320,60 +1320,60 @@
N->p[i] = 0;
/* N = A0 + R * A1 */
- MPI_CHK( mpi_mul_mpi( &M, &M, &R ) );
- MPI_CHK( mpi_add_abs( N, N, &M ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &M, &M, &R ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( N, N, &M ) );
cleanup:
return( ret );
}
-#endif /* POLARSSL_ECP_DP_SECP192K1_ENABLED) ||
- POLARSSL_ECP_DP_SECP224K1_ENABLED) ||
- POLARSSL_ECP_DP_SECP256K1_ENABLED) */
+#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED) ||
+ MBEDTLS_ECP_DP_SECP224K1_ENABLED) ||
+ MBEDTLS_ECP_DP_SECP256K1_ENABLED) */
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
/*
* Fast quasi-reduction modulo p192k1 = 2^192 - R,
* with R = 2^32 + 2^12 + 2^8 + 2^7 + 2^6 + 2^3 + 1 = 0x0100001119
*/
-static int ecp_mod_p192k1( mpi *N )
+static int ecp_mod_p192k1( mbedtls_mpi *N )
{
- static t_uint Rp[] = {
+ static mbedtls_mpi_uint Rp[] = {
BYTES_TO_T_UINT_8( 0xC9, 0x11, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) };
- return( ecp_mod_koblitz( N, Rp, 192 / 8 / sizeof( t_uint ), 0, 0, 0 ) );
+ return( ecp_mod_koblitz( N, Rp, 192 / 8 / sizeof( mbedtls_mpi_uint ), 0, 0, 0 ) );
}
-#endif /* POLARSSL_ECP_DP_SECP192K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
/*
* Fast quasi-reduction modulo p224k1 = 2^224 - R,
* with R = 2^32 + 2^12 + 2^11 + 2^9 + 2^7 + 2^4 + 2 + 1 = 0x0100001A93
*/
-static int ecp_mod_p224k1( mpi *N )
+static int ecp_mod_p224k1( mbedtls_mpi *N )
{
- static t_uint Rp[] = {
+ static mbedtls_mpi_uint Rp[] = {
BYTES_TO_T_UINT_8( 0x93, 0x1A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) };
-#if defined(POLARSSL_HAVE_INT64)
+#if defined(MBEDTLS_HAVE_INT64)
return( ecp_mod_koblitz( N, Rp, 4, 1, 32, 0xFFFFFFFF ) );
#else
- return( ecp_mod_koblitz( N, Rp, 224 / 8 / sizeof( t_uint ), 0, 0, 0 ) );
+ return( ecp_mod_koblitz( N, Rp, 224 / 8 / sizeof( mbedtls_mpi_uint ), 0, 0, 0 ) );
#endif
}
-#endif /* POLARSSL_ECP_DP_SECP224K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
/*
* Fast quasi-reduction modulo p256k1 = 2^256 - R,
* with R = 2^32 + 2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1 = 0x01000003D1
*/
-static int ecp_mod_p256k1( mpi *N )
+static int ecp_mod_p256k1( mbedtls_mpi *N )
{
- static t_uint Rp[] = {
+ static mbedtls_mpi_uint Rp[] = {
BYTES_TO_T_UINT_8( 0xD1, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) };
- return( ecp_mod_koblitz( N, Rp, 256 / 8 / sizeof( t_uint ), 0, 0, 0 ) );
+ return( ecp_mod_koblitz( N, Rp, 256 / 8 / sizeof( mbedtls_mpi_uint ), 0, 0, 0 ) );
}
-#endif /* POLARSSL_ECP_DP_SECP256K1_ENABLED */
+#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
diff --git a/library/entropy.c b/library/entropy.c
index fe271d3..d60250c 100644
--- a/library/entropy.c
+++ b/library/entropy.c
@@ -20,101 +20,101 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ENTROPY_C)
+#if defined(MBEDTLS_ENTROPY_C)
#include "mbedtls/entropy.h"
#include "mbedtls/entropy_poll.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if defined(POLARSSL_HAVEGE_C)
+#if defined(MBEDTLS_HAVEGE_C)
#include "mbedtls/havege.h"
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
#define ENTROPY_MAX_LOOP 256 /**< Maximum amount to loop before error */
-void entropy_init( entropy_context *ctx )
+void mbedtls_entropy_init( mbedtls_entropy_context *ctx )
{
- memset( ctx, 0, sizeof(entropy_context) );
+ memset( ctx, 0, sizeof(mbedtls_entropy_context) );
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_init( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_init( &ctx->mutex );
#endif
-#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
- sha512_starts( &ctx->accumulator, 0 );
+#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
+ mbedtls_sha512_starts( &ctx->accumulator, 0 );
#else
- sha256_starts( &ctx->accumulator, 0 );
+ mbedtls_sha256_starts( &ctx->accumulator, 0 );
#endif
-#if defined(POLARSSL_HAVEGE_C)
- havege_init( &ctx->havege_data );
+#if defined(MBEDTLS_HAVEGE_C)
+ mbedtls_havege_init( &ctx->havege_data );
#endif
-#if !defined(POLARSSL_NO_DEFAULT_ENTROPY_SOURCES)
-#if !defined(POLARSSL_NO_PLATFORM_ENTROPY)
- entropy_add_source( ctx, platform_entropy_poll, NULL,
- ENTROPY_MIN_PLATFORM );
+#if !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
+#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
+ mbedtls_entropy_add_source( ctx, mbedtls_platform_entropy_poll, NULL,
+ MBEDTLS_ENTROPY_MIN_PLATFORM );
#endif
-#if defined(POLARSSL_TIMING_C)
- entropy_add_source( ctx, hardclock_poll, NULL, ENTROPY_MIN_HARDCLOCK );
+#if defined(MBEDTLS_TIMING_C)
+ mbedtls_entropy_add_source( ctx, mbedtls_hardclock_poll, NULL, MBEDTLS_ENTROPY_MIN_HARDCLOCK );
#endif
-#if defined(POLARSSL_HAVEGE_C)
- entropy_add_source( ctx, havege_poll, &ctx->havege_data,
- ENTROPY_MIN_HAVEGE );
+#if defined(MBEDTLS_HAVEGE_C)
+ mbedtls_entropy_add_source( ctx, mbedtls_havege_poll, &ctx->havege_data,
+ MBEDTLS_ENTROPY_MIN_HAVEGE );
#endif
-#endif /* POLARSSL_NO_DEFAULT_ENTROPY_SOURCES */
+#endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
}
-void entropy_free( entropy_context *ctx )
+void mbedtls_entropy_free( mbedtls_entropy_context *ctx )
{
-#if defined(POLARSSL_HAVEGE_C)
- havege_free( &ctx->havege_data );
+#if defined(MBEDTLS_HAVEGE_C)
+ mbedtls_havege_free( &ctx->havege_data );
#endif
- polarssl_zeroize( ctx, sizeof( entropy_context ) );
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_free( &ctx->mutex );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_entropy_context ) );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_free( &ctx->mutex );
#endif
}
-int entropy_add_source( entropy_context *ctx,
- f_source_ptr f_source, void *p_source,
+int mbedtls_entropy_add_source( mbedtls_entropy_context *ctx,
+ mbedtls_entropy_f_source_ptr f_source, void *p_source,
size_t threshold )
{
int index, ret = 0;
-#if defined(POLARSSL_THREADING_C)
- if( ( ret = polarssl_mutex_lock( &ctx->mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
index = ctx->source_count;
- if( index >= ENTROPY_MAX_SOURCES )
+ if( index >= MBEDTLS_ENTROPY_MAX_SOURCES )
{
- ret = POLARSSL_ERR_ENTROPY_MAX_SOURCES;
+ ret = MBEDTLS_ERR_ENTROPY_MAX_SOURCES;
goto exit;
}
@@ -125,9 +125,9 @@
ctx->source_count++;
exit:
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &ctx->mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
@@ -136,54 +136,54 @@
/*
* Entropy accumulator update
*/
-static int entropy_update( entropy_context *ctx, unsigned char source_id,
+static int entropy_update( mbedtls_entropy_context *ctx, unsigned char source_id,
const unsigned char *data, size_t len )
{
unsigned char header[2];
- unsigned char tmp[ENTROPY_BLOCK_SIZE];
+ unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE];
size_t use_len = len;
const unsigned char *p = data;
- if( use_len > ENTROPY_BLOCK_SIZE )
+ if( use_len > MBEDTLS_ENTROPY_BLOCK_SIZE )
{
-#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
- sha512( data, len, tmp, 0 );
+#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
+ mbedtls_sha512( data, len, tmp, 0 );
#else
- sha256( data, len, tmp, 0 );
+ mbedtls_sha256( data, len, tmp, 0 );
#endif
p = tmp;
- use_len = ENTROPY_BLOCK_SIZE;
+ use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
}
header[0] = source_id;
header[1] = use_len & 0xFF;
-#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
- sha512_update( &ctx->accumulator, header, 2 );
- sha512_update( &ctx->accumulator, p, use_len );
+#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
+ mbedtls_sha512_update( &ctx->accumulator, header, 2 );
+ mbedtls_sha512_update( &ctx->accumulator, p, use_len );
#else
- sha256_update( &ctx->accumulator, header, 2 );
- sha256_update( &ctx->accumulator, p, use_len );
+ mbedtls_sha256_update( &ctx->accumulator, header, 2 );
+ mbedtls_sha256_update( &ctx->accumulator, p, use_len );
#endif
return( 0 );
}
-int entropy_update_manual( entropy_context *ctx,
+int mbedtls_entropy_update_manual( mbedtls_entropy_context *ctx,
const unsigned char *data, size_t len )
{
int ret;
-#if defined(POLARSSL_THREADING_C)
- if( ( ret = polarssl_mutex_lock( &ctx->mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
- ret = entropy_update( ctx, ENTROPY_SOURCE_MANUAL, data, len );
+ ret = entropy_update( ctx, MBEDTLS_ENTROPY_SOURCE_MANUAL, data, len );
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &ctx->mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
@@ -192,14 +192,14 @@
/*
* Run through the different sources to add entropy to our accumulator
*/
-static int entropy_gather_internal( entropy_context *ctx )
+static int entropy_gather_internal( mbedtls_entropy_context *ctx )
{
int ret, i;
- unsigned char buf[ENTROPY_MAX_GATHER];
+ unsigned char buf[MBEDTLS_ENTROPY_MAX_GATHER];
size_t olen;
if( ctx->source_count == 0 )
- return( POLARSSL_ERR_ENTROPY_NO_SOURCES_DEFINED );
+ return( MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
/*
* Run through our entropy sources
@@ -208,7 +208,7 @@
{
olen = 0;
if( ( ret = ctx->source[i].f_source( ctx->source[i].p_source,
- buf, ENTROPY_MAX_GATHER, &olen ) ) != 0 )
+ buf, MBEDTLS_ENTROPY_MAX_GATHER, &olen ) ) != 0 )
{
return( ret );
}
@@ -229,36 +229,36 @@
/*
* Thread-safe wrapper for entropy_gather_internal()
*/
-int entropy_gather( entropy_context *ctx )
+int mbedtls_entropy_gather( mbedtls_entropy_context *ctx )
{
int ret;
-#if defined(POLARSSL_THREADING_C)
- if( ( ret = polarssl_mutex_lock( &ctx->mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
ret = entropy_gather_internal( ctx );
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &ctx->mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
}
-int entropy_func( void *data, unsigned char *output, size_t len )
+int mbedtls_entropy_func( void *data, unsigned char *output, size_t len )
{
int ret, count = 0, i, reached;
- entropy_context *ctx = (entropy_context *) data;
- unsigned char buf[ENTROPY_BLOCK_SIZE];
+ mbedtls_entropy_context *ctx = (mbedtls_entropy_context *) data;
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
- if( len > ENTROPY_BLOCK_SIZE )
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ if( len > MBEDTLS_ENTROPY_BLOCK_SIZE )
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-#if defined(POLARSSL_THREADING_C)
- if( ( ret = polarssl_mutex_lock( &ctx->mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
@@ -269,7 +269,7 @@
{
if( count++ > ENTROPY_MAX_LOOP )
{
- ret = POLARSSL_ERR_ENTROPY_SOURCE_FAILED;
+ ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
goto exit;
}
@@ -284,37 +284,37 @@
}
while( reached != ctx->source_count );
- memset( buf, 0, ENTROPY_BLOCK_SIZE );
+ memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
-#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
- sha512_finish( &ctx->accumulator, buf );
+#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
+ mbedtls_sha512_finish( &ctx->accumulator, buf );
/*
* Reset accumulator and counters and recycle existing entropy
*/
- memset( &ctx->accumulator, 0, sizeof( sha512_context ) );
- sha512_starts( &ctx->accumulator, 0 );
- sha512_update( &ctx->accumulator, buf, ENTROPY_BLOCK_SIZE );
+ memset( &ctx->accumulator, 0, sizeof( mbedtls_sha512_context ) );
+ mbedtls_sha512_starts( &ctx->accumulator, 0 );
+ mbedtls_sha512_update( &ctx->accumulator, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
/*
* Perform second SHA-512 on entropy
*/
- sha512( buf, ENTROPY_BLOCK_SIZE, buf, 0 );
-#else /* POLARSSL_ENTROPY_SHA512_ACCUMULATOR */
- sha256_finish( &ctx->accumulator, buf );
+ mbedtls_sha512( buf, MBEDTLS_ENTROPY_BLOCK_SIZE, buf, 0 );
+#else /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
+ mbedtls_sha256_finish( &ctx->accumulator, buf );
/*
* Reset accumulator and counters and recycle existing entropy
*/
- memset( &ctx->accumulator, 0, sizeof( sha256_context ) );
- sha256_starts( &ctx->accumulator, 0 );
- sha256_update( &ctx->accumulator, buf, ENTROPY_BLOCK_SIZE );
+ memset( &ctx->accumulator, 0, sizeof( mbedtls_sha256_context ) );
+ mbedtls_sha256_starts( &ctx->accumulator, 0 );
+ mbedtls_sha256_update( &ctx->accumulator, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
/*
* Perform second SHA-256 on entropy
*/
- sha256( buf, ENTROPY_BLOCK_SIZE, buf, 0 );
-#endif /* POLARSSL_ENTROPY_SHA512_ACCUMULATOR */
+ mbedtls_sha256( buf, MBEDTLS_ENTROPY_BLOCK_SIZE, buf, 0 );
+#endif /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
for( i = 0; i < ctx->source_count; i++ )
ctx->source[i].size = 0;
@@ -324,30 +324,30 @@
ret = 0;
exit:
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &ctx->mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( ret );
}
-#if defined(POLARSSL_FS_IO)
-int entropy_write_seed_file( entropy_context *ctx, const char *path )
+#if defined(MBEDTLS_FS_IO)
+int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
{
- int ret = POLARSSL_ERR_ENTROPY_FILE_IO_ERROR;
+ int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
FILE *f;
- unsigned char buf[ENTROPY_BLOCK_SIZE];
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
if( ( f = fopen( path, "wb" ) ) == NULL )
- return( POLARSSL_ERR_ENTROPY_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
- if( ( ret = entropy_func( ctx, buf, ENTROPY_BLOCK_SIZE ) ) != 0 )
+ if( ( ret = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
goto exit;
- if( fwrite( buf, 1, ENTROPY_BLOCK_SIZE, f ) != ENTROPY_BLOCK_SIZE )
+ if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) != MBEDTLS_ENTROPY_BLOCK_SIZE )
{
- ret = POLARSSL_ERR_ENTROPY_FILE_IO_ERROR;
+ ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
goto exit;
}
@@ -358,37 +358,37 @@
return( ret );
}
-int entropy_update_seed_file( entropy_context *ctx, const char *path )
+int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *ctx, const char *path )
{
FILE *f;
size_t n;
- unsigned char buf[ ENTROPY_MAX_SEED_SIZE ];
+ unsigned char buf[ MBEDTLS_ENTROPY_MAX_SEED_SIZE ];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_ENTROPY_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
n = (size_t) ftell( f );
fseek( f, 0, SEEK_SET );
- if( n > ENTROPY_MAX_SEED_SIZE )
- n = ENTROPY_MAX_SEED_SIZE;
+ if( n > MBEDTLS_ENTROPY_MAX_SEED_SIZE )
+ n = MBEDTLS_ENTROPY_MAX_SEED_SIZE;
if( fread( buf, 1, n, f ) != n )
{
fclose( f );
- return( POLARSSL_ERR_ENTROPY_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
}
fclose( f );
- entropy_update_manual( ctx, buf, n );
+ mbedtls_entropy_update_manual( ctx, buf, n );
- return( entropy_write_seed_file( ctx, path ) );
+ return( mbedtls_entropy_write_seed_file( ctx, path ) );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* Dummy source function
*/
@@ -408,31 +408,31 @@
* test that the functions don't cause errors and write the correct
* amount of data to buffers.
*/
-int entropy_self_test( int verbose )
+int mbedtls_entropy_self_test( int verbose )
{
int ret = 0;
- entropy_context ctx;
- unsigned char buf[ENTROPY_BLOCK_SIZE] = { 0 };
- unsigned char acc[ENTROPY_BLOCK_SIZE] = { 0 };
+ mbedtls_entropy_context ctx;
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
+ unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
size_t i, j;
if( verbose != 0 )
- polarssl_printf( " ENTROPY test: " );
+ mbedtls_printf( " ENTROPY test: " );
- entropy_init( &ctx );
+ mbedtls_entropy_init( &ctx );
- ret = entropy_add_source( &ctx, entropy_dummy_source, NULL, 16 );
+ ret = mbedtls_entropy_add_source( &ctx, entropy_dummy_source, NULL, 16 );
if( ret != 0 )
goto cleanup;
- if( ( ret = entropy_gather( &ctx ) ) != 0 )
+ if( ( ret = mbedtls_entropy_gather( &ctx ) ) != 0 )
goto cleanup;
- if( ( ret = entropy_update_manual( &ctx, buf, sizeof buf ) ) != 0 )
+ if( ( ret = mbedtls_entropy_update_manual( &ctx, buf, sizeof buf ) ) != 0 )
goto cleanup;
/*
- * To test that entropy_func writes correct number of bytes:
+ * To test that mbedtls_entropy_func writes correct number of bytes:
* - use the whole buffer and rely on ASan to detect overruns
* - collect entropy 8 times and OR the result in an accumulator:
* any byte should then be 0 with probably 2^(-64), so requiring
@@ -441,7 +441,7 @@
*/
for( i = 0; i < 8; i++ )
{
- if( ( ret = entropy_func( &ctx, buf, sizeof( buf ) ) ) != 0 )
+ if( ( ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) ) ) != 0 )
goto cleanup;
for( j = 0; j < sizeof( buf ); j++ )
@@ -458,20 +458,20 @@
}
cleanup:
- entropy_free( &ctx );
+ mbedtls_entropy_free( &ctx );
if( verbose != 0 )
{
if( ret != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
else
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
}
return( ret != 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_ENTROPY_C */
+#endif /* MBEDTLS_ENTROPY_C */
diff --git a/library/entropy_poll.c b/library/entropy_poll.c
index e0eff16..51d69a5 100644
--- a/library/entropy_poll.c
+++ b/library/entropy_poll.c
@@ -20,26 +20,26 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ENTROPY_C)
+#if defined(MBEDTLS_ENTROPY_C)
#include "mbedtls/entropy.h"
#include "mbedtls/entropy_poll.h"
-#if defined(POLARSSL_TIMING_C)
+#if defined(MBEDTLS_TIMING_C)
#include <string.h>
#include "mbedtls/timing.h"
#endif
-#if defined(POLARSSL_HAVEGE_C)
+#if defined(MBEDTLS_HAVEGE_C)
#include "mbedtls/havege.h"
#endif
-#if !defined(POLARSSL_NO_PLATFORM_ENTROPY)
+#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
#if !defined(_WIN32_WINNT)
@@ -48,7 +48,7 @@
#include <windows.h>
#include <wincrypt.h>
-int platform_entropy_poll( void *data, unsigned char *output, size_t len,
+int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
size_t *olen )
{
HCRYPTPROV provider;
@@ -58,11 +58,11 @@
if( CryptAcquireContext( &provider, NULL, NULL,
PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
{
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
}
if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
CryptReleaseContext( provider, 0 );
*olen = len;
@@ -93,14 +93,14 @@
#include <errno.h>
-int platform_entropy_poll( void *data,
+int mbedtls_platform_entropy_poll( void *data,
unsigned char *output, size_t len, size_t *olen )
{
int ret;
((void) data);
if( ( ret = getrandom_wrapper( output, len, 0 ) ) < 0 )
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
*olen = ret;
return( 0 );
@@ -110,7 +110,7 @@
#include <stdio.h>
-int platform_entropy_poll( void *data,
+int mbedtls_platform_entropy_poll( void *data,
unsigned char *output, size_t len, size_t *olen )
{
FILE *file;
@@ -121,13 +121,13 @@
file = fopen( "/dev/urandom", "rb" );
if( file == NULL )
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
ret = fread( output, 1, len, file );
if( ret != len )
{
fclose( file );
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
}
fclose( file );
@@ -137,13 +137,13 @@
}
#endif /* HAVE_GETRANDOM */
#endif /* _WIN32 && !EFIX64 && !EFI32 */
-#endif /* !POLARSSL_NO_PLATFORM_ENTROPY */
+#endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
-#if defined(POLARSSL_TIMING_C)
-int hardclock_poll( void *data,
+#if defined(MBEDTLS_TIMING_C)
+int mbedtls_hardclock_poll( void *data,
unsigned char *output, size_t len, size_t *olen )
{
- unsigned long timer = hardclock();
+ unsigned long timer = mbedtls_timing_hardclock();
((void) data);
*olen = 0;
@@ -155,22 +155,22 @@
return( 0 );
}
-#endif /* POLARSSL_TIMING_C */
+#endif /* MBEDTLS_TIMING_C */
-#if defined(POLARSSL_HAVEGE_C)
-int havege_poll( void *data,
+#if defined(MBEDTLS_HAVEGE_C)
+int mbedtls_havege_poll( void *data,
unsigned char *output, size_t len, size_t *olen )
{
- havege_state *hs = (havege_state *) data;
+ mbedtls_havege_state *hs = (mbedtls_havege_state *) data;
*olen = 0;
- if( havege_random( hs, output, len ) != 0 )
- return( POLARSSL_ERR_ENTROPY_SOURCE_FAILED );
+ if( mbedtls_havege_random( hs, output, len ) != 0 )
+ return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
*olen = len;
return( 0 );
}
-#endif /* POLARSSL_HAVEGE_C */
+#endif /* MBEDTLS_HAVEGE_C */
-#endif /* POLARSSL_ENTROPY_C */
+#endif /* MBEDTLS_ENTROPY_C */
diff --git a/library/error.c b/library/error.c
index 9d79240..31f0a11 100644
--- a/library/error.c
+++ b/library/error.c
@@ -20,160 +20,160 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_ERROR_C) || defined(POLARSSL_ERROR_STRERROR_DUMMY)
+#if defined(MBEDTLS_ERROR_C) || defined(MBEDTLS_ERROR_STRERROR_DUMMY)
#include "mbedtls/error.h"
#include <string.h>
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
-#define polarssl_snprintf snprintf
+#define mbedtls_snprintf snprintf
#endif
-#if defined(POLARSSL_ERROR_C)
+#if defined(MBEDTLS_ERROR_C)
#include <stdio.h>
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
#include "mbedtls/aes.h"
#endif
-#if defined(POLARSSL_BASE64_C)
+#if defined(MBEDTLS_BASE64_C)
#include "mbedtls/base64.h"
#endif
-#if defined(POLARSSL_BIGNUM_C)
+#if defined(MBEDTLS_BIGNUM_C)
#include "mbedtls/bignum.h"
#endif
-#if defined(POLARSSL_BLOWFISH_C)
+#if defined(MBEDTLS_BLOWFISH_C)
#include "mbedtls/blowfish.h"
#endif
-#if defined(POLARSSL_CAMELLIA_C)
+#if defined(MBEDTLS_CAMELLIA_C)
#include "mbedtls/camellia.h"
#endif
-#if defined(POLARSSL_CCM_C)
+#if defined(MBEDTLS_CCM_C)
#include "mbedtls/ccm.h"
#endif
-#if defined(POLARSSL_CIPHER_C)
+#if defined(MBEDTLS_CIPHER_C)
#include "mbedtls/cipher.h"
#endif
-#if defined(POLARSSL_CTR_DRBG_C)
+#if defined(MBEDTLS_CTR_DRBG_C)
#include "mbedtls/ctr_drbg.h"
#endif
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
#include "mbedtls/des.h"
#endif
-#if defined(POLARSSL_DHM_C)
+#if defined(MBEDTLS_DHM_C)
#include "mbedtls/dhm.h"
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_ENTROPY_C)
+#if defined(MBEDTLS_ENTROPY_C)
#include "mbedtls/entropy.h"
#endif
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
#include "mbedtls/gcm.h"
#endif
-#if defined(POLARSSL_HMAC_DRBG_C)
+#if defined(MBEDTLS_HMAC_DRBG_C)
#include "mbedtls/hmac_drbg.h"
#endif
-#if defined(POLARSSL_MD_C)
+#if defined(MBEDTLS_MD_C)
#include "mbedtls/md.h"
#endif
-#if defined(POLARSSL_MD2_C)
+#if defined(MBEDTLS_MD2_C)
#include "mbedtls/md2.h"
#endif
-#if defined(POLARSSL_MD4_C)
+#if defined(MBEDTLS_MD4_C)
#include "mbedtls/md4.h"
#endif
-#if defined(POLARSSL_MD5_C)
+#if defined(MBEDTLS_MD5_C)
#include "mbedtls/md5.h"
#endif
-#if defined(POLARSSL_NET_C)
+#if defined(MBEDTLS_NET_C)
#include "mbedtls/net.h"
#endif
-#if defined(POLARSSL_OID_C)
+#if defined(MBEDTLS_OID_C)
#include "mbedtls/oid.h"
#endif
-#if defined(POLARSSL_PADLOCK_C)
+#if defined(MBEDTLS_PADLOCK_C)
#include "mbedtls/padlock.h"
#endif
-#if defined(POLARSSL_PEM_PARSE_C) || defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PK_C)
+#if defined(MBEDTLS_PK_C)
#include "mbedtls/pk.h"
#endif
-#if defined(POLARSSL_PKCS12_C)
+#if defined(MBEDTLS_PKCS12_C)
#include "mbedtls/pkcs12.h"
#endif
-#if defined(POLARSSL_PKCS5_C)
+#if defined(MBEDTLS_PKCS5_C)
#include "mbedtls/pkcs5.h"
#endif
-#if defined(POLARSSL_RIPEMD160_C)
+#if defined(MBEDTLS_RIPEMD160_C)
#include "mbedtls/ripemd160.h"
#endif
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#include "mbedtls/rsa.h"
#endif
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
#include "mbedtls/sha1.h"
#endif
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
#include "mbedtls/sha256.h"
#endif
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
#include "mbedtls/sha512.h"
#endif
-#if defined(POLARSSL_SSL_TLS_C)
+#if defined(MBEDTLS_SSL_TLS_C)
#include "mbedtls/ssl.h"
#endif
-#if defined(POLARSSL_THREADING_C)
+#if defined(MBEDTLS_THREADING_C)
#include "mbedtls/threading.h"
#endif
-#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
+#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
#include "mbedtls/x509.h"
#endif
-#if defined(POLARSSL_XTEA_C)
+#if defined(MBEDTLS_XTEA_C)
#include "mbedtls/xtea.h"
#endif
@@ -182,7 +182,7 @@
#define snprintf _snprintf
#endif
-void polarssl_strerror( int ret, char *buf, size_t buflen )
+void mbedtls_strerror( int ret, char *buf, size_t buflen )
{
size_t len;
int use_ret;
@@ -204,303 +204,303 @@
// High level error codes
//
// BEGIN generated code
-#if defined(POLARSSL_CIPHER_C)
- if( use_ret == -(POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "CIPHER - The selected feature is not available" );
- if( use_ret == -(POLARSSL_ERR_CIPHER_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "CIPHER - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_CIPHER_ALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "CIPHER - Failed to allocate memory" );
- if( use_ret == -(POLARSSL_ERR_CIPHER_INVALID_PADDING) )
- polarssl_snprintf( buf, buflen, "CIPHER - Input data contains invalid padding and is rejected" );
- if( use_ret == -(POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED) )
- polarssl_snprintf( buf, buflen, "CIPHER - Decryption of block requires a full block" );
- if( use_ret == -(POLARSSL_ERR_CIPHER_AUTH_FAILED) )
- polarssl_snprintf( buf, buflen, "CIPHER - Authentication failed (for AEAD modes)" );
-#endif /* POLARSSL_CIPHER_C */
+#if defined(MBEDTLS_CIPHER_C)
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - The selected feature is not available" );
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_ALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - Failed to allocate memory" );
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_INVALID_PADDING) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - Input data contains invalid padding and is rejected" );
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - Decryption of block requires a full block" );
+ if( use_ret == -(MBEDTLS_ERR_CIPHER_AUTH_FAILED) )
+ mbedtls_snprintf( buf, buflen, "CIPHER - Authentication failed (for AEAD modes)" );
+#endif /* MBEDTLS_CIPHER_C */
-#if defined(POLARSSL_DHM_C)
- if( use_ret == -(POLARSSL_ERR_DHM_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "DHM - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_DHM_READ_PARAMS_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Reading of the DHM parameters failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Making of the DHM parameters failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_READ_PUBLIC_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Reading of the public values failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Making of the public value failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_CALC_SECRET_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Calculation of the DHM secret failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_INVALID_FORMAT) )
- polarssl_snprintf( buf, buflen, "DHM - The ASN.1 data is not formatted correctly" );
- if( use_ret == -(POLARSSL_ERR_DHM_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "DHM - Allocation of memory failed" );
- if( use_ret == -(POLARSSL_ERR_DHM_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "DHM - Read/write of file failed" );
-#endif /* POLARSSL_DHM_C */
+#if defined(MBEDTLS_DHM_C)
+ if( use_ret == -(MBEDTLS_ERR_DHM_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "DHM - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_READ_PARAMS_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Reading of the DHM parameters failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Making of the DHM parameters failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_READ_PUBLIC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Reading of the public values failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Making of the public value failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_CALC_SECRET_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Calculation of the DHM secret failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_INVALID_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "DHM - The ASN.1 data is not formatted correctly" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "DHM - Allocation of memory failed" );
+ if( use_ret == -(MBEDTLS_ERR_DHM_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "DHM - Read/write of file failed" );
+#endif /* MBEDTLS_DHM_C */
-#if defined(POLARSSL_ECP_C)
- if( use_ret == -(POLARSSL_ERR_ECP_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "ECP - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_ECP_BUFFER_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "ECP - The buffer is too small to write to" );
- if( use_ret == -(POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "ECP - Requested curve not available" );
- if( use_ret == -(POLARSSL_ERR_ECP_VERIFY_FAILED) )
- polarssl_snprintf( buf, buflen, "ECP - The signature is not valid" );
- if( use_ret == -(POLARSSL_ERR_ECP_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "ECP - Memory allocation failed" );
- if( use_ret == -(POLARSSL_ERR_ECP_RANDOM_FAILED) )
- polarssl_snprintf( buf, buflen, "ECP - Generation of random value, such as (ephemeral) key, failed" );
- if( use_ret == -(POLARSSL_ERR_ECP_INVALID_KEY) )
- polarssl_snprintf( buf, buflen, "ECP - Invalid private or public key" );
- if( use_ret == -(POLARSSL_ERR_ECP_SIG_LEN_MISMATCH) )
- polarssl_snprintf( buf, buflen, "ECP - Signature is valid but shorter than the user-supplied length" );
-#endif /* POLARSSL_ECP_C */
+#if defined(MBEDTLS_ECP_C)
+ if( use_ret == -(MBEDTLS_ERR_ECP_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "ECP - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "ECP - The buffer is too small to write to" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "ECP - Requested curve not available" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_VERIFY_FAILED) )
+ mbedtls_snprintf( buf, buflen, "ECP - The signature is not valid" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "ECP - Memory allocation failed" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_RANDOM_FAILED) )
+ mbedtls_snprintf( buf, buflen, "ECP - Generation of random value, such as (ephemeral) key, failed" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_INVALID_KEY) )
+ mbedtls_snprintf( buf, buflen, "ECP - Invalid private or public key" );
+ if( use_ret == -(MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "ECP - Signature is valid but shorter than the user-supplied length" );
+#endif /* MBEDTLS_ECP_C */
-#if defined(POLARSSL_MD_C)
- if( use_ret == -(POLARSSL_ERR_MD_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "MD - The selected feature is not available" );
- if( use_ret == -(POLARSSL_ERR_MD_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "MD - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_MD_ALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "MD - Failed to allocate memory" );
- if( use_ret == -(POLARSSL_ERR_MD_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "MD - Opening or reading of file failed" );
-#endif /* POLARSSL_MD_C */
+#if defined(MBEDTLS_MD_C)
+ if( use_ret == -(MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "MD - The selected feature is not available" );
+ if( use_ret == -(MBEDTLS_ERR_MD_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "MD - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_MD_ALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "MD - Failed to allocate memory" );
+ if( use_ret == -(MBEDTLS_ERR_MD_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "MD - Opening or reading of file failed" );
+#endif /* MBEDTLS_MD_C */
-#if defined(POLARSSL_PEM_PARSE_C) || defined(POLARSSL_PEM_WRITE_C)
- if( use_ret == -(POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT) )
- polarssl_snprintf( buf, buflen, "PEM - No PEM header or footer found" );
- if( use_ret == -(POLARSSL_ERR_PEM_INVALID_DATA) )
- polarssl_snprintf( buf, buflen, "PEM - PEM string is not as expected" );
- if( use_ret == -(POLARSSL_ERR_PEM_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "PEM - Failed to allocate memory" );
- if( use_ret == -(POLARSSL_ERR_PEM_INVALID_ENC_IV) )
- polarssl_snprintf( buf, buflen, "PEM - RSA IV is not in hex-format" );
- if( use_ret == -(POLARSSL_ERR_PEM_UNKNOWN_ENC_ALG) )
- polarssl_snprintf( buf, buflen, "PEM - Unsupported key encryption algorithm" );
- if( use_ret == -(POLARSSL_ERR_PEM_PASSWORD_REQUIRED) )
- polarssl_snprintf( buf, buflen, "PEM - Private key password can't be empty" );
- if( use_ret == -(POLARSSL_ERR_PEM_PASSWORD_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PEM - Given private key password does not allow for correct decryption" );
- if( use_ret == -(POLARSSL_ERR_PEM_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "PEM - Unavailable feature, e.g. hashing/encryption combination" );
- if( use_ret == -(POLARSSL_ERR_PEM_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "PEM - Bad input parameters to function" );
-#endif /* POLARSSL_PEM_PARSE_C || POLARSSL_PEM_WRITE_C */
+#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
+ if( use_ret == -(MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT) )
+ mbedtls_snprintf( buf, buflen, "PEM - No PEM header or footer found" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_INVALID_DATA) )
+ mbedtls_snprintf( buf, buflen, "PEM - PEM string is not as expected" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "PEM - Failed to allocate memory" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_INVALID_ENC_IV) )
+ mbedtls_snprintf( buf, buflen, "PEM - RSA IV is not in hex-format" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG) )
+ mbedtls_snprintf( buf, buflen, "PEM - Unsupported key encryption algorithm" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_PASSWORD_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "PEM - Private key password can't be empty" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_PASSWORD_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PEM - Given private key password does not allow for correct decryption" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "PEM - Unavailable feature, e.g. hashing/encryption combination" );
+ if( use_ret == -(MBEDTLS_ERR_PEM_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "PEM - Bad input parameters to function" );
+#endif /* MBEDTLS_PEM_PARSE_C || MBEDTLS_PEM_WRITE_C */
-#if defined(POLARSSL_PK_C)
- if( use_ret == -(POLARSSL_ERR_PK_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "PK - Memory alloation failed" );
- if( use_ret == -(POLARSSL_ERR_PK_TYPE_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PK - Type mismatch, eg attempt to encrypt with an ECDSA key" );
- if( use_ret == -(POLARSSL_ERR_PK_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "PK - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_PK_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "PK - Read/write of file failed" );
- if( use_ret == -(POLARSSL_ERR_PK_KEY_INVALID_VERSION) )
- polarssl_snprintf( buf, buflen, "PK - Unsupported key version" );
- if( use_ret == -(POLARSSL_ERR_PK_KEY_INVALID_FORMAT) )
- polarssl_snprintf( buf, buflen, "PK - Invalid key tag or value" );
- if( use_ret == -(POLARSSL_ERR_PK_UNKNOWN_PK_ALG) )
- polarssl_snprintf( buf, buflen, "PK - Key algorithm is unsupported (only RSA and EC are supported)" );
- if( use_ret == -(POLARSSL_ERR_PK_PASSWORD_REQUIRED) )
- polarssl_snprintf( buf, buflen, "PK - Private key password can't be empty" );
- if( use_ret == -(POLARSSL_ERR_PK_PASSWORD_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PK - Given private key password does not allow for correct decryption" );
- if( use_ret == -(POLARSSL_ERR_PK_INVALID_PUBKEY) )
- polarssl_snprintf( buf, buflen, "PK - The pubkey tag or value is invalid (only RSA and EC are supported)" );
- if( use_ret == -(POLARSSL_ERR_PK_INVALID_ALG) )
- polarssl_snprintf( buf, buflen, "PK - The algorithm tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_PK_UNKNOWN_NAMED_CURVE) )
- polarssl_snprintf( buf, buflen, "PK - Elliptic curve is unsupported (only NIST curves are supported)" );
- if( use_ret == -(POLARSSL_ERR_PK_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "PK - Unavailable feature, e.g. RSA disabled for RSA key" );
- if( use_ret == -(POLARSSL_ERR_PK_SIG_LEN_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PK - The signature is valid but its length is less than expected" );
-#endif /* POLARSSL_PK_C */
+#if defined(MBEDTLS_PK_C)
+ if( use_ret == -(MBEDTLS_ERR_PK_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "PK - Memory alloation failed" );
+ if( use_ret == -(MBEDTLS_ERR_PK_TYPE_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PK - Type mismatch, eg attempt to encrypt with an ECDSA key" );
+ if( use_ret == -(MBEDTLS_ERR_PK_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "PK - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_PK_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "PK - Read/write of file failed" );
+ if( use_ret == -(MBEDTLS_ERR_PK_KEY_INVALID_VERSION) )
+ mbedtls_snprintf( buf, buflen, "PK - Unsupported key version" );
+ if( use_ret == -(MBEDTLS_ERR_PK_KEY_INVALID_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "PK - Invalid key tag or value" );
+ if( use_ret == -(MBEDTLS_ERR_PK_UNKNOWN_PK_ALG) )
+ mbedtls_snprintf( buf, buflen, "PK - Key algorithm is unsupported (only RSA and EC are supported)" );
+ if( use_ret == -(MBEDTLS_ERR_PK_PASSWORD_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "PK - Private key password can't be empty" );
+ if( use_ret == -(MBEDTLS_ERR_PK_PASSWORD_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PK - Given private key password does not allow for correct decryption" );
+ if( use_ret == -(MBEDTLS_ERR_PK_INVALID_PUBKEY) )
+ mbedtls_snprintf( buf, buflen, "PK - The pubkey tag or value is invalid (only RSA and EC are supported)" );
+ if( use_ret == -(MBEDTLS_ERR_PK_INVALID_ALG) )
+ mbedtls_snprintf( buf, buflen, "PK - The algorithm tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE) )
+ mbedtls_snprintf( buf, buflen, "PK - Elliptic curve is unsupported (only NIST curves are supported)" );
+ if( use_ret == -(MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "PK - Unavailable feature, e.g. RSA disabled for RSA key" );
+ if( use_ret == -(MBEDTLS_ERR_PK_SIG_LEN_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PK - The signature is valid but its length is less than expected" );
+#endif /* MBEDTLS_PK_C */
-#if defined(POLARSSL_PKCS12_C)
- if( use_ret == -(POLARSSL_ERR_PKCS12_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "PKCS12 - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "PKCS12 - Feature not available, e.g. unsupported encryption scheme" );
- if( use_ret == -(POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT) )
- polarssl_snprintf( buf, buflen, "PKCS12 - PBE ASN.1 data not as expected" );
- if( use_ret == -(POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PKCS12 - Given private key password does not allow for correct decryption" );
-#endif /* POLARSSL_PKCS12_C */
+#if defined(MBEDTLS_PKCS12_C)
+ if( use_ret == -(MBEDTLS_ERR_PKCS12_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "PKCS12 - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "PKCS12 - Feature not available, e.g. unsupported encryption scheme" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "PKCS12 - PBE ASN.1 data not as expected" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PKCS12 - Given private key password does not allow for correct decryption" );
+#endif /* MBEDTLS_PKCS12_C */
-#if defined(POLARSSL_PKCS5_C)
- if( use_ret == -(POLARSSL_ERR_PKCS5_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "PKCS5 - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_PKCS5_INVALID_FORMAT) )
- polarssl_snprintf( buf, buflen, "PKCS5 - Unexpected ASN.1 data" );
- if( use_ret == -(POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "PKCS5 - Requested encryption or digest alg not available" );
- if( use_ret == -(POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH) )
- polarssl_snprintf( buf, buflen, "PKCS5 - Given private key password does not allow for correct decryption" );
-#endif /* POLARSSL_PKCS5_C */
+#if defined(MBEDTLS_PKCS5_C)
+ if( use_ret == -(MBEDTLS_ERR_PKCS5_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "PKCS5 - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS5_INVALID_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "PKCS5 - Unexpected ASN.1 data" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "PKCS5 - Requested encryption or digest alg not available" );
+ if( use_ret == -(MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "PKCS5 - Given private key password does not allow for correct decryption" );
+#endif /* MBEDTLS_PKCS5_C */
-#if defined(POLARSSL_RSA_C)
- if( use_ret == -(POLARSSL_ERR_RSA_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "RSA - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_RSA_INVALID_PADDING) )
- polarssl_snprintf( buf, buflen, "RSA - Input data contains invalid padding and is rejected" );
- if( use_ret == -(POLARSSL_ERR_RSA_KEY_GEN_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - Something failed during generation of a key" );
- if( use_ret == -(POLARSSL_ERR_RSA_KEY_CHECK_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - Key failed to pass the libraries validity check" );
- if( use_ret == -(POLARSSL_ERR_RSA_PUBLIC_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - The public key operation failed" );
- if( use_ret == -(POLARSSL_ERR_RSA_PRIVATE_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - The private key operation failed" );
- if( use_ret == -(POLARSSL_ERR_RSA_VERIFY_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - The PKCS#1 verification failed" );
- if( use_ret == -(POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE) )
- polarssl_snprintf( buf, buflen, "RSA - The output buffer for decryption is not large enough" );
- if( use_ret == -(POLARSSL_ERR_RSA_RNG_FAILED) )
- polarssl_snprintf( buf, buflen, "RSA - The random generator failed to generate non-zeros" );
-#endif /* POLARSSL_RSA_C */
+#if defined(MBEDTLS_RSA_C)
+ if( use_ret == -(MBEDTLS_ERR_RSA_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "RSA - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_INVALID_PADDING) )
+ mbedtls_snprintf( buf, buflen, "RSA - Input data contains invalid padding and is rejected" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_KEY_GEN_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - Something failed during generation of a key" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_KEY_CHECK_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - Key failed to pass the libraries validity check" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_PUBLIC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - The public key operation failed" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_PRIVATE_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - The private key operation failed" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_VERIFY_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - The PKCS#1 verification failed" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE) )
+ mbedtls_snprintf( buf, buflen, "RSA - The output buffer for decryption is not large enough" );
+ if( use_ret == -(MBEDTLS_ERR_RSA_RNG_FAILED) )
+ mbedtls_snprintf( buf, buflen, "RSA - The random generator failed to generate non-zeros" );
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_SSL_TLS_C)
- if( use_ret == -(POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "SSL - The requested feature is not available" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "SSL - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_SSL_INVALID_MAC) )
- polarssl_snprintf( buf, buflen, "SSL - Verification of the message MAC failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_INVALID_RECORD) )
- polarssl_snprintf( buf, buflen, "SSL - An invalid SSL record was received" );
- if( use_ret == -(POLARSSL_ERR_SSL_CONN_EOF) )
- polarssl_snprintf( buf, buflen, "SSL - The connection indicated an EOF" );
- if( use_ret == -(POLARSSL_ERR_SSL_UNKNOWN_CIPHER) )
- polarssl_snprintf( buf, buflen, "SSL - An unknown cipher was received" );
- if( use_ret == -(POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN) )
- polarssl_snprintf( buf, buflen, "SSL - The server has no ciphersuites in common with the client" );
- if( use_ret == -(POLARSSL_ERR_SSL_NO_RNG) )
- polarssl_snprintf( buf, buflen, "SSL - No RNG was provided to the SSL module" );
- if( use_ret == -(POLARSSL_ERR_SSL_NO_CLIENT_CERTIFICATE) )
- polarssl_snprintf( buf, buflen, "SSL - No client certification received from the client, but required by the authentication mode" );
- if( use_ret == -(POLARSSL_ERR_SSL_CERTIFICATE_TOO_LARGE) )
- polarssl_snprintf( buf, buflen, "SSL - Our own certificate(s) is/are too large to send in an SSL message" );
- if( use_ret == -(POLARSSL_ERR_SSL_CERTIFICATE_REQUIRED) )
- polarssl_snprintf( buf, buflen, "SSL - The own certificate is not set, but needed by the server" );
- if( use_ret == -(POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED) )
- polarssl_snprintf( buf, buflen, "SSL - The own private key or pre-shared key is not set, but needed" );
- if( use_ret == -(POLARSSL_ERR_SSL_CA_CHAIN_REQUIRED) )
- polarssl_snprintf( buf, buflen, "SSL - No CA Chain is set, but required to operate" );
- if( use_ret == -(POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE) )
- polarssl_snprintf( buf, buflen, "SSL - An unexpected message was received from our peer" );
- if( use_ret == -(POLARSSL_ERR_SSL_FATAL_ALERT_MESSAGE) )
+#if defined(MBEDTLS_SSL_TLS_C)
+ if( use_ret == -(MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "SSL - The requested feature is not available" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "SSL - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_INVALID_MAC) )
+ mbedtls_snprintf( buf, buflen, "SSL - Verification of the message MAC failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_INVALID_RECORD) )
+ mbedtls_snprintf( buf, buflen, "SSL - An invalid SSL record was received" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_CONN_EOF) )
+ mbedtls_snprintf( buf, buflen, "SSL - The connection indicated an EOF" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_UNKNOWN_CIPHER) )
+ mbedtls_snprintf( buf, buflen, "SSL - An unknown cipher was received" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN) )
+ mbedtls_snprintf( buf, buflen, "SSL - The server has no ciphersuites in common with the client" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_NO_RNG) )
+ mbedtls_snprintf( buf, buflen, "SSL - No RNG was provided to the SSL module" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE) )
+ mbedtls_snprintf( buf, buflen, "SSL - No client certification received from the client, but required by the authentication mode" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE) )
+ mbedtls_snprintf( buf, buflen, "SSL - Our own certificate(s) is/are too large to send in an SSL message" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "SSL - The own certificate is not set, but needed by the server" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "SSL - The own private key or pre-shared key is not set, but needed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "SSL - No CA Chain is set, but required to operate" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE) )
+ mbedtls_snprintf( buf, buflen, "SSL - An unexpected message was received from our peer" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE) )
{
- polarssl_snprintf( buf, buflen, "SSL - A fatal alert message was received from our peer" );
+ mbedtls_snprintf( buf, buflen, "SSL - A fatal alert message was received from our peer" );
return;
}
- if( use_ret == -(POLARSSL_ERR_SSL_PEER_VERIFY_FAILED) )
- polarssl_snprintf( buf, buflen, "SSL - Verification of our peer failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY) )
- polarssl_snprintf( buf, buflen, "SSL - The peer notified us that the connection is going to be closed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientHello handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerHello handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the Certificate handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the CertificateRequest handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerKeyExchange handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerHelloDone handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the CertificateVerify handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the ChangeCipherSpec handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_FINISHED) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the Finished handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "SSL - Memory allocation failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_HW_ACCEL_FAILED) )
- polarssl_snprintf( buf, buflen, "SSL - Hardware acceleration function returned with error" );
- if( use_ret == -(POLARSSL_ERR_SSL_HW_ACCEL_FALLTHROUGH) )
- polarssl_snprintf( buf, buflen, "SSL - Hardware acceleration function skipped / left alone data" );
- if( use_ret == -(POLARSSL_ERR_SSL_COMPRESSION_FAILED) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the compression / decompression failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION) )
- polarssl_snprintf( buf, buflen, "SSL - Handshake protocol not within min/max boundaries" );
- if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) )
- polarssl_snprintf( buf, buflen, "SSL - Processing of the NewSessionTicket handshake message failed" );
- if( use_ret == -(POLARSSL_ERR_SSL_SESSION_TICKET_EXPIRED) )
- polarssl_snprintf( buf, buflen, "SSL - Session ticket has expired" );
- if( use_ret == -(POLARSSL_ERR_SSL_PK_TYPE_MISMATCH) )
- polarssl_snprintf( buf, buflen, "SSL - Public key type mismatch (eg, asked for RSA key exchange and presented EC key)" );
- if( use_ret == -(POLARSSL_ERR_SSL_UNKNOWN_IDENTITY) )
- polarssl_snprintf( buf, buflen, "SSL - Unknown identity received (eg, PSK identity)" );
- if( use_ret == -(POLARSSL_ERR_SSL_INTERNAL_ERROR) )
- polarssl_snprintf( buf, buflen, "SSL - Internal error (eg, unexpected failure in lower-level module)" );
- if( use_ret == -(POLARSSL_ERR_SSL_COUNTER_WRAPPING) )
- polarssl_snprintf( buf, buflen, "SSL - A counter would wrap (eg, too many messages exchanged)" );
- if( use_ret == -(POLARSSL_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) )
- polarssl_snprintf( buf, buflen, "SSL - Unexpected message at ServerHello in renegotiation" );
- if( use_ret == -(POLARSSL_ERR_SSL_HELLO_VERIFY_REQUIRED) )
- polarssl_snprintf( buf, buflen, "SSL - DTLS client must retry for hello verification" );
- if( use_ret == -(POLARSSL_ERR_SSL_BUFFER_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "SSL - A buffer is too small to receive or write a message" );
- if( use_ret == -(POLARSSL_ERR_SSL_NO_USABLE_CIPHERSUITE) )
- polarssl_snprintf( buf, buflen, "SSL - None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages)" );
-#endif /* POLARSSL_SSL_TLS_C */
+ if( use_ret == -(MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Verification of our peer failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) )
+ mbedtls_snprintf( buf, buflen, "SSL - The peer notified us that the connection is going to be closed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientHello handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerHello handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the Certificate handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the CertificateRequest handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerKeyExchange handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerHelloDone handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the CertificateVerify handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the ChangeCipherSpec handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_FINISHED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the Finished handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Memory allocation failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_HW_ACCEL_FAILED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Hardware acceleration function returned with error" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH) )
+ mbedtls_snprintf( buf, buflen, "SSL - Hardware acceleration function skipped / left alone data" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_COMPRESSION_FAILED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the compression / decompression failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION) )
+ mbedtls_snprintf( buf, buflen, "SSL - Handshake protocol not within min/max boundaries" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) )
+ mbedtls_snprintf( buf, buflen, "SSL - Processing of the NewSessionTicket handshake message failed" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED) )
+ mbedtls_snprintf( buf, buflen, "SSL - Session ticket has expired" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "SSL - Public key type mismatch (eg, asked for RSA key exchange and presented EC key)" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY) )
+ mbedtls_snprintf( buf, buflen, "SSL - Unknown identity received (eg, PSK identity)" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_INTERNAL_ERROR) )
+ mbedtls_snprintf( buf, buflen, "SSL - Internal error (eg, unexpected failure in lower-level module)" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_COUNTER_WRAPPING) )
+ mbedtls_snprintf( buf, buflen, "SSL - A counter would wrap (eg, too many messages exchanged)" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) )
+ mbedtls_snprintf( buf, buflen, "SSL - Unexpected message at ServerHello in renegotiation" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) )
+ mbedtls_snprintf( buf, buflen, "SSL - DTLS client must retry for hello verification" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "SSL - A buffer is too small to receive or write a message" );
+ if( use_ret == -(MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE) )
+ mbedtls_snprintf( buf, buflen, "SSL - None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages)" );
+#endif /* MBEDTLS_SSL_TLS_C */
-#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
- if( use_ret == -(POLARSSL_ERR_X509_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "X509 - Unavailable feature, e.g. RSA hashing/encryption combination" );
- if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_OID) )
- polarssl_snprintf( buf, buflen, "X509 - Requested OID is unknown" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_FORMAT) )
- polarssl_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR format is invalid, e.g. different type expected" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_VERSION) )
- polarssl_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR version element is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_SERIAL) )
- polarssl_snprintf( buf, buflen, "X509 - The serial tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_ALG) )
- polarssl_snprintf( buf, buflen, "X509 - The algorithm tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_NAME) )
- polarssl_snprintf( buf, buflen, "X509 - The name tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_DATE) )
- polarssl_snprintf( buf, buflen, "X509 - The date tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_SIGNATURE) )
- polarssl_snprintf( buf, buflen, "X509 - The signature tag or value invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_INVALID_EXTENSIONS) )
- polarssl_snprintf( buf, buflen, "X509 - The extension tag or value is invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_VERSION) )
- polarssl_snprintf( buf, buflen, "X509 - CRT/CRL/CSR has an unsupported version number" );
- if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_SIG_ALG) )
- polarssl_snprintf( buf, buflen, "X509 - Signature algorithm (oid) is unsupported" );
- if( use_ret == -(POLARSSL_ERR_X509_SIG_MISMATCH) )
- polarssl_snprintf( buf, buflen, "X509 - Signature algorithms do not match. (see \\c ::x509_crt sig_oid)" );
- if( use_ret == -(POLARSSL_ERR_X509_CERT_VERIFY_FAILED) )
- polarssl_snprintf( buf, buflen, "X509 - Certificate verification failed, e.g. CRL, CA or signature check failed" );
- if( use_ret == -(POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT) )
- polarssl_snprintf( buf, buflen, "X509 - Format not recognized as DER or PEM" );
- if( use_ret == -(POLARSSL_ERR_X509_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "X509 - Input invalid" );
- if( use_ret == -(POLARSSL_ERR_X509_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "X509 - Allocation of memory failed" );
- if( use_ret == -(POLARSSL_ERR_X509_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "X509 - Read/write of file failed" );
-#endif /* POLARSSL_X509_USE,X509_CREATE_C */
+#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
+ if( use_ret == -(MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "X509 - Unavailable feature, e.g. RSA hashing/encryption combination" );
+ if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_OID) )
+ mbedtls_snprintf( buf, buflen, "X509 - Requested OID is unknown" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR format is invalid, e.g. different type expected" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_VERSION) )
+ mbedtls_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR version element is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_SERIAL) )
+ mbedtls_snprintf( buf, buflen, "X509 - The serial tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_ALG) )
+ mbedtls_snprintf( buf, buflen, "X509 - The algorithm tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_NAME) )
+ mbedtls_snprintf( buf, buflen, "X509 - The name tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_DATE) )
+ mbedtls_snprintf( buf, buflen, "X509 - The date tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_SIGNATURE) )
+ mbedtls_snprintf( buf, buflen, "X509 - The signature tag or value invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_INVALID_EXTENSIONS) )
+ mbedtls_snprintf( buf, buflen, "X509 - The extension tag or value is invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_VERSION) )
+ mbedtls_snprintf( buf, buflen, "X509 - CRT/CRL/CSR has an unsupported version number" );
+ if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG) )
+ mbedtls_snprintf( buf, buflen, "X509 - Signature algorithm (oid) is unsupported" );
+ if( use_ret == -(MBEDTLS_ERR_X509_SIG_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "X509 - Signature algorithms do not match. (see \\c ::mbedtls_x509_crt sig_oid)" );
+ if( use_ret == -(MBEDTLS_ERR_X509_CERT_VERIFY_FAILED) )
+ mbedtls_snprintf( buf, buflen, "X509 - Certificate verification failed, e.g. CRL, CA or signature check failed" );
+ if( use_ret == -(MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT) )
+ mbedtls_snprintf( buf, buflen, "X509 - Format not recognized as DER or PEM" );
+ if( use_ret == -(MBEDTLS_ERR_X509_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "X509 - Input invalid" );
+ if( use_ret == -(MBEDTLS_ERR_X509_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "X509 - Allocation of memory failed" );
+ if( use_ret == -(MBEDTLS_ERR_X509_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "X509 - Read/write of file failed" );
+#endif /* MBEDTLS_X509_USE,X509_CREATE_C */
// END generated code
if( strlen( buf ) == 0 )
- polarssl_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
+ mbedtls_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
}
use_ret = ret & ~0xFF80;
@@ -518,7 +518,7 @@
if( buflen - len < 5 )
return;
- polarssl_snprintf( buf + len, buflen - len, " : " );
+ mbedtls_snprintf( buf + len, buflen - len, " : " );
buf += len + 3;
buflen -= len + 3;
@@ -527,225 +527,225 @@
// Low level error codes
//
// BEGIN generated code
-#if defined(POLARSSL_AES_C)
- if( use_ret == -(POLARSSL_ERR_AES_INVALID_KEY_LENGTH) )
- polarssl_snprintf( buf, buflen, "AES - Invalid key length" );
- if( use_ret == -(POLARSSL_ERR_AES_INVALID_INPUT_LENGTH) )
- polarssl_snprintf( buf, buflen, "AES - Invalid data input length" );
-#endif /* POLARSSL_AES_C */
+#if defined(MBEDTLS_AES_C)
+ if( use_ret == -(MBEDTLS_ERR_AES_INVALID_KEY_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "AES - Invalid key length" );
+ if( use_ret == -(MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "AES - Invalid data input length" );
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_ASN1_PARSE_C)
- if( use_ret == -(POLARSSL_ERR_ASN1_OUT_OF_DATA) )
- polarssl_snprintf( buf, buflen, "ASN1 - Out of data when parsing an ASN1 data structure" );
- if( use_ret == -(POLARSSL_ERR_ASN1_UNEXPECTED_TAG) )
- polarssl_snprintf( buf, buflen, "ASN1 - ASN1 tag was of an unexpected value" );
- if( use_ret == -(POLARSSL_ERR_ASN1_INVALID_LENGTH) )
- polarssl_snprintf( buf, buflen, "ASN1 - Error when trying to determine the length or invalid length" );
- if( use_ret == -(POLARSSL_ERR_ASN1_LENGTH_MISMATCH) )
- polarssl_snprintf( buf, buflen, "ASN1 - Actual length differs from expected length" );
- if( use_ret == -(POLARSSL_ERR_ASN1_INVALID_DATA) )
- polarssl_snprintf( buf, buflen, "ASN1 - Data is invalid. (not used)" );
- if( use_ret == -(POLARSSL_ERR_ASN1_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "ASN1 - Memory allocation failed" );
- if( use_ret == -(POLARSSL_ERR_ASN1_BUF_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "ASN1 - Buffer too small when writing ASN.1 data structure" );
-#endif /* POLARSSL_ASN1_PARSE_C */
+#if defined(MBEDTLS_ASN1_PARSE_C)
+ if( use_ret == -(MBEDTLS_ERR_ASN1_OUT_OF_DATA) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Out of data when parsing an ASN1 data structure" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_UNEXPECTED_TAG) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - ASN1 tag was of an unexpected value" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_INVALID_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Error when trying to determine the length or invalid length" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_LENGTH_MISMATCH) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Actual length differs from expected length" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_INVALID_DATA) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Data is invalid. (not used)" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Memory allocation failed" );
+ if( use_ret == -(MBEDTLS_ERR_ASN1_BUF_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "ASN1 - Buffer too small when writing ASN.1 data structure" );
+#endif /* MBEDTLS_ASN1_PARSE_C */
-#if defined(POLARSSL_BASE64_C)
- if( use_ret == -(POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "BASE64 - Output buffer too small" );
- if( use_ret == -(POLARSSL_ERR_BASE64_INVALID_CHARACTER) )
- polarssl_snprintf( buf, buflen, "BASE64 - Invalid character in input" );
-#endif /* POLARSSL_BASE64_C */
+#if defined(MBEDTLS_BASE64_C)
+ if( use_ret == -(MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "BASE64 - Output buffer too small" );
+ if( use_ret == -(MBEDTLS_ERR_BASE64_INVALID_CHARACTER) )
+ mbedtls_snprintf( buf, buflen, "BASE64 - Invalid character in input" );
+#endif /* MBEDTLS_BASE64_C */
-#if defined(POLARSSL_BIGNUM_C)
- if( use_ret == -(POLARSSL_ERR_MPI_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "BIGNUM - An error occurred while reading from or writing to a file" );
- if( use_ret == -(POLARSSL_ERR_MPI_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "BIGNUM - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_MPI_INVALID_CHARACTER) )
- polarssl_snprintf( buf, buflen, "BIGNUM - There is an invalid character in the digit string" );
- if( use_ret == -(POLARSSL_ERR_MPI_BUFFER_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "BIGNUM - The buffer is too small to write to" );
- if( use_ret == -(POLARSSL_ERR_MPI_NEGATIVE_VALUE) )
- polarssl_snprintf( buf, buflen, "BIGNUM - The input arguments are negative or result in illegal output" );
- if( use_ret == -(POLARSSL_ERR_MPI_DIVISION_BY_ZERO) )
- polarssl_snprintf( buf, buflen, "BIGNUM - The input argument for division is zero, which is not allowed" );
- if( use_ret == -(POLARSSL_ERR_MPI_NOT_ACCEPTABLE) )
- polarssl_snprintf( buf, buflen, "BIGNUM - The input arguments are not acceptable" );
- if( use_ret == -(POLARSSL_ERR_MPI_MALLOC_FAILED) )
- polarssl_snprintf( buf, buflen, "BIGNUM - Memory allocation failed" );
-#endif /* POLARSSL_BIGNUM_C */
+#if defined(MBEDTLS_BIGNUM_C)
+ if( use_ret == -(MBEDTLS_ERR_MPI_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - An error occurred while reading from or writing to a file" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_INVALID_CHARACTER) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - There is an invalid character in the digit string" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - The buffer is too small to write to" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_NEGATIVE_VALUE) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - The input arguments are negative or result in illegal output" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_DIVISION_BY_ZERO) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - The input argument for division is zero, which is not allowed" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_NOT_ACCEPTABLE) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - The input arguments are not acceptable" );
+ if( use_ret == -(MBEDTLS_ERR_MPI_MALLOC_FAILED) )
+ mbedtls_snprintf( buf, buflen, "BIGNUM - Memory allocation failed" );
+#endif /* MBEDTLS_BIGNUM_C */
-#if defined(POLARSSL_BLOWFISH_C)
- if( use_ret == -(POLARSSL_ERR_BLOWFISH_INVALID_KEY_LENGTH) )
- polarssl_snprintf( buf, buflen, "BLOWFISH - Invalid key length" );
- if( use_ret == -(POLARSSL_ERR_BLOWFISH_INVALID_INPUT_LENGTH) )
- polarssl_snprintf( buf, buflen, "BLOWFISH - Invalid data input length" );
-#endif /* POLARSSL_BLOWFISH_C */
+#if defined(MBEDTLS_BLOWFISH_C)
+ if( use_ret == -(MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "BLOWFISH - Invalid key length" );
+ if( use_ret == -(MBEDTLS_ERR_BLOWFISH_INVALID_INPUT_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "BLOWFISH - Invalid data input length" );
+#endif /* MBEDTLS_BLOWFISH_C */
-#if defined(POLARSSL_CAMELLIA_C)
- if( use_ret == -(POLARSSL_ERR_CAMELLIA_INVALID_KEY_LENGTH) )
- polarssl_snprintf( buf, buflen, "CAMELLIA - Invalid key length" );
- if( use_ret == -(POLARSSL_ERR_CAMELLIA_INVALID_INPUT_LENGTH) )
- polarssl_snprintf( buf, buflen, "CAMELLIA - Invalid data input length" );
-#endif /* POLARSSL_CAMELLIA_C */
+#if defined(MBEDTLS_CAMELLIA_C)
+ if( use_ret == -(MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "CAMELLIA - Invalid key length" );
+ if( use_ret == -(MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "CAMELLIA - Invalid data input length" );
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_CCM_C)
- if( use_ret == -(POLARSSL_ERR_CCM_BAD_INPUT) )
- polarssl_snprintf( buf, buflen, "CCM - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_CCM_AUTH_FAILED) )
- polarssl_snprintf( buf, buflen, "CCM - Authenticated decryption failed" );
-#endif /* POLARSSL_CCM_C */
+#if defined(MBEDTLS_CCM_C)
+ if( use_ret == -(MBEDTLS_ERR_CCM_BAD_INPUT) )
+ mbedtls_snprintf( buf, buflen, "CCM - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_CCM_AUTH_FAILED) )
+ mbedtls_snprintf( buf, buflen, "CCM - Authenticated decryption failed" );
+#endif /* MBEDTLS_CCM_C */
-#if defined(POLARSSL_CTR_DRBG_C)
- if( use_ret == -(POLARSSL_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED) )
- polarssl_snprintf( buf, buflen, "CTR_DRBG - The entropy source failed" );
- if( use_ret == -(POLARSSL_ERR_CTR_DRBG_REQUEST_TOO_BIG) )
- polarssl_snprintf( buf, buflen, "CTR_DRBG - Too many random requested in single call" );
- if( use_ret == -(POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG) )
- polarssl_snprintf( buf, buflen, "CTR_DRBG - Input too large (Entropy + additional)" );
- if( use_ret == -(POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "CTR_DRBG - Read/write error in file" );
-#endif /* POLARSSL_CTR_DRBG_C */
+#if defined(MBEDTLS_CTR_DRBG_C)
+ if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED) )
+ mbedtls_snprintf( buf, buflen, "CTR_DRBG - The entropy source failed" );
+ if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG) )
+ mbedtls_snprintf( buf, buflen, "CTR_DRBG - Too many random requested in single call" );
+ if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG) )
+ mbedtls_snprintf( buf, buflen, "CTR_DRBG - Input too large (Entropy + additional)" );
+ if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "CTR_DRBG - Read/write error in file" );
+#endif /* MBEDTLS_CTR_DRBG_C */
-#if defined(POLARSSL_DES_C)
- if( use_ret == -(POLARSSL_ERR_DES_INVALID_INPUT_LENGTH) )
- polarssl_snprintf( buf, buflen, "DES - The data input has an invalid length" );
-#endif /* POLARSSL_DES_C */
+#if defined(MBEDTLS_DES_C)
+ if( use_ret == -(MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "DES - The data input has an invalid length" );
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ENTROPY_C)
- if( use_ret == -(POLARSSL_ERR_ENTROPY_SOURCE_FAILED) )
- polarssl_snprintf( buf, buflen, "ENTROPY - Critical entropy source failure" );
- if( use_ret == -(POLARSSL_ERR_ENTROPY_MAX_SOURCES) )
- polarssl_snprintf( buf, buflen, "ENTROPY - No more sources can be added" );
- if( use_ret == -(POLARSSL_ERR_ENTROPY_NO_SOURCES_DEFINED) )
- polarssl_snprintf( buf, buflen, "ENTROPY - No sources have been added to poll" );
- if( use_ret == -(POLARSSL_ERR_ENTROPY_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "ENTROPY - Read/write error in file" );
-#endif /* POLARSSL_ENTROPY_C */
+#if defined(MBEDTLS_ENTROPY_C)
+ if( use_ret == -(MBEDTLS_ERR_ENTROPY_SOURCE_FAILED) )
+ mbedtls_snprintf( buf, buflen, "ENTROPY - Critical entropy source failure" );
+ if( use_ret == -(MBEDTLS_ERR_ENTROPY_MAX_SOURCES) )
+ mbedtls_snprintf( buf, buflen, "ENTROPY - No more sources can be added" );
+ if( use_ret == -(MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED) )
+ mbedtls_snprintf( buf, buflen, "ENTROPY - No sources have been added to poll" );
+ if( use_ret == -(MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "ENTROPY - Read/write error in file" );
+#endif /* MBEDTLS_ENTROPY_C */
-#if defined(POLARSSL_GCM_C)
- if( use_ret == -(POLARSSL_ERR_GCM_AUTH_FAILED) )
- polarssl_snprintf( buf, buflen, "GCM - Authenticated decryption failed" );
- if( use_ret == -(POLARSSL_ERR_GCM_BAD_INPUT) )
- polarssl_snprintf( buf, buflen, "GCM - Bad input parameters to function" );
-#endif /* POLARSSL_GCM_C */
+#if defined(MBEDTLS_GCM_C)
+ if( use_ret == -(MBEDTLS_ERR_GCM_AUTH_FAILED) )
+ mbedtls_snprintf( buf, buflen, "GCM - Authenticated decryption failed" );
+ if( use_ret == -(MBEDTLS_ERR_GCM_BAD_INPUT) )
+ mbedtls_snprintf( buf, buflen, "GCM - Bad input parameters to function" );
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_HMAC_DRBG_C)
- if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_REQUEST_TOO_BIG) )
- polarssl_snprintf( buf, buflen, "HMAC_DRBG - Too many random requested in single call" );
- if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_INPUT_TOO_BIG) )
- polarssl_snprintf( buf, buflen, "HMAC_DRBG - Input too large (Entropy + additional)" );
- if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "HMAC_DRBG - Read/write error in file" );
- if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED) )
- polarssl_snprintf( buf, buflen, "HMAC_DRBG - The entropy source failed" );
-#endif /* POLARSSL_HMAC_DRBG_C */
+#if defined(MBEDTLS_HMAC_DRBG_C)
+ if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_REQUEST_TOO_BIG) )
+ mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Too many random requested in single call" );
+ if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG) )
+ mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Input too large (Entropy + additional)" );
+ if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Read/write error in file" );
+ if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED) )
+ mbedtls_snprintf( buf, buflen, "HMAC_DRBG - The entropy source failed" );
+#endif /* MBEDTLS_HMAC_DRBG_C */
-#if defined(POLARSSL_MD2_C)
- if( use_ret == -(POLARSSL_ERR_MD2_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "MD2 - Read/write error in file" );
-#endif /* POLARSSL_MD2_C */
+#if defined(MBEDTLS_MD2_C)
+ if( use_ret == -(MBEDTLS_ERR_MD2_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "MD2 - Read/write error in file" );
+#endif /* MBEDTLS_MD2_C */
-#if defined(POLARSSL_MD4_C)
- if( use_ret == -(POLARSSL_ERR_MD4_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "MD4 - Read/write error in file" );
-#endif /* POLARSSL_MD4_C */
+#if defined(MBEDTLS_MD4_C)
+ if( use_ret == -(MBEDTLS_ERR_MD4_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "MD4 - Read/write error in file" );
+#endif /* MBEDTLS_MD4_C */
-#if defined(POLARSSL_MD5_C)
- if( use_ret == -(POLARSSL_ERR_MD5_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "MD5 - Read/write error in file" );
-#endif /* POLARSSL_MD5_C */
+#if defined(MBEDTLS_MD5_C)
+ if( use_ret == -(MBEDTLS_ERR_MD5_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "MD5 - Read/write error in file" );
+#endif /* MBEDTLS_MD5_C */
-#if defined(POLARSSL_NET_C)
- if( use_ret == -(POLARSSL_ERR_NET_SOCKET_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Failed to open a socket" );
- if( use_ret == -(POLARSSL_ERR_NET_CONNECT_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - The connection to the given server / port failed" );
- if( use_ret == -(POLARSSL_ERR_NET_BIND_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Binding of the socket failed" );
- if( use_ret == -(POLARSSL_ERR_NET_LISTEN_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Could not listen on the socket" );
- if( use_ret == -(POLARSSL_ERR_NET_ACCEPT_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Could not accept the incoming connection" );
- if( use_ret == -(POLARSSL_ERR_NET_RECV_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Reading information from the socket failed" );
- if( use_ret == -(POLARSSL_ERR_NET_SEND_FAILED) )
- polarssl_snprintf( buf, buflen, "NET - Sending information through the socket failed" );
- if( use_ret == -(POLARSSL_ERR_NET_CONN_RESET) )
- polarssl_snprintf( buf, buflen, "NET - Connection was reset by peer" );
- if( use_ret == -(POLARSSL_ERR_NET_WANT_READ) )
- polarssl_snprintf( buf, buflen, "NET - Connection requires a read call" );
- if( use_ret == -(POLARSSL_ERR_NET_WANT_WRITE) )
- polarssl_snprintf( buf, buflen, "NET - Connection requires a write call" );
- if( use_ret == -(POLARSSL_ERR_NET_UNKNOWN_HOST) )
- polarssl_snprintf( buf, buflen, "NET - Failed to get an IP address for the given hostname" );
- if( use_ret == -(POLARSSL_ERR_NET_TIMEOUT) )
- polarssl_snprintf( buf, buflen, "NET - The operation timed out" );
-#endif /* POLARSSL_NET_C */
+#if defined(MBEDTLS_NET_C)
+ if( use_ret == -(MBEDTLS_ERR_NET_SOCKET_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Failed to open a socket" );
+ if( use_ret == -(MBEDTLS_ERR_NET_CONNECT_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - The connection to the given server / port failed" );
+ if( use_ret == -(MBEDTLS_ERR_NET_BIND_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Binding of the socket failed" );
+ if( use_ret == -(MBEDTLS_ERR_NET_LISTEN_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Could not listen on the socket" );
+ if( use_ret == -(MBEDTLS_ERR_NET_ACCEPT_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Could not accept the incoming connection" );
+ if( use_ret == -(MBEDTLS_ERR_NET_RECV_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Reading information from the socket failed" );
+ if( use_ret == -(MBEDTLS_ERR_NET_SEND_FAILED) )
+ mbedtls_snprintf( buf, buflen, "NET - Sending information through the socket failed" );
+ if( use_ret == -(MBEDTLS_ERR_NET_CONN_RESET) )
+ mbedtls_snprintf( buf, buflen, "NET - Connection was reset by peer" );
+ if( use_ret == -(MBEDTLS_ERR_NET_WANT_READ) )
+ mbedtls_snprintf( buf, buflen, "NET - Connection requires a read call" );
+ if( use_ret == -(MBEDTLS_ERR_NET_WANT_WRITE) )
+ mbedtls_snprintf( buf, buflen, "NET - Connection requires a write call" );
+ if( use_ret == -(MBEDTLS_ERR_NET_UNKNOWN_HOST) )
+ mbedtls_snprintf( buf, buflen, "NET - Failed to get an IP address for the given hostname" );
+ if( use_ret == -(MBEDTLS_ERR_NET_TIMEOUT) )
+ mbedtls_snprintf( buf, buflen, "NET - The operation timed out" );
+#endif /* MBEDTLS_NET_C */
-#if defined(POLARSSL_OID_C)
- if( use_ret == -(POLARSSL_ERR_OID_NOT_FOUND) )
- polarssl_snprintf( buf, buflen, "OID - OID is not found" );
- if( use_ret == -(POLARSSL_ERR_OID_BUF_TOO_SMALL) )
- polarssl_snprintf( buf, buflen, "OID - output buffer is too small" );
-#endif /* POLARSSL_OID_C */
+#if defined(MBEDTLS_OID_C)
+ if( use_ret == -(MBEDTLS_ERR_OID_NOT_FOUND) )
+ mbedtls_snprintf( buf, buflen, "OID - OID is not found" );
+ if( use_ret == -(MBEDTLS_ERR_OID_BUF_TOO_SMALL) )
+ mbedtls_snprintf( buf, buflen, "OID - output buffer is too small" );
+#endif /* MBEDTLS_OID_C */
-#if defined(POLARSSL_PADLOCK_C)
- if( use_ret == -(POLARSSL_ERR_PADLOCK_DATA_MISALIGNED) )
- polarssl_snprintf( buf, buflen, "PADLOCK - Input data should be aligned" );
-#endif /* POLARSSL_PADLOCK_C */
+#if defined(MBEDTLS_PADLOCK_C)
+ if( use_ret == -(MBEDTLS_ERR_PADLOCK_DATA_MISALIGNED) )
+ mbedtls_snprintf( buf, buflen, "PADLOCK - Input data should be aligned" );
+#endif /* MBEDTLS_PADLOCK_C */
-#if defined(POLARSSL_RIPEMD160_C)
- if( use_ret == -(POLARSSL_ERR_RIPEMD160_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "RIPEMD160 - Read/write error in file" );
-#endif /* POLARSSL_RIPEMD160_C */
+#if defined(MBEDTLS_RIPEMD160_C)
+ if( use_ret == -(MBEDTLS_ERR_RIPEMD160_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "RIPEMD160 - Read/write error in file" );
+#endif /* MBEDTLS_RIPEMD160_C */
-#if defined(POLARSSL_SHA1_C)
- if( use_ret == -(POLARSSL_ERR_SHA1_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "SHA1 - Read/write error in file" );
-#endif /* POLARSSL_SHA1_C */
+#if defined(MBEDTLS_SHA1_C)
+ if( use_ret == -(MBEDTLS_ERR_SHA1_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "SHA1 - Read/write error in file" );
+#endif /* MBEDTLS_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- if( use_ret == -(POLARSSL_ERR_SHA256_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "SHA256 - Read/write error in file" );
-#endif /* POLARSSL_SHA256_C */
+#if defined(MBEDTLS_SHA256_C)
+ if( use_ret == -(MBEDTLS_ERR_SHA256_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "SHA256 - Read/write error in file" );
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- if( use_ret == -(POLARSSL_ERR_SHA512_FILE_IO_ERROR) )
- polarssl_snprintf( buf, buflen, "SHA512 - Read/write error in file" );
-#endif /* POLARSSL_SHA512_C */
+#if defined(MBEDTLS_SHA512_C)
+ if( use_ret == -(MBEDTLS_ERR_SHA512_FILE_IO_ERROR) )
+ mbedtls_snprintf( buf, buflen, "SHA512 - Read/write error in file" );
+#endif /* MBEDTLS_SHA512_C */
-#if defined(POLARSSL_THREADING_C)
- if( use_ret == -(POLARSSL_ERR_THREADING_FEATURE_UNAVAILABLE) )
- polarssl_snprintf( buf, buflen, "THREADING - The selected feature is not available" );
- if( use_ret == -(POLARSSL_ERR_THREADING_BAD_INPUT_DATA) )
- polarssl_snprintf( buf, buflen, "THREADING - Bad input parameters to function" );
- if( use_ret == -(POLARSSL_ERR_THREADING_MUTEX_ERROR) )
- polarssl_snprintf( buf, buflen, "THREADING - Locking / unlocking / free failed with error code" );
-#endif /* POLARSSL_THREADING_C */
+#if defined(MBEDTLS_THREADING_C)
+ if( use_ret == -(MBEDTLS_ERR_THREADING_FEATURE_UNAVAILABLE) )
+ mbedtls_snprintf( buf, buflen, "THREADING - The selected feature is not available" );
+ if( use_ret == -(MBEDTLS_ERR_THREADING_BAD_INPUT_DATA) )
+ mbedtls_snprintf( buf, buflen, "THREADING - Bad input parameters to function" );
+ if( use_ret == -(MBEDTLS_ERR_THREADING_MUTEX_ERROR) )
+ mbedtls_snprintf( buf, buflen, "THREADING - Locking / unlocking / free failed with error code" );
+#endif /* MBEDTLS_THREADING_C */
-#if defined(POLARSSL_XTEA_C)
- if( use_ret == -(POLARSSL_ERR_XTEA_INVALID_INPUT_LENGTH) )
- polarssl_snprintf( buf, buflen, "XTEA - The data input has an invalid length" );
-#endif /* POLARSSL_XTEA_C */
+#if defined(MBEDTLS_XTEA_C)
+ if( use_ret == -(MBEDTLS_ERR_XTEA_INVALID_INPUT_LENGTH) )
+ mbedtls_snprintf( buf, buflen, "XTEA - The data input has an invalid length" );
+#endif /* MBEDTLS_XTEA_C */
// END generated code
if( strlen( buf ) != 0 )
return;
- polarssl_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
+ mbedtls_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
}
-#else /* POLARSSL_ERROR_C */
+#else /* MBEDTLS_ERROR_C */
-#if defined(POLARSSL_ERROR_STRERROR_DUMMY)
+#if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
/*
- * Provide an non-function in case POLARSSL_ERROR_C is not defined
+ * Provide an non-function in case MBEDTLS_ERROR_C is not defined
*/
-void polarssl_strerror( int ret, char *buf, size_t buflen )
+void mbedtls_strerror( int ret, char *buf, size_t buflen )
{
((void) ret);
@@ -753,6 +753,6 @@
buf[0] = '\0';
}
-#endif /* POLARSSL_ERROR_STRERROR_DUMMY */
+#endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
-#endif /* POLARSSL_ERROR_C */
+#endif /* MBEDTLS_ERROR_C */
diff --git a/library/gcm.c b/library/gcm.c
index d46f97d..fe7cf72 100644
--- a/library/gcm.c
+++ b/library/gcm.c
@@ -30,30 +30,30 @@
* [MGV] 4.1, pp. 12-13, to enhance speed without using too much memory.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_GCM_C)
+#if defined(MBEDTLS_GCM_C)
#include "mbedtls/gcm.h"
#include <string.h>
-#if defined(POLARSSL_AESNI_C)
+#if defined(MBEDTLS_AESNI_C)
#include "mbedtls/aesni.h"
#endif
-#if defined(POLARSSL_SELF_TEST) && defined(POLARSSL_AES_C)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST && POLARSSL_AES_C */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
/*
* 32-bit integer manipulation macros (big endian)
@@ -79,7 +79,7 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -91,7 +91,7 @@
* is the high-order bit of HH corresponds to P^0 and the low-order bit of HL
* corresponds to P^127.
*/
-static int gcm_gen_table( gcm_context *ctx )
+static int gcm_gen_table( mbedtls_gcm_context *ctx )
{
int ret, i, j;
uint64_t hi, lo;
@@ -100,7 +100,7 @@
size_t olen = 0;
memset( h, 0, 16 );
- if( ( ret = cipher_update( &ctx->cipher_ctx, h, 16, h, &olen ) ) != 0 )
+ if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, h, 16, h, &olen ) ) != 0 )
return( ret );
/* pack h as two 64-bits ints, big-endian */
@@ -116,9 +116,9 @@
ctx->HL[8] = vl;
ctx->HH[8] = vh;
-#if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
+#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
/* With CLMUL support, we need only h, not the rest of the table */
- if( aesni_supports( POLARSSL_AESNI_CLMUL ) )
+ if( mbedtls_aesni_supports( MBEDTLS_AESNI_CLMUL ) )
return( 0 );
#endif
@@ -151,28 +151,28 @@
return( 0 );
}
-int gcm_init( gcm_context *ctx, cipher_id_t cipher, const unsigned char *key,
+int mbedtls_gcm_init( mbedtls_gcm_context *ctx, mbedtls_cipher_id_t cipher, const unsigned char *key,
unsigned int keysize )
{
int ret;
- const cipher_info_t *cipher_info;
+ const mbedtls_cipher_info_t *cipher_info;
- memset( ctx, 0, sizeof(gcm_context) );
+ memset( ctx, 0, sizeof(mbedtls_gcm_context) );
- cipher_init( &ctx->cipher_ctx );
+ mbedtls_cipher_init( &ctx->cipher_ctx );
- cipher_info = cipher_info_from_values( cipher, keysize, POLARSSL_MODE_ECB );
+ cipher_info = mbedtls_cipher_info_from_values( cipher, keysize, MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
if( cipher_info->block_size != 16 )
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
- if( ( ret = cipher_init_ctx( &ctx->cipher_ctx, cipher_info ) ) != 0 )
+ if( ( ret = mbedtls_cipher_init_ctx( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
- if( ( ret = cipher_setkey( &ctx->cipher_ctx, key, keysize,
- POLARSSL_ENCRYPT ) ) != 0 )
+ if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keysize,
+ MBEDTLS_ENCRYPT ) ) != 0 )
{
return( ret );
}
@@ -200,15 +200,15 @@
* Sets output to x times H using the precomputed tables.
* x and output are seen as elements of GF(2^128) as in [MGV].
*/
-static void gcm_mult( gcm_context *ctx, const unsigned char x[16],
+static void gcm_mult( mbedtls_gcm_context *ctx, const unsigned char x[16],
unsigned char output[16] )
{
int i = 0;
unsigned char lo, hi, rem;
uint64_t zh, zl;
-#if defined(POLARSSL_AESNI_C) && defined(POLARSSL_HAVE_X86_64)
- if( aesni_supports( POLARSSL_AESNI_CLMUL ) ) {
+#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
+ if( mbedtls_aesni_supports( MBEDTLS_AESNI_CLMUL ) ) {
unsigned char h[16];
PUT_UINT32_BE( ctx->HH[8] >> 32, h, 0 );
@@ -216,10 +216,10 @@
PUT_UINT32_BE( ctx->HL[8] >> 32, h, 8 );
PUT_UINT32_BE( ctx->HL[8], h, 12 );
- aesni_gcm_mult( output, x, h );
+ mbedtls_aesni_gcm_mult( output, x, h );
return;
}
-#endif /* POLARSSL_AESNI_C && POLARSSL_HAVE_X86_64 */
+#endif /* MBEDTLS_AESNI_C && MBEDTLS_HAVE_X86_64 */
lo = x[15] & 0xf;
@@ -256,7 +256,7 @@
PUT_UINT32_BE( zl, output, 12 );
}
-int gcm_starts( gcm_context *ctx,
+int mbedtls_gcm_starts( mbedtls_gcm_context *ctx,
int mode,
const unsigned char *iv,
size_t iv_len,
@@ -273,7 +273,7 @@
if( ( (uint64_t) iv_len ) >> 61 != 0 ||
( (uint64_t) add_len ) >> 61 != 0 )
{
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
}
memset( ctx->y, 0x00, sizeof(ctx->y) );
@@ -313,7 +313,7 @@
gcm_mult( ctx, ctx->y, ctx->y );
}
- if( ( ret = cipher_update( &ctx->cipher_ctx, ctx->y, 16, ctx->base_ectr,
+ if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16, ctx->base_ectr,
&olen ) ) != 0 )
{
return( ret );
@@ -337,7 +337,7 @@
return( 0 );
}
-int gcm_update( gcm_context *ctx,
+int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *input,
unsigned char *output )
@@ -350,14 +350,14 @@
size_t use_len, olen = 0;
if( output > input && (size_t) ( output - input ) < length )
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
/* Total length is restricted to 2^39 - 256 bits, ie 2^36 - 2^5 bytes
* Also check for possible overflow */
if( ctx->len + length < ctx->len ||
(uint64_t) ctx->len + length > 0x03FFFFE0ull )
{
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
}
ctx->len += length;
@@ -371,7 +371,7 @@
if( ++ctx->y[i - 1] != 0 )
break;
- if( ( ret = cipher_update( &ctx->cipher_ctx, ctx->y, 16, ectr,
+ if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16, ectr,
&olen ) ) != 0 )
{
return( ret );
@@ -379,10 +379,10 @@
for( i = 0; i < use_len; i++ )
{
- if( ctx->mode == GCM_DECRYPT )
+ if( ctx->mode == MBEDTLS_GCM_DECRYPT )
ctx->buf[i] ^= p[i];
out_p[i] = ectr[i] ^ p[i];
- if( ctx->mode == GCM_ENCRYPT )
+ if( ctx->mode == MBEDTLS_GCM_ENCRYPT )
ctx->buf[i] ^= out_p[i];
}
@@ -396,7 +396,7 @@
return( 0 );
}
-int gcm_finish( gcm_context *ctx,
+int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
unsigned char *tag,
size_t tag_len )
{
@@ -406,7 +406,7 @@
uint64_t orig_add_len = ctx->add_len * 8;
if( tag_len > 16 || tag_len < 4 )
- return( POLARSSL_ERR_GCM_BAD_INPUT );
+ return( MBEDTLS_ERR_GCM_BAD_INPUT );
if( tag_len != 0 )
memcpy( tag, ctx->base_ectr, tag_len );
@@ -432,7 +432,7 @@
return( 0 );
}
-int gcm_crypt_and_tag( gcm_context *ctx,
+int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
int mode,
size_t length,
const unsigned char *iv,
@@ -446,19 +446,19 @@
{
int ret;
- if( ( ret = gcm_starts( ctx, mode, iv, iv_len, add, add_len ) ) != 0 )
+ if( ( ret = mbedtls_gcm_starts( ctx, mode, iv, iv_len, add, add_len ) ) != 0 )
return( ret );
- if( ( ret = gcm_update( ctx, length, input, output ) ) != 0 )
+ if( ( ret = mbedtls_gcm_update( ctx, length, input, output ) ) != 0 )
return( ret );
- if( ( ret = gcm_finish( ctx, tag, tag_len ) ) != 0 )
+ if( ( ret = mbedtls_gcm_finish( ctx, tag, tag_len ) ) != 0 )
return( ret );
return( 0 );
}
-int gcm_auth_decrypt( gcm_context *ctx,
+int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *iv,
size_t iv_len,
@@ -474,7 +474,7 @@
size_t i;
int diff;
- if( ( ret = gcm_crypt_and_tag( ctx, GCM_DECRYPT, length,
+ if( ( ret = mbedtls_gcm_crypt_and_tag( ctx, MBEDTLS_GCM_DECRYPT, length,
iv, iv_len, add, add_len,
input, output, tag_len, check_tag ) ) != 0 )
{
@@ -487,20 +487,20 @@
if( diff != 0 )
{
- polarssl_zeroize( output, length );
- return( POLARSSL_ERR_GCM_AUTH_FAILED );
+ mbedtls_zeroize( output, length );
+ return( MBEDTLS_ERR_GCM_AUTH_FAILED );
}
return( 0 );
}
-void gcm_free( gcm_context *ctx )
+void mbedtls_gcm_free( mbedtls_gcm_context *ctx )
{
- cipher_free( &ctx->cipher_ctx );
- polarssl_zeroize( ctx, sizeof( gcm_context ) );
+ mbedtls_cipher_free( &ctx->cipher_ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_gcm_context ) );
}
-#if defined(POLARSSL_SELF_TEST) && defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
/*
* AES-GCM test vectors from:
*
@@ -728,13 +728,13 @@
0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a },
};
-int gcm_self_test( int verbose )
+int mbedtls_gcm_self_test( int verbose )
{
- gcm_context ctx;
+ mbedtls_gcm_context ctx;
unsigned char buf[64];
unsigned char tag_buf[16];
int i, j, ret;
- cipher_id_t cipher = POLARSSL_CIPHER_ID_AES;
+ mbedtls_cipher_id_t cipher = MBEDTLS_CIPHER_ID_AES;
for( j = 0; j < 3; j++ )
{
@@ -743,12 +743,12 @@
for( i = 0; i < MAX_TESTS; i++ )
{
if( verbose != 0 )
- polarssl_printf( " AES-GCM-%3d #%d (%s): ",
+ mbedtls_printf( " AES-GCM-%3d #%d (%s): ",
key_len, i, "enc" );
- gcm_init( &ctx, cipher, key[key_index[i]], key_len );
+ mbedtls_gcm_init( &ctx, cipher, key[key_index[i]], key_len );
- ret = gcm_crypt_and_tag( &ctx, GCM_ENCRYPT,
+ ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT,
pt_len[i],
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i],
@@ -759,23 +759,23 @@
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- gcm_free( &ctx );
+ mbedtls_gcm_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " AES-GCM-%3d #%d (%s): ",
+ mbedtls_printf( " AES-GCM-%3d #%d (%s): ",
key_len, i, "dec" );
- gcm_init( &ctx, cipher, key[key_index[i]], key_len );
+ mbedtls_gcm_init( &ctx, cipher, key[key_index[i]], key_len );
- ret = gcm_crypt_and_tag( &ctx, GCM_DECRYPT,
+ ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_DECRYPT,
pt_len[i],
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i],
@@ -786,29 +786,29 @@
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- gcm_free( &ctx );
+ mbedtls_gcm_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " AES-GCM-%3d #%d split (%s): ",
+ mbedtls_printf( " AES-GCM-%3d #%d split (%s): ",
key_len, i, "enc" );
- gcm_init( &ctx, cipher, key[key_index[i]], key_len );
+ mbedtls_gcm_init( &ctx, cipher, key[key_index[i]], key_len );
- ret = gcm_starts( &ctx, GCM_ENCRYPT,
+ ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_ENCRYPT,
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i] );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
@@ -816,66 +816,66 @@
if( pt_len[i] > 32 )
{
size_t rest_len = pt_len[i] - 32;
- ret = gcm_update( &ctx, 32, pt[pt_index[i]], buf );
+ ret = mbedtls_gcm_update( &ctx, 32, pt[pt_index[i]], buf );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- ret = gcm_update( &ctx, rest_len, pt[pt_index[i]] + 32,
+ ret = mbedtls_gcm_update( &ctx, rest_len, pt[pt_index[i]] + 32,
buf + 32 );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
else
{
- ret = gcm_update( &ctx, pt_len[i], pt[pt_index[i]], buf );
+ ret = mbedtls_gcm_update( &ctx, pt_len[i], pt[pt_index[i]], buf );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
- ret = gcm_finish( &ctx, tag_buf, 16 );
+ ret = mbedtls_gcm_finish( &ctx, tag_buf, 16 );
if( ret != 0 ||
memcmp( buf, ct[j * 6 + i], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- gcm_free( &ctx );
+ mbedtls_gcm_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " AES-GCM-%3d #%d split (%s): ",
+ mbedtls_printf( " AES-GCM-%3d #%d split (%s): ",
key_len, i, "dec" );
- gcm_init( &ctx, cipher, key[key_index[i]], key_len );
+ mbedtls_gcm_init( &ctx, cipher, key[key_index[i]], key_len );
- ret = gcm_starts( &ctx, GCM_DECRYPT,
+ ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_DECRYPT,
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i] );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
@@ -883,62 +883,62 @@
if( pt_len[i] > 32 )
{
size_t rest_len = pt_len[i] - 32;
- ret = gcm_update( &ctx, 32, ct[j * 6 + i], buf );
+ ret = mbedtls_gcm_update( &ctx, 32, ct[j * 6 + i], buf );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- ret = gcm_update( &ctx, rest_len, ct[j * 6 + i] + 32,
+ ret = mbedtls_gcm_update( &ctx, rest_len, ct[j * 6 + i] + 32,
buf + 32 );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
else
{
- ret = gcm_update( &ctx, pt_len[i], ct[j * 6 + i], buf );
+ ret = mbedtls_gcm_update( &ctx, pt_len[i], ct[j * 6 + i], buf );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
- ret = gcm_finish( &ctx, tag_buf, 16 );
+ ret = mbedtls_gcm_finish( &ctx, tag_buf, 16 );
if( ret != 0 ||
memcmp( buf, pt[pt_index[i]], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
- gcm_free( &ctx );
+ mbedtls_gcm_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST && POLARSSL_AES_C */
+#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
diff --git a/library/havege.c b/library/havege.c
index d07a334..9345074 100644
--- a/library/havege.c
+++ b/library/havege.c
@@ -27,13 +27,13 @@
* Contact: seznec(at)irisa_dot_fr - orocheco(at)irisa_dot_fr
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_HAVEGE_C)
+#if defined(MBEDTLS_HAVEGE_C)
#include "mbedtls/havege.h"
#include "mbedtls/timing.h"
@@ -41,7 +41,7 @@
#include <string.h>
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -82,7 +82,7 @@
PTX = (PT1 >> 18) & 7; \
PT1 &= 0x1FFF; \
PT2 &= 0x1FFF; \
- CLK = (int) hardclock(); \
+ CLK = (int) mbedtls_timing_hardclock(); \
\
i = 0; \
A = &WALK[PT1 ]; RES[i++] ^= *A; \
@@ -105,7 +105,7 @@
\
IN = (*A >> (5)) ^ (*A << (27)) ^ CLK; \
*A = (*B >> (6)) ^ (*B << (26)) ^ CLK; \
- *B = IN; CLK = (int) hardclock(); \
+ *B = IN; CLK = (int) mbedtls_timing_hardclock(); \
*C = (*C >> (7)) ^ (*C << (25)) ^ CLK; \
*D = (*D >> (8)) ^ (*D << (24)) ^ CLK; \
\
@@ -156,12 +156,12 @@
PT1 ^= (PT2 ^ 0x10) & 0x10; \
\
for( n++, i = 0; i < 16; i++ ) \
- hs->pool[n % COLLECT_SIZE] ^= RES[i];
+ hs->pool[n % MBEDTLS_HAVEGE_COLLECT_SIZE] ^= RES[i];
/*
* Entropy gathering function
*/
-static void havege_fill( havege_state *hs )
+static void havege_fill( mbedtls_havege_state *hs )
{
int i, n = 0;
int U1, U2, *A, *B, *C, *D;
@@ -177,7 +177,7 @@
memset( RES, 0, sizeof( RES ) );
- while( n < COLLECT_SIZE * 4 )
+ while( n < MBEDTLS_HAVEGE_COLLECT_SIZE * 4 )
{
ONE_ITERATION
ONE_ITERATION
@@ -189,35 +189,35 @@
hs->PT2 = PT2;
hs->offset[0] = 0;
- hs->offset[1] = COLLECT_SIZE / 2;
+ hs->offset[1] = MBEDTLS_HAVEGE_COLLECT_SIZE / 2;
}
/*
* HAVEGE initialization
*/
-void havege_init( havege_state *hs )
+void mbedtls_havege_init( mbedtls_havege_state *hs )
{
- memset( hs, 0, sizeof( havege_state ) );
+ memset( hs, 0, sizeof( mbedtls_havege_state ) );
havege_fill( hs );
}
-void havege_free( havege_state *hs )
+void mbedtls_havege_free( mbedtls_havege_state *hs )
{
if( hs == NULL )
return;
- polarssl_zeroize( hs, sizeof( havege_state ) );
+ mbedtls_zeroize( hs, sizeof( mbedtls_havege_state ) );
}
/*
* HAVEGE rand function
*/
-int havege_random( void *p_rng, unsigned char *buf, size_t len )
+int mbedtls_havege_random( void *p_rng, unsigned char *buf, size_t len )
{
int val;
size_t use_len;
- havege_state *hs = (havege_state *) p_rng;
+ mbedtls_havege_state *hs = (mbedtls_havege_state *) p_rng;
unsigned char *p = buf;
while( len > 0 )
@@ -226,7 +226,7 @@
if( use_len > sizeof(int) )
use_len = sizeof(int);
- if( hs->offset[1] >= COLLECT_SIZE )
+ if( hs->offset[1] >= MBEDTLS_HAVEGE_COLLECT_SIZE )
havege_fill( hs );
val = hs->pool[hs->offset[0]++];
@@ -241,4 +241,4 @@
return( 0 );
}
-#endif /* POLARSSL_HAVEGE_C */
+#endif /* MBEDTLS_HAVEGE_C */
diff --git a/library/hmac_drbg.c b/library/hmac_drbg.c
index 159d72e..48d5b48 100644
--- a/library/hmac_drbg.c
+++ b/library/hmac_drbg.c
@@ -26,78 +26,78 @@
* References below are based on rev. 1 (January 2012).
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_HMAC_DRBG_C)
+#if defined(MBEDTLS_HMAC_DRBG_C)
#include "mbedtls/hmac_drbg.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_SELF_TEST */
-#endif /* POLARSSL_PLATFORM_C */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_SELF_TEST */
+#endif /* MBEDTLS_PLATFORM_C */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
* HMAC_DRBG update, using optional additional data (10.1.2.2)
*/
-void hmac_drbg_update( hmac_drbg_context *ctx,
+void mbedtls_hmac_drbg_update( mbedtls_hmac_drbg_context *ctx,
const unsigned char *additional, size_t add_len )
{
- size_t md_len = md_get_size( ctx->md_ctx.md_info );
+ size_t md_len = mbedtls_md_get_size( ctx->md_ctx.md_info );
unsigned char rounds = ( additional != NULL && add_len != 0 ) ? 2 : 1;
unsigned char sep[1];
- unsigned char K[POLARSSL_MD_MAX_SIZE];
+ unsigned char K[MBEDTLS_MD_MAX_SIZE];
for( sep[0] = 0; sep[0] < rounds; sep[0]++ )
{
/* Step 1 or 4 */
- md_hmac_reset( &ctx->md_ctx );
- md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
- md_hmac_update( &ctx->md_ctx, sep, 1 );
+ mbedtls_md_hmac_reset( &ctx->md_ctx );
+ mbedtls_md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
+ mbedtls_md_hmac_update( &ctx->md_ctx, sep, 1 );
if( rounds == 2 )
- md_hmac_update( &ctx->md_ctx, additional, add_len );
- md_hmac_finish( &ctx->md_ctx, K );
+ mbedtls_md_hmac_update( &ctx->md_ctx, additional, add_len );
+ mbedtls_md_hmac_finish( &ctx->md_ctx, K );
/* Step 2 or 5 */
- md_hmac_starts( &ctx->md_ctx, K, md_len );
- md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
- md_hmac_finish( &ctx->md_ctx, ctx->V );
+ mbedtls_md_hmac_starts( &ctx->md_ctx, K, md_len );
+ mbedtls_md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
+ mbedtls_md_hmac_finish( &ctx->md_ctx, ctx->V );
}
}
/*
* Simplified HMAC_DRBG initialisation (for use with deterministic ECDSA)
*/
-int hmac_drbg_init_buf( hmac_drbg_context *ctx,
- const md_info_t * md_info,
+int mbedtls_hmac_drbg_init_buf( mbedtls_hmac_drbg_context *ctx,
+ const mbedtls_md_info_t * md_info,
const unsigned char *data, size_t data_len )
{
int ret;
- memset( ctx, 0, sizeof( hmac_drbg_context ) );
+ memset( ctx, 0, sizeof( mbedtls_hmac_drbg_context ) );
- md_init( &ctx->md_ctx );
+ mbedtls_md_init( &ctx->md_ctx );
- if( ( ret = md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 )
return( ret );
/*
@@ -105,10 +105,10 @@
* Use the V memory location, which is currently all 0, to initialize the
* MD context with an all-zero key. Then set V to its initial value.
*/
- md_hmac_starts( &ctx->md_ctx, ctx->V, md_get_size( md_info ) );
- memset( ctx->V, 0x01, md_get_size( md_info ) );
+ mbedtls_md_hmac_starts( &ctx->md_ctx, ctx->V, mbedtls_md_get_size( md_info ) );
+ memset( ctx->V, 0x01, mbedtls_md_get_size( md_info ) );
- hmac_drbg_update( ctx, data, data_len );
+ mbedtls_hmac_drbg_update( ctx, data, data_len );
return( 0 );
}
@@ -116,24 +116,24 @@
/*
* HMAC_DRBG reseeding: 10.1.2.4 (arabic) + 9.2 (Roman)
*/
-int hmac_drbg_reseed( hmac_drbg_context *ctx,
+int mbedtls_hmac_drbg_reseed( mbedtls_hmac_drbg_context *ctx,
const unsigned char *additional, size_t len )
{
- unsigned char seed[POLARSSL_HMAC_DRBG_MAX_SEED_INPUT];
+ unsigned char seed[MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT];
size_t seedlen;
/* III. Check input length */
- if( len > POLARSSL_HMAC_DRBG_MAX_INPUT ||
- ctx->entropy_len + len > POLARSSL_HMAC_DRBG_MAX_SEED_INPUT )
+ if( len > MBEDTLS_HMAC_DRBG_MAX_INPUT ||
+ ctx->entropy_len + len > MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT )
{
- return( POLARSSL_ERR_HMAC_DRBG_INPUT_TOO_BIG );
+ return( MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG );
}
- memset( seed, 0, POLARSSL_HMAC_DRBG_MAX_SEED_INPUT );
+ memset( seed, 0, MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT );
/* IV. Gather entropy_len bytes of entropy for the seed */
if( ctx->f_entropy( ctx->p_entropy, seed, ctx->entropy_len ) != 0 )
- return( POLARSSL_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED );
+ return( MBEDTLS_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED );
seedlen = ctx->entropy_len;
@@ -145,7 +145,7 @@
}
/* 2. Update state */
- hmac_drbg_update( ctx, seed, seedlen );
+ mbedtls_hmac_drbg_update( ctx, seed, seedlen );
/* 3. Reset reseed_counter */
ctx->reseed_counter = 1;
@@ -157,8 +157,8 @@
/*
* HMAC_DRBG initialisation (10.1.2.3 + 9.1)
*/
-int hmac_drbg_init( hmac_drbg_context *ctx,
- const md_info_t * md_info,
+int mbedtls_hmac_drbg_init( mbedtls_hmac_drbg_context *ctx,
+ const mbedtls_md_info_t * md_info,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
@@ -167,27 +167,27 @@
int ret;
size_t entropy_len, md_size;
- memset( ctx, 0, sizeof( hmac_drbg_context ) );
+ memset( ctx, 0, sizeof( mbedtls_hmac_drbg_context ) );
- md_init( &ctx->md_ctx );
+ mbedtls_md_init( &ctx->md_ctx );
- if( ( ret = md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 )
return( ret );
- md_size = md_get_size( md_info );
+ md_size = mbedtls_md_get_size( md_info );
/*
* Set initial working state.
* Use the V memory location, which is currently all 0, to initialize the
* MD context with an all-zero key. Then set V to its initial value.
*/
- md_hmac_starts( &ctx->md_ctx, ctx->V, md_size );
+ mbedtls_md_hmac_starts( &ctx->md_ctx, ctx->V, md_size );
memset( ctx->V, 0x01, md_size );
ctx->f_entropy = f_entropy;
ctx->p_entropy = p_entropy;
- ctx->reseed_interval = POLARSSL_HMAC_DRBG_RESEED_INTERVAL;
+ ctx->reseed_interval = MBEDTLS_HMAC_DRBG_RESEED_INTERVAL;
/*
* See SP800-57 5.6.1 (p. 65-66) for the security strength provided by
@@ -206,7 +206,7 @@
*/
ctx->entropy_len = entropy_len * 3 / 2;
- if( ( ret = hmac_drbg_reseed( ctx, custom, len ) ) != 0 )
+ if( ( ret = mbedtls_hmac_drbg_reseed( ctx, custom, len ) ) != 0 )
return( ret );
ctx->entropy_len = entropy_len;
@@ -217,7 +217,7 @@
/*
* Set prediction resistance
*/
-void hmac_drbg_set_prediction_resistance( hmac_drbg_context *ctx,
+void mbedtls_hmac_drbg_set_prediction_resistance( mbedtls_hmac_drbg_context *ctx,
int resistance )
{
ctx->prediction_resistance = resistance;
@@ -226,7 +226,7 @@
/*
* Set entropy length grabbed for reseeds
*/
-void hmac_drbg_set_entropy_len( hmac_drbg_context *ctx, size_t len )
+void mbedtls_hmac_drbg_set_entropy_len( mbedtls_hmac_drbg_context *ctx, size_t len )
{
ctx->entropy_len = len;
}
@@ -234,7 +234,7 @@
/*
* Set reseed interval
*/
-void hmac_drbg_set_reseed_interval( hmac_drbg_context *ctx, int interval )
+void mbedtls_hmac_drbg_set_reseed_interval( mbedtls_hmac_drbg_context *ctx, int interval )
{
ctx->reseed_interval = interval;
}
@@ -243,30 +243,30 @@
* HMAC_DRBG random function with optional additional data:
* 10.1.2.5 (arabic) + 9.3 (Roman)
*/
-int hmac_drbg_random_with_add( void *p_rng,
+int mbedtls_hmac_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t out_len,
const unsigned char *additional, size_t add_len )
{
int ret;
- hmac_drbg_context *ctx = (hmac_drbg_context *) p_rng;
- size_t md_len = md_get_size( ctx->md_ctx.md_info );
+ mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_context *) p_rng;
+ size_t md_len = mbedtls_md_get_size( ctx->md_ctx.md_info );
size_t left = out_len;
unsigned char *out = output;
/* II. Check request length */
- if( out_len > POLARSSL_HMAC_DRBG_MAX_REQUEST )
- return( POLARSSL_ERR_HMAC_DRBG_REQUEST_TOO_BIG );
+ if( out_len > MBEDTLS_HMAC_DRBG_MAX_REQUEST )
+ return( MBEDTLS_ERR_HMAC_DRBG_REQUEST_TOO_BIG );
/* III. Check input length */
- if( add_len > POLARSSL_HMAC_DRBG_MAX_INPUT )
- return( POLARSSL_ERR_HMAC_DRBG_INPUT_TOO_BIG );
+ if( add_len > MBEDTLS_HMAC_DRBG_MAX_INPUT )
+ return( MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG );
/* 1. (aka VII and IX) Check reseed counter and PR */
if( ctx->f_entropy != NULL && /* For no-reseeding instances */
- ( ctx->prediction_resistance == POLARSSL_HMAC_DRBG_PR_ON ||
+ ( ctx->prediction_resistance == MBEDTLS_HMAC_DRBG_PR_ON ||
ctx->reseed_counter > ctx->reseed_interval ) )
{
- if( ( ret = hmac_drbg_reseed( ctx, additional, add_len ) ) != 0 )
+ if( ( ret = mbedtls_hmac_drbg_reseed( ctx, additional, add_len ) ) != 0 )
return( ret );
add_len = 0; /* VII.4 */
@@ -274,16 +274,16 @@
/* 2. Use additional data if any */
if( additional != NULL && add_len != 0 )
- hmac_drbg_update( ctx, additional, add_len );
+ mbedtls_hmac_drbg_update( ctx, additional, add_len );
/* 3, 4, 5. Generate bytes */
while( left != 0 )
{
size_t use_len = left > md_len ? md_len : left;
- md_hmac_reset( &ctx->md_ctx );
- md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
- md_hmac_finish( &ctx->md_ctx, ctx->V );
+ mbedtls_md_hmac_reset( &ctx->md_ctx );
+ mbedtls_md_hmac_update( &ctx->md_ctx, ctx->V, md_len );
+ mbedtls_md_hmac_finish( &ctx->md_ctx, ctx->V );
memcpy( out, ctx->V, use_len );
out += use_len;
@@ -291,7 +291,7 @@
}
/* 6. Update */
- hmac_drbg_update( ctx, additional, add_len );
+ mbedtls_hmac_drbg_update( ctx, additional, add_len );
/* 7. Update reseed counter */
ctx->reseed_counter++;
@@ -303,40 +303,40 @@
/*
* HMAC_DRBG random function
*/
-int hmac_drbg_random( void *p_rng, unsigned char *output, size_t out_len )
+int mbedtls_hmac_drbg_random( void *p_rng, unsigned char *output, size_t out_len )
{
- return( hmac_drbg_random_with_add( p_rng, output, out_len, NULL, 0 ) );
+ return( mbedtls_hmac_drbg_random_with_add( p_rng, output, out_len, NULL, 0 ) );
}
/*
* Free an HMAC_DRBG context
*/
-void hmac_drbg_free( hmac_drbg_context *ctx )
+void mbedtls_hmac_drbg_free( mbedtls_hmac_drbg_context *ctx )
{
if( ctx == NULL )
return;
- md_free( &ctx->md_ctx );
+ mbedtls_md_free( &ctx->md_ctx );
- polarssl_zeroize( ctx, sizeof( hmac_drbg_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_hmac_drbg_context ) );
}
-#if defined(POLARSSL_FS_IO)
-int hmac_drbg_write_seed_file( hmac_drbg_context *ctx, const char *path )
+#if defined(MBEDTLS_FS_IO)
+int mbedtls_hmac_drbg_write_seed_file( mbedtls_hmac_drbg_context *ctx, const char *path )
{
int ret;
FILE *f;
- unsigned char buf[ POLARSSL_HMAC_DRBG_MAX_INPUT ];
+ unsigned char buf[ MBEDTLS_HMAC_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "wb" ) ) == NULL )
- return( POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR );
- if( ( ret = hmac_drbg_random( ctx, buf, sizeof( buf ) ) ) != 0 )
+ if( ( ret = mbedtls_hmac_drbg_random( ctx, buf, sizeof( buf ) ) ) != 0 )
goto exit;
if( fwrite( buf, 1, sizeof( buf ), f ) != sizeof( buf ) )
{
- ret = POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR;
+ ret = MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR;
goto exit;
}
@@ -347,49 +347,49 @@
return( ret );
}
-int hmac_drbg_update_seed_file( hmac_drbg_context *ctx, const char *path )
+int mbedtls_hmac_drbg_update_seed_file( mbedtls_hmac_drbg_context *ctx, const char *path )
{
FILE *f;
size_t n;
- unsigned char buf[ POLARSSL_HMAC_DRBG_MAX_INPUT ];
+ unsigned char buf[ MBEDTLS_HMAC_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
n = (size_t) ftell( f );
fseek( f, 0, SEEK_SET );
- if( n > POLARSSL_HMAC_DRBG_MAX_INPUT )
+ if( n > MBEDTLS_HMAC_DRBG_MAX_INPUT )
{
fclose( f );
- return( POLARSSL_ERR_HMAC_DRBG_INPUT_TOO_BIG );
+ return( MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG );
}
if( fread( buf, 1, n, f ) != n )
{
fclose( f );
- return( POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR );
}
fclose( f );
- hmac_drbg_update( ctx, buf, n );
+ mbedtls_hmac_drbg_update( ctx, buf, n );
- return( hmac_drbg_write_seed_file( ctx, path ) );
+ return( mbedtls_hmac_drbg_write_seed_file( ctx, path ) );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
-#if !defined(POLARSSL_SHA1_C)
+#if !defined(MBEDTLS_SHA1_C)
/* Dummy checkup routine */
-int hmac_drbg_self_test( int verbose )
+int mbedtls_hmac_drbg_self_test( int verbose )
{
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
@@ -442,63 +442,63 @@
#define CHK( c ) if( (c) != 0 ) \
{ \
if( verbose != 0 ) \
- polarssl_printf( "failed\n" ); \
+ mbedtls_printf( "failed\n" ); \
return( 1 ); \
}
/*
* Checkup routine for HMAC_DRBG with SHA-1
*/
-int hmac_drbg_self_test( int verbose )
+int mbedtls_hmac_drbg_self_test( int verbose )
{
- hmac_drbg_context ctx;
+ mbedtls_hmac_drbg_context ctx;
unsigned char buf[OUTPUT_LEN];
- const md_info_t *md_info = md_info_from_type( POLARSSL_MD_SHA1 );
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
/*
* PR = True
*/
if( verbose != 0 )
- polarssl_printf( " HMAC_DRBG (PR = True) : " );
+ mbedtls_printf( " HMAC_DRBG (PR = True) : " );
test_offset = 0;
- CHK( hmac_drbg_init( &ctx, md_info,
+ CHK( mbedtls_hmac_drbg_init( &ctx, md_info,
hmac_drbg_self_test_entropy, (void *) entropy_pr,
NULL, 0 ) );
- hmac_drbg_set_prediction_resistance( &ctx, POLARSSL_HMAC_DRBG_PR_ON );
- CHK( hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
- CHK( hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
+ mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
+ CHK( mbedtls_hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
+ CHK( mbedtls_hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
CHK( memcmp( buf, result_pr, OUTPUT_LEN ) );
- hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
/*
* PR = False
*/
if( verbose != 0 )
- polarssl_printf( " HMAC_DRBG (PR = False) : " );
+ mbedtls_printf( " HMAC_DRBG (PR = False) : " );
test_offset = 0;
- CHK( hmac_drbg_init( &ctx, md_info,
+ CHK( mbedtls_hmac_drbg_init( &ctx, md_info,
hmac_drbg_self_test_entropy, (void *) entropy_nopr,
NULL, 0 ) );
- CHK( hmac_drbg_reseed( &ctx, NULL, 0 ) );
- CHK( hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
- CHK( hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
+ CHK( mbedtls_hmac_drbg_reseed( &ctx, NULL, 0 ) );
+ CHK( mbedtls_hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
+ CHK( mbedtls_hmac_drbg_random( &ctx, buf, OUTPUT_LEN ) );
CHK( memcmp( buf, result_nopr, OUTPUT_LEN ) );
- hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free( &ctx );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_HMAC_DRBG_C */
+#endif /* MBEDTLS_HMAC_DRBG_C */
diff --git a/library/md.c b/library/md.c
index 74038ae..5fee809 100644
--- a/library/md.c
+++ b/library/md.c
@@ -1,5 +1,5 @@
/**
- * \file md.c
+ * \file mbedtls_md.c
*
* \brief Generic message digest wrapper for mbed TLS
*
@@ -24,23 +24,23 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MD_C)
+#if defined(MBEDTLS_MD_C)
#include "mbedtls/md.h"
#include "mbedtls/md_wrap.h"
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
#include <string.h>
@@ -51,138 +51,138 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
static const int supported_digests[] = {
-#if defined(POLARSSL_SHA512_C)
- POLARSSL_MD_SHA512,
- POLARSSL_MD_SHA384,
+#if defined(MBEDTLS_SHA512_C)
+ MBEDTLS_MD_SHA512,
+ MBEDTLS_MD_SHA384,
#endif
-#if defined(POLARSSL_SHA256_C)
- POLARSSL_MD_SHA256,
- POLARSSL_MD_SHA224,
+#if defined(MBEDTLS_SHA256_C)
+ MBEDTLS_MD_SHA256,
+ MBEDTLS_MD_SHA224,
#endif
-#if defined(POLARSSL_SHA1_C)
- POLARSSL_MD_SHA1,
+#if defined(MBEDTLS_SHA1_C)
+ MBEDTLS_MD_SHA1,
#endif
-#if defined(POLARSSL_RIPEMD160_C)
- POLARSSL_MD_RIPEMD160,
+#if defined(MBEDTLS_RIPEMD160_C)
+ MBEDTLS_MD_RIPEMD160,
#endif
-#if defined(POLARSSL_MD5_C)
- POLARSSL_MD_MD5,
+#if defined(MBEDTLS_MD5_C)
+ MBEDTLS_MD_MD5,
#endif
-#if defined(POLARSSL_MD4_C)
- POLARSSL_MD_MD4,
+#if defined(MBEDTLS_MD4_C)
+ MBEDTLS_MD_MD4,
#endif
-#if defined(POLARSSL_MD2_C)
- POLARSSL_MD_MD2,
+#if defined(MBEDTLS_MD2_C)
+ MBEDTLS_MD_MD2,
#endif
- POLARSSL_MD_NONE
+ MBEDTLS_MD_NONE
};
-const int *md_list( void )
+const int *mbedtls_md_list( void )
{
return( supported_digests );
}
-const md_info_t *md_info_from_string( const char *md_name )
+const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
{
if( NULL == md_name )
return( NULL );
/* Get the appropriate digest information */
-#if defined(POLARSSL_MD2_C)
+#if defined(MBEDTLS_MD2_C)
if( !strcasecmp( "MD2", md_name ) )
- return md_info_from_type( POLARSSL_MD_MD2 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
#endif
-#if defined(POLARSSL_MD4_C)
+#if defined(MBEDTLS_MD4_C)
if( !strcasecmp( "MD4", md_name ) )
- return md_info_from_type( POLARSSL_MD_MD4 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_MD4 );
#endif
-#if defined(POLARSSL_MD5_C)
+#if defined(MBEDTLS_MD5_C)
if( !strcasecmp( "MD5", md_name ) )
- return md_info_from_type( POLARSSL_MD_MD5 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
#endif
-#if defined(POLARSSL_RIPEMD160_C)
+#if defined(MBEDTLS_RIPEMD160_C)
if( !strcasecmp( "RIPEMD160", md_name ) )
- return md_info_from_type( POLARSSL_MD_RIPEMD160 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
#endif
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
if( !strcasecmp( "SHA1", md_name ) || !strcasecmp( "SHA", md_name ) )
- return md_info_from_type( POLARSSL_MD_SHA1 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
#endif
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
if( !strcasecmp( "SHA224", md_name ) )
- return md_info_from_type( POLARSSL_MD_SHA224 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
if( !strcasecmp( "SHA256", md_name ) )
- return md_info_from_type( POLARSSL_MD_SHA256 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
#endif
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
if( !strcasecmp( "SHA384", md_name ) )
- return md_info_from_type( POLARSSL_MD_SHA384 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
if( !strcasecmp( "SHA512", md_name ) )
- return md_info_from_type( POLARSSL_MD_SHA512 );
+ return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
#endif
return( NULL );
}
-const md_info_t *md_info_from_type( md_type_t md_type )
+const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
{
switch( md_type )
{
-#if defined(POLARSSL_MD2_C)
- case POLARSSL_MD_MD2:
- return( &md2_info );
+#if defined(MBEDTLS_MD2_C)
+ case MBEDTLS_MD_MD2:
+ return( &mbedtls_md2_info );
#endif
-#if defined(POLARSSL_MD4_C)
- case POLARSSL_MD_MD4:
- return( &md4_info );
+#if defined(MBEDTLS_MD4_C)
+ case MBEDTLS_MD_MD4:
+ return( &mbedtls_md4_info );
#endif
-#if defined(POLARSSL_MD5_C)
- case POLARSSL_MD_MD5:
- return( &md5_info );
+#if defined(MBEDTLS_MD5_C)
+ case MBEDTLS_MD_MD5:
+ return( &mbedtls_md5_info );
#endif
-#if defined(POLARSSL_RIPEMD160_C)
- case POLARSSL_MD_RIPEMD160:
- return( &ripemd160_info );
+#if defined(MBEDTLS_RIPEMD160_C)
+ case MBEDTLS_MD_RIPEMD160:
+ return( &mbedtls_ripemd160_info );
#endif
-#if defined(POLARSSL_SHA1_C)
- case POLARSSL_MD_SHA1:
- return( &sha1_info );
+#if defined(MBEDTLS_SHA1_C)
+ case MBEDTLS_MD_SHA1:
+ return( &mbedtls_sha1_info );
#endif
-#if defined(POLARSSL_SHA256_C)
- case POLARSSL_MD_SHA224:
- return( &sha224_info );
- case POLARSSL_MD_SHA256:
- return( &sha256_info );
+#if defined(MBEDTLS_SHA256_C)
+ case MBEDTLS_MD_SHA224:
+ return( &mbedtls_sha224_info );
+ case MBEDTLS_MD_SHA256:
+ return( &mbedtls_sha256_info );
#endif
-#if defined(POLARSSL_SHA512_C)
- case POLARSSL_MD_SHA384:
- return( &sha384_info );
- case POLARSSL_MD_SHA512:
- return( &sha512_info );
+#if defined(MBEDTLS_SHA512_C)
+ case MBEDTLS_MD_SHA384:
+ return( &mbedtls_sha384_info );
+ case MBEDTLS_MD_SHA512:
+ return( &mbedtls_sha512_info );
#endif
default:
return( NULL );
}
}
-void md_init( md_context_t *ctx )
+void mbedtls_md_init( mbedtls_md_context_t *ctx )
{
- memset( ctx, 0, sizeof( md_context_t ) );
+ memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
}
-void md_free( md_context_t *ctx )
+void mbedtls_md_free( mbedtls_md_context_t *ctx )
{
if( ctx == NULL || ctx->md_info == NULL )
return;
@@ -192,35 +192,35 @@
if( ctx->hmac_ctx != NULL )
{
- polarssl_zeroize( ctx->hmac_ctx, 2 * ctx->md_info->block_size );
- polarssl_free( ctx->hmac_ctx );
+ mbedtls_zeroize( ctx->hmac_ctx, 2 * ctx->md_info->block_size );
+ mbedtls_free( ctx->hmac_ctx );
}
- polarssl_zeroize( ctx, sizeof( md_context_t ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
}
-#if ! defined(POLARSSL_DEPRECATED_REMOVED)
-int md_init_ctx( md_context_t *ctx, const md_info_t *md_info )
+#if ! defined(MBEDTLS_DEPRECATED_REMOVED)
+int mbedtls_md_init_ctx( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info )
{
- return md_setup( ctx, md_info, 1 );
+ return mbedtls_md_setup( ctx, md_info, 1 );
}
#endif
-int md_setup( md_context_t *ctx, const md_info_t *md_info, int hmac )
+int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
{
if( md_info == NULL || ctx == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( ( ctx->md_ctx = md_info->ctx_alloc_func() ) == NULL )
- return( POLARSSL_ERR_MD_ALLOC_FAILED );
+ return( MBEDTLS_ERR_MD_ALLOC_FAILED );
if( hmac != 0 )
{
- ctx->hmac_ctx = polarssl_malloc( 2 * md_info->block_size );
+ ctx->hmac_ctx = mbedtls_malloc( 2 * md_info->block_size );
if( ctx->hmac_ctx == NULL )
{
md_info->ctx_free_func( ctx->md_ctx );
- return( POLARSSL_ERR_MD_ALLOC_FAILED );
+ return( MBEDTLS_ERR_MD_ALLOC_FAILED );
}
}
@@ -229,78 +229,78 @@
return( 0 );
}
-int md_starts( md_context_t *ctx )
+int mbedtls_md_starts( mbedtls_md_context_t *ctx )
{
if( ctx == NULL || ctx->md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ctx->md_info->starts_func( ctx->md_ctx );
return( 0 );
}
-int md_update( md_context_t *ctx, const unsigned char *input, size_t ilen )
+int mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
{
if( ctx == NULL || ctx->md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ctx->md_info->update_func( ctx->md_ctx, input, ilen );
return( 0 );
}
-int md_finish( md_context_t *ctx, unsigned char *output )
+int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
{
if( ctx == NULL || ctx->md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ctx->md_info->finish_func( ctx->md_ctx, output );
return( 0 );
}
-int md( const md_info_t *md_info, const unsigned char *input, size_t ilen,
+int mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
unsigned char *output )
{
if( md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
md_info->digest_func( input, ilen, output );
return( 0 );
}
-int md_file( const md_info_t *md_info, const char *path, unsigned char *output )
+int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
int ret;
#endif
if( md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
ret = md_info->file_func( path, output );
if( ret != 0 )
- return( POLARSSL_ERR_MD_FILE_IO_ERROR + ret );
+ return( MBEDTLS_ERR_MD_FILE_IO_ERROR + ret );
return( ret );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
-#endif /* POLARSSL_FS_IO */
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
+#endif /* MBEDTLS_FS_IO */
}
-int md_hmac_starts( md_context_t *ctx, const unsigned char *key, size_t keylen )
+int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
{
- unsigned char sum[POLARSSL_MD_MAX_SIZE];
+ unsigned char sum[MBEDTLS_MD_MAX_SIZE];
unsigned char *ipad, *opad;
size_t i;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( keylen > (size_t) ctx->md_info->block_size )
{
@@ -324,7 +324,7 @@
opad[i] = (unsigned char)( opad[i] ^ key[i] );
}
- polarssl_zeroize( sum, sizeof( sum ) );
+ mbedtls_zeroize( sum, sizeof( sum ) );
ctx->md_info->starts_func( ctx->md_ctx );
ctx->md_info->update_func( ctx->md_ctx, ipad, ctx->md_info->block_size );
@@ -332,23 +332,23 @@
return( 0 );
}
-int md_hmac_update( md_context_t *ctx, const unsigned char *input, size_t ilen )
+int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
{
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ctx->md_info->update_func( ctx->md_ctx, input, ilen );
return( 0 );
}
-int md_hmac_finish( md_context_t *ctx, unsigned char *output )
+int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
{
- unsigned char tmp[POLARSSL_MD_MAX_SIZE];
+ unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
unsigned char *opad;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
@@ -361,12 +361,12 @@
return( 0 );
}
-int md_hmac_reset( md_context_t *ctx )
+int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
{
unsigned char *ipad;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ipad = (unsigned char *) ctx->hmac_ctx;
@@ -376,41 +376,41 @@
return( 0 );
}
-int md_hmac( const md_info_t *md_info, const unsigned char *key, size_t keylen,
+int mbedtls_md_hmac( const mbedtls_md_info_t *md_info, const unsigned char *key, size_t keylen,
const unsigned char *input, size_t ilen,
unsigned char *output )
{
- md_context_t ctx;
+ mbedtls_md_context_t ctx;
int ret;
if( md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- md_init( &ctx );
+ mbedtls_md_init( &ctx );
- if( ( ret = md_setup( &ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
return( ret );
- md_hmac_starts( &ctx, key, keylen );
- md_hmac_update( &ctx, input, ilen );
- md_hmac_finish( &ctx, output );
+ mbedtls_md_hmac_starts( &ctx, key, keylen );
+ mbedtls_md_hmac_update( &ctx, input, ilen );
+ mbedtls_md_hmac_finish( &ctx, output );
- md_free( &ctx );
+ mbedtls_md_free( &ctx );
return( 0 );
}
-int md_process( md_context_t *ctx, const unsigned char *data )
+int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
{
if( ctx == NULL || ctx->md_info == NULL )
- return( POLARSSL_ERR_MD_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
ctx->md_info->process_func( ctx->md_ctx, data );
return( 0 );
}
-unsigned char md_get_size( const md_info_t *md_info )
+unsigned char mbedtls_md_get_size( const mbedtls_md_info_t *md_info )
{
if( md_info == NULL )
return( 0 );
@@ -418,15 +418,15 @@
return md_info->size;
}
-md_type_t md_get_type( const md_info_t *md_info )
+mbedtls_md_type_t mbedtls_md_get_type( const mbedtls_md_info_t *md_info )
{
if( md_info == NULL )
- return( POLARSSL_MD_NONE );
+ return( MBEDTLS_MD_NONE );
return md_info->type;
}
-const char *md_get_name( const md_info_t *md_info )
+const char *mbedtls_md_get_name( const mbedtls_md_info_t *md_info )
{
if( md_info == NULL )
return( NULL );
@@ -434,4 +434,4 @@
return md_info->name;
}
-#endif /* POLARSSL_MD_C */
+#endif /* MBEDTLS_MD_C */
diff --git a/library/md2.c b/library/md2.c
index fb8acdd..1526352 100644
--- a/library/md2.c
+++ b/library/md2.c
@@ -26,37 +26,37 @@
* http://www.ietf.org/rfc/rfc1319.txt
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MD2_C)
+#if defined(MBEDTLS_MD2_C)
#include "mbedtls/md2.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_MD2_ALT)
+#if !defined(MBEDTLS_MD2_ALT)
static const unsigned char PI_SUBST[256] =
{
@@ -88,23 +88,23 @@
0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14
};
-void md2_init( md2_context *ctx )
+void mbedtls_md2_init( mbedtls_md2_context *ctx )
{
- memset( ctx, 0, sizeof( md2_context ) );
+ memset( ctx, 0, sizeof( mbedtls_md2_context ) );
}
-void md2_free( md2_context *ctx )
+void mbedtls_md2_free( mbedtls_md2_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( md2_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md2_context ) );
}
/*
* MD2 context setup
*/
-void md2_starts( md2_context *ctx )
+void mbedtls_md2_starts( mbedtls_md2_context *ctx )
{
memset( ctx->cksum, 0, 16 );
memset( ctx->state, 0, 46 );
@@ -112,8 +112,8 @@
ctx->left = 0;
}
-#if !defined(POLARSSL_MD2_PROCESS_ALT)
-void md2_process( md2_context *ctx )
+#if !defined(MBEDTLS_MD2_PROCESS_ALT)
+void mbedtls_md2_process( mbedtls_md2_context *ctx )
{
int i, j;
unsigned char t = 0;
@@ -146,12 +146,12 @@
t = ctx->cksum[i];
}
}
-#endif /* !POLARSSL_MD2_PROCESS_ALT */
+#endif /* !MBEDTLS_MD2_PROCESS_ALT */
/*
* MD2 process buffer
*/
-void md2_update( md2_context *ctx, const unsigned char *input, size_t ilen )
+void mbedtls_md2_update( mbedtls_md2_context *ctx, const unsigned char *input, size_t ilen )
{
size_t fill;
@@ -171,7 +171,7 @@
if( ctx->left == 16 )
{
ctx->left = 0;
- md2_process( ctx );
+ mbedtls_md2_process( ctx );
}
}
}
@@ -179,7 +179,7 @@
/*
* MD2 final digest
*/
-void md2_finish( md2_context *ctx, unsigned char output[16] )
+void mbedtls_md2_finish( mbedtls_md2_context *ctx, unsigned char output[16] )
{
size_t i;
unsigned char x;
@@ -189,65 +189,65 @@
for( i = ctx->left; i < 16; i++ )
ctx->buffer[i] = x;
- md2_process( ctx );
+ mbedtls_md2_process( ctx );
memcpy( ctx->buffer, ctx->cksum, 16 );
- md2_process( ctx );
+ mbedtls_md2_process( ctx );
memcpy( output, ctx->state, 16 );
}
-#endif /* !POLARSSL_MD2_ALT */
+#endif /* !MBEDTLS_MD2_ALT */
/*
* output = MD2( input buffer )
*/
-void md2( const unsigned char *input, size_t ilen, unsigned char output[16] )
+void mbedtls_md2( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
- md2_context ctx;
+ mbedtls_md2_context ctx;
- md2_init( &ctx );
- md2_starts( &ctx );
- md2_update( &ctx, input, ilen );
- md2_finish( &ctx, output );
- md2_free( &ctx );
+ mbedtls_md2_init( &ctx );
+ mbedtls_md2_starts( &ctx );
+ mbedtls_md2_update( &ctx, input, ilen );
+ mbedtls_md2_finish( &ctx, output );
+ mbedtls_md2_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = MD2( file contents )
*/
-int md2_file( const char *path, unsigned char output[16] )
+int mbedtls_md2_file( const char *path, unsigned char output[16] )
{
FILE *f;
size_t n;
- md2_context ctx;
+ mbedtls_md2_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_MD2_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD2_FILE_IO_ERROR );
- md2_init( &ctx );
- md2_starts( &ctx );
+ mbedtls_md2_init( &ctx );
+ mbedtls_md2_starts( &ctx );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- md2_update( &ctx, buf, n );
+ mbedtls_md2_update( &ctx, buf, n );
- md2_finish( &ctx, output );
- md2_free( &ctx );
+ mbedtls_md2_finish( &ctx, output );
+ mbedtls_md2_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_MD2_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD2_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* RFC 1319 test vectors
@@ -285,7 +285,7 @@
/*
* Checkup routine
*/
-int md2_self_test( int verbose )
+int mbedtls_md2_self_test( int verbose )
{
int i;
unsigned char md2sum[16];
@@ -293,29 +293,29 @@
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
- polarssl_printf( " MD2 test #%d: ", i + 1 );
+ mbedtls_printf( " MD2 test #%d: ", i + 1 );
- md2( (unsigned char *) md2_test_str[i],
+ mbedtls_md2( (unsigned char *) md2_test_str[i],
strlen( md2_test_str[i] ), md2sum );
if( memcmp( md2sum, md2_test_sum[i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_MD2_C */
+#endif /* MBEDTLS_MD2_C */
diff --git a/library/md4.c b/library/md4.c
index 2de259d..75a6719 100644
--- a/library/md4.c
+++ b/library/md4.c
@@ -26,37 +26,37 @@
* http://www.ietf.org/rfc/rfc1320.txt
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MD4_C)
+#if defined(MBEDTLS_MD4_C)
#include "mbedtls/md4.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_MD4_ALT)
+#if !defined(MBEDTLS_MD4_ALT)
/*
* 32-bit integer manipulation macros (little endian)
@@ -81,23 +81,23 @@
}
#endif
-void md4_init( md4_context *ctx )
+void mbedtls_md4_init( mbedtls_md4_context *ctx )
{
- memset( ctx, 0, sizeof( md4_context ) );
+ memset( ctx, 0, sizeof( mbedtls_md4_context ) );
}
-void md4_free( md4_context *ctx )
+void mbedtls_md4_free( mbedtls_md4_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( md4_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md4_context ) );
}
/*
* MD4 context setup
*/
-void md4_starts( md4_context *ctx )
+void mbedtls_md4_starts( mbedtls_md4_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -108,8 +108,8 @@
ctx->state[3] = 0x10325476;
}
-#if !defined(POLARSSL_MD4_PROCESS_ALT)
-void md4_process( md4_context *ctx, const unsigned char data[64] )
+#if !defined(MBEDTLS_MD4_PROCESS_ALT)
+void mbedtls_md4_process( mbedtls_md4_context *ctx, const unsigned char data[64] )
{
uint32_t X[16], A, B, C, D;
@@ -211,12 +211,12 @@
ctx->state[2] += C;
ctx->state[3] += D;
}
-#endif /* !POLARSSL_MD4_PROCESS_ALT */
+#endif /* !MBEDTLS_MD4_PROCESS_ALT */
/*
* MD4 process buffer
*/
-void md4_update( md4_context *ctx, const unsigned char *input, size_t ilen )
+void mbedtls_md4_update( mbedtls_md4_context *ctx, const unsigned char *input, size_t ilen )
{
size_t fill;
uint32_t left;
@@ -237,7 +237,7 @@
{
memcpy( (void *) (ctx->buffer + left),
(void *) input, fill );
- md4_process( ctx, ctx->buffer );
+ mbedtls_md4_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -245,7 +245,7 @@
while( ilen >= 64 )
{
- md4_process( ctx, input );
+ mbedtls_md4_process( ctx, input );
input += 64;
ilen -= 64;
}
@@ -268,7 +268,7 @@
/*
* MD4 final digest
*/
-void md4_finish( md4_context *ctx, unsigned char output[16] )
+void mbedtls_md4_finish( mbedtls_md4_context *ctx, unsigned char output[16] )
{
uint32_t last, padn;
uint32_t high, low;
@@ -284,8 +284,8 @@
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
- md4_update( ctx, (unsigned char *) md4_padding, padn );
- md4_update( ctx, msglen, 8 );
+ mbedtls_md4_update( ctx, (unsigned char *) md4_padding, padn );
+ mbedtls_md4_update( ctx, msglen, 8 );
PUT_UINT32_LE( ctx->state[0], output, 0 );
PUT_UINT32_LE( ctx->state[1], output, 4 );
@@ -293,57 +293,57 @@
PUT_UINT32_LE( ctx->state[3], output, 12 );
}
-#endif /* !POLARSSL_MD4_ALT */
+#endif /* !MBEDTLS_MD4_ALT */
/*
* output = MD4( input buffer )
*/
-void md4( const unsigned char *input, size_t ilen, unsigned char output[16] )
+void mbedtls_md4( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
- md4_context ctx;
+ mbedtls_md4_context ctx;
- md4_init( &ctx );
- md4_starts( &ctx );
- md4_update( &ctx, input, ilen );
- md4_finish( &ctx, output );
- md4_free( &ctx );
+ mbedtls_md4_init( &ctx );
+ mbedtls_md4_starts( &ctx );
+ mbedtls_md4_update( &ctx, input, ilen );
+ mbedtls_md4_finish( &ctx, output );
+ mbedtls_md4_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = MD4( file contents )
*/
-int md4_file( const char *path, unsigned char output[16] )
+int mbedtls_md4_file( const char *path, unsigned char output[16] )
{
FILE *f;
size_t n;
- md4_context ctx;
+ mbedtls_md4_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_MD4_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD4_FILE_IO_ERROR );
- md4_init( &ctx );
- md4_starts( &ctx );
+ mbedtls_md4_init( &ctx );
+ mbedtls_md4_starts( &ctx );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- md4_update( &ctx, buf, n );
+ mbedtls_md4_update( &ctx, buf, n );
- md4_finish( &ctx, output );
- md4_free( &ctx );
+ mbedtls_md4_finish( &ctx, output );
+ mbedtls_md4_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_MD4_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD4_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* RFC 1320 test vectors
@@ -381,7 +381,7 @@
/*
* Checkup routine
*/
-int md4_self_test( int verbose )
+int mbedtls_md4_self_test( int verbose )
{
int i;
unsigned char md4sum[16];
@@ -389,29 +389,29 @@
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
- polarssl_printf( " MD4 test #%d: ", i + 1 );
+ mbedtls_printf( " MD4 test #%d: ", i + 1 );
- md4( (unsigned char *) md4_test_str[i],
+ mbedtls_md4( (unsigned char *) md4_test_str[i],
strlen( md4_test_str[i] ), md4sum );
if( memcmp( md4sum, md4_test_sum[i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_MD4_C */
+#endif /* MBEDTLS_MD4_C */
diff --git a/library/md5.c b/library/md5.c
index 5eef65d..592304e 100644
--- a/library/md5.c
+++ b/library/md5.c
@@ -25,37 +25,37 @@
* http://www.ietf.org/rfc/rfc1321.txt
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MD5_C)
+#if defined(MBEDTLS_MD5_C)
#include "mbedtls/md5.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_MD5_ALT)
+#if !defined(MBEDTLS_MD5_ALT)
/*
* 32-bit integer manipulation macros (little endian)
@@ -80,23 +80,23 @@
}
#endif
-void md5_init( md5_context *ctx )
+void mbedtls_md5_init( mbedtls_md5_context *ctx )
{
- memset( ctx, 0, sizeof( md5_context ) );
+ memset( ctx, 0, sizeof( mbedtls_md5_context ) );
}
-void md5_free( md5_context *ctx )
+void mbedtls_md5_free( mbedtls_md5_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( md5_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md5_context ) );
}
/*
* MD5 context setup
*/
-void md5_starts( md5_context *ctx )
+void mbedtls_md5_starts( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -107,8 +107,8 @@
ctx->state[3] = 0x10325476;
}
-#if !defined(POLARSSL_MD5_PROCESS_ALT)
-void md5_process( md5_context *ctx, const unsigned char data[64] )
+#if !defined(MBEDTLS_MD5_PROCESS_ALT)
+void mbedtls_md5_process( mbedtls_md5_context *ctx, const unsigned char data[64] )
{
uint32_t X[16], A, B, C, D;
@@ -230,12 +230,12 @@
ctx->state[2] += C;
ctx->state[3] += D;
}
-#endif /* !POLARSSL_MD5_PROCESS_ALT */
+#endif /* !MBEDTLS_MD5_PROCESS_ALT */
/*
* MD5 process buffer
*/
-void md5_update( md5_context *ctx, const unsigned char *input, size_t ilen )
+void mbedtls_md5_update( mbedtls_md5_context *ctx, const unsigned char *input, size_t ilen )
{
size_t fill;
uint32_t left;
@@ -255,7 +255,7 @@
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
- md5_process( ctx, ctx->buffer );
+ mbedtls_md5_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -263,7 +263,7 @@
while( ilen >= 64 )
{
- md5_process( ctx, input );
+ mbedtls_md5_process( ctx, input );
input += 64;
ilen -= 64;
}
@@ -285,7 +285,7 @@
/*
* MD5 final digest
*/
-void md5_finish( md5_context *ctx, unsigned char output[16] )
+void mbedtls_md5_finish( mbedtls_md5_context *ctx, unsigned char output[16] )
{
uint32_t last, padn;
uint32_t high, low;
@@ -301,8 +301,8 @@
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
- md5_update( ctx, md5_padding, padn );
- md5_update( ctx, msglen, 8 );
+ mbedtls_md5_update( ctx, md5_padding, padn );
+ mbedtls_md5_update( ctx, msglen, 8 );
PUT_UINT32_LE( ctx->state[0], output, 0 );
PUT_UINT32_LE( ctx->state[1], output, 4 );
@@ -310,57 +310,57 @@
PUT_UINT32_LE( ctx->state[3], output, 12 );
}
-#endif /* !POLARSSL_MD5_ALT */
+#endif /* !MBEDTLS_MD5_ALT */
/*
* output = MD5( input buffer )
*/
-void md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
+void mbedtls_md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
- md5_context ctx;
+ mbedtls_md5_context ctx;
- md5_init( &ctx );
- md5_starts( &ctx );
- md5_update( &ctx, input, ilen );
- md5_finish( &ctx, output );
- md5_free( &ctx );
+ mbedtls_md5_init( &ctx );
+ mbedtls_md5_starts( &ctx );
+ mbedtls_md5_update( &ctx, input, ilen );
+ mbedtls_md5_finish( &ctx, output );
+ mbedtls_md5_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = MD5( file contents )
*/
-int md5_file( const char *path, unsigned char output[16] )
+int mbedtls_md5_file( const char *path, unsigned char output[16] )
{
FILE *f;
size_t n;
- md5_context ctx;
+ mbedtls_md5_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_MD5_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD5_FILE_IO_ERROR );
- md5_init( &ctx );
- md5_starts( &ctx );
+ mbedtls_md5_init( &ctx );
+ mbedtls_md5_starts( &ctx );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- md5_update( &ctx, buf, n );
+ mbedtls_md5_update( &ctx, buf, n );
- md5_finish( &ctx, output );
- md5_free( &ctx );
+ mbedtls_md5_finish( &ctx, output );
+ mbedtls_md5_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_MD5_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_MD5_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* RFC 1321 test vectors
*/
@@ -402,7 +402,7 @@
/*
* Checkup routine
*/
-int md5_self_test( int verbose )
+int mbedtls_md5_self_test( int verbose )
{
int i;
unsigned char md5sum[16];
@@ -410,28 +410,28 @@
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
- polarssl_printf( " MD5 test #%d: ", i + 1 );
+ mbedtls_printf( " MD5 test #%d: ", i + 1 );
- md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
+ mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_MD5_C */
+#endif /* MBEDTLS_MD5_C */
diff --git a/library/md_wrap.c b/library/md_wrap.c
index 17c6ab4..f3de452 100644
--- a/library/md_wrap.c
+++ b/library/md_wrap.c
@@ -24,441 +24,441 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MD_C)
+#if defined(MBEDTLS_MD_C)
#include "mbedtls/md_wrap.h"
-#if defined(POLARSSL_MD2_C)
+#if defined(MBEDTLS_MD2_C)
#include "mbedtls/md2.h"
#endif
-#if defined(POLARSSL_MD4_C)
+#if defined(MBEDTLS_MD4_C)
#include "mbedtls/md4.h"
#endif
-#if defined(POLARSSL_MD5_C)
+#if defined(MBEDTLS_MD5_C)
#include "mbedtls/md5.h"
#endif
-#if defined(POLARSSL_RIPEMD160_C)
+#if defined(MBEDTLS_RIPEMD160_C)
#include "mbedtls/ripemd160.h"
#endif
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
#include "mbedtls/sha1.h"
#endif
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
#include "mbedtls/sha256.h"
#endif
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
#include "mbedtls/sha512.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if defined(POLARSSL_MD2_C)
+#if defined(MBEDTLS_MD2_C)
static void md2_starts_wrap( void *ctx )
{
- md2_starts( (md2_context *) ctx );
+ mbedtls_md2_starts( (mbedtls_md2_context *) ctx );
}
static void md2_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- md2_update( (md2_context *) ctx, input, ilen );
+ mbedtls_md2_update( (mbedtls_md2_context *) ctx, input, ilen );
}
static void md2_finish_wrap( void *ctx, unsigned char *output )
{
- md2_finish( (md2_context *) ctx, output );
+ mbedtls_md2_finish( (mbedtls_md2_context *) ctx, output );
}
static int md2_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return md2_file( path, output );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_md2_file( path, output );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * md2_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( md2_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_md2_context ) );
}
static void md2_ctx_free( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( md2_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md2_context ) );
+ mbedtls_free( ctx );
}
static void md2_process_wrap( void *ctx, const unsigned char *data )
{
((void) data);
- md2_process( (md2_context *) ctx );
+ mbedtls_md2_process( (mbedtls_md2_context *) ctx );
}
-const md_info_t md2_info = {
- POLARSSL_MD_MD2,
+const mbedtls_md_info_t mbedtls_md2_info = {
+ MBEDTLS_MD_MD2,
"MD2",
16,
16,
md2_starts_wrap,
md2_update_wrap,
md2_finish_wrap,
- md2,
+ mbedtls_md2,
md2_file_wrap,
md2_ctx_alloc,
md2_ctx_free,
md2_process_wrap,
};
-#endif /* POLARSSL_MD2_C */
+#endif /* MBEDTLS_MD2_C */
-#if defined(POLARSSL_MD4_C)
+#if defined(MBEDTLS_MD4_C)
static void md4_starts_wrap( void *ctx )
{
- md4_starts( (md4_context *) ctx );
+ mbedtls_md4_starts( (mbedtls_md4_context *) ctx );
}
static void md4_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- md4_update( (md4_context *) ctx, input, ilen );
+ mbedtls_md4_update( (mbedtls_md4_context *) ctx, input, ilen );
}
static void md4_finish_wrap( void *ctx, unsigned char *output )
{
- md4_finish( (md4_context *) ctx, output );
+ mbedtls_md4_finish( (mbedtls_md4_context *) ctx, output );
}
static int md4_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return md4_file( path, output );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_md4_file( path, output );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void *md4_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( md4_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_md4_context ) );
}
static void md4_ctx_free( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( md4_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md4_context ) );
+ mbedtls_free( ctx );
}
static void md4_process_wrap( void *ctx, const unsigned char *data )
{
- md4_process( (md4_context *) ctx, data );
+ mbedtls_md4_process( (mbedtls_md4_context *) ctx, data );
}
-const md_info_t md4_info = {
- POLARSSL_MD_MD4,
+const mbedtls_md_info_t mbedtls_md4_info = {
+ MBEDTLS_MD_MD4,
"MD4",
16,
64,
md4_starts_wrap,
md4_update_wrap,
md4_finish_wrap,
- md4,
+ mbedtls_md4,
md4_file_wrap,
md4_ctx_alloc,
md4_ctx_free,
md4_process_wrap,
};
-#endif /* POLARSSL_MD4_C */
+#endif /* MBEDTLS_MD4_C */
-#if defined(POLARSSL_MD5_C)
+#if defined(MBEDTLS_MD5_C)
static void md5_starts_wrap( void *ctx )
{
- md5_starts( (md5_context *) ctx );
+ mbedtls_md5_starts( (mbedtls_md5_context *) ctx );
}
static void md5_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- md5_update( (md5_context *) ctx, input, ilen );
+ mbedtls_md5_update( (mbedtls_md5_context *) ctx, input, ilen );
}
static void md5_finish_wrap( void *ctx, unsigned char *output )
{
- md5_finish( (md5_context *) ctx, output );
+ mbedtls_md5_finish( (mbedtls_md5_context *) ctx, output );
}
static int md5_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return md5_file( path, output );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_md5_file( path, output );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * md5_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( md5_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_md5_context ) );
}
static void md5_ctx_free( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( md5_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_md5_context ) );
+ mbedtls_free( ctx );
}
static void md5_process_wrap( void *ctx, const unsigned char *data )
{
- md5_process( (md5_context *) ctx, data );
+ mbedtls_md5_process( (mbedtls_md5_context *) ctx, data );
}
-const md_info_t md5_info = {
- POLARSSL_MD_MD5,
+const mbedtls_md_info_t mbedtls_md5_info = {
+ MBEDTLS_MD_MD5,
"MD5",
16,
64,
md5_starts_wrap,
md5_update_wrap,
md5_finish_wrap,
- md5,
+ mbedtls_md5,
md5_file_wrap,
md5_ctx_alloc,
md5_ctx_free,
md5_process_wrap,
};
-#endif /* POLARSSL_MD5_C */
+#endif /* MBEDTLS_MD5_C */
-#if defined(POLARSSL_RIPEMD160_C)
+#if defined(MBEDTLS_RIPEMD160_C)
static void ripemd160_starts_wrap( void *ctx )
{
- ripemd160_starts( (ripemd160_context *) ctx );
+ mbedtls_ripemd160_starts( (mbedtls_ripemd160_context *) ctx );
}
static void ripemd160_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- ripemd160_update( (ripemd160_context *) ctx, input, ilen );
+ mbedtls_ripemd160_update( (mbedtls_ripemd160_context *) ctx, input, ilen );
}
static void ripemd160_finish_wrap( void *ctx, unsigned char *output )
{
- ripemd160_finish( (ripemd160_context *) ctx, output );
+ mbedtls_ripemd160_finish( (mbedtls_ripemd160_context *) ctx, output );
}
static int ripemd160_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return ripemd160_file( path, output );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_ripemd160_file( path, output );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * ripemd160_ctx_alloc( void )
{
- ripemd160_context *ctx;
- ctx = polarssl_malloc( sizeof( ripemd160_context ) );
+ mbedtls_ripemd160_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_ripemd160_context ) );
if( ctx == NULL )
return( NULL );
- ripemd160_init( ctx );
+ mbedtls_ripemd160_init( ctx );
return( ctx );
}
static void ripemd160_ctx_free( void *ctx )
{
- ripemd160_free( (ripemd160_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_ripemd160_free( (mbedtls_ripemd160_context *) ctx );
+ mbedtls_free( ctx );
}
static void ripemd160_process_wrap( void *ctx, const unsigned char *data )
{
- ripemd160_process( (ripemd160_context *) ctx, data );
+ mbedtls_ripemd160_process( (mbedtls_ripemd160_context *) ctx, data );
}
-const md_info_t ripemd160_info = {
- POLARSSL_MD_RIPEMD160,
+const mbedtls_md_info_t mbedtls_ripemd160_info = {
+ MBEDTLS_MD_RIPEMD160,
"RIPEMD160",
20,
64,
ripemd160_starts_wrap,
ripemd160_update_wrap,
ripemd160_finish_wrap,
- ripemd160,
+ mbedtls_ripemd160,
ripemd160_file_wrap,
ripemd160_ctx_alloc,
ripemd160_ctx_free,
ripemd160_process_wrap,
};
-#endif /* POLARSSL_RIPEMD160_C */
+#endif /* MBEDTLS_RIPEMD160_C */
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
static void sha1_starts_wrap( void *ctx )
{
- sha1_starts( (sha1_context *) ctx );
+ mbedtls_sha1_starts( (mbedtls_sha1_context *) ctx );
}
static void sha1_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- sha1_update( (sha1_context *) ctx, input, ilen );
+ mbedtls_sha1_update( (mbedtls_sha1_context *) ctx, input, ilen );
}
static void sha1_finish_wrap( void *ctx, unsigned char *output )
{
- sha1_finish( (sha1_context *) ctx, output );
+ mbedtls_sha1_finish( (mbedtls_sha1_context *) ctx, output );
}
static int sha1_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return sha1_file( path, output );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_sha1_file( path, output );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * sha1_ctx_alloc( void )
{
- sha1_context *ctx;
- ctx = polarssl_malloc( sizeof( sha1_context ) );
+ mbedtls_sha1_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_sha1_context ) );
if( ctx == NULL )
return( NULL );
- sha1_init( ctx );
+ mbedtls_sha1_init( ctx );
return( ctx );
}
static void sha1_ctx_free( void *ctx )
{
- sha1_free( (sha1_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_sha1_free( (mbedtls_sha1_context *) ctx );
+ mbedtls_free( ctx );
}
static void sha1_process_wrap( void *ctx, const unsigned char *data )
{
- sha1_process( (sha1_context *) ctx, data );
+ mbedtls_sha1_process( (mbedtls_sha1_context *) ctx, data );
}
-const md_info_t sha1_info = {
- POLARSSL_MD_SHA1,
+const mbedtls_md_info_t mbedtls_sha1_info = {
+ MBEDTLS_MD_SHA1,
"SHA1",
20,
64,
sha1_starts_wrap,
sha1_update_wrap,
sha1_finish_wrap,
- sha1,
+ mbedtls_sha1,
sha1_file_wrap,
sha1_ctx_alloc,
sha1_ctx_free,
sha1_process_wrap,
};
-#endif /* POLARSSL_SHA1_C */
+#endif /* MBEDTLS_SHA1_C */
/*
* Wrappers for generic message digests
*/
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
static void sha224_starts_wrap( void *ctx )
{
- sha256_starts( (sha256_context *) ctx, 1 );
+ mbedtls_sha256_starts( (mbedtls_sha256_context *) ctx, 1 );
}
static void sha224_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- sha256_update( (sha256_context *) ctx, input, ilen );
+ mbedtls_sha256_update( (mbedtls_sha256_context *) ctx, input, ilen );
}
static void sha224_finish_wrap( void *ctx, unsigned char *output )
{
- sha256_finish( (sha256_context *) ctx, output );
+ mbedtls_sha256_finish( (mbedtls_sha256_context *) ctx, output );
}
static void sha224_wrap( const unsigned char *input, size_t ilen,
unsigned char *output )
{
- sha256( input, ilen, output, 1 );
+ mbedtls_sha256( input, ilen, output, 1 );
}
static int sha224_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return sha256_file( path, output, 1 );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_sha256_file( path, output, 1 );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * sha224_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( sha256_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_sha256_context ) );
}
static void sha224_ctx_free( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( sha256_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
+ mbedtls_free( ctx );
}
static void sha224_process_wrap( void *ctx, const unsigned char *data )
{
- sha256_process( (sha256_context *) ctx, data );
+ mbedtls_sha256_process( (mbedtls_sha256_context *) ctx, data );
}
-const md_info_t sha224_info = {
- POLARSSL_MD_SHA224,
+const mbedtls_md_info_t mbedtls_sha224_info = {
+ MBEDTLS_MD_SHA224,
"SHA224",
28,
64,
@@ -474,63 +474,63 @@
static void sha256_starts_wrap( void *ctx )
{
- sha256_starts( (sha256_context *) ctx, 0 );
+ mbedtls_sha256_starts( (mbedtls_sha256_context *) ctx, 0 );
}
static void sha256_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- sha256_update( (sha256_context *) ctx, input, ilen );
+ mbedtls_sha256_update( (mbedtls_sha256_context *) ctx, input, ilen );
}
static void sha256_finish_wrap( void *ctx, unsigned char *output )
{
- sha256_finish( (sha256_context *) ctx, output );
+ mbedtls_sha256_finish( (mbedtls_sha256_context *) ctx, output );
}
static void sha256_wrap( const unsigned char *input, size_t ilen,
unsigned char *output )
{
- sha256( input, ilen, output, 0 );
+ mbedtls_sha256( input, ilen, output, 0 );
}
static int sha256_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return sha256_file( path, output, 0 );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_sha256_file( path, output, 0 );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * sha256_ctx_alloc( void )
{
- sha256_context *ctx;
- ctx = polarssl_malloc( sizeof( sha256_context ) );
+ mbedtls_sha256_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_sha256_context ) );
if( ctx == NULL )
return( NULL );
- sha256_init( ctx );
+ mbedtls_sha256_init( ctx );
return( ctx );
}
static void sha256_ctx_free( void *ctx )
{
- sha256_free( (sha256_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_sha256_free( (mbedtls_sha256_context *) ctx );
+ mbedtls_free( ctx );
}
static void sha256_process_wrap( void *ctx, const unsigned char *data )
{
- sha256_process( (sha256_context *) ctx, data );
+ mbedtls_sha256_process( (mbedtls_sha256_context *) ctx, data );
}
-const md_info_t sha256_info = {
- POLARSSL_MD_SHA256,
+const mbedtls_md_info_t mbedtls_sha256_info = {
+ MBEDTLS_MD_SHA256,
"SHA256",
32,
64,
@@ -544,61 +544,61 @@
sha256_process_wrap,
};
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
static void sha384_starts_wrap( void *ctx )
{
- sha512_starts( (sha512_context *) ctx, 1 );
+ mbedtls_sha512_starts( (mbedtls_sha512_context *) ctx, 1 );
}
static void sha384_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- sha512_update( (sha512_context *) ctx, input, ilen );
+ mbedtls_sha512_update( (mbedtls_sha512_context *) ctx, input, ilen );
}
static void sha384_finish_wrap( void *ctx, unsigned char *output )
{
- sha512_finish( (sha512_context *) ctx, output );
+ mbedtls_sha512_finish( (mbedtls_sha512_context *) ctx, output );
}
static void sha384_wrap( const unsigned char *input, size_t ilen,
unsigned char *output )
{
- sha512( input, ilen, output, 1 );
+ mbedtls_sha512( input, ilen, output, 1 );
}
static int sha384_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return sha512_file( path, output, 1 );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_sha512_file( path, output, 1 );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * sha384_ctx_alloc( void )
{
- return polarssl_malloc( sizeof( sha512_context ) );
+ return mbedtls_malloc( sizeof( mbedtls_sha512_context ) );
}
static void sha384_ctx_free( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( sha512_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
+ mbedtls_free( ctx );
}
static void sha384_process_wrap( void *ctx, const unsigned char *data )
{
- sha512_process( (sha512_context *) ctx, data );
+ mbedtls_sha512_process( (mbedtls_sha512_context *) ctx, data );
}
-const md_info_t sha384_info = {
- POLARSSL_MD_SHA384,
+const mbedtls_md_info_t mbedtls_sha384_info = {
+ MBEDTLS_MD_SHA384,
"SHA384",
48,
128,
@@ -614,63 +614,63 @@
static void sha512_starts_wrap( void *ctx )
{
- sha512_starts( (sha512_context *) ctx, 0 );
+ mbedtls_sha512_starts( (mbedtls_sha512_context *) ctx, 0 );
}
static void sha512_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
- sha512_update( (sha512_context *) ctx, input, ilen );
+ mbedtls_sha512_update( (mbedtls_sha512_context *) ctx, input, ilen );
}
static void sha512_finish_wrap( void *ctx, unsigned char *output )
{
- sha512_finish( (sha512_context *) ctx, output );
+ mbedtls_sha512_finish( (mbedtls_sha512_context *) ctx, output );
}
static void sha512_wrap( const unsigned char *input, size_t ilen,
unsigned char *output )
{
- sha512( input, ilen, output, 0 );
+ mbedtls_sha512( input, ilen, output, 0 );
}
static int sha512_file_wrap( const char *path, unsigned char *output )
{
-#if defined(POLARSSL_FS_IO)
- return sha512_file( path, output, 0 );
+#if defined(MBEDTLS_FS_IO)
+ return mbedtls_sha512_file( path, output, 0 );
#else
((void) path);
((void) output);
- return( POLARSSL_ERR_MD_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE );
#endif
}
static void * sha512_ctx_alloc( void )
{
- sha512_context *ctx;
- ctx = polarssl_malloc( sizeof( sha512_context ) );
+ mbedtls_sha512_context *ctx;
+ ctx = mbedtls_malloc( sizeof( mbedtls_sha512_context ) );
if( ctx == NULL )
return( NULL );
- sha512_init( ctx );
+ mbedtls_sha512_init( ctx );
return( ctx );
}
static void sha512_ctx_free( void *ctx )
{
- sha512_free( (sha512_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_sha512_free( (mbedtls_sha512_context *) ctx );
+ mbedtls_free( ctx );
}
static void sha512_process_wrap( void *ctx, const unsigned char *data )
{
- sha512_process( (sha512_context *) ctx, data );
+ mbedtls_sha512_process( (mbedtls_sha512_context *) ctx, data );
}
-const md_info_t sha512_info = {
- POLARSSL_MD_SHA512,
+const mbedtls_md_info_t mbedtls_sha512_info = {
+ MBEDTLS_MD_SHA512,
"SHA512",
64,
128,
@@ -684,6 +684,6 @@
sha512_process_wrap,
};
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
-#endif /* POLARSSL_MD_C */
+#endif /* MBEDTLS_MD_C */
diff --git a/library/memory_buffer_alloc.c b/library/memory_buffer_alloc.c
index 1d7750a..6e5a8ce 100644
--- a/library/memory_buffer_alloc.c
+++ b/library/memory_buffer_alloc.c
@@ -20,31 +20,31 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
#include "mbedtls/memory_buffer_alloc.h"
-/* No need for the header guard as POLARSSL_MEMORY_BUFFER_ALLOC_C
- is dependent upon POLARSSL_PLATFORM_C */
+/* No need for the header guard as MBEDTLS_MEMORY_BUFFER_ALLOC_C
+ is dependent upon MBEDTLS_PLATFORM_C */
#include "mbedtls/platform.h"
#include <string.h>
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
#include <execinfo.h>
#endif
-#if defined(POLARSSL_THREADING_C)
+#if defined(MBEDTLS_THREADING_C)
#include "mbedtls/threading.h"
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -62,7 +62,7 @@
memory_header *next;
memory_header *prev_free;
memory_header *next_free;
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
char **trace;
size_t trace_count;
#endif
@@ -76,7 +76,7 @@
memory_header *first;
memory_header *first_free;
int verify;
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
size_t malloc_count;
size_t free_count;
size_t total_used;
@@ -84,33 +84,33 @@
size_t header_count;
size_t maximum_header_count;
#endif
-#if defined(POLARSSL_THREADING_C)
- threading_mutex_t mutex;
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_threading_mutex_t mutex;
#endif
}
buffer_alloc_ctx;
static buffer_alloc_ctx heap;
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
static void debug_header( memory_header *hdr )
{
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
size_t i;
#endif
- polarssl_fprintf( stderr, "HDR: PTR(%10zu), PREV(%10zu), NEXT(%10zu), "
+ mbedtls_fprintf( stderr, "HDR: PTR(%10zu), PREV(%10zu), NEXT(%10zu), "
"ALLOC(%zu), SIZE(%10zu)\n",
(size_t) hdr, (size_t) hdr->prev, (size_t) hdr->next,
hdr->alloc, hdr->size );
- polarssl_fprintf( stderr, " FPREV(%10zu), FNEXT(%10zu)\n",
+ mbedtls_fprintf( stderr, " FPREV(%10zu), FNEXT(%10zu)\n",
(size_t) hdr->prev_free, (size_t) hdr->next_free );
-#if defined(POLARSSL_MEMORY_BACKTRACE)
- polarssl_fprintf( stderr, "TRACE: \n" );
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
+ mbedtls_fprintf( stderr, "TRACE: \n" );
for( i = 0; i < hdr->trace_count; i++ )
- polarssl_fprintf( stderr, "%s\n", hdr->trace[i] );
- polarssl_fprintf( stderr, "\n" );
+ mbedtls_fprintf( stderr, "%s\n", hdr->trace[i] );
+ mbedtls_fprintf( stderr, "\n" );
#endif
}
@@ -118,14 +118,14 @@
{
memory_header *cur = heap.first;
- polarssl_fprintf( stderr, "\nBlock list\n" );
+ mbedtls_fprintf( stderr, "\nBlock list\n" );
while( cur != NULL )
{
debug_header( cur );
cur = cur->next;
}
- polarssl_fprintf( stderr, "Free list\n" );
+ mbedtls_fprintf( stderr, "Free list\n" );
cur = heap.first_free;
while( cur != NULL )
@@ -134,46 +134,46 @@
cur = cur->next_free;
}
}
-#endif /* POLARSSL_MEMORY_DEBUG */
+#endif /* MBEDTLS_MEMORY_DEBUG */
static int verify_header( memory_header *hdr )
{
if( hdr->magic1 != MAGIC1 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: MAGIC1 mismatch\n" );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: MAGIC1 mismatch\n" );
#endif
return( 1 );
}
if( hdr->magic2 != MAGIC2 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: MAGIC2 mismatch\n" );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: MAGIC2 mismatch\n" );
#endif
return( 1 );
}
if( hdr->alloc > 1 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: alloc has illegal value\n" );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: alloc has illegal value\n" );
#endif
return( 1 );
}
if( hdr->prev != NULL && hdr->prev == hdr->next )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: prev == next\n" );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: prev == next\n" );
#endif
return( 1 );
}
if( hdr->prev_free != NULL && hdr->prev_free == hdr->next_free )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: prev_free == next_free\n" );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: prev_free == next_free\n" );
#endif
return( 1 );
}
@@ -187,8 +187,8 @@
if( verify_header( heap.first ) != 0 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: verification of first header "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: verification of first header "
"failed\n" );
#endif
return( 1 );
@@ -196,8 +196,8 @@
if( heap.first->prev != NULL )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: verification failed: "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: verification failed: "
"first->prev != NULL\n" );
#endif
return( 1 );
@@ -207,8 +207,8 @@
{
if( verify_header( cur ) != 0 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: verification of header "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: verification of header "
"failed\n" );
#endif
return( 1 );
@@ -216,8 +216,8 @@
if( cur->prev != prv )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: verification failed: "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: verification failed: "
"cur->prev != prv\n" );
#endif
return( 1 );
@@ -234,7 +234,7 @@
{
memory_header *new, *cur = heap.first_free;
unsigned char *p;
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
void *trace_buffer[MAX_BT];
size_t trace_cnt;
#endif
@@ -242,10 +242,10 @@
if( heap.buf == NULL || heap.first == NULL )
return( NULL );
- if( len % POLARSSL_MEMORY_ALIGN_MULTIPLE )
+ if( len % MBEDTLS_MEMORY_ALIGN_MULTIPLE )
{
- len -= len % POLARSSL_MEMORY_ALIGN_MULTIPLE;
- len += POLARSSL_MEMORY_ALIGN_MULTIPLE;
+ len -= len % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
+ len += MBEDTLS_MEMORY_ALIGN_MULTIPLE;
}
// Find block that fits
@@ -263,21 +263,21 @@
if( cur->alloc != 0 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: block in free_list but allocated "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: block in free_list but allocated "
"data\n" );
#endif
- polarssl_exit( 1 );
+ mbedtls_exit( 1 );
}
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.malloc_count++;
#endif
// Found location, split block if > memory_header + 4 room left
//
if( cur->size - len < sizeof(memory_header) +
- POLARSSL_MEMORY_ALIGN_MULTIPLE )
+ MBEDTLS_MEMORY_ALIGN_MULTIPLE )
{
cur->alloc = 1;
@@ -294,19 +294,19 @@
cur->prev_free = NULL;
cur->next_free = NULL;
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.total_used += cur->size;
if( heap.total_used > heap.maximum_used )
heap.maximum_used = heap.total_used;
#endif
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
trace_cnt = backtrace( trace_buffer, MAX_BT );
cur->trace = backtrace_symbols( trace_buffer, trace_cnt );
cur->trace_count = trace_cnt;
#endif
- if( ( heap.verify & MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
- polarssl_exit( 1 );
+ if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
+ mbedtls_exit( 1 );
return( ( (unsigned char *) cur ) + sizeof(memory_header) );
}
@@ -318,7 +318,7 @@
new->alloc = 0;
new->prev = cur;
new->next = cur->next;
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
new->trace = NULL;
new->trace_count = 0;
#endif
@@ -346,7 +346,7 @@
cur->prev_free = NULL;
cur->next_free = NULL;
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.header_count++;
if( heap.header_count > heap.maximum_header_count )
heap.maximum_header_count = heap.header_count;
@@ -354,14 +354,14 @@
if( heap.total_used > heap.maximum_used )
heap.maximum_used = heap.total_used;
#endif
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
trace_cnt = backtrace( trace_buffer, MAX_BT );
cur->trace = backtrace_symbols( trace_buffer, trace_cnt );
cur->trace_count = trace_cnt;
#endif
- if( ( heap.verify & MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
- polarssl_exit( 1 );
+ if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
+ mbedtls_exit( 1 );
return( ( (unsigned char *) cur ) + sizeof(memory_header) );
}
@@ -376,31 +376,31 @@
if( p < heap.buf || p > heap.buf + heap.len )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: polarssl_free() outside of managed "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: mbedtls_free() outside of managed "
"space\n" );
#endif
- polarssl_exit( 1 );
+ mbedtls_exit( 1 );
}
p -= sizeof(memory_header);
hdr = (memory_header *) p;
if( verify_header( hdr ) != 0 )
- polarssl_exit( 1 );
+ mbedtls_exit( 1 );
if( hdr->alloc != 1 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
- polarssl_fprintf( stderr, "FATAL: polarssl_free() on unallocated "
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_fprintf( stderr, "FATAL: mbedtls_free() on unallocated "
"data\n" );
#endif
- polarssl_exit( 1 );
+ mbedtls_exit( 1 );
}
hdr->alloc = 0;
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.free_count++;
heap.total_used -= hdr->size;
#endif
@@ -409,7 +409,7 @@
//
if( hdr->prev != NULL && hdr->prev->alloc == 0 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.header_count--;
#endif
hdr->prev->size += sizeof(memory_header) + hdr->size;
@@ -420,7 +420,7 @@
if( hdr->next != NULL )
hdr->next->prev = hdr;
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
free( old->trace );
#endif
memset( old, 0, sizeof(memory_header) );
@@ -430,7 +430,7 @@
//
if( hdr->next != NULL && hdr->next->alloc == 0 )
{
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.header_count--;
#endif
hdr->size += sizeof(memory_header) + hdr->next->size;
@@ -462,7 +462,7 @@
if( hdr->next != NULL )
hdr->next->prev = hdr;
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
free( old->trace );
#endif
memset( old, 0, sizeof(memory_header) );
@@ -479,29 +479,29 @@
heap.first_free = hdr;
}
-#if defined(POLARSSL_MEMORY_BACKTRACE)
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
hdr->trace = NULL;
hdr->trace_count = 0;
#endif
- if( ( heap.verify & MEMORY_VERIFY_FREE ) && verify_chain() != 0 )
- polarssl_exit( 1 );
+ if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_FREE ) && verify_chain() != 0 )
+ mbedtls_exit( 1 );
}
-void memory_buffer_set_verify( int verify )
+void mbedtls_memory_buffer_set_verify( int verify )
{
heap.verify = verify;
}
-int memory_buffer_alloc_verify()
+int mbedtls_memory_buffer_alloc_verify()
{
return verify_chain();
}
-#if defined(POLARSSL_MEMORY_DEBUG)
-void memory_buffer_alloc_status()
+#if defined(MBEDTLS_MEMORY_DEBUG)
+void mbedtls_memory_buffer_alloc_status()
{
- polarssl_fprintf( stderr,
+ mbedtls_fprintf( stderr,
"Current use: %zu blocks / %zu bytes, max: %zu blocks / "
"%zu bytes (total %zu bytes), malloc / free: %zu / %zu\n",
heap.header_count, heap.total_used,
@@ -511,71 +511,71 @@
heap.malloc_count, heap.free_count );
if( heap.first->next == NULL )
- polarssl_fprintf( stderr, "All memory de-allocated in stack buffer\n" );
+ mbedtls_fprintf( stderr, "All memory de-allocated in stack buffer\n" );
else
{
- polarssl_fprintf( stderr, "Memory currently allocated:\n" );
+ mbedtls_fprintf( stderr, "Memory currently allocated:\n" );
debug_chain();
}
}
-void memory_buffer_alloc_max_get( size_t *max_used, size_t *max_blocks )
+void mbedtls_memory_buffer_alloc_max_get( size_t *max_used, size_t *max_blocks )
{
*max_used = heap.maximum_used;
*max_blocks = heap.maximum_header_count;
}
-void memory_buffer_alloc_max_reset( void )
+void mbedtls_memory_buffer_alloc_max_reset( void )
{
heap.maximum_used = 0;
heap.maximum_header_count = 0;
}
-void memory_buffer_alloc_cur_get( size_t *cur_used, size_t *cur_blocks )
+void mbedtls_memory_buffer_alloc_cur_get( size_t *cur_used, size_t *cur_blocks )
{
*cur_used = heap.total_used;
*cur_blocks = heap.header_count;
}
-#endif /* POLARSSL_MEMORY_DEBUG */
+#endif /* MBEDTLS_MEMORY_DEBUG */
-#if defined(POLARSSL_THREADING_C)
+#if defined(MBEDTLS_THREADING_C)
static void *buffer_alloc_malloc_mutexed( size_t len )
{
void *buf;
- polarssl_mutex_lock( &heap.mutex );
+ mbedtls_mutex_lock( &heap.mutex );
buf = buffer_alloc_malloc( len );
- polarssl_mutex_unlock( &heap.mutex );
+ mbedtls_mutex_unlock( &heap.mutex );
return( buf );
}
static void buffer_alloc_free_mutexed( void *ptr )
{
- polarssl_mutex_lock( &heap.mutex );
+ mbedtls_mutex_lock( &heap.mutex );
buffer_alloc_free( ptr );
- polarssl_mutex_unlock( &heap.mutex );
+ mbedtls_mutex_unlock( &heap.mutex );
}
-#endif /* POLARSSL_THREADING_C */
+#endif /* MBEDTLS_THREADING_C */
-int memory_buffer_alloc_init( unsigned char *buf, size_t len )
+int mbedtls_memory_buffer_alloc_init( unsigned char *buf, size_t len )
{
memset( &heap, 0, sizeof(buffer_alloc_ctx) );
memset( buf, 0, len );
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_init( &heap.mutex );
- platform_set_malloc_free( buffer_alloc_malloc_mutexed,
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_init( &heap.mutex );
+ mbedtls_platform_set_malloc_free( buffer_alloc_malloc_mutexed,
buffer_alloc_free_mutexed );
#else
- platform_set_malloc_free( buffer_alloc_malloc, buffer_alloc_free );
+ mbedtls_platform_set_malloc_free( buffer_alloc_malloc, buffer_alloc_free );
#endif
- if( (size_t) buf % POLARSSL_MEMORY_ALIGN_MULTIPLE )
+ if( (size_t) buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE )
{
/* Adjust len first since buf is used in the computation */
- len -= POLARSSL_MEMORY_ALIGN_MULTIPLE
- - (size_t) buf % POLARSSL_MEMORY_ALIGN_MULTIPLE;
- buf += POLARSSL_MEMORY_ALIGN_MULTIPLE
- - (size_t) buf % POLARSSL_MEMORY_ALIGN_MULTIPLE;
+ len -= MBEDTLS_MEMORY_ALIGN_MULTIPLE
+ - (size_t) buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
+ buf += MBEDTLS_MEMORY_ALIGN_MULTIPLE
+ - (size_t) buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
}
heap.buf = buf;
@@ -589,21 +589,21 @@
return( 0 );
}
-void memory_buffer_alloc_free()
+void mbedtls_memory_buffer_alloc_free()
{
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_free( &heap.mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_free( &heap.mutex );
#endif
- polarssl_zeroize( &heap, sizeof(buffer_alloc_ctx) );
+ mbedtls_zeroize( &heap, sizeof(buffer_alloc_ctx) );
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
static int check_pointer( void *p )
{
if( p == NULL )
return( -1 );
- if( (size_t) p % POLARSSL_MEMORY_ALIGN_MULTIPLE != 0 )
+ if( (size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0 )
return( -1 );
return( 0 );
@@ -612,7 +612,7 @@
static int check_all_free( )
{
if(
-#if defined(POLARSSL_MEMORY_DEBUG)
+#if defined(MBEDTLS_MEMORY_DEBUG)
heap.total_used != 0 ||
#endif
heap.first != heap.first_free ||
@@ -628,107 +628,107 @@
if( ! (condition) ) \
{ \
if( verbose != 0 ) \
- polarssl_printf( "failed\n" ); \
+ mbedtls_printf( "failed\n" ); \
\
ret = 1; \
goto cleanup; \
}
-int memory_buffer_alloc_self_test( int verbose )
+int mbedtls_memory_buffer_alloc_self_test( int verbose )
{
unsigned char buf[1024];
unsigned char *p, *q, *r, *end;
int ret = 0;
if( verbose != 0 )
- polarssl_printf( " MBA test #1 (basic alloc-free cycle): " );
+ mbedtls_printf( " MBA test #1 (basic alloc-free cycle): " );
- memory_buffer_alloc_init( buf, sizeof( buf ) );
+ mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
- p = polarssl_malloc( 1 );
- q = polarssl_malloc( 128 );
- r = polarssl_malloc( 16 );
+ p = mbedtls_malloc( 1 );
+ q = mbedtls_malloc( 128 );
+ r = mbedtls_malloc( 16 );
TEST_ASSERT( check_pointer( p ) == 0 &&
check_pointer( q ) == 0 &&
check_pointer( r ) == 0 );
- polarssl_free( r );
- polarssl_free( q );
- polarssl_free( p );
+ mbedtls_free( r );
+ mbedtls_free( q );
+ mbedtls_free( p );
TEST_ASSERT( check_all_free( ) == 0 );
/* Memorize end to compare with the next test */
end = heap.buf + heap.len;
- memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free( );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " MBA test #2 (buf not aligned): " );
+ mbedtls_printf( " MBA test #2 (buf not aligned): " );
- memory_buffer_alloc_init( buf + 1, sizeof( buf ) - 1 );
+ mbedtls_memory_buffer_alloc_init( buf + 1, sizeof( buf ) - 1 );
TEST_ASSERT( heap.buf + heap.len == end );
- p = polarssl_malloc( 1 );
- q = polarssl_malloc( 128 );
- r = polarssl_malloc( 16 );
+ p = mbedtls_malloc( 1 );
+ q = mbedtls_malloc( 128 );
+ r = mbedtls_malloc( 16 );
TEST_ASSERT( check_pointer( p ) == 0 &&
check_pointer( q ) == 0 &&
check_pointer( r ) == 0 );
- polarssl_free( r );
- polarssl_free( q );
- polarssl_free( p );
+ mbedtls_free( r );
+ mbedtls_free( q );
+ mbedtls_free( p );
TEST_ASSERT( check_all_free( ) == 0 );
- memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free( );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " MBA test #3 (full): " );
+ mbedtls_printf( " MBA test #3 (full): " );
- memory_buffer_alloc_init( buf, sizeof( buf ) );
+ mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
- p = polarssl_malloc( sizeof( buf ) - sizeof( memory_header ) );
+ p = mbedtls_malloc( sizeof( buf ) - sizeof( memory_header ) );
TEST_ASSERT( check_pointer( p ) == 0 );
- TEST_ASSERT( polarssl_malloc( 1 ) == NULL );
+ TEST_ASSERT( mbedtls_malloc( 1 ) == NULL );
- polarssl_free( p );
+ mbedtls_free( p );
- p = polarssl_malloc( sizeof( buf ) - 2 * sizeof( memory_header ) - 16 );
- q = polarssl_malloc( 16 );
+ p = mbedtls_malloc( sizeof( buf ) - 2 * sizeof( memory_header ) - 16 );
+ q = mbedtls_malloc( 16 );
TEST_ASSERT( check_pointer( p ) == 0 && check_pointer( q ) == 0 );
- TEST_ASSERT( polarssl_malloc( 1 ) == NULL );
+ TEST_ASSERT( mbedtls_malloc( 1 ) == NULL );
- polarssl_free( q );
+ mbedtls_free( q );
- TEST_ASSERT( polarssl_malloc( 17 ) == NULL );
+ TEST_ASSERT( mbedtls_malloc( 17 ) == NULL );
- polarssl_free( p );
+ mbedtls_free( p );
TEST_ASSERT( check_all_free( ) == 0 );
- memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free( );
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
cleanup:
- memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free( );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_MEMORY_BUFFER_ALLOC_C */
+#endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
diff --git a/library/net.c b/library/net.c
index a073c4c..cd53d80 100644
--- a/library/net.c
+++ b/library/net.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_NET_C)
+#if defined(MBEDTLS_NET_C)
#include "mbedtls/net.h"
@@ -35,7 +35,7 @@
#if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
!defined(EFI32)
-#if defined(POLARSSL_HAVE_IPV6)
+#if defined(MBEDTLS_HAVE_IPV6)
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
@@ -67,7 +67,7 @@
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
#include <sys/time.h>
#endif
#include <unistd.h>
@@ -86,7 +86,7 @@
#define snprintf _snprintf
#endif
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
#include <time.h>
#endif
@@ -97,7 +97,7 @@
#include <inttypes.h>
#endif
-#if !defined(POLARSSL_HAVE_IPV6)
+#if !defined(MBEDTLS_HAVE_IPV6)
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || \
defined(__DragonFly__)
#include <sys/endian.h>
@@ -135,12 +135,12 @@
(((unsigned long ) n & 0xFF000000) >> 24) );
}
#endif
-#endif /* !POLARSSL_HAVE_IPV6 */
+#endif /* !MBEDTLS_HAVE_IPV6 */
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
-#define polarssl_snprintf snprintf
+#define mbedtls_snprintf snprintf
#endif
/*
@@ -155,7 +155,7 @@
if( wsa_init_done == 0 )
{
if( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 )
- return( POLARSSL_ERR_NET_SOCKET_FAILED );
+ return( MBEDTLS_ERR_NET_SOCKET_FAILED );
wsa_init_done = 1;
}
@@ -170,9 +170,9 @@
/*
* Initiate a TCP connection with host:port and the given protocol
*/
-int net_connect( int *fd, const char *host, int port, int proto )
+int mbedtls_net_connect( int *fd, const char *host, int port, int proto )
{
-#if defined(POLARSSL_HAVE_IPV6)
+#if defined(MBEDTLS_HAVE_IPV6)
int ret;
struct addrinfo hints, *addr_list, *cur;
char port_str[6];
@@ -182,26 +182,26 @@
/* getaddrinfo expects port as a string */
memset( port_str, 0, sizeof( port_str ) );
- polarssl_snprintf( port_str, sizeof( port_str ), "%d", port );
+ mbedtls_snprintf( port_str, sizeof( port_str ), "%d", port );
/* Do name resolution with both IPv6 and IPv4 */
memset( &hints, 0, sizeof( hints ) );
hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = proto == NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
- hints.ai_protocol = proto == NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
+ hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
+ hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
if( getaddrinfo( host, port_str, &hints, &addr_list ) != 0 )
- return( POLARSSL_ERR_NET_UNKNOWN_HOST );
+ return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
/* Try the sockaddrs until a connection succeeds */
- ret = POLARSSL_ERR_NET_UNKNOWN_HOST;
+ ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
for( cur = addr_list; cur != NULL; cur = cur->ai_next )
{
*fd = (int) socket( cur->ai_family, cur->ai_socktype,
cur->ai_protocol );
if( *fd < 0 )
{
- ret = POLARSSL_ERR_NET_SOCKET_FAILED;
+ ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
@@ -212,7 +212,7 @@
}
close( *fd );
- ret = POLARSSL_ERR_NET_CONNECT_FAILED;
+ ret = MBEDTLS_ERR_NET_CONNECT_FAILED;
}
freeaddrinfo( addr_list );
@@ -230,12 +230,12 @@
return( ret );
if( ( server_host = gethostbyname( host ) ) == NULL )
- return( POLARSSL_ERR_NET_UNKNOWN_HOST );
+ return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
if( ( *fd = (int) socket( AF_INET,
- proto == NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM,
- proto == NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP ) ) < 0 )
- return( POLARSSL_ERR_NET_SOCKET_FAILED );
+ proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM,
+ proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP ) ) < 0 )
+ return( MBEDTLS_ERR_NET_SOCKET_FAILED );
memcpy( (void *) &server_addr.sin_addr,
(void *) server_host->h_addr,
@@ -248,19 +248,19 @@
sizeof( server_addr ) ) < 0 )
{
close( *fd );
- return( POLARSSL_ERR_NET_CONNECT_FAILED );
+ return( MBEDTLS_ERR_NET_CONNECT_FAILED );
}
return( 0 );
-#endif /* POLARSSL_HAVE_IPV6 */
+#endif /* MBEDTLS_HAVE_IPV6 */
}
/*
* Create a listening socket on bind_ip:port
*/
-int net_bind( int *fd, const char *bind_ip, int port, int proto )
+int mbedtls_net_bind( int *fd, const char *bind_ip, int port, int proto )
{
-#if defined(POLARSSL_HAVE_IPV6)
+#if defined(MBEDTLS_HAVE_IPV6)
int n, ret;
struct addrinfo hints, *addr_list, *cur;
char port_str[6];
@@ -270,28 +270,28 @@
/* getaddrinfo expects port as a string */
memset( port_str, 0, sizeof( port_str ) );
- polarssl_snprintf( port_str, sizeof( port_str ), "%d", port );
+ mbedtls_snprintf( port_str, sizeof( port_str ), "%d", port );
/* Bind to IPv6 and/or IPv4, but only in TCP */
memset( &hints, 0, sizeof( hints ) );
hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = proto == NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
- hints.ai_protocol = proto == NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
+ hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
+ hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
if( bind_ip == NULL )
hints.ai_flags = AI_PASSIVE;
if( getaddrinfo( bind_ip, port_str, &hints, &addr_list ) != 0 )
- return( POLARSSL_ERR_NET_UNKNOWN_HOST );
+ return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
/* Try the sockaddrs until a binding succeeds */
- ret = POLARSSL_ERR_NET_UNKNOWN_HOST;
+ ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
for( cur = addr_list; cur != NULL; cur = cur->ai_next )
{
*fd = (int) socket( cur->ai_family, cur->ai_socktype,
cur->ai_protocol );
if( *fd < 0 )
{
- ret = POLARSSL_ERR_NET_SOCKET_FAILED;
+ ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
@@ -300,24 +300,24 @@
(const char *) &n, sizeof( n ) ) != 0 )
{
close( *fd );
- ret = POLARSSL_ERR_NET_SOCKET_FAILED;
+ ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
if( bind( *fd, cur->ai_addr, cur->ai_addrlen ) != 0 )
{
close( *fd );
- ret = POLARSSL_ERR_NET_BIND_FAILED;
+ ret = MBEDTLS_ERR_NET_BIND_FAILED;
continue;
}
/* Listen only makes sense for TCP */
- if( proto == NET_PROTO_TCP )
+ if( proto == MBEDTLS_NET_PROTO_TCP )
{
- if( listen( *fd, POLARSSL_NET_LISTEN_BACKLOG ) != 0 )
+ if( listen( *fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 )
{
close( *fd );
- ret = POLARSSL_ERR_NET_LISTEN_FAILED;
+ ret = MBEDTLS_ERR_NET_LISTEN_FAILED;
continue;
}
}
@@ -341,9 +341,9 @@
return( ret );
if( ( *fd = (int) socket( AF_INET,
- proto == NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM,
- proto == NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP ) ) < 0 )
- return( POLARSSL_ERR_NET_SOCKET_FAILED );
+ proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM,
+ proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP ) ) < 0 )
+ return( MBEDTLS_ERR_NET_SOCKET_FAILED );
n = 1;
setsockopt( *fd, SOL_SOCKET, SO_REUSEADDR,
@@ -374,21 +374,21 @@
sizeof( server_addr ) ) < 0 )
{
close( *fd );
- return( POLARSSL_ERR_NET_BIND_FAILED );
+ return( MBEDTLS_ERR_NET_BIND_FAILED );
}
/* Listen only makes sense for TCP */
- if( proto == NET_PROTO_TCP )
+ if( proto == MBEDTLS_NET_PROTO_TCP )
{
- if( listen( *fd, POLARSSL_NET_LISTEN_BACKLOG ) != 0 )
+ if( listen( *fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 )
{
close( *fd );
- return( POLARSSL_ERR_NET_LISTEN_FAILED );
+ return( MBEDTLS_ERR_NET_LISTEN_FAILED );
}
}
return( 0 );
-#endif /* POLARSSL_HAVE_IPV6 */
+#endif /* MBEDTLS_HAVE_IPV6 */
}
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
@@ -434,12 +434,12 @@
/*
* Accept a connection from a remote client
*/
-int net_accept( int bind_fd, int *client_fd, void *client_ip )
+int mbedtls_net_accept( int bind_fd, int *client_fd, void *client_ip )
{
int ret;
int type;
-#if defined(POLARSSL_HAVE_IPV6)
+#if defined(MBEDTLS_HAVE_IPV6)
struct sockaddr_storage client_addr;
#else
struct sockaddr_in client_addr;
@@ -458,7 +458,7 @@
if( getsockopt( bind_fd, SOL_SOCKET, SO_TYPE, (void *) &type, &type_len ) != 0 ||
( type != SOCK_STREAM && type != SOCK_DGRAM ) )
{
- return( POLARSSL_ERR_NET_ACCEPT_FAILED );
+ return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
}
if( type == SOCK_STREAM )
@@ -479,23 +479,23 @@
if( ret < 0 )
{
if( net_would_block( bind_fd ) != 0 )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
- return( POLARSSL_ERR_NET_ACCEPT_FAILED );
+ return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
}
/* UDP: hijack the listening socket for communicating with the client */
if( type != SOCK_STREAM )
{
if( connect( bind_fd, (struct sockaddr *) &client_addr, n ) != 0 )
- return( POLARSSL_ERR_NET_ACCEPT_FAILED );
+ return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
*client_fd = bind_fd;
}
if( client_ip != NULL )
{
-#if defined(POLARSSL_HAVE_IPV6)
+#if defined(MBEDTLS_HAVE_IPV6)
if( client_addr.ss_family == AF_INET )
{
struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr;
@@ -511,7 +511,7 @@
#else
memcpy( client_ip, &client_addr.sin_addr.s_addr,
sizeof( client_addr.sin_addr.s_addr ) );
-#endif /* POLARSSL_HAVE_IPV6 */
+#endif /* MBEDTLS_HAVE_IPV6 */
}
return( 0 );
@@ -520,7 +520,7 @@
/*
* Set the socket blocking or non-blocking
*/
-int net_set_block( int fd )
+int mbedtls_net_set_block( int fd )
{
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
@@ -531,7 +531,7 @@
#endif
}
-int net_set_nonblock( int fd )
+int mbedtls_net_set_nonblock( int fd )
{
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
@@ -542,11 +542,11 @@
#endif
}
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
/*
* Portable usleep helper
*/
-void net_usleep( unsigned long usec )
+void mbedtls_net_usleep( unsigned long usec )
{
struct timeval tv;
tv.tv_sec = usec / 1000000;
@@ -558,12 +558,12 @@
#endif
select( 0, NULL, NULL, NULL, &tv );
}
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
/*
* Read at most 'len' characters
*/
-int net_recv( void *ctx, unsigned char *buf, size_t len )
+int mbedtls_net_recv( void *ctx, unsigned char *buf, size_t len )
{
int fd = *((int *) ctx);
int ret = (int) read( fd, buf, len );
@@ -571,31 +571,31 @@
if( ret < 0 )
{
if( net_would_block( fd ) != 0 )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
if( WSAGetLastError() == WSAECONNRESET )
- return( POLARSSL_ERR_NET_CONN_RESET );
+ return( MBEDTLS_ERR_NET_CONN_RESET );
#else
if( errno == EPIPE || errno == ECONNRESET )
- return( POLARSSL_ERR_NET_CONN_RESET );
+ return( MBEDTLS_ERR_NET_CONN_RESET );
if( errno == EINTR )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
#endif
- return( POLARSSL_ERR_NET_RECV_FAILED );
+ return( MBEDTLS_ERR_NET_RECV_FAILED );
}
return( ret );
}
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
/*
* Read at most 'len' characters, blocking for at most 'timeout' ms
*/
-int net_recv_timeout( void *ctx, unsigned char *buf, size_t len,
+int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, size_t len,
uint32_t timeout )
{
int ret;
@@ -613,31 +613,31 @@
/* Zero fds ready means we timed out */
if( ret == 0 )
- return( POLARSSL_ERR_NET_TIMEOUT );
+ return( MBEDTLS_ERR_NET_TIMEOUT );
if( ret < 0 )
{
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
if( WSAGetLastError() == WSAEINTR )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
#else
if( errno == EINTR )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
#endif
- return( POLARSSL_ERR_NET_RECV_FAILED );
+ return( MBEDTLS_ERR_NET_RECV_FAILED );
}
/* This call will not block */
- return( net_recv( ctx, buf, len ) );
+ return( mbedtls_net_recv( ctx, buf, len ) );
}
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
/*
* Write at most 'len' characters
*/
-int net_send( void *ctx, const unsigned char *buf, size_t len )
+int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len )
{
int fd = *((int *) ctx);
int ret = (int) write( fd, buf, len );
@@ -645,21 +645,21 @@
if( ret < 0 )
{
if( net_would_block( fd ) != 0 )
- return( POLARSSL_ERR_NET_WANT_WRITE );
+ return( MBEDTLS_ERR_NET_WANT_WRITE );
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
if( WSAGetLastError() == WSAECONNRESET )
- return( POLARSSL_ERR_NET_CONN_RESET );
+ return( MBEDTLS_ERR_NET_CONN_RESET );
#else
if( errno == EPIPE || errno == ECONNRESET )
- return( POLARSSL_ERR_NET_CONN_RESET );
+ return( MBEDTLS_ERR_NET_CONN_RESET );
if( errno == EINTR )
- return( POLARSSL_ERR_NET_WANT_WRITE );
+ return( MBEDTLS_ERR_NET_WANT_WRITE );
#endif
- return( POLARSSL_ERR_NET_SEND_FAILED );
+ return( MBEDTLS_ERR_NET_SEND_FAILED );
}
return( ret );
@@ -668,10 +668,10 @@
/*
* Gracefully close the connection
*/
-void net_close( int fd )
+void mbedtls_net_close( int fd )
{
shutdown( fd, 2 );
close( fd );
}
-#endif /* POLARSSL_NET_C */
+#endif /* MBEDTLS_NET_C */
diff --git a/library/oid.c b/library/oid.c
index ad6d184..f3ab1bb 100644
--- a/library/oid.c
+++ b/library/oid.c
@@ -22,13 +22,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_OID_C)
+#if defined(MBEDTLS_OID_C)
#include "mbedtls/oid.h"
#include "mbedtls/rsa.h"
@@ -36,30 +36,30 @@
#include <stdio.h>
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
-#define polarssl_snprintf snprintf
+#define mbedtls_snprintf snprintf
#endif
-#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
+#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
#include "mbedtls/x509.h"
#endif
/*
* Macro to automatically add the size of #define'd OIDs
*/
-#define ADD_LEN(s) s, OID_SIZE(s)
+#define ADD_LEN(s) s, MBEDTLS_OID_SIZE(s)
/*
* Macro to generate an internal function for oid_XXX_from_asn1() (used by
* the other functions)
*/
#define FN_OID_TYPED_FROM_ASN1( TYPE_T, NAME, LIST ) \
-static const TYPE_T * oid_ ## NAME ## _from_asn1( const asn1_buf *oid ) \
+static const TYPE_T * oid_ ## NAME ## _from_asn1( const mbedtls_asn1_buf *oid ) \
{ \
const TYPE_T *p = LIST; \
- const oid_descriptor_t *cur = (const oid_descriptor_t *) p; \
+ const mbedtls_oid_descriptor_t *cur = (const mbedtls_oid_descriptor_t *) p; \
if( p == NULL || oid == NULL ) return( NULL ); \
while( cur->asn1 != NULL ) { \
if( cur->asn1_len == oid->len && \
@@ -67,47 +67,47 @@
return( p ); \
} \
p++; \
- cur = (const oid_descriptor_t *) p; \
+ cur = (const mbedtls_oid_descriptor_t *) p; \
} \
return( NULL ); \
}
/*
* Macro to generate a function for retrieving a single attribute from the
- * descriptor of an oid_descriptor_t wrapper.
+ * descriptor of an mbedtls_oid_descriptor_t wrapper.
*/
#define FN_OID_GET_DESCRIPTOR_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
-int FN_NAME( const asn1_buf *oid, ATTR1_TYPE * ATTR1 ) \
+int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 ) \
{ \
const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid ); \
- if( data == NULL ) return( POLARSSL_ERR_OID_NOT_FOUND ); \
+ if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND ); \
*ATTR1 = data->descriptor.ATTR1; \
return( 0 ); \
}
/*
* Macro to generate a function for retrieving a single attribute from an
- * oid_descriptor_t wrapper.
+ * mbedtls_oid_descriptor_t wrapper.
*/
#define FN_OID_GET_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
-int FN_NAME( const asn1_buf *oid, ATTR1_TYPE * ATTR1 ) \
+int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 ) \
{ \
const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid ); \
- if( data == NULL ) return( POLARSSL_ERR_OID_NOT_FOUND ); \
+ if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND ); \
*ATTR1 = data->ATTR1; \
return( 0 ); \
}
/*
* Macro to generate a function for retrieving two attributes from an
- * oid_descriptor_t wrapper.
+ * mbedtls_oid_descriptor_t wrapper.
*/
#define FN_OID_GET_ATTR2(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1, \
ATTR2_TYPE, ATTR2) \
-int FN_NAME( const asn1_buf *oid, ATTR1_TYPE * ATTR1, ATTR2_TYPE * ATTR2 ) \
+int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1, ATTR2_TYPE * ATTR2 ) \
{ \
const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid ); \
- if( data == NULL ) return( POLARSSL_ERR_OID_NOT_FOUND ); \
+ if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND ); \
*ATTR1 = data->ATTR1; \
*ATTR2 = data->ATTR2; \
return( 0 ); \
@@ -115,7 +115,7 @@
/*
* Macro to generate a function for retrieving the OID based on a single
- * attribute from a oid_descriptor_t wrapper.
+ * attribute from a mbedtls_oid_descriptor_t wrapper.
*/
#define FN_OID_GET_OID_BY_ATTR1(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1) \
int FN_NAME( ATTR1_TYPE ATTR1, const char **oid, size_t *olen ) \
@@ -129,12 +129,12 @@
} \
cur++; \
} \
- return( POLARSSL_ERR_OID_NOT_FOUND ); \
+ return( MBEDTLS_ERR_OID_NOT_FOUND ); \
}
/*
* Macro to generate a function for retrieving the OID based on two
- * attributes from a oid_descriptor_t wrapper.
+ * attributes from a mbedtls_oid_descriptor_t wrapper.
*/
#define FN_OID_GET_OID_BY_ATTR2(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1, \
ATTR2_TYPE, ATTR2) \
@@ -150,93 +150,93 @@
} \
cur++; \
} \
- return( POLARSSL_ERR_OID_NOT_FOUND ); \
+ return( MBEDTLS_ERR_OID_NOT_FOUND ); \
}
/*
* For X520 attribute types
*/
typedef struct {
- oid_descriptor_t descriptor;
+ mbedtls_oid_descriptor_t descriptor;
const char *short_name;
} oid_x520_attr_t;
static const oid_x520_attr_t oid_x520_attr_type[] =
{
{
- { ADD_LEN( OID_AT_CN ), "id-at-commonName", "Common Name" },
+ { ADD_LEN( MBEDTLS_OID_AT_CN ), "id-at-commonName", "Common Name" },
"CN",
},
{
- { ADD_LEN( OID_AT_COUNTRY ), "id-at-countryName", "Country" },
+ { ADD_LEN( MBEDTLS_OID_AT_COUNTRY ), "id-at-countryName", "Country" },
"C",
},
{
- { ADD_LEN( OID_AT_LOCALITY ), "id-at-locality", "Locality" },
+ { ADD_LEN( MBEDTLS_OID_AT_LOCALITY ), "id-at-locality", "Locality" },
"L",
},
{
- { ADD_LEN( OID_AT_STATE ), "id-at-state", "State" },
+ { ADD_LEN( MBEDTLS_OID_AT_STATE ), "id-at-state", "State" },
"ST",
},
{
- { ADD_LEN( OID_AT_ORGANIZATION ),"id-at-organizationName", "Organization" },
+ { ADD_LEN( MBEDTLS_OID_AT_ORGANIZATION ),"id-at-organizationName", "Organization" },
"O",
},
{
- { ADD_LEN( OID_AT_ORG_UNIT ), "id-at-organizationalUnitName", "Org Unit" },
+ { ADD_LEN( MBEDTLS_OID_AT_ORG_UNIT ), "id-at-organizationalUnitName", "Org Unit" },
"OU",
},
{
- { ADD_LEN( OID_PKCS9_EMAIL ), "emailAddress", "E-mail address" },
+ { ADD_LEN( MBEDTLS_OID_PKCS9_EMAIL ), "emailAddress", "E-mail address" },
"emailAddress",
},
{
- { ADD_LEN( OID_AT_SERIAL_NUMBER ),"id-at-serialNumber", "Serial number" },
+ { ADD_LEN( MBEDTLS_OID_AT_SERIAL_NUMBER ),"id-at-serialNumber", "Serial number" },
"serialNumber",
},
{
- { ADD_LEN( OID_AT_POSTAL_ADDRESS ),"id-at-postalAddress", "Postal address" },
+ { ADD_LEN( MBEDTLS_OID_AT_POSTAL_ADDRESS ),"id-at-postalAddress", "Postal address" },
"postalAddress",
},
{
- { ADD_LEN( OID_AT_POSTAL_CODE ), "id-at-postalCode", "Postal code" },
+ { ADD_LEN( MBEDTLS_OID_AT_POSTAL_CODE ), "id-at-postalCode", "Postal code" },
"postalCode",
},
{
- { ADD_LEN( OID_AT_SUR_NAME ), "id-at-surName", "Surname" },
+ { ADD_LEN( MBEDTLS_OID_AT_SUR_NAME ), "id-at-surName", "Surname" },
"SN",
},
{
- { ADD_LEN( OID_AT_GIVEN_NAME ), "id-at-givenName", "Given name" },
+ { ADD_LEN( MBEDTLS_OID_AT_GIVEN_NAME ), "id-at-givenName", "Given name" },
"GN",
},
{
- { ADD_LEN( OID_AT_INITIALS ), "id-at-initials", "Initials" },
+ { ADD_LEN( MBEDTLS_OID_AT_INITIALS ), "id-at-initials", "Initials" },
"initials",
},
{
- { ADD_LEN( OID_AT_GENERATION_QUALIFIER ), "id-at-generationQualifier", "Generation qualifier" },
+ { ADD_LEN( MBEDTLS_OID_AT_GENERATION_QUALIFIER ), "id-at-generationQualifier", "Generation qualifier" },
"generationQualifier",
},
{
- { ADD_LEN( OID_AT_TITLE ), "id-at-title", "Title" },
+ { ADD_LEN( MBEDTLS_OID_AT_TITLE ), "id-at-title", "Title" },
"title",
},
{
- { ADD_LEN( OID_AT_DN_QUALIFIER ),"id-at-dnQualifier", "Distinguished Name qualifier" },
+ { ADD_LEN( MBEDTLS_OID_AT_DN_QUALIFIER ),"id-at-dnQualifier", "Distinguished Name qualifier" },
"dnQualifier",
},
{
- { ADD_LEN( OID_AT_PSEUDONYM ), "id-at-pseudonym", "Pseudonym" },
+ { ADD_LEN( MBEDTLS_OID_AT_PSEUDONYM ), "id-at-pseudonym", "Pseudonym" },
"pseudonym",
},
{
- { ADD_LEN( OID_DOMAIN_COMPONENT ), "id-domainComponent", "Domain component" },
+ { ADD_LEN( MBEDTLS_OID_DOMAIN_COMPONENT ), "id-domainComponent", "Domain component" },
"DC",
},
{
- { ADD_LEN( OID_AT_UNIQUE_IDENTIFIER ), "id-at-uniqueIdentifier", "Unique Identifier" },
+ { ADD_LEN( MBEDTLS_OID_AT_UNIQUE_IDENTIFIER ), "id-at-uniqueIdentifier", "Unique Identifier" },
"uniqueIdentifier",
},
{
@@ -246,38 +246,38 @@
};
FN_OID_TYPED_FROM_ASN1(oid_x520_attr_t, x520_attr, oid_x520_attr_type);
-FN_OID_GET_ATTR1(oid_get_attr_short_name, oid_x520_attr_t, x520_attr, const char *, short_name);
+FN_OID_GET_ATTR1(mbedtls_oid_get_attr_short_name, oid_x520_attr_t, x520_attr, const char *, short_name);
-#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
+#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
/*
* For X509 extensions
*/
typedef struct {
- oid_descriptor_t descriptor;
+ mbedtls_oid_descriptor_t descriptor;
int ext_type;
} oid_x509_ext_t;
static const oid_x509_ext_t oid_x509_ext[] =
{
{
- { ADD_LEN( OID_BASIC_CONSTRAINTS ), "id-ce-basicConstraints", "Basic Constraints" },
- EXT_BASIC_CONSTRAINTS,
+ { ADD_LEN( MBEDTLS_OID_BASIC_CONSTRAINTS ), "id-ce-basicConstraints", "Basic Constraints" },
+ MBEDTLS_EXT_BASIC_CONSTRAINTS,
},
{
- { ADD_LEN( OID_KEY_USAGE ), "id-ce-keyUsage", "Key Usage" },
- EXT_KEY_USAGE,
+ { ADD_LEN( MBEDTLS_OID_KEY_USAGE ), "id-ce-keyUsage", "Key Usage" },
+ MBEDTLS_X509_EXT_KEY_USAGE,
},
{
- { ADD_LEN( OID_EXTENDED_KEY_USAGE ), "id-ce-keyUsage", "Extended Key Usage" },
- EXT_EXTENDED_KEY_USAGE,
+ { ADD_LEN( MBEDTLS_OID_EXTENDED_KEY_USAGE ), "id-ce-keyUsage", "Extended Key Usage" },
+ MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE,
},
{
- { ADD_LEN( OID_SUBJECT_ALT_NAME ), "id-ce-subjectAltName", "Subject Alt Name" },
- EXT_SUBJECT_ALT_NAME,
+ { ADD_LEN( MBEDTLS_OID_SUBJECT_ALT_NAME ), "id-ce-subjectAltName", "Subject Alt Name" },
+ MBEDTLS_EXT_SUBJECT_ALT_NAME,
},
{
- { ADD_LEN( OID_NS_CERT_TYPE ), "id-netscape-certtype", "Netscape Certificate Type" },
- EXT_NS_CERT_TYPE,
+ { ADD_LEN( MBEDTLS_OID_NS_CERT_TYPE ), "id-netscape-certtype", "Netscape Certificate Type" },
+ MBEDTLS_X509_EXT_NS_CERT_TYPE,
},
{
{ NULL, 0, NULL, NULL },
@@ -286,317 +286,317 @@
};
FN_OID_TYPED_FROM_ASN1(oid_x509_ext_t, x509_ext, oid_x509_ext);
-FN_OID_GET_ATTR1(oid_get_x509_ext_type, oid_x509_ext_t, x509_ext, int, ext_type);
+FN_OID_GET_ATTR1(mbedtls_oid_get_x509_ext_type, oid_x509_ext_t, x509_ext, int, ext_type);
-static const oid_descriptor_t oid_ext_key_usage[] =
+static const mbedtls_oid_descriptor_t oid_ext_key_usage[] =
{
- { ADD_LEN( OID_SERVER_AUTH ), "id-kp-serverAuth", "TLS Web Server Authentication" },
- { ADD_LEN( OID_CLIENT_AUTH ), "id-kp-clientAuth", "TLS Web Client Authentication" },
- { ADD_LEN( OID_CODE_SIGNING ), "id-kp-codeSigning", "Code Signing" },
- { ADD_LEN( OID_EMAIL_PROTECTION ), "id-kp-emailProtection", "E-mail Protection" },
- { ADD_LEN( OID_TIME_STAMPING ), "id-kp-timeStamping", "Time Stamping" },
- { ADD_LEN( OID_OCSP_SIGNING ), "id-kp-OCSPSigning", "OCSP Signing" },
+ { ADD_LEN( MBEDTLS_OID_SERVER_AUTH ), "id-kp-serverAuth", "TLS Web Server Authentication" },
+ { ADD_LEN( MBEDTLS_OID_CLIENT_AUTH ), "id-kp-clientAuth", "TLS Web Client Authentication" },
+ { ADD_LEN( MBEDTLS_OID_CODE_SIGNING ), "id-kp-codeSigning", "Code Signing" },
+ { ADD_LEN( MBEDTLS_OID_EMAIL_PROTECTION ), "id-kp-emailProtection", "E-mail Protection" },
+ { ADD_LEN( MBEDTLS_OID_TIME_STAMPING ), "id-kp-timeStamping", "Time Stamping" },
+ { ADD_LEN( MBEDTLS_OID_OCSP_SIGNING ), "id-kp-OCSPSigning", "OCSP Signing" },
{ NULL, 0, NULL, NULL },
};
-FN_OID_TYPED_FROM_ASN1(oid_descriptor_t, ext_key_usage, oid_ext_key_usage);
-FN_OID_GET_ATTR1(oid_get_extended_key_usage, oid_descriptor_t, ext_key_usage, const char *, description);
-#endif /* POLARSSL_X509_USE_C || POLARSSL_X509_CREATE_C */
+FN_OID_TYPED_FROM_ASN1(mbedtls_oid_descriptor_t, ext_key_usage, oid_ext_key_usage);
+FN_OID_GET_ATTR1(mbedtls_oid_get_extended_key_usage, mbedtls_oid_descriptor_t, ext_key_usage, const char *, description);
+#endif /* MBEDTLS_X509_USE_C || MBEDTLS_X509_CREATE_C */
-#if defined(POLARSSL_MD_C)
+#if defined(MBEDTLS_MD_C)
/*
* For SignatureAlgorithmIdentifier
*/
typedef struct {
- oid_descriptor_t descriptor;
- md_type_t md_alg;
- pk_type_t pk_alg;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_md_type_t md_alg;
+ mbedtls_pk_type_t pk_alg;
} oid_sig_alg_t;
static const oid_sig_alg_t oid_sig_alg[] =
{
{
- { ADD_LEN( OID_PKCS1_MD2 ), "md2WithRSAEncryption", "RSA with MD2" },
- POLARSSL_MD_MD2, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_MD2 ), "md2WithRSAEncryption", "RSA with MD2" },
+ MBEDTLS_MD_MD2, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_MD4 ), "md4WithRSAEncryption", "RSA with MD4" },
- POLARSSL_MD_MD4, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_MD4 ), "md4WithRSAEncryption", "RSA with MD4" },
+ MBEDTLS_MD_MD4, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_MD5 ), "md5WithRSAEncryption", "RSA with MD5" },
- POLARSSL_MD_MD5, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_MD5 ), "md5WithRSAEncryption", "RSA with MD5" },
+ MBEDTLS_MD_MD5, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_SHA1 ), "sha-1WithRSAEncryption", "RSA with SHA1" },
- POLARSSL_MD_SHA1, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_SHA1 ), "sha-1WithRSAEncryption", "RSA with SHA1" },
+ MBEDTLS_MD_SHA1, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_SHA224 ), "sha224WithRSAEncryption", "RSA with SHA-224" },
- POLARSSL_MD_SHA224, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_SHA224 ), "sha224WithRSAEncryption", "RSA with SHA-224" },
+ MBEDTLS_MD_SHA224, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_SHA256 ), "sha256WithRSAEncryption", "RSA with SHA-256" },
- POLARSSL_MD_SHA256, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_SHA256 ), "sha256WithRSAEncryption", "RSA with SHA-256" },
+ MBEDTLS_MD_SHA256, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_SHA384 ), "sha384WithRSAEncryption", "RSA with SHA-384" },
- POLARSSL_MD_SHA384, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_SHA384 ), "sha384WithRSAEncryption", "RSA with SHA-384" },
+ MBEDTLS_MD_SHA384, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_PKCS1_SHA512 ), "sha512WithRSAEncryption", "RSA with SHA-512" },
- POLARSSL_MD_SHA512, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_SHA512 ), "sha512WithRSAEncryption", "RSA with SHA-512" },
+ MBEDTLS_MD_SHA512, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_RSA_SHA_OBS ), "sha-1WithRSAEncryption", "RSA with SHA1" },
- POLARSSL_MD_SHA1, POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_RSA_SHA_OBS ), "sha-1WithRSAEncryption", "RSA with SHA1" },
+ MBEDTLS_MD_SHA1, MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_ECDSA_SHA1 ), "ecdsa-with-SHA1", "ECDSA with SHA1" },
- POLARSSL_MD_SHA1, POLARSSL_PK_ECDSA,
+ { ADD_LEN( MBEDTLS_OID_ECDSA_SHA1 ), "ecdsa-with-SHA1", "ECDSA with SHA1" },
+ MBEDTLS_MD_SHA1, MBEDTLS_PK_ECDSA,
},
{
- { ADD_LEN( OID_ECDSA_SHA224 ), "ecdsa-with-SHA224", "ECDSA with SHA224" },
- POLARSSL_MD_SHA224, POLARSSL_PK_ECDSA,
+ { ADD_LEN( MBEDTLS_OID_ECDSA_SHA224 ), "ecdsa-with-SHA224", "ECDSA with SHA224" },
+ MBEDTLS_MD_SHA224, MBEDTLS_PK_ECDSA,
},
{
- { ADD_LEN( OID_ECDSA_SHA256 ), "ecdsa-with-SHA256", "ECDSA with SHA256" },
- POLARSSL_MD_SHA256, POLARSSL_PK_ECDSA,
+ { ADD_LEN( MBEDTLS_OID_ECDSA_SHA256 ), "ecdsa-with-SHA256", "ECDSA with SHA256" },
+ MBEDTLS_MD_SHA256, MBEDTLS_PK_ECDSA,
},
{
- { ADD_LEN( OID_ECDSA_SHA384 ), "ecdsa-with-SHA384", "ECDSA with SHA384" },
- POLARSSL_MD_SHA384, POLARSSL_PK_ECDSA,
+ { ADD_LEN( MBEDTLS_OID_ECDSA_SHA384 ), "ecdsa-with-SHA384", "ECDSA with SHA384" },
+ MBEDTLS_MD_SHA384, MBEDTLS_PK_ECDSA,
},
{
- { ADD_LEN( OID_ECDSA_SHA512 ), "ecdsa-with-SHA512", "ECDSA with SHA512" },
- POLARSSL_MD_SHA512, POLARSSL_PK_ECDSA,
+ { ADD_LEN( MBEDTLS_OID_ECDSA_SHA512 ), "ecdsa-with-SHA512", "ECDSA with SHA512" },
+ MBEDTLS_MD_SHA512, MBEDTLS_PK_ECDSA,
},
{
- { ADD_LEN( OID_RSASSA_PSS ), "RSASSA-PSS", "RSASSA-PSS" },
- POLARSSL_MD_NONE, POLARSSL_PK_RSASSA_PSS,
+ { ADD_LEN( MBEDTLS_OID_RSASSA_PSS ), "RSASSA-PSS", "RSASSA-PSS" },
+ MBEDTLS_MD_NONE, MBEDTLS_PK_RSASSA_PSS,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_MD_NONE, POLARSSL_PK_NONE,
+ MBEDTLS_MD_NONE, MBEDTLS_PK_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_sig_alg_t, sig_alg, oid_sig_alg);
-FN_OID_GET_DESCRIPTOR_ATTR1(oid_get_sig_alg_desc, oid_sig_alg_t, sig_alg, const char *, description);
-FN_OID_GET_ATTR2(oid_get_sig_alg, oid_sig_alg_t, sig_alg, md_type_t, md_alg, pk_type_t, pk_alg);
-FN_OID_GET_OID_BY_ATTR2(oid_get_oid_by_sig_alg, oid_sig_alg_t, oid_sig_alg, pk_type_t, pk_alg, md_type_t, md_alg);
-#endif /* POLARSSL_MD_C */
+FN_OID_GET_DESCRIPTOR_ATTR1(mbedtls_oid_get_sig_alg_desc, oid_sig_alg_t, sig_alg, const char *, description);
+FN_OID_GET_ATTR2(mbedtls_oid_get_sig_alg, oid_sig_alg_t, sig_alg, mbedtls_md_type_t, md_alg, mbedtls_pk_type_t, pk_alg);
+FN_OID_GET_OID_BY_ATTR2(mbedtls_oid_get_oid_by_sig_alg, oid_sig_alg_t, oid_sig_alg, mbedtls_pk_type_t, pk_alg, mbedtls_md_type_t, md_alg);
+#endif /* MBEDTLS_MD_C */
/*
* For PublicKeyInfo (PKCS1, RFC 5480)
*/
typedef struct {
- oid_descriptor_t descriptor;
- pk_type_t pk_alg;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_pk_type_t pk_alg;
} oid_pk_alg_t;
static const oid_pk_alg_t oid_pk_alg[] =
{
{
- { ADD_LEN( OID_PKCS1_RSA ), "rsaEncryption", "RSA" },
- POLARSSL_PK_RSA,
+ { ADD_LEN( MBEDTLS_OID_PKCS1_RSA ), "rsaEncryption", "RSA" },
+ MBEDTLS_PK_RSA,
},
{
- { ADD_LEN( OID_EC_ALG_UNRESTRICTED ), "id-ecPublicKey", "Generic EC key" },
- POLARSSL_PK_ECKEY,
+ { ADD_LEN( MBEDTLS_OID_EC_ALG_UNRESTRICTED ), "id-ecPublicKey", "Generic EC key" },
+ MBEDTLS_PK_ECKEY,
},
{
- { ADD_LEN( OID_EC_ALG_ECDH ), "id-ecDH", "EC key for ECDH" },
- POLARSSL_PK_ECKEY_DH,
+ { ADD_LEN( MBEDTLS_OID_EC_ALG_ECDH ), "id-ecDH", "EC key for ECDH" },
+ MBEDTLS_PK_ECKEY_DH,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_PK_NONE,
+ MBEDTLS_PK_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_pk_alg_t, pk_alg, oid_pk_alg);
-FN_OID_GET_ATTR1(oid_get_pk_alg, oid_pk_alg_t, pk_alg, pk_type_t, pk_alg);
-FN_OID_GET_OID_BY_ATTR1(oid_get_oid_by_pk_alg, oid_pk_alg_t, oid_pk_alg, pk_type_t, pk_alg);
+FN_OID_GET_ATTR1(mbedtls_oid_get_pk_alg, oid_pk_alg_t, pk_alg, mbedtls_pk_type_t, pk_alg);
+FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_pk_alg, oid_pk_alg_t, oid_pk_alg, mbedtls_pk_type_t, pk_alg);
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
/*
* For namedCurve (RFC 5480)
*/
typedef struct {
- oid_descriptor_t descriptor;
- ecp_group_id grp_id;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_ecp_group_id grp_id;
} oid_ecp_grp_t;
static const oid_ecp_grp_t oid_ecp_grp[] =
{
{
- { ADD_LEN( OID_EC_GRP_SECP192R1 ), "secp192r1", "secp192r1" },
- POLARSSL_ECP_DP_SECP192R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP192R1 ), "secp192r1", "secp192r1" },
+ MBEDTLS_ECP_DP_SECP192R1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP224R1 ), "secp224r1", "secp224r1" },
- POLARSSL_ECP_DP_SECP224R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP224R1 ), "secp224r1", "secp224r1" },
+ MBEDTLS_ECP_DP_SECP224R1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP256R1 ), "secp256r1", "secp256r1" },
- POLARSSL_ECP_DP_SECP256R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP256R1 ), "secp256r1", "secp256r1" },
+ MBEDTLS_ECP_DP_SECP256R1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP384R1 ), "secp384r1", "secp384r1" },
- POLARSSL_ECP_DP_SECP384R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP384R1 ), "secp384r1", "secp384r1" },
+ MBEDTLS_ECP_DP_SECP384R1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP521R1 ), "secp521r1", "secp521r1" },
- POLARSSL_ECP_DP_SECP521R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP521R1 ), "secp521r1", "secp521r1" },
+ MBEDTLS_ECP_DP_SECP521R1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP192K1 ), "secp192k1", "secp192k1" },
- POLARSSL_ECP_DP_SECP192K1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP192K1 ), "secp192k1", "secp192k1" },
+ MBEDTLS_ECP_DP_SECP192K1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP224K1 ), "secp224k1", "secp224k1" },
- POLARSSL_ECP_DP_SECP224K1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP224K1 ), "secp224k1", "secp224k1" },
+ MBEDTLS_ECP_DP_SECP224K1,
},
{
- { ADD_LEN( OID_EC_GRP_SECP256K1 ), "secp256k1", "secp256k1" },
- POLARSSL_ECP_DP_SECP256K1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP256K1 ), "secp256k1", "secp256k1" },
+ MBEDTLS_ECP_DP_SECP256K1,
},
{
- { ADD_LEN( OID_EC_GRP_BP256R1 ), "brainpoolP256r1","brainpool256r1" },
- POLARSSL_ECP_DP_BP256R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_BP256R1 ), "brainpoolP256r1","brainpool256r1" },
+ MBEDTLS_ECP_DP_BP256R1,
},
{
- { ADD_LEN( OID_EC_GRP_BP384R1 ), "brainpoolP384r1","brainpool384r1" },
- POLARSSL_ECP_DP_BP384R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_BP384R1 ), "brainpoolP384r1","brainpool384r1" },
+ MBEDTLS_ECP_DP_BP384R1,
},
{
- { ADD_LEN( OID_EC_GRP_BP512R1 ), "brainpoolP512r1","brainpool512r1" },
- POLARSSL_ECP_DP_BP512R1,
+ { ADD_LEN( MBEDTLS_OID_EC_GRP_BP512R1 ), "brainpoolP512r1","brainpool512r1" },
+ MBEDTLS_ECP_DP_BP512R1,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_ECP_DP_NONE,
+ MBEDTLS_ECP_DP_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_ecp_grp_t, grp_id, oid_ecp_grp);
-FN_OID_GET_ATTR1(oid_get_ec_grp, oid_ecp_grp_t, grp_id, ecp_group_id, grp_id);
-FN_OID_GET_OID_BY_ATTR1(oid_get_oid_by_ec_grp, oid_ecp_grp_t, oid_ecp_grp, ecp_group_id, grp_id);
-#endif /* POLARSSL_ECP_C */
+FN_OID_GET_ATTR1(mbedtls_oid_get_ec_grp, oid_ecp_grp_t, grp_id, mbedtls_ecp_group_id, grp_id);
+FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_ec_grp, oid_ecp_grp_t, oid_ecp_grp, mbedtls_ecp_group_id, grp_id);
+#endif /* MBEDTLS_ECP_C */
-#if defined(POLARSSL_CIPHER_C)
+#if defined(MBEDTLS_CIPHER_C)
/*
* For PKCS#5 PBES2 encryption algorithm
*/
typedef struct {
- oid_descriptor_t descriptor;
- cipher_type_t cipher_alg;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_cipher_type_t cipher_alg;
} oid_cipher_alg_t;
static const oid_cipher_alg_t oid_cipher_alg[] =
{
{
- { ADD_LEN( OID_DES_CBC ), "desCBC", "DES-CBC" },
- POLARSSL_CIPHER_DES_CBC,
+ { ADD_LEN( MBEDTLS_OID_DES_CBC ), "desCBC", "DES-CBC" },
+ MBEDTLS_CIPHER_DES_CBC,
},
{
- { ADD_LEN( OID_DES_EDE3_CBC ), "des-ede3-cbc", "DES-EDE3-CBC" },
- POLARSSL_CIPHER_DES_EDE3_CBC,
+ { ADD_LEN( MBEDTLS_OID_DES_EDE3_CBC ), "des-ede3-cbc", "DES-EDE3-CBC" },
+ MBEDTLS_CIPHER_DES_EDE3_CBC,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_CIPHER_NONE,
+ MBEDTLS_CIPHER_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_cipher_alg_t, cipher_alg, oid_cipher_alg);
-FN_OID_GET_ATTR1(oid_get_cipher_alg, oid_cipher_alg_t, cipher_alg, cipher_type_t, cipher_alg);
-#endif /* POLARSSL_CIPHER_C */
+FN_OID_GET_ATTR1(mbedtls_oid_get_cipher_alg, oid_cipher_alg_t, cipher_alg, mbedtls_cipher_type_t, cipher_alg);
+#endif /* MBEDTLS_CIPHER_C */
-#if defined(POLARSSL_MD_C)
+#if defined(MBEDTLS_MD_C)
/*
* For digestAlgorithm
*/
typedef struct {
- oid_descriptor_t descriptor;
- md_type_t md_alg;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_md_type_t md_alg;
} oid_md_alg_t;
static const oid_md_alg_t oid_md_alg[] =
{
{
- { ADD_LEN( OID_DIGEST_ALG_MD2 ), "id-md2", "MD2" },
- POLARSSL_MD_MD2,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD2 ), "id-md2", "MD2" },
+ MBEDTLS_MD_MD2,
},
{
- { ADD_LEN( OID_DIGEST_ALG_MD4 ), "id-md4", "MD4" },
- POLARSSL_MD_MD4,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD4 ), "id-md4", "MD4" },
+ MBEDTLS_MD_MD4,
},
{
- { ADD_LEN( OID_DIGEST_ALG_MD5 ), "id-md5", "MD5" },
- POLARSSL_MD_MD5,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD5 ), "id-md5", "MD5" },
+ MBEDTLS_MD_MD5,
},
{
- { ADD_LEN( OID_DIGEST_ALG_SHA1 ), "id-sha1", "SHA-1" },
- POLARSSL_MD_SHA1,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA1 ), "id-sha1", "SHA-1" },
+ MBEDTLS_MD_SHA1,
},
{
- { ADD_LEN( OID_DIGEST_ALG_SHA224 ), "id-sha224", "SHA-224" },
- POLARSSL_MD_SHA224,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA224 ), "id-sha224", "SHA-224" },
+ MBEDTLS_MD_SHA224,
},
{
- { ADD_LEN( OID_DIGEST_ALG_SHA256 ), "id-sha256", "SHA-256" },
- POLARSSL_MD_SHA256,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA256 ), "id-sha256", "SHA-256" },
+ MBEDTLS_MD_SHA256,
},
{
- { ADD_LEN( OID_DIGEST_ALG_SHA384 ), "id-sha384", "SHA-384" },
- POLARSSL_MD_SHA384,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA384 ), "id-sha384", "SHA-384" },
+ MBEDTLS_MD_SHA384,
},
{
- { ADD_LEN( OID_DIGEST_ALG_SHA512 ), "id-sha512", "SHA-512" },
- POLARSSL_MD_SHA512,
+ { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA512 ), "id-sha512", "SHA-512" },
+ MBEDTLS_MD_SHA512,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_MD_NONE,
+ MBEDTLS_MD_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_md_alg_t, md_alg, oid_md_alg);
-FN_OID_GET_ATTR1(oid_get_md_alg, oid_md_alg_t, md_alg, md_type_t, md_alg);
-FN_OID_GET_OID_BY_ATTR1(oid_get_oid_by_md, oid_md_alg_t, oid_md_alg, md_type_t, md_alg);
-#endif /* POLARSSL_MD_C */
+FN_OID_GET_ATTR1(mbedtls_oid_get_md_alg, oid_md_alg_t, md_alg, mbedtls_md_type_t, md_alg);
+FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_md, oid_md_alg_t, oid_md_alg, mbedtls_md_type_t, md_alg);
+#endif /* MBEDTLS_MD_C */
-#if defined(POLARSSL_PKCS12_C)
+#if defined(MBEDTLS_PKCS12_C)
/*
* For PKCS#12 PBEs
*/
typedef struct {
- oid_descriptor_t descriptor;
- md_type_t md_alg;
- cipher_type_t cipher_alg;
+ mbedtls_oid_descriptor_t descriptor;
+ mbedtls_md_type_t md_alg;
+ mbedtls_cipher_type_t cipher_alg;
} oid_pkcs12_pbe_alg_t;
static const oid_pkcs12_pbe_alg_t oid_pkcs12_pbe_alg[] =
{
{
- { ADD_LEN( OID_PKCS12_PBE_SHA1_DES3_EDE_CBC ), "pbeWithSHAAnd3-KeyTripleDES-CBC", "PBE with SHA1 and 3-Key 3DES" },
- POLARSSL_MD_SHA1, POLARSSL_CIPHER_DES_EDE3_CBC,
+ { ADD_LEN( MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC ), "pbeWithSHAAnd3-KeyTripleDES-CBC", "PBE with SHA1 and 3-Key 3DES" },
+ MBEDTLS_MD_SHA1, MBEDTLS_CIPHER_DES_EDE3_CBC,
},
{
- { ADD_LEN( OID_PKCS12_PBE_SHA1_DES2_EDE_CBC ), "pbeWithSHAAnd2-KeyTripleDES-CBC", "PBE with SHA1 and 2-Key 3DES" },
- POLARSSL_MD_SHA1, POLARSSL_CIPHER_DES_EDE_CBC,
+ { ADD_LEN( MBEDTLS_OID_PKCS12_PBE_SHA1_DES2_EDE_CBC ), "pbeWithSHAAnd2-KeyTripleDES-CBC", "PBE with SHA1 and 2-Key 3DES" },
+ MBEDTLS_MD_SHA1, MBEDTLS_CIPHER_DES_EDE_CBC,
},
{
{ NULL, 0, NULL, NULL },
- POLARSSL_MD_NONE, POLARSSL_CIPHER_NONE,
+ MBEDTLS_MD_NONE, MBEDTLS_CIPHER_NONE,
},
};
FN_OID_TYPED_FROM_ASN1(oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, oid_pkcs12_pbe_alg);
-FN_OID_GET_ATTR2(oid_get_pkcs12_pbe_alg, oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, md_type_t, md_alg, cipher_type_t, cipher_alg);
-#endif /* POLARSSL_PKCS12_C */
+FN_OID_GET_ATTR2(mbedtls_oid_get_pkcs12_pbe_alg, oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, mbedtls_md_type_t, md_alg, mbedtls_cipher_type_t, cipher_alg);
+#endif /* MBEDTLS_PKCS12_C */
#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
!defined(EFI32)
@@ -637,11 +637,11 @@
#define SAFE_SNPRINTF() \
{ \
if( ret == -1 ) \
- return( POLARSSL_ERR_OID_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_OID_BUF_TOO_SMALL ); \
\
if( (unsigned int) ret >= n ) { \
p[n - 1] = '\0'; \
- return( POLARSSL_ERR_OID_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_OID_BUF_TOO_SMALL ); \
} \
\
n -= (unsigned int) ret; \
@@ -649,8 +649,8 @@
}
/* Return the x.y.z.... style numeric string for the given OID */
-int oid_get_numeric_string( char *buf, size_t size,
- const asn1_buf *oid )
+int mbedtls_oid_get_numeric_string( char *buf, size_t size,
+ const mbedtls_asn1_buf *oid )
{
int ret;
size_t i, n;
@@ -663,7 +663,7 @@
/* First byte contains first two dots */
if( oid->len > 0 )
{
- ret = polarssl_snprintf( p, n, "%d.%d", oid->p[0] / 40, oid->p[0] % 40 );
+ ret = mbedtls_snprintf( p, n, "%d.%d", oid->p[0] / 40, oid->p[0] % 40 );
SAFE_SNPRINTF();
}
@@ -672,7 +672,7 @@
{
/* Prevent overflow in value. */
if( ( ( value << 7 ) >> 7 ) != value )
- return( POLARSSL_ERR_OID_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_OID_BUF_TOO_SMALL );
value <<= 7;
value += oid->p[i] & 0x7F;
@@ -680,7 +680,7 @@
if( !( oid->p[i] & 0x80 ) )
{
/* Last byte */
- ret = polarssl_snprintf( p, n, ".%d", value );
+ ret = mbedtls_snprintf( p, n, ".%d", value );
SAFE_SNPRINTF();
value = 0;
}
@@ -689,4 +689,4 @@
return( (int) ( size - n ) );
}
-#endif /* POLARSSL_OID_C */
+#endif /* MBEDTLS_OID_C */
diff --git a/library/padlock.c b/library/padlock.c
index c6e7bf9..3e9f9a9 100644
--- a/library/padlock.c
+++ b/library/padlock.c
@@ -26,24 +26,24 @@
* programming_guide.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PADLOCK_C)
+#if defined(MBEDTLS_PADLOCK_C)
#include "mbedtls/padlock.h"
#include <string.h>
-#if defined(POLARSSL_HAVE_X86)
+#if defined(MBEDTLS_HAVE_X86)
/*
* PadLock detection routine
*/
-int padlock_supports( int feature )
+int mbedtls_padlock_supports( int feature )
{
static int flags = -1;
int ebx = 0, edx = 0;
@@ -74,7 +74,7 @@
/*
* PadLock AES-ECB block en(de)cryption
*/
-int padlock_xcryptecb( aes_context *ctx,
+int mbedtls_padlock_xcryptecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
@@ -86,7 +86,7 @@
unsigned char buf[256];
rk = ctx->rk;
- blk = PADLOCK_ALIGN16( buf );
+ blk = MBEDTLS_PADLOCK_ALIGN16( buf );
memcpy( blk, input, 16 );
ctrl = blk + 4;
@@ -114,7 +114,7 @@
/*
* PadLock AES-CBC buffer en(de)cryption
*/
-int padlock_xcryptcbc( aes_context *ctx,
+int mbedtls_padlock_xcryptcbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
@@ -130,10 +130,10 @@
if( ( (long) input & 15 ) != 0 ||
( (long) output & 15 ) != 0 )
- return( POLARSSL_ERR_PADLOCK_DATA_MISALIGNED );
+ return( MBEDTLS_ERR_PADLOCK_DATA_MISALIGNED );
rk = ctx->rk;
- iw = PADLOCK_ALIGN16( buf );
+ iw = MBEDTLS_PADLOCK_ALIGN16( buf );
memcpy( iw, iv, 16 );
ctrl = iw + 4;
@@ -162,6 +162,6 @@
return( 0 );
}
-#endif /* POLARSSL_HAVE_X86 */
+#endif /* MBEDTLS_HAVE_X86 */
-#endif /* POLARSSL_PADLOCK_C */
+#endif /* MBEDTLS_PADLOCK_C */
diff --git a/library/pem.c b/library/pem.c
index c722282..c97e800 100644
--- a/library/pem.c
+++ b/library/pem.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PEM_PARSE_C) || defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
#include "mbedtls/base64.h"
@@ -37,27 +37,27 @@
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if defined(POLARSSL_PEM_PARSE_C)
-void pem_init( pem_context *ctx )
+#if defined(MBEDTLS_PEM_PARSE_C)
+void mbedtls_pem_init( mbedtls_pem_context *ctx )
{
- memset( ctx, 0, sizeof( pem_context ) );
+ memset( ctx, 0, sizeof( mbedtls_pem_context ) );
}
-#if defined(POLARSSL_MD5_C) && defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_DES_C) || defined(POLARSSL_AES_C) )
+#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
/*
* Read a 16-byte hex string and convert it to binary
*/
@@ -73,7 +73,7 @@
if( *s >= '0' && *s <= '9' ) j = *s - '0'; else
if( *s >= 'A' && *s <= 'F' ) j = *s - '7'; else
if( *s >= 'a' && *s <= 'f' ) j = *s - 'W'; else
- return( POLARSSL_ERR_PEM_INVALID_ENC_IV );
+ return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
k = ( ( i & 1 ) != 0 ) ? j : j << 4;
@@ -87,26 +87,26 @@
unsigned char *iv,
const unsigned char *pwd, size_t pwdlen )
{
- md5_context md5_ctx;
+ mbedtls_md5_context md5_ctx;
unsigned char md5sum[16];
size_t use_len;
- md5_init( &md5_ctx );
+ mbedtls_md5_init( &md5_ctx );
/*
* key[ 0..15] = MD5(pwd || IV)
*/
- md5_starts( &md5_ctx );
- md5_update( &md5_ctx, pwd, pwdlen );
- md5_update( &md5_ctx, iv, 8 );
- md5_finish( &md5_ctx, md5sum );
+ mbedtls_md5_starts( &md5_ctx );
+ mbedtls_md5_update( &md5_ctx, pwd, pwdlen );
+ mbedtls_md5_update( &md5_ctx, iv, 8 );
+ mbedtls_md5_finish( &md5_ctx, md5sum );
if( keylen <= 16 )
{
memcpy( key, md5sum, keylen );
- md5_free( &md5_ctx );
- polarssl_zeroize( md5sum, 16 );
+ mbedtls_md5_free( &md5_ctx );
+ mbedtls_zeroize( md5sum, 16 );
return;
}
@@ -115,11 +115,11 @@
/*
* key[16..23] = MD5(key[ 0..15] || pwd || IV])
*/
- md5_starts( &md5_ctx );
- md5_update( &md5_ctx, md5sum, 16 );
- md5_update( &md5_ctx, pwd, pwdlen );
- md5_update( &md5_ctx, iv, 8 );
- md5_finish( &md5_ctx, md5sum );
+ mbedtls_md5_starts( &md5_ctx );
+ mbedtls_md5_update( &md5_ctx, md5sum, 16 );
+ mbedtls_md5_update( &md5_ctx, pwd, pwdlen );
+ mbedtls_md5_update( &md5_ctx, iv, 8 );
+ mbedtls_md5_finish( &md5_ctx, md5sum );
use_len = 16;
if( keylen < 32 )
@@ -127,11 +127,11 @@
memcpy( key + 16, md5sum, use_len );
- md5_free( &md5_ctx );
- polarssl_zeroize( md5sum, 16 );
+ mbedtls_md5_free( &md5_ctx );
+ mbedtls_zeroize( md5sum, 16 );
}
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
/*
* Decrypt with DES-CBC, using PBKDF1 for key derivation
*/
@@ -139,19 +139,19 @@
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
- des_context des_ctx;
+ mbedtls_des_context des_ctx;
unsigned char des_key[8];
- des_init( &des_ctx );
+ mbedtls_des_init( &des_ctx );
pem_pbkdf1( des_key, 8, des_iv, pwd, pwdlen );
- des_setkey_dec( &des_ctx, des_key );
- des_crypt_cbc( &des_ctx, DES_DECRYPT, buflen,
+ mbedtls_des_setkey_dec( &des_ctx, des_key );
+ mbedtls_des_crypt_cbc( &des_ctx, MBEDTLS_DES_DECRYPT, buflen,
des_iv, buf, buf );
- des_free( &des_ctx );
- polarssl_zeroize( des_key, 8 );
+ mbedtls_des_free( &des_ctx );
+ mbedtls_zeroize( des_key, 8 );
}
/*
@@ -161,23 +161,23 @@
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
- des3_context des3_ctx;
+ mbedtls_des3_context des3_ctx;
unsigned char des3_key[24];
- des3_init( &des3_ctx );
+ mbedtls_des3_init( &des3_ctx );
pem_pbkdf1( des3_key, 24, des3_iv, pwd, pwdlen );
- des3_set3key_dec( &des3_ctx, des3_key );
- des3_crypt_cbc( &des3_ctx, DES_DECRYPT, buflen,
+ mbedtls_des3_set3key_dec( &des3_ctx, des3_key );
+ mbedtls_des3_crypt_cbc( &des3_ctx, MBEDTLS_DES_DECRYPT, buflen,
des3_iv, buf, buf );
- des3_free( &des3_ctx );
- polarssl_zeroize( des3_key, 24 );
+ mbedtls_des3_free( &des3_ctx );
+ mbedtls_zeroize( des3_key, 24 );
}
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
/*
* Decrypt with AES-XXX-CBC, using PBKDF1 for key derivation
*/
@@ -185,26 +185,26 @@
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
- aes_context aes_ctx;
+ mbedtls_aes_context aes_ctx;
unsigned char aes_key[32];
- aes_init( &aes_ctx );
+ mbedtls_aes_init( &aes_ctx );
pem_pbkdf1( aes_key, keylen, aes_iv, pwd, pwdlen );
- aes_setkey_dec( &aes_ctx, aes_key, keylen * 8 );
- aes_crypt_cbc( &aes_ctx, AES_DECRYPT, buflen,
+ mbedtls_aes_setkey_dec( &aes_ctx, aes_key, keylen * 8 );
+ mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_DECRYPT, buflen,
aes_iv, buf, buf );
- aes_free( &aes_ctx );
- polarssl_zeroize( aes_key, keylen );
+ mbedtls_aes_free( &aes_ctx );
+ mbedtls_zeroize( aes_key, keylen );
}
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
-#endif /* POLARSSL_MD5_C && POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_DES_C ) */
+#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
-int pem_read_buffer( pem_context *ctx, const char *header, const char *footer,
+int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer,
const unsigned char *data, const unsigned char *pwd,
size_t pwdlen, size_t *use_len )
{
@@ -212,33 +212,33 @@
size_t len;
unsigned char *buf;
const unsigned char *s1, *s2, *end;
-#if defined(POLARSSL_MD5_C) && defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_DES_C) || defined(POLARSSL_AES_C) )
+#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
unsigned char pem_iv[16];
- cipher_type_t enc_alg = POLARSSL_CIPHER_NONE;
+ mbedtls_cipher_type_t enc_alg = MBEDTLS_CIPHER_NONE;
#else
((void) pwd);
((void) pwdlen);
-#endif /* POLARSSL_MD5_C && POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_DES_C ) */
+#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
if( ctx == NULL )
- return( POLARSSL_ERR_PEM_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PEM_BAD_INPUT_DATA );
s1 = (unsigned char *) strstr( (const char *) data, header );
if( s1 == NULL )
- return( POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
+ return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
s2 = (unsigned char *) strstr( (const char *) data, footer );
if( s2 == NULL || s2 <= s1 )
- return( POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
+ return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
s1 += strlen( header );
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
- else return( POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
+ else return( MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT );
end = s2;
end += strlen( footer );
@@ -250,111 +250,111 @@
if( memcmp( s1, "Proc-Type: 4,ENCRYPTED", 22 ) == 0 )
{
-#if defined(POLARSSL_MD5_C) && defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_DES_C) || defined(POLARSSL_AES_C) )
+#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
enc++;
s1 += 22;
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
- else return( POLARSSL_ERR_PEM_INVALID_DATA );
+ else return( MBEDTLS_ERR_PEM_INVALID_DATA );
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
if( memcmp( s1, "DEK-Info: DES-EDE3-CBC,", 23 ) == 0 )
{
- enc_alg = POLARSSL_CIPHER_DES_EDE3_CBC;
+ enc_alg = MBEDTLS_CIPHER_DES_EDE3_CBC;
s1 += 23;
if( pem_get_iv( s1, pem_iv, 8 ) != 0 )
- return( POLARSSL_ERR_PEM_INVALID_ENC_IV );
+ return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 16;
}
else if( memcmp( s1, "DEK-Info: DES-CBC,", 18 ) == 0 )
{
- enc_alg = POLARSSL_CIPHER_DES_CBC;
+ enc_alg = MBEDTLS_CIPHER_DES_CBC;
s1 += 18;
if( pem_get_iv( s1, pem_iv, 8) != 0 )
- return( POLARSSL_ERR_PEM_INVALID_ENC_IV );
+ return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 16;
}
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_AES_C)
if( memcmp( s1, "DEK-Info: AES-", 14 ) == 0 )
{
if( memcmp( s1, "DEK-Info: AES-128-CBC,", 22 ) == 0 )
- enc_alg = POLARSSL_CIPHER_AES_128_CBC;
+ enc_alg = MBEDTLS_CIPHER_AES_128_CBC;
else if( memcmp( s1, "DEK-Info: AES-192-CBC,", 22 ) == 0 )
- enc_alg = POLARSSL_CIPHER_AES_192_CBC;
+ enc_alg = MBEDTLS_CIPHER_AES_192_CBC;
else if( memcmp( s1, "DEK-Info: AES-256-CBC,", 22 ) == 0 )
- enc_alg = POLARSSL_CIPHER_AES_256_CBC;
+ enc_alg = MBEDTLS_CIPHER_AES_256_CBC;
else
- return( POLARSSL_ERR_PEM_UNKNOWN_ENC_ALG );
+ return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
s1 += 22;
if( pem_get_iv( s1, pem_iv, 16 ) != 0 )
- return( POLARSSL_ERR_PEM_INVALID_ENC_IV );
+ return( MBEDTLS_ERR_PEM_INVALID_ENC_IV );
s1 += 32;
}
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
- if( enc_alg == POLARSSL_CIPHER_NONE )
- return( POLARSSL_ERR_PEM_UNKNOWN_ENC_ALG );
+ if( enc_alg == MBEDTLS_CIPHER_NONE )
+ return( MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG );
if( *s1 == '\r' ) s1++;
if( *s1 == '\n' ) s1++;
- else return( POLARSSL_ERR_PEM_INVALID_DATA );
+ else return( MBEDTLS_ERR_PEM_INVALID_DATA );
#else
- return( POLARSSL_ERR_PEM_FEATURE_UNAVAILABLE );
-#endif /* POLARSSL_MD5_C && POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_DES_C ) */
+ return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
+#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
}
len = 0;
- ret = base64_decode( NULL, &len, s1, s2 - s1 );
+ ret = mbedtls_base64_decode( NULL, &len, s1, s2 - s1 );
- if( ret == POLARSSL_ERR_BASE64_INVALID_CHARACTER )
- return( POLARSSL_ERR_PEM_INVALID_DATA + ret );
+ if( ret == MBEDTLS_ERR_BASE64_INVALID_CHARACTER )
+ return( MBEDTLS_ERR_PEM_INVALID_DATA + ret );
- if( ( buf = polarssl_malloc( len ) ) == NULL )
- return( POLARSSL_ERR_PEM_MALLOC_FAILED );
+ if( ( buf = mbedtls_malloc( len ) ) == NULL )
+ return( MBEDTLS_ERR_PEM_MALLOC_FAILED );
- if( ( ret = base64_decode( buf, &len, s1, s2 - s1 ) ) != 0 )
+ if( ( ret = mbedtls_base64_decode( buf, &len, s1, s2 - s1 ) ) != 0 )
{
- polarssl_free( buf );
- return( POLARSSL_ERR_PEM_INVALID_DATA + ret );
+ mbedtls_free( buf );
+ return( MBEDTLS_ERR_PEM_INVALID_DATA + ret );
}
if( enc != 0 )
{
-#if defined(POLARSSL_MD5_C) && defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_DES_C) || defined(POLARSSL_AES_C) )
+#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_DES_C) || defined(MBEDTLS_AES_C) )
if( pwd == NULL )
{
- polarssl_free( buf );
- return( POLARSSL_ERR_PEM_PASSWORD_REQUIRED );
+ mbedtls_free( buf );
+ return( MBEDTLS_ERR_PEM_PASSWORD_REQUIRED );
}
-#if defined(POLARSSL_DES_C)
- if( enc_alg == POLARSSL_CIPHER_DES_EDE3_CBC )
+#if defined(MBEDTLS_DES_C)
+ if( enc_alg == MBEDTLS_CIPHER_DES_EDE3_CBC )
pem_des3_decrypt( pem_iv, buf, len, pwd, pwdlen );
- else if( enc_alg == POLARSSL_CIPHER_DES_CBC )
+ else if( enc_alg == MBEDTLS_CIPHER_DES_CBC )
pem_des_decrypt( pem_iv, buf, len, pwd, pwdlen );
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_AES_C)
- if( enc_alg == POLARSSL_CIPHER_AES_128_CBC )
+#if defined(MBEDTLS_AES_C)
+ if( enc_alg == MBEDTLS_CIPHER_AES_128_CBC )
pem_aes_decrypt( pem_iv, 16, buf, len, pwd, pwdlen );
- else if( enc_alg == POLARSSL_CIPHER_AES_192_CBC )
+ else if( enc_alg == MBEDTLS_CIPHER_AES_192_CBC )
pem_aes_decrypt( pem_iv, 24, buf, len, pwd, pwdlen );
- else if( enc_alg == POLARSSL_CIPHER_AES_256_CBC )
+ else if( enc_alg == MBEDTLS_CIPHER_AES_256_CBC )
pem_aes_decrypt( pem_iv, 32, buf, len, pwd, pwdlen );
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_AES_C */
/*
* The result will be ASN.1 starting with a SEQUENCE tag, with 1 to 3
@@ -364,14 +364,14 @@
*/
if( len <= 2 || buf[0] != 0x30 || buf[1] > 0x83 )
{
- polarssl_free( buf );
- return( POLARSSL_ERR_PEM_PASSWORD_MISMATCH );
+ mbedtls_free( buf );
+ return( MBEDTLS_ERR_PEM_PASSWORD_MISMATCH );
}
#else
- polarssl_free( buf );
- return( POLARSSL_ERR_PEM_FEATURE_UNAVAILABLE );
-#endif /* POLARSSL_MD5_C && POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_DES_C ) */
+ mbedtls_free( buf );
+ return( MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE );
+#endif /* MBEDTLS_MD5_C && MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
}
ctx->buf = buf;
@@ -380,17 +380,17 @@
return( 0 );
}
-void pem_free( pem_context *ctx )
+void mbedtls_pem_free( mbedtls_pem_context *ctx )
{
- polarssl_free( ctx->buf );
- polarssl_free( ctx->info );
+ mbedtls_free( ctx->buf );
+ mbedtls_free( ctx->info );
- polarssl_zeroize( ctx, sizeof( pem_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_pem_context ) );
}
-#endif /* POLARSSL_PEM_PARSE_C */
+#endif /* MBEDTLS_PEM_PARSE_C */
-#if defined(POLARSSL_PEM_WRITE_C)
-int pem_write_buffer( const char *header, const char *footer,
+#if defined(MBEDTLS_PEM_WRITE_C)
+int mbedtls_pem_write_buffer( const char *header, const char *footer,
const unsigned char *der_data, size_t der_len,
unsigned char *buf, size_t buf_len, size_t *olen )
{
@@ -398,22 +398,22 @@
unsigned char *encode_buf, *c, *p = buf;
size_t len = 0, use_len = 0, add_len = 0;
- base64_encode( NULL, &use_len, der_data, der_len );
+ mbedtls_base64_encode( NULL, &use_len, der_data, der_len );
add_len = strlen( header ) + strlen( footer ) + ( use_len / 64 ) + 1;
if( use_len + add_len > buf_len )
{
*olen = use_len + add_len;
- return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
}
- if( ( encode_buf = polarssl_malloc( use_len ) ) == NULL )
- return( POLARSSL_ERR_PEM_MALLOC_FAILED );
+ if( ( encode_buf = mbedtls_malloc( use_len ) ) == NULL )
+ return( MBEDTLS_ERR_PEM_MALLOC_FAILED );
- if( ( ret = base64_encode( encode_buf, &use_len, der_data,
+ if( ( ret = mbedtls_base64_encode( encode_buf, &use_len, der_data,
der_len ) ) != 0 )
{
- polarssl_free( encode_buf );
+ mbedtls_free( encode_buf );
return( ret );
}
@@ -437,8 +437,8 @@
*p++ = '\0';
*olen = p - buf;
- polarssl_free( encode_buf );
+ mbedtls_free( encode_buf );
return( 0 );
}
-#endif /* POLARSSL_PEM_WRITE_C */
-#endif /* POLARSSL_PEM_PARSE_C || POLARSSL_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_PARSE_C || MBEDTLS_PEM_WRITE_C */
diff --git a/library/pk.c b/library/pk.c
index d147302..043f8e3 100644
--- a/library/pk.c
+++ b/library/pk.c
@@ -20,35 +20,35 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PK_C)
+#if defined(MBEDTLS_PK_C)
#include "mbedtls/pk.h"
#include "mbedtls/pk_wrap.h"
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#include "mbedtls/rsa.h"
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#include "mbedtls/ecdsa.h"
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
- * Initialise a pk_context
+ * Initialise a mbedtls_pk_context
*/
-void pk_init( pk_context *ctx )
+void mbedtls_pk_init( mbedtls_pk_context *ctx )
{
if( ctx == NULL )
return;
@@ -58,39 +58,39 @@
}
/*
- * Free (the components of) a pk_context
+ * Free (the components of) a mbedtls_pk_context
*/
-void pk_free( pk_context *ctx )
+void mbedtls_pk_free( mbedtls_pk_context *ctx )
{
if( ctx == NULL || ctx->pk_info == NULL )
return;
ctx->pk_info->ctx_free_func( ctx->pk_ctx );
- polarssl_zeroize( ctx, sizeof( pk_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_pk_context ) );
}
/*
* Get pk_info structure from type
*/
-const pk_info_t * pk_info_from_type( pk_type_t pk_type )
+const mbedtls_pk_info_t * mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type )
{
switch( pk_type ) {
-#if defined(POLARSSL_RSA_C)
- case POLARSSL_PK_RSA:
- return( &rsa_info );
+#if defined(MBEDTLS_RSA_C)
+ case MBEDTLS_PK_RSA:
+ return( &mbedtls_rsa_info );
#endif
-#if defined(POLARSSL_ECP_C)
- case POLARSSL_PK_ECKEY:
- return( &eckey_info );
- case POLARSSL_PK_ECKEY_DH:
- return( &eckeydh_info );
+#if defined(MBEDTLS_ECP_C)
+ case MBEDTLS_PK_ECKEY:
+ return( &mbedtls_eckey_info );
+ case MBEDTLS_PK_ECKEY_DH:
+ return( &mbedtls_eckeydh_info );
#endif
-#if defined(POLARSSL_ECDSA_C)
- case POLARSSL_PK_ECDSA:
- return( &ecdsa_info );
+#if defined(MBEDTLS_ECDSA_C)
+ case MBEDTLS_PK_ECDSA:
+ return( &mbedtls_ecdsa_info );
#endif
- /* POLARSSL_PK_RSA_ALT omitted on purpose */
+ /* MBEDTLS_PK_RSA_ALT omitted on purpose */
default:
return( NULL );
}
@@ -99,40 +99,40 @@
/*
* Initialise context
*/
-int pk_init_ctx( pk_context *ctx, const pk_info_t *info )
+int mbedtls_pk_init_ctx( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
{
if( ctx == NULL || info == NULL || ctx->pk_info != NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
- return( POLARSSL_ERR_PK_MALLOC_FAILED );
+ return( MBEDTLS_ERR_PK_MALLOC_FAILED );
ctx->pk_info = info;
return( 0 );
}
-#if defined(POLARSSL_PK_RSA_ALT_SUPPORT)
+#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
/*
* Initialize an RSA-alt context
*/
-int pk_init_ctx_rsa_alt( pk_context *ctx, void * key,
- pk_rsa_alt_decrypt_func decrypt_func,
- pk_rsa_alt_sign_func sign_func,
- pk_rsa_alt_key_len_func key_len_func )
+int mbedtls_pk_init_ctx_rsa_alt( mbedtls_pk_context *ctx, void * key,
+ mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
+ mbedtls_pk_rsa_alt_sign_func sign_func,
+ mbedtls_pk_rsa_alt_key_len_func key_len_func )
{
- rsa_alt_context *rsa_alt;
- const pk_info_t *info = &rsa_alt_info;
+ mbedtls_rsa_alt_context *rsa_alt;
+ const mbedtls_pk_info_t *info = &mbedtls_rsa_alt_info;
if( ctx == NULL || ctx->pk_info != NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
- return( POLARSSL_ERR_PK_MALLOC_FAILED );
+ return( MBEDTLS_ERR_PK_MALLOC_FAILED );
ctx->pk_info = info;
- rsa_alt = (rsa_alt_context *) ctx->pk_ctx;
+ rsa_alt = (mbedtls_rsa_alt_context *) ctx->pk_ctx;
rsa_alt->key = key;
rsa_alt->decrypt_func = decrypt_func;
@@ -141,12 +141,12 @@
return( 0 );
}
-#endif /* POLARSSL_PK_RSA_ALT_SUPPORT */
+#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
/*
* Tell if a PK can do the operations of the given type
*/
-int pk_can_do( const pk_context *ctx, pk_type_t type )
+int mbedtls_pk_can_do( const mbedtls_pk_context *ctx, mbedtls_pk_type_t type )
{
/* null or NONE context can't do anything */
if( ctx == NULL || ctx->pk_info == NULL )
@@ -156,35 +156,35 @@
}
/*
- * Helper for pk_sign and pk_verify
+ * Helper for mbedtls_pk_sign and mbedtls_pk_verify
*/
-static inline int pk_hashlen_helper( md_type_t md_alg, size_t *hash_len )
+static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
{
- const md_info_t *md_info;
+ const mbedtls_md_info_t *md_info;
if( *hash_len != 0 )
return( 0 );
- if( ( md_info = md_info_from_type( md_alg ) ) == NULL )
+ if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
return( -1 );
- *hash_len = md_get_size( md_info );
+ *hash_len = mbedtls_md_get_size( md_info );
return( 0 );
}
/*
* Verify a signature
*/
-int pk_verify( pk_context *ctx, md_type_t md_alg,
+int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL ||
pk_hashlen_helper( md_alg, &hash_len ) != 0 )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->verify_func == NULL )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->verify_func( ctx->pk_ctx, md_alg, hash, hash_len,
sig, sig_len ) );
@@ -193,33 +193,33 @@
/*
* Verify a signature with options
*/
-int pk_verify_ext( pk_type_t type, const void *options,
- pk_context *ctx, md_type_t md_alg,
+int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
+ mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
- if( ! pk_can_do( ctx, type ) )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ if( ! mbedtls_pk_can_do( ctx, type ) )
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
- if( type == POLARSSL_PK_RSASSA_PSS )
+ if( type == MBEDTLS_PK_RSASSA_PSS )
{
-#if defined(POLARSSL_RSA_C) && defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21)
int ret;
- const pk_rsassa_pss_options *pss_opts;
+ const mbedtls_pk_rsassa_pss_options *pss_opts;
if( options == NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
- pss_opts = (const pk_rsassa_pss_options *) options;
+ pss_opts = (const mbedtls_pk_rsassa_pss_options *) options;
- if( sig_len < pk_get_len( ctx ) )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( sig_len < mbedtls_pk_get_len( ctx ) )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
- ret = rsa_rsassa_pss_verify_ext( pk_rsa( *ctx ),
- NULL, NULL, RSA_PUBLIC,
+ ret = mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_pk_rsa( *ctx ),
+ NULL, NULL, MBEDTLS_RSA_PUBLIC,
md_alg, (unsigned int) hash_len, hash,
pss_opts->mgf1_hash_id,
pss_opts->expected_salt_len,
@@ -227,36 +227,36 @@
if( ret != 0 )
return( ret );
- if( sig_len > pk_get_len( ctx ) )
- return( POLARSSL_ERR_PK_SIG_LEN_MISMATCH );
+ if( sig_len > mbedtls_pk_get_len( ctx ) )
+ return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
return( 0 );
#else
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
#endif
}
/* General case: no options */
if( options != NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
- return( pk_verify( ctx, md_alg, hash, hash_len, sig, sig_len ) );
+ return( mbedtls_pk_verify( ctx, md_alg, hash, hash_len, sig, sig_len ) );
}
/*
* Make a signature
*/
-int pk_sign( pk_context *ctx, md_type_t md_alg,
+int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL ||
pk_hashlen_helper( md_alg, &hash_len ) != 0 )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->sign_func == NULL )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->sign_func( ctx->pk_ctx, md_alg, hash, hash_len,
sig, sig_len, f_rng, p_rng ) );
@@ -265,16 +265,16 @@
/*
* Decrypt message
*/
-int pk_decrypt( pk_context *ctx,
+int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->decrypt_func == NULL )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->decrypt_func( ctx->pk_ctx, input, ilen,
output, olen, osize, f_rng, p_rng ) );
@@ -283,16 +283,16 @@
/*
* Encrypt message
*/
-int pk_encrypt( pk_context *ctx,
+int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->encrypt_func == NULL )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
return( ctx->pk_info->encrypt_func( ctx->pk_ctx, input, ilen,
output, olen, osize, f_rng, p_rng ) );
@@ -301,24 +301,24 @@
/*
* Check public-private key pair
*/
-int pk_check_pair( const pk_context *pub, const pk_context *prv )
+int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv )
{
if( pub == NULL || pub->pk_info == NULL ||
prv == NULL || prv->pk_info == NULL ||
prv->pk_info->check_pair_func == NULL )
{
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
}
- if( prv->pk_info->type == POLARSSL_PK_RSA_ALT )
+ if( prv->pk_info->type == MBEDTLS_PK_RSA_ALT )
{
- if( pub->pk_info->type != POLARSSL_PK_RSA )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ if( pub->pk_info->type != MBEDTLS_PK_RSA )
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
}
else
{
if( pub->pk_info != prv->pk_info )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
}
return( prv->pk_info->check_pair_func( pub->pk_ctx, prv->pk_ctx ) );
@@ -327,7 +327,7 @@
/*
* Get key size in bits
*/
-size_t pk_get_size( const pk_context *ctx )
+size_t mbedtls_pk_get_size( const mbedtls_pk_context *ctx )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( 0 );
@@ -338,13 +338,13 @@
/*
* Export debug information
*/
-int pk_debug( const pk_context *ctx, pk_debug_item *items )
+int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items )
{
if( ctx == NULL || ctx->pk_info == NULL )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->debug_func == NULL )
- return( POLARSSL_ERR_PK_TYPE_MISMATCH );
+ return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
ctx->pk_info->debug_func( ctx->pk_ctx, items );
return( 0 );
@@ -353,7 +353,7 @@
/*
* Access the PK type name
*/
-const char *pk_get_name( const pk_context *ctx )
+const char *mbedtls_pk_get_name( const mbedtls_pk_context *ctx )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( "invalid PK" );
@@ -364,12 +364,12 @@
/*
* Access the PK type
*/
-pk_type_t pk_get_type( const pk_context *ctx )
+mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx )
{
if( ctx == NULL || ctx->pk_info == NULL )
- return( POLARSSL_PK_NONE );
+ return( MBEDTLS_PK_NONE );
return( ctx->pk_info->type );
}
-#endif /* POLARSSL_PK_C */
+#endif /* MBEDTLS_PK_C */
diff --git a/library/pk_wrap.c b/library/pk_wrap.c
index 994320f..b1ed2c5 100644
--- a/library/pk_wrap.c
+++ b/library/pk_wrap.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PK_C)
+#if defined(MBEDTLS_PK_C)
#include "mbedtls/pk_wrap.h"
/* Even if RSA not activated, for the sake of RSA-alt */
@@ -34,69 +34,69 @@
#include <string.h>
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#include "mbedtls/ecdsa.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-#if defined(POLARSSL_PK_RSA_ALT_SUPPORT)
+#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
#endif
-#if defined(POLARSSL_RSA_C)
-static int rsa_can_do( pk_type_t type )
+#if defined(MBEDTLS_RSA_C)
+static int rsa_can_do( mbedtls_pk_type_t type )
{
- return( type == POLARSSL_PK_RSA ||
- type == POLARSSL_PK_RSASSA_PSS );
+ return( type == MBEDTLS_PK_RSA ||
+ type == MBEDTLS_PK_RSASSA_PSS );
}
static size_t rsa_get_size( const void *ctx )
{
- return( 8 * ((const rsa_context *) ctx)->len );
+ return( 8 * ((const mbedtls_rsa_context *) ctx)->len );
}
-static int rsa_verify_wrap( void *ctx, md_type_t md_alg,
+static int rsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
int ret;
- if( sig_len < ((rsa_context *) ctx)->len )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( sig_len < ((mbedtls_rsa_context *) ctx)->len )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
- if( ( ret = rsa_pkcs1_verify( (rsa_context *) ctx, NULL, NULL,
- RSA_PUBLIC, md_alg,
+ if( ( ret = mbedtls_rsa_pkcs1_verify( (mbedtls_rsa_context *) ctx, NULL, NULL,
+ MBEDTLS_RSA_PUBLIC, md_alg,
(unsigned int) hash_len, hash, sig ) ) != 0 )
return( ret );
- if( sig_len > ((rsa_context *) ctx)->len )
- return( POLARSSL_ERR_PK_SIG_LEN_MISMATCH );
+ if( sig_len > ((mbedtls_rsa_context *) ctx)->len )
+ return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
return( 0 );
}
-static int rsa_sign_wrap( void *ctx, md_type_t md_alg,
+static int rsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- *sig_len = ((rsa_context *) ctx)->len;
+ *sig_len = ((mbedtls_rsa_context *) ctx)->len;
- return( rsa_pkcs1_sign( (rsa_context *) ctx, f_rng, p_rng, RSA_PRIVATE,
+ return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, f_rng, p_rng, MBEDTLS_RSA_PRIVATE,
md_alg, (unsigned int) hash_len, hash, sig ) );
}
@@ -105,11 +105,11 @@
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- if( ilen != ((rsa_context *) ctx)->len )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( ilen != ((mbedtls_rsa_context *) ctx)->len )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- return( rsa_pkcs1_decrypt( (rsa_context *) ctx, f_rng, p_rng,
- RSA_PRIVATE, olen, input, output, osize ) );
+ return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx, f_rng, p_rng,
+ MBEDTLS_RSA_PRIVATE, olen, input, output, osize ) );
}
static int rsa_encrypt_wrap( void *ctx,
@@ -117,52 +117,52 @@
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- *olen = ((rsa_context *) ctx)->len;
+ *olen = ((mbedtls_rsa_context *) ctx)->len;
if( *olen > osize )
- return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
+ return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
- return( rsa_pkcs1_encrypt( (rsa_context *) ctx,
- f_rng, p_rng, RSA_PUBLIC, ilen, input, output ) );
+ return( mbedtls_rsa_pkcs1_encrypt( (mbedtls_rsa_context *) ctx,
+ f_rng, p_rng, MBEDTLS_RSA_PUBLIC, ilen, input, output ) );
}
static int rsa_check_pair_wrap( const void *pub, const void *prv )
{
- return( rsa_check_pub_priv( (const rsa_context *) pub,
- (const rsa_context *) prv ) );
+ return( mbedtls_rsa_check_pub_priv( (const mbedtls_rsa_context *) pub,
+ (const mbedtls_rsa_context *) prv ) );
}
static void *rsa_alloc_wrap( void )
{
- void *ctx = polarssl_malloc( sizeof( rsa_context ) );
+ void *ctx = mbedtls_malloc( sizeof( mbedtls_rsa_context ) );
if( ctx != NULL )
- rsa_init( (rsa_context *) ctx, 0, 0 );
+ mbedtls_rsa_init( (mbedtls_rsa_context *) ctx, 0, 0 );
return( ctx );
}
static void rsa_free_wrap( void *ctx )
{
- rsa_free( (rsa_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_rsa_free( (mbedtls_rsa_context *) ctx );
+ mbedtls_free( ctx );
}
-static void rsa_debug( const void *ctx, pk_debug_item *items )
+static void rsa_debug( const void *ctx, mbedtls_pk_debug_item *items )
{
- items->type = POLARSSL_PK_DEBUG_MPI;
+ items->type = MBEDTLS_PK_DEBUG_MPI;
items->name = "rsa.N";
- items->value = &( ((rsa_context *) ctx)->N );
+ items->value = &( ((mbedtls_rsa_context *) ctx)->N );
items++;
- items->type = POLARSSL_PK_DEBUG_MPI;
+ items->type = MBEDTLS_PK_DEBUG_MPI;
items->name = "rsa.E";
- items->value = &( ((rsa_context *) ctx)->E );
+ items->value = &( ((mbedtls_rsa_context *) ctx)->E );
}
-const pk_info_t rsa_info = {
- POLARSSL_PK_RSA,
+const mbedtls_pk_info_t mbedtls_rsa_info = {
+ MBEDTLS_PK_RSA,
"RSA",
rsa_get_size,
rsa_can_do,
@@ -175,108 +175,108 @@
rsa_free_wrap,
rsa_debug,
};
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
/*
* Generic EC key
*/
-static int eckey_can_do( pk_type_t type )
+static int eckey_can_do( mbedtls_pk_type_t type )
{
- return( type == POLARSSL_PK_ECKEY ||
- type == POLARSSL_PK_ECKEY_DH ||
- type == POLARSSL_PK_ECDSA );
+ return( type == MBEDTLS_PK_ECKEY ||
+ type == MBEDTLS_PK_ECKEY_DH ||
+ type == MBEDTLS_PK_ECDSA );
}
static size_t eckey_get_size( const void *ctx )
{
- return( ((ecp_keypair *) ctx)->grp.pbits );
+ return( ((mbedtls_ecp_keypair *) ctx)->grp.pbits );
}
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
/* Forward declarations */
-static int ecdsa_verify_wrap( void *ctx, md_type_t md_alg,
+static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len );
-static int ecdsa_sign_wrap( void *ctx, md_type_t md_alg,
+static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
-static int eckey_verify_wrap( void *ctx, md_type_t md_alg,
+static int eckey_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
int ret;
- ecdsa_context ecdsa;
+ mbedtls_ecdsa_context ecdsa;
- ecdsa_init( &ecdsa );
+ mbedtls_ecdsa_init( &ecdsa );
- if( ( ret = ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
+ if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
ret = ecdsa_verify_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len );
- ecdsa_free( &ecdsa );
+ mbedtls_ecdsa_free( &ecdsa );
return( ret );
}
-static int eckey_sign_wrap( void *ctx, md_type_t md_alg,
+static int eckey_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret;
- ecdsa_context ecdsa;
+ mbedtls_ecdsa_context ecdsa;
- ecdsa_init( &ecdsa );
+ mbedtls_ecdsa_init( &ecdsa );
- if( ( ret = ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
+ if( ( ret = mbedtls_ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 )
ret = ecdsa_sign_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len,
f_rng, p_rng );
- ecdsa_free( &ecdsa );
+ mbedtls_ecdsa_free( &ecdsa );
return( ret );
}
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
static int eckey_check_pair( const void *pub, const void *prv )
{
- return( ecp_check_pub_priv( (const ecp_keypair *) pub,
- (const ecp_keypair *) prv ) );
+ return( mbedtls_ecp_check_pub_priv( (const mbedtls_ecp_keypair *) pub,
+ (const mbedtls_ecp_keypair *) prv ) );
}
static void *eckey_alloc_wrap( void )
{
- void *ctx = polarssl_malloc( sizeof( ecp_keypair ) );
+ void *ctx = mbedtls_malloc( sizeof( mbedtls_ecp_keypair ) );
if( ctx != NULL )
- ecp_keypair_init( ctx );
+ mbedtls_ecp_keypair_init( ctx );
return( ctx );
}
static void eckey_free_wrap( void *ctx )
{
- ecp_keypair_free( (ecp_keypair *) ctx );
- polarssl_free( ctx );
+ mbedtls_ecp_keypair_free( (mbedtls_ecp_keypair *) ctx );
+ mbedtls_free( ctx );
}
-static void eckey_debug( const void *ctx, pk_debug_item *items )
+static void eckey_debug( const void *ctx, mbedtls_pk_debug_item *items )
{
- items->type = POLARSSL_PK_DEBUG_ECP;
+ items->type = MBEDTLS_PK_DEBUG_ECP;
items->name = "eckey.Q";
- items->value = &( ((ecp_keypair *) ctx)->Q );
+ items->value = &( ((mbedtls_ecp_keypair *) ctx)->Q );
}
-const pk_info_t eckey_info = {
- POLARSSL_PK_ECKEY,
+const mbedtls_pk_info_t mbedtls_eckey_info = {
+ MBEDTLS_PK_ECKEY,
"EC",
eckey_get_size,
eckey_can_do,
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
eckey_verify_wrap,
eckey_sign_wrap,
#else
@@ -294,14 +294,14 @@
/*
* EC key restricted to ECDH
*/
-static int eckeydh_can_do( pk_type_t type )
+static int eckeydh_can_do( mbedtls_pk_type_t type )
{
- return( type == POLARSSL_PK_ECKEY ||
- type == POLARSSL_PK_ECKEY_DH );
+ return( type == MBEDTLS_PK_ECKEY ||
+ type == MBEDTLS_PK_ECKEY_DH );
}
-const pk_info_t eckeydh_info = {
- POLARSSL_PK_ECKEY_DH,
+const mbedtls_pk_info_t mbedtls_eckeydh_info = {
+ MBEDTLS_PK_ECKEY_DH,
"EC_DH",
eckey_get_size, /* Same underlying key structure */
eckeydh_can_do,
@@ -314,57 +314,57 @@
eckey_free_wrap, /* Same underlying key structure */
eckey_debug, /* Same underlying key structure */
};
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
-#if defined(POLARSSL_ECDSA_C)
-static int ecdsa_can_do( pk_type_t type )
+#if defined(MBEDTLS_ECDSA_C)
+static int ecdsa_can_do( mbedtls_pk_type_t type )
{
- return( type == POLARSSL_PK_ECDSA );
+ return( type == MBEDTLS_PK_ECDSA );
}
-static int ecdsa_verify_wrap( void *ctx, md_type_t md_alg,
+static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
int ret;
((void) md_alg);
- ret = ecdsa_read_signature( (ecdsa_context *) ctx,
+ ret = mbedtls_ecdsa_read_signature( (mbedtls_ecdsa_context *) ctx,
hash, hash_len, sig, sig_len );
- if( ret == POLARSSL_ERR_ECP_SIG_LEN_MISMATCH )
- return( POLARSSL_ERR_PK_SIG_LEN_MISMATCH );
+ if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
+ return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
return( ret );
}
-static int ecdsa_sign_wrap( void *ctx, md_type_t md_alg,
+static int ecdsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- return( ecdsa_write_signature( (ecdsa_context *) ctx,
+ return( mbedtls_ecdsa_write_signature( (mbedtls_ecdsa_context *) ctx,
md_alg, hash, hash_len, sig, sig_len, f_rng, p_rng ) );
}
static void *ecdsa_alloc_wrap( void )
{
- void *ctx = polarssl_malloc( sizeof( ecdsa_context ) );
+ void *ctx = mbedtls_malloc( sizeof( mbedtls_ecdsa_context ) );
if( ctx != NULL )
- ecdsa_init( (ecdsa_context *) ctx );
+ mbedtls_ecdsa_init( (mbedtls_ecdsa_context *) ctx );
return( ctx );
}
static void ecdsa_free_wrap( void *ctx )
{
- ecdsa_free( (ecdsa_context *) ctx );
- polarssl_free( ctx );
+ mbedtls_ecdsa_free( (mbedtls_ecdsa_context *) ctx );
+ mbedtls_free( ctx );
}
-const pk_info_t ecdsa_info = {
- POLARSSL_PK_ECDSA,
+const mbedtls_pk_info_t mbedtls_ecdsa_info = {
+ MBEDTLS_PK_ECDSA,
"ECDSA",
eckey_get_size, /* Compatible key structures */
ecdsa_can_do,
@@ -377,35 +377,35 @@
ecdsa_free_wrap,
eckey_debug, /* Compatible key structures */
};
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_PK_RSA_ALT_SUPPORT)
+#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
/*
* Support for alternative RSA-private implementations
*/
-static int rsa_alt_can_do( pk_type_t type )
+static int rsa_alt_can_do( mbedtls_pk_type_t type )
{
- return( type == POLARSSL_PK_RSA );
+ return( type == MBEDTLS_PK_RSA );
}
static size_t rsa_alt_get_size( const void *ctx )
{
- const rsa_alt_context *rsa_alt = (const rsa_alt_context *) ctx;
+ const mbedtls_rsa_alt_context *rsa_alt = (const mbedtls_rsa_alt_context *) ctx;
return( 8 * rsa_alt->key_len_func( rsa_alt->key ) );
}
-static int rsa_alt_sign_wrap( void *ctx, md_type_t md_alg,
+static int rsa_alt_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- rsa_alt_context *rsa_alt = (rsa_alt_context *) ctx;
+ mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
*sig_len = rsa_alt->key_len_func( rsa_alt->key );
- return( rsa_alt->sign_func( rsa_alt->key, f_rng, p_rng, RSA_PRIVATE,
+ return( rsa_alt->sign_func( rsa_alt->key, f_rng, p_rng, MBEDTLS_RSA_PRIVATE,
md_alg, (unsigned int) hash_len, hash, sig ) );
}
@@ -414,66 +414,66 @@
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
- rsa_alt_context *rsa_alt = (rsa_alt_context *) ctx;
+ mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_context *) ctx;
((void) f_rng);
((void) p_rng);
if( ilen != rsa_alt->key_len_func( rsa_alt->key ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
return( rsa_alt->decrypt_func( rsa_alt->key,
- RSA_PRIVATE, olen, input, output, osize ) );
+ MBEDTLS_RSA_PRIVATE, olen, input, output, osize ) );
}
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
static int rsa_alt_check_pair( const void *pub, const void *prv )
{
- unsigned char sig[POLARSSL_MPI_MAX_SIZE];
+ unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
unsigned char hash[32];
size_t sig_len = 0;
int ret;
if( rsa_alt_get_size( prv ) != rsa_get_size( pub ) )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
memset( hash, 0x2a, sizeof( hash ) );
- if( ( ret = rsa_alt_sign_wrap( (void *) prv, POLARSSL_MD_NONE,
+ if( ( ret = rsa_alt_sign_wrap( (void *) prv, MBEDTLS_MD_NONE,
hash, sizeof( hash ),
sig, &sig_len, NULL, NULL ) ) != 0 )
{
return( ret );
}
- if( rsa_verify_wrap( (void *) pub, POLARSSL_MD_NONE,
+ if( rsa_verify_wrap( (void *) pub, MBEDTLS_MD_NONE,
hash, sizeof( hash ), sig, sig_len ) != 0 )
{
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
}
return( 0 );
}
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
static void *rsa_alt_alloc_wrap( void )
{
- void *ctx = polarssl_malloc( sizeof( rsa_alt_context ) );
+ void *ctx = mbedtls_malloc( sizeof( mbedtls_rsa_alt_context ) );
if( ctx != NULL )
- memset( ctx, 0, sizeof( rsa_alt_context ) );
+ memset( ctx, 0, sizeof( mbedtls_rsa_alt_context ) );
return( ctx );
}
static void rsa_alt_free_wrap( void *ctx )
{
- polarssl_zeroize( ctx, sizeof( rsa_alt_context ) );
- polarssl_free( ctx );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_rsa_alt_context ) );
+ mbedtls_free( ctx );
}
-const pk_info_t rsa_alt_info = {
- POLARSSL_PK_RSA_ALT,
+const mbedtls_pk_info_t mbedtls_rsa_alt_info = {
+ MBEDTLS_PK_RSA_ALT,
"RSA-alt",
rsa_alt_get_size,
rsa_alt_can_do,
@@ -481,7 +481,7 @@
rsa_alt_sign_wrap,
rsa_alt_decrypt_wrap,
NULL,
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
rsa_alt_check_pair,
#else
NULL,
@@ -491,6 +491,6 @@
NULL,
};
-#endif /* POLARSSL_PK_RSA_ALT_SUPPORT */
+#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
-#endif /* POLARSSL_PK_C */
+#endif /* MBEDTLS_PK_C */
diff --git a/library/pkcs11.c b/library/pkcs11.c
index 3943541..fff1d1e 100644
--- a/library/pkcs11.c
+++ b/library/pkcs11.c
@@ -26,21 +26,21 @@
#include "mbedtls/pkcs11.h"
-#if defined(POLARSSL_PKCS11_C)
+#if defined(MBEDTLS_PKCS11_C)
#include "mbedtls/md.h"
#include "mbedtls/oid.h"
#include "mbedtls/x509_crt.h"
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-int pkcs11_x509_cert_init( x509_crt *cert, pkcs11h_certificate_t pkcs11_cert )
+int mbedtls_pkcs11_x509_cert_init( mbedtls_x509_crt *cert, pkcs11h_certificate_t pkcs11_cert )
{
int ret = 1;
unsigned char *cert_blob = NULL;
@@ -59,7 +59,7 @@
goto cleanup;
}
- cert_blob = polarssl_malloc( cert_blob_size );
+ cert_blob = mbedtls_malloc( cert_blob_size );
if( NULL == cert_blob )
{
ret = 4;
@@ -73,7 +73,7 @@
goto cleanup;
}
- if( 0 != x509_crt_parse( cert, cert_blob, cert_blob_size ) )
+ if( 0 != mbedtls_x509_crt_parse( cert, cert_blob, cert_blob_size ) )
{
ret = 6;
goto cleanup;
@@ -83,44 +83,44 @@
cleanup:
if( NULL != cert_blob )
- polarssl_free( cert_blob );
+ mbedtls_free( cert_blob );
return( ret );
}
-int pkcs11_priv_key_init( pkcs11_context *priv_key,
+int mbedtls_pkcs11_priv_key_init( mbedtls_pkcs11_context *priv_key,
pkcs11h_certificate_t pkcs11_cert )
{
int ret = 1;
- x509_crt cert;
+ mbedtls_x509_crt cert;
- x509_crt_init( &cert );
+ mbedtls_x509_crt_init( &cert );
if( priv_key == NULL )
goto cleanup;
- if( 0 != pkcs11_x509_cert_init( &cert, pkcs11_cert ) )
+ if( 0 != mbedtls_pkcs11_x509_cert_init( &cert, pkcs11_cert ) )
goto cleanup;
- priv_key->len = pk_get_len( &cert.pk );
+ priv_key->len = mbedtls_pk_get_len( &cert.pk );
priv_key->pkcs11h_cert = pkcs11_cert;
ret = 0;
cleanup:
- x509_crt_free( &cert );
+ mbedtls_x509_crt_free( &cert );
return( ret );
}
-void pkcs11_priv_key_free( pkcs11_context *priv_key )
+void mbedtls_pkcs11_priv_key_free( mbedtls_pkcs11_context *priv_key )
{
if( NULL != priv_key )
pkcs11h_certificate_freeCertificate( priv_key->pkcs11h_cert );
}
-int pkcs11_decrypt( pkcs11_context *ctx,
+int mbedtls_pkcs11_decrypt( mbedtls_pkcs11_context *ctx,
int mode, size_t *olen,
const unsigned char *input,
unsigned char *output,
@@ -129,38 +129,38 @@
size_t input_len, output_len;
if( NULL == ctx )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- if( RSA_PRIVATE != mode )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( MBEDTLS_RSA_PRIVATE != mode )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
output_len = input_len = ctx->len;
if( input_len < 16 || input_len > output_max_len )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
/* Determine size of output buffer */
if( pkcs11h_certificate_decryptAny( ctx->pkcs11h_cert, CKM_RSA_PKCS, input,
input_len, NULL, &output_len ) != CKR_OK )
{
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
if( output_len > output_max_len )
- return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
+ return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
if( pkcs11h_certificate_decryptAny( ctx->pkcs11h_cert, CKM_RSA_PKCS, input,
input_len, output, &output_len ) != CKR_OK )
{
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
*olen = output_len;
return( 0 );
}
-int pkcs11_sign( pkcs11_context *ctx,
+int mbedtls_pkcs11_sign( mbedtls_pkcs11_context *ctx,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
@@ -170,21 +170,21 @@
const char *oid;
if( NULL == ctx )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- if( RSA_PRIVATE != mode )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( MBEDTLS_RSA_PRIVATE != mode )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- if( md_alg != POLARSSL_MD_NONE )
+ if( md_alg != MBEDTLS_MD_NONE )
{
- const md_info_t *md_info = md_info_from_type( md_alg );
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- if( oid_get_oid_by_md( md_alg, &oid, &oid_size ) != 0 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mbedtls_oid_get_oid_by_md( md_alg, &oid, &oid_size ) != 0 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- hashlen = md_get_size( md_info );
+ hashlen = mbedtls_md_get_size( md_info );
asn_len = 10 + oid_size;
}
@@ -192,10 +192,10 @@
if( hashlen > sig_len || asn_len > sig_len ||
hashlen + asn_len > sig_len )
{
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
- if( md_alg != POLARSSL_MD_NONE )
+ if( md_alg != MBEDTLS_MD_NONE )
{
/*
* DigestInfo ::= SEQUENCE {
@@ -206,17 +206,17 @@
*
* Digest ::= OCTET STRING
*/
- *p++ = ASN1_SEQUENCE | ASN1_CONSTRUCTED;
+ *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
*p++ = (unsigned char) ( 0x08 + oid_size + hashlen );
- *p++ = ASN1_SEQUENCE | ASN1_CONSTRUCTED;
+ *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
*p++ = (unsigned char) ( 0x04 + oid_size );
- *p++ = ASN1_OID;
+ *p++ = MBEDTLS_ASN1_OID;
*p++ = oid_size & 0xFF;
memcpy( p, oid, oid_size );
p += oid_size;
- *p++ = ASN1_NULL;
+ *p++ = MBEDTLS_ASN1_NULL;
*p++ = 0x00;
- *p++ = ASN1_OCTET_STRING;
+ *p++ = MBEDTLS_ASN1_OCTET_STRING;
*p++ = hashlen;
}
@@ -225,10 +225,10 @@
if( pkcs11h_certificate_signAny( ctx->pkcs11h_cert, CKM_RSA_PKCS, sig,
asn_len + hashlen, sig, &sig_len ) != CKR_OK )
{
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
return( 0 );
}
-#endif /* defined(POLARSSL_PKCS11_C) */
+#endif /* defined(MBEDTLS_PKCS11_C) */
diff --git a/library/pkcs12.c b/library/pkcs12.c
index 0a25edd..e3ca995 100644
--- a/library/pkcs12.c
+++ b/library/pkcs12.c
@@ -26,13 +26,13 @@
* ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-12/pkcs-12v1-1.asn
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PKCS12_C)
+#if defined(MBEDTLS_PKCS12_C)
#include "mbedtls/pkcs12.h"
#include "mbedtls/asn1.h"
@@ -40,21 +40,21 @@
#include <string.h>
-#if defined(POLARSSL_ARC4_C)
+#if defined(MBEDTLS_ARC4_C)
#include "mbedtls/arc4.h"
#endif
-#if defined(POLARSSL_DES_C)
+#if defined(MBEDTLS_DES_C)
#include "mbedtls/des.h"
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-static int pkcs12_parse_pbe_params( asn1_buf *params,
- asn1_buf *salt, int *iterations )
+static int pkcs12_parse_pbe_params( mbedtls_asn1_buf *params,
+ mbedtls_asn1_buf *salt, int *iterations )
{
int ret;
unsigned char **p = ¶ms->p;
@@ -67,37 +67,37 @@
* }
*
*/
- if( params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
- if( ( ret = asn1_get_tag( p, end, &salt->len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &salt->len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_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( ( ret = mbedtls_asn1_get_int( p, end, iterations ) ) != 0 )
+ return( MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT + ret );
if( *p != end )
- return( POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-static int pkcs12_pbe_derive_key_iv( asn1_buf *pbe_params, md_type_t md_type,
+static int pkcs12_pbe_derive_key_iv( mbedtls_asn1_buf *pbe_params, mbedtls_md_type_t md_type,
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;
+ mbedtls_asn1_buf salt;
size_t i;
unsigned char unipwd[258];
- memset( &salt, 0, sizeof(asn1_buf) );
+ memset( &salt, 0, sizeof(mbedtls_asn1_buf) );
memset( &unipwd, 0, sizeof(unipwd) );
if( ( ret = pkcs12_parse_pbe_params( pbe_params, &salt,
@@ -107,9 +107,9 @@
for( i = 0; i < pwdlen; i++ )
unipwd[i * 2 + 1] = pwd[i];
- if( ( ret = pkcs12_derivation( key, keylen, unipwd, pwdlen * 2 + 2,
+ if( ( ret = mbedtls_pkcs12_derivation( key, keylen, unipwd, pwdlen * 2 + 2,
salt.p, salt.len, md_type,
- PKCS12_DERIVE_KEY, iterations ) ) != 0 )
+ MBEDTLS_PKCS12_DERIVE_KEY, iterations ) ) != 0 )
{
return( ret );
}
@@ -117,21 +117,21 @@
if( iv == NULL || ivlen == 0 )
return( 0 );
- if( ( ret = pkcs12_derivation( iv, ivlen, unipwd, pwdlen * 2 + 2,
+ if( ( ret = mbedtls_pkcs12_derivation( iv, ivlen, unipwd, pwdlen * 2 + 2,
salt.p, salt.len, md_type,
- PKCS12_DERIVE_IV, iterations ) ) != 0 )
+ MBEDTLS_PKCS12_DERIVE_IV, iterations ) ) != 0 )
{
return( ret );
}
return( 0 );
}
-int pkcs12_pbe_sha1_rc4_128( asn1_buf *pbe_params, int mode,
+int mbedtls_pkcs12_pbe_sha1_rc4_128( mbedtls_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)
+#if !defined(MBEDTLS_ARC4_C)
((void) pbe_params);
((void) mode);
((void) pwd);
@@ -139,36 +139,36 @@
((void) data);
((void) len);
((void) output);
- return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE );
#else
int ret;
unsigned char key[16];
- arc4_context ctx;
+ mbedtls_arc4_context ctx;
((void) mode);
- arc4_init( &ctx );
+ mbedtls_arc4_init( &ctx );
- if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, POLARSSL_MD_SHA1,
+ if( ( ret = pkcs12_pbe_derive_key_iv( pbe_params, MBEDTLS_MD_SHA1,
pwd, pwdlen,
key, 16, NULL, 0 ) ) != 0 )
{
return( ret );
}
- arc4_setup( &ctx, key, 16 );
- if( ( ret = arc4_crypt( &ctx, len, data, output ) ) != 0 )
+ mbedtls_arc4_setup( &ctx, key, 16 );
+ if( ( ret = mbedtls_arc4_crypt( &ctx, len, data, output ) ) != 0 )
goto exit;
exit:
- polarssl_zeroize( key, sizeof( key ) );
- arc4_free( &ctx );
+ mbedtls_zeroize( key, sizeof( key ) );
+ mbedtls_arc4_free( &ctx );
return( ret );
-#endif /* POLARSSL_ARC4_C */
+#endif /* MBEDTLS_ARC4_C */
}
-int pkcs12_pbe( asn1_buf *pbe_params, int mode,
- cipher_type_t cipher_type, md_type_t md_type,
+int mbedtls_pkcs12_pbe( mbedtls_asn1_buf *pbe_params, int mode,
+ mbedtls_cipher_type_t cipher_type, mbedtls_md_type_t md_type,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t len,
unsigned char *output )
@@ -176,13 +176,13 @@
int ret, keylen = 0;
unsigned char key[32];
unsigned char iv[16];
- const cipher_info_t *cipher_info;
- cipher_context_t cipher_ctx;
+ const mbedtls_cipher_info_t *cipher_info;
+ mbedtls_cipher_context_t cipher_ctx;
size_t olen = 0;
- cipher_info = cipher_info_from_type( cipher_type );
+ cipher_info = mbedtls_cipher_info_from_type( cipher_type );
if( cipher_info == NULL )
- return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE );
keylen = cipher_info->key_length / 8;
@@ -193,33 +193,33 @@
return( ret );
}
- cipher_init( &cipher_ctx );
+ mbedtls_cipher_init( &cipher_ctx );
- if( ( ret = cipher_init_ctx( &cipher_ctx, cipher_info ) ) != 0 )
+ if( ( ret = mbedtls_cipher_init_ctx( &cipher_ctx, cipher_info ) ) != 0 )
goto exit;
- if( ( ret = cipher_setkey( &cipher_ctx, key, 8 * keylen, (operation_t) mode ) ) != 0 )
+ if( ( ret = mbedtls_cipher_setkey( &cipher_ctx, key, 8 * keylen, (mbedtls_operation_t) mode ) ) != 0 )
goto exit;
- if( ( ret = cipher_set_iv( &cipher_ctx, iv, cipher_info->iv_size ) ) != 0 )
+ if( ( ret = mbedtls_cipher_set_iv( &cipher_ctx, iv, cipher_info->iv_size ) ) != 0 )
goto exit;
- if( ( ret = cipher_reset( &cipher_ctx ) ) != 0 )
+ if( ( ret = mbedtls_cipher_reset( &cipher_ctx ) ) != 0 )
goto exit;
- if( ( ret = cipher_update( &cipher_ctx, data, len,
+ if( ( ret = mbedtls_cipher_update( &cipher_ctx, data, len,
output, &olen ) ) != 0 )
{
goto exit;
}
- if( ( ret = cipher_finish( &cipher_ctx, output + olen, &olen ) ) != 0 )
- ret = POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH;
+ if( ( ret = mbedtls_cipher_finish( &cipher_ctx, output + olen, &olen ) ) != 0 )
+ ret = MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH;
exit:
- polarssl_zeroize( key, sizeof( key ) );
- polarssl_zeroize( iv, sizeof( iv ) );
- cipher_free( &cipher_ctx );
+ mbedtls_zeroize( key, sizeof( key ) );
+ mbedtls_zeroize( iv, sizeof( iv ) );
+ mbedtls_cipher_free( &cipher_ctx );
return( ret );
}
@@ -239,38 +239,38 @@
}
}
-int pkcs12_derivation( unsigned char *data, size_t datalen,
+int mbedtls_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 )
+ mbedtls_md_type_t md_type, int id, int iterations )
{
int ret;
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 hash_output[MBEDTLS_MD_MAX_SIZE];
unsigned char *p;
unsigned char c;
size_t hlen, use_len, v, i;
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_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 );
+ return( MBEDTLS_ERR_PKCS12_BAD_INPUT_DATA );
- md_info = md_info_from_type( md_type );
+ md_info = mbedtls_md_info_from_type( md_type );
if( md_info == NULL )
- return( POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE );
- md_init( &md_ctx );
+ mbedtls_md_init( &md_ctx );
- if( ( ret = md_setup( &md_ctx, md_info, 0 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
return( ret );
- hlen = md_get_size( md_info );
+ hlen = mbedtls_md_get_size( md_info );
if( hlen <= 32 )
v = 64;
@@ -286,25 +286,25 @@
while( datalen > 0 )
{
// Calculate hash( diversifier || salt_block || pwd_block )
- if( ( ret = md_starts( &md_ctx ) ) != 0 )
+ if( ( ret = mbedtls_md_starts( &md_ctx ) ) != 0 )
goto exit;
- if( ( ret = md_update( &md_ctx, diversifier, v ) ) != 0 )
+ if( ( ret = mbedtls_md_update( &md_ctx, diversifier, v ) ) != 0 )
goto exit;
- if( ( ret = md_update( &md_ctx, salt_block, v ) ) != 0 )
+ if( ( ret = mbedtls_md_update( &md_ctx, salt_block, v ) ) != 0 )
goto exit;
- if( ( ret = md_update( &md_ctx, pwd_block, v ) ) != 0 )
+ if( ( ret = mbedtls_md_update( &md_ctx, pwd_block, v ) ) != 0 )
goto exit;
- if( ( ret = md_finish( &md_ctx, hash_output ) ) != 0 )
+ if( ( ret = mbedtls_md_finish( &md_ctx, hash_output ) ) != 0 )
goto exit;
// Perform remaining ( iterations - 1 ) recursive hash calculations
for( i = 1; i < (size_t) iterations; i++ )
{
- if( ( ret = md( md_info, hash_output, hlen, hash_output ) ) != 0 )
+ if( ( ret = mbedtls_md( md_info, hash_output, hlen, hash_output ) ) != 0 )
goto exit;
}
@@ -346,14 +346,14 @@
ret = 0;
exit:
- polarssl_zeroize( salt_block, sizeof( salt_block ) );
- polarssl_zeroize( pwd_block, sizeof( pwd_block ) );
- polarssl_zeroize( hash_block, sizeof( hash_block ) );
- polarssl_zeroize( hash_output, sizeof( hash_output ) );
+ mbedtls_zeroize( salt_block, sizeof( salt_block ) );
+ mbedtls_zeroize( pwd_block, sizeof( pwd_block ) );
+ mbedtls_zeroize( hash_block, sizeof( hash_block ) );
+ mbedtls_zeroize( hash_output, sizeof( hash_output ) );
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
return( ret );
}
-#endif /* POLARSSL_PKCS12_C */
+#endif /* MBEDTLS_PKCS12_C */
diff --git a/library/pkcs5.c b/library/pkcs5.c
index 9cce1a5..6163e9a 100644
--- a/library/pkcs5.c
+++ b/library/pkcs5.c
@@ -30,13 +30,13 @@
* http://tools.ietf.org/html/rfc6070 (Test vectors)
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PKCS5_C)
+#if defined(MBEDTLS_PKCS5_C)
#include "mbedtls/pkcs5.h"
#include "mbedtls/asn1.h"
@@ -45,25 +45,25 @@
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
+#define mbedtls_printf printf
#endif
-static int pkcs5_parse_pbkdf2_params( const asn1_buf *params,
- asn1_buf *salt, int *iterations,
- int *keylen, md_type_t *md_type )
+static int pkcs5_parse_pbkdf2_params( const mbedtls_asn1_buf *params,
+ mbedtls_asn1_buf *salt, int *iterations,
+ int *keylen, mbedtls_md_type_t *md_type )
{
int ret;
- asn1_buf prf_alg_oid;
+ mbedtls_asn1_buf prf_alg_oid;
unsigned char *p = params->p;
const unsigned char *end = params->p + params->len;
- if( params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
/*
* PBKDF2-params ::= SEQUENCE {
* salt OCTET STRING,
@@ -73,59 +73,59 @@
* }
*
*/
- if( ( ret = asn1_get_tag( &p, end, &salt->len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &salt->len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
salt->p = p;
p += salt->len;
- if( ( ret = asn1_get_int( &p, end, iterations ) ) != 0 )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end, iterations ) ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
if( p == end )
return( 0 );
- if( ( ret = asn1_get_int( &p, end, keylen ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_int( &p, end, keylen ) ) != 0 )
{
- if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
}
if( p == end )
return( 0 );
- if( ( ret = asn1_get_alg_null( &p, end, &prf_alg_oid ) ) != 0 )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_alg_null( &p, end, &prf_alg_oid ) ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
- if( OID_CMP( OID_HMAC_SHA1, &prf_alg_oid ) != 0 )
- return( POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE );
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_HMAC_SHA1, &prf_alg_oid ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
- *md_type = POLARSSL_MD_SHA1;
+ *md_type = MBEDTLS_MD_SHA1;
if( p != end )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-int pkcs5_pbes2( const asn1_buf *pbe_params, int mode,
+int mbedtls_pkcs5_pbes2( const mbedtls_asn1_buf *pbe_params, int mode,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t datalen,
unsigned char *output )
{
int ret, iterations = 0, keylen = 0;
unsigned char *p, *end;
- asn1_buf kdf_alg_oid, enc_scheme_oid, kdf_alg_params, enc_scheme_params;
- asn1_buf salt;
- md_type_t md_type = POLARSSL_MD_SHA1;
+ mbedtls_asn1_buf kdf_alg_oid, enc_scheme_oid, kdf_alg_params, enc_scheme_params;
+ mbedtls_asn1_buf salt;
+ mbedtls_md_type_t md_type = MBEDTLS_MD_SHA1;
unsigned char key[32], iv[32];
size_t olen = 0;
- const md_info_t *md_info;
- const cipher_info_t *cipher_info;
- md_context_t md_ctx;
- cipher_type_t cipher_alg;
- cipher_context_t cipher_ctx;
+ const mbedtls_md_info_t *md_info;
+ const mbedtls_cipher_info_t *cipher_info;
+ mbedtls_md_context_t md_ctx;
+ mbedtls_cipher_type_t cipher_alg;
+ mbedtls_cipher_context_t cipher_ctx;
p = pbe_params->p;
end = p + pbe_params->len;
@@ -136,17 +136,17 @@
* encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}
* }
*/
- if( pbe_params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( pbe_params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
- if( ( ret = asn1_get_alg( &p, end, &kdf_alg_oid, &kdf_alg_params ) ) != 0 )
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_alg( &p, end, &kdf_alg_oid, &kdf_alg_params ) ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
// Only PBKDF2 supported at the moment
//
- if( OID_CMP( OID_PKCS5_PBKDF2, &kdf_alg_oid ) != 0 )
- return( POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE );
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS5_PBKDF2, &kdf_alg_oid ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
if( ( ret = pkcs5_parse_pbkdf2_params( &kdf_alg_params,
&salt, &iterations, &keylen,
@@ -155,22 +155,22 @@
return( ret );
}
- md_info = md_info_from_type( md_type );
+ md_info = mbedtls_md_info_from_type( md_type );
if( md_info == NULL )
- return( POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
- if( ( ret = asn1_get_alg( &p, end, &enc_scheme_oid,
+ if( ( ret = mbedtls_asn1_get_alg( &p, end, &enc_scheme_oid,
&enc_scheme_params ) ) != 0 )
{
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT + ret );
}
- if( oid_get_cipher_alg( &enc_scheme_oid, &cipher_alg ) != 0 )
- return( POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE );
+ if( mbedtls_oid_get_cipher_alg( &enc_scheme_oid, &cipher_alg ) != 0 )
+ return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
- cipher_info = cipher_info_from_type( cipher_alg );
+ cipher_info = mbedtls_cipher_info_from_type( cipher_alg );
if( cipher_info == NULL )
- return( POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE );
/*
* The value of keylen from pkcs5_parse_pbkdf2_params() is ignored
@@ -178,53 +178,53 @@
*/
keylen = cipher_info->key_length / 8;
- if( enc_scheme_params.tag != ASN1_OCTET_STRING ||
+ if( enc_scheme_params.tag != MBEDTLS_ASN1_OCTET_STRING ||
enc_scheme_params.len != cipher_info->iv_size )
{
- return( POLARSSL_ERR_PKCS5_INVALID_FORMAT );
+ return( MBEDTLS_ERR_PKCS5_INVALID_FORMAT );
}
- md_init( &md_ctx );
- cipher_init( &cipher_ctx );
+ mbedtls_md_init( &md_ctx );
+ mbedtls_cipher_init( &cipher_ctx );
memcpy( iv, enc_scheme_params.p, enc_scheme_params.len );
- if( ( ret = md_setup( &md_ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
goto exit;
- if( ( ret = pkcs5_pbkdf2_hmac( &md_ctx, pwd, pwdlen, salt.p, salt.len,
+ if( ( ret = mbedtls_pkcs5_pbkdf2_hmac( &md_ctx, pwd, pwdlen, salt.p, salt.len,
iterations, keylen, key ) ) != 0 )
{
goto exit;
}
- if( ( ret = cipher_init_ctx( &cipher_ctx, cipher_info ) ) != 0 )
+ if( ( ret = mbedtls_cipher_init_ctx( &cipher_ctx, cipher_info ) ) != 0 )
goto exit;
- if( ( ret = cipher_setkey( &cipher_ctx, key, 8 * keylen, (operation_t) mode ) ) != 0 )
+ if( ( ret = mbedtls_cipher_setkey( &cipher_ctx, key, 8 * keylen, (mbedtls_operation_t) mode ) ) != 0 )
goto exit;
- if( ( ret = cipher_crypt( &cipher_ctx, iv, enc_scheme_params.len,
+ if( ( ret = mbedtls_cipher_crypt( &cipher_ctx, iv, enc_scheme_params.len,
data, datalen, output, &olen ) ) != 0 )
- ret = POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH;
+ ret = MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH;
exit:
- md_free( &md_ctx );
- cipher_free( &cipher_ctx );
+ mbedtls_md_free( &md_ctx );
+ mbedtls_cipher_free( &cipher_ctx );
return( ret );
}
-int pkcs5_pbkdf2_hmac( md_context_t *ctx, const unsigned char *password,
+int mbedtls_pkcs5_pbkdf2_hmac( mbedtls_md_context_t *ctx, const unsigned char *password,
size_t plen, const unsigned char *salt, size_t slen,
unsigned int iteration_count,
uint32_t key_length, unsigned char *output )
{
int ret, j;
unsigned int i;
- unsigned char md1[POLARSSL_MD_MAX_SIZE];
- unsigned char work[POLARSSL_MD_MAX_SIZE];
- unsigned char md_size = md_get_size( ctx->md_info );
+ unsigned char md1[MBEDTLS_MD_MAX_SIZE];
+ unsigned char work[MBEDTLS_MD_MAX_SIZE];
+ unsigned char md_size = mbedtls_md_get_size( ctx->md_info );
size_t use_len;
unsigned char *out_p = output;
unsigned char counter[4];
@@ -233,22 +233,22 @@
counter[3] = 1;
if( iteration_count > 0xFFFFFFFF )
- return( POLARSSL_ERR_PKCS5_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PKCS5_BAD_INPUT_DATA );
while( key_length )
{
// U1 ends up in work
//
- if( ( ret = md_hmac_starts( ctx, password, plen ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_starts( ctx, password, plen ) ) != 0 )
return( ret );
- if( ( ret = md_hmac_update( ctx, salt, slen ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_update( ctx, salt, slen ) ) != 0 )
return( ret );
- if( ( ret = md_hmac_update( ctx, counter, 4 ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_update( ctx, counter, 4 ) ) != 0 )
return( ret );
- if( ( ret = md_hmac_finish( ctx, work ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_finish( ctx, work ) ) != 0 )
return( ret );
memcpy( md1, work, md_size );
@@ -257,13 +257,13 @@
{
// U2 ends up in md1
//
- if( ( ret = md_hmac_starts( ctx, password, plen ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_starts( ctx, password, plen ) ) != 0 )
return( ret );
- if( ( ret = md_hmac_update( ctx, md1, md_size ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_update( ctx, md1, md_size ) ) != 0 )
return( ret );
- if( ( ret = md_hmac_finish( ctx, md1 ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_finish( ctx, md1 ) ) != 0 )
return( ret );
// U1 xor U2
@@ -286,13 +286,13 @@
return( 0 );
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
-#if !defined(POLARSSL_SHA1_C)
-int pkcs5_self_test( int verbose )
+#if !defined(MBEDTLS_SHA1_C)
+int mbedtls_pkcs5_self_test( int verbose )
{
if( verbose != 0 )
- polarssl_printf( " PBKDF2 (SHA1): skipped\n\n" );
+ mbedtls_printf( " PBKDF2 (SHA1): skipped\n\n" );
return( 0 );
}
@@ -349,23 +349,23 @@
0xcc, 0x37, 0xd7, 0xf0, 0x34, 0x25, 0xe0, 0xc3 },
};
-int pkcs5_self_test( int verbose )
+int mbedtls_pkcs5_self_test( int verbose )
{
- md_context_t sha1_ctx;
- const md_info_t *info_sha1;
+ mbedtls_md_context_t sha1_ctx;
+ const mbedtls_md_info_t *info_sha1;
int ret, i;
unsigned char key[64];
- md_init( &sha1_ctx );
+ mbedtls_md_init( &sha1_ctx );
- info_sha1 = md_info_from_type( POLARSSL_MD_SHA1 );
+ info_sha1 = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
if( info_sha1 == NULL )
{
ret = 1;
goto exit;
}
- if( ( ret = md_setup( &sha1_ctx, info_sha1, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &sha1_ctx, info_sha1, 1 ) ) != 0 )
{
ret = 1;
goto exit;
@@ -374,33 +374,33 @@
for( i = 0; i < MAX_TESTS; i++ )
{
if( verbose != 0 )
- polarssl_printf( " PBKDF2 (SHA1) #%d: ", i );
+ mbedtls_printf( " PBKDF2 (SHA1) #%d: ", i );
- ret = pkcs5_pbkdf2_hmac( &sha1_ctx, password[i], plen[i], salt[i],
+ ret = mbedtls_pkcs5_pbkdf2_hmac( &sha1_ctx, password[i], plen[i], salt[i],
slen[i], it_cnt[i], key_len[i], key );
if( ret != 0 ||
memcmp( result_key[i], key, key_len[i] ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- md_free( &sha1_ctx );
+ mbedtls_md_free( &sha1_ctx );
return( ret );
}
-#endif /* POLARSSL_SHA1_C */
+#endif /* MBEDTLS_SHA1_C */
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_PKCS5_C */
+#endif /* MBEDTLS_PKCS5_C */
diff --git a/library/pkparse.c b/library/pkparse.c
index b42bf8b..c2e51e7 100644
--- a/library/pkparse.c
+++ b/library/pkparse.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PK_PARSE_C)
+#if defined(MBEDTLS_PK_PARSE_C)
#include "mbedtls/pk.h"
#include "mbedtls/asn1.h"
@@ -34,72 +34,72 @@
#include <string.h>
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#include "mbedtls/rsa.h"
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#include "mbedtls/ecdsa.h"
#endif
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PKCS5_C)
+#if defined(MBEDTLS_PKCS5_C)
#include "mbedtls/pkcs5.h"
#endif
-#if defined(POLARSSL_PKCS12_C)
+#if defined(MBEDTLS_PKCS12_C)
#include "mbedtls/pkcs12.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
* Load all data from a file into a given buffer.
*/
-int pk_load_file( const char *path, unsigned char **buf, size_t *n )
+int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
{
FILE *f;
long size;
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_PK_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
if( ( size = ftell( f ) ) == -1 )
{
fclose( f );
- return( POLARSSL_ERR_PK_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
fseek( f, 0, SEEK_SET );
*n = (size_t) size;
if( *n + 1 == 0 ||
- ( *buf = polarssl_malloc( *n + 1 ) ) == NULL )
+ ( *buf = mbedtls_malloc( *n + 1 ) ) == NULL )
{
fclose( f );
- return( POLARSSL_ERR_PK_MALLOC_FAILED );
+ return( MBEDTLS_ERR_PK_MALLOC_FAILED );
}
if( fread( *buf, 1, *n, f ) != *n )
{
fclose( f );
- polarssl_free( *buf );
- return( POLARSSL_ERR_PK_FILE_IO_ERROR );
+ mbedtls_free( *buf );
+ return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
fclose( f );
@@ -112,24 +112,24 @@
/*
* Load and parse a private key
*/
-int pk_parse_keyfile( pk_context *ctx,
+int mbedtls_pk_parse_keyfile( mbedtls_pk_context *ctx,
const char *path, const char *pwd )
{
int ret;
size_t n;
unsigned char *buf;
- if( ( ret = pk_load_file( path, &buf, &n ) ) != 0 )
+ if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
if( pwd == NULL )
- ret = pk_parse_key( ctx, buf, n, NULL, 0 );
+ ret = mbedtls_pk_parse_key( ctx, buf, n, NULL, 0 );
else
- ret = pk_parse_key( ctx, buf, n,
+ ret = mbedtls_pk_parse_key( ctx, buf, n,
(const unsigned char *) pwd, strlen( pwd ) );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
@@ -137,26 +137,26 @@
/*
* Load and parse a public key
*/
-int pk_parse_public_keyfile( pk_context *ctx, const char *path )
+int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *ctx, const char *path )
{
int ret;
size_t n;
unsigned char *buf;
- if( ( ret = pk_load_file( path, &buf, &n ) ) != 0 )
+ if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
- ret = pk_parse_public_key( ctx, buf, n );
+ ret = mbedtls_pk_parse_public_key( ctx, buf, n );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_ECP_C)
-/* Minimally parse an ECParameters buffer to and asn1_buf
+#if defined(MBEDTLS_ECP_C)
+/* Minimally parse an ECParameters buffer to and mbedtls_asn1_buf
*
* ECParameters ::= CHOICE {
* namedCurve OBJECT IDENTIFIER
@@ -165,38 +165,38 @@
* }
*/
static int pk_get_ecparams( unsigned char **p, const unsigned char *end,
- asn1_buf *params )
+ mbedtls_asn1_buf *params )
{
int ret;
/* Tag may be either OID or SEQUENCE */
params->tag = **p;
- if( params->tag != ASN1_OID
-#if defined(POLARSSL_PK_PARSE_EC_EXTENDED)
- && params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE )
+ if( params->tag != MBEDTLS_ASN1_OID
+#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
+ && params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE )
#endif
)
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
- if( ( ret = asn1_get_tag( p, end, ¶ms->len, params->tag ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, ¶ms->len, params->tag ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
params->p = *p;
*p += params->len;
if( *p != end )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-#if defined(POLARSSL_PK_PARSE_EC_EXTENDED)
+#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
/*
* Parse a SpecifiedECDomain (SEC 1 C.2) and (mostly) fill the group with it.
* WARNING: the resulting group should only be used with
@@ -216,7 +216,7 @@
*
* We only support prime-field as field type, and ignore hash and cofactor.
*/
-static int pk_group_from_specified( const asn1_buf *params, ecp_group *grp )
+static int pk_group_from_specified( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
{
int ret;
unsigned char *p = params->p;
@@ -226,11 +226,11 @@
int ver;
/* SpecifiedECDomainVersion ::= INTEGER { 1, 2, 3 } */
- if( ( ret = asn1_get_int( &p, end, &ver ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end, &ver ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( ver < 1 || ver > 3 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
/*
* FieldID { FIELD-ID:IOSet } ::= SEQUENCE { -- Finite field
@@ -238,8 +238,8 @@
* parameters FIELD-ID.&Type({IOSet}{@fieldType})
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
end_field = p + len;
@@ -252,26 +252,26 @@
* }
* prime-field OBJECT IDENTIFIER ::= { id-fieldType 1 }
*/
- if( ( ret = asn1_get_tag( &p, end_field, &len, ASN1_OID ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end_field, &len, MBEDTLS_ASN1_OID ) ) != 0 )
return( ret );
- if( len != OID_SIZE( OID_ANSI_X9_62_PRIME_FIELD ) ||
- memcmp( p, OID_ANSI_X9_62_PRIME_FIELD, len ) != 0 )
+ if( len != MBEDTLS_OID_SIZE( MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD ) ||
+ memcmp( p, MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD, len ) != 0 )
{
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
}
p += len;
/* Prime-p ::= INTEGER -- Field of size p. */
- if( ( ret = asn1_get_mpi( &p, end_field, &grp->P ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_mpi( &p, end_field, &grp->P ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- grp->pbits = mpi_msb( &grp->P );
+ grp->pbits = mbedtls_mpi_msb( &grp->P );
if( p != end_field )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/*
* Curve ::= SEQUENCE {
@@ -282,8 +282,8 @@
* -- with version equal to ecdpVer2 or ecdpVer3
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
end_curve = p + len;
@@ -292,51 +292,51 @@
* FieldElement ::= OCTET STRING
* containing an integer in the case of a prime field
*/
- if( ( ret = asn1_get_tag( &p, end_curve, &len, ASN1_OCTET_STRING ) ) != 0 ||
- ( ret = mpi_read_binary( &grp->A, p, len ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
+ ( ret = mbedtls_mpi_read_binary( &grp->A, p, len ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
p += len;
- if( ( ret = asn1_get_tag( &p, end_curve, &len, ASN1_OCTET_STRING ) ) != 0 ||
- ( ret = mpi_read_binary( &grp->B, p, len ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
+ ( ret = mbedtls_mpi_read_binary( &grp->B, p, len ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
p += len;
/* Ignore seed BIT STRING OPTIONAL */
- if( ( ret = asn1_get_tag( &p, end_curve, &len, ASN1_BIT_STRING ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_BIT_STRING ) ) == 0 )
p += len;
if( p != end_curve )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/*
* ECPoint ::= OCTET STRING
*/
- if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- if( ( ret = ecp_point_read_binary( grp, &grp->G,
+ if( ( ret = mbedtls_ecp_point_read_binary( grp, &grp->G,
( const unsigned char *) p, len ) ) != 0 )
{
/*
* If we can't read the point because it's compressed, cheat by
* reading only the X coordinate and the parity bit of Y.
*/
- if( ret != POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE ||
+ if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE ||
( p[0] != 0x02 && p[0] != 0x03 ) ||
- len != mpi_size( &grp->P ) + 1 ||
- mpi_read_binary( &grp->G.X, p + 1, len - 1 ) != 0 ||
- mpi_lset( &grp->G.Y, p[0] - 2 ) != 0 ||
- mpi_lset( &grp->G.Z, 1 ) != 0 )
+ len != mbedtls_mpi_size( &grp->P ) + 1 ||
+ mbedtls_mpi_read_binary( &grp->G.X, p + 1, len - 1 ) != 0 ||
+ mbedtls_mpi_lset( &grp->G.Y, p[0] - 2 ) != 0 ||
+ mbedtls_mpi_lset( &grp->G.Z, 1 ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
}
}
@@ -345,10 +345,10 @@
/*
* order INTEGER
*/
- if( ( ret = asn1_get_mpi( &p, end, &grp->N ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_mpi( &p, end, &grp->N ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- grp->nbits = mpi_msb( &grp->N );
+ grp->nbits = mbedtls_mpi_msb( &grp->N );
/*
* Allow optional elements by purposefully not enforcing p == end here.
@@ -361,30 +361,30 @@
* Find the group id associated with an (almost filled) group as generated by
* pk_group_from_specified(), or return an error if unknown.
*/
-static int pk_group_id_from_group( const ecp_group *grp, ecp_group_id *grp_id )
+static int pk_group_id_from_group( const mbedtls_ecp_group *grp, mbedtls_ecp_group_id *grp_id )
{
int ret = 0;
- ecp_group ref;
- const ecp_group_id *id;
+ mbedtls_ecp_group ref;
+ const mbedtls_ecp_group_id *id;
- ecp_group_init( &ref );
+ mbedtls_ecp_group_init( &ref );
- for( id = ecp_grp_id_list(); *id != POLARSSL_ECP_DP_NONE; id++ )
+ for( id = mbedtls_ecp_grp_id_list(); *id != MBEDTLS_ECP_DP_NONE; id++ )
{
/* Load the group associated to that id */
- ecp_group_free( &ref );
- MPI_CHK( ecp_use_known_dp( &ref, *id ) );
+ mbedtls_ecp_group_free( &ref );
+ MBEDTLS_MPI_CHK( mbedtls_ecp_use_known_dp( &ref, *id ) );
/* Compare to the group we were given, starting with easy tests */
if( grp->pbits == ref.pbits && grp->nbits == ref.nbits &&
- mpi_cmp_mpi( &grp->P, &ref.P ) == 0 &&
- mpi_cmp_mpi( &grp->A, &ref.A ) == 0 &&
- mpi_cmp_mpi( &grp->B, &ref.B ) == 0 &&
- mpi_cmp_mpi( &grp->N, &ref.N ) == 0 &&
- mpi_cmp_mpi( &grp->G.X, &ref.G.X ) == 0 &&
- mpi_cmp_mpi( &grp->G.Z, &ref.G.Z ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->P, &ref.P ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->A, &ref.A ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->B, &ref.B ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->N, &ref.N ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->G.X, &ref.G.X ) == 0 &&
+ mbedtls_mpi_cmp_mpi( &grp->G.Z, &ref.G.Z ) == 0 &&
/* For Y we may only know the parity bit, so compare only that */
- mpi_get_bit( &grp->G.Y, 0 ) == mpi_get_bit( &ref.G.Y, 0 ) )
+ mbedtls_mpi_get_bit( &grp->G.Y, 0 ) == mbedtls_mpi_get_bit( &ref.G.Y, 0 ) )
{
break;
}
@@ -392,12 +392,12 @@
}
cleanup:
- ecp_group_free( &ref );
+ mbedtls_ecp_group_free( &ref );
*grp_id = *id;
- if( ret == 0 && *id == POLARSSL_ECP_DP_NONE )
- ret = POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE;
+ if( ret == 0 && *id == MBEDTLS_ECP_DP_NONE )
+ ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
return( ret );
}
@@ -405,13 +405,13 @@
/*
* Parse a SpecifiedECDomain (SEC 1 C.2) and find the associated group ID
*/
-static int pk_group_id_from_specified( const asn1_buf *params,
- ecp_group_id *grp_id )
+static int pk_group_id_from_specified( const mbedtls_asn1_buf *params,
+ mbedtls_ecp_group_id *grp_id )
{
int ret;
- ecp_group grp;
+ mbedtls_ecp_group grp;
- ecp_group_init( &grp );
+ mbedtls_ecp_group_init( &grp );
if( ( ret = pk_group_from_specified( params, &grp ) ) != 0 )
goto cleanup;
@@ -419,11 +419,11 @@
ret = pk_group_id_from_group( &grp, grp_id );
cleanup:
- ecp_group_free( &grp );
+ mbedtls_ecp_group_free( &grp );
return( ret );
}
-#endif /* POLARSSL_PK_PARSE_EC_EXTENDED */
+#endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
/*
* Use EC parameters to initialise an EC group
@@ -433,33 +433,33 @@
* specifiedCurve SpecifiedECDomain -- = SEQUENCE { ... }
* -- implicitCurve NULL
*/
-static int pk_use_ecparams( const asn1_buf *params, ecp_group *grp )
+static int pk_use_ecparams( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
{
int ret;
- ecp_group_id grp_id;
+ mbedtls_ecp_group_id grp_id;
- if( params->tag == ASN1_OID )
+ if( params->tag == MBEDTLS_ASN1_OID )
{
- if( oid_get_ec_grp( params, &grp_id ) != 0 )
- return( POLARSSL_ERR_PK_UNKNOWN_NAMED_CURVE );
+ if( mbedtls_oid_get_ec_grp( params, &grp_id ) != 0 )
+ return( MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE );
}
else
{
-#if defined(POLARSSL_PK_PARSE_EC_EXTENDED)
+#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
if( ( ret = pk_group_id_from_specified( params, &grp_id ) ) != 0 )
return( ret );
#else
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
#endif
}
/*
* grp may already be initilialized; if so, make sure IDs match
*/
- if( grp->id != POLARSSL_ECP_DP_NONE && grp->id != grp_id )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ if( grp->id != MBEDTLS_ECP_DP_NONE && grp->id != grp_id )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
- if( ( ret = ecp_use_known_dp( grp, grp_id ) ) != 0 )
+ if( ( ret = mbedtls_ecp_use_known_dp( grp, grp_id ) ) != 0 )
return( ret );
return( 0 );
@@ -470,29 +470,29 @@
*
* The caller is responsible for clearing the structure upon failure if
* desired. Take care to pass along the possible ECP_FEATURE_UNAVAILABLE
- * return code of ecp_point_read_binary() and leave p in a usable state.
+ * return code of mbedtls_ecp_point_read_binary() and leave p in a usable state.
*/
static int pk_get_ecpubkey( unsigned char **p, const unsigned char *end,
- ecp_keypair *key )
+ mbedtls_ecp_keypair *key )
{
int ret;
- if( ( ret = ecp_point_read_binary( &key->grp, &key->Q,
+ if( ( ret = mbedtls_ecp_point_read_binary( &key->grp, &key->Q,
(const unsigned char *) *p, end - *p ) ) == 0 )
{
- ret = ecp_check_pubkey( &key->grp, &key->Q );
+ ret = mbedtls_ecp_check_pubkey( &key->grp, &key->Q );
}
/*
- * We know ecp_point_read_binary consumed all bytes or failed
+ * We know mbedtls_ecp_point_read_binary consumed all bytes or failed
*/
*p = (unsigned char *) end;
return( ret );
}
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
/*
* RSAPublicKey ::= SEQUENCE {
* modulus INTEGER, -- n
@@ -501,35 +501,35 @@
*/
static int pk_get_rsapubkey( unsigned char **p,
const unsigned char *end,
- rsa_context *rsa )
+ mbedtls_rsa_context *rsa )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
if( *p + len != end )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- if( ( ret = asn1_get_mpi( p, end, &rsa->N ) ) != 0 ||
- ( ret = asn1_get_mpi( p, end, &rsa->E ) ) != 0 )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY + ret );
+ if( ( ret = mbedtls_asn1_get_mpi( p, end, &rsa->N ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( p, end, &rsa->E ) ) != 0 )
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
if( *p != end )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- if( ( ret = rsa_check_pubkey( rsa ) ) != 0 )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY );
+ if( ( ret = mbedtls_rsa_check_pubkey( rsa ) ) != 0 )
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
- rsa->len = mpi_size( &rsa->N );
+ rsa->len = mbedtls_mpi_size( &rsa->N );
return( 0 );
}
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
/* Get a PK algorithm identifier
*
@@ -539,27 +539,27 @@
*/
static int pk_get_pk_alg( unsigned char **p,
const unsigned char *end,
- pk_type_t *pk_alg, asn1_buf *params )
+ mbedtls_pk_type_t *pk_alg, mbedtls_asn1_buf *params )
{
int ret;
- asn1_buf alg_oid;
+ mbedtls_asn1_buf alg_oid;
- memset( params, 0, sizeof(asn1_buf) );
+ memset( params, 0, sizeof(mbedtls_asn1_buf) );
- if( ( ret = asn1_get_alg( p, end, &alg_oid, params ) ) != 0 )
- return( POLARSSL_ERR_PK_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_alg( p, end, &alg_oid, params ) ) != 0 )
+ return( MBEDTLS_ERR_PK_INVALID_ALG + ret );
- if( oid_get_pk_alg( &alg_oid, pk_alg ) != 0 )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+ if( mbedtls_oid_get_pk_alg( &alg_oid, pk_alg ) != 0 )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
/*
* No parameters with RSA (only for EC)
*/
- if( *pk_alg == POLARSSL_PK_RSA &&
- ( ( params->tag != ASN1_NULL && params->tag != 0 ) ||
+ if( *pk_alg == MBEDTLS_PK_RSA &&
+ ( ( params->tag != MBEDTLS_ASN1_NULL && params->tag != 0 ) ||
params->len != 0 ) )
{
- return( POLARSSL_ERR_PK_INVALID_ALG );
+ return( MBEDTLS_ERR_PK_INVALID_ALG );
}
return( 0 );
@@ -570,19 +570,19 @@
* algorithm AlgorithmIdentifier,
* subjectPublicKey BIT STRING }
*/
-int pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
- pk_context *pk )
+int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
+ mbedtls_pk_context *pk )
{
int ret;
size_t len;
- asn1_buf alg_params;
- pk_type_t pk_alg = POLARSSL_PK_NONE;
- const pk_info_t *pk_info;
+ mbedtls_asn1_buf alg_params;
+ mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
+ const mbedtls_pk_info_t *pk_info;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = *p + len;
@@ -590,50 +590,50 @@
if( ( ret = pk_get_pk_alg( p, end, &pk_alg, &alg_params ) ) != 0 )
return( ret );
- if( ( ret = asn1_get_bitstring_null( p, end, &len ) ) != 0 )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY + ret );
+ if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
if( *p + len != end )
- return( POLARSSL_ERR_PK_INVALID_PUBKEY +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- if( ( pk_info = pk_info_from_type( pk_alg ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+ if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 )
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 )
return( ret );
-#if defined(POLARSSL_RSA_C)
- if( pk_alg == POLARSSL_PK_RSA )
+#if defined(MBEDTLS_RSA_C)
+ if( pk_alg == MBEDTLS_PK_RSA )
{
- ret = pk_get_rsapubkey( p, end, pk_rsa( *pk ) );
+ ret = pk_get_rsapubkey( p, end, mbedtls_pk_rsa( *pk ) );
} else
-#endif /* POLARSSL_RSA_C */
-#if defined(POLARSSL_ECP_C)
- if( pk_alg == POLARSSL_PK_ECKEY_DH || pk_alg == POLARSSL_PK_ECKEY )
+#endif /* MBEDTLS_RSA_C */
+#if defined(MBEDTLS_ECP_C)
+ if( pk_alg == MBEDTLS_PK_ECKEY_DH || pk_alg == MBEDTLS_PK_ECKEY )
{
- ret = pk_use_ecparams( &alg_params, &pk_ec( *pk )->grp );
+ ret = pk_use_ecparams( &alg_params, &mbedtls_pk_ec( *pk )->grp );
if( ret == 0 )
- ret = pk_get_ecpubkey( p, end, pk_ec( *pk ) );
+ ret = pk_get_ecpubkey( p, end, mbedtls_pk_ec( *pk ) );
} else
-#endif /* POLARSSL_ECP_C */
- ret = POLARSSL_ERR_PK_UNKNOWN_PK_ALG;
+#endif /* MBEDTLS_ECP_C */
+ ret = MBEDTLS_ERR_PK_UNKNOWN_PK_ALG;
if( ret == 0 && *p != end )
- ret = POLARSSL_ERR_PK_INVALID_PUBKEY
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH;
+ ret = MBEDTLS_ERR_PK_INVALID_PUBKEY
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
if( ret != 0 )
- pk_free( pk );
+ mbedtls_pk_free( pk );
return( ret );
}
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
/*
* Parse a PKCS#1 encoded private RSA key
*/
-static int pk_parse_key_pkcs1_der( rsa_context *rsa,
+static int pk_parse_key_pkcs1_der( mbedtls_rsa_context *rsa,
const unsigned char *key,
size_t keylen )
{
@@ -660,68 +660,68 @@
* otherPrimeInfos OtherPrimeInfos OPTIONAL
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = p + len;
- if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
if( rsa->ver != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_VERSION );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
}
- if( ( ret = asn1_get_mpi( &p, end, &rsa->N ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->E ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->D ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->P ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 ||
- ( ret = asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->N ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->E ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->D ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->P ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 ||
+ ( ret = mbedtls_asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 )
{
- rsa_free( rsa );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ mbedtls_rsa_free( rsa );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
- rsa->len = mpi_size( &rsa->N );
+ rsa->len = mbedtls_mpi_size( &rsa->N );
if( p != end )
{
- rsa_free( rsa );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_rsa_free( rsa );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
- if( ( ret = rsa_check_privkey( rsa ) ) != 0 )
+ if( ( ret = mbedtls_rsa_check_privkey( rsa ) ) != 0 )
{
- rsa_free( rsa );
+ mbedtls_rsa_free( rsa );
return( ret );
}
return( 0 );
}
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
/*
* Parse a SEC1 encoded private EC key
*/
-static int pk_parse_key_sec1_der( ecp_keypair *eck,
+static int pk_parse_key_sec1_der( mbedtls_ecp_keypair *eck,
const unsigned char *key,
size_t keylen )
{
int ret;
int version, pubkey_done;
size_t len;
- asn1_buf params;
+ mbedtls_asn1_buf params;
unsigned char *p = (unsigned char *) key;
unsigned char *end = p + keylen;
unsigned char *end2;
@@ -736,27 +736,27 @@
* publicKey [1] BIT STRING OPTIONAL
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = p + len;
- if( ( ret = asn1_get_int( &p, end, &version ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( version != 1 )
- return( POLARSSL_ERR_PK_KEY_INVALID_VERSION );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
- if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- if( ( ret = mpi_read_binary( &eck->d, p, len ) ) != 0 )
+ if( ( ret = mbedtls_mpi_read_binary( &eck->d, p, len ) ) != 0 )
{
- ecp_keypair_free( eck );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ mbedtls_ecp_keypair_free( eck );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
p += len;
@@ -764,20 +764,20 @@
/*
* Is 'parameters' present?
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
{
if( ( ret = pk_get_ecparams( &p, p + len, ¶ms) ) != 0 ||
( ret = pk_use_ecparams( ¶ms, &eck->grp ) ) != 0 )
{
- ecp_keypair_free( eck );
+ mbedtls_ecp_keypair_free( eck );
return( ret );
}
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
- ecp_keypair_free( eck );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ mbedtls_ecp_keypair_free( eck );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
/*
@@ -785,17 +785,17 @@
* is compressed), create it from the private key.
*/
pubkey_done = 0;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 1 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
{
end2 = p + len;
- if( ( ret = asn1_get_bitstring_null( &p, end2, &len ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_bitstring_null( &p, end2, &len ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( p + len != end2 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
if( ( ret = pk_get_ecpubkey( &p, end2, eck ) ) == 0 )
pubkey_done = 1;
@@ -805,49 +805,49 @@
* The only acceptable failure mode of pk_get_ecpubkey() above
* is if the point format is not recognized.
*/
- if( ret != POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
}
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
- ecp_keypair_free( eck );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ mbedtls_ecp_keypair_free( eck );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
if( ! pubkey_done &&
- ( ret = ecp_mul( &eck->grp, &eck->Q, &eck->d, &eck->grp.G,
+ ( ret = mbedtls_ecp_mul( &eck->grp, &eck->Q, &eck->d, &eck->grp.G,
NULL, NULL ) ) != 0 )
{
- ecp_keypair_free( eck );
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ mbedtls_ecp_keypair_free( eck );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
- if( ( ret = ecp_check_privkey( &eck->grp, &eck->d ) ) != 0 )
+ if( ( ret = mbedtls_ecp_check_privkey( &eck->grp, &eck->d ) ) != 0 )
{
- ecp_keypair_free( eck );
+ mbedtls_ecp_keypair_free( eck );
return( ret );
}
return( 0 );
}
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
/*
* Parse an unencrypted PKCS#8 encoded private key
*/
static int pk_parse_key_pkcs8_unencrypted_der(
- pk_context *pk,
+ mbedtls_pk_context *pk,
const unsigned char* key,
size_t keylen )
{
int ret, version;
size_t len;
- asn1_buf params;
+ mbedtls_asn1_buf params;
unsigned char *p = (unsigned char *) key;
unsigned char *end = p + keylen;
- pk_type_t pk_alg = POLARSSL_PK_NONE;
- const pk_info_t *pk_info;
+ mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
+ const mbedtls_pk_info_t *pk_info;
/*
* This function parses the PrivatKeyInfo object (PKCS#8 v1.2 = RFC 5208)
@@ -865,58 +865,58 @@
* The PrivateKey OCTET STRING is a SEC1 ECPrivateKey
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = p + len;
- if( ( ret = asn1_get_int( &p, end, &version ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( version != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_VERSION + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION + ret );
if( ( ret = pk_get_pk_alg( &p, end, &pk_alg, ¶ms ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( len < 1 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- if( ( pk_info = pk_info_from_type( pk_alg ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+ if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 )
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 )
return( ret );
-#if defined(POLARSSL_RSA_C)
- if( pk_alg == POLARSSL_PK_RSA )
+#if defined(MBEDTLS_RSA_C)
+ if( pk_alg == MBEDTLS_PK_RSA )
{
- if( ( ret = pk_parse_key_pkcs1_der( pk_rsa( *pk ), p, len ) ) != 0 )
+ if( ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), p, len ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
return( ret );
}
} else
-#endif /* POLARSSL_RSA_C */
-#if defined(POLARSSL_ECP_C)
- if( pk_alg == POLARSSL_PK_ECKEY || pk_alg == POLARSSL_PK_ECKEY_DH )
+#endif /* MBEDTLS_RSA_C */
+#if defined(MBEDTLS_ECP_C)
+ if( pk_alg == MBEDTLS_PK_ECKEY || pk_alg == MBEDTLS_PK_ECKEY_DH )
{
- if( ( ret = pk_use_ecparams( ¶ms, &pk_ec( *pk )->grp ) ) != 0 ||
- ( ret = pk_parse_key_sec1_der( pk_ec( *pk ), p, len ) ) != 0 )
+ if( ( ret = pk_use_ecparams( ¶ms, &mbedtls_pk_ec( *pk )->grp ) ) != 0 ||
+ ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ), p, len ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
return( ret );
}
} else
-#endif /* POLARSSL_ECP_C */
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+#endif /* MBEDTLS_ECP_C */
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
return( 0 );
}
@@ -924,9 +924,9 @@
/*
* Parse an encrypted PKCS#8 encoded private key
*/
-#if defined(POLARSSL_PKCS12_C) || defined(POLARSSL_PKCS5_C)
+#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
static int pk_parse_key_pkcs8_encrypted_der(
- pk_context *pk,
+ mbedtls_pk_context *pk,
const unsigned char *key, size_t keylen,
const unsigned char *pwd, size_t pwdlen )
{
@@ -934,10 +934,10 @@
size_t len;
unsigned char buf[2048];
unsigned char *p, *end;
- asn1_buf pbe_alg_oid, pbe_params;
-#if defined(POLARSSL_PKCS12_C)
- cipher_type_t cipher_alg;
- md_type_t md_alg;
+ mbedtls_asn1_buf pbe_alg_oid, pbe_params;
+#if defined(MBEDTLS_PKCS12_C)
+ mbedtls_cipher_type_t cipher_alg;
+ mbedtls_md_type_t md_alg;
#endif
memset( buf, 0, sizeof( buf ) );
@@ -946,7 +946,7 @@
end = p + keylen;
if( pwdlen == 0 )
- return( POLARSSL_ERR_PK_PASSWORD_REQUIRED );
+ return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
/*
* This function parses the EncryptedPrivatKeyInfo object (PKCS#8)
@@ -962,45 +962,45 @@
*
* The EncryptedData OCTET STRING is a PKCS#8 PrivateKeyInfo
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
}
end = p + len;
- if( ( ret = asn1_get_alg( &p, end, &pbe_alg_oid, &pbe_params ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_alg( &p, end, &pbe_alg_oid, &pbe_params ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
- if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
if( len > sizeof( buf ) )
- return( POLARSSL_ERR_PK_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
/*
* Decrypt EncryptedData with appropriate PDE
*/
-#if defined(POLARSSL_PKCS12_C)
- if( oid_get_pkcs12_pbe_alg( &pbe_alg_oid, &md_alg, &cipher_alg ) == 0 )
+#if defined(MBEDTLS_PKCS12_C)
+ if( mbedtls_oid_get_pkcs12_pbe_alg( &pbe_alg_oid, &md_alg, &cipher_alg ) == 0 )
{
- if( ( ret = pkcs12_pbe( &pbe_params, PKCS12_PBE_DECRYPT,
+ if( ( ret = mbedtls_pkcs12_pbe( &pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT,
cipher_alg, md_alg,
pwd, pwdlen, p, len, buf ) ) != 0 )
{
- if( ret == POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH )
- return( POLARSSL_ERR_PK_PASSWORD_MISMATCH );
+ if( ret == MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH )
+ return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
return( ret );
}
decrypted = 1;
}
- else if( OID_CMP( OID_PKCS12_PBE_SHA1_RC4_128, &pbe_alg_oid ) == 0 )
+ else if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS12_PBE_SHA1_RC4_128, &pbe_alg_oid ) == 0 )
{
- if( ( ret = pkcs12_pbe_sha1_rc4_128( &pbe_params,
- PKCS12_PBE_DECRYPT,
+ if( ( ret = mbedtls_pkcs12_pbe_sha1_rc4_128( &pbe_params,
+ MBEDTLS_PKCS12_PBE_DECRYPT,
pwd, pwdlen,
p, len, buf ) ) != 0 )
{
@@ -1008,23 +1008,23 @@
}
// Best guess for password mismatch when using RC4. If first tag is
- // not ASN1_CONSTRUCTED | ASN1_SEQUENCE
+ // not MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE
//
- if( *buf != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_PK_PASSWORD_MISMATCH );
+ if( *buf != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
decrypted = 1;
}
else
-#endif /* POLARSSL_PKCS12_C */
-#if defined(POLARSSL_PKCS5_C)
- if( OID_CMP( OID_PKCS5_PBES2, &pbe_alg_oid ) == 0 )
+#endif /* MBEDTLS_PKCS12_C */
+#if defined(MBEDTLS_PKCS5_C)
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS5_PBES2, &pbe_alg_oid ) == 0 )
{
- if( ( ret = pkcs5_pbes2( &pbe_params, PKCS5_DECRYPT, pwd, pwdlen,
+ if( ( ret = mbedtls_pkcs5_pbes2( &pbe_params, MBEDTLS_PKCS5_DECRYPT, pwd, pwdlen,
p, len, buf ) ) != 0 )
{
- if( ret == POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH )
- return( POLARSSL_ERR_PK_PASSWORD_MISMATCH );
+ if( ret == MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH )
+ return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
return( ret );
}
@@ -1032,91 +1032,91 @@
decrypted = 1;
}
else
-#endif /* POLARSSL_PKCS5_C */
+#endif /* MBEDTLS_PKCS5_C */
{
((void) pwd);
}
if( decrypted == 0 )
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
return( pk_parse_key_pkcs8_unencrypted_der( pk, buf, len ) );
}
-#endif /* POLARSSL_PKCS12_C || POLARSSL_PKCS5_C */
+#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
/*
* Parse a private key
*/
-int pk_parse_key( pk_context *pk,
+int mbedtls_pk_parse_key( mbedtls_pk_context *pk,
const unsigned char *key, size_t keylen,
const unsigned char *pwd, size_t pwdlen )
{
int ret;
- const pk_info_t *pk_info;
+ const mbedtls_pk_info_t *pk_info;
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
size_t len;
- pem_context pem;
+ mbedtls_pem_context pem;
- pem_init( &pem );
+ mbedtls_pem_init( &pem );
-#if defined(POLARSSL_RSA_C)
- ret = pem_read_buffer( &pem,
+#if defined(MBEDTLS_RSA_C)
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN RSA PRIVATE KEY-----",
"-----END RSA PRIVATE KEY-----",
key, pwd, pwdlen, &len );
if( ret == 0 )
{
- if( ( pk_info = pk_info_from_type( POLARSSL_PK_RSA ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+ if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 ||
- ( ret = pk_parse_key_pkcs1_der( pk_rsa( *pk ),
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 ||
+ ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ),
pem.buf, pem.buflen ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
}
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
- else if( ret == POLARSSL_ERR_PEM_PASSWORD_MISMATCH )
- return( POLARSSL_ERR_PK_PASSWORD_MISMATCH );
- else if( ret == POLARSSL_ERR_PEM_PASSWORD_REQUIRED )
- return( POLARSSL_ERR_PK_PASSWORD_REQUIRED );
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
+ return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
+ else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
+ return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
return( ret );
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
- ret = pem_read_buffer( &pem,
+#if defined(MBEDTLS_ECP_C)
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN EC PRIVATE KEY-----",
"-----END EC PRIVATE KEY-----",
key, pwd, pwdlen, &len );
if( ret == 0 )
{
- if( ( pk_info = pk_info_from_type( POLARSSL_PK_ECKEY ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+ if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 ||
- ( ret = pk_parse_key_sec1_der( pk_ec( *pk ),
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 ||
+ ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ),
pem.buf, pem.buflen ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
}
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
- else if( ret == POLARSSL_ERR_PEM_PASSWORD_MISMATCH )
- return( POLARSSL_ERR_PK_PASSWORD_MISMATCH );
- else if( ret == POLARSSL_ERR_PEM_PASSWORD_REQUIRED )
- return( POLARSSL_ERR_PK_PASSWORD_REQUIRED );
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
+ return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
+ else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
+ return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
return( ret );
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
- ret = pem_read_buffer( &pem,
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN PRIVATE KEY-----",
"-----END PRIVATE KEY-----",
key, NULL, 0, &len );
@@ -1125,17 +1125,17 @@
if( ( ret = pk_parse_key_pkcs8_unencrypted_der( pk,
pem.buf, pem.buflen ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
}
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
return( ret );
-#if defined(POLARSSL_PKCS12_C) || defined(POLARSSL_PKCS5_C)
- ret = pem_read_buffer( &pem,
+#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN ENCRYPTED PRIVATE KEY-----",
"-----END ENCRYPTED PRIVATE KEY-----",
key, NULL, 0, &len );
@@ -1145,19 +1145,19 @@
pem.buf, pem.buflen,
pwd, pwdlen ) ) != 0 )
{
- pk_free( pk );
+ mbedtls_pk_free( pk );
}
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
return( ret );
-#endif /* POLARSSL_PKCS12_C || POLARSSL_PKCS5_C */
+#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
#else
((void) pwd);
((void) pwdlen);
-#endif /* POLARSSL_PEM_PARSE_C */
+#endif /* MBEDTLS_PEM_PARSE_C */
/*
* At this point we only know it's not a PEM formatted key. Could be any
@@ -1166,69 +1166,69 @@
* We try the different DER format parsers to see if one passes without
* error
*/
-#if defined(POLARSSL_PKCS12_C) || defined(POLARSSL_PKCS5_C)
+#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
if( ( ret = pk_parse_key_pkcs8_encrypted_der( pk, key, keylen,
pwd, pwdlen ) ) == 0 )
{
return( 0 );
}
- pk_free( pk );
+ mbedtls_pk_free( pk );
- if( ret == POLARSSL_ERR_PK_PASSWORD_MISMATCH )
+ if( ret == MBEDTLS_ERR_PK_PASSWORD_MISMATCH )
{
return( ret );
}
-#endif /* POLARSSL_PKCS12_C || POLARSSL_PKCS5_C */
+#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
if( ( ret = pk_parse_key_pkcs8_unencrypted_der( pk, key, keylen ) ) == 0 )
return( 0 );
- pk_free( pk );
+ mbedtls_pk_free( pk );
-#if defined(POLARSSL_RSA_C)
- if( ( pk_info = pk_info_from_type( POLARSSL_PK_RSA ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+#if defined(MBEDTLS_RSA_C)
+ if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 ||
- ( ret = pk_parse_key_pkcs1_der( pk_rsa( *pk ), key, keylen ) ) == 0 )
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 ||
+ ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), key, keylen ) ) == 0 )
{
return( 0 );
}
- pk_free( pk );
-#endif /* POLARSSL_RSA_C */
+ mbedtls_pk_free( pk );
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
- if( ( pk_info = pk_info_from_type( POLARSSL_PK_ECKEY ) ) == NULL )
- return( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
+#if defined(MBEDTLS_ECP_C)
+ if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == NULL )
+ return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
- if( ( ret = pk_init_ctx( pk, pk_info ) ) != 0 ||
- ( ret = pk_parse_key_sec1_der( pk_ec( *pk ), key, keylen ) ) == 0 )
+ if( ( ret = mbedtls_pk_init_ctx( pk, pk_info ) ) != 0 ||
+ ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ), key, keylen ) ) == 0 )
{
return( 0 );
}
- pk_free( pk );
-#endif /* POLARSSL_ECP_C */
+ mbedtls_pk_free( pk );
+#endif /* MBEDTLS_ECP_C */
- return( POLARSSL_ERR_PK_KEY_INVALID_FORMAT );
+ return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
}
/*
* Parse a public key
*/
-int pk_parse_public_key( pk_context *ctx,
+int mbedtls_pk_parse_public_key( mbedtls_pk_context *ctx,
const unsigned char *key, size_t keylen )
{
int ret;
unsigned char *p;
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
size_t len;
- pem_context pem;
+ mbedtls_pem_context pem;
- pem_init( &pem );
- ret = pem_read_buffer( &pem,
+ mbedtls_pem_init( &pem );
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN PUBLIC KEY-----",
"-----END PUBLIC KEY-----",
key, NULL, 0, &len );
@@ -1241,21 +1241,21 @@
key = pem.buf;
keylen = pem.buflen;
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
-#endif /* POLARSSL_PEM_PARSE_C */
+#endif /* MBEDTLS_PEM_PARSE_C */
p = (unsigned char *) key;
- ret = pk_parse_subpubkey( &p, p + keylen, ctx );
+ ret = mbedtls_pk_parse_subpubkey( &p, p + keylen, ctx );
-#if defined(POLARSSL_PEM_PARSE_C)
- pem_free( &pem );
+#if defined(MBEDTLS_PEM_PARSE_C)
+ mbedtls_pem_free( &pem );
#endif
return( ret );
}
-#endif /* POLARSSL_PK_PARSE_C */
+#endif /* MBEDTLS_PK_PARSE_C */
diff --git a/library/pkwrite.c b/library/pkwrite.c
index 2c08b92..6c982ee 100644
--- a/library/pkwrite.c
+++ b/library/pkwrite.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PK_WRITE_C)
+#if defined(MBEDTLS_PK_WRITE_C)
#include "mbedtls/pk.h"
#include "mbedtls/asn1write.h"
@@ -34,28 +34,28 @@
#include <string.h>
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#include "mbedtls/rsa.h"
#endif
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
#include "mbedtls/ecdsa.h"
#endif
-#if defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
/*
* RSAPublicKey ::= SEQUENCE {
* modulus INTEGER, -- n
@@ -63,42 +63,42 @@
* }
*/
static int pk_write_rsa_pubkey( unsigned char **p, unsigned char *start,
- rsa_context *rsa )
+ mbedtls_rsa_context *rsa )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_mpi( p, start, &rsa->E ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( p, start, &rsa->N ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( p, start, &rsa->E ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( p, start, &rsa->N ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
/*
* EC public key is an EC point
*/
static int pk_write_ec_pubkey( unsigned char **p, unsigned char *start,
- ecp_keypair *ec )
+ mbedtls_ecp_keypair *ec )
{
int ret;
size_t len = 0;
- unsigned char buf[POLARSSL_ECP_MAX_PT_LEN];
+ unsigned char buf[MBEDTLS_ECP_MAX_PT_LEN];
- if( ( ret = ecp_point_write_binary( &ec->grp, &ec->Q,
- POLARSSL_ECP_PF_UNCOMPRESSED,
+ if( ( ret = mbedtls_ecp_point_write_binary( &ec->grp, &ec->Q,
+ MBEDTLS_ECP_PF_UNCOMPRESSED,
&len, buf, sizeof( buf ) ) ) != 0 )
{
return( ret );
}
if( *p - start < (int) len )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*p -= len;
memcpy( *p, buf, len );
@@ -112,44 +112,44 @@
* }
*/
static int pk_write_ec_param( unsigned char **p, unsigned char *start,
- ecp_keypair *ec )
+ mbedtls_ecp_keypair *ec )
{
int ret;
size_t len = 0;
const char *oid;
size_t oid_len;
- if( ( ret = oid_get_oid_by_ec_grp( ec->grp.id, &oid, &oid_len ) ) != 0 )
+ if( ( ret = mbedtls_oid_get_oid_by_ec_grp( ec->grp.id, &oid, &oid_len ) ) != 0 )
return( ret );
- ASN1_CHK_ADD( len, asn1_write_oid( p, start, oid, oid_len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( p, start, oid, oid_len ) );
return( (int) len );
}
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
-int pk_write_pubkey( unsigned char **p, unsigned char *start,
- const pk_context *key )
+int mbedtls_pk_write_pubkey( unsigned char **p, unsigned char *start,
+ const mbedtls_pk_context *key )
{
int ret;
size_t len = 0;
-#if defined(POLARSSL_RSA_C)
- if( pk_get_type( key ) == POLARSSL_PK_RSA )
- ASN1_CHK_ADD( len, pk_write_rsa_pubkey( p, start, pk_rsa( *key ) ) );
+#if defined(MBEDTLS_RSA_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
+ MBEDTLS_ASN1_CHK_ADD( len, pk_write_rsa_pubkey( p, start, mbedtls_pk_rsa( *key ) ) );
else
#endif
-#if defined(POLARSSL_ECP_C)
- if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
- ASN1_CHK_ADD( len, pk_write_ec_pubkey( p, start, pk_ec( *key ) ) );
+#if defined(MBEDTLS_ECP_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
+ MBEDTLS_ASN1_CHK_ADD( len, pk_write_ec_pubkey( p, start, mbedtls_pk_ec( *key ) ) );
else
#endif
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
return( (int) len );
}
-int pk_write_pubkey_der( pk_context *key, unsigned char *buf, size_t size )
+int mbedtls_pk_write_pubkey_der( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char *c;
@@ -158,10 +158,10 @@
c = buf + size;
- ASN1_CHK_ADD( len, pk_write_pubkey( &c, buf, key ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_pk_write_pubkey( &c, buf, key ) );
if( c - buf < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
/*
* SubjectPublicKeyInfo ::= SEQUENCE {
@@ -171,63 +171,63 @@
*--c = 0;
len += 1;
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_BIT_STRING ) );
- if( ( ret = oid_get_oid_by_pk_alg( pk_get_type( key ),
+ if( ( ret = mbedtls_oid_get_oid_by_pk_alg( mbedtls_pk_get_type( key ),
&oid, &oid_len ) ) != 0 )
{
return( ret );
}
-#if defined(POLARSSL_ECP_C)
- if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
+#if defined(MBEDTLS_ECP_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
{
- ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, pk_ec( *key ) ) );
+ MBEDTLS_ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, mbedtls_pk_ec( *key ) ) );
}
#endif
- ASN1_CHK_ADD( len, asn1_write_algorithm_identifier( &c, buf, oid, oid_len,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_algorithm_identifier( &c, buf, oid, oid_len,
par_len ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
-int pk_write_key_der( pk_context *key, unsigned char *buf, size_t size )
+int mbedtls_pk_write_key_der( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char *c = buf + size;
size_t len = 0;
-#if defined(POLARSSL_RSA_C)
- if( pk_get_type( key ) == POLARSSL_PK_RSA )
+#if defined(MBEDTLS_RSA_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
{
- rsa_context *rsa = pk_rsa( *key );
+ mbedtls_rsa_context *rsa = mbedtls_pk_rsa( *key );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->QP ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->DQ ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->DP ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->Q ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->P ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->D ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->E ) );
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->N ) );
- ASN1_CHK_ADD( len, asn1_write_int( &c, buf, 0 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->QP ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->DQ ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->DP ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->Q ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->P ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->D ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->E ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &rsa->N ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, 0 ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
}
else
-#endif /* POLARSSL_RSA_C */
-#if defined(POLARSSL_ECP_C)
- if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
+#endif /* MBEDTLS_RSA_C */
+#if defined(MBEDTLS_ECP_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
{
- ecp_keypair *ec = pk_ec( *key );
+ mbedtls_ecp_keypair *ec = mbedtls_pk_ec( *key );
size_t pub_len = 0, par_len = 0;
/*
@@ -242,48 +242,48 @@
*/
/* publicKey */
- ASN1_CHK_ADD( pub_len, pk_write_ec_pubkey( &c, buf, ec ) );
+ MBEDTLS_ASN1_CHK_ADD( pub_len, pk_write_ec_pubkey( &c, buf, ec ) );
if( c - buf < 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--c = 0;
pub_len += 1;
- ASN1_CHK_ADD( pub_len, asn1_write_len( &c, buf, pub_len ) );
- ASN1_CHK_ADD( pub_len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_len( &c, buf, pub_len ) );
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_BIT_STRING ) );
- ASN1_CHK_ADD( pub_len, asn1_write_len( &c, buf, pub_len ) );
- ASN1_CHK_ADD( pub_len, asn1_write_tag( &c, buf,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 1 ) );
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_len( &c, buf, pub_len ) );
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_tag( &c, buf,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) );
len += pub_len;
/* parameters */
- ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, ec ) );
+ MBEDTLS_ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, ec ) );
- ASN1_CHK_ADD( par_len, asn1_write_len( &c, buf, par_len ) );
- ASN1_CHK_ADD( par_len, asn1_write_tag( &c, buf,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) );
+ MBEDTLS_ASN1_CHK_ADD( par_len, mbedtls_asn1_write_len( &c, buf, par_len ) );
+ MBEDTLS_ASN1_CHK_ADD( par_len, mbedtls_asn1_write_tag( &c, buf,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) );
len += par_len;
/* privateKey: write as MPI then fix tag */
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &ec->d ) );
- *c = ASN1_OCTET_STRING;
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf, &ec->d ) );
+ *c = MBEDTLS_ASN1_OCTET_STRING;
/* version */
- ASN1_CHK_ADD( len, asn1_write_int( &c, buf, 1 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, 1 ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
}
else
-#endif /* POLARSSL_ECP_C */
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+#endif /* MBEDTLS_ECP_C */
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
return( (int) len );
}
-#if defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_WRITE_C)
#define PEM_BEGIN_PUBLIC_KEY "-----BEGIN PUBLIC KEY-----\n"
#define PEM_END_PUBLIC_KEY "-----END PUBLIC KEY-----\n"
@@ -297,7 +297,7 @@
* Max sizes of key per types. Shown as tag + len (+ content).
*/
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
/*
* RSA public keys:
* SubjectPublicKeyInfo ::= SEQUENCE { 1 + 3
@@ -310,7 +310,7 @@
* publicExponent INTEGER -- e 1 + 3 + MPI_MAX + 1
* }
*/
-#define RSA_PUB_DER_MAX_BYTES 38 + 2 * POLARSSL_MPI_MAX_SIZE
+#define RSA_PUB_DER_MAX_BYTES 38 + 2 * MBEDTLS_MPI_MAX_SIZE
/*
* RSA private keys:
@@ -327,19 +327,19 @@
* otherPrimeInfos OtherPrimeInfos OPTIONAL 0 (not supported)
* }
*/
-#define MPI_MAX_SIZE_2 POLARSSL_MPI_MAX_SIZE / 2 + \
- POLARSSL_MPI_MAX_SIZE % 2
-#define RSA_PRV_DER_MAX_BYTES 47 + 3 * POLARSSL_MPI_MAX_SIZE \
+#define MPI_MAX_SIZE_2 MBEDTLS_MPI_MAX_SIZE / 2 + \
+ MBEDTLS_MPI_MAX_SIZE % 2
+#define RSA_PRV_DER_MAX_BYTES 47 + 3 * MBEDTLS_MPI_MAX_SIZE \
+ 5 * MPI_MAX_SIZE_2
-#else /* POLARSSL_RSA_C */
+#else /* MBEDTLS_RSA_C */
#define RSA_PUB_DER_MAX_BYTES 0
#define RSA_PRV_DER_MAX_BYTES 0
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
/*
* EC public keys:
* SubjectPublicKeyInfo ::= SEQUENCE { 1 + 2
@@ -351,7 +351,7 @@
* + 2 * ECP_MAX (coords) [1]
* }
*/
-#define ECP_PUB_DER_MAX_BYTES 30 + 2 * POLARSSL_ECP_MAX_BYTES
+#define ECP_PUB_DER_MAX_BYTES 30 + 2 * MBEDTLS_ECP_MAX_BYTES
/*
* EC private keys:
@@ -362,33 +362,33 @@
* publicKey [1] BIT STRING OPTIONAL 1 + 2 + [1] above
* }
*/
-#define ECP_PRV_DER_MAX_BYTES 29 + 3 * POLARSSL_ECP_MAX_BYTES
+#define ECP_PRV_DER_MAX_BYTES 29 + 3 * MBEDTLS_ECP_MAX_BYTES
-#else /* POLARSSL_ECP_C */
+#else /* MBEDTLS_ECP_C */
#define ECP_PUB_DER_MAX_BYTES 0
#define ECP_PRV_DER_MAX_BYTES 0
-#endif /* POLARSSL_ECP_C */
+#endif /* MBEDTLS_ECP_C */
#define PUB_DER_MAX_BYTES RSA_PUB_DER_MAX_BYTES > ECP_PUB_DER_MAX_BYTES ? \
RSA_PUB_DER_MAX_BYTES : ECP_PUB_DER_MAX_BYTES
#define PRV_DER_MAX_BYTES RSA_PRV_DER_MAX_BYTES > ECP_PRV_DER_MAX_BYTES ? \
RSA_PRV_DER_MAX_BYTES : ECP_PRV_DER_MAX_BYTES
-int pk_write_pubkey_pem( pk_context *key, unsigned char *buf, size_t size )
+int mbedtls_pk_write_pubkey_pem( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char output_buf[PUB_DER_MAX_BYTES];
size_t olen = 0;
- if( ( ret = pk_write_pubkey_der( key, output_buf,
+ if( ( ret = mbedtls_pk_write_pubkey_der( key, output_buf,
sizeof(output_buf) ) ) < 0 )
{
return( ret );
}
- if( ( ret = pem_write_buffer( PEM_BEGIN_PUBLIC_KEY, PEM_END_PUBLIC_KEY,
+ if( ( ret = mbedtls_pem_write_buffer( PEM_BEGIN_PUBLIC_KEY, PEM_END_PUBLIC_KEY,
output_buf + sizeof(output_buf) - ret,
ret, buf, size, &olen ) ) != 0 )
{
@@ -398,35 +398,35 @@
return( 0 );
}
-int pk_write_key_pem( pk_context *key, unsigned char *buf, size_t size )
+int mbedtls_pk_write_key_pem( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char output_buf[PRV_DER_MAX_BYTES];
const char *begin, *end;
size_t olen = 0;
- if( ( ret = pk_write_key_der( key, output_buf, sizeof(output_buf) ) ) < 0 )
+ if( ( ret = mbedtls_pk_write_key_der( key, output_buf, sizeof(output_buf) ) ) < 0 )
return( ret );
-#if defined(POLARSSL_RSA_C)
- if( pk_get_type( key ) == POLARSSL_PK_RSA )
+#if defined(MBEDTLS_RSA_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
{
begin = PEM_BEGIN_PRIVATE_KEY_RSA;
end = PEM_END_PRIVATE_KEY_RSA;
}
else
#endif
-#if defined(POLARSSL_ECP_C)
- if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
+#if defined(MBEDTLS_ECP_C)
+ if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
{
begin = PEM_BEGIN_PRIVATE_KEY_EC;
end = PEM_END_PRIVATE_KEY_EC;
}
else
#endif
- return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
- if( ( ret = pem_write_buffer( begin, end,
+ if( ( ret = mbedtls_pem_write_buffer( begin, end,
output_buf + sizeof(output_buf) - ret,
ret, buf, size, &olen ) ) != 0 )
{
@@ -435,6 +435,6 @@
return( 0 );
}
-#endif /* POLARSSL_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_WRITE_C */
-#endif /* POLARSSL_PK_WRITE_C */
+#endif /* MBEDTLS_PK_WRITE_C */
diff --git a/library/platform.c b/library/platform.c
index abd0b55..788cd1f 100644
--- a/library/platform.c
+++ b/library/platform.c
@@ -20,50 +20,50 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
-#if defined(POLARSSL_PLATFORM_MEMORY)
-#if !defined(POLARSSL_PLATFORM_STD_MALLOC)
+#if defined(MBEDTLS_PLATFORM_MEMORY)
+#if !defined(MBEDTLS_PLATFORM_STD_MALLOC)
static void *platform_malloc_uninit( size_t len )
{
((void) len);
return( NULL );
}
-#define POLARSSL_PLATFORM_STD_MALLOC platform_malloc_uninit
-#endif /* !POLARSSL_PLATFORM_STD_MALLOC */
+#define MBEDTLS_PLATFORM_STD_MALLOC platform_malloc_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_MALLOC */
-#if !defined(POLARSSL_PLATFORM_STD_FREE)
+#if !defined(MBEDTLS_PLATFORM_STD_FREE)
static void platform_free_uninit( void *ptr )
{
((void) ptr);
}
-#define POLARSSL_PLATFORM_STD_FREE platform_free_uninit
-#endif /* !POLARSSL_PLATFORM_STD_FREE */
+#define MBEDTLS_PLATFORM_STD_FREE platform_free_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_FREE */
-void * (*polarssl_malloc)( size_t ) = POLARSSL_PLATFORM_STD_MALLOC;
-void (*polarssl_free)( void * ) = POLARSSL_PLATFORM_STD_FREE;
+void * (*mbedtls_malloc)( size_t ) = MBEDTLS_PLATFORM_STD_MALLOC;
+void (*mbedtls_free)( void * ) = MBEDTLS_PLATFORM_STD_FREE;
-int platform_set_malloc_free( void * (*malloc_func)( size_t ),
+int mbedtls_platform_set_malloc_free( void * (*malloc_func)( size_t ),
void (*free_func)( void * ) )
{
- polarssl_malloc = malloc_func;
- polarssl_free = free_func;
+ mbedtls_malloc = malloc_func;
+ mbedtls_free = free_func;
return( 0 );
}
-#endif /* POLARSSL_PLATFORM_MEMORY */
+#endif /* MBEDTLS_PLATFORM_MEMORY */
-#if defined(POLARSSL_PLATFORM_SNPRINTF_ALT)
-#if !defined(POLARSSL_PLATFORM_STD_SNPRINTF)
+#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
+#if !defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
/*
* Make dummy function to prevent NULL pointer dereferences
*/
@@ -76,24 +76,24 @@
return( 0 );
}
-#define POLARSSL_PLATFORM_STD_SNPRINTF platform_snprintf_uninit
-#endif /* !POLARSSL_PLATFORM_STD_SNPRINTF */
+#define MBEDTLS_PLATFORM_STD_SNPRINTF platform_snprintf_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_SNPRINTF */
-int (*polarssl_snprintf)( char * s, size_t n,
+int (*mbedtls_snprintf)( char * s, size_t n,
const char * format,
- ... ) = POLARSSL_PLATFORM_STD_SNPRINTF;
+ ... ) = MBEDTLS_PLATFORM_STD_SNPRINTF;
-int platform_set_snprintf( int (*snprintf_func)( char * s, size_t n,
+int mbedtls_platform_set_snprintf( int (*snprintf_func)( char * s, size_t n,
const char * format,
... ) )
{
- polarssl_snprintf = snprintf_func;
+ mbedtls_snprintf = snprintf_func;
return( 0 );
}
-#endif /* POLARSSL_PLATFORM_SNPRINTF_ALT */
+#endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
-#if defined(POLARSSL_PLATFORM_PRINTF_ALT)
-#if !defined(POLARSSL_PLATFORM_STD_PRINTF)
+#if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
+#if !defined(MBEDTLS_PLATFORM_STD_PRINTF)
/*
* Make dummy function to prevent NULL pointer dereferences
*/
@@ -103,20 +103,20 @@
return( 0 );
}
-#define POLARSSL_PLATFORM_STD_PRINTF platform_printf_uninit
-#endif /* !POLARSSL_PLATFORM_STD_PRINTF */
+#define MBEDTLS_PLATFORM_STD_PRINTF platform_printf_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_PRINTF */
-int (*polarssl_printf)( const char *, ... ) = POLARSSL_PLATFORM_STD_PRINTF;
+int (*mbedtls_printf)( const char *, ... ) = MBEDTLS_PLATFORM_STD_PRINTF;
-int platform_set_printf( int (*printf_func)( const char *, ... ) )
+int mbedtls_platform_set_printf( int (*printf_func)( const char *, ... ) )
{
- polarssl_printf = printf_func;
+ mbedtls_printf = printf_func;
return( 0 );
}
-#endif /* POLARSSL_PLATFORM_PRINTF_ALT */
+#endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
-#if defined(POLARSSL_PLATFORM_FPRINTF_ALT)
-#if !defined(POLARSSL_PLATFORM_STD_FPRINTF)
+#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
+#if !defined(MBEDTLS_PLATFORM_STD_FPRINTF)
/*
* Make dummy function to prevent NULL pointer dereferences
*/
@@ -127,21 +127,21 @@
return( 0 );
}
-#define POLARSSL_PLATFORM_STD_FPRINTF platform_fprintf_uninit
-#endif /* !POLARSSL_PLATFORM_STD_FPRINTF */
+#define MBEDTLS_PLATFORM_STD_FPRINTF platform_fprintf_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_FPRINTF */
-int (*polarssl_fprintf)( FILE *, const char *, ... ) =
- POLARSSL_PLATFORM_STD_FPRINTF;
+int (*mbedtls_fprintf)( FILE *, const char *, ... ) =
+ MBEDTLS_PLATFORM_STD_FPRINTF;
-int platform_set_fprintf( int (*fprintf_func)( FILE *, const char *, ... ) )
+int mbedtls_platform_set_fprintf( int (*fprintf_func)( FILE *, const char *, ... ) )
{
- polarssl_fprintf = fprintf_func;
+ mbedtls_fprintf = fprintf_func;
return( 0 );
}
-#endif /* POLARSSL_PLATFORM_FPRINTF_ALT */
+#endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
-#if defined(POLARSSL_PLATFORM_EXIT_ALT)
-#if !defined(POLARSSL_PLATFORM_STD_EXIT)
+#if defined(MBEDTLS_PLATFORM_EXIT_ALT)
+#if !defined(MBEDTLS_PLATFORM_STD_EXIT)
/*
* Make dummy function to prevent NULL pointer dereferences
*/
@@ -151,16 +151,16 @@
return( 0 );
}
-#define POLARSSL_PLATFORM_STD_EXIT platform_exit_uninit
-#endif /* !POLARSSL_PLATFORM_STD_EXIT */
+#define MBEDTLS_PLATFORM_STD_EXIT platform_exit_uninit
+#endif /* !MBEDTLS_PLATFORM_STD_EXIT */
-int (*polarssl_exit)( int status ) = POLARSSL_PLATFORM_STD_EXIT;
+int (*mbedtls_exit)( int status ) = MBEDTLS_PLATFORM_STD_EXIT;
-int platform_set_exit( void (*exit_func)( int status ) )
+int mbedtls_platform_set_exit( void (*exit_func)( int status ) )
{
- polarssl_exit = exit_func;
+ mbedtls_exit = exit_func;
return( 0 );
}
-#endif /* POLARSSL_PLATFORM_EXIT_ALT */
+#endif /* MBEDTLS_PLATFORM_EXIT_ALT */
-#endif /* POLARSSL_PLATFORM_C */
+#endif /* MBEDTLS_PLATFORM_C */
diff --git a/library/ripemd160.c b/library/ripemd160.c
index 5e55ff5..12c2e20 100644
--- a/library/ripemd160.c
+++ b/library/ripemd160.c
@@ -22,34 +22,34 @@
/*
* The RIPEMD-160 algorithm was designed by RIPE in 1996
- * http://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html
* http://ehash.iaik.tugraz.at/wiki/RIPEMD-160
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_RIPEMD160_C)
+#if defined(MBEDTLS_RIPEMD160_C)
#include "mbedtls/ripemd160.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/*
* 32-bit integer manipulation macros (little endian)
@@ -75,27 +75,27 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-void ripemd160_init( ripemd160_context *ctx )
+void mbedtls_ripemd160_init( mbedtls_ripemd160_context *ctx )
{
- memset( ctx, 0, sizeof( ripemd160_context ) );
+ memset( ctx, 0, sizeof( mbedtls_ripemd160_context ) );
}
-void ripemd160_free( ripemd160_context *ctx )
+void mbedtls_ripemd160_free( mbedtls_ripemd160_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( ripemd160_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_ripemd160_context ) );
}
/*
* RIPEMD-160 context setup
*/
-void ripemd160_starts( ripemd160_context *ctx )
+void mbedtls_ripemd160_starts( mbedtls_ripemd160_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -107,11 +107,11 @@
ctx->state[4] = 0xC3D2E1F0;
}
-#if !defined(POLARSSL_RIPEMD160_PROCESS_ALT)
+#if !defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
/*
* Process one block
*/
-void ripemd160_process( ripemd160_context *ctx, const unsigned char data[64] )
+void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, const unsigned char data[64] )
{
uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
@@ -287,12 +287,12 @@
ctx->state[4] = ctx->state[0] + B + Cp;
ctx->state[0] = C;
}
-#endif /* !POLARSSL_RIPEMD160_PROCESS_ALT */
+#endif /* !MBEDTLS_RIPEMD160_PROCESS_ALT */
/*
* RIPEMD-160 process buffer
*/
-void ripemd160_update( ripemd160_context *ctx,
+void mbedtls_ripemd160_update( mbedtls_ripemd160_context *ctx,
const unsigned char *input, size_t ilen )
{
size_t fill;
@@ -313,7 +313,7 @@
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
- ripemd160_process( ctx, ctx->buffer );
+ mbedtls_ripemd160_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -321,7 +321,7 @@
while( ilen >= 64 )
{
- ripemd160_process( ctx, input );
+ mbedtls_ripemd160_process( ctx, input );
input += 64;
ilen -= 64;
}
@@ -343,7 +343,7 @@
/*
* RIPEMD-160 final digest
*/
-void ripemd160_finish( ripemd160_context *ctx, unsigned char output[20] )
+void mbedtls_ripemd160_finish( mbedtls_ripemd160_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
@@ -359,8 +359,8 @@
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
- ripemd160_update( ctx, ripemd160_padding, padn );
- ripemd160_update( ctx, msglen, 8 );
+ mbedtls_ripemd160_update( ctx, ripemd160_padding, padn );
+ mbedtls_ripemd160_update( ctx, msglen, 8 );
PUT_UINT32_LE( ctx->state[0], output, 0 );
PUT_UINT32_LE( ctx->state[1], output, 4 );
@@ -372,56 +372,56 @@
/*
* output = RIPEMD-160( input buffer )
*/
-void ripemd160( const unsigned char *input, size_t ilen,
+void mbedtls_ripemd160( const unsigned char *input, size_t ilen,
unsigned char output[20] )
{
- ripemd160_context ctx;
+ mbedtls_ripemd160_context ctx;
- ripemd160_init( &ctx );
- ripemd160_starts( &ctx );
- ripemd160_update( &ctx, input, ilen );
- ripemd160_finish( &ctx, output );
- ripemd160_free( &ctx );
+ mbedtls_ripemd160_init( &ctx );
+ mbedtls_ripemd160_starts( &ctx );
+ mbedtls_ripemd160_update( &ctx, input, ilen );
+ mbedtls_ripemd160_finish( &ctx, output );
+ mbedtls_ripemd160_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = RIPEMD-160( file contents )
*/
-int ripemd160_file( const char *path, unsigned char output[20] )
+int mbedtls_ripemd160_file( const char *path, unsigned char output[20] )
{
FILE *f;
size_t n;
- ripemd160_context ctx;
+ mbedtls_ripemd160_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_RIPEMD160_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_RIPEMD160_FILE_IO_ERROR );
- ripemd160_init( &ctx );
- ripemd160_starts( &ctx );
+ mbedtls_ripemd160_init( &ctx );
+ mbedtls_ripemd160_starts( &ctx );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- ripemd160_update( &ctx, buf, n );
+ mbedtls_ripemd160_update( &ctx, buf, n );
- ripemd160_finish( &ctx, output );
- ripemd160_free( &ctx );
+ mbedtls_ripemd160_finish( &ctx, output );
+ mbedtls_ripemd160_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_RIPEMD160_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_RIPEMD160_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* Test vectors from the RIPEMD-160 paper and
- * http://homes.esat.kuleuven.be/~bosselae/ripemd160.html#HMAC
+ * http://homes.esat.kuleuven.be/~bosselae/mbedtls_ripemd160.html#HMAC
*/
#define TESTS 8
#define KEYS 2
@@ -461,7 +461,7 @@
/*
* Checkup routine
*/
-int ripemd160_self_test( int verbose )
+int mbedtls_ripemd160_self_test( int verbose )
{
int i;
unsigned char output[20];
@@ -471,27 +471,27 @@
for( i = 0; i < TESTS; i++ )
{
if( verbose != 0 )
- polarssl_printf( " RIPEMD-160 test #%d: ", i + 1 );
+ mbedtls_printf( " RIPEMD-160 test #%d: ", i + 1 );
- ripemd160( (const unsigned char *) ripemd160_test_input[i],
+ mbedtls_ripemd160( (const unsigned char *) ripemd160_test_input[i],
strlen( ripemd160_test_input[i] ),
output );
if( memcmp( output, ripemd160_test_md[i], 20 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_RIPEMD160_C */
+#endif /* MBEDTLS_RIPEMD160_C */
diff --git a/library/rsa.c b/library/rsa.c
index bff6d7d..f6a88fd 100644
--- a/library/rsa.c
+++ b/library/rsa.c
@@ -26,107 +26,107 @@
* http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
#include "mbedtls/rsa.h"
#include "mbedtls/oid.h"
#include <string.h>
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
#include "mbedtls/md.h"
#endif
-#if defined(POLARSSL_PKCS1_V15) && !defined(__OpenBSD__)
+#if defined(MBEDTLS_PKCS1_V15) && !defined(__OpenBSD__)
#include <stdlib.h>
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
+#define mbedtls_printf printf
#endif
/*
* Initialize an RSA context
*/
-void rsa_init( rsa_context *ctx,
+void mbedtls_rsa_init( mbedtls_rsa_context *ctx,
int padding,
int hash_id )
{
- memset( ctx, 0, sizeof( rsa_context ) );
+ memset( ctx, 0, sizeof( mbedtls_rsa_context ) );
- rsa_set_padding( ctx, padding, hash_id );
+ mbedtls_rsa_set_padding( ctx, padding, hash_id );
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_init( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_init( &ctx->mutex );
#endif
}
/*
* Set padding for an existing RSA context
*/
-void rsa_set_padding( rsa_context *ctx, int padding, int hash_id )
+void mbedtls_rsa_set_padding( mbedtls_rsa_context *ctx, int padding, int hash_id )
{
ctx->padding = padding;
ctx->hash_id = hash_id;
}
-#if defined(POLARSSL_GENPRIME)
+#if defined(MBEDTLS_GENPRIME)
/*
* Generate an RSA keypair
*/
-int rsa_gen_key( rsa_context *ctx,
+int mbedtls_rsa_gen_key( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
unsigned int nbits, int exponent )
{
int ret;
- mpi P1, Q1, H, G;
+ mbedtls_mpi P1, Q1, H, G;
if( f_rng == NULL || nbits < 128 || exponent < 3 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
+ mbedtls_mpi_init( &P1 ); mbedtls_mpi_init( &Q1 ); mbedtls_mpi_init( &H ); mbedtls_mpi_init( &G );
/*
* find primes P and Q with Q < P so that:
* GCD( E, (P-1)*(Q-1) ) == 1
*/
- MPI_CHK( mpi_lset( &ctx->E, exponent ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &ctx->E, exponent ) );
do
{
- MPI_CHK( mpi_gen_prime( &ctx->P, ( nbits + 1 ) >> 1, 0,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gen_prime( &ctx->P, ( nbits + 1 ) >> 1, 0,
f_rng, p_rng ) );
- MPI_CHK( mpi_gen_prime( &ctx->Q, ( nbits + 1 ) >> 1, 0,
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gen_prime( &ctx->Q, ( nbits + 1 ) >> 1, 0,
f_rng, p_rng ) );
- if( mpi_cmp_mpi( &ctx->P, &ctx->Q ) < 0 )
- mpi_swap( &ctx->P, &ctx->Q );
+ if( mbedtls_mpi_cmp_mpi( &ctx->P, &ctx->Q ) < 0 )
+ mbedtls_mpi_swap( &ctx->P, &ctx->Q );
- if( mpi_cmp_mpi( &ctx->P, &ctx->Q ) == 0 )
+ if( mbedtls_mpi_cmp_mpi( &ctx->P, &ctx->Q ) == 0 )
continue;
- MPI_CHK( mpi_mul_mpi( &ctx->N, &ctx->P, &ctx->Q ) );
- if( mpi_msb( &ctx->N ) != nbits )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->N, &ctx->P, &ctx->Q ) );
+ if( mbedtls_mpi_msb( &ctx->N ) != nbits )
continue;
- MPI_CHK( mpi_sub_int( &P1, &ctx->P, 1 ) );
- MPI_CHK( mpi_sub_int( &Q1, &ctx->Q, 1 ) );
- MPI_CHK( mpi_mul_mpi( &H, &P1, &Q1 ) );
- MPI_CHK( mpi_gcd( &G, &ctx->E, &H ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &P1, &ctx->P, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &Q1, &ctx->Q, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &H, &P1, &Q1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, &ctx->E, &H ) );
}
- while( mpi_cmp_int( &G, 1 ) != 0 );
+ while( mbedtls_mpi_cmp_int( &G, 1 ) != 0 );
/*
* D = E^-1 mod ((P-1)*(Q-1))
@@ -134,47 +134,47 @@
* DQ = D mod (Q - 1)
* QP = Q^-1 mod P
*/
- MPI_CHK( mpi_inv_mod( &ctx->D , &ctx->E, &H ) );
- MPI_CHK( mpi_mod_mpi( &ctx->DP, &ctx->D, &P1 ) );
- MPI_CHK( mpi_mod_mpi( &ctx->DQ, &ctx->D, &Q1 ) );
- MPI_CHK( mpi_inv_mod( &ctx->QP, &ctx->Q, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->D , &ctx->E, &H ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->DP, &ctx->D, &P1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->DQ, &ctx->D, &Q1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->QP, &ctx->Q, &ctx->P ) );
- ctx->len = ( mpi_msb( &ctx->N ) + 7 ) >> 3;
+ ctx->len = ( mbedtls_mpi_msb( &ctx->N ) + 7 ) >> 3;
cleanup:
- mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
+ mbedtls_mpi_free( &P1 ); mbedtls_mpi_free( &Q1 ); mbedtls_mpi_free( &H ); mbedtls_mpi_free( &G );
if( ret != 0 )
{
- rsa_free( ctx );
- return( POLARSSL_ERR_RSA_KEY_GEN_FAILED + ret );
+ mbedtls_rsa_free( ctx );
+ return( MBEDTLS_ERR_RSA_KEY_GEN_FAILED + ret );
}
return( 0 );
}
-#endif /* POLARSSL_GENPRIME */
+#endif /* MBEDTLS_GENPRIME */
/*
* Check a public RSA key
*/
-int rsa_check_pubkey( const rsa_context *ctx )
+int mbedtls_rsa_check_pubkey( const mbedtls_rsa_context *ctx )
{
if( !ctx->N.p || !ctx->E.p )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
if( ( ctx->N.p[0] & 1 ) == 0 ||
( ctx->E.p[0] & 1 ) == 0 )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
- if( mpi_msb( &ctx->N ) < 128 ||
- mpi_msb( &ctx->N ) > POLARSSL_MPI_MAX_BITS )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ if( mbedtls_mpi_msb( &ctx->N ) < 128 ||
+ mbedtls_mpi_msb( &ctx->N ) > MBEDTLS_MPI_MAX_BITS )
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
- if( mpi_msb( &ctx->E ) < 2 ||
- mpi_cmp_mpi( &ctx->E, &ctx->N ) >= 0 )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ if( mbedtls_mpi_msb( &ctx->E ) < 2 ||
+ mbedtls_mpi_cmp_mpi( &ctx->E, &ctx->N ) >= 0 )
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
return( 0 );
}
@@ -182,61 +182,61 @@
/*
* Check a private RSA key
*/
-int rsa_check_privkey( const rsa_context *ctx )
+int mbedtls_rsa_check_privkey( const mbedtls_rsa_context *ctx )
{
int ret;
- mpi PQ, DE, P1, Q1, H, I, G, G2, L1, L2, DP, DQ, QP;
+ mbedtls_mpi PQ, DE, P1, Q1, H, I, G, G2, L1, L2, DP, DQ, QP;
- if( ( ret = rsa_check_pubkey( ctx ) ) != 0 )
+ if( ( ret = mbedtls_rsa_check_pubkey( ctx ) ) != 0 )
return( ret );
if( !ctx->P.p || !ctx->Q.p || !ctx->D.p )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
- mpi_init( &PQ ); mpi_init( &DE ); mpi_init( &P1 ); mpi_init( &Q1 );
- mpi_init( &H ); mpi_init( &I ); mpi_init( &G ); mpi_init( &G2 );
- mpi_init( &L1 ); mpi_init( &L2 ); mpi_init( &DP ); mpi_init( &DQ );
- mpi_init( &QP );
+ mbedtls_mpi_init( &PQ ); mbedtls_mpi_init( &DE ); mbedtls_mpi_init( &P1 ); mbedtls_mpi_init( &Q1 );
+ mbedtls_mpi_init( &H ); mbedtls_mpi_init( &I ); mbedtls_mpi_init( &G ); mbedtls_mpi_init( &G2 );
+ mbedtls_mpi_init( &L1 ); mbedtls_mpi_init( &L2 ); mbedtls_mpi_init( &DP ); mbedtls_mpi_init( &DQ );
+ mbedtls_mpi_init( &QP );
- MPI_CHK( mpi_mul_mpi( &PQ, &ctx->P, &ctx->Q ) );
- MPI_CHK( mpi_mul_mpi( &DE, &ctx->D, &ctx->E ) );
- MPI_CHK( mpi_sub_int( &P1, &ctx->P, 1 ) );
- MPI_CHK( mpi_sub_int( &Q1, &ctx->Q, 1 ) );
- MPI_CHK( mpi_mul_mpi( &H, &P1, &Q1 ) );
- MPI_CHK( mpi_gcd( &G, &ctx->E, &H ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &PQ, &ctx->P, &ctx->Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &DE, &ctx->D, &ctx->E ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &P1, &ctx->P, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &Q1, &ctx->Q, 1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &H, &P1, &Q1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, &ctx->E, &H ) );
- MPI_CHK( mpi_gcd( &G2, &P1, &Q1 ) );
- MPI_CHK( mpi_div_mpi( &L1, &L2, &H, &G2 ) );
- MPI_CHK( mpi_mod_mpi( &I, &DE, &L1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G2, &P1, &Q1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &L1, &L2, &H, &G2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &I, &DE, &L1 ) );
- MPI_CHK( mpi_mod_mpi( &DP, &ctx->D, &P1 ) );
- MPI_CHK( mpi_mod_mpi( &DQ, &ctx->D, &Q1 ) );
- MPI_CHK( mpi_inv_mod( &QP, &ctx->Q, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &DP, &ctx->D, &P1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &DQ, &ctx->D, &Q1 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &QP, &ctx->Q, &ctx->P ) );
/*
* Check for a valid PKCS1v2 private key
*/
- if( mpi_cmp_mpi( &PQ, &ctx->N ) != 0 ||
- mpi_cmp_mpi( &DP, &ctx->DP ) != 0 ||
- mpi_cmp_mpi( &DQ, &ctx->DQ ) != 0 ||
- mpi_cmp_mpi( &QP, &ctx->QP ) != 0 ||
- mpi_cmp_int( &L2, 0 ) != 0 ||
- mpi_cmp_int( &I, 1 ) != 0 ||
- mpi_cmp_int( &G, 1 ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &PQ, &ctx->N ) != 0 ||
+ mbedtls_mpi_cmp_mpi( &DP, &ctx->DP ) != 0 ||
+ mbedtls_mpi_cmp_mpi( &DQ, &ctx->DQ ) != 0 ||
+ mbedtls_mpi_cmp_mpi( &QP, &ctx->QP ) != 0 ||
+ mbedtls_mpi_cmp_int( &L2, 0 ) != 0 ||
+ mbedtls_mpi_cmp_int( &I, 1 ) != 0 ||
+ mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
{
- ret = POLARSSL_ERR_RSA_KEY_CHECK_FAILED;
+ ret = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
}
cleanup:
- mpi_free( &PQ ); mpi_free( &DE ); mpi_free( &P1 ); mpi_free( &Q1 );
- mpi_free( &H ); mpi_free( &I ); mpi_free( &G ); mpi_free( &G2 );
- mpi_free( &L1 ); mpi_free( &L2 ); mpi_free( &DP ); mpi_free( &DQ );
- mpi_free( &QP );
+ mbedtls_mpi_free( &PQ ); mbedtls_mpi_free( &DE ); mbedtls_mpi_free( &P1 ); mbedtls_mpi_free( &Q1 );
+ mbedtls_mpi_free( &H ); mbedtls_mpi_free( &I ); mbedtls_mpi_free( &G ); mbedtls_mpi_free( &G2 );
+ mbedtls_mpi_free( &L1 ); mbedtls_mpi_free( &L2 ); mbedtls_mpi_free( &DP ); mbedtls_mpi_free( &DQ );
+ mbedtls_mpi_free( &QP );
- if( ret == POLARSSL_ERR_RSA_KEY_CHECK_FAILED )
+ if( ret == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED )
return( ret );
if( ret != 0 )
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED + ret );
return( 0 );
}
@@ -244,18 +244,18 @@
/*
* Check if contexts holding a public and private key match
*/
-int rsa_check_pub_priv( const rsa_context *pub, const rsa_context *prv )
+int mbedtls_rsa_check_pub_priv( const mbedtls_rsa_context *pub, const mbedtls_rsa_context *prv )
{
- if( rsa_check_pubkey( pub ) != 0 ||
- rsa_check_privkey( prv ) != 0 )
+ if( mbedtls_rsa_check_pubkey( pub ) != 0 ||
+ mbedtls_rsa_check_privkey( prv ) != 0 )
{
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
}
- if( mpi_cmp_mpi( &pub->N, &prv->N ) != 0 ||
- mpi_cmp_mpi( &pub->E, &prv->E ) != 0 )
+ if( mbedtls_mpi_cmp_mpi( &pub->N, &prv->N ) != 0 ||
+ mbedtls_mpi_cmp_mpi( &pub->E, &prv->E ) != 0 )
{
- return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
+ return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
}
return( 0 );
@@ -264,41 +264,41 @@
/*
* Do an RSA public key operation
*/
-int rsa_public( rsa_context *ctx,
+int mbedtls_rsa_public( mbedtls_rsa_context *ctx,
const unsigned char *input,
unsigned char *output )
{
int ret;
size_t olen;
- mpi T;
+ mbedtls_mpi T;
- mpi_init( &T );
+ mbedtls_mpi_init( &T );
- MPI_CHK( mpi_read_binary( &T, input, ctx->len ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &T, input, ctx->len ) );
- if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
+ if( mbedtls_mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
{
- mpi_free( &T );
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ mbedtls_mpi_free( &T );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_lock( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_lock( &ctx->mutex );
#endif
olen = ctx->len;
- MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) );
- MPI_CHK( mpi_write_binary( &T, output, olen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &T, output, olen ) );
cleanup:
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_unlock( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_unlock( &ctx->mutex );
#endif
- mpi_free( &T );
+ mbedtls_mpi_free( &T );
if( ret != 0 )
- return( POLARSSL_ERR_RSA_PUBLIC_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_PUBLIC_FAILED + ret );
return( 0 );
}
@@ -309,22 +309,22 @@
* DSS, and other systems. In : Advances in Cryptology-CRYPTO'96. Springer
* Berlin Heidelberg, 1996. p. 104-113.
*/
-static int rsa_prepare_blinding( rsa_context *ctx, mpi *Vi, mpi *Vf,
+static int rsa_prepare_blinding( mbedtls_rsa_context *ctx, mbedtls_mpi *Vi, mbedtls_mpi *Vf,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret, count = 0;
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_lock( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_lock( &ctx->mutex );
#endif
if( ctx->Vf.p != NULL )
{
/* We already have blinding values, just update them by squaring */
- MPI_CHK( mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) );
- MPI_CHK( mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->N ) );
- MPI_CHK( mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) );
- MPI_CHK( mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vi, &ctx->Vi, &ctx->Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vi, &ctx->Vi, &ctx->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ctx->Vf, &ctx->Vf, &ctx->Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &ctx->Vf, &ctx->Vf, &ctx->N ) );
goto done;
}
@@ -332,26 +332,26 @@
/* Unblinding value: Vf = random number, invertible mod N */
do {
if( count++ > 10 )
- return( POLARSSL_ERR_RSA_RNG_FAILED );
+ return( MBEDTLS_ERR_RSA_RNG_FAILED );
- MPI_CHK( mpi_fill_random( &ctx->Vf, ctx->len - 1, f_rng, p_rng ) );
- MPI_CHK( mpi_gcd( &ctx->Vi, &ctx->Vf, &ctx->N ) );
- } while( mpi_cmp_int( &ctx->Vi, 1 ) != 0 );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &ctx->Vf, ctx->len - 1, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &ctx->Vi, &ctx->Vf, &ctx->N ) );
+ } while( mbedtls_mpi_cmp_int( &ctx->Vi, 1 ) != 0 );
/* Blinding value: Vi = Vf^(-e) mod N */
- MPI_CHK( mpi_inv_mod( &ctx->Vi, &ctx->Vf, &ctx->N ) );
- MPI_CHK( mpi_exp_mod( &ctx->Vi, &ctx->Vi, &ctx->E, &ctx->N, &ctx->RN ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &ctx->Vi, &ctx->Vf, &ctx->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &ctx->Vi, &ctx->Vi, &ctx->E, &ctx->N, &ctx->RN ) );
done:
if( Vi != &ctx->Vi )
{
- MPI_CHK( mpi_copy( Vi, &ctx->Vi ) );
- MPI_CHK( mpi_copy( Vf, &ctx->Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Vi, &ctx->Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Vf, &ctx->Vf ) );
}
cleanup:
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_unlock( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_unlock( &ctx->mutex );
#endif
return( ret );
@@ -360,7 +360,7 @@
/*
* Do an RSA private key operation
*/
-int rsa_private( rsa_context *ctx,
+int mbedtls_rsa_private( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
const unsigned char *input,
@@ -368,18 +368,18 @@
{
int ret;
size_t olen;
- mpi T, T1, T2;
- mpi *Vi, *Vf;
+ mbedtls_mpi T, T1, T2;
+ mbedtls_mpi *Vi, *Vf;
/*
* When using the Chinese Remainder Theorem, we use blinding values.
* Without threading, we just read them directly from the context,
* otherwise we make a local copy in order to reduce locking contention.
*/
-#if defined(POLARSSL_THREADING_C)
- mpi Vi_copy, Vf_copy;
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mpi Vi_copy, Vf_copy;
- mpi_init( &Vi_copy ); mpi_init( &Vf_copy );
+ mbedtls_mpi_init( &Vi_copy ); mbedtls_mpi_init( &Vf_copy );
Vi = &Vi_copy;
Vf = &Vf_copy;
#else
@@ -387,13 +387,13 @@
Vf = &ctx->Vf;
#endif
- mpi_init( &T ); mpi_init( &T1 ); mpi_init( &T2 );
+ mbedtls_mpi_init( &T ); mbedtls_mpi_init( &T1 ); mbedtls_mpi_init( &T2 );
- MPI_CHK( mpi_read_binary( &T, input, ctx->len ) );
- if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &T, input, ctx->len ) );
+ if( mbedtls_mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
{
- mpi_free( &T );
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ mbedtls_mpi_free( &T );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
}
if( f_rng != NULL )
@@ -402,17 +402,17 @@
* Blinding
* T = T * Vi mod N
*/
- MPI_CHK( rsa_prepare_blinding( ctx, Vi, Vf, f_rng, p_rng ) );
- MPI_CHK( mpi_mul_mpi( &T, &T, Vi ) );
- MPI_CHK( mpi_mod_mpi( &T, &T, &ctx->N ) );
+ MBEDTLS_MPI_CHK( rsa_prepare_blinding( ctx, Vi, Vf, f_rng, p_rng ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &T, Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &T, &ctx->N ) );
}
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_lock( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_lock( &ctx->mutex );
#endif
-#if defined(POLARSSL_RSA_NO_CRT)
- MPI_CHK( mpi_exp_mod( &T, &T, &ctx->D, &ctx->N, &ctx->RN ) );
+#if defined(MBEDTLS_RSA_NO_CRT)
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T, &T, &ctx->D, &ctx->N, &ctx->RN ) );
#else
/*
* faster decryption using the CRT
@@ -420,22 +420,22 @@
* T1 = input ^ dP mod P
* T2 = input ^ dQ mod Q
*/
- MPI_CHK( mpi_exp_mod( &T1, &T, &ctx->DP, &ctx->P, &ctx->RP ) );
- MPI_CHK( mpi_exp_mod( &T2, &T, &ctx->DQ, &ctx->Q, &ctx->RQ ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T1, &T, &ctx->DP, &ctx->P, &ctx->RP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &T2, &T, &ctx->DQ, &ctx->Q, &ctx->RQ ) );
/*
* T = (T1 - T2) * (Q^-1 mod P) mod P
*/
- MPI_CHK( mpi_sub_mpi( &T, &T1, &T2 ) );
- MPI_CHK( mpi_mul_mpi( &T1, &T, &ctx->QP ) );
- MPI_CHK( mpi_mod_mpi( &T, &T1, &ctx->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T, &T1, &T2 ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T, &ctx->QP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &T1, &ctx->P ) );
/*
* T = T2 + T * Q
*/
- MPI_CHK( mpi_mul_mpi( &T1, &T, &ctx->Q ) );
- MPI_CHK( mpi_add_mpi( &T, &T2, &T1 ) );
-#endif /* POLARSSL_RSA_NO_CRT */
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T, &ctx->Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &T, &T2, &T1 ) );
+#endif /* MBEDTLS_RSA_NO_CRT */
if( f_rng != NULL )
{
@@ -443,27 +443,27 @@
* Unblind
* T = T * Vf mod N
*/
- MPI_CHK( mpi_mul_mpi( &T, &T, Vf ) );
- MPI_CHK( mpi_mod_mpi( &T, &T, &ctx->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &T, Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &T, &T, &ctx->N ) );
}
olen = ctx->len;
- MPI_CHK( mpi_write_binary( &T, output, olen ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &T, output, olen ) );
cleanup:
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_unlock( &ctx->mutex );
- mpi_free( &Vi_copy ); mpi_free( &Vf_copy );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_unlock( &ctx->mutex );
+ mbedtls_mpi_free( &Vi_copy ); mbedtls_mpi_free( &Vf_copy );
#endif
- mpi_free( &T ); mpi_free( &T1 ); mpi_free( &T2 );
+ mbedtls_mpi_free( &T ); mbedtls_mpi_free( &T1 ); mbedtls_mpi_free( &T2 );
if( ret != 0 )
- return( POLARSSL_ERR_RSA_PRIVATE_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_PRIVATE_FAILED + ret );
return( 0 );
}
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
/**
* Generate and apply the MGF1 operation (from PKCS#1 v2.1) to a buffer.
*
@@ -474,18 +474,18 @@
* \param md_ctx message digest context to use
*/
static void mgf_mask( unsigned char *dst, size_t dlen, unsigned char *src,
- size_t slen, md_context_t *md_ctx )
+ size_t slen, mbedtls_md_context_t *md_ctx )
{
- unsigned char mask[POLARSSL_MD_MAX_SIZE];
+ unsigned char mask[MBEDTLS_MD_MAX_SIZE];
unsigned char counter[4];
unsigned char *p;
unsigned int hlen;
size_t i, use_len;
- memset( mask, 0, POLARSSL_MD_MAX_SIZE );
+ memset( mask, 0, MBEDTLS_MD_MAX_SIZE );
memset( counter, 0, 4 );
- hlen = md_get_size( md_ctx->md_info );
+ hlen = mbedtls_md_get_size( md_ctx->md_info );
// Generate and apply dbMask
//
@@ -497,10 +497,10 @@
if( dlen < hlen )
use_len = dlen;
- md_starts( md_ctx );
- md_update( md_ctx, src, slen );
- md_update( md_ctx, counter, 4 );
- md_finish( md_ctx, mask );
+ mbedtls_md_starts( md_ctx );
+ mbedtls_md_update( md_ctx, src, slen );
+ mbedtls_md_update( md_ctx, counter, 4 );
+ mbedtls_md_finish( md_ctx, mask );
for( i = 0; i < use_len; ++i )
*p++ ^= mask[i];
@@ -510,13 +510,13 @@
dlen -= use_len;
}
}
-#endif /* POLARSSL_PKCS1_V21 */
+#endif /* MBEDTLS_PKCS1_V21 */
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
/*
* Implementation of the PKCS#1 v2.1 RSAES-OAEP-ENCRYPT function
*/
-int rsa_rsaes_oaep_encrypt( rsa_context *ctx,
+int mbedtls_rsa_rsaes_oaep_encrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
@@ -529,24 +529,24 @@
int ret;
unsigned char *p = output;
unsigned int hlen;
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
if( f_rng == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- md_info = md_info_from_type( (md_type_t) ctx->hash_id );
+ md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
- hlen = md_get_size( md_info );
+ hlen = mbedtls_md_get_size( md_info );
if( olen < ilen + 2 * hlen + 2 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
memset( output, 0, olen );
@@ -555,20 +555,20 @@
// Generate a random octet string seed
//
if( ( ret = f_rng( p_rng, p, hlen ) ) != 0 )
- return( POLARSSL_ERR_RSA_RNG_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_RNG_FAILED + ret );
p += hlen;
// Construct DB
//
- md( md_info, label, label_len, p );
+ mbedtls_md( md_info, label, label_len, p );
p += hlen;
p += olen - 2 * hlen - 2 - ilen;
*p++ = 1;
memcpy( p, input, ilen );
- md_init( &md_ctx );
- md_setup( &md_ctx, md_info, 0 );
+ mbedtls_md_init( &md_ctx );
+ mbedtls_md_setup( &md_ctx, md_info, 0 );
// maskedDB: Apply dbMask to DB
//
@@ -580,19 +580,19 @@
mgf_mask( output + 1, hlen, output + hlen + 1, olen - hlen - 1,
&md_ctx );
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
- return( ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, output, output )
- : rsa_private( ctx, f_rng, p_rng, output, output ) );
+ return( ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, output, output )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, output, output ) );
}
-#endif /* POLARSSL_PKCS1_V21 */
+#endif /* MBEDTLS_PKCS1_V21 */
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
/*
* Implementation of the PKCS#1 v2.1 RSAES-PKCS1-V1_5-ENCRYPT function
*/
-int rsa_rsaes_pkcs1_v15_encrypt( rsa_context *ctx,
+int mbedtls_rsa_rsaes_pkcs1_v15_encrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t ilen,
@@ -603,23 +603,23 @@
int ret;
unsigned char *p = output;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V15 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
if( f_rng == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
if( olen < ilen + 11 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
nb_pad = olen - 3 - ilen;
*p++ = 0;
- if( mode == RSA_PUBLIC )
+ if( mode == MBEDTLS_RSA_PUBLIC )
{
- *p++ = RSA_CRYPT;
+ *p++ = MBEDTLS_RSA_CRYPT;
while( nb_pad-- > 0 )
{
@@ -632,14 +632,14 @@
// Check if RNG failed to generate data
//
if( rng_dl == 0 || ret != 0 )
- return( POLARSSL_ERR_RSA_RNG_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_RNG_FAILED + ret );
p++;
}
}
else
{
- *p++ = RSA_SIGN;
+ *p++ = MBEDTLS_RSA_SIGN;
while( nb_pad-- > 0 )
*p++ = 0xFF;
@@ -648,16 +648,16 @@
*p++ = 0;
memcpy( p, input, ilen );
- return( ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, output, output )
- : rsa_private( ctx, f_rng, p_rng, output, output ) );
+ return( ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, output, output )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, output, output ) );
}
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
/*
* Add the message padding, then do an RSA operation
*/
-int rsa_pkcs1_encrypt( rsa_context *ctx,
+int mbedtls_rsa_pkcs1_encrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t ilen,
@@ -666,28 +666,28 @@
{
switch( ctx->padding )
{
-#if defined(POLARSSL_PKCS1_V15)
- case RSA_PKCS_V15:
- return rsa_rsaes_pkcs1_v15_encrypt( ctx, f_rng, p_rng, mode, ilen,
+#if defined(MBEDTLS_PKCS1_V15)
+ case MBEDTLS_RSA_PKCS_V15:
+ return mbedtls_rsa_rsaes_pkcs1_v15_encrypt( ctx, f_rng, p_rng, mode, ilen,
input, output );
#endif
-#if defined(POLARSSL_PKCS1_V21)
- case RSA_PKCS_V21:
- return rsa_rsaes_oaep_encrypt( ctx, f_rng, p_rng, mode, NULL, 0,
+#if defined(MBEDTLS_PKCS1_V21)
+ case MBEDTLS_RSA_PKCS_V21:
+ return mbedtls_rsa_rsaes_oaep_encrypt( ctx, f_rng, p_rng, mode, NULL, 0,
ilen, input, output );
#endif
default:
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
}
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
/*
* Implementation of the PKCS#1 v2.1 RSAES-OAEP-DECRYPT function
*/
-int rsa_rsaes_oaep_decrypt( rsa_context *ctx,
+int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
@@ -700,33 +700,33 @@
int ret;
size_t ilen, i, pad_len;
unsigned char *p, bad, pad_done;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE];
- unsigned char lhash[POLARSSL_MD_MAX_SIZE];
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
+ unsigned char lhash[MBEDTLS_MD_MAX_SIZE];
unsigned int hlen;
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
/*
* Parameters sanity checks
*/
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ilen = ctx->len;
if( ilen < 16 || ilen > sizeof( buf ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- md_info = md_info_from_type( (md_type_t) ctx->hash_id );
+ md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
/*
* RSA operation
*/
- ret = ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, input, buf )
- : rsa_private( ctx, f_rng, p_rng, input, buf );
+ ret = ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, input, buf )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
if( ret != 0 )
return( ret );
@@ -734,13 +734,13 @@
/*
* Unmask data and generate lHash
*/
- hlen = md_get_size( md_info );
+ hlen = mbedtls_md_get_size( md_info );
- md_init( &md_ctx );
- md_setup( &md_ctx, md_info, 0 );
+ mbedtls_md_init( &md_ctx );
+ mbedtls_md_setup( &md_ctx, md_info, 0 );
/* Generate lHash */
- md( md_info, label, label_len, lhash );
+ mbedtls_md( md_info, label, label_len, lhash );
/* seed: Apply seedMask to maskedSeed */
mgf_mask( buf + 1, hlen, buf + hlen + 1, ilen - hlen - 1,
@@ -750,7 +750,7 @@
mgf_mask( buf + hlen + 1, ilen - hlen - 1, buf + 1, hlen,
&md_ctx );
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
/*
* Check contents, in "constant-time"
@@ -786,23 +786,23 @@
* the different error conditions.
*/
if( bad != 0 )
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
if( ilen - ( p - buf ) > output_max_len )
- return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
+ return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
*olen = ilen - (p - buf);
memcpy( output, p, *olen );
return( 0 );
}
-#endif /* POLARSSL_PKCS1_V21 */
+#endif /* MBEDTLS_PKCS1_V21 */
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
/*
* Implementation of the PKCS#1 v2.1 RSAES-PKCS1-V1_5-DECRYPT function
*/
-int rsa_rsaes_pkcs1_v15_decrypt( rsa_context *ctx,
+int mbedtls_rsa_rsaes_pkcs1_v15_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
@@ -813,19 +813,19 @@
int ret;
size_t ilen, pad_count = 0, i;
unsigned char *p, bad, pad_done = 0;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE];
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V15 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ilen = ctx->len;
if( ilen < 16 || ilen > sizeof( buf ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- ret = ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, input, buf )
- : rsa_private( ctx, f_rng, p_rng, input, buf );
+ ret = ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, input, buf )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
if( ret != 0 )
return( ret );
@@ -839,9 +839,9 @@
bad |= *p++; /* First byte must be 0 */
/* This test does not depend on secret data */
- if( mode == RSA_PRIVATE )
+ if( mode == MBEDTLS_RSA_PRIVATE )
{
- bad |= *p++ ^ RSA_CRYPT;
+ bad |= *p++ ^ MBEDTLS_RSA_CRYPT;
/* Get padding len, but always read till end of buffer
* (minus one, for the 00 byte) */
@@ -856,7 +856,7 @@
}
else
{
- bad |= *p++ ^ RSA_SIGN;
+ bad |= *p++ ^ MBEDTLS_RSA_SIGN;
/* Get padding len, but always read till end of buffer
* (minus one, for the 00 byte) */
@@ -871,22 +871,22 @@
}
if( bad )
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
if( ilen - ( p - buf ) > output_max_len )
- return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
+ return( MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE );
*olen = ilen - (p - buf);
memcpy( output, p, *olen );
return( 0 );
}
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
/*
* Do an RSA operation, then remove the message padding
*/
-int rsa_pkcs1_decrypt( rsa_context *ctx,
+int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
@@ -896,100 +896,100 @@
{
switch( ctx->padding )
{
-#if defined(POLARSSL_PKCS1_V15)
- case RSA_PKCS_V15:
- return rsa_rsaes_pkcs1_v15_decrypt( ctx, f_rng, p_rng, mode, olen,
+#if defined(MBEDTLS_PKCS1_V15)
+ case MBEDTLS_RSA_PKCS_V15:
+ return mbedtls_rsa_rsaes_pkcs1_v15_decrypt( ctx, f_rng, p_rng, mode, olen,
input, output, output_max_len );
#endif
-#if defined(POLARSSL_PKCS1_V21)
- case RSA_PKCS_V21:
- return rsa_rsaes_oaep_decrypt( ctx, f_rng, p_rng, mode, NULL, 0,
+#if defined(MBEDTLS_PKCS1_V21)
+ case MBEDTLS_RSA_PKCS_V21:
+ return mbedtls_rsa_rsaes_oaep_decrypt( ctx, f_rng, p_rng, mode, NULL, 0,
olen, input, output,
output_max_len );
#endif
default:
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
}
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
/*
* Implementation of the PKCS#1 v2.1 RSASSA-PSS-SIGN function
*/
-int rsa_rsassa_pss_sign( rsa_context *ctx,
+int mbedtls_rsa_rsassa_pss_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
{
size_t olen;
unsigned char *p = sig;
- unsigned char salt[POLARSSL_MD_MAX_SIZE];
+ unsigned char salt[MBEDTLS_MD_MAX_SIZE];
unsigned int slen, hlen, offset = 0;
int ret;
size_t msb;
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
if( f_rng == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
- if( md_alg != POLARSSL_MD_NONE )
+ if( md_alg != MBEDTLS_MD_NONE )
{
// Gather length of hash to sign
//
- md_info = md_info_from_type( md_alg );
+ md_info = mbedtls_md_info_from_type( md_alg );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- hashlen = md_get_size( md_info );
+ hashlen = mbedtls_md_get_size( md_info );
}
- md_info = md_info_from_type( (md_type_t) ctx->hash_id );
+ md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- hlen = md_get_size( md_info );
+ hlen = mbedtls_md_get_size( md_info );
slen = hlen;
if( olen < hlen + slen + 2 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
memset( sig, 0, olen );
// Generate salt of length slen
//
if( ( ret = f_rng( p_rng, salt, slen ) ) != 0 )
- return( POLARSSL_ERR_RSA_RNG_FAILED + ret );
+ return( MBEDTLS_ERR_RSA_RNG_FAILED + ret );
// Note: EMSA-PSS encoding is over the length of N - 1 bits
//
- msb = mpi_msb( &ctx->N ) - 1;
+ msb = mbedtls_mpi_msb( &ctx->N ) - 1;
p += olen - hlen * 2 - 2;
*p++ = 0x01;
memcpy( p, salt, slen );
p += slen;
- md_init( &md_ctx );
- md_setup( &md_ctx, md_info, 0 );
+ mbedtls_md_init( &md_ctx );
+ mbedtls_md_setup( &md_ctx, md_info, 0 );
// Generate H = Hash( M' )
//
- md_starts( &md_ctx );
- md_update( &md_ctx, p, 8 );
- md_update( &md_ctx, hash, hashlen );
- md_update( &md_ctx, salt, slen );
- md_finish( &md_ctx, p );
+ mbedtls_md_starts( &md_ctx );
+ mbedtls_md_update( &md_ctx, p, 8 );
+ mbedtls_md_update( &md_ctx, hash, hashlen );
+ mbedtls_md_update( &md_ctx, salt, slen );
+ mbedtls_md_finish( &md_ctx, p );
// Compensate for boundary condition when applying mask
//
@@ -1000,32 +1000,32 @@
//
mgf_mask( sig + offset, olen - hlen - 1 - offset, p, hlen, &md_ctx );
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
- msb = mpi_msb( &ctx->N ) - 1;
+ msb = mbedtls_mpi_msb( &ctx->N ) - 1;
sig[0] &= 0xFF >> ( olen * 8 - msb );
p += hlen;
*p++ = 0xBC;
- return( ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, sig, sig )
- : rsa_private( ctx, f_rng, p_rng, sig, sig ) );
+ return( ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, sig, sig )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig ) );
}
-#endif /* POLARSSL_PKCS1_V21 */
+#endif /* MBEDTLS_PKCS1_V21 */
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
/*
* Implementation of the PKCS#1 v2.1 RSASSA-PKCS1-V1_5-SIGN function
*/
/*
* Do an RSA operation to sign the message digest
*/
-int rsa_rsassa_pkcs1_v15_sign( rsa_context *ctx,
+int mbedtls_rsa_rsassa_pkcs1_v15_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
@@ -1034,38 +1034,38 @@
unsigned char *p = sig;
const char *oid = NULL;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V15 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
nb_pad = olen - 3;
- if( md_alg != POLARSSL_MD_NONE )
+ if( md_alg != MBEDTLS_MD_NONE )
{
- const md_info_t *md_info = md_info_from_type( md_alg );
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- if( oid_get_oid_by_md( md_alg, &oid, &oid_size ) != 0 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mbedtls_oid_get_oid_by_md( md_alg, &oid, &oid_size ) != 0 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
nb_pad -= 10 + oid_size;
- hashlen = md_get_size( md_info );
+ hashlen = mbedtls_md_get_size( md_info );
}
nb_pad -= hashlen;
if( ( nb_pad < 8 ) || ( nb_pad > olen ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
*p++ = 0;
- *p++ = RSA_SIGN;
+ *p++ = MBEDTLS_RSA_SIGN;
memset( p, 0xFF, nb_pad );
p += nb_pad;
*p++ = 0;
- if( md_alg == POLARSSL_MD_NONE )
+ if( md_alg == MBEDTLS_MD_NONE )
{
memcpy( p, hash, hashlen );
}
@@ -1080,95 +1080,95 @@
*
* Digest ::= OCTET STRING
*/
- *p++ = ASN1_SEQUENCE | ASN1_CONSTRUCTED;
+ *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
*p++ = (unsigned char) ( 0x08 + oid_size + hashlen );
- *p++ = ASN1_SEQUENCE | ASN1_CONSTRUCTED;
+ *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
*p++ = (unsigned char) ( 0x04 + oid_size );
- *p++ = ASN1_OID;
+ *p++ = MBEDTLS_ASN1_OID;
*p++ = oid_size & 0xFF;
memcpy( p, oid, oid_size );
p += oid_size;
- *p++ = ASN1_NULL;
+ *p++ = MBEDTLS_ASN1_NULL;
*p++ = 0x00;
- *p++ = ASN1_OCTET_STRING;
+ *p++ = MBEDTLS_ASN1_OCTET_STRING;
*p++ = hashlen;
memcpy( p, hash, hashlen );
}
- return( ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, sig, sig )
- : rsa_private( ctx, f_rng, p_rng, sig, sig ) );
+ return( ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, sig, sig )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig ) );
}
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
/*
* Do an RSA operation to sign the message digest
*/
-int rsa_pkcs1_sign( rsa_context *ctx,
+int mbedtls_rsa_pkcs1_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
{
switch( ctx->padding )
{
-#if defined(POLARSSL_PKCS1_V15)
- case RSA_PKCS_V15:
- return rsa_rsassa_pkcs1_v15_sign( ctx, f_rng, p_rng, mode, md_alg,
+#if defined(MBEDTLS_PKCS1_V15)
+ case MBEDTLS_RSA_PKCS_V15:
+ return mbedtls_rsa_rsassa_pkcs1_v15_sign( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
-#if defined(POLARSSL_PKCS1_V21)
- case RSA_PKCS_V21:
- return rsa_rsassa_pss_sign( ctx, f_rng, p_rng, mode, md_alg,
+#if defined(MBEDTLS_PKCS1_V21)
+ case MBEDTLS_RSA_PKCS_V21:
+ return mbedtls_rsa_rsassa_pss_sign( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
default:
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
}
-#if defined(POLARSSL_PKCS1_V21)
+#if defined(MBEDTLS_PKCS1_V21)
/*
* Implementation of the PKCS#1 v2.1 RSASSA-PSS-VERIFY function
*/
-int rsa_rsassa_pss_verify_ext( rsa_context *ctx,
+int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
- md_type_t mgf1_hash_id,
+ mbedtls_md_type_t mgf1_hash_id,
int expected_salt_len,
const unsigned char *sig )
{
int ret;
size_t siglen;
unsigned char *p;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE];
- unsigned char result[POLARSSL_MD_MAX_SIZE];
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
+ unsigned char result[MBEDTLS_MD_MAX_SIZE];
unsigned char zeros[8];
unsigned int hlen;
size_t slen, msb;
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
siglen = ctx->len;
if( siglen < 16 || siglen > sizeof( buf ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- ret = ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, sig, buf )
- : rsa_private( ctx, f_rng, p_rng, sig, buf );
+ ret = ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, sig, buf )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, sig, buf );
if( ret != 0 )
return( ret );
@@ -1176,31 +1176,31 @@
p = buf;
if( buf[siglen - 1] != 0xBC )
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
- if( md_alg != POLARSSL_MD_NONE )
+ if( md_alg != MBEDTLS_MD_NONE )
{
// Gather length of hash to sign
//
- md_info = md_info_from_type( md_alg );
+ md_info = mbedtls_md_info_from_type( md_alg );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- hashlen = md_get_size( md_info );
+ hashlen = mbedtls_md_get_size( md_info );
}
- md_info = md_info_from_type( mgf1_hash_id );
+ md_info = mbedtls_md_info_from_type( mgf1_hash_id );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- hlen = md_get_size( md_info );
+ hlen = mbedtls_md_get_size( md_info );
slen = siglen - hlen - 1; /* Currently length of salt + padding */
memset( zeros, 0, 8 );
// Note: EMSA-PSS verification is over the length of N - 1 bits
//
- msb = mpi_msb( &ctx->N ) - 1;
+ msb = mbedtls_mpi_msb( &ctx->N ) - 1;
// Compensate for boundary condition when applying mask
//
@@ -1210,10 +1210,10 @@
siglen -= 1;
}
if( buf[0] >> ( 8 - siglen * 8 + msb ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- md_init( &md_ctx );
- md_setup( &md_ctx, md_info, 0 );
+ mbedtls_md_init( &md_ctx );
+ mbedtls_md_setup( &md_ctx, md_info, 0 );
mgf_mask( p, siglen - hlen - 1, p + siglen - hlen - 1, hlen, &md_ctx );
@@ -1225,69 +1225,69 @@
if( p == buf + siglen ||
*p++ != 0x01 )
{
- md_free( &md_ctx );
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ mbedtls_md_free( &md_ctx );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
/* Actual salt len */
slen -= p - buf;
- if( expected_salt_len != RSA_SALT_LEN_ANY &&
+ if( expected_salt_len != MBEDTLS_RSA_SALT_LEN_ANY &&
slen != (size_t) expected_salt_len )
{
- md_free( &md_ctx );
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ mbedtls_md_free( &md_ctx );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
// Generate H = Hash( M' )
//
- md_starts( &md_ctx );
- md_update( &md_ctx, zeros, 8 );
- md_update( &md_ctx, hash, hashlen );
- md_update( &md_ctx, p, slen );
- md_finish( &md_ctx, result );
+ mbedtls_md_starts( &md_ctx );
+ mbedtls_md_update( &md_ctx, zeros, 8 );
+ mbedtls_md_update( &md_ctx, hash, hashlen );
+ mbedtls_md_update( &md_ctx, p, slen );
+ mbedtls_md_finish( &md_ctx, result );
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
if( memcmp( p + slen, result, hlen ) == 0 )
return( 0 );
else
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
}
/*
* Simplified PKCS#1 v2.1 RSASSA-PSS-VERIFY function
*/
-int rsa_rsassa_pss_verify( rsa_context *ctx,
+int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
const unsigned char *sig )
{
- md_type_t mgf1_hash_id = ( ctx->hash_id != POLARSSL_MD_NONE )
- ? (md_type_t) ctx->hash_id
+ mbedtls_md_type_t mgf1_hash_id = ( ctx->hash_id != MBEDTLS_MD_NONE )
+ ? (mbedtls_md_type_t) ctx->hash_id
: md_alg;
- return( rsa_rsassa_pss_verify_ext( ctx, f_rng, p_rng, mode,
+ return( mbedtls_rsa_rsassa_pss_verify_ext( ctx, f_rng, p_rng, mode,
md_alg, hashlen, hash,
- mgf1_hash_id, RSA_SALT_LEN_ANY,
+ mgf1_hash_id, MBEDTLS_RSA_SALT_LEN_ANY,
sig ) );
}
-#endif /* POLARSSL_PKCS1_V21 */
+#endif /* MBEDTLS_PKCS1_V21 */
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
/*
* Implementation of the PKCS#1 v2.1 RSASSA-PKCS1-v1_5-VERIFY function
*/
-int rsa_rsassa_pkcs1_v15_verify( rsa_context *ctx,
+int mbedtls_rsa_rsassa_pkcs1_v15_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
const unsigned char *sig )
@@ -1295,172 +1295,172 @@
int ret;
size_t len, siglen, asn1_len;
unsigned char *p, *end;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE];
- md_type_t msg_md_alg;
- const md_info_t *md_info;
- asn1_buf oid;
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
+ mbedtls_md_type_t msg_md_alg;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_asn1_buf oid;
- if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V15 )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
siglen = ctx->len;
if( siglen < 16 || siglen > sizeof( buf ) )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
- ret = ( mode == RSA_PUBLIC )
- ? rsa_public( ctx, sig, buf )
- : rsa_private( ctx, f_rng, p_rng, sig, buf );
+ ret = ( mode == MBEDTLS_RSA_PUBLIC )
+ ? mbedtls_rsa_public( ctx, sig, buf )
+ : mbedtls_rsa_private( ctx, f_rng, p_rng, sig, buf );
if( ret != 0 )
return( ret );
p = buf;
- if( *p++ != 0 || *p++ != RSA_SIGN )
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ if( *p++ != 0 || *p++ != MBEDTLS_RSA_SIGN )
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
while( *p != 0 )
{
if( p >= buf + siglen - 1 || *p != 0xFF )
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
p++;
}
p++;
len = siglen - ( p - buf );
- if( len == hashlen && md_alg == POLARSSL_MD_NONE )
+ if( len == hashlen && md_alg == MBEDTLS_MD_NONE )
{
if( memcmp( p, hash, hashlen ) == 0 )
return( 0 );
else
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
}
- md_info = md_info_from_type( md_alg );
+ md_info = mbedtls_md_info_from_type( md_alg );
if( md_info == NULL )
- return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
- hashlen = md_get_size( md_info );
+ return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
+ hashlen = mbedtls_md_get_size( md_info );
end = p + len;
// Parse the ASN.1 structure inside the PKCS#1 v1.5 structure
//
- if( ( ret = asn1_get_tag( &p, end, &asn1_len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &asn1_len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
if( asn1_len + 2 != len )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
- if( ( ret = asn1_get_tag( &p, end, &asn1_len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &asn1_len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
if( asn1_len + 6 + hashlen != len )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
- if( ( ret = asn1_get_tag( &p, end, &oid.len, ASN1_OID ) ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
oid.p = p;
p += oid.len;
- if( oid_get_md_alg( &oid, &msg_md_alg ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( mbedtls_oid_get_md_alg( &oid, &msg_md_alg ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
if( md_alg != msg_md_alg )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
/*
* assume the algorithm parameters must be NULL
*/
- if( ( ret = asn1_get_tag( &p, end, &asn1_len, ASN1_NULL ) ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &asn1_len, MBEDTLS_ASN1_NULL ) ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
- if( ( ret = asn1_get_tag( &p, end, &asn1_len, ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &asn1_len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
if( asn1_len != hashlen )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
if( memcmp( p, hash, hashlen ) != 0 )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
p += hashlen;
if( p != end )
- return( POLARSSL_ERR_RSA_VERIFY_FAILED );
+ return( MBEDTLS_ERR_RSA_VERIFY_FAILED );
return( 0 );
}
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
/*
* Do an RSA operation and check the message digest
*/
-int rsa_pkcs1_verify( rsa_context *ctx,
+int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
- md_type_t md_alg,
+ mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *hash,
const unsigned char *sig )
{
switch( ctx->padding )
{
-#if defined(POLARSSL_PKCS1_V15)
- case RSA_PKCS_V15:
- return rsa_rsassa_pkcs1_v15_verify( ctx, f_rng, p_rng, mode, md_alg,
+#if defined(MBEDTLS_PKCS1_V15)
+ case MBEDTLS_RSA_PKCS_V15:
+ return mbedtls_rsa_rsassa_pkcs1_v15_verify( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
-#if defined(POLARSSL_PKCS1_V21)
- case RSA_PKCS_V21:
- return rsa_rsassa_pss_verify( ctx, f_rng, p_rng, mode, md_alg,
+#if defined(MBEDTLS_PKCS1_V21)
+ case MBEDTLS_RSA_PKCS_V21:
+ return mbedtls_rsa_rsassa_pss_verify( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
default:
- return( POLARSSL_ERR_RSA_INVALID_PADDING );
+ return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
}
/*
* Copy the components of an RSA key
*/
-int rsa_copy( rsa_context *dst, const rsa_context *src )
+int mbedtls_rsa_copy( mbedtls_rsa_context *dst, const mbedtls_rsa_context *src )
{
int ret;
dst->ver = src->ver;
dst->len = src->len;
- MPI_CHK( mpi_copy( &dst->N, &src->N ) );
- MPI_CHK( mpi_copy( &dst->E, &src->E ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->N, &src->N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->E, &src->E ) );
- MPI_CHK( mpi_copy( &dst->D, &src->D ) );
- MPI_CHK( mpi_copy( &dst->P, &src->P ) );
- MPI_CHK( mpi_copy( &dst->Q, &src->Q ) );
- MPI_CHK( mpi_copy( &dst->DP, &src->DP ) );
- MPI_CHK( mpi_copy( &dst->DQ, &src->DQ ) );
- MPI_CHK( mpi_copy( &dst->QP, &src->QP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->D, &src->D ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->P, &src->P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Q, &src->Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->DP, &src->DP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->DQ, &src->DQ ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->QP, &src->QP ) );
- MPI_CHK( mpi_copy( &dst->RN, &src->RN ) );
- MPI_CHK( mpi_copy( &dst->RP, &src->RP ) );
- MPI_CHK( mpi_copy( &dst->RQ, &src->RQ ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RN, &src->RN ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RP, &src->RP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->RQ, &src->RQ ) );
- MPI_CHK( mpi_copy( &dst->Vi, &src->Vi ) );
- MPI_CHK( mpi_copy( &dst->Vf, &src->Vf ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Vi, &src->Vi ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->Vf, &src->Vf ) );
dst->padding = src->padding;
dst->hash_id = src->hash_id;
cleanup:
if( ret != 0 )
- rsa_free( dst );
+ mbedtls_rsa_free( dst );
return( ret );
}
@@ -1468,20 +1468,20 @@
/*
* Free the components of an RSA key
*/
-void rsa_free( rsa_context *ctx )
+void mbedtls_rsa_free( mbedtls_rsa_context *ctx )
{
- mpi_free( &ctx->Vi ); mpi_free( &ctx->Vf );
- mpi_free( &ctx->RQ ); mpi_free( &ctx->RP ); mpi_free( &ctx->RN );
- mpi_free( &ctx->QP ); mpi_free( &ctx->DQ ); mpi_free( &ctx->DP );
- mpi_free( &ctx->Q ); mpi_free( &ctx->P ); mpi_free( &ctx->D );
- mpi_free( &ctx->E ); mpi_free( &ctx->N );
+ mbedtls_mpi_free( &ctx->Vi ); mbedtls_mpi_free( &ctx->Vf );
+ mbedtls_mpi_free( &ctx->RQ ); mbedtls_mpi_free( &ctx->RP ); mbedtls_mpi_free( &ctx->RN );
+ mbedtls_mpi_free( &ctx->QP ); mbedtls_mpi_free( &ctx->DQ ); mbedtls_mpi_free( &ctx->DP );
+ mbedtls_mpi_free( &ctx->Q ); mbedtls_mpi_free( &ctx->P ); mbedtls_mpi_free( &ctx->D );
+ mbedtls_mpi_free( &ctx->E ); mbedtls_mpi_free( &ctx->N );
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_free( &ctx->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_free( &ctx->mutex );
#endif
}
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#include "mbedtls/sha1.h"
@@ -1539,7 +1539,7 @@
#define RSA_PT "\xAA\xBB\xCC\x03\x02\x01\x00\xFF\xFF\xFF\xFF\xFF" \
"\x11\x22\x33\x0A\x0B\x0C\xCC\xDD\xDD\xDD\xDD\xDD"
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
static int myrand( void *rng_state, unsigned char *output, size_t len )
{
#if !defined(__OpenBSD__)
@@ -1559,71 +1559,71 @@
return( 0 );
}
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
/*
* Checkup routine
*/
-int rsa_self_test( int verbose )
+int mbedtls_rsa_self_test( int verbose )
{
int ret = 0;
-#if defined(POLARSSL_PKCS1_V15)
+#if defined(MBEDTLS_PKCS1_V15)
size_t len;
- rsa_context rsa;
+ mbedtls_rsa_context rsa;
unsigned char rsa_plaintext[PT_LEN];
unsigned char rsa_decrypted[PT_LEN];
unsigned char rsa_ciphertext[KEY_LEN];
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
unsigned char sha1sum[20];
#endif
- rsa_init( &rsa, RSA_PKCS_V15, 0 );
+ mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
rsa.len = KEY_LEN;
- MPI_CHK( mpi_read_string( &rsa.N , 16, RSA_N ) );
- MPI_CHK( mpi_read_string( &rsa.E , 16, RSA_E ) );
- MPI_CHK( mpi_read_string( &rsa.D , 16, RSA_D ) );
- MPI_CHK( mpi_read_string( &rsa.P , 16, RSA_P ) );
- MPI_CHK( mpi_read_string( &rsa.Q , 16, RSA_Q ) );
- MPI_CHK( mpi_read_string( &rsa.DP, 16, RSA_DP ) );
- MPI_CHK( mpi_read_string( &rsa.DQ, 16, RSA_DQ ) );
- MPI_CHK( mpi_read_string( &rsa.QP, 16, RSA_QP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.N , 16, RSA_N ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.E , 16, RSA_E ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.D , 16, RSA_D ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.P , 16, RSA_P ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.Q , 16, RSA_Q ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.DP, 16, RSA_DP ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.DQ, 16, RSA_DQ ) );
+ MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &rsa.QP, 16, RSA_QP ) );
if( verbose != 0 )
- polarssl_printf( " RSA key validation: " );
+ mbedtls_printf( " RSA key validation: " );
- if( rsa_check_pubkey( &rsa ) != 0 ||
- rsa_check_privkey( &rsa ) != 0 )
+ if( mbedtls_rsa_check_pubkey( &rsa ) != 0 ||
+ mbedtls_rsa_check_privkey( &rsa ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n PKCS#1 encryption : " );
+ mbedtls_printf( "passed\n PKCS#1 encryption : " );
memcpy( rsa_plaintext, RSA_PT, PT_LEN );
- if( rsa_pkcs1_encrypt( &rsa, myrand, NULL, RSA_PUBLIC, PT_LEN,
+ if( mbedtls_rsa_pkcs1_encrypt( &rsa, myrand, NULL, MBEDTLS_RSA_PUBLIC, PT_LEN,
rsa_plaintext, rsa_ciphertext ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n PKCS#1 decryption : " );
+ mbedtls_printf( "passed\n PKCS#1 decryption : " );
- if( rsa_pkcs1_decrypt( &rsa, myrand, NULL, RSA_PRIVATE, &len,
+ if( mbedtls_rsa_pkcs1_decrypt( &rsa, myrand, NULL, MBEDTLS_RSA_PRIVATE, &len,
rsa_ciphertext, rsa_decrypted,
sizeof(rsa_decrypted) ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
@@ -1631,50 +1631,50 @@
if( memcmp( rsa_decrypted, rsa_plaintext, len ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
if( verbose != 0 )
- polarssl_printf( "passed\n PKCS#1 data sign : " );
+ mbedtls_printf( "passed\n PKCS#1 data sign : " );
- sha1( rsa_plaintext, PT_LEN, sha1sum );
+ mbedtls_sha1( rsa_plaintext, PT_LEN, sha1sum );
- if( rsa_pkcs1_sign( &rsa, myrand, NULL, RSA_PRIVATE, POLARSSL_MD_SHA1, 0,
+ if( mbedtls_rsa_pkcs1_sign( &rsa, myrand, NULL, MBEDTLS_RSA_PRIVATE, MBEDTLS_MD_SHA1, 0,
sha1sum, rsa_ciphertext ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n PKCS#1 sig. verify: " );
+ mbedtls_printf( "passed\n PKCS#1 sig. verify: " );
- if( rsa_pkcs1_verify( &rsa, NULL, NULL, RSA_PUBLIC, POLARSSL_MD_SHA1, 0,
+ if( mbedtls_rsa_pkcs1_verify( &rsa, NULL, NULL, MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_SHA1, 0,
sha1sum, rsa_ciphertext ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
- polarssl_printf( "passed\n\n" );
-#endif /* POLARSSL_SHA1_C */
+ mbedtls_printf( "passed\n\n" );
+#endif /* MBEDTLS_SHA1_C */
cleanup:
- rsa_free( &rsa );
-#else /* POLARSSL_PKCS1_V15 */
+ mbedtls_rsa_free( &rsa );
+#else /* MBEDTLS_PKCS1_V15 */
((void) verbose);
-#endif /* POLARSSL_PKCS1_V15 */
+#endif /* MBEDTLS_PKCS1_V15 */
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_RSA_C */
+#endif /* MBEDTLS_RSA_C */
diff --git a/library/sha1.c b/library/sha1.c
index bf25f6d..6b34cea 100644
--- a/library/sha1.c
+++ b/library/sha1.c
@@ -25,37 +25,37 @@
* http://www.itl.nist.gov/fipspubs/fip180-1.htm
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_SHA1_C)
#include "mbedtls/sha1.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_SHA1_ALT)
+#if !defined(MBEDTLS_SHA1_ALT)
/*
* 32-bit integer manipulation macros (big endian)
@@ -80,23 +80,23 @@
}
#endif
-void sha1_init( sha1_context *ctx )
+void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
{
- memset( ctx, 0, sizeof( sha1_context ) );
+ memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
}
-void sha1_free( sha1_context *ctx )
+void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( sha1_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
}
/*
* SHA-1 context setup
*/
-void sha1_starts( sha1_context *ctx )
+void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -108,8 +108,8 @@
ctx->state[4] = 0xC3D2E1F0;
}
-#if !defined(POLARSSL_SHA1_PROCESS_ALT)
-void sha1_process( sha1_context *ctx, const unsigned char data[64] )
+#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
+void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] )
{
uint32_t temp, W[16], A, B, C, D, E;
@@ -264,12 +264,12 @@
ctx->state[3] += D;
ctx->state[4] += E;
}
-#endif /* !POLARSSL_SHA1_PROCESS_ALT */
+#endif /* !MBEDTLS_SHA1_PROCESS_ALT */
/*
* SHA-1 process buffer
*/
-void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
+void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen )
{
size_t fill;
uint32_t left;
@@ -289,7 +289,7 @@
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
- sha1_process( ctx, ctx->buffer );
+ mbedtls_sha1_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -297,7 +297,7 @@
while( ilen >= 64 )
{
- sha1_process( ctx, input );
+ mbedtls_sha1_process( ctx, input );
input += 64;
ilen -= 64;
}
@@ -317,7 +317,7 @@
/*
* SHA-1 final digest
*/
-void sha1_finish( sha1_context *ctx, unsigned char output[20] )
+void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
@@ -333,8 +333,8 @@
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
- sha1_update( ctx, sha1_padding, padn );
- sha1_update( ctx, msglen, 8 );
+ mbedtls_sha1_update( ctx, sha1_padding, padn );
+ mbedtls_sha1_update( ctx, msglen, 8 );
PUT_UINT32_BE( ctx->state[0], output, 0 );
PUT_UINT32_BE( ctx->state[1], output, 4 );
@@ -343,57 +343,57 @@
PUT_UINT32_BE( ctx->state[4], output, 16 );
}
-#endif /* !POLARSSL_SHA1_ALT */
+#endif /* !MBEDTLS_SHA1_ALT */
/*
* output = SHA-1( input buffer )
*/
-void sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
+void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
{
- sha1_context ctx;
+ mbedtls_sha1_context ctx;
- sha1_init( &ctx );
- sha1_starts( &ctx );
- sha1_update( &ctx, input, ilen );
- sha1_finish( &ctx, output );
- sha1_free( &ctx );
+ mbedtls_sha1_init( &ctx );
+ mbedtls_sha1_starts( &ctx );
+ mbedtls_sha1_update( &ctx, input, ilen );
+ mbedtls_sha1_finish( &ctx, output );
+ mbedtls_sha1_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = SHA-1( file contents )
*/
-int sha1_file( const char *path, unsigned char output[20] )
+int mbedtls_sha1_file( const char *path, unsigned char output[20] )
{
FILE *f;
size_t n;
- sha1_context ctx;
+ mbedtls_sha1_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_SHA1_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA1_FILE_IO_ERROR );
- sha1_init( &ctx );
- sha1_starts( &ctx );
+ mbedtls_sha1_init( &ctx );
+ mbedtls_sha1_starts( &ctx );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- sha1_update( &ctx, buf, n );
+ mbedtls_sha1_update( &ctx, buf, n );
- sha1_finish( &ctx, output );
- sha1_free( &ctx );
+ mbedtls_sha1_finish( &ctx, output );
+ mbedtls_sha1_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_SHA1_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA1_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* FIPS-180-1 test vectors
*/
@@ -422,14 +422,14 @@
/*
* Checkup routine
*/
-int sha1_self_test( int verbose )
+int mbedtls_sha1_self_test( int verbose )
{
int i, j, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha1sum[20];
- sha1_context ctx;
+ mbedtls_sha1_context ctx;
- sha1_init( &ctx );
+ mbedtls_sha1_init( &ctx );
/*
* SHA-1
@@ -437,45 +437,45 @@
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
- polarssl_printf( " SHA-1 test #%d: ", i + 1 );
+ mbedtls_printf( " SHA-1 test #%d: ", i + 1 );
- sha1_starts( &ctx );
+ mbedtls_sha1_starts( &ctx );
if( i == 2 )
{
memset( buf, 'a', buflen = 1000 );
for( j = 0; j < 1000; j++ )
- sha1_update( &ctx, buf, buflen );
+ mbedtls_sha1_update( &ctx, buf, buflen );
}
else
- sha1_update( &ctx, sha1_test_buf[i],
+ mbedtls_sha1_update( &ctx, sha1_test_buf[i],
sha1_test_buflen[i] );
- sha1_finish( &ctx, sha1sum );
+ mbedtls_sha1_finish( &ctx, sha1sum );
if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- sha1_free( &ctx );
+ mbedtls_sha1_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_SHA1_C */
+#endif /* MBEDTLS_SHA1_C */
diff --git a/library/sha256.c b/library/sha256.c
index f6f6556..5c12638 100644
--- a/library/sha256.c
+++ b/library/sha256.c
@@ -25,37 +25,37 @@
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
#include "mbedtls/sha256.h"
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_SHA256_ALT)
+#if !defined(MBEDTLS_SHA256_ALT)
/*
* 32-bit integer manipulation macros (big endian)
@@ -80,23 +80,23 @@
}
#endif
-void sha256_init( sha256_context *ctx )
+void mbedtls_sha256_init( mbedtls_sha256_context *ctx )
{
- memset( ctx, 0, sizeof( sha256_context ) );
+ memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
}
-void sha256_free( sha256_context *ctx )
+void mbedtls_sha256_free( mbedtls_sha256_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( sha256_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
}
/*
* SHA-256 context setup
*/
-void sha256_starts( sha256_context *ctx, int is224 )
+void mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -129,8 +129,8 @@
ctx->is224 = is224;
}
-#if !defined(POLARSSL_SHA256_PROCESS_ALT)
-void sha256_process( sha256_context *ctx, const unsigned char data[64] )
+#if !defined(MBEDTLS_SHA256_PROCESS_ALT)
+void mbedtls_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] )
{
uint32_t temp1, temp2, W[64];
uint32_t A, B, C, D, E, F, G, H;
@@ -260,12 +260,12 @@
ctx->state[6] += G;
ctx->state[7] += H;
}
-#endif /* !POLARSSL_SHA256_PROCESS_ALT */
+#endif /* !MBEDTLS_SHA256_PROCESS_ALT */
/*
* SHA-256 process buffer
*/
-void sha256_update( sha256_context *ctx, const unsigned char *input,
+void mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *input,
size_t ilen )
{
size_t fill;
@@ -286,7 +286,7 @@
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
- sha256_process( ctx, ctx->buffer );
+ mbedtls_sha256_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -294,7 +294,7 @@
while( ilen >= 64 )
{
- sha256_process( ctx, input );
+ mbedtls_sha256_process( ctx, input );
input += 64;
ilen -= 64;
}
@@ -314,7 +314,7 @@
/*
* SHA-256 final digest
*/
-void sha256_finish( sha256_context *ctx, unsigned char output[32] )
+void mbedtls_sha256_finish( mbedtls_sha256_context *ctx, unsigned char output[32] )
{
uint32_t last, padn;
uint32_t high, low;
@@ -330,8 +330,8 @@
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
- sha256_update( ctx, sha256_padding, padn );
- sha256_update( ctx, msglen, 8 );
+ mbedtls_sha256_update( ctx, sha256_padding, padn );
+ mbedtls_sha256_update( ctx, msglen, 8 );
PUT_UINT32_BE( ctx->state[0], output, 0 );
PUT_UINT32_BE( ctx->state[1], output, 4 );
@@ -345,58 +345,58 @@
PUT_UINT32_BE( ctx->state[7], output, 28 );
}
-#endif /* !POLARSSL_SHA256_ALT */
+#endif /* !MBEDTLS_SHA256_ALT */
/*
* output = SHA-256( input buffer )
*/
-void sha256( const unsigned char *input, size_t ilen,
+void mbedtls_sha256( const unsigned char *input, size_t ilen,
unsigned char output[32], int is224 )
{
- sha256_context ctx;
+ mbedtls_sha256_context ctx;
- sha256_init( &ctx );
- sha256_starts( &ctx, is224 );
- sha256_update( &ctx, input, ilen );
- sha256_finish( &ctx, output );
- sha256_free( &ctx );
+ mbedtls_sha256_init( &ctx );
+ mbedtls_sha256_starts( &ctx, is224 );
+ mbedtls_sha256_update( &ctx, input, ilen );
+ mbedtls_sha256_finish( &ctx, output );
+ mbedtls_sha256_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = SHA-256( file contents )
*/
-int sha256_file( const char *path, unsigned char output[32], int is224 )
+int mbedtls_sha256_file( const char *path, unsigned char output[32], int is224 )
{
FILE *f;
size_t n;
- sha256_context ctx;
+ mbedtls_sha256_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_SHA256_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA256_FILE_IO_ERROR );
- sha256_init( &ctx );
- sha256_starts( &ctx, is224 );
+ mbedtls_sha256_init( &ctx );
+ mbedtls_sha256_starts( &ctx, is224 );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- sha256_update( &ctx, buf, n );
+ mbedtls_sha256_update( &ctx, buf, n );
- sha256_finish( &ctx, output );
- sha256_free( &ctx );
+ mbedtls_sha256_finish( &ctx, output );
+ mbedtls_sha256_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_SHA256_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA256_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* FIPS-180-2 test vectors
*/
@@ -450,14 +450,14 @@
/*
* Checkup routine
*/
-int sha256_self_test( int verbose )
+int mbedtls_sha256_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha256sum[32];
- sha256_context ctx;
+ mbedtls_sha256_context ctx;
- sha256_init( &ctx );
+ mbedtls_sha256_init( &ctx );
for( i = 0; i < 6; i++ )
{
@@ -465,45 +465,45 @@
k = i < 3;
if( verbose != 0 )
- polarssl_printf( " SHA-%d test #%d: ", 256 - k * 32, j + 1 );
+ mbedtls_printf( " SHA-%d test #%d: ", 256 - k * 32, j + 1 );
- sha256_starts( &ctx, k );
+ mbedtls_sha256_starts( &ctx, k );
if( j == 2 )
{
memset( buf, 'a', buflen = 1000 );
for( j = 0; j < 1000; j++ )
- sha256_update( &ctx, buf, buflen );
+ mbedtls_sha256_update( &ctx, buf, buflen );
}
else
- sha256_update( &ctx, sha256_test_buf[j],
+ mbedtls_sha256_update( &ctx, sha256_test_buf[j],
sha256_test_buflen[j] );
- sha256_finish( &ctx, sha256sum );
+ mbedtls_sha256_finish( &ctx, sha256sum );
if( memcmp( sha256sum, sha256_test_sum[i], 32 - k * 4 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- sha256_free( &ctx );
+ mbedtls_sha256_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
diff --git a/library/sha512.c b/library/sha512.c
index aeb4187..fb872a1 100644
--- a/library/sha512.c
+++ b/library/sha512.c
@@ -25,13 +25,13 @@
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
#include "mbedtls/sha512.h"
@@ -43,25 +43,25 @@
#include <string.h>
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#endif
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-#if !defined(POLARSSL_SHA512_ALT)
+#if !defined(MBEDTLS_SHA512_ALT)
/*
* 64-bit integer manipulation macros (big endian)
@@ -141,23 +141,23 @@
UL64(0x5FCB6FAB3AD6FAEC), UL64(0x6C44198C4A475817)
};
-void sha512_init( sha512_context *ctx )
+void mbedtls_sha512_init( mbedtls_sha512_context *ctx )
{
- memset( ctx, 0, sizeof( sha512_context ) );
+ memset( ctx, 0, sizeof( mbedtls_sha512_context ) );
}
-void sha512_free( sha512_context *ctx )
+void mbedtls_sha512_free( mbedtls_sha512_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( sha512_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
}
/*
* SHA-512 context setup
*/
-void sha512_starts( sha512_context *ctx, int is384 )
+void mbedtls_sha512_starts( mbedtls_sha512_context *ctx, int is384 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -190,8 +190,8 @@
ctx->is384 = is384;
}
-#if !defined(POLARSSL_SHA512_PROCESS_ALT)
-void sha512_process( sha512_context *ctx, const unsigned char data[128] )
+#if !defined(MBEDTLS_SHA512_PROCESS_ALT)
+void mbedtls_sha512_process( mbedtls_sha512_context *ctx, const unsigned char data[128] )
{
int i;
uint64_t temp1, temp2, W[80];
@@ -259,12 +259,12 @@
ctx->state[6] += G;
ctx->state[7] += H;
}
-#endif /* !POLARSSL_SHA512_PROCESS_ALT */
+#endif /* !MBEDTLS_SHA512_PROCESS_ALT */
/*
* SHA-512 process buffer
*/
-void sha512_update( sha512_context *ctx, const unsigned char *input,
+void mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
size_t ilen )
{
size_t fill;
@@ -284,7 +284,7 @@
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
- sha512_process( ctx, ctx->buffer );
+ mbedtls_sha512_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
@@ -292,7 +292,7 @@
while( ilen >= 128 )
{
- sha512_process( ctx, input );
+ mbedtls_sha512_process( ctx, input );
input += 128;
ilen -= 128;
}
@@ -316,7 +316,7 @@
/*
* SHA-512 final digest
*/
-void sha512_finish( sha512_context *ctx, unsigned char output[64] )
+void mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char output[64] )
{
size_t last, padn;
uint64_t high, low;
@@ -332,8 +332,8 @@
last = (size_t)( ctx->total[0] & 0x7F );
padn = ( last < 112 ) ? ( 112 - last ) : ( 240 - last );
- sha512_update( ctx, sha512_padding, padn );
- sha512_update( ctx, msglen, 16 );
+ mbedtls_sha512_update( ctx, sha512_padding, padn );
+ mbedtls_sha512_update( ctx, msglen, 16 );
PUT_UINT64_BE( ctx->state[0], output, 0 );
PUT_UINT64_BE( ctx->state[1], output, 8 );
@@ -349,58 +349,58 @@
}
}
-#endif /* !POLARSSL_SHA512_ALT */
+#endif /* !MBEDTLS_SHA512_ALT */
/*
* output = SHA-512( input buffer )
*/
-void sha512( const unsigned char *input, size_t ilen,
+void mbedtls_sha512( const unsigned char *input, size_t ilen,
unsigned char output[64], int is384 )
{
- sha512_context ctx;
+ mbedtls_sha512_context ctx;
- sha512_init( &ctx );
- sha512_starts( &ctx, is384 );
- sha512_update( &ctx, input, ilen );
- sha512_finish( &ctx, output );
- sha512_free( &ctx );
+ mbedtls_sha512_init( &ctx );
+ mbedtls_sha512_starts( &ctx, is384 );
+ mbedtls_sha512_update( &ctx, input, ilen );
+ mbedtls_sha512_finish( &ctx, output );
+ mbedtls_sha512_free( &ctx );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* output = SHA-512( file contents )
*/
-int sha512_file( const char *path, unsigned char output[64], int is384 )
+int mbedtls_sha512_file( const char *path, unsigned char output[64], int is384 )
{
FILE *f;
size_t n;
- sha512_context ctx;
+ mbedtls_sha512_context ctx;
unsigned char buf[1024];
if( ( f = fopen( path, "rb" ) ) == NULL )
- return( POLARSSL_ERR_SHA512_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA512_FILE_IO_ERROR );
- sha512_init( &ctx );
- sha512_starts( &ctx, is384 );
+ mbedtls_sha512_init( &ctx );
+ mbedtls_sha512_starts( &ctx, is384 );
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
- sha512_update( &ctx, buf, n );
+ mbedtls_sha512_update( &ctx, buf, n );
- sha512_finish( &ctx, output );
- sha512_free( &ctx );
+ mbedtls_sha512_finish( &ctx, output );
+ mbedtls_sha512_free( &ctx );
if( ferror( f ) != 0 )
{
fclose( f );
- return( POLARSSL_ERR_SHA512_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_SHA512_FILE_IO_ERROR );
}
fclose( f );
return( 0 );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* FIPS-180-2 test vectors
@@ -474,14 +474,14 @@
/*
* Checkup routine
*/
-int sha512_self_test( int verbose )
+int mbedtls_sha512_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha512sum[64];
- sha512_context ctx;
+ mbedtls_sha512_context ctx;
- sha512_init( &ctx );
+ mbedtls_sha512_init( &ctx );
for( i = 0; i < 6; i++ )
{
@@ -489,45 +489,45 @@
k = i < 3;
if( verbose != 0 )
- polarssl_printf( " SHA-%d test #%d: ", 512 - k * 128, j + 1 );
+ mbedtls_printf( " SHA-%d test #%d: ", 512 - k * 128, j + 1 );
- sha512_starts( &ctx, k );
+ mbedtls_sha512_starts( &ctx, k );
if( j == 2 )
{
memset( buf, 'a', buflen = 1000 );
for( j = 0; j < 1000; j++ )
- sha512_update( &ctx, buf, buflen );
+ mbedtls_sha512_update( &ctx, buf, buflen );
}
else
- sha512_update( &ctx, sha512_test_buf[j],
+ mbedtls_sha512_update( &ctx, sha512_test_buf[j],
sha512_test_buflen[j] );
- sha512_finish( &ctx, sha512sum );
+ mbedtls_sha512_finish( &ctx, sha512sum );
if( memcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- sha512_free( &ctx );
+ mbedtls_sha512_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
diff --git a/library/ssl_cache.c b/library/ssl_cache.c
index eaf67e8..ca42b7a 100644
--- a/library/ssl_cache.c
+++ b/library/ssl_cache.c
@@ -24,49 +24,49 @@
* to store and retrieve the session information.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_CACHE_C)
+#if defined(MBEDTLS_SSL_CACHE_C)
#include "mbedtls/ssl_cache.h"
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-void ssl_cache_init( ssl_cache_context *cache )
+void mbedtls_ssl_cache_init( mbedtls_ssl_cache_context *cache )
{
- memset( cache, 0, sizeof( ssl_cache_context ) );
+ memset( cache, 0, sizeof( mbedtls_ssl_cache_context ) );
- cache->timeout = SSL_CACHE_DEFAULT_TIMEOUT;
- cache->max_entries = SSL_CACHE_DEFAULT_MAX_ENTRIES;
+ cache->timeout = MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT;
+ cache->max_entries = MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES;
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_init( &cache->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_init( &cache->mutex );
#endif
}
-int ssl_cache_get( void *data, ssl_session *session )
+int mbedtls_ssl_cache_get( void *data, mbedtls_ssl_session *session )
{
int ret = 1;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
time_t t = time( NULL );
#endif
- ssl_cache_context *cache = (ssl_cache_context *) data;
- ssl_cache_entry *cur, *entry;
+ mbedtls_ssl_cache_context *cache = (mbedtls_ssl_cache_context *) data;
+ mbedtls_ssl_cache_entry *cur, *entry;
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_lock( &cache->mutex ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_lock( &cache->mutex ) != 0 )
return( 1 );
#endif
@@ -78,7 +78,7 @@
entry = cur;
cur = cur->next;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
if( cache->timeout != 0 &&
(int) ( t - entry->timestamp ) > cache->timeout )
continue;
@@ -97,57 +97,57 @@
session->verify_result = entry->session.verify_result;
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Restore peer certificate (without rest of the original chain)
*/
if( entry->peer_cert.p != NULL )
{
- if( ( session->peer_cert = polarssl_malloc(
- sizeof(x509_crt) ) ) == NULL )
+ if( ( session->peer_cert = mbedtls_malloc(
+ sizeof(mbedtls_x509_crt) ) ) == NULL )
{
ret = 1;
goto exit;
}
- x509_crt_init( session->peer_cert );
- if( x509_crt_parse( session->peer_cert, entry->peer_cert.p,
+ mbedtls_x509_crt_init( session->peer_cert );
+ if( mbedtls_x509_crt_parse( session->peer_cert, entry->peer_cert.p,
entry->peer_cert.len ) != 0 )
{
- polarssl_free( session->peer_cert );
+ mbedtls_free( session->peer_cert );
session->peer_cert = NULL;
ret = 1;
goto exit;
}
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
ret = 0;
goto exit;
}
exit:
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &cache->mutex ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &cache->mutex ) != 0 )
ret = 1;
#endif
return( ret );
}
-int ssl_cache_set( void *data, const ssl_session *session )
+int mbedtls_ssl_cache_set( void *data, const mbedtls_ssl_session *session )
{
int ret = 1;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
time_t t = time( NULL ), oldest = 0;
- ssl_cache_entry *old = NULL;
+ mbedtls_ssl_cache_entry *old = NULL;
#endif
- ssl_cache_context *cache = (ssl_cache_context *) data;
- ssl_cache_entry *cur, *prv;
+ mbedtls_ssl_cache_context *cache = (mbedtls_ssl_cache_context *) data;
+ mbedtls_ssl_cache_entry *cur, *prv;
int count = 0;
-#if defined(POLARSSL_THREADING_C)
- if( ( ret = polarssl_mutex_lock( &cache->mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( ( ret = mbedtls_mutex_lock( &cache->mutex ) ) != 0 )
return( ret );
#endif
@@ -158,7 +158,7 @@
{
count++;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
if( cache->timeout != 0 &&
(int) ( t - cur->timestamp ) > cache->timeout )
{
@@ -170,7 +170,7 @@
if( memcmp( session->id, cur->session.id, cur->session.length ) == 0 )
break; /* client reconnected, keep timestamp for session id */
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
if( oldest == 0 || cur->timestamp < oldest )
{
oldest = cur->timestamp;
@@ -184,7 +184,7 @@
if( cur == NULL )
{
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
/*
* Reuse oldest entry if max_entries reached
*/
@@ -198,7 +198,7 @@
cur = old;
}
-#else /* POLARSSL_HAVE_TIME */
+#else /* MBEDTLS_HAVE_TIME */
/*
* Reuse first entry in chain if max_entries reached,
* but move to last place
@@ -216,20 +216,20 @@
cur->next = NULL;
prv->next = cur;
}
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
else
{
/*
* max_entries not reached, create new entry
*/
- cur = polarssl_malloc( sizeof(ssl_cache_entry) );
+ cur = mbedtls_malloc( sizeof(mbedtls_ssl_cache_entry) );
if( cur == NULL )
{
ret = 1;
goto exit;
}
- memset( cur, 0, sizeof(ssl_cache_entry) );
+ memset( cur, 0, sizeof(mbedtls_ssl_cache_entry) );
if( prv == NULL )
cache->chain = cur;
@@ -237,21 +237,21 @@
prv->next = cur;
}
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
cur->timestamp = t;
#endif
}
- memcpy( &cur->session, session, sizeof( ssl_session ) );
+ memcpy( &cur->session, session, sizeof( mbedtls_ssl_session ) );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* If we're reusing an entry, free its certificate first
*/
if( cur->peer_cert.p != NULL )
{
- polarssl_free( cur->peer_cert.p );
- memset( &cur->peer_cert, 0, sizeof(x509_buf) );
+ mbedtls_free( cur->peer_cert.p );
+ memset( &cur->peer_cert, 0, sizeof(mbedtls_x509_buf) );
}
/*
@@ -259,7 +259,7 @@
*/
if( session->peer_cert != NULL )
{
- cur->peer_cert.p = polarssl_malloc( session->peer_cert->raw.len );
+ cur->peer_cert.p = mbedtls_malloc( session->peer_cert->raw.len );
if( cur->peer_cert.p == NULL )
{
ret = 1;
@@ -272,38 +272,38 @@
cur->session.peer_cert = NULL;
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
ret = 0;
exit:
-#if defined(POLARSSL_THREADING_C)
- if( polarssl_mutex_unlock( &cache->mutex ) != 0 )
+#if defined(MBEDTLS_THREADING_C)
+ if( mbedtls_mutex_unlock( &cache->mutex ) != 0 )
ret = 1;
#endif
return( ret );
}
-#if defined(POLARSSL_HAVE_TIME)
-void ssl_cache_set_timeout( ssl_cache_context *cache, int timeout )
+#if defined(MBEDTLS_HAVE_TIME)
+void mbedtls_ssl_cache_set_timeout( mbedtls_ssl_cache_context *cache, int timeout )
{
if( timeout < 0 ) timeout = 0;
cache->timeout = timeout;
}
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
-void ssl_cache_set_max_entries( ssl_cache_context *cache, int max )
+void mbedtls_ssl_cache_set_max_entries( mbedtls_ssl_cache_context *cache, int max )
{
if( max < 0 ) max = 0;
cache->max_entries = max;
}
-void ssl_cache_free( ssl_cache_context *cache )
+void mbedtls_ssl_cache_free( mbedtls_ssl_cache_context *cache )
{
- ssl_cache_entry *cur, *prv;
+ mbedtls_ssl_cache_entry *cur, *prv;
cur = cache->chain;
@@ -312,18 +312,18 @@
prv = cur;
cur = cur->next;
- ssl_session_free( &prv->session );
+ mbedtls_ssl_session_free( &prv->session );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
- polarssl_free( prv->peer_cert.p );
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+ mbedtls_free( prv->peer_cert.p );
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
- polarssl_free( prv );
+ mbedtls_free( prv );
}
-#if defined(POLARSSL_THREADING_C)
- polarssl_mutex_free( &cache->mutex );
+#if defined(MBEDTLS_THREADING_C)
+ mbedtls_mutex_free( &cache->mutex );
#endif
}
-#endif /* POLARSSL_SSL_CACHE_C */
+#endif /* MBEDTLS_SSL_CACHE_C */
diff --git a/library/ssl_ciphersuites.c b/library/ssl_ciphersuites.c
index 11c46a5..f5e02a0 100644
--- a/library/ssl_ciphersuites.c
+++ b/library/ssl_ciphersuites.c
@@ -22,13 +22,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_TLS_C)
+#if defined(MBEDTLS_SSL_TLS_C)
#include "mbedtls/ssl_ciphersuites.h"
#include "mbedtls/ssl.h"
@@ -55,1632 +55,1632 @@
*/
static const int ciphersuite_preference[] =
{
-#if defined(SSL_CIPHERSUITES)
- SSL_CIPHERSUITES,
+#if defined(MBEDTLS_SSL_CIPHERSUITES)
+ MBEDTLS_SSL_CIPHERSUITES,
#else
/* All AES-256 ephemeral suites */
- TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
- TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
- TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
- TLS_ECDHE_ECDSA_WITH_AES_256_CCM,
- TLS_DHE_RSA_WITH_AES_256_CCM,
- TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
- TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
- TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
- TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
- TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
- TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
- TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8,
- TLS_DHE_RSA_WITH_AES_256_CCM_8,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM_8,
/* All CAMELLIA-256 ephemeral suites */
- TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
- TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
/* All AES-128 ephemeral suites */
- TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
- TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
- TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
- TLS_ECDHE_ECDSA_WITH_AES_128_CCM,
- TLS_DHE_RSA_WITH_AES_128_CCM,
- TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
- TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
- TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
- TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
- TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
- TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
- TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8,
- TLS_DHE_RSA_WITH_AES_128_CCM_8,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8,
+ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM_8,
/* All CAMELLIA-128 ephemeral suites */
- TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
/* All remaining >= 128-bit ephemeral suites */
- TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
- TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
- TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
/* The PSK ephemeral suites */
- TLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
- TLS_DHE_PSK_WITH_AES_256_CCM,
- TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
- TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
- TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
- TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
- TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_DHE_PSK_WITH_AES_256_CCM_8,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM_8,
- TLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
- TLS_DHE_PSK_WITH_AES_128_CCM,
- TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
- TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
- TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
- TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
- TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_DHE_PSK_WITH_AES_128_CCM_8,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM_8,
- TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
- TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
/* All AES-256 suites */
- TLS_RSA_WITH_AES_256_GCM_SHA384,
- TLS_RSA_WITH_AES_256_CCM,
- TLS_RSA_WITH_AES_256_CBC_SHA256,
- TLS_RSA_WITH_AES_256_CBC_SHA,
- TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
- TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
- TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
- TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
- TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
- TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
- TLS_RSA_WITH_AES_256_CCM_8,
+ MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_RSA_WITH_AES_256_CCM,
+ MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256,
+ MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_RSA_WITH_AES_256_CCM_8,
/* All CAMELLIA-256 suites */
- TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
- TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
- TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
+ MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
/* All AES-128 suites */
- TLS_RSA_WITH_AES_128_GCM_SHA256,
- TLS_RSA_WITH_AES_128_CCM,
- TLS_RSA_WITH_AES_128_CBC_SHA256,
- TLS_RSA_WITH_AES_128_CBC_SHA,
- TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
- TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
- TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
- TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
- TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
- TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
- TLS_RSA_WITH_AES_128_CCM_8,
+ MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_RSA_WITH_AES_128_CCM,
+ MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_RSA_WITH_AES_128_CCM_8,
/* All CAMELLIA-128 suites */
- TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
- TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
+ MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
/* All remaining >= 128-bit suites */
- TLS_RSA_WITH_3DES_EDE_CBC_SHA,
- TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
- TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
/* The RSA PSK suites */
- TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
- TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
- TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
- TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
- TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
- TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
- TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
/* The PSK suites */
- TLS_PSK_WITH_AES_256_GCM_SHA384,
- TLS_PSK_WITH_AES_256_CCM,
- TLS_PSK_WITH_AES_256_CBC_SHA384,
- TLS_PSK_WITH_AES_256_CBC_SHA,
- TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
- TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
- TLS_PSK_WITH_AES_256_CCM_8,
+ MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384,
+ MBEDTLS_TLS_PSK_WITH_AES_256_CCM,
+ MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384,
+ MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA,
+ MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
+ MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+ MBEDTLS_TLS_PSK_WITH_AES_256_CCM_8,
- TLS_PSK_WITH_AES_128_GCM_SHA256,
- TLS_PSK_WITH_AES_128_CCM,
- TLS_PSK_WITH_AES_128_CBC_SHA256,
- TLS_PSK_WITH_AES_128_CBC_SHA,
- TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
- TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
- TLS_PSK_WITH_AES_128_CCM_8,
+ MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256,
+ MBEDTLS_TLS_PSK_WITH_AES_128_CCM,
+ MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256,
+ MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA,
+ MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
+ MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+ MBEDTLS_TLS_PSK_WITH_AES_128_CCM_8,
- TLS_PSK_WITH_3DES_EDE_CBC_SHA,
+ MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
/* RC4 suites */
- TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
- TLS_ECDHE_RSA_WITH_RC4_128_SHA,
- TLS_ECDHE_PSK_WITH_RC4_128_SHA,
- TLS_DHE_PSK_WITH_RC4_128_SHA,
- TLS_RSA_WITH_RC4_128_SHA,
- TLS_RSA_WITH_RC4_128_MD5,
- TLS_ECDH_RSA_WITH_RC4_128_SHA,
- TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
- TLS_RSA_PSK_WITH_RC4_128_SHA,
- TLS_PSK_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_RSA_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_RSA_WITH_RC4_128_MD5,
+ MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA,
+ MBEDTLS_TLS_PSK_WITH_RC4_128_SHA,
/* Weak suites */
- TLS_DHE_RSA_WITH_DES_CBC_SHA,
- TLS_RSA_WITH_DES_CBC_SHA,
+ MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA,
+ MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA,
/* NULL suites */
- TLS_ECDHE_ECDSA_WITH_NULL_SHA,
- TLS_ECDHE_RSA_WITH_NULL_SHA,
- TLS_ECDHE_PSK_WITH_NULL_SHA384,
- TLS_ECDHE_PSK_WITH_NULL_SHA256,
- TLS_ECDHE_PSK_WITH_NULL_SHA,
- TLS_DHE_PSK_WITH_NULL_SHA384,
- TLS_DHE_PSK_WITH_NULL_SHA256,
- TLS_DHE_PSK_WITH_NULL_SHA,
+ MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
+ MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256,
+ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA,
+ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384,
+ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256,
+ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA,
- TLS_RSA_WITH_NULL_SHA256,
- TLS_RSA_WITH_NULL_SHA,
- TLS_RSA_WITH_NULL_MD5,
- TLS_ECDH_RSA_WITH_NULL_SHA,
- TLS_ECDH_ECDSA_WITH_NULL_SHA,
- TLS_RSA_PSK_WITH_NULL_SHA384,
- TLS_RSA_PSK_WITH_NULL_SHA256,
- TLS_RSA_PSK_WITH_NULL_SHA,
- TLS_PSK_WITH_NULL_SHA384,
- TLS_PSK_WITH_NULL_SHA256,
- TLS_PSK_WITH_NULL_SHA,
+ MBEDTLS_TLS_RSA_WITH_NULL_SHA256,
+ MBEDTLS_TLS_RSA_WITH_NULL_SHA,
+ MBEDTLS_TLS_RSA_WITH_NULL_MD5,
+ MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA,
+ MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA,
+ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384,
+ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256,
+ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA,
+ MBEDTLS_TLS_PSK_WITH_NULL_SHA384,
+ MBEDTLS_TLS_PSK_WITH_NULL_SHA256,
+ MBEDTLS_TLS_PSK_WITH_NULL_SHA,
-#endif /* SSL_CIPHERSUITES */
+#endif /* MBEDTLS_SSL_CIPHERSUITES */
0
};
-static const ssl_ciphersuite_t ciphersuite_definitions[] =
+static const mbedtls_ssl_ciphersuite_t ciphersuite_definitions[] =
{
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA1_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA1_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, "TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, "TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, "TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, "TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA512_C */
-#if defined(POLARSSL_CCM_C)
- { TLS_ECDHE_ECDSA_WITH_AES_256_CCM, "TLS-ECDHE-ECDSA-WITH-AES-256-CCM",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM, "TLS-ECDHE-ECDSA-WITH-AES-256-CCM",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8, "TLS-ECDHE-ECDSA-WITH-AES-256-CCM-8",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
- { TLS_ECDHE_ECDSA_WITH_AES_128_CCM, "TLS-ECDHE-ECDSA-WITH-AES-128-CCM",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8, "TLS-ECDHE-ECDSA-WITH-AES-256-CCM-8",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM, "TLS-ECDHE-ECDSA-WITH-AES-128-CCM",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, "TLS-ECDHE-ECDSA-WITH-AES-128-CCM-8",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
-#endif /* POLARSSL_CCM_C */
-#endif /* POLARSSL_AES_C */
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, "TLS-ECDHE-ECDSA-WITH-AES-128-CCM-8",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+#endif /* MBEDTLS_CCM_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDHE-ECDSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-ECDSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, "TLS-ECDHE-ECDSA-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, "TLS-ECDHE-ECDSA-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_ECDSA_WITH_NULL_SHA, "TLS-ECDHE-ECDSA-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA, "TLS-ECDHE-ECDSA-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA1_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, "TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA1_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, "TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, "TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, "TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, "TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, "TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, "TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, "TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-RSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-RSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-RSA-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-RSA-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDHE-RSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDHE-RSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDHE-RSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDHE-RSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-RSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-RSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_RSA_WITH_RC4_128_SHA, "TLS-ECDHE-RSA-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA, "TLS-ECDHE-RSA-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_RSA_WITH_NULL_SHA, "TLS-ECDHE-RSA-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA, "TLS-ECDHE-RSA-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA512_C) && defined(POLARSSL_GCM_C)
- { TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, "TLS-DHE-RSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA512_C) && defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, "TLS-DHE-RSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C && POLARSSL_GCM_C */
+#endif /* MBEDTLS_SHA512_C && MBEDTLS_GCM_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_GCM_C)
- { TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, "TLS-DHE-RSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, "TLS-DHE-RSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, "TLS-DHE-RSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, "TLS-DHE-RSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, "TLS-DHE-RSA-WITH-AES-256-CBC-SHA256",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, "TLS-DHE-RSA-WITH-AES-256-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_RSA_WITH_AES_128_CBC_SHA, "TLS-DHE-RSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA, "TLS-DHE-RSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_AES_256_CBC_SHA, "TLS-DHE-RSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA, "TLS-DHE-RSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CCM_C)
- { TLS_DHE_RSA_WITH_AES_256_CCM, "TLS-DHE-RSA-WITH-AES-256-CCM",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM, "TLS-DHE-RSA-WITH-AES-256-CCM",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_AES_256_CCM_8, "TLS-DHE-RSA-WITH-AES-256-CCM-8",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
- { TLS_DHE_RSA_WITH_AES_128_CCM, "TLS-DHE-RSA-WITH-AES-128-CCM",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM_8, "TLS-DHE-RSA-WITH-AES-256-CCM-8",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM, "TLS-DHE-RSA-WITH-AES-128-CCM",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_AES_128_CCM_8, "TLS-DHE-RSA-WITH-AES-128-CCM-8",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
-#endif /* POLARSSL_CCM_C */
-#endif /* POLARSSL_AES_C */
+ { MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM_8, "TLS-DHE-RSA-WITH-AES-128-CCM-8",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+#endif /* MBEDTLS_CCM_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-256-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-256-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, "TLS-DHE-RSA-WITH-CAMELLIA-128-CBC-SHA",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, "TLS-DHE-RSA-WITH-CAMELLIA-128-CBC-SHA",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, "TLS-DHE-RSA-WITH-CAMELLIA-256-CBC-SHA",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, "TLS-DHE-RSA-WITH-CAMELLIA-256-CBC-SHA",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-DHE-RSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-DHE-RSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-DHE-RSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-DHE-RSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-DHE-RSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA512_C) && defined(POLARSSL_GCM_C)
- { TLS_RSA_WITH_AES_256_GCM_SHA384, "TLS-RSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA512_C) && defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384, "TLS-RSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C && POLARSSL_GCM_C */
+#endif /* MBEDTLS_SHA512_C && MBEDTLS_GCM_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_GCM_C)
- { TLS_RSA_WITH_AES_128_GCM_SHA256, "TLS-RSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256, "TLS-RSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_RSA_WITH_AES_128_CBC_SHA256, "TLS-RSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256, "TLS-RSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_AES_256_CBC_SHA256, "TLS-RSA-WITH-AES-256-CBC-SHA256",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256, "TLS-RSA-WITH-AES-256-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA1_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_RSA_WITH_AES_128_CBC_SHA, "TLS-RSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA, "TLS-RSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_AES_256_CBC_SHA, "TLS-RSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA, "TLS-RSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_CCM_C)
- { TLS_RSA_WITH_AES_256_CCM, "TLS-RSA-WITH-AES-256-CCM",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_TLS_RSA_WITH_AES_256_CCM, "TLS-RSA-WITH-AES-256-CCM",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_AES_256_CCM_8, "TLS-RSA-WITH-AES-256-CCM-8",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
- { TLS_RSA_WITH_AES_128_CCM, "TLS-RSA-WITH-AES-128-CCM",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_WITH_AES_256_CCM_8, "TLS-RSA-WITH-AES-256-CCM-8",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+ { MBEDTLS_TLS_RSA_WITH_AES_128_CCM, "TLS-RSA-WITH-AES-128-CCM",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_AES_128_CCM_8, "TLS-RSA-WITH-AES-128-CCM-8",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
-#endif /* POLARSSL_CCM_C */
-#endif /* POLARSSL_AES_C */
+ { MBEDTLS_TLS_RSA_WITH_AES_128_CCM_8, "TLS-RSA-WITH-AES-128-CCM-8",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+#endif /* MBEDTLS_CCM_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-RSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-RSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256, "TLS-RSA-WITH-CAMELLIA-256-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256, "TLS-RSA-WITH-CAMELLIA-256-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, "TLS-RSA-WITH-CAMELLIA-128-CBC-SHA",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, "TLS-RSA-WITH-CAMELLIA-128-CBC-SHA",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, "TLS-RSA-WITH-CAMELLIA-256-CBC-SHA",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, "TLS-RSA-WITH-CAMELLIA-256-CBC-SHA",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-RSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-RSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-RSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-RSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-RSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-RSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_MD5_C)
- { TLS_RSA_WITH_RC4_128_MD5, "TLS-RSA-WITH-RC4-128-MD5",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_MD5, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_MD5_C)
+ { MBEDTLS_TLS_RSA_WITH_RC4_128_MD5, "TLS-RSA-WITH-RC4-128-MD5",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_MD5, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
#endif
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_RC4_128_SHA, "TLS-RSA-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_RC4_128_SHA, "TLS-RSA-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
#endif
-#endif /* POLARSSL_ARC4_C */
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
+#endif /* MBEDTLS_ARC4_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA1_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, "TLS-ECDH-RSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA1_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, "TLS-ECDH-RSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, "TLS-ECDH-RSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, "TLS-ECDH-RSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, "TLS-ECDH-RSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, "TLS-ECDH-RSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, "TLS-ECDH-RSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, "TLS-ECDH-RSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, "TLS-ECDH-RSA-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, "TLS-ECDH-RSA-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, "TLS-ECDH-RSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, "TLS-ECDH-RSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDH-RSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDH-RSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDH-RSA-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDH-RSA-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDH-RSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDH-RSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDH-RSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDH-RSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDH-RSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDH-RSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_RSA_WITH_RC4_128_SHA, "TLS-ECDH-RSA-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA, "TLS-ECDH-RSA-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_RSA_WITH_NULL_SHA, "TLS-ECDH-RSA-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA, "TLS-ECDH-RSA-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_SHA1_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, "TLS-ECDH-ECDSA-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_SHA1_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, "TLS-ECDH-ECDSA-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, "TLS-ECDH-ECDSA-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, "TLS-ECDH-ECDSA-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, "TLS-ECDH-ECDSA-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_SHA256_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, "TLS-ECDH-ECDSA-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, "TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, "TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- { TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, "TLS-ECDH-ECDSA-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, "TLS-ECDH-ECDSA-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
- { TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, "TLS-ECDH-ECDSA-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_GCM_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, "TLS-ECDH-ECDSA-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDH-ECDSA-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDH-ECDSA-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDH-ECDSA-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDH-ECDSA-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDH-ECDSA-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, "TLS-ECDH-ECDSA-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDH-ECDSA-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, "TLS-ECDH-ECDSA-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDH-ECDSA-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, "TLS-ECDH-ECDSA-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_ECDSA_WITH_RC4_128_SHA, "TLS-ECDH-ECDSA-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA, "TLS-ECDH-ECDSA-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDH_ECDSA_WITH_NULL_SHA, "TLS-ECDH-ECDSA-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDH_ECDSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA, "TLS-ECDH-ECDSA-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_PSK_WITH_AES_128_GCM_SHA256, "TLS-PSK-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256, "TLS-PSK-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_PSK_WITH_AES_256_GCM_SHA384, "TLS-PSK-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384, "TLS-PSK-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_PSK_WITH_AES_128_CBC_SHA256, "TLS-PSK-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256, "TLS-PSK-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_PSK_WITH_AES_256_CBC_SHA384, "TLS-PSK-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384, "TLS-PSK-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_PSK_WITH_AES_128_CBC_SHA, "TLS-PSK-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA, "TLS-PSK-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_PSK_WITH_AES_256_CBC_SHA, "TLS-PSK-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA, "TLS-PSK-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CCM_C)
- { TLS_PSK_WITH_AES_256_CCM, "TLS-PSK-WITH-AES-256-CCM",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_TLS_PSK_WITH_AES_256_CCM, "TLS-PSK-WITH-AES-256-CCM",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_PSK_WITH_AES_256_CCM_8, "TLS-PSK-WITH-AES-256-CCM-8",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
- { TLS_PSK_WITH_AES_128_CCM, "TLS-PSK-WITH-AES-128-CCM",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_PSK_WITH_AES_256_CCM_8, "TLS-PSK-WITH-AES-256-CCM-8",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+ { MBEDTLS_TLS_PSK_WITH_AES_128_CCM, "TLS-PSK-WITH-AES-128-CCM",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_PSK_WITH_AES_128_CCM_8, "TLS-PSK-WITH-AES-128-CCM-8",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
-#endif /* POLARSSL_CCM_C */
-#endif /* POLARSSL_AES_C */
+ { MBEDTLS_TLS_PSK_WITH_AES_128_CCM_8, "TLS-PSK-WITH-AES-128-CCM-8",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+#endif /* MBEDTLS_CCM_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-PSK-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-PSK-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-PSK-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-PSK-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-PSK-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-PSK-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-PSK-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-PSK-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-PSK-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-PSK-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_PSK_WITH_RC4_128_SHA, "TLS-PSK-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_PSK_WITH_RC4_128_SHA, "TLS-PSK-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_PSK_WITH_AES_128_GCM_SHA256, "TLS-DHE-PSK-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256, "TLS-DHE-PSK-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_PSK_WITH_AES_256_GCM_SHA384, "TLS-DHE-PSK-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384, "TLS-DHE-PSK-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_PSK_WITH_AES_128_CBC_SHA256, "TLS-DHE-PSK-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256, "TLS-DHE-PSK-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, "TLS-DHE-PSK-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, "TLS-DHE-PSK-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_PSK_WITH_AES_128_CBC_SHA, "TLS-DHE-PSK-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA, "TLS-DHE-PSK-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_PSK_WITH_AES_256_CBC_SHA, "TLS-DHE-PSK-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA, "TLS-DHE-PSK-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CCM_C)
- { TLS_DHE_PSK_WITH_AES_256_CCM, "TLS-DHE-PSK-WITH-AES-256-CCM",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_CCM_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM, "TLS-DHE-PSK-WITH-AES-256-CCM",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_PSK_WITH_AES_256_CCM_8, "TLS-DHE-PSK-WITH-AES-256-CCM-8",
- POLARSSL_CIPHER_AES_256_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
- { TLS_DHE_PSK_WITH_AES_128_CCM, "TLS-DHE-PSK-WITH-AES-128-CCM",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM_8, "TLS-DHE-PSK-WITH-AES-256-CCM-8",
+ MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM, "TLS-DHE-PSK-WITH-AES-128-CCM",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_DHE_PSK_WITH_AES_128_CCM_8, "TLS-DHE-PSK-WITH-AES-128-CCM-8",
- POLARSSL_CIPHER_AES_128_CCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_SHORT_TAG },
-#endif /* POLARSSL_CCM_C */
-#endif /* POLARSSL_AES_C */
+ { MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM_8, "TLS-DHE-PSK-WITH-AES-128-CCM-8",
+ MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_SHORT_TAG },
+#endif /* MBEDTLS_CCM_C */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-DHE-PSK-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-DHE-PSK-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-DHE-PSK-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-DHE-PSK-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-DHE-PSK-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-DHE-PSK-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-DHE-PSK-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-DHE-PSK-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-DHE-PSK-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-DHE-PSK-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_PSK_WITH_RC4_128_SHA, "TLS-DHE-PSK-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA, "TLS-DHE-PSK-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
-#if defined(POLARSSL_AES_C)
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+#if defined(MBEDTLS_AES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-PSK-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, "TLS-ECDHE-PSK-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-PSK-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384, "TLS-ECDHE-PSK-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA, "TLS-ECDHE-PSK-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA, "TLS-ECDHE-PSK-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, "TLS-ECDHE-PSK-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, "TLS-ECDHE-PSK-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-PSK-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-ECDHE-PSK-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-PSK-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-ECDHE-PSK-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-PSK-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-ECDHE-PSK-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_PSK_WITH_RC4_128_SHA, "TLS-ECDHE-PSK-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA, "TLS-ECDHE-PSK-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
-#if defined(POLARSSL_AES_C)
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_PSK_WITH_AES_128_GCM_SHA256, "TLS-RSA-PSK-WITH-AES-128-GCM-SHA256",
- POLARSSL_CIPHER_AES_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256, "TLS-RSA-PSK-WITH-AES-128-GCM-SHA256",
+ MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, "TLS-RSA-PSK-WITH-AES-256-GCM-SHA384",
- POLARSSL_CIPHER_AES_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, "TLS-RSA-PSK-WITH-AES-256-GCM-SHA384",
+ MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_PSK_WITH_AES_128_CBC_SHA256, "TLS-RSA-PSK-WITH-AES-128-CBC-SHA256",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256, "TLS-RSA-PSK-WITH-AES-128-CBC-SHA256",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_RSA_PSK_WITH_AES_256_CBC_SHA384, "TLS-RSA-PSK-WITH-AES-256-CBC-SHA384",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384, "TLS-RSA-PSK-WITH-AES-256-CBC-SHA384",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
+#endif /* MBEDTLS_SHA512_C */
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_PSK_WITH_AES_128_CBC_SHA, "TLS-RSA-PSK-WITH-AES-128-CBC-SHA",
- POLARSSL_CIPHER_AES_128_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA, "TLS-RSA-PSK-WITH-AES-128-CBC-SHA",
+ MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
- { TLS_RSA_PSK_WITH_AES_256_CBC_SHA, "TLS-RSA-PSK-WITH-AES-256-CBC-SHA",
- POLARSSL_CIPHER_AES_256_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+ { MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA, "TLS-RSA-PSK-WITH-AES-256-CBC-SHA",
+ MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_AES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_AES_C */
-#if defined(POLARSSL_CAMELLIA_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-RSA-PSK-WITH-CAMELLIA-128-CBC-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_CBC, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_CAMELLIA_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, "TLS-RSA-PSK-WITH-CAMELLIA-128-CBC-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-RSA-PSK-WITH-CAMELLIA-256-CBC-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_CBC, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, "TLS-RSA-PSK-WITH-CAMELLIA-256-CBC-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
-#if defined(POLARSSL_GCM_C)
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-RSA-PSK-WITH-CAMELLIA-128-GCM-SHA256",
- POLARSSL_CIPHER_CAMELLIA_128_GCM, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_GCM_C)
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256, "TLS-RSA-PSK-WITH-CAMELLIA-128-GCM-SHA256",
+ MBEDTLS_CIPHER_CAMELLIA_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- { TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-RSA-PSK-WITH-CAMELLIA-256-GCM-SHA384",
- POLARSSL_CIPHER_CAMELLIA_256_GCM, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384, "TLS-RSA-PSK-WITH-CAMELLIA-256-GCM-SHA384",
+ MBEDTLS_CIPHER_CAMELLIA_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_GCM_C */
-#endif /* POLARSSL_CAMELLIA_C */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_GCM_C */
+#endif /* MBEDTLS_CAMELLIA_C */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-RSA-PSK-WITH-3DES-EDE-CBC-SHA",
- POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA, "TLS-RSA-PSK-WITH-3DES-EDE-CBC-SHA",
+ MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
-#if defined(POLARSSL_ARC4_C)
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_PSK_WITH_RC4_128_SHA, "TLS-RSA-PSK-WITH-RC4-128-SHA",
- POLARSSL_CIPHER_ARC4_128, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_NODTLS },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_ARC4_C */
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#if defined(MBEDTLS_ARC4_C)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA, "TLS-RSA-PSK-WITH-RC4-128-SHA",
+ MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_NODTLS },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_ARC4_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_ENABLE_WEAK_CIPHERSUITES)
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
-#if defined(POLARSSL_MD5_C)
- { TLS_RSA_WITH_NULL_MD5, "TLS-RSA-WITH-NULL-MD5",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_MD5, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_ENABLE_WEAK_CIPHERSUITES)
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+#if defined(MBEDTLS_MD5_C)
+ { MBEDTLS_TLS_RSA_WITH_NULL_MD5, "TLS-RSA-WITH-NULL-MD5",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_MD5, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_NULL_SHA, "TLS-RSA-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_NULL_SHA, "TLS-RSA-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_WITH_NULL_SHA256, "TLS-RSA-WITH-NULL-SHA256",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_WITH_NULL_SHA256, "TLS-RSA-WITH-NULL-SHA256",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_PSK_WITH_NULL_SHA, "TLS-PSK-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_PSK_WITH_NULL_SHA, "TLS-PSK-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- { TLS_PSK_WITH_NULL_SHA256, "TLS-PSK-WITH-NULL-SHA256",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_PSK_WITH_NULL_SHA256, "TLS-PSK-WITH-NULL-SHA256",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA512_C)
- { TLS_PSK_WITH_NULL_SHA384, "TLS-PSK-WITH-NULL-SHA384",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_PSK_WITH_NULL_SHA384, "TLS-PSK-WITH-NULL-SHA384",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_PSK_WITH_NULL_SHA, "TLS-DHE-PSK-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA, "TLS-DHE-PSK-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- { TLS_DHE_PSK_WITH_NULL_SHA256, "TLS-DHE-PSK-WITH-NULL-SHA256",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256, "TLS-DHE-PSK-WITH-NULL-SHA256",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA512_C)
- { TLS_DHE_PSK_WITH_NULL_SHA384, "TLS-DHE-PSK-WITH-NULL-SHA384",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_DHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384, "TLS-DHE-PSK-WITH-NULL-SHA384",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_ECDHE_PSK_WITH_NULL_SHA, "TLS-ECDHE-PSK-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA, "TLS-ECDHE-PSK-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- { TLS_ECDHE_PSK_WITH_NULL_SHA256, "TLS-ECDHE-PSK-WITH-NULL-SHA256",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256, "TLS-ECDHE-PSK-WITH-NULL-SHA256",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA512_C)
- { TLS_ECDHE_PSK_WITH_NULL_SHA384, "TLS-ECDHE-PSK-WITH-NULL-SHA384",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_ECDHE_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384, "TLS-ECDHE-PSK-WITH-NULL-SHA384",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_PSK_WITH_NULL_SHA, "TLS-RSA-PSK-WITH-NULL-SHA",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA, "TLS-RSA-PSK-WITH-NULL-SHA",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- { TLS_RSA_PSK_WITH_NULL_SHA256, "TLS-RSA-PSK-WITH-NULL-SHA256",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA256, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA256_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256, "TLS-RSA-PSK-WITH-NULL-SHA256",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#if defined(POLARSSL_SHA512_C)
- { TLS_RSA_PSK_WITH_NULL_SHA384, "TLS-RSA-PSK-WITH-NULL-SHA384",
- POLARSSL_CIPHER_NULL, POLARSSL_MD_SHA384, POLARSSL_KEY_EXCHANGE_RSA_PSK,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_1,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
+#if defined(MBEDTLS_SHA512_C)
+ { MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384, "TLS-RSA-PSK-WITH-NULL-SHA384",
+ MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
#endif
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
-#if defined(POLARSSL_DES_C)
-#if defined(POLARSSL_CIPHER_MODE_CBC)
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_DHE_RSA_WITH_DES_CBC_SHA, "TLS-DHE-RSA-WITH-DES-CBC-SHA",
- POLARSSL_CIPHER_DES_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_DHE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA, "TLS-DHE-RSA-WITH-DES-CBC-SHA",
+ MBEDTLS_CIPHER_DES_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
-#if defined(POLARSSL_SHA1_C)
- { TLS_RSA_WITH_DES_CBC_SHA, "TLS-RSA-WITH-DES-CBC-SHA",
- POLARSSL_CIPHER_DES_CBC, POLARSSL_MD_SHA1, POLARSSL_KEY_EXCHANGE_RSA,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_0,
- SSL_MAJOR_VERSION_3, SSL_MINOR_VERSION_3,
- POLARSSL_CIPHERSUITE_WEAK },
-#endif /* POLARSSL_SHA1_C */
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* POLARSSL_DES_C */
-#endif /* POLARSSL_ENABLE_WEAK_CIPHERSUITES */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+#if defined(MBEDTLS_SHA1_C)
+ { MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA, "TLS-RSA-WITH-DES-CBC-SHA",
+ MBEDTLS_CIPHER_DES_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
+ MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
+ MBEDTLS_CIPHERSUITE_WEAK },
+#endif /* MBEDTLS_SHA1_C */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_DES_C */
+#endif /* MBEDTLS_ENABLE_WEAK_CIPHERSUITES */
{ 0, "",
- POLARSSL_CIPHER_NONE, POLARSSL_MD_NONE, POLARSSL_KEY_EXCHANGE_NONE,
+ MBEDTLS_CIPHER_NONE, MBEDTLS_MD_NONE, MBEDTLS_KEY_EXCHANGE_NONE,
0, 0, 0, 0, 0 }
};
-#if defined(SSL_CIPHERSUITES)
-const int *ssl_list_ciphersuites( void )
+#if defined(MBEDTLS_SSL_CIPHERSUITES)
+const int *mbedtls_ssl_list_ciphersuites( void )
{
return( ciphersuite_preference );
}
@@ -1690,7 +1690,7 @@
static int supported_ciphersuites[MAX_CIPHERSUITES];
static int supported_init = 0;
-const int *ssl_list_ciphersuites( void )
+const int *mbedtls_ssl_list_ciphersuites( void )
{
/*
* On initial call filter out all ciphersuites not supported by current
@@ -1705,12 +1705,12 @@
*p != 0 && q < supported_ciphersuites + MAX_CIPHERSUITES - 1;
p++ )
{
-#if defined(POLARSSL_REMOVE_ARC4_CIPHERSUITES)
- const ssl_ciphersuite_t *cs_info;
- if( ( cs_info = ssl_ciphersuite_from_id( *p ) ) != NULL &&
- cs_info->cipher != POLARSSL_CIPHER_ARC4_128 )
+#if defined(MBEDTLS_REMOVE_ARC4_CIPHERSUITES)
+ const mbedtls_ssl_ciphersuite_t *cs_info;
+ if( ( cs_info = mbedtls_ssl_ciphersuite_from_id( *p ) ) != NULL &&
+ cs_info->cipher != MBEDTLS_CIPHER_ARC4_128 )
#else
- if( ssl_ciphersuite_from_id( *p ) != NULL )
+ if( mbedtls_ssl_ciphersuite_from_id( *p ) != NULL )
#endif
*(q++) = *p;
}
@@ -1721,12 +1721,12 @@
return( supported_ciphersuites );
};
-#endif /* SSL_CIPHERSUITES */
+#endif /* MBEDTLS_SSL_CIPHERSUITES */
-const ssl_ciphersuite_t *ssl_ciphersuite_from_string(
+const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_string(
const char *ciphersuite_name )
{
- const ssl_ciphersuite_t *cur = ciphersuite_definitions;
+ const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
if( NULL == ciphersuite_name )
return( NULL );
@@ -1742,9 +1742,9 @@
return( NULL );
}
-const ssl_ciphersuite_t *ssl_ciphersuite_from_id( int ciphersuite )
+const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_id( int ciphersuite )
{
- const ssl_ciphersuite_t *cur = ciphersuite_definitions;
+ const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
while( cur->id != 0 )
{
@@ -1757,11 +1757,11 @@
return( NULL );
}
-const char *ssl_get_ciphersuite_name( const int ciphersuite_id )
+const char *mbedtls_ssl_get_ciphersuite_name( const int ciphersuite_id )
{
- const ssl_ciphersuite_t *cur;
+ const mbedtls_ssl_ciphersuite_t *cur;
- cur = ssl_ciphersuite_from_id( ciphersuite_id );
+ cur = mbedtls_ssl_ciphersuite_from_id( ciphersuite_id );
if( cur == NULL )
return( "unknown" );
@@ -1769,11 +1769,11 @@
return( cur->name );
}
-int ssl_get_ciphersuite_id( const char *ciphersuite_name )
+int mbedtls_ssl_get_ciphersuite_id( const char *ciphersuite_name )
{
- const ssl_ciphersuite_t *cur;
+ const mbedtls_ssl_ciphersuite_t *cur;
- cur = ssl_ciphersuite_from_string( ciphersuite_name );
+ cur = mbedtls_ssl_ciphersuite_from_string( ciphersuite_name );
if( cur == NULL )
return( 0 );
@@ -1781,63 +1781,63 @@
return( cur->id );
}
-#if defined(POLARSSL_PK_C)
-pk_type_t ssl_get_ciphersuite_sig_pk_alg( const ssl_ciphersuite_t *info )
+#if defined(MBEDTLS_PK_C)
+mbedtls_pk_type_t mbedtls_ssl_get_ciphersuite_sig_pk_alg( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
- case POLARSSL_KEY_EXCHANGE_RSA:
- case POLARSSL_KEY_EXCHANGE_DHE_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDHE_RSA:
- case POLARSSL_KEY_EXCHANGE_RSA_PSK:
- return( POLARSSL_PK_RSA );
+ case MBEDTLS_KEY_EXCHANGE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
+ return( MBEDTLS_PK_RSA );
- case POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA:
- return( POLARSSL_PK_ECDSA );
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
+ return( MBEDTLS_PK_ECDSA );
- case POLARSSL_KEY_EXCHANGE_ECDH_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDH_ECDSA:
- return( POLARSSL_PK_ECKEY );
+ case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
+ return( MBEDTLS_PK_ECKEY );
default:
- return( POLARSSL_PK_NONE );
+ return( MBEDTLS_PK_NONE );
}
}
-#endif /* POLARSSL_PK_C */
+#endif /* MBEDTLS_PK_C */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
-int ssl_ciphersuite_uses_ec( const ssl_ciphersuite_t *info )
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+int mbedtls_ssl_ciphersuite_uses_ec( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
- case POLARSSL_KEY_EXCHANGE_ECDHE_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA:
- case POLARSSL_KEY_EXCHANGE_ECDHE_PSK:
- case POLARSSL_KEY_EXCHANGE_ECDH_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDH_ECDSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
return( 1 );
default:
return( 0 );
}
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
-int ssl_ciphersuite_uses_psk( const ssl_ciphersuite_t *info )
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+int mbedtls_ssl_ciphersuite_uses_psk( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
- case POLARSSL_KEY_EXCHANGE_PSK:
- case POLARSSL_KEY_EXCHANGE_RSA_PSK:
- case POLARSSL_KEY_EXCHANGE_DHE_PSK:
- case POLARSSL_KEY_EXCHANGE_ECDHE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
+ case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
return( 1 );
default:
return( 0 );
}
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#endif /* POLARSSL_SSL_TLS_C */
+#endif /* MBEDTLS_SSL_TLS_C */
diff --git a/library/ssl_cli.c b/library/ssl_cli.c
index 05bfca7..9f04b2b 100644
--- a/library/ssl_cli.c
+++ b/library/ssl_cli.c
@@ -20,25 +20,25 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_CLI_C)
+#if defined(MBEDTLS_SSL_CLI_C)
#include "mbedtls/debug.h"
#include "mbedtls/ssl.h"
#include <string.h>
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
#if defined(_MSC_VER) && !defined(EFIX64) && !defined(EFI32)
@@ -48,19 +48,19 @@
#include <inttypes.h>
#endif
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
#include <time.h>
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
#endif
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
-static void ssl_write_hostname_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
+static void ssl_write_hostname_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
@@ -71,7 +71,7 @@
if( ssl->hostname == NULL )
return;
- SSL_DEBUG_MSG( 3, ( "client hello, adding server name extension: %s",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding server name extension: %s",
ssl->hostname ) );
/*
@@ -92,8 +92,8 @@
* ServerName server_name_list<1..2^16-1>
* } ServerNameList;
*/
- *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SERVERNAME >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SERVERNAME ) & 0xFF );
*p++ = (unsigned char)( ( (ssl->hostname_len + 5) >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( (ssl->hostname_len + 5) ) & 0xFF );
@@ -101,7 +101,7 @@
*p++ = (unsigned char)( ( (ssl->hostname_len + 3) >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( (ssl->hostname_len + 3) ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME_HOSTNAME ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME ) & 0xFF );
*p++ = (unsigned char)( ( ssl->hostname_len >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( ssl->hostname_len ) & 0xFF );
@@ -109,10 +109,10 @@
*olen = ssl->hostname_len + 9;
}
-#endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
-#if defined(POLARSSL_SSL_RENEGOTIATION)
-static void ssl_write_renegotiation_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+static void ssl_write_renegotiation_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
@@ -120,16 +120,16 @@
*olen = 0;
- if( ssl->renego_status != SSL_RENEGOTIATION_IN_PROGRESS )
+ if( ssl->renego_status != MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
return;
- SSL_DEBUG_MSG( 3, ( "client hello, adding renegotiation extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding renegotiation extension" ) );
/*
* Secure renegotiation
*/
- *p++ = (unsigned char)( ( TLS_EXT_RENEGOTIATION_INFO >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_RENEGOTIATION_INFO ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO ) & 0xFF );
*p++ = 0x00;
*p++ = ( ssl->verify_data_len + 1 ) & 0xFF;
@@ -139,82 +139,82 @@
*olen = 5 + ssl->verify_data_len;
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
/*
* Only if we handle at least one key exchange that needs signatures.
*/
-#if defined(POLARSSL_SSL_PROTO_TLS1_2) && \
- defined(POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED)
-static void ssl_write_signature_algorithms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
+ defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
+static void ssl_write_signature_algorithms_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
size_t sig_alg_len = 0;
-#if defined(POLARSSL_RSA_C) || defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_RSA_C) || defined(MBEDTLS_ECDSA_C)
unsigned char *sig_alg_list = buf + 6;
#endif
*olen = 0;
- if( ssl->max_minor_ver != SSL_MINOR_VERSION_3 )
+ if( ssl->max_minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
return;
- SSL_DEBUG_MSG( 3, ( "client hello, adding signature_algorithms extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding signature_algorithms extension" ) );
/*
* Prepare signature_algorithms extension (TLS 1.2)
*/
-#if defined(POLARSSL_RSA_C)
-#if defined(POLARSSL_SHA512_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA512;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA384;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
+#if defined(MBEDTLS_RSA_C)
+#if defined(MBEDTLS_SHA512_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA512;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA384;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
-#if defined(POLARSSL_SHA256_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA256;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA224;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
+#if defined(MBEDTLS_SHA256_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA256;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA224;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
-#if defined(POLARSSL_SHA1_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA1;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
+#if defined(MBEDTLS_SHA1_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA1;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
-#if defined(POLARSSL_MD5_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_MD5;
- sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
+#if defined(MBEDTLS_MD5_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_MD5;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
-#endif /* POLARSSL_RSA_C */
-#if defined(POLARSSL_ECDSA_C)
-#if defined(POLARSSL_SHA512_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA512;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA384;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
+#endif /* MBEDTLS_RSA_C */
+#if defined(MBEDTLS_ECDSA_C)
+#if defined(MBEDTLS_SHA512_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA512;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA384;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
-#if defined(POLARSSL_SHA256_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA256;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA224;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
+#if defined(MBEDTLS_SHA256_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA256;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA224;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
-#if defined(POLARSSL_SHA1_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_SHA1;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
+#if defined(MBEDTLS_SHA1_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_SHA1;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
-#if defined(POLARSSL_MD5_C)
- sig_alg_list[sig_alg_len++] = SSL_HASH_MD5;
- sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
+#if defined(MBEDTLS_MD5_C)
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_HASH_MD5;
+ sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
/*
* enum {
- * none(0), md5(1), sha1(2), sha224(3), sha256(4), sha384(5),
- * sha512(6), (255)
+ * none(0), mbedtls_md5(1), mbedtls_sha1(2), sha224(3), mbedtls_sha256(4), sha384(5),
+ * mbedtls_sha512(6), (255)
* } HashAlgorithm;
*
* enum { anonymous(0), rsa(1), dsa(2), ecdsa(3), (255) }
@@ -228,8 +228,8 @@
* SignatureAndHashAlgorithm
* supported_signature_algorithms<2..2^16-2>;
*/
- *p++ = (unsigned char)( ( TLS_EXT_SIG_ALG >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SIG_ALG ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SIG_ALG >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SIG_ALG ) & 0xFF );
*p++ = (unsigned char)( ( ( sig_alg_len + 2 ) >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( ( sig_alg_len + 2 ) ) & 0xFF );
@@ -239,34 +239,34 @@
*olen = 6 + sig_alg_len;
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 &&
- POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
+ MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
-static void ssl_write_supported_elliptic_curves_ext( ssl_context *ssl,
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+static void ssl_write_supported_elliptic_curves_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
unsigned char *elliptic_curve_list = p + 6;
size_t elliptic_curve_len = 0;
- const ecp_curve_info *info;
-#if defined(POLARSSL_SSL_SET_CURVES)
- const ecp_group_id *grp_id;
+ const mbedtls_ecp_curve_info *info;
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ const mbedtls_ecp_group_id *grp_id;
#else
((void) ssl);
#endif
*olen = 0;
- SSL_DEBUG_MSG( 3, ( "client hello, adding supported_elliptic_curves extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding supported_elliptic_curves extension" ) );
-#if defined(POLARSSL_SSL_SET_CURVES)
- for( grp_id = ssl->curve_list; *grp_id != POLARSSL_ECP_DP_NONE; grp_id++ )
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ for( grp_id = ssl->curve_list; *grp_id != MBEDTLS_ECP_DP_NONE; grp_id++ )
{
- info = ecp_curve_info_from_grp_id( *grp_id );
+ info = mbedtls_ecp_curve_info_from_grp_id( *grp_id );
#else
- for( info = ecp_curve_list(); info->grp_id != POLARSSL_ECP_DP_NONE; info++ )
+ for( info = mbedtls_ecp_curve_list(); info->grp_id != MBEDTLS_ECP_DP_NONE; info++ )
{
#endif
@@ -277,8 +277,8 @@
if( elliptic_curve_len == 0 )
return;
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_ELLIPTIC_CURVES >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_ELLIPTIC_CURVES ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES ) & 0xFF );
*p++ = (unsigned char)( ( ( elliptic_curve_len + 2 ) >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( ( elliptic_curve_len + 2 ) ) & 0xFF );
@@ -289,7 +289,7 @@
*olen = 6 + elliptic_curve_len;
}
-static void ssl_write_supported_point_formats_ext( ssl_context *ssl,
+static void ssl_write_supported_point_formats_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
@@ -298,37 +298,37 @@
*olen = 0;
- SSL_DEBUG_MSG( 3, ( "client hello, adding supported_point_formats extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding supported_point_formats extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_POINT_FORMATS >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_POINT_FORMATS ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS ) & 0xFF );
*p++ = 0x00;
*p++ = 2;
*p++ = 1;
- *p++ = POLARSSL_ECP_PF_UNCOMPRESSED;
+ *p++ = MBEDTLS_ECP_PF_UNCOMPRESSED;
*olen = 6;
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
-static void ssl_write_max_fragment_length_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+static void ssl_write_max_fragment_length_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- if( ssl->mfl_code == SSL_MAX_FRAG_LEN_NONE ) {
+ if( ssl->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE ) {
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding max_fragment_length extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding max_fragment_length extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_MAX_FRAGMENT_LENGTH >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_MAX_FRAGMENT_LENGTH ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH ) & 0xFF );
*p++ = 0x00;
*p++ = 1;
@@ -337,101 +337,101 @@
*olen = 5;
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
-static void ssl_write_truncated_hmac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+static void ssl_write_truncated_hmac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
unsigned char *p = buf;
- if( ssl->trunc_hmac == SSL_TRUNC_HMAC_DISABLED )
+ if( ssl->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding truncated_hmac extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding truncated_hmac extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_TRUNCATED_HMAC >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_TRUNCATED_HMAC ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_TRUNCATED_HMAC >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_TRUNCATED_HMAC ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
-static void ssl_write_encrypt_then_mac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+static void ssl_write_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
unsigned char *p = buf;
- if( ssl->encrypt_then_mac == SSL_ETM_DISABLED ||
- ssl->max_minor_ver == SSL_MINOR_VERSION_0 )
+ if( ssl->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED ||
+ ssl->max_minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding encrypt_then_mac "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding encrypt_then_mac "
"extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_ENCRYPT_THEN_MAC >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_ENCRYPT_THEN_MAC ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
-static void ssl_write_extended_ms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+static void ssl_write_extended_ms_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
unsigned char *p = buf;
- if( ssl->extended_ms == SSL_EXTENDED_MS_DISABLED ||
- ssl->max_minor_ver == SSL_MINOR_VERSION_0 )
+ if( ssl->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
+ ssl->max_minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding extended_master_secret "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding extended_master_secret "
"extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_EXTENDED_MASTER_SECRET >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_EXTENDED_MASTER_SECRET ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static void ssl_write_session_ticket_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static void ssl_write_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
unsigned char *p = buf;
size_t tlen = ssl->session_negotiate->ticket_len;
- if( ssl->session_tickets == SSL_SESSION_TICKETS_DISABLED )
+ if( ssl->session_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding session ticket extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding session ticket extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_SESSION_TICKET >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SESSION_TICKET ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET ) & 0xFF );
*p++ = (unsigned char)( ( tlen >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( tlen ) & 0xFF );
@@ -444,16 +444,16 @@
return;
}
- SSL_DEBUG_MSG( 3, ( "sending session ticket of length %d", tlen ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "sending session ticket of length %d", tlen ) );
memcpy( p, ssl->session_negotiate->ticket, tlen );
*olen += tlen;
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_SSL_ALPN)
-static void ssl_write_alpn_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ALPN)
+static void ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
unsigned char *p = buf;
@@ -465,10 +465,10 @@
return;
}
- SSL_DEBUG_MSG( 3, ( "client hello, adding alpn extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding alpn extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_ALPN >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_ALPN ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN ) & 0xFF );
/*
* opaque ProtocolName<1..2^8-1>;
@@ -498,44 +498,44 @@
buf[2] = (unsigned char)( ( ( *olen - 4 ) >> 8 ) & 0xFF );
buf[3] = (unsigned char)( ( ( *olen - 4 ) ) & 0xFF );
}
-#endif /* POLARSSL_SSL_ALPN */
+#endif /* MBEDTLS_SSL_ALPN */
/*
* Generate random bytes for ClientHello
*/
-static int ssl_generate_random( ssl_context *ssl )
+static int ssl_generate_random( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *p = ssl->handshake->randbytes;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
time_t t;
#endif
/*
* When responding to a verify request, MUST reuse random (RFC 6347 4.2.1)
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->verify_cookie != NULL )
{
return( 0 );
}
#endif
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
t = time( NULL );
*p++ = (unsigned char)( t >> 24 );
*p++ = (unsigned char)( t >> 16 );
*p++ = (unsigned char)( t >> 8 );
*p++ = (unsigned char)( t );
- SSL_DEBUG_MSG( 3, ( "client hello, current time: %lu", t ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, current time: %lu", t ) );
#else
if( ( ret = ssl->f_rng( ssl->p_rng, p, 4 ) ) != 0 )
return( ret );
p += 4;
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
if( ( ret = ssl->f_rng( ssl->p_rng, p, 28 ) ) != 0 )
return( ret );
@@ -543,7 +543,7 @@
return( 0 );
}
-static int ssl_write_client_hello( ssl_context *ssl )
+static int ssl_write_client_hello( mbedtls_ssl_context *ssl )
{
int ret;
size_t i, n, olen, ext_len = 0;
@@ -551,18 +551,18 @@
unsigned char *p, *q;
unsigned char offer_compress;
const int *ciphersuites;
- const ssl_ciphersuite_t *ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> write client hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write client hello" ) );
if( ssl->f_rng == NULL )
{
- SSL_DEBUG_MSG( 1, ( "no RNG provided") );
- return( POLARSSL_ERR_SSL_NO_RNG );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "no RNG provided") );
+ return( MBEDTLS_ERR_SSL_NO_RNG );
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
#endif
{
ssl->major_ver = ssl->min_major_ver;
@@ -571,8 +571,8 @@
if( ssl->max_major_ver == 0 && ssl->max_minor_ver == 0 )
{
- ssl->max_major_ver = SSL_MAX_MAJOR_VERSION;
- ssl->max_minor_ver = SSL_MAX_MINOR_VERSION;
+ ssl->max_major_ver = MBEDTLS_SSL_MAX_MAJOR_VERSION;
+ ssl->max_minor_ver = MBEDTLS_SSL_MAX_MINOR_VERSION;
}
/*
@@ -585,21 +585,21 @@
buf = ssl->out_msg;
p = buf + 4;
- ssl_write_version( ssl->max_major_ver, ssl->max_minor_ver,
+ mbedtls_ssl_write_version( ssl->max_major_ver, ssl->max_minor_ver,
ssl->transport, p );
p += 2;
- SSL_DEBUG_MSG( 3, ( "client hello, max version: [%d:%d]",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, max version: [%d:%d]",
buf[4], buf[5] ) );
if( ( ret = ssl_generate_random( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_generate_random", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_generate_random", ret );
return( ret );
}
memcpy( p, ssl->handshake->randbytes, 32 );
- SSL_DEBUG_BUF( 3, "client hello, random bytes", p, 32 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, random bytes", p, 32 );
p += 32;
/*
@@ -617,21 +617,21 @@
n = ssl->session_negotiate->length;
if( n < 16 || n > 32 ||
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- ssl->renego_status != SSL_INITIAL_HANDSHAKE ||
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE ||
#endif
ssl->handshake->resume == 0 )
{
n = 0;
}
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
/*
* RFC 5077 section 3.4: "When presenting a ticket, the client MAY
* generate and include a Session ID in the TLS ClientHello."
*/
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
#endif
{
if( ssl->session_negotiate->ticket != NULL &&
@@ -645,30 +645,30 @@
ssl->session_negotiate->length = n = 32;
}
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
*p++ = (unsigned char) n;
for( i = 0; i < n; i++ )
*p++ = ssl->session_negotiate->id[i];
- SSL_DEBUG_MSG( 3, ( "client hello, session id len.: %d", n ) );
- SSL_DEBUG_BUF( 3, "client hello, session id", buf + 39, n );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, session id len.: %d", n ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id", buf + 39, n );
/*
* DTLS cookie
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
if( ssl->handshake->verify_cookie == NULL )
{
- SSL_DEBUG_MSG( 3, ( "no verify cookie to send" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "no verify cookie to send" ) );
*p++ = 0;
}
else
{
- SSL_DEBUG_BUF( 3, "client hello, cookie",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, cookie",
ssl->handshake->verify_cookie,
ssl->handshake->verify_cookie_len );
@@ -692,7 +692,7 @@
for( i = 0; ciphersuites[i] != 0; i++ )
{
- ciphersuite_info = ssl_ciphersuite_from_id( ciphersuites[i] );
+ ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( ciphersuites[i] );
if( ciphersuite_info == NULL )
continue;
@@ -701,17 +701,17 @@
ciphersuite_info->max_minor_ver < ssl->min_minor_ver )
continue;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
- ( ciphersuite_info->flags & POLARSSL_CIPHERSUITE_NODTLS ) )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
+ ( ciphersuite_info->flags & MBEDTLS_CIPHERSUITE_NODTLS ) )
continue;
#endif
- if( ssl->arc4_disabled == SSL_ARC4_DISABLED &&
- ciphersuite_info->cipher == POLARSSL_CIPHER_ARC4_128 )
+ if( ssl->arc4_disabled == MBEDTLS_SSL_ARC4_DISABLED &&
+ ciphersuite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
continue;
- SSL_DEBUG_MSG( 3, ( "client hello, add ciphersuite: %2d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, add ciphersuite: %2d",
ciphersuites[i] ) );
n++;
@@ -722,22 +722,22 @@
/*
* Add TLS_EMPTY_RENEGOTIATION_INFO_SCSV
*/
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
#endif
{
- *p++ = (unsigned char)( SSL_EMPTY_RENEGOTIATION_INFO >> 8 );
- *p++ = (unsigned char)( SSL_EMPTY_RENEGOTIATION_INFO );
+ *p++ = (unsigned char)( MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO >> 8 );
+ *p++ = (unsigned char)( MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO );
n++;
}
/* Some versions of OpenSSL don't handle it correctly if not at end */
-#if defined(POLARSSL_SSL_FALLBACK_SCSV)
- if( ssl->fallback == SSL_IS_FALLBACK )
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
+ if( ssl->fallback == MBEDTLS_SSL_IS_FALLBACK )
{
- SSL_DEBUG_MSG( 3, ( "adding FALLBACK_SCSV" ) );
- *p++ = (unsigned char)( SSL_FALLBACK_SCSV_VALUE >> 8 );
- *p++ = (unsigned char)( SSL_FALLBACK_SCSV_VALUE );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "adding FALLBACK_SCSV" ) );
+ *p++ = (unsigned char)( MBEDTLS_SSL_FALLBACK_SCSV_VALUE >> 8 );
+ *p++ = (unsigned char)( MBEDTLS_SSL_FALLBACK_SCSV_VALUE );
n++;
}
#endif
@@ -745,9 +745,9 @@
*q++ = (unsigned char)( n >> 7 );
*q++ = (unsigned char)( n << 1 );
- SSL_DEBUG_MSG( 3, ( "client hello, got %d ciphersuites", n ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, got %d ciphersuites", n ) );
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
offer_compress = 1;
#else
offer_compress = 0;
@@ -759,50 +759,50 @@
* We don't want to add complexity for handling that case unless there is
* an actual need for it.
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
offer_compress = 0;
#endif
if( offer_compress )
{
- SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 2 ) );
- SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d %d",
- SSL_COMPRESS_DEFLATE, SSL_COMPRESS_NULL ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 2 ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d %d",
+ MBEDTLS_SSL_COMPRESS_DEFLATE, MBEDTLS_SSL_COMPRESS_NULL ) );
*p++ = 2;
- *p++ = SSL_COMPRESS_DEFLATE;
- *p++ = SSL_COMPRESS_NULL;
+ *p++ = MBEDTLS_SSL_COMPRESS_DEFLATE;
+ *p++ = MBEDTLS_SSL_COMPRESS_NULL;
}
else
{
- SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 1 ) );
- SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d",
- SSL_COMPRESS_NULL ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 1 ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d",
+ MBEDTLS_SSL_COMPRESS_NULL ) );
*p++ = 1;
- *p++ = SSL_COMPRESS_NULL;
+ *p++ = MBEDTLS_SSL_COMPRESS_NULL;
}
// First write extensions, then the total length
//
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
ssl_write_hostname_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl_write_renegotiation_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2) && \
- defined(POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED)
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
+ defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
ssl_write_signature_algorithms_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
ssl_write_supported_elliptic_curves_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
@@ -810,32 +810,32 @@
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
ssl_write_max_fragment_length_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
ssl_write_truncated_hmac_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
ssl_write_encrypt_then_mac_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
ssl_write_extended_ms_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
ssl_write_session_ticket_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_ALPN)
+#if defined(MBEDTLS_SSL_ALPN)
ssl_write_alpn_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
@@ -843,7 +843,7 @@
/* olen unused if all extensions are disabled */
((void) olen);
- SSL_DEBUG_MSG( 3, ( "client hello, total extension length: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, total extension length: %d",
ext_len ) );
if( ext_len > 0 )
@@ -854,73 +854,73 @@
}
ssl->out_msglen = p - buf;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_CLIENT_HELLO;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_CLIENT_HELLO;
ssl->state++;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_send_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_send_flight_completed( ssl );
#endif
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write client hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write client hello" ) );
return( 0 );
}
-static int ssl_parse_renegotiation_info( ssl_context *ssl,
+static int ssl_parse_renegotiation_info( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
int ret;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
/* Check verify-data in constant-time. The length OTOH is no secret */
if( len != 1 + ssl->verify_data_len * 2 ||
buf[0] != ssl->verify_data_len * 2 ||
- safer_memcmp( buf + 1,
+ mbedtls_ssl_safer_memcmp( buf + 1,
ssl->own_verify_data, ssl->verify_data_len ) != 0 ||
- safer_memcmp( buf + 1 + ssl->verify_data_len,
+ mbedtls_ssl_safer_memcmp( buf + 1 + ssl->verify_data_len,
ssl->peer_verify_data, ssl->verify_data_len ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
}
else
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
if( len != 1 || buf[0] != 0x00 )
{
- SSL_DEBUG_MSG( 1, ( "non-zero length renegotiation info" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-zero length renegotiation info" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
- ssl->secure_renegotiation = SSL_SECURE_RENEGOTIATION;
+ ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
}
return( 0 );
}
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
-static int ssl_parse_max_fragment_length_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+static int ssl_parse_max_fragment_length_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
@@ -928,85 +928,85 @@
* server should use the extension only if we did,
* and if so the server's value should match ours (and len is always 1)
*/
- if( ssl->mfl_code == SSL_MAX_FRAG_LEN_NONE ||
+ if( ssl->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE ||
len != 1 ||
buf[0] != ssl->mfl_code )
{
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
return( 0 );
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
-static int ssl_parse_truncated_hmac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+static int ssl_parse_truncated_hmac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
- if( ssl->trunc_hmac == SSL_TRUNC_HMAC_DISABLED ||
+ if( ssl->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED ||
len != 0 )
{
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
((void) buf);
- ssl->session_negotiate->trunc_hmac = SSL_TRUNC_HMAC_ENABLED;
+ ssl->session_negotiate->trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED;
return( 0 );
}
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
-static int ssl_parse_encrypt_then_mac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+static int ssl_parse_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
- if( ssl->encrypt_then_mac == SSL_ETM_DISABLED ||
- ssl->minor_ver == SSL_MINOR_VERSION_0 ||
+ if( ssl->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
len != 0 )
{
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
((void) buf);
- ssl->session_negotiate->encrypt_then_mac = SSL_ETM_ENABLED;
+ ssl->session_negotiate->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
return( 0 );
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
-static int ssl_parse_extended_ms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
- if( ssl->extended_ms == SSL_EXTENDED_MS_DISABLED ||
- ssl->minor_ver == SSL_MINOR_VERSION_0 ||
+ if( ssl->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
len != 0 )
{
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
((void) buf);
- ssl->handshake->extended_ms = SSL_EXTENDED_MS_ENABLED;
+ ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
return( 0 );
}
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static int ssl_parse_session_ticket_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static int ssl_parse_session_ticket_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
- if( ssl->session_tickets == SSL_SESSION_TICKETS_DISABLED ||
+ if( ssl->session_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED ||
len != 0 )
{
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
((void) buf);
@@ -1015,10 +1015,10 @@
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
-static int ssl_parse_supported_point_formats_ext( ssl_context *ssl,
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+static int ssl_parse_supported_point_formats_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
@@ -1028,18 +1028,18 @@
list_size = buf[0];
if( list_size + 1 != len )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
p = buf + 1;
while( list_size > 0 )
{
- if( p[0] == POLARSSL_ECP_PF_UNCOMPRESSED ||
- p[0] == POLARSSL_ECP_PF_COMPRESSED )
+ if( p[0] == MBEDTLS_ECP_PF_UNCOMPRESSED ||
+ p[0] == MBEDTLS_ECP_PF_COMPRESSED )
{
ssl->handshake->ecdh_ctx.point_format = p[0];
- SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
return( 0 );
}
@@ -1047,13 +1047,13 @@
p++;
}
- SSL_DEBUG_MSG( 1, ( "no point format in common" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "no point format in common" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_ALPN)
-static int ssl_parse_alpn_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ALPN)
+static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, name_len;
@@ -1061,7 +1061,7 @@
/* If we didn't send it, the server shouldn't send it */
if( ssl->alpn_list == NULL )
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
/*
* opaque ProtocolName<1..2^8-1>;
@@ -1075,15 +1075,15 @@
/* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
if( len < 4 )
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
list_len = ( buf[0] << 8 ) | buf[1];
if( list_len != len - 2 )
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
name_len = buf[2];
if( name_len != list_len - 1 )
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
/* Check that the server chosen protocol was in our list and save it */
for( p = ssl->alpn_list; *p != NULL; p++ )
@@ -1096,21 +1096,21 @@
}
}
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
-#endif /* POLARSSL_SSL_ALPN */
+#endif /* MBEDTLS_SSL_ALPN */
/*
* Parse HelloVerifyRequest. Only called after verifying the HS type.
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
-static int ssl_parse_hello_verify_request( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+static int ssl_parse_hello_verify_request( mbedtls_ssl_context *ssl )
{
- const unsigned char *p = ssl->in_msg + ssl_hs_hdr_len( ssl );
+ const unsigned char *p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
int major_ver, minor_ver;
unsigned char cookie_len;
- SSL_DEBUG_MSG( 2, ( "=> parse hello verify request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse hello verify request" ) );
/*
* struct {
@@ -1118,128 +1118,128 @@
* opaque cookie<0..2^8-1>;
* } HelloVerifyRequest;
*/
- SSL_DEBUG_BUF( 3, "server version", p, 2 );
- ssl_read_version( &major_ver, &minor_ver, ssl->transport, p );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
+ mbedtls_ssl_read_version( &major_ver, &minor_ver, ssl->transport, p );
p += 2;
/*
* Since the RFC is not clear on this point, accept DTLS 1.0 (TLS 1.1)
* even is lower than our min version.
*/
- if( major_ver < SSL_MAJOR_VERSION_3 ||
- minor_ver < SSL_MINOR_VERSION_2 ||
+ if( major_ver < MBEDTLS_SSL_MAJOR_VERSION_3 ||
+ minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 ||
major_ver > ssl->max_major_ver ||
minor_ver > ssl->max_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "bad server version" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server version" ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_PROTOCOL_VERSION );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
- return( POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
+ return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
cookie_len = *p++;
- SSL_DEBUG_BUF( 3, "cookie", p, cookie_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "cookie", p, cookie_len );
- polarssl_free( ssl->handshake->verify_cookie );
+ mbedtls_free( ssl->handshake->verify_cookie );
- ssl->handshake->verify_cookie = polarssl_malloc( cookie_len );
+ ssl->handshake->verify_cookie = mbedtls_malloc( cookie_len );
if( ssl->handshake->verify_cookie == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc failed (%d bytes)", cookie_len ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc failed (%d bytes)", cookie_len ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
memcpy( ssl->handshake->verify_cookie, p, cookie_len );
ssl->handshake->verify_cookie_len = cookie_len;
/* Start over at ClientHello */
- ssl->state = SSL_CLIENT_HELLO;
- ssl_reset_checksum( ssl );
+ ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
+ mbedtls_ssl_reset_checksum( ssl );
- ssl_recv_flight_completed( ssl );
+ mbedtls_ssl_recv_flight_completed( ssl );
- SSL_DEBUG_MSG( 2, ( "<= parse hello verify request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse hello verify request" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
-static int ssl_parse_server_hello( ssl_context *ssl )
+static int ssl_parse_server_hello( mbedtls_ssl_context *ssl )
{
int ret, i;
size_t n;
size_t ext_len;
unsigned char *buf, *ext;
unsigned char comp, accept_comp;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renegotiation_info_seen = 0;
#endif
int handshake_failure = 0;
- const ssl_ciphersuite_t *suite_info;
-#if defined(POLARSSL_DEBUG_C)
+ const mbedtls_ssl_ciphersuite_t *suite_info;
+#if defined(MBEDTLS_DEBUG_C)
uint32_t t;
#endif
- SSL_DEBUG_MSG( 2, ( "=> parse server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello" ) );
buf = ssl->in_msg;
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
ssl->renego_records_seen++;
if( ssl->renego_max_records >= 0 &&
ssl->renego_records_seen > ssl->renego_max_records )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
"but not honored by server" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
- SSL_DEBUG_MSG( 1, ( "non-handshake message during renego" ) );
- return( POLARSSL_ERR_SSL_WAITING_SERVER_HELLO_RENEGO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-handshake message during renego" ) );
+ return( MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
- if( buf[0] == SSL_HS_HELLO_VERIFY_REQUEST )
+ if( buf[0] == MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST )
{
- SSL_DEBUG_MSG( 2, ( "received hello verify request" ) );
- SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "received hello verify request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
return( ssl_parse_hello_verify_request( ssl ) );
}
else
{
/* We made it through the verification process */
- polarssl_free( ssl->handshake->verify_cookie );
+ mbedtls_free( ssl->handshake->verify_cookie );
ssl->handshake->verify_cookie = NULL;
ssl->handshake->verify_cookie_len = 0;
}
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
- if( ssl->in_hslen < 38 + ssl_hs_hdr_len( ssl ) ||
- buf[0] != SSL_HS_SERVER_HELLO )
+ if( ssl->in_hslen < 38 + mbedtls_ssl_hs_hdr_len( ssl ) ||
+ buf[0] != MBEDTLS_SSL_HS_SERVER_HELLO )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
/*
@@ -1253,10 +1253,10 @@
* 38+n . 39+n extensions length (optional)
* 40+n . .. extensions
*/
- buf += ssl_hs_hdr_len( ssl );
+ buf += mbedtls_ssl_hs_hdr_len( ssl );
- SSL_DEBUG_BUF( 3, "server hello, version", buf + 0, 2 );
- ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, version", buf + 0, 2 );
+ mbedtls_ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
ssl->transport, buf + 0 );
if( ssl->major_ver < ssl->min_major_ver ||
@@ -1264,36 +1264,36 @@
ssl->major_ver > ssl->max_major_ver ||
ssl->minor_ver > ssl->max_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "server version out of bounds - "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "server version out of bounds - "
" min: [%d:%d], server: [%d:%d], max: [%d:%d]",
ssl->min_major_ver, ssl->min_minor_ver,
ssl->major_ver, ssl->minor_ver,
ssl->max_major_ver, ssl->max_minor_ver ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_PROTOCOL_VERSION );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
- return( POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
+ return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
-#if defined(POLARSSL_DEBUG_C)
+#if defined(MBEDTLS_DEBUG_C)
t = ( (uint32_t) buf[2] << 24 )
| ( (uint32_t) buf[3] << 16 )
| ( (uint32_t) buf[4] << 8 )
| ( (uint32_t) buf[5] );
- SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
#endif
memcpy( ssl->handshake->randbytes + 32, buf + 2, 32 );
n = buf[34];
- SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 2, 32 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 2, 32 );
if( n > 32 )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
if( ssl->in_hslen > 39 + n )
@@ -1302,10 +1302,10 @@
| ( buf[39 + n] ) );
if( ( ext_len > 0 && ext_len < 4 ) ||
- ssl->in_hslen != ssl_hs_hdr_len( ssl ) + 40 + n + ext_len )
+ ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + 40 + n + ext_len )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
}
else if( ssl->in_hslen == 38 + n )
@@ -1314,8 +1314,8 @@
}
else
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
/* ciphersuite (used later) */
@@ -1326,47 +1326,47 @@
*/
comp = buf[37 + n];
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
accept_comp = 1;
#else
accept_comp = 0;
#endif
/* See comments in ssl_write_client_hello() */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
accept_comp = 0;
#endif
- if( ( accept_comp == 0 && comp != SSL_COMPRESS_NULL ) ||
- ( comp != SSL_COMPRESS_NULL && comp != SSL_COMPRESS_DEFLATE ) )
+ if( ( accept_comp == 0 && comp != MBEDTLS_SSL_COMPRESS_NULL ) ||
+ ( comp != MBEDTLS_SSL_COMPRESS_NULL && comp != MBEDTLS_SSL_COMPRESS_DEFLATE ) )
{
- SSL_DEBUG_MSG( 1, ( "server hello, bad compression: %d", comp ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "server hello, bad compression: %d", comp ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
/*
* Initialize update checksum functions
*/
- ssl->transform_negotiate->ciphersuite_info = ssl_ciphersuite_from_id( i );
+ ssl->transform_negotiate->ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( i );
if( ssl->transform_negotiate->ciphersuite_info == NULL )
{
- SSL_DEBUG_MSG( 1, ( "ciphersuite info for %04x not found", i ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "ciphersuite info for %04x not found", i ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
- ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
+ mbedtls_ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
- SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
- SSL_DEBUG_BUF( 3, "server hello, session id", buf + 35, n );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, session id", buf + 35, n );
/*
* Check if the session can be resumed
*/
if( ssl->handshake->resume == 0 || n == 0 ||
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- ssl->renego_status != SSL_INITIAL_HANDSHAKE ||
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE ||
#endif
ssl->session_negotiate->ciphersuite != i ||
ssl->session_negotiate->compression != comp ||
@@ -1375,7 +1375,7 @@
{
ssl->state++;
ssl->handshake->resume = 0;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
ssl->session_negotiate->start = time( NULL );
#endif
ssl->session_negotiate->ciphersuite = i;
@@ -1385,28 +1385,28 @@
}
else
{
- ssl->state = SSL_SERVER_CHANGE_CIPHER_SPEC;
+ ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
- if( ( ret = ssl_derive_keys( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_derive_keys", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
}
- SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
ssl->handshake->resume ? "a" : "no" ) );
- SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %d", i ) );
- SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: %d", buf[37 + n] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %d", i ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: %d", buf[37 + n] ) );
- suite_info = ssl_ciphersuite_from_id( ssl->session_negotiate->ciphersuite );
+ suite_info = mbedtls_ssl_ciphersuite_from_id( ssl->session_negotiate->ciphersuite );
if( suite_info == NULL ||
( ssl->arc4_disabled &&
- suite_info->cipher == POLARSSL_CIPHER_ARC4_128 ) )
+ suite_info->cipher == MBEDTLS_CIPHER_ARC4_128 ) )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
@@ -1415,8 +1415,8 @@
{
if( ssl->ciphersuite_list[ssl->minor_ver][i] == 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
if( ssl->ciphersuite_list[ssl->minor_ver][i++] ==
@@ -1426,20 +1426,20 @@
}
}
- if( comp != SSL_COMPRESS_NULL
-#if defined(POLARSSL_ZLIB_SUPPORT)
- && comp != SSL_COMPRESS_DEFLATE
+ if( comp != MBEDTLS_SSL_COMPRESS_NULL
+#if defined(MBEDTLS_ZLIB_SUPPORT)
+ && comp != MBEDTLS_SSL_COMPRESS_DEFLATE
#endif
)
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
ssl->session_negotiate->compression = comp;
ext = buf + 40 + n;
- SSL_DEBUG_MSG( 2, ( "server hello, total extension length: %d", ext_len ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "server hello, total extension length: %d", ext_len ) );
while( ext_len )
{
@@ -1450,15 +1450,15 @@
if( ext_size + 4 > ext_len )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
switch( ext_id )
{
- case TLS_EXT_RENEGOTIATION_INFO:
- SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+ case MBEDTLS_TLS_EXT_RENEGOTIATION_INFO:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
renegotiation_info_seen = 1;
#endif
@@ -1468,9 +1468,9 @@
break;
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
- case TLS_EXT_MAX_FRAGMENT_LENGTH:
- SSL_DEBUG_MSG( 3, ( "found max_fragment_length extension" ) );
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+ case MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found max_fragment_length extension" ) );
if( ( ret = ssl_parse_max_fragment_length_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1479,11 +1479,11 @@
}
break;
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
- case TLS_EXT_TRUNCATED_HMAC:
- SSL_DEBUG_MSG( 3, ( "found truncated_hmac extension" ) );
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+ case MBEDTLS_TLS_EXT_TRUNCATED_HMAC:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found truncated_hmac extension" ) );
if( ( ret = ssl_parse_truncated_hmac_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1492,11 +1492,11 @@
}
break;
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- case TLS_EXT_ENCRYPT_THEN_MAC:
- SSL_DEBUG_MSG( 3, ( "found encrypt_then_mac extension" ) );
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ case MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found encrypt_then_mac extension" ) );
if( ( ret = ssl_parse_encrypt_then_mac_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1505,11 +1505,11 @@
}
break;
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
- case TLS_EXT_EXTENDED_MASTER_SECRET:
- SSL_DEBUG_MSG( 3, ( "found extended_master_secret extension" ) );
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+ case MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found extended_master_secret extension" ) );
if( ( ret = ssl_parse_extended_ms_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1518,11 +1518,11 @@
}
break;
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- case TLS_EXT_SESSION_TICKET:
- SSL_DEBUG_MSG( 3, ( "found session_ticket extension" ) );
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ case MBEDTLS_TLS_EXT_SESSION_TICKET:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found session_ticket extension" ) );
if( ( ret = ssl_parse_session_ticket_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1531,11 +1531,11 @@
}
break;
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
- case TLS_EXT_SUPPORTED_POINT_FORMATS:
- SSL_DEBUG_MSG( 3, ( "found supported_point_formats extension" ) );
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+ case MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found supported_point_formats extension" ) );
if( ( ret = ssl_parse_supported_point_formats_ext( ssl,
ext + 4, ext_size ) ) != 0 )
@@ -1544,20 +1544,20 @@
}
break;
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_ALPN)
- case TLS_EXT_ALPN:
- SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
+#if defined(MBEDTLS_SSL_ALPN)
+ case MBEDTLS_TLS_EXT_ALPN:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
if( ( ret = ssl_parse_alpn_ext( ssl, ext + 4, ext_size ) ) != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_ALPN */
+#endif /* MBEDTLS_SSL_ALPN */
default:
- SSL_DEBUG_MSG( 3, ( "unknown extension found: %d (ignoring)",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "unknown extension found: %d (ignoring)",
ext_id ) );
}
@@ -1566,63 +1566,63 @@
if( ext_len > 0 && ext_len < 4 )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
}
/*
* Renegotiation security checks
*/
- if( ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
- ssl->allow_legacy_renegotiation == SSL_LEGACY_BREAK_HANDSHAKE )
+ if( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
+ ssl->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
handshake_failure = 1;
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_SECURE_RENEGOTIATION &&
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_SECURE_RENEGOTIATION &&
renegotiation_info_seen == 0 )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation_info extension missing (secure)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension missing (secure)" ) );
handshake_failure = 1;
}
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
- ssl->allow_legacy_renegotiation == SSL_LEGACY_NO_RENEGOTIATION )
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
+ ssl->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION )
{
- SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
handshake_failure = 1;
}
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
renegotiation_info_seen == 1 )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation_info extension present (legacy)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension present (legacy)" ) );
handshake_failure = 1;
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
if( handshake_failure == 1 )
{
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
}
- SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
return( 0 );
}
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
-static int ssl_parse_server_dh_params( ssl_context *ssl, unsigned char **p,
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+static int ssl_parse_server_dh_params( mbedtls_ssl_context *ssl, unsigned char **p,
unsigned char *end )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
/*
* Ephemeral DH parameters:
@@ -1633,72 +1633,72 @@
* opaque dh_Ys<1..2^16-1>;
* } ServerDHParams;
*/
- if( ( ret = dhm_read_params( &ssl->handshake->dhm_ctx, p, end ) ) != 0 )
+ if( ( ret = mbedtls_dhm_read_params( &ssl->handshake->dhm_ctx, p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 2, ( "dhm_read_params" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 2, ( "mbedtls_dhm_read_params" ), ret );
return( ret );
}
if( ssl->handshake->dhm_ctx.len < 64 ||
ssl->handshake->dhm_ctx.len > 512 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message (DHM length)" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message (DHM length)" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
- SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
- SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
- SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
return( ret );
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
-static int ssl_check_server_ecdh_params( const ssl_context *ssl )
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+static int ssl_check_server_ecdh_params( const mbedtls_ssl_context *ssl )
{
- const ecp_curve_info *curve_info;
+ const mbedtls_ecp_curve_info *curve_info;
- curve_info = ecp_curve_info_from_grp_id( ssl->handshake->ecdh_ctx.grp.id );
+ curve_info = mbedtls_ecp_curve_info_from_grp_id( ssl->handshake->ecdh_ctx.grp.id );
if( curve_info == NULL )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_MSG( 2, ( "ECDH curve: %s", curve_info->name ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "ECDH curve: %s", curve_info->name ) );
-#if defined(POLARSSL_SSL_SET_CURVES)
- if( ! ssl_curve_is_acceptable( ssl, ssl->handshake->ecdh_ctx.grp.id ) )
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ if( ! mbedtls_ssl_curve_is_acceptable( ssl, ssl->handshake->ecdh_ctx.grp.id ) )
#else
if( ssl->handshake->ecdh_ctx.grp.nbits < 163 ||
ssl->handshake->ecdh_ctx.grp.nbits > 521 )
#endif
return( -1 );
- SSL_DEBUG_ECP( 3, "ECDH: Qp", &ssl->handshake->ecdh_ctx.Qp );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Qp", &ssl->handshake->ecdh_ctx.Qp );
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
-static int ssl_parse_server_ecdh_params( ssl_context *ssl,
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+static int ssl_parse_server_ecdh_params( mbedtls_ssl_context *ssl,
unsigned char **p,
unsigned char *end )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
/*
* Ephemeral ECDH parameters:
@@ -1708,31 +1708,31 @@
* ECPoint public;
* } ServerECDHParams;
*/
- if( ( ret = ecdh_read_params( &ssl->handshake->ecdh_ctx,
+ if( ( ret = mbedtls_ecdh_read_params( &ssl->handshake->ecdh_ctx,
(const unsigned char **) p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ecdh_read_params" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_read_params" ), ret );
return( ret );
}
if( ssl_check_server_ecdh_params( ssl ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message (ECDHE curve)" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message (ECDHE curve)" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
return( ret );
}
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
-static int ssl_parse_server_psk_hint( ssl_context *ssl,
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+static int ssl_parse_server_psk_hint( mbedtls_ssl_context *ssl,
unsigned char **p,
unsigned char *end )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t len;
((void) ssl);
@@ -1746,8 +1746,8 @@
if( (*p) + len > end )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message (psk_identity_hint length)" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message (psk_identity_hint length)" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
// TODO: Retrieve PSK identity hint and callback to app
@@ -1757,19 +1757,19 @@
return( ret );
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
/*
* Generate a pre-master secret and encrypt it with the server's RSA key
*/
-static int ssl_write_encrypted_pms( ssl_context *ssl,
+static int ssl_write_encrypted_pms( mbedtls_ssl_context *ssl,
size_t offset, size_t *olen,
size_t pms_offset )
{
int ret;
- size_t len_bytes = ssl->minor_ver == SSL_MINOR_VERSION_0 ? 0 : 2;
+ size_t len_bytes = ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ? 0 : 2;
unsigned char *p = ssl->handshake->premaster + pms_offset;
/*
@@ -1779,12 +1779,12 @@
* opaque random[46];
* } PreMasterSecret;
*/
- ssl_write_version( ssl->max_major_ver, ssl->max_minor_ver,
+ mbedtls_ssl_write_version( ssl->max_major_ver, ssl->max_minor_ver,
ssl->transport, p );
if( ( ret = ssl->f_rng( ssl->p_rng, p + 2, 46 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "f_rng", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "f_rng", ret );
return( ret );
}
@@ -1793,25 +1793,25 @@
/*
* Now write it out, encrypted
*/
- if( ! pk_can_do( &ssl->session_negotiate->peer_cert->pk,
- POLARSSL_PK_RSA ) )
+ if( ! mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk,
+ MBEDTLS_PK_RSA ) )
{
- SSL_DEBUG_MSG( 1, ( "certificate key type mismatch" ) );
- return( POLARSSL_ERR_SSL_PK_TYPE_MISMATCH );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "certificate key type mismatch" ) );
+ return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
- if( ( ret = pk_encrypt( &ssl->session_negotiate->peer_cert->pk,
+ if( ( ret = mbedtls_pk_encrypt( &ssl->session_negotiate->peer_cert->pk,
p, ssl->handshake->pmslen,
ssl->out_msg + offset + len_bytes, olen,
- SSL_MAX_CONTENT_LEN - offset - len_bytes,
+ MBEDTLS_SSL_MAX_CONTENT_LEN - offset - len_bytes,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "rsa_pkcs1_encrypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_rsa_pkcs1_encrypt", ret );
return( ret );
}
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( len_bytes == 2 )
{
ssl->out_msg[offset+0] = (unsigned char)( *olen >> 8 );
@@ -1822,110 +1822,110 @@
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-static int ssl_parse_signature_algorithm( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+static int ssl_parse_signature_algorithm( mbedtls_ssl_context *ssl,
unsigned char **p,
unsigned char *end,
- md_type_t *md_alg,
- pk_type_t *pk_alg )
+ mbedtls_md_type_t *md_alg,
+ mbedtls_pk_type_t *pk_alg )
{
((void) ssl);
- *md_alg = POLARSSL_MD_NONE;
- *pk_alg = POLARSSL_PK_NONE;
+ *md_alg = MBEDTLS_MD_NONE;
+ *pk_alg = MBEDTLS_PK_NONE;
/* Only in TLS 1.2 */
- if( ssl->minor_ver != SSL_MINOR_VERSION_3 )
+ if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
{
return( 0 );
}
if( (*p) + 2 > end )
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
/*
* Get hash algorithm
*/
- if( ( *md_alg = ssl_md_alg_from_hash( (*p)[0] ) ) == POLARSSL_MD_NONE )
+ if( ( *md_alg = mbedtls_ssl_md_alg_from_hash( (*p)[0] ) ) == MBEDTLS_MD_NONE )
{
- SSL_DEBUG_MSG( 2, ( "Server used unsupported "
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "Server used unsupported "
"HashAlgorithm %d", *(p)[0] ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
/*
* Get signature algorithm
*/
- if( ( *pk_alg = ssl_pk_alg_from_sig( (*p)[1] ) ) == POLARSSL_PK_NONE )
+ if( ( *pk_alg = mbedtls_ssl_pk_alg_from_sig( (*p)[1] ) ) == MBEDTLS_PK_NONE )
{
- SSL_DEBUG_MSG( 2, ( "server used unsupported "
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "server used unsupported "
"SignatureAlgorithm %d", (*p)[1] ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
- SSL_DEBUG_MSG( 2, ( "Server used SignatureAlgorithm %d", (*p)[1] ) );
- SSL_DEBUG_MSG( 2, ( "Server used HashAlgorithm %d", (*p)[0] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "Server used SignatureAlgorithm %d", (*p)[1] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "Server used HashAlgorithm %d", (*p)[0] ) );
*p += 2;
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
-static int ssl_get_ecdh_params_from_cert( ssl_context *ssl )
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
{
int ret;
- const ecp_keypair *peer_key;
+ const mbedtls_ecp_keypair *peer_key;
- if( ! pk_can_do( &ssl->session_negotiate->peer_cert->pk,
- POLARSSL_PK_ECKEY ) )
+ if( ! mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk,
+ MBEDTLS_PK_ECKEY ) )
{
- SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
- return( POLARSSL_ERR_SSL_PK_TYPE_MISMATCH );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
+ return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
- peer_key = pk_ec( ssl->session_negotiate->peer_cert->pk );
+ peer_key = mbedtls_pk_ec( ssl->session_negotiate->peer_cert->pk );
- if( ( ret = ecdh_get_params( &ssl->handshake->ecdh_ctx, peer_key,
- POLARSSL_ECDH_THEIRS ) ) != 0 )
+ if( ( ret = mbedtls_ecdh_get_params( &ssl->handshake->ecdh_ctx, peer_key,
+ MBEDTLS_ECDH_THEIRS ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ecdh_get_params" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_get_params" ), ret );
return( ret );
}
if( ssl_check_server_ecdh_params( ssl ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server certificate (ECDH curve)" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server certificate (ECDH curve)" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
return( ret );
}
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-static int ssl_parse_server_key_exchange( ssl_context *ssl )
+static int ssl_parse_server_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
unsigned char *p, *end;
- SSL_DEBUG_MSG( 2, ( "=> parse server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server key exchange" ) );
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
ssl->state++;
return( 0 );
}
@@ -1933,167 +1933,167 @@
((void) end);
#endif
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
if( ( ret = ssl_get_ecdh_params_from_cert( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_get_ecdh_params_from_cert", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_get_ecdh_params_from_cert", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
ssl->state++;
return( 0 );
}
((void) p);
((void) end);
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/*
* ServerKeyExchange may be skipped with PSK and RSA-PSK when the server
* doesn't use a psk_identity_hint
*/
- if( ssl->in_msg[0] != SSL_HS_SERVER_KEY_EXCHANGE )
+ if( ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE )
{
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
ssl->record_read = 1;
goto exit;
}
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
- p = ssl->in_msg + ssl_hs_hdr_len( ssl );
+ p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
end = ssl->in_msg + ssl->in_hslen;
- SSL_DEBUG_BUF( 3, "server key exchange", p, end - p );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server key exchange", p, end - p );
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
if( ssl_parse_server_psk_hint( ssl, &p, end ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
} /* FALLTROUGH */
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
; /* nothing more to do */
else
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED ||
- POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
if( ssl_parse_server_dh_params( ssl, &p, end ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
if( ssl_parse_server_ecdh_params( ssl, &p, end ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
size_t sig_len, hashlen;
unsigned char hash[64];
- md_type_t md_alg = POLARSSL_MD_NONE;
- pk_type_t pk_alg = POLARSSL_PK_NONE;
- unsigned char *params = ssl->in_msg + ssl_hs_hdr_len( ssl );
+ mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
+ mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
+ unsigned char *params = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
size_t params_len = p - params;
/*
* Handle the digitally-signed structure
*/
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
if( ssl_parse_signature_algorithm( ssl, &p, end,
&md_alg, &pk_alg ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
- if( pk_alg != ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info ) )
+ if( pk_alg != mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info ) )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( ssl->minor_ver < SSL_MINOR_VERSION_3 )
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
{
- pk_alg = ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
+ pk_alg = mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
/* Default hash for ECDSA is SHA-1 */
- if( pk_alg == POLARSSL_PK_ECDSA && md_alg == POLARSSL_MD_NONE )
- md_alg = POLARSSL_MD_SHA1;
+ if( pk_alg == MBEDTLS_PK_ECDSA && md_alg == MBEDTLS_MD_NONE )
+ md_alg = MBEDTLS_MD_SHA1;
}
else
#endif
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/*
@@ -2104,24 +2104,24 @@
if( end != p + sig_len )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
- SSL_DEBUG_BUF( 3, "signature", p, sig_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "signature", p, sig_len );
/*
* Compute the hash that has been signed
*/
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( md_alg == POLARSSL_MD_NONE )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( md_alg == MBEDTLS_MD_NONE )
{
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
- md5_init( &md5 );
- sha1_init( &sha1 );
+ mbedtls_md5_init( &mbedtls_md5 );
+ mbedtls_sha1_init( &mbedtls_sha1 );
hashlen = 36;
@@ -2138,29 +2138,29 @@
* SHA(ClientHello.random + ServerHello.random
* + ServerParams);
*/
- md5_starts( &md5 );
- md5_update( &md5, ssl->handshake->randbytes, 64 );
- md5_update( &md5, params, params_len );
- md5_finish( &md5, hash );
+ mbedtls_md5_starts( &mbedtls_md5 );
+ mbedtls_md5_update( &mbedtls_md5, ssl->handshake->randbytes, 64 );
+ mbedtls_md5_update( &mbedtls_md5, params, params_len );
+ mbedtls_md5_finish( &mbedtls_md5, hash );
- sha1_starts( &sha1 );
- sha1_update( &sha1, ssl->handshake->randbytes, 64 );
- sha1_update( &sha1, params, params_len );
- sha1_finish( &sha1, hash + 16 );
+ mbedtls_sha1_starts( &mbedtls_sha1 );
+ mbedtls_sha1_update( &mbedtls_sha1, ssl->handshake->randbytes, 64 );
+ mbedtls_sha1_update( &mbedtls_sha1, params, params_len );
+ mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 || \
- POLARSSL_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( md_alg != POLARSSL_MD_NONE )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
+ MBEDTLS_SSL_PROTO_TLS1_1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( md_alg != MBEDTLS_MD_NONE )
{
- md_context_t ctx;
+ mbedtls_md_context_t ctx;
- md_init( &ctx );
+ mbedtls_md_init( &ctx );
/* Info from md_alg will be used instead */
hashlen = 0;
@@ -2172,114 +2172,114 @@
* ServerDHParams params;
* };
*/
- if( ( ret = md_setup( &ctx,
- md_info_from_type( md_alg ), 0 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &ctx,
+ mbedtls_md_info_from_type( md_alg ), 0 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "md_setup", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_md_setup", ret );
return( ret );
}
- md_starts( &ctx );
- md_update( &ctx, ssl->handshake->randbytes, 64 );
- md_update( &ctx, params, params_len );
- md_finish( &ctx, hash );
- md_free( &ctx );
+ mbedtls_md_starts( &ctx );
+ mbedtls_md_update( &ctx, ssl->handshake->randbytes, 64 );
+ mbedtls_md_update( &ctx, params, params_len );
+ mbedtls_md_finish( &ctx, hash );
+ mbedtls_md_free( &ctx );
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 || \
- POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
+ MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen != 0 ? hashlen :
- (unsigned int) ( md_get_size( md_info_from_type( md_alg ) ) ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen != 0 ? hashlen :
+ (unsigned int) ( mbedtls_md_get_size( mbedtls_md_info_from_type( md_alg ) ) ) );
/*
* Verify signature
*/
- if( ! pk_can_do( &ssl->session_negotiate->peer_cert->pk, pk_alg ) )
+ if( ! mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk, pk_alg ) )
{
- SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
- return( POLARSSL_ERR_SSL_PK_TYPE_MISMATCH );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
- if( ( ret = pk_verify( &ssl->session_negotiate->peer_cert->pk,
+ if( ( ret = mbedtls_pk_verify( &ssl->session_negotiate->peer_cert->pk,
md_alg, hash, hashlen, p, sig_len ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "pk_verify", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_verify", ret );
return( ret );
}
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
exit:
ssl->state++;
- SSL_DEBUG_MSG( 2, ( "<= parse server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server key exchange" ) );
return( 0 );
}
-#if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-static int ssl_parse_certificate_request( ssl_context *ssl )
+#if !defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+static int ssl_parse_certificate_request( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else
-static int ssl_parse_certificate_request( ssl_context *ssl )
+static int ssl_parse_certificate_request( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *buf, *p;
size_t n = 0, m = 0;
size_t cert_type_len = 0, dn_len = 0;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
ssl->state++;
return( 0 );
}
if( ssl->record_read == 0 )
{
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
ssl->record_read = 1;
@@ -2288,10 +2288,10 @@
ssl->client_auth = 0;
ssl->state++;
- if( ssl->in_msg[0] == SSL_HS_CERTIFICATE_REQUEST )
+ if( ssl->in_msg[0] == MBEDTLS_SSL_HS_CERTIFICATE_REQUEST )
ssl->client_auth++;
- SSL_DEBUG_MSG( 3, ( "got %s certificate request",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "got %s certificate request",
ssl->client_auth ? "a" : "no" ) );
if( ssl->client_auth == 0 )
@@ -2314,32 +2314,32 @@
// Retrieve cert types
//
- cert_type_len = buf[ssl_hs_hdr_len( ssl )];
+ cert_type_len = buf[mbedtls_ssl_hs_hdr_len( ssl )];
n = cert_type_len;
- if( ssl->in_hslen < ssl_hs_hdr_len( ssl ) + 2 + n )
+ if( ssl->in_hslen < mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
}
- p = buf + ssl_hs_hdr_len( ssl ) + 1;
+ p = buf + mbedtls_ssl_hs_hdr_len( ssl ) + 1;
while( cert_type_len > 0 )
{
-#if defined(POLARSSL_RSA_C)
- if( *p == SSL_CERT_TYPE_RSA_SIGN &&
- pk_can_do( ssl_own_key( ssl ), POLARSSL_PK_RSA ) )
+#if defined(MBEDTLS_RSA_C)
+ if( *p == MBEDTLS_SSL_CERT_TYPE_RSA_SIGN &&
+ mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_RSA ) )
{
- ssl->handshake->cert_type = SSL_CERT_TYPE_RSA_SIGN;
+ ssl->handshake->cert_type = MBEDTLS_SSL_CERT_TYPE_RSA_SIGN;
break;
}
else
#endif
-#if defined(POLARSSL_ECDSA_C)
- if( *p == SSL_CERT_TYPE_ECDSA_SIGN &&
- pk_can_do( ssl_own_key( ssl ), POLARSSL_PK_ECDSA ) )
+#if defined(MBEDTLS_ECDSA_C)
+ if( *p == MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN &&
+ mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECDSA ) )
{
- ssl->handshake->cert_type = SSL_CERT_TYPE_ECDSA_SIGN;
+ ssl->handshake->cert_type = MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN;
break;
}
else
@@ -2352,99 +2352,99 @@
p++;
}
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
/* Ignored, see comments about hash in write_certificate_verify */
// TODO: should check the signature part against our pk_key though
- size_t sig_alg_len = ( ( buf[ssl_hs_hdr_len( ssl ) + 1 + n] << 8 )
- | ( buf[ssl_hs_hdr_len( ssl ) + 2 + n] ) );
+ size_t sig_alg_len = ( ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 1 + n] << 8 )
+ | ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n] ) );
- p = buf + ssl_hs_hdr_len( ssl ) + 3 + n;
+ p = buf + mbedtls_ssl_hs_hdr_len( ssl ) + 3 + n;
m += 2;
n += sig_alg_len;
- if( ssl->in_hslen < ssl_hs_hdr_len( ssl ) + 2 + n )
+ if( ssl->in_hslen < mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
}
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
/* Ignore certificate_authorities, we only have one cert anyway */
// TODO: should not send cert if no CA matches
- dn_len = ( ( buf[ssl_hs_hdr_len( ssl ) + 1 + m + n] << 8 )
- | ( buf[ssl_hs_hdr_len( ssl ) + 2 + m + n] ) );
+ dn_len = ( ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 1 + m + n] << 8 )
+ | ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 2 + m + n] ) );
n += dn_len;
- if( ssl->in_hslen != ssl_hs_hdr_len( ssl ) + 3 + m + n )
+ if( ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + 3 + m + n )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
}
exit:
- SSL_DEBUG_MSG( 2, ( "<= parse certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate request" ) );
return( 0 );
}
-#endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* !MBEDTLS_KEY_EXCHANGE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
-static int ssl_parse_server_hello_done( ssl_context *ssl )
+static int ssl_parse_server_hello_done( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> parse server hello done" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello done" ) );
if( ssl->record_read == 0 )
{
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
}
ssl->record_read = 0;
- if( ssl->in_hslen != ssl_hs_hdr_len( ssl ) ||
- ssl->in_msg[0] != SSL_HS_SERVER_HELLO_DONE )
+ if( ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) ||
+ ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_HELLO_DONE )
{
- SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO_DONE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE );
}
ssl->state++;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_recv_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_recv_flight_completed( ssl );
#endif
- SSL_DEBUG_MSG( 2, ( "<= parse server hello done" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello done" ) );
return( 0 );
}
-static int ssl_write_client_key_exchange( ssl_context *ssl )
+static int ssl_write_client_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
size_t i, n;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> write client key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write client key exchange" ) );
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA )
{
/*
* DHM key exchange -- send G^X mod P
@@ -2455,88 +2455,88 @@
ssl->out_msg[5] = (unsigned char)( n );
i = 6;
- ret = dhm_make_public( &ssl->handshake->dhm_ctx,
- (int) mpi_size( &ssl->handshake->dhm_ctx.P ),
+ ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
+ (int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
&ssl->out_msg[i], n,
ssl->f_rng, ssl->p_rng );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_make_public", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
return( ret );
}
- SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
- SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
- ssl->handshake->pmslen = POLARSSL_PREMASTER_SIZE;
+ ssl->handshake->pmslen = MBEDTLS_PREMASTER_SIZE;
- if( ( ret = dhm_calc_secret( &ssl->handshake->dhm_ctx,
+ if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
ssl->handshake->premaster,
&ssl->handshake->pmslen,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_calc_secret", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
return( ret );
}
- SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
/*
* ECDH key exchange -- send client public value
*/
i = 4;
- ret = ecdh_make_public( &ssl->handshake->ecdh_ctx,
+ ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx,
&n,
&ssl->out_msg[i], 1000,
ssl->f_rng, ssl->p_rng );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_make_public", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
return( ret );
}
- SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
- if( ( ret = ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
+ if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
&ssl->handshake->pmslen,
ssl->handshake->premaster,
- POLARSSL_MPI_MAX_SIZE,
+ MBEDTLS_MPI_MAX_SIZE,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_calc_secret", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
return( ret );
}
- SSL_DEBUG_MPI( 3, "ECDH: z", &ssl->handshake->ecdh_ctx.z );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "ECDH: z", &ssl->handshake->ecdh_ctx.z );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/*
* opaque psk_identity<0..2^16-1>;
*/
if( ssl->psk == NULL || ssl->psk_identity == NULL )
- return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
+ return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
i = 4;
n = ssl->psk_identity_len;
@@ -2546,23 +2546,23 @@
memcpy( ssl->out_msg + i, ssl->psk_identity, ssl->psk_identity_len );
i += ssl->psk_identity_len;
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK )
{
n = 0;
}
else
#endif
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
if( ( ret = ssl_write_encrypted_pms( ssl, i, &n, 2 ) ) != 0 )
return( ret );
}
else
#endif
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
/*
* ClientDiffieHellmanPublic public (DHM send G^X mod P)
@@ -2571,153 +2571,153 @@
ssl->out_msg[i++] = (unsigned char)( n >> 8 );
ssl->out_msg[i++] = (unsigned char)( n );
- ret = dhm_make_public( &ssl->handshake->dhm_ctx,
- (int) mpi_size( &ssl->handshake->dhm_ctx.P ),
+ ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
+ (int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
&ssl->out_msg[i], n,
ssl->f_rng, ssl->p_rng );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_make_public", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/*
* ClientECDiffieHellmanPublic public;
*/
- ret = ecdh_make_public( &ssl->handshake->ecdh_ctx, &n,
- &ssl->out_msg[i], SSL_MAX_CONTENT_LEN - i,
+ ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx, &n,
+ &ssl->out_msg[i], MBEDTLS_SSL_MAX_CONTENT_LEN - i,
ssl->f_rng, ssl->p_rng );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_make_public", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
return( ret );
}
- SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- if( ( ret = ssl_psk_derive_premaster( ssl,
+ if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_psk_derive_premaster", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA )
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
i = 4;
if( ( ret = ssl_write_encrypted_pms( ssl, i, &n, 0 ) ) != 0 )
return( ret );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
{
((void) ciphersuite_info);
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->out_msglen = i + n;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_CLIENT_KEY_EXCHANGE;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE;
ssl->state++;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write client key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write client key exchange" ) );
return( 0 );
}
-#if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-static int ssl_write_certificate_verify( ssl_context *ssl )
+#if !defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+static int ssl_write_certificate_verify( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
int ret;
- SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
- if( ( ret = ssl_derive_keys( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_derive_keys", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else
-static int ssl_write_certificate_verify( ssl_context *ssl )
+static int ssl_write_certificate_verify( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
size_t n = 0, offset = 0;
unsigned char hash[48];
unsigned char *hash_start = hash;
- md_type_t md_alg = POLARSSL_MD_NONE;
+ mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
unsigned int hashlen;
- SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
- if( ( ret = ssl_derive_keys( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_derive_keys", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
ssl->state++;
return( 0 );
}
- if( ssl->client_auth == 0 || ssl_own_cert( ssl ) == NULL )
+ if( ssl->client_auth == 0 || mbedtls_ssl_own_cert( ssl ) == NULL )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
ssl->state++;
return( 0 );
}
- if( ssl_own_key( ssl ) == NULL )
+ if( mbedtls_ssl_own_key( ssl ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "got no private key" ) );
- return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no private key" ) );
+ return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/*
@@ -2725,9 +2725,9 @@
*/
ssl->handshake->calc_verify( ssl, hash );
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( ssl->minor_ver != SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
{
/*
* digitally-signed struct {
@@ -2742,23 +2742,23 @@
* SHA(handshake_messages);
*/
hashlen = 36;
- md_alg = POLARSSL_MD_NONE;
+ md_alg = MBEDTLS_MD_NONE;
/*
* For ECDSA, default hash is SHA-1 only
*/
- if( pk_can_do( ssl_own_key( ssl ), POLARSSL_PK_ECDSA ) )
+ if( mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECDSA ) )
{
hash_start += 16;
hashlen -= 16;
- md_alg = POLARSSL_MD_SHA1;
+ md_alg = MBEDTLS_MD_SHA1;
}
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 || \
- POLARSSL_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
+ MBEDTLS_SSL_PROTO_TLS1_1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
/*
* digitally-signed struct {
@@ -2776,34 +2776,34 @@
* in order to satisfy 'weird' needs from the server side.
*/
if( ssl->transform_negotiate->ciphersuite_info->mac ==
- POLARSSL_MD_SHA384 )
+ MBEDTLS_MD_SHA384 )
{
- md_alg = POLARSSL_MD_SHA384;
- ssl->out_msg[4] = SSL_HASH_SHA384;
+ md_alg = MBEDTLS_MD_SHA384;
+ ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA384;
}
else
{
- md_alg = POLARSSL_MD_SHA256;
- ssl->out_msg[4] = SSL_HASH_SHA256;
+ md_alg = MBEDTLS_MD_SHA256;
+ ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA256;
}
- ssl->out_msg[5] = ssl_sig_from_pk( ssl_own_key( ssl ) );
+ ssl->out_msg[5] = mbedtls_ssl_sig_from_pk( mbedtls_ssl_own_key( ssl ) );
/* Info from md_alg will be used instead */
hashlen = 0;
offset = 2;
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- if( ( ret = pk_sign( ssl_own_key( ssl ), md_alg, hash_start, hashlen,
+ if( ( ret = mbedtls_pk_sign( mbedtls_ssl_own_key( ssl ), md_alg, hash_start, hashlen,
ssl->out_msg + 6 + offset, &n,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "pk_sign", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_sign", ret );
return( ret );
}
@@ -2811,27 +2811,27 @@
ssl->out_msg[5 + offset] = (unsigned char)( n );
ssl->out_msglen = 6 + n + offset;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_CERTIFICATE_VERIFY;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_VERIFY;
ssl->state++;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate verify" ) );
return( ret );
}
-#endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
+#endif /* !MBEDTLS_KEY_EXCHANGE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static int ssl_parse_new_session_ticket( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static int ssl_parse_new_session_ticket( mbedtls_ssl_context *ssl )
{
int ret;
uint32_t lifetime;
@@ -2839,18 +2839,18 @@
unsigned char *ticket;
const unsigned char *msg;
- SSL_DEBUG_MSG( 2, ( "=> parse new session ticket" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse new session ticket" ) );
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/*
@@ -2863,31 +2863,31 @@
* 4 . 5 ticket_len (n)
* 6 . 5+n ticket content
*/
- if( ssl->in_msg[0] != SSL_HS_NEW_SESSION_TICKET ||
- ssl->in_hslen < 6 + ssl_hs_hdr_len( ssl ) )
+ if( ssl->in_msg[0] != MBEDTLS_SSL_HS_NEW_SESSION_TICKET ||
+ ssl->in_hslen < 6 + mbedtls_ssl_hs_hdr_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
}
- msg = ssl->in_msg + ssl_hs_hdr_len( ssl );
+ msg = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
lifetime = ( msg[0] << 24 ) | ( msg[1] << 16 ) |
( msg[2] << 8 ) | ( msg[3] );
ticket_len = ( msg[4] << 8 ) | ( msg[5] );
- if( ticket_len + 6 + ssl_hs_hdr_len( ssl ) != ssl->in_hslen )
+ if( ticket_len + 6 + mbedtls_ssl_hs_hdr_len( ssl ) != ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
}
- SSL_DEBUG_MSG( 3, ( "ticket length: %d", ticket_len ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket length: %d", ticket_len ) );
/* We're not waiting for a NewSessionTicket message any more */
ssl->handshake->new_session_ticket = 0;
- ssl->state = SSL_SERVER_CHANGE_CIPHER_SPEC;
+ ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
/*
* Zero-length ticket means the server changed his mind and doesn't want
@@ -2896,16 +2896,16 @@
if( ticket_len == 0 )
return( 0 );
- polarssl_zeroize( ssl->session_negotiate->ticket,
+ mbedtls_zeroize( ssl->session_negotiate->ticket,
ssl->session_negotiate->ticket_len );
- polarssl_free( ssl->session_negotiate->ticket );
+ mbedtls_free( ssl->session_negotiate->ticket );
ssl->session_negotiate->ticket = NULL;
ssl->session_negotiate->ticket_len = 0;
- if( ( ticket = polarssl_malloc( ticket_len ) ) == NULL )
+ if( ( ticket = mbedtls_malloc( ticket_len ) ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "ticket malloc failed" ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "ticket malloc failed" ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
memcpy( ticket, msg + 6, ticket_len );
@@ -2919,60 +2919,60 @@
* "If the client receives a session ticket from the server, then it
* discards any Session ID that was sent in the ServerHello."
*/
- SSL_DEBUG_MSG( 3, ( "ticket in use, discarding session id" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket in use, discarding session id" ) );
ssl->session_negotiate->length = 0;
- SSL_DEBUG_MSG( 2, ( "<= parse new session ticket" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse new session ticket" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
/*
* SSL handshake -- client side -- single step
*/
-int ssl_handshake_client_step( ssl_context *ssl )
+int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context *ssl )
{
int ret = 0;
- if( ssl->state == SSL_HANDSHAKE_OVER )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
- if( ( ret = ssl_flush_output( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL &&
- ssl->handshake->retransmit_state == SSL_RETRANS_SENDING )
+ ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
return( ret );
}
#endif
- /* Change state now, so that it is right in ssl_read_record(), used
+ /* Change state now, so that it is right in mbedtls_ssl_read_record(), used
* by DTLS for dropping out-of-sequence ChangeCipherSpec records */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- if( ssl->state == SSL_SERVER_CHANGE_CIPHER_SPEC &&
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ if( ssl->state == MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC &&
ssl->handshake->new_session_ticket != 0 )
{
- ssl->state = SSL_SERVER_NEW_SESSION_TICKET;
+ ssl->state = MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET;
}
#endif
switch( ssl->state )
{
- case SSL_HELLO_REQUEST:
- ssl->state = SSL_CLIENT_HELLO;
+ case MBEDTLS_SSL_HELLO_REQUEST:
+ ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
break;
/*
* ==> ClientHello
*/
- case SSL_CLIENT_HELLO:
+ case MBEDTLS_SSL_CLIENT_HELLO:
ret = ssl_write_client_hello( ssl );
break;
@@ -2983,23 +2983,23 @@
* ( CertificateRequest )
* ServerHelloDone
*/
- case SSL_SERVER_HELLO:
+ case MBEDTLS_SSL_SERVER_HELLO:
ret = ssl_parse_server_hello( ssl );
break;
- case SSL_SERVER_CERTIFICATE:
- ret = ssl_parse_certificate( ssl );
+ case MBEDTLS_SSL_SERVER_CERTIFICATE:
+ ret = mbedtls_ssl_parse_certificate( ssl );
break;
- case SSL_SERVER_KEY_EXCHANGE:
+ case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
ret = ssl_parse_server_key_exchange( ssl );
break;
- case SSL_CERTIFICATE_REQUEST:
+ case MBEDTLS_SSL_CERTIFICATE_REQUEST:
ret = ssl_parse_certificate_request( ssl );
break;
- case SSL_SERVER_HELLO_DONE:
+ case MBEDTLS_SSL_SERVER_HELLO_DONE:
ret = ssl_parse_server_hello_done( ssl );
break;
@@ -3010,24 +3010,24 @@
* ChangeCipherSpec
* Finished
*/
- case SSL_CLIENT_CERTIFICATE:
- ret = ssl_write_certificate( ssl );
+ case MBEDTLS_SSL_CLIENT_CERTIFICATE:
+ ret = mbedtls_ssl_write_certificate( ssl );
break;
- case SSL_CLIENT_KEY_EXCHANGE:
+ case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
ret = ssl_write_client_key_exchange( ssl );
break;
- case SSL_CERTIFICATE_VERIFY:
+ case MBEDTLS_SSL_CERTIFICATE_VERIFY:
ret = ssl_write_certificate_verify( ssl );
break;
- case SSL_CLIENT_CHANGE_CIPHER_SPEC:
- ret = ssl_write_change_cipher_spec( ssl );
+ case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
+ ret = mbedtls_ssl_write_change_cipher_spec( ssl );
break;
- case SSL_CLIENT_FINISHED:
- ret = ssl_write_finished( ssl );
+ case MBEDTLS_SSL_CLIENT_FINISHED:
+ ret = mbedtls_ssl_write_finished( ssl );
break;
/*
@@ -3035,34 +3035,34 @@
* ChangeCipherSpec
* Finished
*/
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- case SSL_SERVER_NEW_SESSION_TICKET:
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ case MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET:
ret = ssl_parse_new_session_ticket( ssl );
break;
#endif
- case SSL_SERVER_CHANGE_CIPHER_SPEC:
- ret = ssl_parse_change_cipher_spec( ssl );
+ case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
+ ret = mbedtls_ssl_parse_change_cipher_spec( ssl );
break;
- case SSL_SERVER_FINISHED:
- ret = ssl_parse_finished( ssl );
+ case MBEDTLS_SSL_SERVER_FINISHED:
+ ret = mbedtls_ssl_parse_finished( ssl );
break;
- case SSL_FLUSH_BUFFERS:
- SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
- ssl->state = SSL_HANDSHAKE_WRAPUP;
+ case MBEDTLS_SSL_FLUSH_BUFFERS:
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
+ ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
break;
- case SSL_HANDSHAKE_WRAPUP:
- ssl_handshake_wrapup( ssl );
+ case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
+ mbedtls_ssl_handshake_wrapup( ssl );
break;
default:
- SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ret );
}
-#endif /* POLARSSL_SSL_CLI_C */
+#endif /* MBEDTLS_SSL_CLI_C */
diff --git a/library/ssl_cookie.c b/library/ssl_cookie.c
index 2958c5c..efcce3c 100644
--- a/library/ssl_cookie.c
+++ b/library/ssl_cookie.c
@@ -24,27 +24,27 @@
* to store and retrieve the session information.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_COOKIE_C)
+#if defined(MBEDTLS_SSL_COOKIE_C)
#include "mbedtls/ssl_cookie.h"
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
#include <string.h>
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -53,16 +53,16 @@
* available. Try SHA-256 first, 512 wastes resources since we need to stay
* with max 32 bytes of cookie for DTLS 1.0
*/
-#if defined(POLARSSL_SHA256_C)
-#define COOKIE_MD POLARSSL_MD_SHA224
+#if defined(MBEDTLS_SHA256_C)
+#define COOKIE_MD MBEDTLS_MD_SHA224
#define COOKIE_MD_OUTLEN 32
#define COOKIE_HMAC_LEN 28
-#elif defined(POLARSSL_SHA512_C)
-#define COOKIE_MD POLARSSL_MD_SHA384
+#elif defined(MBEDTLS_SHA512_C)
+#define COOKIE_MD MBEDTLS_MD_SHA384
#define COOKIE_MD_OUTLEN 48
#define COOKIE_HMAC_LEN 28
-#elif defined(POLARSSL_SHA1_C)
-#define COOKIE_MD POLARSSL_MD_SHA1
+#elif defined(MBEDTLS_SHA1_C)
+#define COOKIE_MD MBEDTLS_MD_SHA1
#define COOKIE_MD_OUTLEN 20
#define COOKIE_HMAC_LEN 20
#else
@@ -75,26 +75,26 @@
*/
#define COOKIE_LEN ( 4 + COOKIE_HMAC_LEN )
-void ssl_cookie_init( ssl_cookie_ctx *ctx )
+void mbedtls_ssl_cookie_init( mbedtls_ssl_cookie_ctx *ctx )
{
- md_init( &ctx->hmac_ctx );
-#if !defined(POLARSSL_HAVE_TIME)
+ mbedtls_md_init( &ctx->hmac_ctx );
+#if !defined(MBEDTLS_HAVE_TIME)
ctx->serial = 0;
#endif
- ctx->timeout = POLARSSL_SSL_COOKIE_TIMEOUT;
+ ctx->timeout = MBEDTLS_SSL_COOKIE_TIMEOUT;
}
-void ssl_cookie_set_timeout( ssl_cookie_ctx *ctx, unsigned long delay )
+void mbedtls_ssl_cookie_set_timeout( mbedtls_ssl_cookie_ctx *ctx, unsigned long delay )
{
ctx->timeout = delay;
}
-void ssl_cookie_free( ssl_cookie_ctx *ctx )
+void mbedtls_ssl_cookie_free( mbedtls_ssl_cookie_ctx *ctx )
{
- md_free( &ctx->hmac_ctx );
+ mbedtls_md_free( &ctx->hmac_ctx );
}
-int ssl_cookie_setup( ssl_cookie_ctx *ctx,
+int mbedtls_ssl_cookie_setup( mbedtls_ssl_cookie_ctx *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -104,15 +104,15 @@
if( ( ret = f_rng( p_rng, key, sizeof( key ) ) ) != 0 )
return( ret );
- ret = md_setup( &ctx->hmac_ctx, md_info_from_type( COOKIE_MD ), 1 );
+ ret = mbedtls_md_setup( &ctx->hmac_ctx, mbedtls_md_info_from_type( COOKIE_MD ), 1 );
if( ret != 0 )
return( ret );
- ret = md_hmac_starts( &ctx->hmac_ctx, key, sizeof( key ) );
+ ret = mbedtls_md_hmac_starts( &ctx->hmac_ctx, key, sizeof( key ) );
if( ret != 0 )
return( ret );
- polarssl_zeroize( key, sizeof( key ) );
+ mbedtls_zeroize( key, sizeof( key ) );
return( 0 );
}
@@ -120,7 +120,7 @@
/*
* Generate the HMAC part of a cookie
*/
-static int ssl_cookie_hmac( md_context_t *hmac_ctx,
+static int ssl_cookie_hmac( mbedtls_md_context_t *hmac_ctx,
const unsigned char time[4],
unsigned char **p, unsigned char *end,
const unsigned char *cli_id, size_t cli_id_len )
@@ -129,14 +129,14 @@
unsigned char hmac_out[COOKIE_MD_OUTLEN];
if( (size_t)( end - *p ) < COOKIE_HMAC_LEN )
- return( POLARSSL_ERR_SSL_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- if( ( ret = md_hmac_reset( hmac_ctx ) ) != 0 ||
- ( ret = md_hmac_update( hmac_ctx, time, 4 ) ) != 0 ||
- ( ret = md_hmac_update( hmac_ctx, cli_id, cli_id_len ) ) != 0 ||
- ( ret = md_hmac_finish( hmac_ctx, hmac_out ) ) != 0 )
+ if( ( ret = mbedtls_md_hmac_reset( hmac_ctx ) ) != 0 ||
+ ( ret = mbedtls_md_hmac_update( hmac_ctx, time, 4 ) ) != 0 ||
+ ( ret = mbedtls_md_hmac_update( hmac_ctx, cli_id, cli_id_len ) ) != 0 ||
+ ( ret = mbedtls_md_hmac_finish( hmac_ctx, hmac_out ) ) != 0 )
{
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( *p, hmac_out, COOKIE_HMAC_LEN );
@@ -148,20 +148,20 @@
/*
* Generate cookie for DTLS ClientHello verification
*/
-int ssl_cookie_write( void *p_ctx,
+int mbedtls_ssl_cookie_write( void *p_ctx,
unsigned char **p, unsigned char *end,
const unsigned char *cli_id, size_t cli_id_len )
{
- ssl_cookie_ctx *ctx = (ssl_cookie_ctx *) p_ctx;
+ mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
unsigned long t;
if( ctx == NULL || cli_id == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( (size_t)( end - *p ) < COOKIE_LEN )
- return( POLARSSL_ERR_SSL_BUFFER_TOO_SMALL );
+ return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
t = (unsigned long) time( NULL );
#else
t = ctx->serial++;
@@ -180,17 +180,17 @@
/*
* Check a cookie
*/
-int ssl_cookie_check( void *p_ctx,
+int mbedtls_ssl_cookie_check( void *p_ctx,
const unsigned char *cookie, size_t cookie_len,
const unsigned char *cli_id, size_t cli_id_len )
{
unsigned char ref_hmac[COOKIE_HMAC_LEN];
unsigned char *p = ref_hmac;
- ssl_cookie_ctx *ctx = (ssl_cookie_ctx *) p_ctx;
+ mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
unsigned long cur_time, cookie_time;
if( ctx == NULL || cli_id == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( cookie_len != COOKIE_LEN )
return( -1 );
@@ -200,10 +200,10 @@
cli_id, cli_id_len ) != 0 )
return( -1 );
- if( safer_memcmp( cookie + 4, ref_hmac, sizeof( ref_hmac ) ) != 0 )
+ if( mbedtls_ssl_safer_memcmp( cookie + 4, ref_hmac, sizeof( ref_hmac ) ) != 0 )
return( -1 );
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
cur_time = (unsigned long) time( NULL );
#else
cur_time = ctx->serial;
@@ -219,4 +219,4 @@
return( 0 );
}
-#endif /* POLARSSL_SSL_COOKIE_C */
+#endif /* MBEDTLS_SSL_COOKIE_C */
diff --git a/library/ssl_srv.c b/library/ssl_srv.c
index 1b2d4db..4d2032e 100644
--- a/library/ssl_srv.c
+++ b/library/ssl_srv.c
@@ -20,67 +20,67 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_SRV_C)
+#if defined(MBEDTLS_SSL_SRV_C)
#include "mbedtls/debug.h"
#include "mbedtls/ssl.h"
#include <string.h>
-#if defined(POLARSSL_ECP_C)
+#if defined(MBEDTLS_ECP_C)
#include "mbedtls/ecp.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
#include <time.h>
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/*
* Serialize a session in the following format:
- * 0 . n-1 session structure, n = sizeof(ssl_session)
+ * 0 . n-1 session structure, n = sizeof(mbedtls_ssl_session)
* n . n+2 peer_cert length = m (0 if no certificate)
* n+3 . n+2+m peer cert ASN.1
*
* Assumes ticket is NULL (always true on server side).
*/
-static int ssl_save_session( const ssl_session *session,
+static int ssl_save_session( const mbedtls_ssl_session *session,
unsigned char *buf, size_t buf_len,
size_t *olen )
{
unsigned char *p = buf;
size_t left = buf_len;
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
size_t cert_len;
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
- if( left < sizeof( ssl_session ) )
+ if( left < sizeof( mbedtls_ssl_session ) )
return( -1 );
- memcpy( p, session, sizeof( ssl_session ) );
- p += sizeof( ssl_session );
- left -= sizeof( ssl_session );
+ memcpy( p, session, sizeof( mbedtls_ssl_session ) );
+ p += sizeof( mbedtls_ssl_session );
+ left -= sizeof( mbedtls_ssl_session );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( session->peer_cert == NULL )
cert_len = 0;
else
@@ -97,7 +97,7 @@
memcpy( p, session->peer_cert->raw.p, cert_len );
p += cert_len;
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
*olen = p - buf;
@@ -107,24 +107,24 @@
/*
* Unserialise session, see ssl_save_session()
*/
-static int ssl_load_session( ssl_session *session,
+static int ssl_load_session( mbedtls_ssl_session *session,
const unsigned char *buf, size_t len )
{
const unsigned char *p = buf;
const unsigned char * const end = buf + len;
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
size_t cert_len;
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
- if( p + sizeof( ssl_session ) > end )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( p + sizeof( mbedtls_ssl_session ) > end )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- memcpy( session, p, sizeof( ssl_session ) );
- p += sizeof( ssl_session );
+ memcpy( session, p, sizeof( mbedtls_ssl_session ) );
+ p += sizeof( mbedtls_ssl_session );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( p + 3 > end )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
cert_len = ( p[0] << 16 ) | ( p[1] << 8 ) | p[2];
p += 3;
@@ -138,30 +138,30 @@
int ret;
if( p + cert_len > end )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- session->peer_cert = polarssl_malloc( sizeof( x509_crt ) );
+ session->peer_cert = mbedtls_malloc( sizeof( mbedtls_x509_crt ) );
if( session->peer_cert == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
- x509_crt_init( session->peer_cert );
+ mbedtls_x509_crt_init( session->peer_cert );
- if( ( ret = x509_crt_parse_der( session->peer_cert,
+ if( ( ret = mbedtls_x509_crt_parse_der( session->peer_cert,
p, cert_len ) ) != 0 )
{
- x509_crt_free( session->peer_cert );
- polarssl_free( session->peer_cert );
+ mbedtls_x509_crt_free( session->peer_cert );
+ mbedtls_free( session->peer_cert );
session->peer_cert = NULL;
return( ret );
}
p += cert_len;
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
if( p != end )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
return( 0 );
}
@@ -178,7 +178,7 @@
*
* (the internal state structure differs, however).
*/
-static int ssl_write_ticket( ssl_context *ssl, size_t *tlen )
+static int ssl_write_ticket( mbedtls_ssl_context *ssl, size_t *tlen )
{
int ret;
unsigned char * const start = ssl->out_msg + 10;
@@ -190,7 +190,7 @@
*tlen = 0;
if( ssl->ticket_keys == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
/* Write key name */
memcpy( p, ssl->ticket_keys->key_name, 16 );
@@ -210,12 +210,12 @@
*/
state = p + 2;
if( ssl_save_session( ssl->session_negotiate, state,
- SSL_MAX_CONTENT_LEN - ( state - ssl->out_msg ) - 48,
+ MBEDTLS_SSL_MAX_CONTENT_LEN - ( state - ssl->out_msg ) - 48,
&clear_len ) != 0 )
{
- return( POLARSSL_ERR_SSL_CERTIFICATE_TOO_LARGE );
+ return( MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE );
}
- SSL_DEBUG_BUF( 3, "session ticket cleartext", state, clear_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "session ticket cleartext", state, clear_len );
/* Apply PKCS padding */
pad_len = 16 - clear_len % 16;
@@ -224,7 +224,7 @@
state[i] = (unsigned char) pad_len;
/* Encrypt */
- if( ( ret = aes_crypt_cbc( &ssl->ticket_keys->enc, AES_ENCRYPT,
+ if( ( ret = mbedtls_aes_crypt_cbc( &ssl->ticket_keys->enc, MBEDTLS_AES_ENCRYPT,
enc_len, iv, state, state ) ) != 0 )
{
return( ret );
@@ -236,7 +236,7 @@
p = state + enc_len;
/* Compute and write MAC( key_name + iv + enc_state_len + enc_state ) */
- if( ( ret = md_hmac( md_info_from_type( POLARSSL_MD_SHA256 ),
+ if( ( ret = mbedtls_md_hmac( mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ),
ssl->ticket_keys->mac_key, 16,
start, p - start, p ) ) != 0 )
{
@@ -246,7 +246,7 @@
*tlen = p - start;
- SSL_DEBUG_BUF( 3, "session ticket structure", start, *tlen );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "session ticket structure", start, *tlen );
return( 0 );
}
@@ -254,12 +254,12 @@
/*
* Load session ticket (see ssl_write_ticket for structure)
*/
-static int ssl_parse_ticket( ssl_context *ssl,
+static int ssl_parse_ticket( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t len )
{
int ret;
- ssl_session session;
+ mbedtls_ssl_session session;
unsigned char *key_name = buf;
unsigned char *iv = buf + 16;
unsigned char *enc_len_p = iv + 16;
@@ -269,16 +269,16 @@
size_t enc_len, clear_len, i;
unsigned char pad_len, diff;
- SSL_DEBUG_BUF( 3, "session ticket structure", buf, len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "session ticket structure", buf, len );
if( len < 34 || ssl->ticket_keys == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
enc_len = ( enc_len_p[0] << 8 ) | enc_len_p[1];
mac = ticket + enc_len;
if( len != enc_len + 66 )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
/* Check name, in constant time though it's not a big secret */
diff = 0;
@@ -287,7 +287,7 @@
/* don't return yet, check the MAC anyway */
/* Check mac, with constant-time buffer comparison */
- if( ( ret = md_hmac( md_info_from_type( POLARSSL_MD_SHA256 ),
+ if( ( ret = mbedtls_md_hmac( mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ),
ssl->ticket_keys->mac_key, 16,
buf, len - 32, computed_mac ) ) != 0 )
{
@@ -300,10 +300,10 @@
/* Now return if ticket is not authentic, since we want to avoid
* decrypting arbitrary attacker-chosen data */
if( diff != 0 )
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
/* Decrypt */
- if( ( ret = aes_crypt_cbc( &ssl->ticket_keys->dec, AES_DECRYPT,
+ if( ( ret = mbedtls_aes_crypt_cbc( &ssl->ticket_keys->dec, MBEDTLS_AES_DECRYPT,
enc_len, iv, ticket, ticket ) ) != 0 )
{
return( ret );
@@ -315,29 +315,29 @@
ret = 0;
for( i = 2; i < pad_len; i++ )
if( ticket[enc_len - i] != pad_len )
- ret = POLARSSL_ERR_SSL_BAD_INPUT_DATA;
+ ret = MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
if( ret != 0 )
return( ret );
clear_len = enc_len - pad_len;
- SSL_DEBUG_BUF( 3, "session ticket cleartext", ticket, clear_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "session ticket cleartext", ticket, clear_len );
/* Actually load session */
if( ( ret = ssl_load_session( &session, ticket, clear_len ) ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "failed to parse ticket content" ) );
- ssl_session_free( &session );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "failed to parse ticket content" ) );
+ mbedtls_ssl_session_free( &session );
return( ret );
}
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
/* Check if still valid */
if( (int) ( time( NULL) - session.start ) > ssl->ticket_lifetime )
{
- SSL_DEBUG_MSG( 1, ( "session ticket expired" ) );
- ssl_session_free( &session );
- return( POLARSSL_ERR_SSL_SESSION_TICKET_EXPIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "session ticket expired" ) );
+ mbedtls_ssl_session_free( &session );
+ return( MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED );
}
#endif
@@ -348,28 +348,28 @@
session.length = ssl->session_negotiate->length;
memcpy( &session.id, ssl->session_negotiate->id, session.length );
- ssl_session_free( ssl->session_negotiate );
- memcpy( ssl->session_negotiate, &session, sizeof( ssl_session ) );
+ mbedtls_ssl_session_free( ssl->session_negotiate );
+ memcpy( ssl->session_negotiate, &session, sizeof( mbedtls_ssl_session ) );
/* Zeroize instead of free as we copied the content */
- polarssl_zeroize( &session, sizeof( ssl_session ) );
+ mbedtls_zeroize( &session, sizeof( mbedtls_ssl_session ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
-int ssl_set_client_transport_id( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+int mbedtls_ssl_set_client_transport_id( mbedtls_ssl_context *ssl,
const unsigned char *info,
size_t ilen )
{
- if( ssl->endpoint != SSL_IS_SERVER )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( ssl->endpoint != MBEDTLS_SSL_IS_SERVER )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- polarssl_free( ssl->cli_id );
+ mbedtls_free( ssl->cli_id );
- if( ( ssl->cli_id = polarssl_malloc( ilen ) ) == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ if( ( ssl->cli_id = mbedtls_malloc( ilen ) ) == NULL )
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
memcpy( ssl->cli_id, info, ilen );
ssl->cli_id_len = ilen;
@@ -377,27 +377,27 @@
return( 0 );
}
-void ssl_set_dtls_cookies( ssl_context *ssl,
- ssl_cookie_write_t *f_cookie_write,
- ssl_cookie_check_t *f_cookie_check,
+void mbedtls_ssl_set_dtls_cookies( mbedtls_ssl_context *ssl,
+ mbedtls_ssl_cookie_write_t *f_cookie_write,
+ mbedtls_ssl_cookie_check_t *f_cookie_check,
void *p_cookie )
{
ssl->f_cookie_write = f_cookie_write;
ssl->f_cookie_check = f_cookie_check;
ssl->p_cookie = p_cookie;
}
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
/*
- * Wrapper around f_sni, allowing use of ssl_set_own_cert() but
+ * Wrapper around f_sni, allowing use of mbedtls_ssl_set_own_cert() but
* making it act on ssl->handshake->sni_key_cert instead.
*/
-static int ssl_sni_wrapper( ssl_context *ssl,
+static int ssl_sni_wrapper( mbedtls_ssl_context *ssl,
const unsigned char* name, size_t len )
{
int ret;
- ssl_key_cert *key_cert_ori = ssl->key_cert;
+ mbedtls_ssl_key_cert *key_cert_ori = ssl->key_cert;
ssl->key_cert = NULL;
ret = ssl->f_sni( ssl->p_sni, ssl, name, len );
@@ -408,7 +408,7 @@
return( ret );
}
-static int ssl_parse_servername_ext( ssl_context *ssl,
+static int ssl_parse_servername_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
@@ -416,13 +416,13 @@
size_t servername_list_size, hostname_len;
const unsigned char *p;
- SSL_DEBUG_MSG( 3, ( "parse ServerName extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "parse ServerName extension" ) );
servername_list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( servername_list_size + 2 != len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
p = buf + 2;
@@ -431,19 +431,19 @@
hostname_len = ( ( p[1] << 8 ) | p[2] );
if( hostname_len + 3 > servername_list_size )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- if( p[0] == TLS_EXT_SERVERNAME_HOSTNAME )
+ if( p[0] == MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME )
{
ret = ssl_sni_wrapper( ssl, p + 3, hostname_len );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_sni_wrapper", ret );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_UNRECOGNIZED_NAME );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_sni_wrapper", ret );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
return( 0 );
}
@@ -454,59 +454,59 @@
if( servername_list_size != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
return( 0 );
}
-#endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
-static int ssl_parse_renegotiation_info( ssl_context *ssl,
+static int ssl_parse_renegotiation_info( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
int ret;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
/* Check verify-data in constant-time. The length OTOH is no secret */
if( len != 1 + ssl->verify_data_len ||
buf[0] != ssl->verify_data_len ||
- safer_memcmp( buf + 1, ssl->peer_verify_data,
+ mbedtls_ssl_safer_memcmp( buf + 1, ssl->peer_verify_data,
ssl->verify_data_len ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
else
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
if( len != 1 || buf[0] != 0x0 )
{
- SSL_DEBUG_MSG( 1, ( "non-zero length renegotiation info" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-zero length renegotiation info" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- ssl->secure_renegotiation = SSL_SECURE_RENEGOTIATION;
+ ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
}
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_TLS1_2) && \
- defined(POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED)
-static int ssl_parse_signature_algorithms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
+ defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
+static int ssl_parse_signature_algorithms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
@@ -520,8 +520,8 @@
if( sig_alg_list_size + 2 != len ||
sig_alg_list_size % 2 != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
@@ -530,9 +530,9 @@
*
* So, just look at the HashAlgorithm part.
*/
- for( md_cur = md_list(); *md_cur != POLARSSL_MD_NONE; md_cur++ ) {
+ for( md_cur = mbedtls_md_list(); *md_cur != MBEDTLS_MD_NONE; md_cur++ ) {
for( p = buf + 2; p < end; p += 2 ) {
- if( *md_cur == (int) ssl_md_alg_from_hash( p[0] ) ) {
+ if( *md_cur == (int) mbedtls_ssl_md_alg_from_hash( p[0] ) ) {
ssl->handshake->sig_alg = p[0];
goto have_sig_alg;
}
@@ -540,50 +540,50 @@
}
/* Some key echanges do not need signatures at all */
- SSL_DEBUG_MSG( 3, ( "no signature_algorithm in common" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "no signature_algorithm in common" ) );
return( 0 );
have_sig_alg:
- SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext: %d",
ssl->handshake->sig_alg ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 &&
- POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
+ MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
-static int ssl_parse_supported_elliptic_curves( ssl_context *ssl,
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+static int ssl_parse_supported_elliptic_curves( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t list_size, our_size;
const unsigned char *p;
- const ecp_curve_info *curve_info, **curves;
+ const mbedtls_ecp_curve_info *curve_info, **curves;
list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( list_size + 2 != len ||
list_size % 2 != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Should never happen unless client duplicates the extension */
if( ssl->handshake->curves != NULL )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Don't allow our peer to make us allocate too much memory,
* and leave room for a final 0 */
our_size = list_size / 2 + 1;
- if( our_size > POLARSSL_ECP_DP_MAX )
- our_size = POLARSSL_ECP_DP_MAX;
+ if( our_size > MBEDTLS_ECP_DP_MAX )
+ our_size = MBEDTLS_ECP_DP_MAX;
- if( ( curves = polarssl_malloc( our_size * sizeof( *curves ) ) ) == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ if( ( curves = mbedtls_malloc( our_size * sizeof( *curves ) ) ) == NULL )
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
/* explicit void pointer cast for buggy MS compiler */
memset( (void *) curves, 0, our_size * sizeof( *curves ) );
@@ -592,7 +592,7 @@
p = buf + 2;
while( list_size > 0 && our_size > 1 )
{
- curve_info = ecp_curve_info_from_tls_id( ( p[0] << 8 ) | p[1] );
+ curve_info = mbedtls_ecp_curve_info_from_tls_id( ( p[0] << 8 ) | p[1] );
if( curve_info != NULL )
{
@@ -607,7 +607,7 @@
return( 0 );
}
-static int ssl_parse_supported_point_formats( ssl_context *ssl,
+static int ssl_parse_supported_point_formats( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
@@ -617,18 +617,18 @@
list_size = buf[0];
if( list_size + 1 != len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
p = buf + 2;
while( list_size > 0 )
{
- if( p[0] == POLARSSL_ECP_PF_UNCOMPRESSED ||
- p[0] == POLARSSL_ECP_PF_COMPRESSED )
+ if( p[0] == MBEDTLS_ECP_PF_UNCOMPRESSED ||
+ p[0] == MBEDTLS_ECP_PF_COMPRESSED )
{
ssl->handshake->ecdh_ctx.point_format = p[0];
- SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
return( 0 );
}
@@ -638,127 +638,127 @@
return( 0 );
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
-static int ssl_parse_max_fragment_length_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+static int ssl_parse_max_fragment_length_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
- if( len != 1 || buf[0] >= SSL_MAX_FRAG_LEN_INVALID )
+ if( len != 1 || buf[0] >= MBEDTLS_SSL_MAX_FRAG_LEN_INVALID )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->session_negotiate->mfl_code = buf[0];
return( 0 );
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
-static int ssl_parse_truncated_hmac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+static int ssl_parse_truncated_hmac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
- if( ssl->trunc_hmac == SSL_TRUNC_HMAC_ENABLED )
- ssl->session_negotiate->trunc_hmac = SSL_TRUNC_HMAC_ENABLED;
+ if( ssl->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_ENABLED )
+ ssl->session_negotiate->trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED;
return( 0 );
}
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
-static int ssl_parse_encrypt_then_mac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+static int ssl_parse_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
- if( ssl->encrypt_then_mac == SSL_ETM_ENABLED &&
- ssl->minor_ver != SSL_MINOR_VERSION_0 )
+ if( ssl->encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED &&
+ ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
- ssl->session_negotiate->encrypt_then_mac = SSL_ETM_ENABLED;
+ ssl->session_negotiate->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
}
return( 0 );
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
-static int ssl_parse_extended_ms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
- if( ssl->extended_ms == SSL_EXTENDED_MS_ENABLED &&
- ssl->minor_ver != SSL_MINOR_VERSION_0 )
+ if( ssl->extended_ms == MBEDTLS_SSL_EXTENDED_MS_ENABLED &&
+ ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
- ssl->handshake->extended_ms = SSL_EXTENDED_MS_ENABLED;
+ ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
}
return( 0 );
}
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static int ssl_parse_session_ticket_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static int ssl_parse_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t len )
{
int ret;
- if( ssl->session_tickets == SSL_SESSION_TICKETS_DISABLED )
+ if( ssl->session_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED )
return( 0 );
/* Remember the client asked us to send a new ticket */
ssl->handshake->new_session_ticket = 1;
- SSL_DEBUG_MSG( 3, ( "ticket length: %d", len ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket length: %d", len ) );
if( len == 0 )
return( 0 );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
- SSL_DEBUG_MSG( 3, ( "ticket rejected: renegotiating" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket rejected: renegotiating" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
/*
* Failures are ok: just ignore the ticket and proceed.
*/
if( ( ret = ssl_parse_ticket( ssl, buf, len ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_parse_ticket", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_parse_ticket", ret );
return( 0 );
}
- SSL_DEBUG_MSG( 3, ( "session successfully restored from ticket" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "session successfully restored from ticket" ) );
ssl->handshake->resume = 1;
@@ -767,10 +767,10 @@
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_SSL_ALPN)
-static int ssl_parse_alpn_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ALPN)
+static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, cur_len, ours_len;
@@ -791,11 +791,11 @@
/* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
if( len < 4 )
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
list_len = ( buf[0] << 8 ) | buf[1];
if( list_len != len - 2 )
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
/*
* Use our order of preference
@@ -809,13 +809,13 @@
{
/* If the list is well formed, we should get equality first */
if( theirs > end )
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
cur_len = *theirs++;
/* Empty strings MUST NOT be included */
if( cur_len == 0 )
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
if( cur_len == ours_len &&
memcmp( theirs, *ours, cur_len ) == 0 )
@@ -827,26 +827,26 @@
}
/* If we get there, no match was found */
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
-#endif /* POLARSSL_SSL_ALPN */
+#endif /* MBEDTLS_SSL_ALPN */
/*
* Auxiliary functions for ServerHello parsing and related actions
*/
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Return 0 if the given key uses one of the acceptable curves, -1 otherwise
*/
-#if defined(POLARSSL_ECDSA_C)
-static int ssl_check_key_curve( pk_context *pk,
- const ecp_curve_info **curves )
+#if defined(MBEDTLS_ECDSA_C)
+static int ssl_check_key_curve( mbedtls_pk_context *pk,
+ const mbedtls_ecp_curve_info **curves )
{
- const ecp_curve_info **crv = curves;
- ecp_group_id grp_id = pk_ec( *pk )->grp.id;
+ const mbedtls_ecp_curve_info **crv = curves;
+ mbedtls_ecp_group_id grp_id = mbedtls_pk_ec( *pk )->grp.id;
while( *crv != NULL )
{
@@ -857,38 +857,38 @@
return( -1 );
}
-#endif /* POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDSA_C */
/*
* Try picking a certificate for this ciphersuite,
* return 0 on success and -1 on failure.
*/
-static int ssl_pick_cert( ssl_context *ssl,
- const ssl_ciphersuite_t * ciphersuite_info )
+static int ssl_pick_cert( mbedtls_ssl_context *ssl,
+ const mbedtls_ssl_ciphersuite_t * ciphersuite_info )
{
- ssl_key_cert *cur, *list, *fallback = NULL;
- pk_type_t pk_alg = ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
+ mbedtls_ssl_key_cert *cur, *list, *fallback = NULL;
+ mbedtls_pk_type_t pk_alg = mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_key_cert != NULL )
list = ssl->handshake->sni_key_cert;
else
#endif
list = ssl->handshake->key_cert;
- if( pk_alg == POLARSSL_PK_NONE )
+ if( pk_alg == MBEDTLS_PK_NONE )
return( 0 );
- SSL_DEBUG_MSG( 3, ( "ciphersuite requires certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite requires certificate" ) );
for( cur = list; cur != NULL; cur = cur->next )
{
- SSL_DEBUG_CRT( 3, "candidate certificate chain, certificate",
+ MBEDTLS_SSL_DEBUG_CRT( 3, "candidate certificate chain, certificate",
cur->cert );
- if( ! pk_can_do( cur->key, pk_alg ) )
+ if( ! mbedtls_pk_can_do( cur->key, pk_alg ) )
{
- SSL_DEBUG_MSG( 3, ( "certificate mismatch: key type" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: key type" ) );
continue;
}
@@ -900,19 +900,19 @@
* different uses based on keyUsage, eg if they want to avoid signing
* and decrypting with the same RSA key.
*/
- if( ssl_check_cert_usage( cur->cert, ciphersuite_info,
- SSL_IS_SERVER ) != 0 )
+ if( mbedtls_ssl_check_cert_usage( cur->cert, ciphersuite_info,
+ MBEDTLS_SSL_IS_SERVER ) != 0 )
{
- SSL_DEBUG_MSG( 3, ( "certificate mismatch: "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: "
"(extended) key usage extension" ) );
continue;
}
-#if defined(POLARSSL_ECDSA_C)
- if( pk_alg == POLARSSL_PK_ECDSA &&
+#if defined(MBEDTLS_ECDSA_C)
+ if( pk_alg == MBEDTLS_PK_ECDSA &&
ssl_check_key_curve( cur->key, ssl->handshake->curves ) != 0 )
{
- SSL_DEBUG_MSG( 3, ( "certificate mismatch: elliptic curve" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: elliptic curve" ) );
continue;
}
#endif
@@ -922,13 +922,13 @@
* present them a SHA-higher cert rather than failing if it's the only
* one we got that satisfies the other conditions.
*/
- if( ssl->minor_ver < SSL_MINOR_VERSION_3 &&
- cur->cert->sig_md != POLARSSL_MD_SHA1 )
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 &&
+ cur->cert->sig_md != MBEDTLS_MD_SHA1 )
{
if( fallback == NULL )
fallback = cur;
{
- SSL_DEBUG_MSG( 3, ( "certificate not preferred: "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate not preferred: "
"sha-2 with pre-TLS 1.2 client" ) );
continue;
}
@@ -946,78 +946,78 @@
if( cur != NULL )
{
ssl->handshake->key_cert = cur;
- SSL_DEBUG_CRT( 3, "selected certificate chain, certificate",
+ MBEDTLS_SSL_DEBUG_CRT( 3, "selected certificate chain, certificate",
ssl->handshake->key_cert->cert );
return( 0 );
}
return( -1 );
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
/*
* Check if a given ciphersuite is suitable for use with our config/keys/etc
* Sets ciphersuite_info only if the suite matches.
*/
-static int ssl_ciphersuite_match( ssl_context *ssl, int suite_id,
- const ssl_ciphersuite_t **ciphersuite_info )
+static int ssl_ciphersuite_match( mbedtls_ssl_context *ssl, int suite_id,
+ const mbedtls_ssl_ciphersuite_t **ciphersuite_info )
{
- const ssl_ciphersuite_t *suite_info;
+ const mbedtls_ssl_ciphersuite_t *suite_info;
- suite_info = ssl_ciphersuite_from_id( suite_id );
+ suite_info = mbedtls_ssl_ciphersuite_from_id( suite_id );
if( suite_info == NULL )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_MSG( 3, ( "trying ciphersuite: %s", suite_info->name ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "trying ciphersuite: %s", suite_info->name ) );
if( suite_info->min_minor_ver > ssl->minor_ver ||
suite_info->max_minor_ver < ssl->minor_ver )
{
- SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: version" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: version" ) );
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
- ( suite_info->flags & POLARSSL_CIPHERSUITE_NODTLS ) )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
+ ( suite_info->flags & MBEDTLS_CIPHERSUITE_NODTLS ) )
return( 0 );
#endif
- if( ssl->arc4_disabled == SSL_ARC4_DISABLED &&
- suite_info->cipher == POLARSSL_CIPHER_ARC4_128 )
+ if( ssl->arc4_disabled == MBEDTLS_SSL_ARC4_DISABLED &&
+ suite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
{
- SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: rc4" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: rc4" ) );
return( 0 );
}
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
- if( ssl_ciphersuite_uses_ec( suite_info ) &&
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+ if( mbedtls_ssl_ciphersuite_uses_ec( suite_info ) &&
( ssl->handshake->curves == NULL ||
ssl->handshake->curves[0] == NULL ) )
{
- SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
"no common elliptic curve" ) );
return( 0 );
}
#endif
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
/* If the ciphersuite requires a pre-shared key and we don't
* have one, skip it now rather than failing later */
- if( ssl_ciphersuite_uses_psk( suite_info ) &&
+ if( mbedtls_ssl_ciphersuite_uses_psk( suite_info ) &&
ssl->f_psk == NULL &&
( ssl->psk == NULL || ssl->psk_identity == NULL ||
ssl->psk_identity_len == 0 || ssl->psk_len == 0 ) )
{
- SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: no pre-shared key" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: no pre-shared key" ) );
return( 0 );
}
#endif
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Final check: if ciphersuite requires us to have a
* certificate/key of a particular type:
@@ -1027,7 +1027,7 @@
*/
if( ssl_pick_cert( ssl, suite_info ) != 0 )
{
- SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
"no suitable certificate" ) );
return( 0 );
}
@@ -1037,8 +1037,8 @@
return( 0 );
}
-#if defined(POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
-static int ssl_parse_client_hello_v2( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
+static int ssl_parse_client_hello_v2( mbedtls_ssl_context *ssl )
{
int ret, got_common_suite;
unsigned int i, j;
@@ -1046,31 +1046,31 @@
unsigned int ciph_len, sess_len, chal_len;
unsigned char *buf, *p;
const int *ciphersuites;
- const ssl_ciphersuite_t *ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse client hello v2" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client hello v2" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "client hello v2 illegal for renegotiation" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "client hello v2 illegal for renegotiation" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
buf = ssl->in_hdr;
- SSL_DEBUG_BUF( 4, "record header", buf, 5 );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "record header", buf, 5 );
- SSL_DEBUG_MSG( 3, ( "client hello v2, message type: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, message type: %d",
buf[2] ) );
- SSL_DEBUG_MSG( 3, ( "client hello v2, message len.: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, message len.: %d",
( ( buf[0] & 0x7F ) << 8 ) | buf[1] ) );
- SSL_DEBUG_MSG( 3, ( "client hello v2, max. version: [%d:%d]",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, max. version: [%d:%d]",
buf[3], buf[4] ) );
/*
@@ -1083,43 +1083,43 @@
* 2 . 2 message type
* 3 . 4 protocol version
*/
- if( buf[2] != SSL_HS_CLIENT_HELLO ||
- buf[3] != SSL_MAJOR_VERSION_3 )
+ if( buf[2] != MBEDTLS_SSL_HS_CLIENT_HELLO ||
+ buf[3] != MBEDTLS_SSL_MAJOR_VERSION_3 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
n = ( ( buf[0] << 8 ) | buf[1] ) & 0x7FFF;
if( n < 17 || n > 512 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- ssl->major_ver = SSL_MAJOR_VERSION_3;
+ ssl->major_ver = MBEDTLS_SSL_MAJOR_VERSION_3;
ssl->minor_ver = ( buf[4] <= ssl->max_minor_ver )
? buf[4] : ssl->max_minor_ver;
if( ssl->minor_ver < ssl->min_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
" [%d:%d] < [%d:%d]",
ssl->major_ver, ssl->minor_ver,
ssl->min_major_ver, ssl->min_minor_ver ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_PROTOCOL_VERSION );
- return( POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
+ return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
ssl->handshake->max_major_ver = buf[3];
ssl->handshake->max_minor_ver = buf[4];
- if( ( ret = ssl_fetch_input( ssl, 2 + n ) ) != 0 )
+ if( ( ret = mbedtls_ssl_fetch_input( ssl, 2 + n ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_fetch_input", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
@@ -1136,13 +1136,13 @@
* .. . .. session id
* .. . .. challenge
*/
- SSL_DEBUG_BUF( 4, "record contents", buf, n );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "record contents", buf, n );
ciph_len = ( buf[0] << 8 ) | buf[1];
sess_len = ( buf[2] << 8 ) | buf[3];
chal_len = ( buf[4] << 8 ) | buf[5];
- SSL_DEBUG_MSG( 3, ( "ciph_len: %d, sess_len: %d, chal_len: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciph_len: %d, sess_len: %d, chal_len: %d",
ciph_len, sess_len, chal_len ) );
/*
@@ -1150,33 +1150,33 @@
*/
if( ciph_len < 3 || ( ciph_len % 3 ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( sess_len > 32 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( chal_len < 8 || chal_len > 32 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( n != 6 + ciph_len + sess_len + chal_len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
buf + 6, ciph_len );
- SSL_DEBUG_BUF( 3, "client hello, session id",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id",
buf + 6 + ciph_len, sess_len );
- SSL_DEBUG_BUF( 3, "client hello, challenge",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, challenge",
buf + 6 + ciph_len + sess_len, chal_len );
p = buf + 6 + ciph_len;
@@ -1194,54 +1194,54 @@
*/
for( i = 0, p = buf + 6; i < ciph_len; i += 3, p += 3 )
{
- if( p[0] == 0 && p[1] == 0 && p[2] == SSL_EMPTY_RENEGOTIATION_INFO )
+ if( p[0] == 0 && p[1] == 0 && p[2] == MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO )
{
- SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
- SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV "
"during renegotiation" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
- ssl->secure_renegotiation = SSL_SECURE_RENEGOTIATION;
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
+ ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
break;
}
}
-#if defined(POLARSSL_SSL_FALLBACK_SCSV)
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
for( i = 0, p = buf + 6; i < ciph_len; i += 3, p += 3 )
{
if( p[0] == 0 &&
- p[1] == (unsigned char)( ( SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
- p[2] == (unsigned char)( ( SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
+ p[1] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
+ p[2] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
{
- SSL_DEBUG_MSG( 3, ( "received FALLBACK_SCSV" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "received FALLBACK_SCSV" ) );
if( ssl->minor_ver < ssl->max_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "inapropriate fallback" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "inapropriate fallback" ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
break;
}
}
-#endif /* POLARSSL_SSL_FALLBACK_SCSV */
+#endif /* MBEDTLS_SSL_FALLBACK_SCSV */
got_common_suite = 0;
ciphersuites = ssl->ciphersuite_list[ssl->minor_ver];
ciphersuite_info = NULL;
-#if defined(POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
+#if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
for( j = 0, p = buf + 6; j < ciph_len; j += 3, p += 3 )
{
for( i = 0; ciphersuites[i] != 0; i++ )
@@ -1269,96 +1269,96 @@
if( got_common_suite )
{
- SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
"but none of them usable" ) );
- return( POLARSSL_ERR_SSL_NO_USABLE_CIPHERSUITE );
+ return( MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE );
}
else
{
- SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
- return( POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
+ return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
have_ciphersuite_v2:
- SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
ssl->session_negotiate->ciphersuite = ciphersuites[i];
ssl->transform_negotiate->ciphersuite_info = ciphersuite_info;
- ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
+ mbedtls_ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
/*
* SSLv2 Client Hello relevant renegotiation security checks
*/
- if( ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
- ssl->allow_legacy_renegotiation == SSL_LEGACY_BREAK_HANDSHAKE )
+ if( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
+ ssl->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->in_left = 0;
ssl->state++;
- SSL_DEBUG_MSG( 2, ( "<= parse client hello v2" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client hello v2" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
+#endif /* MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
-static int ssl_parse_client_hello( ssl_context *ssl )
+static int ssl_parse_client_hello( mbedtls_ssl_context *ssl )
{
int ret, got_common_suite;
unsigned int i, j;
unsigned int ciph_offset, comp_offset, ext_offset;
unsigned int msg_len, ciph_len, sess_len, comp_len, ext_len;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
unsigned int cookie_offset, cookie_len;
#endif
unsigned char *buf, *p, *ext;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renegotiation_info_seen = 0;
#endif
int handshake_failure = 0;
const int *ciphersuites;
- const ssl_ciphersuite_t *ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
int major, minor;
- SSL_DEBUG_MSG( 2, ( "=> parse client hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client hello" ) );
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
read_record_header:
#endif
/*
- * If renegotiating, then the input was read with ssl_read_record(),
+ * If renegotiating, then the input was read with mbedtls_ssl_read_record(),
* otherwise read it ourselves manually in order to support SSLv2
* ClientHello, which doesn't use the same record layer format.
*/
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
#endif
{
- if( ( ret = ssl_fetch_input( ssl, 5 ) ) != 0 )
+ if( ( ret = mbedtls_ssl_fetch_input( ssl, 5 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_fetch_input", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
}
buf = ssl->in_hdr;
-#if defined(POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_STREAM )
+#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_STREAM )
#endif
if( ( buf[0] & 0x80 ) != 0 )
return ssl_parse_client_hello_v2( ssl );
#endif
- SSL_DEBUG_BUF( 4, "record header", buf, ssl_hdr_len( ssl ) );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "record header", buf, mbedtls_ssl_hdr_len( ssl ) );
/*
* SSLv3/TLS Client Hello
@@ -1369,93 +1369,93 @@
* 3 . 11 DTLS: epoch + record sequence number
* 3 . 4 message length
*/
- SSL_DEBUG_MSG( 3, ( "client hello v3, message type: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, message type: %d",
buf[0] ) );
- if( buf[0] != SSL_MSG_HANDSHAKE )
+ if( buf[0] != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_MSG( 3, ( "client hello v3, message len.: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, message len.: %d",
( ssl->in_len[0] << 8 ) | ssl->in_len[1] ) );
- SSL_DEBUG_MSG( 3, ( "client hello v3, protocol version: [%d:%d]",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, protocol version: [%d:%d]",
buf[1], buf[2] ) );
- ssl_read_version( &major, &minor, ssl->transport, buf + 1 );
+ mbedtls_ssl_read_version( &major, &minor, ssl->transport, buf + 1 );
/* According to RFC 5246 Appendix E.1, the version here is typically
* "{03,00}, the lowest version number supported by the client, [or] the
* value of ClientHello.client_version", so the only meaningful check here
* is the major version shouldn't be less than 3 */
- if( major < SSL_MAJOR_VERSION_3 )
+ if( major < MBEDTLS_SSL_MAJOR_VERSION_3 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* For DTLS if this is the initial handshake, remember the client sequence
* number to use it in our next message (RFC 6347 4.2.1) */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- && ssl->renego_status == SSL_INITIAL_HANDSHAKE
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ && ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE
#endif
)
{
/* Epoch should be 0 for initial handshakes */
if( ssl->in_ctr[0] != 0 || ssl->in_ctr[1] != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
memcpy( ssl->out_ctr + 2, ssl->in_ctr + 2, 6 );
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
- if( ssl_dtls_replay_check( ssl ) != 0 )
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+ if( mbedtls_ssl_dtls_replay_check( ssl ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "replayed record, discarding" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "replayed record, discarding" ) );
ssl->next_record_offset = 0;
ssl->in_left = 0;
goto read_record_header;
}
/* No MAC to check yet, so we can update right now */
- ssl_dtls_replay_update( ssl );
+ mbedtls_ssl_dtls_replay_update( ssl );
#endif
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
msg_len = ( ssl->in_len[0] << 8 ) | ssl->in_len[1];
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
- /* Set by ssl_read_record() */
+ /* Set by mbedtls_ssl_read_record() */
msg_len = ssl->in_hslen;
}
else
#endif
{
- if( msg_len > SSL_MAX_CONTENT_LEN )
+ if( msg_len > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- if( ( ret = ssl_fetch_input( ssl, ssl_hdr_len( ssl ) + msg_len ) ) != 0 )
+ if( ( ret = mbedtls_ssl_fetch_input( ssl, mbedtls_ssl_hdr_len( ssl ) + msg_len ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_fetch_input", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
/* Done reading this record, get ready for the next one */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl->next_record_offset = msg_len + ssl_hdr_len( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ ssl->next_record_offset = msg_len + mbedtls_ssl_hdr_len( ssl );
else
#endif
ssl->in_left = 0;
@@ -1463,7 +1463,7 @@
buf = ssl->in_msg;
- SSL_DEBUG_BUF( 4, "record contents", buf, msg_len );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "record contents", buf, msg_len );
ssl->handshake->update_checksum( ssl, buf, msg_len );
@@ -1475,40 +1475,40 @@
* 6 . 8 DTLS only: fragment offset
* 9 . 11 DTLS only: fragment length
*/
- if( msg_len < ssl_hs_hdr_len( ssl ) )
+ if( msg_len < mbedtls_ssl_hs_hdr_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_MSG( 3, ( "client hello v3, handshake type: %d", buf[0] ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, handshake type: %d", buf[0] ) );
- if( buf[0] != SSL_HS_CLIENT_HELLO )
+ if( buf[0] != MBEDTLS_SSL_HS_CLIENT_HELLO )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_MSG( 3, ( "client hello v3, handshake len.: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, handshake len.: %d",
( buf[1] << 16 ) | ( buf[2] << 8 ) | buf[3] ) );
/* We don't support fragmentation of ClientHello (yet?) */
if( buf[1] != 0 ||
- msg_len != ssl_hs_hdr_len( ssl ) + ( ( buf[2] << 8 ) | buf[3] ) )
+ msg_len != mbedtls_ssl_hs_hdr_len( ssl ) + ( ( buf[2] << 8 ) | buf[3] ) )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/*
* Copy the client's handshake message_seq on initial handshakes,
* check sequence number on renego.
*/
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
/* This couldn't be done in ssl_prepare_handshake_record() */
unsigned int cli_msg_seq = ( ssl->in_msg[4] << 8 ) |
@@ -1516,10 +1516,10 @@
if( cli_msg_seq != ssl->handshake->in_msg_seq )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message_seq: "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message_seq: "
"%d (expected %d)", cli_msg_seq,
ssl->handshake->in_msg_seq ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->handshake->in_msg_seq++;
@@ -1540,14 +1540,14 @@
if( ssl->in_msg[6] != 0 || ssl->in_msg[7] != 0 || ssl->in_msg[8] != 0 ||
memcmp( ssl->in_msg + 1, ssl->in_msg + 9, 3 ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "ClientHello fragmentation not supported" ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "ClientHello fragmentation not supported" ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
- buf += ssl_hs_hdr_len( ssl );
- msg_len -= ssl_hs_hdr_len( ssl );
+ buf += mbedtls_ssl_hs_hdr_len( ssl );
+ msg_len -= mbedtls_ssl_hs_hdr_len( ssl );
/*
* ClientHello layer:
@@ -1572,16 +1572,16 @@
*/
if( msg_len < 38 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* Check and save the protocol version
*/
- SSL_DEBUG_BUF( 3, "client hello, version", buf, 2 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, version", buf, 2 );
- ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
+ mbedtls_ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
ssl->transport, buf );
ssl->handshake->max_major_ver = ssl->major_ver;
@@ -1590,15 +1590,15 @@
if( ssl->major_ver < ssl->min_major_ver ||
ssl->minor_ver < ssl->min_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
" [%d:%d] < [%d:%d]",
ssl->major_ver, ssl->minor_ver,
ssl->min_major_ver, ssl->min_minor_ver ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_PROTOCOL_VERSION );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
- return( POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
+ return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
if( ssl->major_ver > ssl->max_major_ver )
@@ -1612,7 +1612,7 @@
/*
* Save client random (inc. Unix time)
*/
- SSL_DEBUG_BUF( 3, "client hello, random bytes", buf + 2, 32 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, random bytes", buf + 2, 32 );
memcpy( ssl->handshake->randbytes, buf + 2, 32 );
@@ -1624,11 +1624,11 @@
if( sess_len > sizeof( ssl->session_negotiate->id ) ||
sess_len + 34 + 2 > msg_len ) /* 2 for cipherlist length field */
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_BUF( 3, "client hello, session id", buf + 35, sess_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id", buf + 35, sess_len );
ssl->session_negotiate->length = sess_len;
memset( ssl->session_negotiate->id, 0,
@@ -1639,25 +1639,25 @@
/*
* Check the cookie length and content
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
cookie_offset = 35 + sess_len;
cookie_len = buf[cookie_offset];
if( cookie_offset + 1 + cookie_len + 2 > msg_len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_BUF( 3, "client hello, cookie",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, cookie",
buf + cookie_offset + 1, cookie_len );
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
if( ssl->f_cookie_check != NULL
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- && ssl->renego_status == SSL_INITIAL_HANDSHAKE
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ && ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE
#endif
)
{
@@ -1665,26 +1665,26 @@
buf + cookie_offset + 1, cookie_len,
ssl->cli_id, ssl->cli_id_len ) != 0 )
{
- SSL_DEBUG_MSG( 2, ( "cookie verification failed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification failed" ) );
ssl->handshake->verify_cookie_len = 1;
}
else
{
- SSL_DEBUG_MSG( 2, ( "cookie verification passed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification passed" ) );
ssl->handshake->verify_cookie_len = 0;
}
}
else
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
{
/* We know we didn't send a cookie, so it should be empty */
if( cookie_len != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_MSG( 2, ( "cookie verification skipped" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification skipped" ) );
}
/*
@@ -1693,7 +1693,7 @@
ciph_offset = cookie_offset + 1 + cookie_len;
}
else
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
ciph_offset = 35 + sess_len;
ciph_len = ( buf[ciph_offset + 0] << 8 )
@@ -1703,11 +1703,11 @@
ciph_len + 2 + ciph_offset + 1 > msg_len || /* 1 for comp. alg. len */
( ciph_len % 2 ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
buf + ciph_offset + 2, ciph_len );
/*
@@ -1721,29 +1721,29 @@
comp_len > 16 ||
comp_len + comp_offset + 1 > msg_len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
- SSL_DEBUG_BUF( 3, "client hello, compression",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, compression",
buf + comp_offset + 1, comp_len );
- ssl->session_negotiate->compression = SSL_COMPRESS_NULL;
-#if defined(POLARSSL_ZLIB_SUPPORT)
+ ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_NULL;
+#if defined(MBEDTLS_ZLIB_SUPPORT)
for( i = 0; i < comp_len; ++i )
{
- if( buf[comp_offset + 1 + i] == SSL_COMPRESS_DEFLATE )
+ if( buf[comp_offset + 1 + i] == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
- ssl->session_negotiate->compression = SSL_COMPRESS_DEFLATE;
+ ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_DEFLATE;
break;
}
}
#endif
/* See comments in ssl_write_client_hello() */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl->session_negotiate->compression = SSL_COMPRESS_NULL;
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_NULL;
#endif
/*
@@ -1754,8 +1754,8 @@
{
if( msg_len < ext_offset + 2 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ext_len = ( buf[ext_offset + 0] << 8 )
@@ -1764,10 +1764,10 @@
if( ( ext_len > 0 && ext_len < 4 ) ||
msg_len != ext_offset + 2 + ext_len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- SSL_DEBUG_BUF( 3, "client hello extensions",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "client hello extensions",
buf + ext_offset + 2, ext_len );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
else
@@ -1784,14 +1784,14 @@
if( ext_size + 4 > ext_len )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
switch( ext_id )
{
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
- case TLS_EXT_SERVERNAME:
- SSL_DEBUG_MSG( 3, ( "found ServerName extension" ) );
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
+ case MBEDTLS_TLS_EXT_SERVERNAME:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found ServerName extension" ) );
if( ssl->f_sni == NULL )
break;
@@ -1799,11 +1799,11 @@
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
- case TLS_EXT_RENEGOTIATION_INFO:
- SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+ case MBEDTLS_TLS_EXT_RENEGOTIATION_INFO:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
renegotiation_info_seen = 1;
#endif
@@ -1812,12 +1812,12 @@
return( ret );
break;
-#if defined(POLARSSL_SSL_PROTO_TLS1_2) && \
- defined(POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED)
- case TLS_EXT_SIG_ALG:
- SSL_DEBUG_MSG( 3, ( "found signature_algorithms extension" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
+ defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
+ case MBEDTLS_TLS_EXT_SIG_ALG:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found signature_algorithms extension" ) );
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
break;
#endif
@@ -1825,90 +1825,90 @@
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 &&
- POLARSSL_KEY_EXCHANGE__WITH_CERT__ENABLED */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
+ MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
- case TLS_EXT_SUPPORTED_ELLIPTIC_CURVES:
- SSL_DEBUG_MSG( 3, ( "found supported elliptic curves extension" ) );
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+ case MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found supported elliptic curves extension" ) );
ret = ssl_parse_supported_elliptic_curves( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
- case TLS_EXT_SUPPORTED_POINT_FORMATS:
- SSL_DEBUG_MSG( 3, ( "found supported point formats extension" ) );
- ssl->handshake->cli_exts |= TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT;
+ case MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found supported point formats extension" ) );
+ ssl->handshake->cli_exts |= MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT;
ret = ssl_parse_supported_point_formats( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
- case TLS_EXT_MAX_FRAGMENT_LENGTH:
- SSL_DEBUG_MSG( 3, ( "found max fragment length extension" ) );
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+ case MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found max fragment length extension" ) );
ret = ssl_parse_max_fragment_length_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
- case TLS_EXT_TRUNCATED_HMAC:
- SSL_DEBUG_MSG( 3, ( "found truncated hmac extension" ) );
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+ case MBEDTLS_TLS_EXT_TRUNCATED_HMAC:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found truncated hmac extension" ) );
ret = ssl_parse_truncated_hmac_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- case TLS_EXT_ENCRYPT_THEN_MAC:
- SSL_DEBUG_MSG( 3, ( "found encrypt then mac extension" ) );
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ case MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found encrypt then mac extension" ) );
ret = ssl_parse_encrypt_then_mac_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
- case TLS_EXT_EXTENDED_MASTER_SECRET:
- SSL_DEBUG_MSG( 3, ( "found extended master secret extension" ) );
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+ case MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found extended master secret extension" ) );
ret = ssl_parse_extended_ms_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- case TLS_EXT_SESSION_TICKET:
- SSL_DEBUG_MSG( 3, ( "found session ticket extension" ) );
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ case MBEDTLS_TLS_EXT_SESSION_TICKET:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found session ticket extension" ) );
ret = ssl_parse_session_ticket_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_SSL_ALPN)
- case TLS_EXT_ALPN:
- SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
+#if defined(MBEDTLS_SSL_ALPN)
+ case MBEDTLS_TLS_EXT_ALPN:
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
ret = ssl_parse_alpn_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
default:
- SSL_DEBUG_MSG( 3, ( "unknown extension found: %d (ignoring)",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "unknown extension found: %d (ignoring)",
ext_id ) );
}
@@ -1917,54 +1917,54 @@
if( ext_len > 0 && ext_len < 4 )
{
- SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
-#if defined(POLARSSL_SSL_FALLBACK_SCSV)
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
for( i = 0, p = buf + 41 + sess_len; i < ciph_len; i += 2, p += 2 )
{
- if( p[0] == (unsigned char)( ( SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
- p[1] == (unsigned char)( ( SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
+ if( p[0] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
+ p[1] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
{
- SSL_DEBUG_MSG( 0, ( "received FALLBACK_SCSV" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 0, ( "received FALLBACK_SCSV" ) );
if( ssl->minor_ver < ssl->max_minor_ver )
{
- SSL_DEBUG_MSG( 0, ( "inapropriate fallback" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 0, ( "inapropriate fallback" ) );
- ssl_send_alert_message( ssl, SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
+ mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
break;
}
}
-#endif /* POLARSSL_SSL_FALLBACK_SCSV */
+#endif /* MBEDTLS_SSL_FALLBACK_SCSV */
/*
* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV
*/
for( i = 0, p = buf + ciph_offset + 2; i < ciph_len; i += 2, p += 2 )
{
- if( p[0] == 0 && p[1] == SSL_EMPTY_RENEGOTIATION_INFO )
+ if( p[0] == 0 && p[1] == MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO )
{
- SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
- SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV during renegotiation" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV during renegotiation" ) );
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#endif
- ssl->secure_renegotiation = SSL_SECURE_RENEGOTIATION;
+ ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
break;
}
}
@@ -1972,42 +1972,42 @@
/*
* Renegotiation security checks
*/
- if( ssl->secure_renegotiation != SSL_SECURE_RENEGOTIATION &&
- ssl->allow_legacy_renegotiation == SSL_LEGACY_BREAK_HANDSHAKE )
+ if( ssl->secure_renegotiation != MBEDTLS_SSL_SECURE_RENEGOTIATION &&
+ ssl->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
handshake_failure = 1;
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_SECURE_RENEGOTIATION &&
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_SECURE_RENEGOTIATION &&
renegotiation_info_seen == 0 )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation_info extension missing (secure)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension missing (secure)" ) );
handshake_failure = 1;
}
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
- ssl->allow_legacy_renegotiation == SSL_LEGACY_NO_RENEGOTIATION )
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
+ ssl->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION )
{
- SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
handshake_failure = 1;
}
- else if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
renegotiation_info_seen == 1 )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation_info extension present (legacy)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension present (legacy)" ) );
handshake_failure = 1;
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
if( handshake_failure == 1 )
{
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
@@ -2018,7 +2018,7 @@
got_common_suite = 0;
ciphersuites = ssl->ciphersuite_list[ssl->minor_ver];
ciphersuite_info = NULL;
-#if defined(POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
+#if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
for( j = 0, p = buf + ciph_offset + 2; j < ciph_len; j += 2, p += 2 )
{
for( i = 0; ciphersuites[i] != 0; i++ )
@@ -2045,73 +2045,73 @@
if( got_common_suite )
{
- SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
"but none of them usable" ) );
- ssl_send_fatal_handshake_failure( ssl );
- return( POLARSSL_ERR_SSL_NO_USABLE_CIPHERSUITE );
+ mbedtls_ssl_send_fatal_handshake_failure( ssl );
+ return( MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE );
}
else
{
- SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
- ssl_send_fatal_handshake_failure( ssl );
- return( POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
+ mbedtls_ssl_send_fatal_handshake_failure( ssl );
+ return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
have_ciphersuite:
- SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
ssl->session_negotiate->ciphersuite = ciphersuites[i];
ssl->transform_negotiate->ciphersuite_info = ciphersuite_info;
- ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
+ mbedtls_ssl_optimize_checksum( ssl, ssl->transform_negotiate->ciphersuite_info );
ssl->state++;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_recv_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_recv_flight_completed( ssl );
#endif
- SSL_DEBUG_MSG( 2, ( "<= parse client hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client hello" ) );
return( 0 );
}
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
-static void ssl_write_truncated_hmac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+static void ssl_write_truncated_hmac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- if( ssl->session_negotiate->trunc_hmac == SSL_TRUNC_HMAC_DISABLED )
+ if( ssl->session_negotiate->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, adding truncated hmac extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding truncated hmac extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_TRUNCATED_HMAC >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_TRUNCATED_HMAC ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_TRUNCATED_HMAC >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_TRUNCATED_HMAC ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
-static void ssl_write_encrypt_then_mac_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+static void ssl_write_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- const ssl_ciphersuite_t *suite = NULL;
- const cipher_info_t *cipher = NULL;
+ const mbedtls_ssl_ciphersuite_t *suite = NULL;
+ const mbedtls_cipher_info_t *cipher = NULL;
- if( ssl->session_negotiate->encrypt_then_mac == SSL_EXTENDED_MS_DISABLED ||
- ssl->minor_ver == SSL_MINOR_VERSION_0 )
+ if( ssl->session_negotiate->encrypt_then_mac == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
@@ -2123,56 +2123,56 @@
* with Associated Data (AEAD) ciphersuite, it MUST NOT send an
* encrypt-then-MAC response extension back to the client."
*/
- if( ( suite = ssl_ciphersuite_from_id(
+ if( ( suite = mbedtls_ssl_ciphersuite_from_id(
ssl->session_negotiate->ciphersuite ) ) == NULL ||
- ( cipher = cipher_info_from_type( suite->cipher ) ) == NULL ||
- cipher->mode != POLARSSL_MODE_CBC )
+ ( cipher = mbedtls_cipher_info_from_type( suite->cipher ) ) == NULL ||
+ cipher->mode != MBEDTLS_MODE_CBC )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, adding encrypt then mac extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding encrypt then mac extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_ENCRYPT_THEN_MAC >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_ENCRYPT_THEN_MAC ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
-static void ssl_write_extended_ms_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+static void ssl_write_extended_ms_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- if( ssl->handshake->extended_ms == SSL_EXTENDED_MS_DISABLED ||
- ssl->minor_ver == SSL_MINOR_VERSION_0 )
+ if( ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, adding extended master secret "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding extended master secret "
"extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_EXTENDED_MASTER_SECRET >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_EXTENDED_MASTER_SECRET ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static void ssl_write_session_ticket_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static void ssl_write_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
@@ -2184,37 +2184,37 @@
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, adding session ticket extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding session ticket extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_SESSION_TICKET >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SESSION_TICKET ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
-static void ssl_write_renegotiation_ext( ssl_context *ssl,
+static void ssl_write_renegotiation_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- if( ssl->secure_renegotiation != SSL_SECURE_RENEGOTIATION )
+ if( ssl->secure_renegotiation != MBEDTLS_SSL_SECURE_RENEGOTIATION )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, secure renegotiation extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, secure renegotiation extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_RENEGOTIATION_INFO >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_RENEGOTIATION_INFO ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO ) & 0xFF );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status != SSL_INITIAL_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
*p++ = 0x00;
*p++ = ( ssl->verify_data_len * 2 + 1 ) & 0xFF;
@@ -2228,7 +2228,7 @@
*olen = 5 + ssl->verify_data_len * 2;
}
else
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
*p++ = 0x00;
*p++ = 0x01;
@@ -2238,23 +2238,23 @@
}
}
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
-static void ssl_write_max_fragment_length_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+static void ssl_write_max_fragment_length_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
- if( ssl->session_negotiate->mfl_code == SSL_MAX_FRAG_LEN_NONE )
+ if( ssl->session_negotiate->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, max_fragment_length extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, max_fragment_length extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_MAX_FRAGMENT_LENGTH >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_MAX_FRAGMENT_LENGTH ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH ) & 0xFF );
*p++ = 0x00;
*p++ = 1;
@@ -2263,10 +2263,10 @@
*olen = 5;
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
-static void ssl_write_supported_point_formats_ext( ssl_context *ssl,
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
+static void ssl_write_supported_point_formats_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
@@ -2274,29 +2274,29 @@
((void) ssl);
if( ( ssl->handshake->cli_exts &
- TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT ) == 0 )
+ MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT ) == 0 )
{
*olen = 0;
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, supported_point_formats extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, supported_point_formats extension" ) );
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_POINT_FORMATS >> 8 ) & 0xFF );
- *p++ = (unsigned char)( ( TLS_EXT_SUPPORTED_POINT_FORMATS ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS >> 8 ) & 0xFF );
+ *p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS ) & 0xFF );
*p++ = 0x00;
*p++ = 2;
*p++ = 1;
- *p++ = POLARSSL_ECP_PF_UNCOMPRESSED;
+ *p++ = MBEDTLS_ECP_PF_UNCOMPRESSED;
*olen = 6;
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_ALPN )
-static void ssl_write_alpn_ext( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_ALPN )
+static void ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
if( ssl->alpn_chosen == NULL )
@@ -2305,7 +2305,7 @@
return;
}
- SSL_DEBUG_MSG( 3, ( "server hello, adding alpn extension" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding alpn extension" ) );
/*
* 0 . 1 ext identifier
@@ -2314,8 +2314,8 @@
* 6 . 6 protocol name length
* 7 . 7+n protocol name
*/
- buf[0] = (unsigned char)( ( TLS_EXT_ALPN >> 8 ) & 0xFF );
- buf[1] = (unsigned char)( ( TLS_EXT_ALPN ) & 0xFF );
+ buf[0] = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN >> 8 ) & 0xFF );
+ buf[1] = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN ) & 0xFF );
*olen = 7 + strlen( ssl->alpn_chosen );
@@ -2329,16 +2329,16 @@
memcpy( buf + 7, ssl->alpn_chosen, *olen - 7 );
}
-#endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
+#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
-static int ssl_write_hello_verify_request( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+static int ssl_write_hello_verify_request( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *p = ssl->out_msg + 4;
unsigned char *cookie_len_byte;
- SSL_DEBUG_MSG( 2, ( "=> write hello verify request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write hello verify request" ) );
/*
* struct {
@@ -2349,77 +2349,77 @@
/* The RFC is not clear on this point, but sending the actual negotiated
* version looks like the most interoperable thing to do. */
- ssl_write_version( ssl->major_ver, ssl->minor_ver,
+ mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->transport, p );
- SSL_DEBUG_BUF( 3, "server version", p, 2 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
p += 2;
/* If we get here, f_cookie_check is not null */
if( ssl->f_cookie_write == NULL )
{
- SSL_DEBUG_MSG( 1, ( "inconsistent cookie callbacks" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "inconsistent cookie callbacks" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/* Skip length byte until we know the length */
cookie_len_byte = p++;
if( ( ret = ssl->f_cookie_write( ssl->p_cookie,
- &p, ssl->out_buf + SSL_BUFFER_LEN,
+ &p, ssl->out_buf + MBEDTLS_SSL_BUFFER_LEN,
ssl->cli_id, ssl->cli_id_len ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "f_cookie_write", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "f_cookie_write", ret );
return( ret );
}
*cookie_len_byte = (unsigned char)( p - ( cookie_len_byte + 1 ) );
- SSL_DEBUG_BUF( 3, "cookie sent", cookie_len_byte + 1, *cookie_len_byte );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "cookie sent", cookie_len_byte + 1, *cookie_len_byte );
ssl->out_msglen = p - ssl->out_msg;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_HELLO_VERIFY_REQUEST;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST;
- ssl->state = SSL_SERVER_HELLO_VERIFY_REQUEST_SENT;
+ ssl->state = MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write hello verify request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write hello verify request" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
-static int ssl_write_server_hello( ssl_context *ssl )
+static int ssl_write_server_hello( mbedtls_ssl_context *ssl )
{
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
time_t t;
#endif
int ret;
size_t olen, ext_len = 0, n;
unsigned char *buf, *p;
- SSL_DEBUG_MSG( 2, ( "=> write server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server hello" ) );
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->verify_cookie_len != 0 )
{
- SSL_DEBUG_MSG( 2, ( "client hello was not authenticated" ) );
- SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "client hello was not authenticated" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
return( ssl_write_hello_verify_request( ssl ) );
}
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
if( ssl->f_rng == NULL )
{
- SSL_DEBUG_MSG( 1, ( "no RNG provided") );
- return( POLARSSL_ERR_SSL_NO_RNG );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "no RNG provided") );
+ return( MBEDTLS_ERR_SSL_NO_RNG );
}
/*
@@ -2432,27 +2432,27 @@
buf = ssl->out_msg;
p = buf + 4;
- ssl_write_version( ssl->major_ver, ssl->minor_ver,
+ mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->transport, p );
p += 2;
- SSL_DEBUG_MSG( 3, ( "server hello, chosen version: [%d:%d]",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen version: [%d:%d]",
buf[4], buf[5] ) );
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
t = time( NULL );
*p++ = (unsigned char)( t >> 24 );
*p++ = (unsigned char)( t >> 16 );
*p++ = (unsigned char)( t >> 8 );
*p++ = (unsigned char)( t );
- SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
#else
if( ( ret = ssl->f_rng( ssl->p_rng, p, 4 ) ) != 0 )
return( ret );
p += 4;
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
if( ( ret = ssl->f_rng( ssl->p_rng, p, 28 ) ) != 0 )
return( ret );
@@ -2461,7 +2461,7 @@
memcpy( ssl->handshake->randbytes + 32, buf + 6, 32 );
- SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 6, 32 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 6, 32 );
/*
* Resume is 0 by default, see ssl_handshake_init().
@@ -2469,14 +2469,14 @@
* If not, try looking up session ID in our cache.
*/
if( ssl->handshake->resume == 0 &&
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- ssl->renego_status == SSL_INITIAL_HANDSHAKE &&
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE &&
#endif
ssl->session_negotiate->length != 0 &&
ssl->f_get_cache != NULL &&
ssl->f_get_cache( ssl->p_get_cache, ssl->session_negotiate ) == 0 )
{
- SSL_DEBUG_MSG( 3, ( "session successfully restored from cache" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "session successfully restored from cache" ) );
ssl->handshake->resume = 1;
}
@@ -2488,18 +2488,18 @@
*/
ssl->state++;
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
ssl->session_negotiate->start = time( NULL );
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->handshake->new_session_ticket != 0 )
{
ssl->session_negotiate->length = n = 0;
memset( ssl->session_negotiate->id, 0, 32 );
}
else
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
{
ssl->session_negotiate->length = n = 32;
if( ( ret = ssl->f_rng( ssl->p_rng, ssl->session_negotiate->id,
@@ -2513,11 +2513,11 @@
* Resuming a session
*/
n = ssl->session_negotiate->length;
- ssl->state = SSL_SERVER_CHANGE_CIPHER_SPEC;
+ ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
- if( ( ret = ssl_derive_keys( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_derive_keys", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
}
@@ -2534,18 +2534,18 @@
memcpy( p, ssl->session_negotiate->id, ssl->session_negotiate->length );
p += ssl->session_negotiate->length;
- SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
- SSL_DEBUG_BUF( 3, "server hello, session id", buf + 39, n );
- SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, session id", buf + 39, n );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
ssl->handshake->resume ? "a" : "no" ) );
*p++ = (unsigned char)( ssl->session_negotiate->ciphersuite >> 8 );
*p++ = (unsigned char)( ssl->session_negotiate->ciphersuite );
*p++ = (unsigned char)( ssl->session_negotiate->compression );
- SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %s",
- ssl_get_ciphersuite_name( ssl->session_negotiate->ciphersuite ) ) );
- SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: 0x%02X",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %s",
+ mbedtls_ssl_get_ciphersuite_name( ssl->session_negotiate->ciphersuite ) ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: 0x%02X",
ssl->session_negotiate->compression ) );
/*
@@ -2554,42 +2554,42 @@
ssl_write_renegotiation_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
ssl_write_max_fragment_length_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
ssl_write_truncated_hmac_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
ssl_write_encrypt_then_mac_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
ssl_write_extended_ms_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
ssl_write_session_ticket_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
ssl_write_supported_point_formats_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
-#if defined(POLARSSL_SSL_ALPN)
+#if defined(MBEDTLS_SSL_ALPN)
ssl_write_alpn_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
- SSL_DEBUG_MSG( 3, ( "server hello, total extension length: %d", ext_len ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, total extension length: %d", ext_len ) );
if( ext_len > 0 )
{
@@ -2599,60 +2599,60 @@
}
ssl->out_msglen = p - buf;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_SERVER_HELLO;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_HELLO;
- ret = ssl_write_record( ssl );
+ ret = mbedtls_ssl_write_record( ssl );
- SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
return( ret );
}
-#if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-static int ssl_write_certificate_request( ssl_context *ssl )
+#if !defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else
-static int ssl_write_certificate_request( ssl_context *ssl )
+static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
size_t dn_size, total_dn_size; /* excluding length bytes */
size_t ct_len, sa_len; /* including length bytes */
unsigned char *buf, *p;
- const x509_crt *crt;
+ const mbedtls_x509_crt *crt;
- SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
ssl->state++;
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ssl->authmode == SSL_VERIFY_NONE )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ssl->authmode == MBEDTLS_SSL_VERIFY_NONE )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
return( 0 );
}
@@ -2679,18 +2679,18 @@
*/
ct_len = 0;
-#if defined(POLARSSL_RSA_C)
- p[1 + ct_len++] = SSL_CERT_TYPE_RSA_SIGN;
+#if defined(MBEDTLS_RSA_C)
+ p[1 + ct_len++] = MBEDTLS_SSL_CERT_TYPE_RSA_SIGN;
#endif
-#if defined(POLARSSL_ECDSA_C)
- p[1 + ct_len++] = SSL_CERT_TYPE_ECDSA_SIGN;
+#if defined(MBEDTLS_ECDSA_C)
+ p[1 + ct_len++] = MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN;
#endif
p[0] = (unsigned char) ct_len++;
p += ct_len;
sa_len = 0;
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
/*
* Add signature_algorithms for verify (TLS 1.2)
*
@@ -2704,30 +2704,30 @@
* enum { (255) } HashAlgorithm;
* enum { (255) } SignatureAlgorithm;
*/
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
/*
* Only use current running hash algorithm that is already required
* for requested ciphersuite.
*/
- ssl->handshake->verify_sig_alg = SSL_HASH_SHA256;
+ ssl->handshake->verify_sig_alg = MBEDTLS_SSL_HASH_SHA256;
if( ssl->transform_negotiate->ciphersuite_info->mac ==
- POLARSSL_MD_SHA384 )
+ MBEDTLS_MD_SHA384 )
{
- ssl->handshake->verify_sig_alg = SSL_HASH_SHA384;
+ ssl->handshake->verify_sig_alg = MBEDTLS_SSL_HASH_SHA384;
}
/*
* Supported signature algorithms
*/
-#if defined(POLARSSL_RSA_C)
+#if defined(MBEDTLS_RSA_C)
p[2 + sa_len++] = ssl->handshake->verify_sig_alg;
- p[2 + sa_len++] = SSL_SIG_RSA;
+ p[2 + sa_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
-#if defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDSA_C)
p[2 + sa_len++] = ssl->handshake->verify_sig_alg;
- p[2 + sa_len++] = SSL_SIG_ECDSA;
+ p[2 + sa_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
p[0] = (unsigned char)( sa_len >> 8 );
@@ -2735,7 +2735,7 @@
sa_len += 2;
p += sa_len;
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
/*
* DistinguishedName certificate_authorities<0..2^16-1>;
@@ -2756,66 +2756,66 @@
memcpy( p, crt->subject_raw.p, dn_size );
p += dn_size;
- SSL_DEBUG_BUF( 3, "requested DN", p, dn_size );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "requested DN", p, dn_size );
total_dn_size += 2 + dn_size;
crt = crt->next;
}
ssl->out_msglen = p - buf;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_CERTIFICATE_REQUEST;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_REQUEST;
ssl->out_msg[4 + ct_len + sa_len] = (unsigned char)( total_dn_size >> 8 );
ssl->out_msg[5 + ct_len + sa_len] = (unsigned char)( total_dn_size );
- ret = ssl_write_record( ssl );
+ ret = mbedtls_ssl_write_record( ssl );
- SSL_DEBUG_MSG( 2, ( "<= write certificate request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate request" ) );
return( ret );
}
-#endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* !MBEDTLS_KEY_EXCHANGE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
-static int ssl_get_ecdh_params_from_cert( ssl_context *ssl )
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
{
int ret;
- if( ! pk_can_do( ssl_own_key( ssl ), POLARSSL_PK_ECKEY ) )
+ if( ! mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECKEY ) )
{
- SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
- return( POLARSSL_ERR_SSL_PK_TYPE_MISMATCH );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
+ return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
- if( ( ret = ecdh_get_params( &ssl->handshake->ecdh_ctx,
- pk_ec( *ssl_own_key( ssl ) ),
- POLARSSL_ECDH_OURS ) ) != 0 )
+ if( ( ret = mbedtls_ecdh_get_params( &ssl->handshake->ecdh_ctx,
+ mbedtls_pk_ec( *mbedtls_ssl_own_key( ssl ) ),
+ MBEDTLS_ECDH_OURS ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ecdh_get_params" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_get_params" ), ret );
return( ret );
}
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-static int ssl_write_server_key_exchange( ssl_context *ssl )
+static int ssl_write_server_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
size_t n = 0;
- const ssl_ciphersuite_t *ciphersuite_info =
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->transform_negotiate->ciphersuite_info;
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
unsigned char *p = ssl->out_msg + 4;
unsigned char *dig_signed = p;
size_t dig_signed_len = 0, len;
@@ -2823,38 +2823,38 @@
((void) dig_signed_len);
#endif
- SSL_DEBUG_MSG( 2, ( "=> write server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server key exchange" ) );
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
ssl->state++;
return( 0 );
}
#endif
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
ssl_get_ecdh_params_from_cert( ssl );
- SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
ssl->state++;
return( 0 );
}
#endif
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/* TODO: Support identity hints */
*(p++) = 0x00;
@@ -2862,13 +2862,13 @@
n += 2;
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
/*
* Ephemeral DH parameters:
@@ -2879,18 +2879,18 @@
* opaque dh_Ys<1..2^16-1>;
* } ServerDHParams;
*/
- if( ( ret = mpi_copy( &ssl->handshake->dhm_ctx.P, &ssl->dhm_P ) ) != 0 ||
- ( ret = mpi_copy( &ssl->handshake->dhm_ctx.G, &ssl->dhm_G ) ) != 0 )
+ if( ( ret = mbedtls_mpi_copy( &ssl->handshake->dhm_ctx.P, &ssl->dhm_P ) ) != 0 ||
+ ( ret = mbedtls_mpi_copy( &ssl->handshake->dhm_ctx.G, &ssl->dhm_G ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_copy", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_copy", ret );
return( ret );
}
- if( ( ret = dhm_make_params( &ssl->handshake->dhm_ctx,
- (int) mpi_size( &ssl->handshake->dhm_ctx.P ),
+ if( ( ret = mbedtls_dhm_make_params( &ssl->handshake->dhm_ctx,
+ (int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
p, &len, ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_make_params", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_params", ret );
return( ret );
}
@@ -2900,18 +2900,18 @@
p += len;
n += len;
- SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
- SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
- SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
- SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__ECDHE_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__ECDHE_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
/*
* Ephemeral ECDH parameters:
@@ -2921,12 +2921,12 @@
* ECPoint public;
* } ServerECDHParams;
*/
- const ecp_curve_info **curve = NULL;
-#if defined(POLARSSL_SSL_SET_CURVES)
- const ecp_group_id *gid;
+ const mbedtls_ecp_curve_info **curve = NULL;
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ const mbedtls_ecp_group_id *gid;
/* Match our preference list against the offered curves */
- for( gid = ssl->curve_list; *gid != POLARSSL_ECP_DP_NONE; gid++ )
+ for( gid = ssl->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++ )
for( curve = ssl->handshake->curves; *curve != NULL; curve++ )
if( (*curve)->grp_id == *gid )
goto curve_matching_done;
@@ -2938,24 +2938,24 @@
if( *curve == NULL )
{
- SSL_DEBUG_MSG( 1, ( "no matching curve for ECDHE" ) );
- return( POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "no matching curve for ECDHE" ) );
+ return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
- SSL_DEBUG_MSG( 2, ( "ECDHE curve: %s", (*curve)->name ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "ECDHE curve: %s", (*curve)->name ) );
- if( ( ret = ecp_use_known_dp( &ssl->handshake->ecdh_ctx.grp,
+ if( ( ret = mbedtls_ecp_use_known_dp( &ssl->handshake->ecdh_ctx.grp,
(*curve)->grp_id ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecp_use_known_dp", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecp_use_known_dp", ret );
return( ret );
}
- if( ( ret = ecdh_make_params( &ssl->handshake->ecdh_ctx, &len,
- p, SSL_MAX_CONTENT_LEN - n,
+ if( ( ret = mbedtls_ecdh_make_params( &ssl->handshake->ecdh_ctx, &len,
+ p, MBEDTLS_SSL_MAX_CONTENT_LEN - n,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_make_params", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_params", ret );
return( ret );
}
@@ -2965,63 +2965,63 @@
p += len;
n += len;
- SSL_DEBUG_ECP( 3, "ECDH: Q ", &ssl->handshake->ecdh_ctx.Q );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Q ", &ssl->handshake->ecdh_ctx.Q );
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__ECDHE_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__ECDHE_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
size_t signature_len = 0;
unsigned int hashlen = 0;
unsigned char hash[64];
- md_type_t md_alg = POLARSSL_MD_NONE;
+ mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
/*
* Choose hash algorithm. NONE means MD5 + SHA1 here.
*/
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
- md_alg = ssl_md_alg_from_hash( ssl->handshake->sig_alg );
+ md_alg = mbedtls_ssl_md_alg_from_hash( ssl->handshake->sig_alg );
- if( md_alg == POLARSSL_MD_NONE )
+ if( md_alg == MBEDTLS_MD_NONE )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ciphersuite_info->key_exchange ==
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA )
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
- md_alg = POLARSSL_MD_SHA1;
+ md_alg = MBEDTLS_MD_SHA1;
}
else
#endif
{
- md_alg = POLARSSL_MD_NONE;
+ md_alg = MBEDTLS_MD_NONE;
}
/*
* Compute the hash to be signed
*/
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( md_alg == POLARSSL_MD_NONE )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( md_alg == MBEDTLS_MD_NONE )
{
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
- md5_init( &md5 );
- sha1_init( &sha1 );
+ mbedtls_md5_init( &mbedtls_md5 );
+ mbedtls_sha1_init( &mbedtls_sha1 );
/*
* digitally-signed struct {
@@ -3036,32 +3036,32 @@
* SHA(ClientHello.random + ServerHello.random
* + ServerParams);
*/
- md5_starts( &md5 );
- md5_update( &md5, ssl->handshake->randbytes, 64 );
- md5_update( &md5, dig_signed, dig_signed_len );
- md5_finish( &md5, hash );
+ mbedtls_md5_starts( &mbedtls_md5 );
+ mbedtls_md5_update( &mbedtls_md5, ssl->handshake->randbytes, 64 );
+ mbedtls_md5_update( &mbedtls_md5, dig_signed, dig_signed_len );
+ mbedtls_md5_finish( &mbedtls_md5, hash );
- sha1_starts( &sha1 );
- sha1_update( &sha1, ssl->handshake->randbytes, 64 );
- sha1_update( &sha1, dig_signed, dig_signed_len );
- sha1_finish( &sha1, hash + 16 );
+ mbedtls_sha1_starts( &mbedtls_sha1 );
+ mbedtls_sha1_update( &mbedtls_sha1, ssl->handshake->randbytes, 64 );
+ mbedtls_sha1_update( &mbedtls_sha1, dig_signed, dig_signed_len );
+ mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
hashlen = 36;
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 || \
- POLARSSL_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( md_alg != POLARSSL_MD_NONE )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
+ MBEDTLS_SSL_PROTO_TLS1_1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( md_alg != MBEDTLS_MD_NONE )
{
- md_context_t ctx;
- const md_info_t *md_info = md_info_from_type( md_alg );
+ mbedtls_md_context_t ctx;
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
- md_init( &ctx );
+ mbedtls_md_init( &ctx );
/* Info from md_alg will be used instead */
hashlen = 0;
@@ -3073,53 +3073,53 @@
* ServerDHParams params;
* };
*/
- if( ( ret = md_setup( &ctx, md_info, 0 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "md_setup", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_md_setup", ret );
return( ret );
}
- md_starts( &ctx );
- md_update( &ctx, ssl->handshake->randbytes, 64 );
- md_update( &ctx, dig_signed, dig_signed_len );
- md_finish( &ctx, hash );
- md_free( &ctx );
+ mbedtls_md_starts( &ctx );
+ mbedtls_md_update( &ctx, ssl->handshake->randbytes, 64 );
+ mbedtls_md_update( &ctx, dig_signed, dig_signed_len );
+ mbedtls_md_finish( &ctx, hash );
+ mbedtls_md_free( &ctx );
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 || \
- POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
+ MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen != 0 ? hashlen :
- (unsigned int) ( md_get_size( md_info_from_type( md_alg ) ) ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen != 0 ? hashlen :
+ (unsigned int) ( mbedtls_md_get_size( mbedtls_md_info_from_type( md_alg ) ) ) );
/*
* Make the signature
*/
- if( ssl_own_key( ssl ) == NULL )
+ if( mbedtls_ssl_own_key( ssl ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "got no private key" ) );
- return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no private key" ) );
+ return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
*(p++) = ssl->handshake->sig_alg;
- *(p++) = ssl_sig_from_pk( ssl_own_key( ssl ) );
+ *(p++) = mbedtls_ssl_sig_from_pk( mbedtls_ssl_own_key( ssl ) );
n += 2;
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
- if( ( ret = pk_sign( ssl_own_key( ssl ), md_alg, hash, hashlen,
+ if( ( ret = mbedtls_pk_sign( mbedtls_ssl_own_key( ssl ), md_alg, hash, hashlen,
p + 2 , &signature_len,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "pk_sign", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_sign", ret );
return( ret );
}
@@ -3127,66 +3127,66 @@
*(p++) = (unsigned char)( signature_len );
n += 2;
- SSL_DEBUG_BUF( 3, "my signature", p, signature_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "my signature", p, signature_len );
p += signature_len;
n += signature_len;
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||
- POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
ssl->out_msglen = 4 + n;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_SERVER_KEY_EXCHANGE;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE;
ssl->state++;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write server key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server key exchange" ) );
return( 0 );
}
-static int ssl_write_server_hello_done( ssl_context *ssl )
+static int ssl_write_server_hello_done( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> write server hello done" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server hello done" ) );
ssl->out_msglen = 4;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_SERVER_HELLO_DONE;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_HELLO_DONE;
ssl->state++;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_send_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_send_flight_completed( ssl );
#endif
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write server hello done" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello done" ) );
return( 0 );
}
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
-static int ssl_parse_client_dh_public( ssl_context *ssl, unsigned char **p,
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+static int ssl_parse_client_dh_public( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t n;
/*
@@ -3194,8 +3194,8 @@
*/
if( *p + 2 > end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
n = ( (*p)[0] << 8 ) | (*p)[1];
@@ -3203,69 +3203,69 @@
if( *p + n > end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- if( ( ret = dhm_read_public( &ssl->handshake->dhm_ctx, *p, n ) ) != 0 )
+ if( ( ret = mbedtls_dhm_read_public( &ssl->handshake->dhm_ctx, *p, n ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_read_public", ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_read_public", ret );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
*p += n;
- SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
return( ret );
}
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
-static int ssl_parse_encrypted_pms( ssl_context *ssl,
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+static int ssl_parse_encrypted_pms( mbedtls_ssl_context *ssl,
const unsigned char *p,
const unsigned char *end,
size_t pms_offset )
{
int ret;
- size_t len = pk_get_len( ssl_own_key( ssl ) );
+ size_t len = mbedtls_pk_get_len( mbedtls_ssl_own_key( ssl ) );
unsigned char *pms = ssl->handshake->premaster + pms_offset;
unsigned char ver[2];
unsigned char fake_pms[48], peer_pms[48];
unsigned char mask;
size_t i;
- if( ! pk_can_do( ssl_own_key( ssl ), POLARSSL_PK_RSA ) )
+ if( ! mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_RSA ) )
{
- SSL_DEBUG_MSG( 1, ( "got no RSA private key" ) );
- return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no RSA private key" ) );
+ return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/*
* Decrypt the premaster using own private RSA key
*/
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver != SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( *p++ != ( ( len >> 8 ) & 0xFF ) ||
*p++ != ( ( len ) & 0xFF ) )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
}
#endif
if( p + len != end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- ssl_write_version( ssl->handshake->max_major_ver,
+ mbedtls_ssl_write_version( ssl->handshake->max_major_ver,
ssl->handshake->max_minor_ver,
ssl->transport, ver );
/*
@@ -3279,7 +3279,7 @@
if( ret != 0 )
return( ret );
- ret = pk_decrypt( ssl_own_key( ssl ), p, len,
+ ret = mbedtls_pk_decrypt( mbedtls_ssl_own_key( ssl ), p, len,
peer_pms, &ssl->handshake->pmslen,
sizeof( peer_pms ),
ssl->f_rng, ssl->p_rng );
@@ -3288,16 +3288,16 @@
ret |= peer_pms[0] - ver[0];
ret |= peer_pms[1] - ver[1];
-#if defined(POLARSSL_SSL_DEBUG_ALL)
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
if( ret != 0 )
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
#endif
if( sizeof( ssl->handshake->premaster ) < pms_offset ||
sizeof( ssl->handshake->premaster ) - pms_offset < 48 )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->handshake->pmslen = 48;
@@ -3307,11 +3307,11 @@
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
-static int ssl_parse_client_psk_identity( ssl_context *ssl, unsigned char **p,
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+static int ssl_parse_client_psk_identity( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = 0;
@@ -3321,8 +3321,8 @@
( ssl->psk == NULL || ssl->psk_identity == NULL ||
ssl->psk_identity_len == 0 || ssl->psk_len == 0 ) )
{
- SSL_DEBUG_MSG( 1, ( "got no pre-shared key" ) );
- return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no pre-shared key" ) );
+ return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/*
@@ -3330,8 +3330,8 @@
*/
if( *p + 2 > end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
n = ( (*p)[0] << 8 ) | (*p)[1];
@@ -3339,320 +3339,320 @@
if( n < 1 || n > 65535 || *p + n > end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ssl->f_psk != NULL )
{
if( ssl->f_psk( ssl->p_psk, ssl, *p, n ) != 0 )
- ret = POLARSSL_ERR_SSL_UNKNOWN_IDENTITY;
+ ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
else
{
/* Identity is not a big secret since clients send it in the clear,
* but treat it carefully anyway, just in case */
if( n != ssl->psk_identity_len ||
- safer_memcmp( ssl->psk_identity, *p, n ) != 0 )
+ mbedtls_ssl_safer_memcmp( ssl->psk_identity, *p, n ) != 0 )
{
- ret = POLARSSL_ERR_SSL_UNKNOWN_IDENTITY;
+ ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
}
- if( ret == POLARSSL_ERR_SSL_UNKNOWN_IDENTITY )
+ if( ret == MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY )
{
- SSL_DEBUG_BUF( 3, "Unknown PSK identity", *p, n );
- if( ( ret = ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY ) ) != 0 )
+ MBEDTLS_SSL_DEBUG_BUF( 3, "Unknown PSK identity", *p, n );
+ if( ( ret = mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY ) ) != 0 )
{
return( ret );
}
- return( POLARSSL_ERR_SSL_UNKNOWN_IDENTITY );
+ return( MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY );
}
*p += n;
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-static int ssl_parse_client_key_exchange( ssl_context *ssl )
+static int ssl_parse_client_key_exchange( mbedtls_ssl_context *ssl )
{
int ret;
- const ssl_ciphersuite_t *ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
unsigned char *p, *end;
ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse client key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client key exchange" ) );
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- p = ssl->in_msg + ssl_hs_hdr_len( ssl );
+ p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
end = ssl->in_msg + ssl->in_hslen;
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- if( ssl->in_msg[0] != SSL_HS_CLIENT_KEY_EXCHANGE )
+ if( ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA )
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA )
{
if( ( ret = ssl_parse_client_dh_public( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
return( ret );
}
if( p != end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- ssl->handshake->pmslen = POLARSSL_PREMASTER_SIZE;
+ ssl->handshake->pmslen = MBEDTLS_PREMASTER_SIZE;
- if( ( ret = dhm_calc_secret( &ssl->handshake->dhm_ctx,
+ if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
ssl->handshake->premaster,
&ssl->handshake->pmslen,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_calc_secret", ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
}
- SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
- defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
+ defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
- if( ( ret = ecdh_read_public( &ssl->handshake->ecdh_ctx,
+ if( ( ret = mbedtls_ecdh_read_public( &ssl->handshake->ecdh_ctx,
p, end - p) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_read_public", ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_read_public", ret );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
- SSL_DEBUG_ECP( 3, "ECDH: Qp ", &ssl->handshake->ecdh_ctx.Qp );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Qp ", &ssl->handshake->ecdh_ctx.Qp );
- if( ( ret = ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
+ if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
&ssl->handshake->pmslen,
ssl->handshake->premaster,
- POLARSSL_MPI_MAX_SIZE,
+ MBEDTLS_MPI_MAX_SIZE,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_calc_secret", ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
}
- SSL_DEBUG_MPI( 3, "ECDH: z ", &ssl->handshake->ecdh_ctx.z );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "ECDH: z ", &ssl->handshake->ecdh_ctx.z );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
- POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
+ MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( p != end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- if( ( ret = ssl_psk_derive_premaster( ssl,
+ if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_psk_derive_premaster", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( ( ret = ssl_parse_encrypted_pms( ssl, p, end, 2 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_encrypted_pms" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_encrypted_pms" ), ret );
return( ret );
}
- if( ( ret = ssl_psk_derive_premaster( ssl,
+ if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_psk_derive_premaster", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( ( ret = ssl_parse_client_dh_public( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
return( ret );
}
if( p != end )
{
- SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
- if( ( ret = ssl_psk_derive_premaster( ssl,
+ if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_psk_derive_premaster", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
- if( ( ret = ecdh_read_public( &ssl->handshake->ecdh_ctx,
+ if( ( ret = mbedtls_ecdh_read_public( &ssl->handshake->ecdh_ctx,
p, end - p ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_read_public", ret );
- return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_read_public", ret );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
- SSL_DEBUG_ECP( 3, "ECDH: Qp ", &ssl->handshake->ecdh_ctx.Qp );
+ MBEDTLS_SSL_DEBUG_ECP( 3, "ECDH: Qp ", &ssl->handshake->ecdh_ctx.Qp );
- if( ( ret = ssl_psk_derive_premaster( ssl,
+ if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_psk_derive_premaster", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA )
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
if( ( ret = ssl_parse_encrypted_pms( ssl, p, end, 0 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, ( "ssl_parse_parse_encrypted_pms_secret" ), ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_parse_encrypted_pms_secret" ), ret );
return( ret );
}
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- if( ( ret = ssl_derive_keys( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_derive_keys", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
ssl->state++;
- SSL_DEBUG_MSG( 2, ( "<= parse client key exchange" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client key exchange" ) );
return( 0 );
}
-#if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
-static int ssl_parse_certificate_verify( ssl_context *ssl )
+#if !defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+static int ssl_parse_certificate_verify( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else
-static int ssl_parse_certificate_verify( ssl_context *ssl )
+static int ssl_parse_certificate_verify( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, sig_len;
unsigned char hash[48];
unsigned char *hash_start = hash;
size_t hashlen;
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- pk_type_t pk_alg;
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ mbedtls_pk_type_t pk_alg;
#endif
- md_type_t md_alg;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ mbedtls_md_type_t md_alg;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ssl->session_negotiate->peer_cert == NULL )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
@@ -3660,22 +3660,22 @@
/* Needs to be done before read_record() to exclude current message */
ssl->handshake->calc_verify( ssl, hash );
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
ssl->state++;
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE ||
- ssl->in_msg[0] != SSL_HS_CERTIFICATE_VERIFY )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE ||
+ ssl->in_msg[0] != MBEDTLS_SSL_HS_CERTIFICATE_VERIFY )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
- i = ssl_hs_hdr_len( ssl );
+ i = mbedtls_ssl_hs_hdr_len( ssl );
/*
* struct {
@@ -3683,32 +3683,32 @@
* opaque signature<0..2^16-1>;
* } DigitallySigned;
*/
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( ssl->minor_ver != SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
{
- md_alg = POLARSSL_MD_NONE;
+ md_alg = MBEDTLS_MD_NONE;
hashlen = 36;
/* For ECDSA, use SHA-1, not MD-5 + SHA-1 */
- if( pk_can_do( &ssl->session_negotiate->peer_cert->pk,
- POLARSSL_PK_ECDSA ) )
+ if( mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk,
+ MBEDTLS_PK_ECDSA ) )
{
hash_start += 16;
hashlen -= 16;
- md_alg = POLARSSL_MD_SHA1;
+ md_alg = MBEDTLS_MD_SHA1;
}
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 ||
- POLARSSL_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 ||
+ MBEDTLS_SSL_PROTO_TLS1_1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
if( i + 2 > ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
/*
@@ -3716,12 +3716,12 @@
*/
if( ssl->in_msg[i] != ssl->handshake->verify_sig_alg )
{
- SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
" for verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
- md_alg = ssl_md_alg_from_hash( ssl->handshake->verify_sig_alg );
+ md_alg = mbedtls_ssl_md_alg_from_hash( ssl->handshake->verify_sig_alg );
/* Info from md_alg will be used instead */
hashlen = 0;
@@ -3731,36 +3731,36 @@
/*
* Signature
*/
- if( ( pk_alg = ssl_pk_alg_from_sig( ssl->in_msg[i] ) )
- == POLARSSL_PK_NONE )
+ if( ( pk_alg = mbedtls_ssl_pk_alg_from_sig( ssl->in_msg[i] ) )
+ == MBEDTLS_PK_NONE )
{
- SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
" for verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
/*
* Check the certificate's key type matches the signature alg
*/
- if( ! pk_can_do( &ssl->session_negotiate->peer_cert->pk, pk_alg ) )
+ if( ! mbedtls_pk_can_do( &ssl->session_negotiate->peer_cert->pk, pk_alg ) )
{
- SSL_DEBUG_MSG( 1, ( "sig_alg doesn't match cert key" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "sig_alg doesn't match cert key" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
i++;
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( i + 2 > ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
sig_len = ( ssl->in_msg[i] << 8 ) | ssl->in_msg[i+1];
@@ -3768,37 +3768,37 @@
if( i + sig_len != ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
- if( ( ret = pk_verify( &ssl->session_negotiate->peer_cert->pk,
+ if( ( ret = mbedtls_pk_verify( &ssl->session_negotiate->peer_cert->pk,
md_alg, hash_start, hashlen,
ssl->in_msg + i, sig_len ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "pk_verify", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_verify", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= parse certificate verify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate verify" ) );
return( ret );
}
-#endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
- !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
+#endif /* !MBEDTLS_KEY_EXCHANGE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED &&
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static int ssl_write_new_session_ticket( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static int ssl_write_new_session_ticket( mbedtls_ssl_context *ssl )
{
int ret;
size_t tlen;
uint32_t lifetime = (uint32_t) ssl->ticket_lifetime;
- SSL_DEBUG_MSG( 2, ( "=> write new session ticket" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write new session ticket" ) );
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_NEW_SESSION_TICKET;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_NEW_SESSION_TICKET;
/*
* struct {
@@ -3818,7 +3818,7 @@
if( ( ret = ssl_write_ticket( ssl, &tlen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_ticket", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_ticket", ret );
tlen = 0;
}
@@ -3833,59 +3833,59 @@
*/
ssl->handshake->new_session_ticket = 0;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write new session ticket" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write new session ticket" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
/*
* SSL handshake -- server side -- single step
*/
-int ssl_handshake_server_step( ssl_context *ssl )
+int mbedtls_ssl_handshake_server_step( mbedtls_ssl_context *ssl )
{
int ret = 0;
- if( ssl->state == SSL_HANDSHAKE_OVER )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- SSL_DEBUG_MSG( 2, ( "server state: %d", ssl->state ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "server state: %d", ssl->state ) );
- if( ( ret = ssl_flush_output( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL &&
- ssl->handshake->retransmit_state == SSL_RETRANS_SENDING )
+ ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
return( ret );
}
#endif
switch( ssl->state )
{
- case SSL_HELLO_REQUEST:
- ssl->state = SSL_CLIENT_HELLO;
+ case MBEDTLS_SSL_HELLO_REQUEST:
+ ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
break;
/*
* <== ClientHello
*/
- case SSL_CLIENT_HELLO:
+ case MBEDTLS_SSL_CLIENT_HELLO:
ret = ssl_parse_client_hello( ssl );
break;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- case SSL_SERVER_HELLO_VERIFY_REQUEST_SENT:
- return( POLARSSL_ERR_SSL_HELLO_VERIFY_REQUIRED );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ case MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT:
+ return( MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED );
#endif
/*
@@ -3895,23 +3895,23 @@
* ( CertificateRequest )
* ServerHelloDone
*/
- case SSL_SERVER_HELLO:
+ case MBEDTLS_SSL_SERVER_HELLO:
ret = ssl_write_server_hello( ssl );
break;
- case SSL_SERVER_CERTIFICATE:
- ret = ssl_write_certificate( ssl );
+ case MBEDTLS_SSL_SERVER_CERTIFICATE:
+ ret = mbedtls_ssl_write_certificate( ssl );
break;
- case SSL_SERVER_KEY_EXCHANGE:
+ case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
ret = ssl_write_server_key_exchange( ssl );
break;
- case SSL_CERTIFICATE_REQUEST:
+ case MBEDTLS_SSL_CERTIFICATE_REQUEST:
ret = ssl_write_certificate_request( ssl );
break;
- case SSL_SERVER_HELLO_DONE:
+ case MBEDTLS_SSL_SERVER_HELLO_DONE:
ret = ssl_write_server_hello_done( ssl );
break;
@@ -3922,24 +3922,24 @@
* ChangeCipherSpec
* Finished
*/
- case SSL_CLIENT_CERTIFICATE:
- ret = ssl_parse_certificate( ssl );
+ case MBEDTLS_SSL_CLIENT_CERTIFICATE:
+ ret = mbedtls_ssl_parse_certificate( ssl );
break;
- case SSL_CLIENT_KEY_EXCHANGE:
+ case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
ret = ssl_parse_client_key_exchange( ssl );
break;
- case SSL_CERTIFICATE_VERIFY:
+ case MBEDTLS_SSL_CERTIFICATE_VERIFY:
ret = ssl_parse_certificate_verify( ssl );
break;
- case SSL_CLIENT_CHANGE_CIPHER_SPEC:
- ret = ssl_parse_change_cipher_spec( ssl );
+ case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
+ ret = mbedtls_ssl_parse_change_cipher_spec( ssl );
break;
- case SSL_CLIENT_FINISHED:
- ret = ssl_parse_finished( ssl );
+ case MBEDTLS_SSL_CLIENT_FINISHED:
+ ret = mbedtls_ssl_parse_finished( ssl );
break;
/*
@@ -3947,33 +3947,33 @@
* ChangeCipherSpec
* Finished
*/
- case SSL_SERVER_CHANGE_CIPHER_SPEC:
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+ case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->handshake->new_session_ticket != 0 )
ret = ssl_write_new_session_ticket( ssl );
else
#endif
- ret = ssl_write_change_cipher_spec( ssl );
+ ret = mbedtls_ssl_write_change_cipher_spec( ssl );
break;
- case SSL_SERVER_FINISHED:
- ret = ssl_write_finished( ssl );
+ case MBEDTLS_SSL_SERVER_FINISHED:
+ ret = mbedtls_ssl_write_finished( ssl );
break;
- case SSL_FLUSH_BUFFERS:
- SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
- ssl->state = SSL_HANDSHAKE_WRAPUP;
+ case MBEDTLS_SSL_FLUSH_BUFFERS:
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
+ ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
break;
- case SSL_HANDSHAKE_WRAPUP:
- ssl_handshake_wrapup( ssl );
+ case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
+ mbedtls_ssl_handshake_wrapup( ssl );
break;
default:
- SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ret );
}
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_SRV_C */
diff --git a/library/ssl_tls.c b/library/ssl_tls.c
index db11a80..8cce276 100644
--- a/library/ssl_tls.c
+++ b/library/ssl_tls.c
@@ -28,30 +28,30 @@
* http://www.ietf.org/rfc/rfc4346.txt
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SSL_TLS_C)
+#if defined(MBEDTLS_SSL_TLS_C)
#include "mbedtls/debug.h"
#include "mbedtls/ssl.h"
#include <string.h>
-#if defined(POLARSSL_X509_CRT_PARSE_C) && \
- defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
+#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
+ defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
#include "mbedtls/oid.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_malloc malloc
-#define polarssl_free free
+#define mbedtls_malloc malloc
+#define mbedtls_free free
#endif
#if defined(_MSC_VER) && !defined strcasecmp && !defined(EFIX64) && \
@@ -60,15 +60,15 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
/* Length of the "epoch" field in the record header */
-static inline size_t ssl_ep_len( const ssl_context *ssl )
+static inline size_t ssl_ep_len( const mbedtls_ssl_context *ssl )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return( 2 );
#else
((void) ssl);
@@ -77,25 +77,25 @@
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
/*
* Start a timer.
* Passing millisecs = 0 cancels a running timer.
* The timer is already running iff time_limit != 0.
*/
-static void ssl_set_timer( ssl_context *ssl, uint32_t millisecs )
+static void ssl_set_timer( mbedtls_ssl_context *ssl, uint32_t millisecs )
{
ssl->time_limit = millisecs;
- get_timer( &ssl->time_info, 1 );
+ mbedtls_timing_get_timer( &ssl->time_info, 1 );
}
/*
* Return -1 is timer is expired, 0 if it isn't.
*/
-static int ssl_check_timer( ssl_context *ssl )
+static int ssl_check_timer( mbedtls_ssl_context *ssl )
{
if( ssl->time_limit != 0 &&
- get_timer( &ssl->time_info, 0 ) > ssl->time_limit )
+ mbedtls_timing_get_timer( &ssl->time_info, 0 ) > ssl->time_limit )
{
return( -1 );
}
@@ -107,7 +107,7 @@
* Double the retransmit timeout value, within the allowed range,
* returning -1 if the maximum value has already been reached.
*/
-static int ssl_double_retransmit_timeout( ssl_context *ssl )
+static int ssl_double_retransmit_timeout( mbedtls_ssl_context *ssl )
{
uint32_t new_timeout;
@@ -124,21 +124,21 @@
}
ssl->handshake->retransmit_timeout = new_timeout;
- SSL_DEBUG_MSG( 3, ( "update timeout value to %d millisecs",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "update timeout value to %d millisecs",
ssl->handshake->retransmit_timeout ) );
return( 0 );
}
-static void ssl_reset_retransmit_timeout( ssl_context *ssl )
+static void ssl_reset_retransmit_timeout( mbedtls_ssl_context *ssl )
{
ssl->handshake->retransmit_timeout = ssl->hs_timeout_min;
- SSL_DEBUG_MSG( 3, ( "update timeout value to %d millisecs",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "update timeout value to %d millisecs",
ssl->handshake->retransmit_timeout ) );
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
/*
* Convert max_fragment_length codes to length.
* RFC 6066 says:
@@ -147,89 +147,89 @@
* } MaxFragmentLength;
* and we add 0 -> extension unused
*/
-static unsigned int mfl_code_to_length[SSL_MAX_FRAG_LEN_INVALID] =
+static unsigned int mfl_code_to_length[MBEDTLS_SSL_MAX_FRAG_LEN_INVALID] =
{
- SSL_MAX_CONTENT_LEN, /* SSL_MAX_FRAG_LEN_NONE */
- 512, /* SSL_MAX_FRAG_LEN_512 */
- 1024, /* SSL_MAX_FRAG_LEN_1024 */
- 2048, /* SSL_MAX_FRAG_LEN_2048 */
- 4096, /* SSL_MAX_FRAG_LEN_4096 */
+ MBEDTLS_SSL_MAX_CONTENT_LEN, /* MBEDTLS_SSL_MAX_FRAG_LEN_NONE */
+ 512, /* MBEDTLS_SSL_MAX_FRAG_LEN_512 */
+ 1024, /* MBEDTLS_SSL_MAX_FRAG_LEN_1024 */
+ 2048, /* MBEDTLS_SSL_MAX_FRAG_LEN_2048 */
+ 4096, /* MBEDTLS_SSL_MAX_FRAG_LEN_4096 */
};
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-static int ssl_session_copy( ssl_session *dst, const ssl_session *src )
+static int ssl_session_copy( mbedtls_ssl_session *dst, const mbedtls_ssl_session *src )
{
- ssl_session_free( dst );
- memcpy( dst, src, sizeof( ssl_session ) );
+ mbedtls_ssl_session_free( dst );
+ memcpy( dst, src, sizeof( mbedtls_ssl_session ) );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( src->peer_cert != NULL )
{
int ret;
- dst->peer_cert = polarssl_malloc( sizeof(x509_crt) );
+ dst->peer_cert = mbedtls_malloc( sizeof(mbedtls_x509_crt) );
if( dst->peer_cert == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
- x509_crt_init( dst->peer_cert );
+ mbedtls_x509_crt_init( dst->peer_cert );
- if( ( ret = x509_crt_parse_der( dst->peer_cert, src->peer_cert->raw.p,
+ if( ( ret = mbedtls_x509_crt_parse_der( dst->peer_cert, src->peer_cert->raw.p,
src->peer_cert->raw.len ) ) != 0 )
{
- polarssl_free( dst->peer_cert );
+ mbedtls_free( dst->peer_cert );
dst->peer_cert = NULL;
return( ret );
}
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( src->ticket != NULL )
{
- dst->ticket = polarssl_malloc( src->ticket_len );
+ dst->ticket = mbedtls_malloc( src->ticket_len );
if( dst->ticket == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
memcpy( dst->ticket, src->ticket, src->ticket_len );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
return( 0 );
}
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
-int (*ssl_hw_record_init)( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+int (*mbedtls_ssl_hw_record_init)( mbedtls_ssl_context *ssl,
const unsigned char *key_enc, const unsigned char *key_dec,
size_t keylen,
const unsigned char *iv_enc, const unsigned char *iv_dec,
size_t ivlen,
const unsigned char *mac_enc, const unsigned char *mac_dec,
size_t maclen ) = NULL;
-int (*ssl_hw_record_activate)( ssl_context *ssl, int direction) = NULL;
-int (*ssl_hw_record_reset)( ssl_context *ssl ) = NULL;
-int (*ssl_hw_record_write)( ssl_context *ssl ) = NULL;
-int (*ssl_hw_record_read)( ssl_context *ssl ) = NULL;
-int (*ssl_hw_record_finish)( ssl_context *ssl ) = NULL;
-#endif /* POLARSSL_SSL_HW_RECORD_ACCEL */
+int (*mbedtls_ssl_hw_record_activate)( mbedtls_ssl_context *ssl, int direction) = NULL;
+int (*mbedtls_ssl_hw_record_reset)( mbedtls_ssl_context *ssl ) = NULL;
+int (*mbedtls_ssl_hw_record_write)( mbedtls_ssl_context *ssl ) = NULL;
+int (*mbedtls_ssl_hw_record_read)( mbedtls_ssl_context *ssl ) = NULL;
+int (*mbedtls_ssl_hw_record_finish)( mbedtls_ssl_context *ssl ) = NULL;
+#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
/*
* Key material generation
*/
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
static int ssl3_prf( const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
unsigned char *dstbuf, size_t dlen )
{
size_t i;
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
unsigned char padding[16];
unsigned char sha1sum[20];
((void)label);
- md5_init( &md5 );
- sha1_init( &sha1 );
+ mbedtls_md5_init( &mbedtls_md5 );
+ mbedtls_sha1_init( &mbedtls_sha1 );
/*
* SSLv3:
@@ -243,29 +243,29 @@
{
memset( padding, (unsigned char) ('A' + i), 1 + i );
- sha1_starts( &sha1 );
- sha1_update( &sha1, padding, 1 + i );
- sha1_update( &sha1, secret, slen );
- sha1_update( &sha1, random, rlen );
- sha1_finish( &sha1, sha1sum );
+ mbedtls_sha1_starts( &mbedtls_sha1 );
+ mbedtls_sha1_update( &mbedtls_sha1, padding, 1 + i );
+ mbedtls_sha1_update( &mbedtls_sha1, secret, slen );
+ mbedtls_sha1_update( &mbedtls_sha1, random, rlen );
+ mbedtls_sha1_finish( &mbedtls_sha1, sha1sum );
- md5_starts( &md5 );
- md5_update( &md5, secret, slen );
- md5_update( &md5, sha1sum, 20 );
- md5_finish( &md5, dstbuf + i * 16 );
+ mbedtls_md5_starts( &mbedtls_md5 );
+ mbedtls_md5_update( &mbedtls_md5, secret, slen );
+ mbedtls_md5_update( &mbedtls_md5, sha1sum, 20 );
+ mbedtls_md5_finish( &mbedtls_md5, dstbuf + i * 16 );
}
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
- polarssl_zeroize( padding, sizeof( padding ) );
- polarssl_zeroize( sha1sum, sizeof( sha1sum ) );
+ mbedtls_zeroize( padding, sizeof( padding ) );
+ mbedtls_zeroize( sha1sum, sizeof( sha1sum ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1)
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
static int tls1_prf( const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
@@ -276,14 +276,14 @@
const unsigned char *S1, *S2;
unsigned char tmp[128];
unsigned char h_i[20];
- const md_info_t *md_info;
- md_context_t md_ctx;
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
int ret;
- md_init( &md_ctx );
+ mbedtls_md_init( &md_ctx );
if( sizeof( tmp ) < 20 + strlen( label ) + rlen )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
hs = ( slen + 1 ) / 2;
S1 = secret;
@@ -297,25 +297,25 @@
/*
* First compute P_md5(secret,label+random)[0..dlen]
*/
- if( ( md_info = md_info_from_type( POLARSSL_MD_MD5 ) ) == NULL )
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_MD5 ) ) == NULL )
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
- if( ( ret = md_setup( &md_ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
return( ret );
- md_hmac_starts( &md_ctx, S1, hs );
- md_hmac_update( &md_ctx, tmp + 20, nb );
- md_hmac_finish( &md_ctx, 4 + tmp );
+ mbedtls_md_hmac_starts( &md_ctx, S1, hs );
+ mbedtls_md_hmac_update( &md_ctx, tmp + 20, nb );
+ mbedtls_md_hmac_finish( &md_ctx, 4 + tmp );
for( i = 0; i < dlen; i += 16 )
{
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, 4 + tmp, 16 + nb );
- md_hmac_finish( &md_ctx, h_i );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, 4 + tmp, 16 + nb );
+ mbedtls_md_hmac_finish( &md_ctx, h_i );
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, 4 + tmp, 16 );
- md_hmac_finish( &md_ctx, 4 + tmp );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, 4 + tmp, 16 );
+ mbedtls_md_hmac_finish( &md_ctx, 4 + tmp );
k = ( i + 16 > dlen ) ? dlen % 16 : 16;
@@ -323,30 +323,30 @@
dstbuf[i + j] = h_i[j];
}
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
/*
* XOR out with P_sha1(secret,label+random)[0..dlen]
*/
- if( ( md_info = md_info_from_type( POLARSSL_MD_SHA1 ) ) == NULL )
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
- if( ( ret = md_setup( &md_ctx, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
return( ret );
- md_hmac_starts( &md_ctx, S2, hs );
- md_hmac_update( &md_ctx, tmp + 20, nb );
- md_hmac_finish( &md_ctx, tmp );
+ mbedtls_md_hmac_starts( &md_ctx, S2, hs );
+ mbedtls_md_hmac_update( &md_ctx, tmp + 20, nb );
+ mbedtls_md_hmac_finish( &md_ctx, tmp );
for( i = 0; i < dlen; i += 20 )
{
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, tmp, 20 + nb );
- md_hmac_finish( &md_ctx, h_i );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, tmp, 20 + nb );
+ mbedtls_md_hmac_finish( &md_ctx, h_i );
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, tmp, 20 );
- md_hmac_finish( &md_ctx, tmp );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, tmp, 20 );
+ mbedtls_md_hmac_finish( &md_ctx, tmp );
k = ( i + 20 > dlen ) ? dlen % 20 : 20;
@@ -354,17 +354,17 @@
dstbuf[i + j] = (unsigned char)( dstbuf[i + j] ^ h_i[j] );
}
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
- polarssl_zeroize( tmp, sizeof( tmp ) );
- polarssl_zeroize( h_i, sizeof( h_i ) );
+ mbedtls_zeroize( tmp, sizeof( tmp ) );
+ mbedtls_zeroize( h_i, sizeof( h_i ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_PROTO_TLS1) || POLARSSL_SSL_PROTO_TLS1_1 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1) || MBEDTLS_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-static int tls_prf_generic( md_type_t md_type,
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+static int tls_prf_generic( mbedtls_md_type_t md_type,
const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
@@ -373,20 +373,20 @@
size_t nb;
size_t i, j, k, md_len;
unsigned char tmp[128];
- unsigned char h_i[POLARSSL_MD_MAX_SIZE];
- const md_info_t *md_info;
- md_context_t md_ctx;
+ unsigned char h_i[MBEDTLS_MD_MAX_SIZE];
+ const mbedtls_md_info_t *md_info;
+ mbedtls_md_context_t md_ctx;
int ret;
- md_init( &md_ctx );
+ mbedtls_md_init( &md_ctx );
- if( ( md_info = md_info_from_type( md_type ) ) == NULL )
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ if( ( md_info = mbedtls_md_info_from_type( md_type ) ) == NULL )
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
- md_len = md_get_size( md_info );
+ md_len = mbedtls_md_get_size( md_info );
if( sizeof( tmp ) < md_len + strlen( label ) + rlen )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
nb = strlen( label );
memcpy( tmp + md_len, label, nb );
@@ -396,22 +396,22 @@
/*
* Compute P_<hash>(secret, label + random)[0..dlen]
*/
- if ( ( ret = md_setup( &md_ctx, md_info, 1 ) ) != 0 )
+ if ( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 )
return( ret );
- md_hmac_starts( &md_ctx, secret, slen );
- md_hmac_update( &md_ctx, tmp + md_len, nb );
- md_hmac_finish( &md_ctx, tmp );
+ mbedtls_md_hmac_starts( &md_ctx, secret, slen );
+ mbedtls_md_hmac_update( &md_ctx, tmp + md_len, nb );
+ mbedtls_md_hmac_finish( &md_ctx, tmp );
for( i = 0; i < dlen; i += md_len )
{
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, tmp, md_len + nb );
- md_hmac_finish( &md_ctx, h_i );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, tmp, md_len + nb );
+ mbedtls_md_hmac_finish( &md_ctx, h_i );
- md_hmac_reset ( &md_ctx );
- md_hmac_update( &md_ctx, tmp, md_len );
- md_hmac_finish( &md_ctx, tmp );
+ mbedtls_md_hmac_reset ( &md_ctx );
+ mbedtls_md_hmac_update( &md_ctx, tmp, md_len );
+ mbedtls_md_hmac_finish( &md_ctx, tmp );
k = ( i + md_len > dlen ) ? dlen % md_len : md_len;
@@ -419,69 +419,69 @@
dstbuf[i + j] = h_i[j];
}
- md_free( &md_ctx );
+ mbedtls_md_free( &md_ctx );
- polarssl_zeroize( tmp, sizeof( tmp ) );
- polarssl_zeroize( h_i, sizeof( h_i ) );
+ mbedtls_zeroize( tmp, sizeof( tmp ) );
+ mbedtls_zeroize( h_i, sizeof( h_i ) );
return( 0 );
}
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SHA256_C)
static int tls_prf_sha256( const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
unsigned char *dstbuf, size_t dlen )
{
- return( tls_prf_generic( POLARSSL_MD_SHA256, secret, slen,
+ return( tls_prf_generic( MBEDTLS_MD_SHA256, secret, slen,
label, random, rlen, dstbuf, dlen ) );
}
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
static int tls_prf_sha384( const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
unsigned char *dstbuf, size_t dlen )
{
- return( tls_prf_generic( POLARSSL_MD_SHA384, secret, slen,
+ return( tls_prf_generic( MBEDTLS_MD_SHA384, secret, slen,
label, random, rlen, dstbuf, dlen ) );
}
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-static void ssl_update_checksum_start( ssl_context *, const unsigned char *, size_t );
+static void ssl_update_checksum_start( mbedtls_ssl_context *, const unsigned char *, size_t );
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
-static void ssl_update_checksum_md5sha1( ssl_context *, const unsigned char *, size_t );
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+static void ssl_update_checksum_md5sha1( mbedtls_ssl_context *, const unsigned char *, size_t );
#endif
-#if defined(POLARSSL_SSL_PROTO_SSL3)
-static void ssl_calc_verify_ssl( ssl_context *, unsigned char * );
-static void ssl_calc_finished_ssl( ssl_context *, unsigned char *, int );
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+static void ssl_calc_verify_ssl( mbedtls_ssl_context *, unsigned char * );
+static void ssl_calc_finished_ssl( mbedtls_ssl_context *, unsigned char *, int );
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1)
-static void ssl_calc_verify_tls( ssl_context *, unsigned char * );
-static void ssl_calc_finished_tls( ssl_context *, unsigned char *, int );
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
+static void ssl_calc_verify_tls( mbedtls_ssl_context *, unsigned char * );
+static void ssl_calc_finished_tls( mbedtls_ssl_context *, unsigned char *, int );
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
-static void ssl_update_checksum_sha256( ssl_context *, const unsigned char *, size_t );
-static void ssl_calc_verify_tls_sha256( ssl_context *,unsigned char * );
-static void ssl_calc_finished_tls_sha256( ssl_context *,unsigned char *, int );
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+static void ssl_update_checksum_sha256( mbedtls_ssl_context *, const unsigned char *, size_t );
+static void ssl_calc_verify_tls_sha256( mbedtls_ssl_context *,unsigned char * );
+static void ssl_calc_finished_tls_sha256( mbedtls_ssl_context *,unsigned char *, int );
#endif
-#if defined(POLARSSL_SHA512_C)
-static void ssl_update_checksum_sha384( ssl_context *, const unsigned char *, size_t );
-static void ssl_calc_verify_tls_sha384( ssl_context *, unsigned char * );
-static void ssl_calc_finished_tls_sha384( ssl_context *, unsigned char *, int );
+#if defined(MBEDTLS_SHA512_C)
+static void ssl_update_checksum_sha384( mbedtls_ssl_context *, const unsigned char *, size_t );
+static void ssl_calc_verify_tls_sha384( mbedtls_ssl_context *, unsigned char * );
+static void ssl_calc_finished_tls_sha384( mbedtls_ssl_context *, unsigned char *, int );
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-int ssl_derive_keys( ssl_context *ssl )
+int mbedtls_ssl_derive_keys( mbedtls_ssl_context *ssl )
{
int ret = 0;
unsigned char tmp[64];
@@ -491,36 +491,36 @@
unsigned char *mac_enc;
unsigned char *mac_dec;
size_t iv_copy_len;
- const cipher_info_t *cipher_info;
- const md_info_t *md_info;
+ const mbedtls_cipher_info_t *cipher_info;
+ const mbedtls_md_info_t *md_info;
- ssl_session *session = ssl->session_negotiate;
- ssl_transform *transform = ssl->transform_negotiate;
- ssl_handshake_params *handshake = ssl->handshake;
+ mbedtls_ssl_session *session = ssl->session_negotiate;
+ mbedtls_ssl_transform *transform = ssl->transform_negotiate;
+ mbedtls_ssl_handshake_params *handshake = ssl->handshake;
- SSL_DEBUG_MSG( 2, ( "=> derive keys" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> derive keys" ) );
- cipher_info = cipher_info_from_type( transform->ciphersuite_info->cipher );
+ cipher_info = mbedtls_cipher_info_from_type( transform->ciphersuite_info->cipher );
if( cipher_info == NULL )
{
- SSL_DEBUG_MSG( 1, ( "cipher info for %d not found",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "cipher info for %d not found",
transform->ciphersuite_info->cipher ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
- md_info = md_info_from_type( transform->ciphersuite_info->mac );
+ md_info = mbedtls_md_info_from_type( transform->ciphersuite_info->mac );
if( md_info == NULL )
{
- SSL_DEBUG_MSG( 1, ( "md info for %d not found",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "mbedtls_md info for %d not found",
transform->ciphersuite_info->mac ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/*
* Set appropriate PRF function and other SSL / TLS / TLS1.2 functions
*/
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
handshake->tls_prf = ssl3_prf;
handshake->calc_verify = ssl_calc_verify_ssl;
@@ -528,8 +528,8 @@
}
else
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( ssl->minor_ver < SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
{
handshake->tls_prf = tls1_prf;
handshake->calc_verify = ssl_calc_verify_tls;
@@ -537,10 +537,10 @@
}
else
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA512_C)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 &&
- transform->ciphersuite_info->mac == POLARSSL_MD_SHA384 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA512_C)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 &&
+ transform->ciphersuite_info->mac == MBEDTLS_MD_SHA384 )
{
handshake->tls_prf = tls_prf_sha384;
handshake->calc_verify = ssl_calc_verify_tls_sha384;
@@ -548,8 +548,8 @@
}
else
#endif
-#if defined(POLARSSL_SHA256_C)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SHA256_C)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
handshake->tls_prf = tls_prf_sha256;
handshake->calc_verify = ssl_calc_verify_tls_sha256;
@@ -557,10 +557,10 @@
}
else
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/*
@@ -575,25 +575,25 @@
*/
if( handshake->resume == 0 )
{
- SSL_DEBUG_BUF( 3, "premaster secret", handshake->premaster,
+ MBEDTLS_SSL_DEBUG_BUF( 3, "premaster secret", handshake->premaster,
handshake->pmslen );
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
- if( ssl->handshake->extended_ms == SSL_EXTENDED_MS_ENABLED )
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+ if( ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_ENABLED )
{
unsigned char session_hash[48];
size_t hash_len;
- SSL_DEBUG_MSG( 3, ( "using extended master secret" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "using extended master secret" ) );
ssl->handshake->calc_verify( ssl, session_hash );
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
if( ssl->transform_negotiate->ciphersuite_info->mac ==
- POLARSSL_MD_SHA384 )
+ MBEDTLS_MD_SHA384 )
{
hash_len = 48;
}
@@ -602,10 +602,10 @@
hash_len = 32;
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
hash_len = 36;
- SSL_DEBUG_BUF( 3, "session hash", session_hash, hash_len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "session hash", session_hash, hash_len );
ret = handshake->tls_prf( handshake->premaster, handshake->pmslen,
"extended master secret",
@@ -613,7 +613,7 @@
session->master, 48 );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "prf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
@@ -626,14 +626,14 @@
session->master, 48 );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "prf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
- polarssl_zeroize( handshake->premaster, sizeof(handshake->premaster) );
+ mbedtls_zeroize( handshake->premaster, sizeof(handshake->premaster) );
}
else
- SSL_DEBUG_MSG( 3, ( "no premaster (session resumed)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "no premaster (session resumed)" ) );
/*
* Swap the client and server random values.
@@ -641,7 +641,7 @@
memcpy( tmp, handshake->randbytes, 64 );
memcpy( handshake->randbytes, tmp + 32, 32 );
memcpy( handshake->randbytes + 32, tmp, 32 );
- polarssl_zeroize( tmp, sizeof( tmp ) );
+ mbedtls_zeroize( tmp, sizeof( tmp ) );
/*
* SSLv3:
@@ -659,17 +659,17 @@
handshake->randbytes, 64, keyblk, 256 );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "prf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "prf", ret );
return( ret );
}
- SSL_DEBUG_MSG( 3, ( "ciphersuite = %s",
- ssl_get_ciphersuite_name( session->ciphersuite ) ) );
- SSL_DEBUG_BUF( 3, "master secret", session->master, 48 );
- SSL_DEBUG_BUF( 4, "random bytes", handshake->randbytes, 64 );
- SSL_DEBUG_BUF( 4, "key block", keyblk, 256 );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite = %s",
+ mbedtls_ssl_get_ciphersuite_name( session->ciphersuite ) ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "master secret", session->master, 48 );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "random bytes", handshake->randbytes, 64 );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "key block", keyblk, 256 );
- polarssl_zeroize( handshake->randbytes, sizeof( handshake->randbytes ) );
+ mbedtls_zeroize( handshake->randbytes, sizeof( handshake->randbytes ) );
/*
* Determine the appropriate key, IV and MAC length.
@@ -677,8 +677,8 @@
transform->keylen = cipher_info->key_length / 8;
- if( cipher_info->mode == POLARSSL_MODE_GCM ||
- cipher_info->mode == POLARSSL_MODE_CCM )
+ if( cipher_info->mode == MBEDTLS_MODE_GCM ||
+ cipher_info->mode == MBEDTLS_MODE_CCM )
{
transform->maclen = 0;
@@ -688,38 +688,38 @@
/* Minimum length is expicit IV + tag */
transform->minlen = transform->ivlen - transform->fixed_ivlen
+ ( transform->ciphersuite_info->flags &
- POLARSSL_CIPHERSUITE_SHORT_TAG ? 8 : 16 );
+ MBEDTLS_CIPHERSUITE_SHORT_TAG ? 8 : 16 );
}
else
{
int ret;
/* Initialize HMAC contexts */
- if( ( ret = md_setup( &transform->md_ctx_enc, md_info, 1 ) ) != 0 ||
- ( ret = md_setup( &transform->md_ctx_dec, md_info, 1 ) ) != 0 )
+ if( ( ret = mbedtls_md_setup( &transform->md_ctx_enc, md_info, 1 ) ) != 0 ||
+ ( ret = mbedtls_md_setup( &transform->md_ctx_dec, md_info, 1 ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "md_setup", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_md_setup", ret );
return( ret );
}
/* Get MAC length */
- transform->maclen = md_get_size( md_info );
+ transform->maclen = mbedtls_md_get_size( md_info );
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
/*
* If HMAC is to be truncated, we shall keep the leftmost bytes,
* (rfc 6066 page 13 or rfc 2104 section 4),
* so we only need to adjust the length here.
*/
- if( session->trunc_hmac == SSL_TRUNC_HMAC_ENABLED )
- transform->maclen = SSL_TRUNCATED_HMAC_LEN;
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+ if( session->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_ENABLED )
+ transform->maclen = MBEDTLS_SSL_TRUNCATED_HMAC_LEN;
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
/* IV length */
transform->ivlen = cipher_info->iv_size;
/* Minimum length */
- if( cipher_info->mode == POLARSSL_MODE_STREAM )
+ if( cipher_info->mode == MBEDTLS_MODE_STREAM )
transform->minlen = transform->maclen;
else
{
@@ -729,8 +729,8 @@
* otherwise: * first multiple of blocklen greater than maclen
* 2. IV except for SSL3 and TLS 1.0
*/
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- if( session->encrypt_then_mac == SSL_ETM_ENABLED )
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ if( session->encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED )
{
transform->minlen = transform->maclen
+ cipher_info->block_size;
@@ -743,36 +743,36 @@
- transform->maclen % cipher_info->block_size;
}
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 ||
- ssl->minor_ver == SSL_MINOR_VERSION_1 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_1 )
; /* No need to adjust minlen */
else
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_1) || defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver == SSL_MINOR_VERSION_2 ||
- ssl->minor_ver == SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_1) || defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_2 ||
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
transform->minlen += transform->ivlen;
}
else
#endif
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
}
- SSL_DEBUG_MSG( 3, ( "keylen: %d, minlen: %d, ivlen: %d, maclen: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "keylen: %d, minlen: %d, ivlen: %d, maclen: %d",
transform->keylen, transform->minlen, transform->ivlen,
transform->maclen ) );
/*
* Finally setup the cipher contexts, IVs and MAC secrets.
*/
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
key1 = keyblk + transform->maclen * 2;
key2 = keyblk + transform->maclen * 2 + transform->keylen;
@@ -790,9 +790,9 @@
iv_copy_len );
}
else
-#endif /* POLARSSL_SSL_CLI_C */
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER )
+#endif /* MBEDTLS_SSL_CLI_C */
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
{
key1 = keyblk + transform->maclen * 2 + transform->keylen;
key2 = keyblk + transform->maclen * 2;
@@ -810,128 +810,128 @@
iv_copy_len );
}
else
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_SRV_C */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( transform->maclen > sizeof transform->mac_enc )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( transform->mac_enc, mac_enc, transform->maclen );
memcpy( transform->mac_dec, mac_dec, transform->maclen );
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver >= SSL_MINOR_VERSION_1 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 )
{
- md_hmac_starts( &transform->md_ctx_enc, mac_enc, transform->maclen );
- md_hmac_starts( &transform->md_ctx_dec, mac_dec, transform->maclen );
+ mbedtls_md_hmac_starts( &transform->md_ctx_enc, mac_enc, transform->maclen );
+ mbedtls_md_hmac_starts( &transform->md_ctx_dec, mac_dec, transform->maclen );
}
else
#endif
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_init != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_init != NULL )
{
int ret = 0;
- SSL_DEBUG_MSG( 2, ( "going for ssl_hw_record_init()" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_init()" ) );
- if( ( ret = ssl_hw_record_init( ssl, key1, key2, transform->keylen,
+ if( ( ret = mbedtls_ssl_hw_record_init( ssl, key1, key2, transform->keylen,
transform->iv_enc, transform->iv_dec,
iv_copy_len,
mac_enc, mac_dec,
transform->maclen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_init", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_init", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
-#endif /* POLARSSL_SSL_HW_RECORD_ACCEL */
+#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
- if( ( ret = cipher_init_ctx( &transform->cipher_ctx_enc,
+ if( ( ret = mbedtls_cipher_init_ctx( &transform->cipher_ctx_enc,
cipher_info ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_init_ctx", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_init_ctx", ret );
return( ret );
}
- if( ( ret = cipher_init_ctx( &transform->cipher_ctx_dec,
+ if( ( ret = mbedtls_cipher_init_ctx( &transform->cipher_ctx_dec,
cipher_info ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_init_ctx", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_init_ctx", ret );
return( ret );
}
- if( ( ret = cipher_setkey( &transform->cipher_ctx_enc, key1,
+ if( ( ret = mbedtls_cipher_setkey( &transform->cipher_ctx_enc, key1,
cipher_info->key_length,
- POLARSSL_ENCRYPT ) ) != 0 )
+ MBEDTLS_ENCRYPT ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_setkey", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setkey", ret );
return( ret );
}
- if( ( ret = cipher_setkey( &transform->cipher_ctx_dec, key2,
+ if( ( ret = mbedtls_cipher_setkey( &transform->cipher_ctx_dec, key2,
cipher_info->key_length,
- POLARSSL_DECRYPT ) ) != 0 )
+ MBEDTLS_DECRYPT ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_setkey", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_setkey", ret );
return( ret );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- if( cipher_info->mode == POLARSSL_MODE_CBC )
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( cipher_info->mode == MBEDTLS_MODE_CBC )
{
- if( ( ret = cipher_set_padding_mode( &transform->cipher_ctx_enc,
- POLARSSL_PADDING_NONE ) ) != 0 )
+ if( ( ret = mbedtls_cipher_set_padding_mode( &transform->cipher_ctx_enc,
+ MBEDTLS_PADDING_NONE ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_set_padding_mode", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_set_padding_mode", ret );
return( ret );
}
- if( ( ret = cipher_set_padding_mode( &transform->cipher_ctx_dec,
- POLARSSL_PADDING_NONE ) ) != 0 )
+ if( ( ret = mbedtls_cipher_set_padding_mode( &transform->cipher_ctx_dec,
+ MBEDTLS_PADDING_NONE ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_set_padding_mode", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_set_padding_mode", ret );
return( ret );
}
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
- polarssl_zeroize( keyblk, sizeof( keyblk ) );
+ mbedtls_zeroize( keyblk, sizeof( keyblk ) );
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
// Initialize compression
//
- if( session->compression == SSL_COMPRESS_DEFLATE )
+ if( session->compression == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
if( ssl->compress_buf == NULL )
{
- SSL_DEBUG_MSG( 3, ( "Allocating compression buffer" ) );
- ssl->compress_buf = polarssl_malloc( SSL_BUFFER_LEN );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "Allocating compression buffer" ) );
+ ssl->compress_buf = mbedtls_malloc( MBEDTLS_SSL_BUFFER_LEN );
if( ssl->compress_buf == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed",
- SSL_BUFFER_LEN ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed",
+ MBEDTLS_SSL_BUFFER_LEN ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
}
- SSL_DEBUG_MSG( 3, ( "Initializing zlib states" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "Initializing zlib states" ) );
memset( &transform->ctx_deflate, 0, sizeof( transform->ctx_deflate ) );
memset( &transform->ctx_inflate, 0, sizeof( transform->ctx_inflate ) );
@@ -940,129 +940,129 @@
Z_DEFAULT_COMPRESSION ) != Z_OK ||
inflateInit( &transform->ctx_inflate ) != Z_OK )
{
- SSL_DEBUG_MSG( 1, ( "Failed to initialize compression" ) );
- return( POLARSSL_ERR_SSL_COMPRESSION_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "Failed to initialize compression" ) );
+ return( MBEDTLS_ERR_SSL_COMPRESSION_FAILED );
}
}
-#endif /* POLARSSL_ZLIB_SUPPORT */
+#endif /* MBEDTLS_ZLIB_SUPPORT */
- SSL_DEBUG_MSG( 2, ( "<= derive keys" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= derive keys" ) );
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
-void ssl_calc_verify_ssl( ssl_context *ssl, unsigned char hash[36] )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+void ssl_calc_verify_ssl( mbedtls_ssl_context *ssl, unsigned char hash[36] )
{
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
unsigned char pad_1[48];
unsigned char pad_2[48];
- SSL_DEBUG_MSG( 2, ( "=> calc verify ssl" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify ssl" ) );
- memcpy( &md5 , &ssl->handshake->fin_md5 , sizeof(md5_context) );
- memcpy( &sha1, &ssl->handshake->fin_sha1, sizeof(sha1_context) );
+ memcpy( &mbedtls_md5 , &ssl->handshake->fin_md5 , sizeof(mbedtls_md5_context) );
+ memcpy( &mbedtls_sha1, &ssl->handshake->fin_sha1, sizeof(mbedtls_sha1_context) );
memset( pad_1, 0x36, 48 );
memset( pad_2, 0x5C, 48 );
- md5_update( &md5, ssl->session_negotiate->master, 48 );
- md5_update( &md5, pad_1, 48 );
- md5_finish( &md5, hash );
+ mbedtls_md5_update( &mbedtls_md5, ssl->session_negotiate->master, 48 );
+ mbedtls_md5_update( &mbedtls_md5, pad_1, 48 );
+ mbedtls_md5_finish( &mbedtls_md5, hash );
- md5_starts( &md5 );
- md5_update( &md5, ssl->session_negotiate->master, 48 );
- md5_update( &md5, pad_2, 48 );
- md5_update( &md5, hash, 16 );
- md5_finish( &md5, hash );
+ mbedtls_md5_starts( &mbedtls_md5 );
+ mbedtls_md5_update( &mbedtls_md5, ssl->session_negotiate->master, 48 );
+ mbedtls_md5_update( &mbedtls_md5, pad_2, 48 );
+ mbedtls_md5_update( &mbedtls_md5, hash, 16 );
+ mbedtls_md5_finish( &mbedtls_md5, hash );
- sha1_update( &sha1, ssl->session_negotiate->master, 48 );
- sha1_update( &sha1, pad_1, 40 );
- sha1_finish( &sha1, hash + 16 );
+ mbedtls_sha1_update( &mbedtls_sha1, ssl->session_negotiate->master, 48 );
+ mbedtls_sha1_update( &mbedtls_sha1, pad_1, 40 );
+ mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
- sha1_starts( &sha1 );
- sha1_update( &sha1, ssl->session_negotiate->master, 48 );
- sha1_update( &sha1, pad_2, 40 );
- sha1_update( &sha1, hash + 16, 20 );
- sha1_finish( &sha1, hash + 16 );
+ mbedtls_sha1_starts( &mbedtls_sha1 );
+ mbedtls_sha1_update( &mbedtls_sha1, ssl->session_negotiate->master, 48 );
+ mbedtls_sha1_update( &mbedtls_sha1, pad_2, 40 );
+ mbedtls_sha1_update( &mbedtls_sha1, hash + 16, 20 );
+ mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
- SSL_DEBUG_BUF( 3, "calculated verify result", hash, 36 );
- SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calculated verify result", hash, 36 );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
return;
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1)
-void ssl_calc_verify_tls( ssl_context *ssl, unsigned char hash[36] )
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
+void ssl_calc_verify_tls( mbedtls_ssl_context *ssl, unsigned char hash[36] )
{
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
- SSL_DEBUG_MSG( 2, ( "=> calc verify tls" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify tls" ) );
- memcpy( &md5 , &ssl->handshake->fin_md5 , sizeof(md5_context) );
- memcpy( &sha1, &ssl->handshake->fin_sha1, sizeof(sha1_context) );
+ memcpy( &mbedtls_md5 , &ssl->handshake->fin_md5 , sizeof(mbedtls_md5_context) );
+ memcpy( &mbedtls_sha1, &ssl->handshake->fin_sha1, sizeof(mbedtls_sha1_context) );
- md5_finish( &md5, hash );
- sha1_finish( &sha1, hash + 16 );
+ mbedtls_md5_finish( &mbedtls_md5, hash );
+ mbedtls_sha1_finish( &mbedtls_sha1, hash + 16 );
- SSL_DEBUG_BUF( 3, "calculated verify result", hash, 36 );
- SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calculated verify result", hash, 36 );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
return;
}
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
-void ssl_calc_verify_tls_sha256( ssl_context *ssl, unsigned char hash[32] )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+void ssl_calc_verify_tls_sha256( mbedtls_ssl_context *ssl, unsigned char hash[32] )
{
- sha256_context sha256;
+ mbedtls_sha256_context mbedtls_sha256;
- SSL_DEBUG_MSG( 2, ( "=> calc verify sha256" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify mbedtls_sha256" ) );
- memcpy( &sha256, &ssl->handshake->fin_sha256, sizeof(sha256_context) );
- sha256_finish( &sha256, hash );
+ memcpy( &mbedtls_sha256, &ssl->handshake->fin_sha256, sizeof(mbedtls_sha256_context) );
+ mbedtls_sha256_finish( &mbedtls_sha256, hash );
- SSL_DEBUG_BUF( 3, "calculated verify result", hash, 32 );
- SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calculated verify result", hash, 32 );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
- sha256_free( &sha256 );
+ mbedtls_sha256_free( &mbedtls_sha256 );
return;
}
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
-void ssl_calc_verify_tls_sha384( ssl_context *ssl, unsigned char hash[48] )
+#if defined(MBEDTLS_SHA512_C)
+void ssl_calc_verify_tls_sha384( mbedtls_ssl_context *ssl, unsigned char hash[48] )
{
- sha512_context sha512;
+ mbedtls_sha512_context mbedtls_sha512;
- SSL_DEBUG_MSG( 2, ( "=> calc verify sha384" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify sha384" ) );
- memcpy( &sha512, &ssl->handshake->fin_sha512, sizeof(sha512_context) );
- sha512_finish( &sha512, hash );
+ memcpy( &mbedtls_sha512, &ssl->handshake->fin_sha512, sizeof(mbedtls_sha512_context) );
+ mbedtls_sha512_finish( &mbedtls_sha512, hash );
- SSL_DEBUG_BUF( 3, "calculated verify result", hash, 48 );
- SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calculated verify result", hash, 48 );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc verify" ) );
- sha512_free( &sha512 );
+ mbedtls_sha512_free( &mbedtls_sha512 );
return;
}
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
-int ssl_psk_derive_premaster( ssl_context *ssl, key_exchange_type_t key_ex )
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+int mbedtls_ssl_psk_derive_premaster( mbedtls_ssl_context *ssl, mbedtls_key_exchange_type_t key_ex )
{
unsigned char *p = ssl->handshake->premaster;
unsigned char *end = p + sizeof( ssl->handshake->premaster );
@@ -1074,20 +1074,20 @@
* };
* with "other_secret" depending on the particular key exchange
*/
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
- if( key_ex == POLARSSL_KEY_EXCHANGE_PSK )
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+ if( key_ex == MBEDTLS_KEY_EXCHANGE_PSK )
{
if( end - p < 2 + (int) ssl->psk_len )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
*(p++) = (unsigned char)( ssl->psk_len >> 8 );
*(p++) = (unsigned char)( ssl->psk_len );
p += ssl->psk_len;
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- if( key_ex == POLARSSL_KEY_EXCHANGE_RSA_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ if( key_ex == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
/*
* other_secret already set by the ClientKeyExchange message,
@@ -1098,40 +1098,40 @@
p += 48;
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- if( key_ex == POLARSSL_KEY_EXCHANGE_DHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ if( key_ex == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
int ret;
size_t len = end - ( p + 2 );
/* Write length only when we know the actual value */
- if( ( ret = dhm_calc_secret( &ssl->handshake->dhm_ctx,
+ if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
p + 2, &len,
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "dhm_calc_secret", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
return( ret );
}
*(p++) = (unsigned char)( len >> 8 );
*(p++) = (unsigned char)( len );
p += len;
- SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
- if( key_ex == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+ if( key_ex == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
int ret;
size_t zlen;
- if( ( ret = ecdh_calc_secret( &ssl->handshake->ecdh_ctx, &zlen,
+ if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx, &zlen,
p + 2, end - ( p + 2 ),
ssl->f_rng, ssl->p_rng ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ecdh_calc_secret", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
return( ret );
}
@@ -1139,18 +1139,18 @@
*(p++) = (unsigned char)( zlen );
p += zlen;
- SSL_DEBUG_MPI( 3, "ECDH: z", &ssl->handshake->ecdh_ctx.z );
+ MBEDTLS_SSL_DEBUG_MPI( 3, "ECDH: z", &ssl->handshake->ecdh_ctx.z );
}
else
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/* opaque psk<0..2^16-1>; */
if( end - p < 2 + (int) ssl->psk_len )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
*(p++) = (unsigned char)( ssl->psk_len >> 8 );
*(p++) = (unsigned char)( ssl->psk_len );
@@ -1161,24 +1161,24 @@
return( 0 );
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
/*
* SSLv3.0 MAC functions
*/
-static void ssl_mac( md_context_t *md_ctx, unsigned char *secret,
+static void ssl_mac( mbedtls_md_context_t *md_ctx, unsigned char *secret,
unsigned char *buf, size_t len,
unsigned char *ctr, int type )
{
unsigned char header[11];
unsigned char padding[48];
int padlen;
- int md_size = md_get_size( md_ctx->md_info );
- int md_type = md_get_type( md_ctx->md_info );
+ int md_size = mbedtls_md_get_size( md_ctx->md_info );
+ int md_type = mbedtls_md_get_type( md_ctx->md_info );
/* Only MD5 and SHA-1 supported */
- if( md_type == POLARSSL_MD_MD5 )
+ if( md_type == MBEDTLS_MD_MD5 )
padlen = 48;
else
padlen = 40;
@@ -1189,62 +1189,62 @@
header[10] = (unsigned char)( len );
memset( padding, 0x36, padlen );
- md_starts( md_ctx );
- md_update( md_ctx, secret, md_size );
- md_update( md_ctx, padding, padlen );
- md_update( md_ctx, header, 11 );
- md_update( md_ctx, buf, len );
- md_finish( md_ctx, buf + len );
+ mbedtls_md_starts( md_ctx );
+ mbedtls_md_update( md_ctx, secret, md_size );
+ mbedtls_md_update( md_ctx, padding, padlen );
+ mbedtls_md_update( md_ctx, header, 11 );
+ mbedtls_md_update( md_ctx, buf, len );
+ mbedtls_md_finish( md_ctx, buf + len );
memset( padding, 0x5C, padlen );
- md_starts( md_ctx );
- md_update( md_ctx, secret, md_size );
- md_update( md_ctx, padding, padlen );
- md_update( md_ctx, buf + len, md_size );
- md_finish( md_ctx, buf + len );
+ mbedtls_md_starts( md_ctx );
+ mbedtls_md_update( md_ctx, secret, md_size );
+ mbedtls_md_update( md_ctx, padding, padlen );
+ mbedtls_md_update( md_ctx, buf + len, md_size );
+ mbedtls_md_finish( md_ctx, buf + len );
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER) || \
- ( defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_AES_C) || defined(POLARSSL_CAMELLIA_C) ) )
-#define POLARSSL_SOME_MODES_USE_MAC
+#if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER) || \
+ ( defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_AES_C) || defined(MBEDTLS_CAMELLIA_C) ) )
+#define MBEDTLS_SOME_MODES_USE_MAC
#endif
/*
* Encryption/decryption functions
*/
-static int ssl_encrypt_buf( ssl_context *ssl )
+static int ssl_encrypt_buf( mbedtls_ssl_context *ssl )
{
- cipher_mode_t mode;
+ mbedtls_cipher_mode_t mode;
int auth_done = 0;
- SSL_DEBUG_MSG( 2, ( "=> encrypt buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> encrypt buf" ) );
if( ssl->session_out == NULL || ssl->transform_out == NULL )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- mode = cipher_get_cipher_mode( &ssl->transform_out->cipher_ctx_enc );
+ mode = mbedtls_cipher_get_cipher_mode( &ssl->transform_out->cipher_ctx_enc );
- SSL_DEBUG_BUF( 4, "before encrypt: output payload",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "before encrypt: output payload",
ssl->out_msg, ssl->out_msglen );
/*
* Add MAC before if needed
*/
-#if defined(POLARSSL_SOME_MODES_USE_MAC)
- if( mode == POLARSSL_MODE_STREAM ||
- ( mode == POLARSSL_MODE_CBC
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- && ssl->session_out->encrypt_then_mac == SSL_ETM_DISABLED
+#if defined(MBEDTLS_SOME_MODES_USE_MAC)
+ if( mode == MBEDTLS_MODE_STREAM ||
+ ( mode == MBEDTLS_MODE_CBC
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ && ssl->session_out->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED
#endif
) )
{
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl_mac( &ssl->transform_out->md_ctx_enc,
ssl->transform_out->mac_enc,
@@ -1253,27 +1253,27 @@
}
else
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver >= SSL_MINOR_VERSION_1 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 )
{
- md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_ctr, 8 );
- md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_hdr, 3 );
- md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_len, 2 );
- md_hmac_update( &ssl->transform_out->md_ctx_enc,
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_ctr, 8 );
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_hdr, 3 );
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc, ssl->out_len, 2 );
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc,
ssl->out_msg, ssl->out_msglen );
- md_hmac_finish( &ssl->transform_out->md_ctx_enc,
+ mbedtls_md_hmac_finish( &ssl->transform_out->md_ctx_enc,
ssl->out_msg + ssl->out_msglen );
- md_hmac_reset( &ssl->transform_out->md_ctx_enc );
+ mbedtls_md_hmac_reset( &ssl->transform_out->md_ctx_enc );
}
else
#endif
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_BUF( 4, "computed mac",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "computed mac",
ssl->out_msg + ssl->out_msglen,
ssl->transform_out->maclen );
@@ -1285,59 +1285,59 @@
/*
* Encrypt
*/
-#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER)
- if( mode == POLARSSL_MODE_STREAM )
+#if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER)
+ if( mode == MBEDTLS_MODE_STREAM )
{
int ret;
size_t olen = 0;
- SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
"including %d bytes of padding",
ssl->out_msglen, 0 ) );
- if( ( ret = cipher_crypt( &ssl->transform_out->cipher_ctx_enc,
+ if( ( ret = mbedtls_cipher_crypt( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen,
ssl->out_msg, ssl->out_msglen,
ssl->out_msg, &olen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_crypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_crypt", ret );
return( ret );
}
if( ssl->out_msglen != olen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
-#endif /* POLARSSL_ARC4_C || POLARSSL_CIPHER_NULL_CIPHER */
-#if defined(POLARSSL_GCM_C) || defined(POLARSSL_CCM_C)
- if( mode == POLARSSL_MODE_GCM ||
- mode == POLARSSL_MODE_CCM )
+#endif /* MBEDTLS_ARC4_C || MBEDTLS_CIPHER_NULL_CIPHER */
+#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C)
+ if( mode == MBEDTLS_MODE_GCM ||
+ mode == MBEDTLS_MODE_CCM )
{
int ret;
size_t enc_msglen, olen;
unsigned char *enc_msg;
unsigned char add_data[13];
unsigned char taglen = ssl->transform_out->ciphersuite_info->flags &
- POLARSSL_CIPHERSUITE_SHORT_TAG ? 8 : 16;
+ MBEDTLS_CIPHERSUITE_SHORT_TAG ? 8 : 16;
memcpy( add_data, ssl->out_ctr, 8 );
add_data[8] = ssl->out_msgtype;
- ssl_write_version( ssl->major_ver, ssl->minor_ver,
+ mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->transport, add_data + 9 );
add_data[11] = ( ssl->out_msglen >> 8 ) & 0xFF;
add_data[12] = ssl->out_msglen & 0xFF;
- SSL_DEBUG_BUF( 4, "additional data used for AEAD",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "additional data used for AEAD",
add_data, 13 );
/*
* Generate IV
*/
-#if defined(POLARSSL_SSL_AEAD_RANDOM_IV)
+#if defined(MBEDTLS_SSL_AEAD_RANDOM_IV)
ret = ssl->f_rng( ssl->p_rng,
ssl->transform_out->iv_enc + ssl->transform_out->fixed_ivlen,
ssl->transform_out->ivlen - ssl->transform_out->fixed_ivlen );
@@ -1351,8 +1351,8 @@
if( ssl->transform_out->ivlen - ssl->transform_out->fixed_ivlen != 8 )
{
/* Reminder if we ever add an AEAD mode with a different size */
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( ssl->transform_out->iv_enc + ssl->transform_out->fixed_ivlen,
@@ -1360,7 +1360,7 @@
memcpy( ssl->out_iv, ssl->out_ctr, 8 );
#endif
- SSL_DEBUG_BUF( 4, "IV used", ssl->out_iv,
+ MBEDTLS_SSL_DEBUG_BUF( 4, "IV used", ssl->out_iv,
ssl->transform_out->ivlen - ssl->transform_out->fixed_ivlen );
/*
@@ -1371,14 +1371,14 @@
ssl->out_msglen += ssl->transform_out->ivlen -
ssl->transform_out->fixed_ivlen;
- SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
"including %d bytes of padding",
ssl->out_msglen, 0 ) );
/*
* Encrypt and authenticate
*/
- if( ( ret = cipher_auth_encrypt( &ssl->transform_out->cipher_ctx_enc,
+ if( ( ret = mbedtls_cipher_auth_encrypt( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen,
add_data, 13,
@@ -1386,26 +1386,26 @@
enc_msg, &olen,
enc_msg + enc_msglen, taglen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_auth_encrypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_auth_encrypt", ret );
return( ret );
}
if( olen != enc_msglen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->out_msglen += taglen;
auth_done++;
- SSL_DEBUG_BUF( 4, "after encrypt: tag", enc_msg + enc_msglen, taglen );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "after encrypt: tag", enc_msg + enc_msglen, taglen );
}
else
-#endif /* POLARSSL_GCM_C || POLARSSL_CCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_AES_C) || defined(POLARSSL_CAMELLIA_C) )
- if( mode == POLARSSL_MODE_CBC )
+#endif /* MBEDTLS_GCM_C || MBEDTLS_CCM_C */
+#if defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_AES_C) || defined(MBEDTLS_CAMELLIA_C) )
+ if( mode == MBEDTLS_MODE_CBC )
{
int ret;
unsigned char *enc_msg;
@@ -1424,12 +1424,12 @@
enc_msglen = ssl->out_msglen;
enc_msg = ssl->out_msg;
-#if defined(POLARSSL_SSL_PROTO_TLS1_1) || defined(POLARSSL_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SSL_PROTO_TLS1_1) || defined(MBEDTLS_SSL_PROTO_TLS1_2)
/*
* Prepend per-record IV for block cipher in TLS v1.1 and up as per
* Method 1 (6.2.3.2. in RFC4346 and RFC5246)
*/
- if( ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
{
/*
* Generate IV
@@ -1449,31 +1449,31 @@
enc_msglen = ssl->out_msglen;
ssl->out_msglen += ssl->transform_out->ivlen;
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_1 || POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_1 || MBEDTLS_SSL_PROTO_TLS1_2 */
- SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
"including %d bytes of IV and %d bytes of padding",
ssl->out_msglen, ssl->transform_out->ivlen,
padlen + 1 ) );
- if( ( ret = cipher_crypt( &ssl->transform_out->cipher_ctx_enc,
+ if( ( ret = mbedtls_cipher_crypt( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen,
enc_msg, enc_msglen,
enc_msg, &olen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_crypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_crypt", ret );
return( ret );
}
if( enc_msglen != olen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1)
- if( ssl->minor_ver < SSL_MINOR_VERSION_2 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1)
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 )
{
/*
* Save IV in SSL3 and TLS1
@@ -1484,7 +1484,7 @@
}
#endif
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
if( auth_done == 0 )
{
/*
@@ -1497,104 +1497,104 @@
*/
unsigned char pseudo_hdr[13];
- SSL_DEBUG_MSG( 3, ( "using encrypt then mac" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "using encrypt then mac" ) );
memcpy( pseudo_hdr + 0, ssl->out_ctr, 8 );
memcpy( pseudo_hdr + 8, ssl->out_hdr, 3 );
pseudo_hdr[11] = (unsigned char)( ( ssl->out_msglen >> 8 ) & 0xFF );
pseudo_hdr[12] = (unsigned char)( ( ssl->out_msglen ) & 0xFF );
- SSL_DEBUG_BUF( 4, "MAC'd meta-data", pseudo_hdr, 13 );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "MAC'd meta-data", pseudo_hdr, 13 );
- md_hmac_update( &ssl->transform_out->md_ctx_enc, pseudo_hdr, 13 );
- md_hmac_update( &ssl->transform_out->md_ctx_enc,
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc, pseudo_hdr, 13 );
+ mbedtls_md_hmac_update( &ssl->transform_out->md_ctx_enc,
ssl->out_iv, ssl->out_msglen );
- md_hmac_finish( &ssl->transform_out->md_ctx_enc,
+ mbedtls_md_hmac_finish( &ssl->transform_out->md_ctx_enc,
ssl->out_iv + ssl->out_msglen );
- md_hmac_reset( &ssl->transform_out->md_ctx_enc );
+ mbedtls_md_hmac_reset( &ssl->transform_out->md_ctx_enc );
ssl->out_msglen += ssl->transform_out->maclen;
auth_done++;
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
}
else
-#endif /* POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_CAMELLIA_C ) */
+#endif /* MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_CAMELLIA_C ) */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/* Make extra sure authentication was performed, exactly once */
if( auth_done != 1 )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_MSG( 2, ( "<= encrypt buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= encrypt buf" ) );
return( 0 );
}
-#define POLARSSL_SSL_MAX_MAC_SIZE 48
+#define MBEDTLS_SSL_MAX_MAC_SIZE 48
-static int ssl_decrypt_buf( ssl_context *ssl )
+static int ssl_decrypt_buf( mbedtls_ssl_context *ssl )
{
size_t i;
- cipher_mode_t mode;
+ mbedtls_cipher_mode_t mode;
int auth_done = 0;
-#if defined(POLARSSL_SOME_MODES_USE_MAC)
+#if defined(MBEDTLS_SOME_MODES_USE_MAC)
size_t padlen = 0, correct = 1;
#endif
- SSL_DEBUG_MSG( 2, ( "=> decrypt buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> decrypt buf" ) );
if( ssl->session_in == NULL || ssl->transform_in == NULL )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- mode = cipher_get_cipher_mode( &ssl->transform_in->cipher_ctx_dec );
+ mode = mbedtls_cipher_get_cipher_mode( &ssl->transform_in->cipher_ctx_dec );
if( ssl->in_msglen < ssl->transform_in->minlen )
{
- SSL_DEBUG_MSG( 1, ( "in_msglen (%d) < minlen (%d)",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "in_msglen (%d) < minlen (%d)",
ssl->in_msglen, ssl->transform_in->minlen ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
-#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER)
- if( mode == POLARSSL_MODE_STREAM )
+#if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER)
+ if( mode == MBEDTLS_MODE_STREAM )
{
int ret;
size_t olen = 0;
padlen = 0;
- if( ( ret = cipher_crypt( &ssl->transform_in->cipher_ctx_dec,
+ if( ( ret = mbedtls_cipher_crypt( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen,
ssl->in_msg, ssl->in_msglen,
ssl->in_msg, &olen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_crypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_crypt", ret );
return( ret );
}
if( ssl->in_msglen != olen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
-#endif /* POLARSSL_ARC4_C || POLARSSL_CIPHER_NULL_CIPHER */
-#if defined(POLARSSL_GCM_C) || defined(POLARSSL_CCM_C)
- if( mode == POLARSSL_MODE_GCM ||
- mode == POLARSSL_MODE_CCM )
+#endif /* MBEDTLS_ARC4_C || MBEDTLS_CIPHER_NULL_CIPHER */
+#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C)
+ if( mode == MBEDTLS_MODE_GCM ||
+ mode == MBEDTLS_MODE_CCM )
{
int ret;
size_t dec_msglen, olen;
@@ -1602,16 +1602,16 @@
unsigned char *dec_msg_result;
unsigned char add_data[13];
unsigned char taglen = ssl->transform_in->ciphersuite_info->flags &
- POLARSSL_CIPHERSUITE_SHORT_TAG ? 8 : 16;
+ MBEDTLS_CIPHERSUITE_SHORT_TAG ? 8 : 16;
unsigned char explicit_iv_len = ssl->transform_in->ivlen -
ssl->transform_in->fixed_ivlen;
if( ssl->in_msglen < (size_t) explicit_iv_len + taglen )
{
- SSL_DEBUG_MSG( 1, ( "msglen (%d) < explicit_iv_len (%d) "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "msglen (%d) < explicit_iv_len (%d) "
"+ taglen (%d)", ssl->in_msglen,
explicit_iv_len, taglen ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
dec_msglen = ssl->in_msglen - explicit_iv_len - taglen;
@@ -1621,26 +1621,26 @@
memcpy( add_data, ssl->in_ctr, 8 );
add_data[8] = ssl->in_msgtype;
- ssl_write_version( ssl->major_ver, ssl->minor_ver,
+ mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->transport, add_data + 9 );
add_data[11] = ( ssl->in_msglen >> 8 ) & 0xFF;
add_data[12] = ssl->in_msglen & 0xFF;
- SSL_DEBUG_BUF( 4, "additional data used for AEAD",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "additional data used for AEAD",
add_data, 13 );
memcpy( ssl->transform_in->iv_dec + ssl->transform_in->fixed_ivlen,
ssl->in_iv,
ssl->transform_in->ivlen - ssl->transform_in->fixed_ivlen );
- SSL_DEBUG_BUF( 4, "IV used", ssl->transform_in->iv_dec,
+ MBEDTLS_SSL_DEBUG_BUF( 4, "IV used", ssl->transform_in->iv_dec,
ssl->transform_in->ivlen );
- SSL_DEBUG_BUF( 4, "TAG used", dec_msg + dec_msglen, taglen );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "TAG used", dec_msg + dec_msglen, taglen );
/*
* Decrypt and authenticate
*/
- if( ( ret = cipher_auth_decrypt( &ssl->transform_in->cipher_ctx_dec,
+ if( ( ret = mbedtls_cipher_auth_decrypt( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen,
add_data, 13,
@@ -1648,10 +1648,10 @@
dec_msg_result, &olen,
dec_msg + dec_msglen, taglen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_auth_decrypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_auth_decrypt", ret );
- if( ret == POLARSSL_ERR_CIPHER_AUTH_FAILED )
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ if( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED )
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
return( ret );
}
@@ -1659,15 +1659,15 @@
if( olen != dec_msglen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
-#endif /* POLARSSL_GCM_C || POLARSSL_CCM_C */
-#if defined(POLARSSL_CIPHER_MODE_CBC) && \
- ( defined(POLARSSL_AES_C) || defined(POLARSSL_CAMELLIA_C) )
- if( mode == POLARSSL_MODE_CBC )
+#endif /* MBEDTLS_GCM_C || MBEDTLS_CCM_C */
+#if defined(MBEDTLS_CIPHER_MODE_CBC) && \
+ ( defined(MBEDTLS_AES_C) || defined(MBEDTLS_CAMELLIA_C) )
+ if( mode == MBEDTLS_MODE_CBC )
{
/*
* Decrypt and check the padding
@@ -1682,19 +1682,19 @@
/*
* Check immediate ciphertext sanity
*/
-#if defined(POLARSSL_SSL_PROTO_TLS1_1) || defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_1) || defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
minlen += ssl->transform_in->ivlen;
#endif
if( ssl->in_msglen < minlen + ssl->transform_in->ivlen ||
ssl->in_msglen < minlen + ssl->transform_in->maclen + 1 )
{
- SSL_DEBUG_MSG( 1, ( "msglen (%d) < max( ivlen(%d), maclen (%d) "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "msglen (%d) < max( ivlen(%d), maclen (%d) "
"+ 1 ) ( + expl IV )", ssl->in_msglen,
ssl->transform_in->ivlen,
ssl->transform_in->maclen ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
dec_msglen = ssl->in_msglen;
@@ -1704,13 +1704,13 @@
/*
* Authenticate before decrypt if enabled
*/
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- if( ssl->session_in->encrypt_then_mac == SSL_ETM_ENABLED )
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ if( ssl->session_in->encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED )
{
- unsigned char computed_mac[POLARSSL_SSL_MAX_MAC_SIZE];
+ unsigned char computed_mac[MBEDTLS_SSL_MAX_MAC_SIZE];
unsigned char pseudo_hdr[13];
- SSL_DEBUG_MSG( 3, ( "using encrypt then mac" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "using encrypt then mac" ) );
dec_msglen -= ssl->transform_in->maclen;
ssl->in_msglen -= ssl->transform_in->maclen;
@@ -1720,45 +1720,45 @@
pseudo_hdr[11] = (unsigned char)( ( ssl->in_msglen >> 8 ) & 0xFF );
pseudo_hdr[12] = (unsigned char)( ( ssl->in_msglen ) & 0xFF );
- SSL_DEBUG_BUF( 4, "MAC'd meta-data", pseudo_hdr, 13 );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "MAC'd meta-data", pseudo_hdr, 13 );
- md_hmac_update( &ssl->transform_in->md_ctx_dec, pseudo_hdr, 13 );
- md_hmac_update( &ssl->transform_in->md_ctx_dec,
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec, pseudo_hdr, 13 );
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec,
ssl->in_iv, ssl->in_msglen );
- md_hmac_finish( &ssl->transform_in->md_ctx_dec, computed_mac );
- md_hmac_reset( &ssl->transform_in->md_ctx_dec );
+ mbedtls_md_hmac_finish( &ssl->transform_in->md_ctx_dec, computed_mac );
+ mbedtls_md_hmac_reset( &ssl->transform_in->md_ctx_dec );
- SSL_DEBUG_BUF( 4, "message mac", ssl->in_iv + ssl->in_msglen,
+ MBEDTLS_SSL_DEBUG_BUF( 4, "message mac", ssl->in_iv + ssl->in_msglen,
ssl->transform_in->maclen );
- SSL_DEBUG_BUF( 4, "computed mac", computed_mac,
+ MBEDTLS_SSL_DEBUG_BUF( 4, "computed mac", computed_mac,
ssl->transform_in->maclen );
- if( safer_memcmp( ssl->in_iv + ssl->in_msglen, computed_mac,
+ if( mbedtls_ssl_safer_memcmp( ssl->in_iv + ssl->in_msglen, computed_mac,
ssl->transform_in->maclen ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "message mac does not match" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "message mac does not match" ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
auth_done++;
}
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
/*
* Check length sanity
*/
if( ssl->in_msglen % ssl->transform_in->ivlen != 0 )
{
- SSL_DEBUG_MSG( 1, ( "msglen (%d) %% ivlen (%d) != 0",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "msglen (%d) %% ivlen (%d) != 0",
ssl->in_msglen, ssl->transform_in->ivlen ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
-#if defined(POLARSSL_SSL_PROTO_TLS1_1) || defined(POLARSSL_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SSL_PROTO_TLS1_1) || defined(MBEDTLS_SSL_PROTO_TLS1_2)
/*
* Initialize for prepended IV for block cipher in TLS v1.1 and up
*/
- if( ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
{
dec_msglen -= ssl->transform_in->ivlen;
ssl->in_msglen -= ssl->transform_in->ivlen;
@@ -1766,26 +1766,26 @@
for( i = 0; i < ssl->transform_in->ivlen; i++ )
ssl->transform_in->iv_dec[i] = ssl->in_iv[i];
}
-#endif /* POLARSSL_SSL_PROTO_TLS1_1 || POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_1 || MBEDTLS_SSL_PROTO_TLS1_2 */
- if( ( ret = cipher_crypt( &ssl->transform_in->cipher_ctx_dec,
+ if( ( ret = mbedtls_cipher_crypt( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen,
dec_msg, dec_msglen,
dec_msg_result, &olen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "cipher_crypt", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_cipher_crypt", ret );
return( ret );
}
if( dec_msglen != olen )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1)
- if( ssl->minor_ver < SSL_MINOR_VERSION_2 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1)
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 )
{
/*
* Save IV in SSL3 and TLS1
@@ -1801,21 +1801,21 @@
if( ssl->in_msglen < ssl->transform_in->maclen + padlen &&
auth_done == 0 )
{
-#if defined(POLARSSL_SSL_DEBUG_ALL)
- SSL_DEBUG_MSG( 1, ( "msglen (%d) < maclen (%d) + padlen (%d)",
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "msglen (%d) < maclen (%d) + padlen (%d)",
ssl->in_msglen, ssl->transform_in->maclen, padlen ) );
#endif
padlen = 0;
correct = 0;
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( padlen > ssl->transform_in->ivlen )
{
-#if defined(POLARSSL_SSL_DEBUG_ALL)
- SSL_DEBUG_MSG( 1, ( "bad padding length: is %d, "
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad padding length: is %d, "
"should be no more than %d",
padlen, ssl->transform_in->ivlen ) );
#endif
@@ -1823,10 +1823,10 @@
}
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver > SSL_MINOR_VERSION_0 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver > MBEDTLS_SSL_MINOR_VERSION_0 )
{
/*
* TLSv1+: always check the padding up to the first failure
@@ -1839,14 +1839,14 @@
* Padding is guaranteed to be incorrect if:
* 1. padlen >= ssl->in_msglen
*
- * 2. padding_idx >= SSL_MAX_CONTENT_LEN +
+ * 2. padding_idx >= MBEDTLS_SSL_MAX_CONTENT_LEN +
* ssl->transform_in->maclen
*
* In both cases we reset padding_idx to a safe value (0) to
* prevent out-of-buffer reads.
*/
correct &= ( ssl->in_msglen >= padlen + 1 );
- correct &= ( padding_idx < SSL_MAX_CONTENT_LEN +
+ correct &= ( padding_idx < MBEDTLS_SSL_MAX_CONTENT_LEN +
ssl->transform_in->maclen );
padding_idx *= correct;
@@ -1860,41 +1860,41 @@
correct &= ( pad_count == padlen ); /* Only 1 on correct padding */
-#if defined(POLARSSL_SSL_DEBUG_ALL)
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
if( padlen > 0 && correct == 0 )
- SSL_DEBUG_MSG( 1, ( "bad padding byte detected" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad padding byte detected" ) );
#endif
padlen &= correct * 0x1FF;
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 || \
- POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
+ MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->in_msglen -= padlen;
}
else
-#endif /* POLARSSL_CIPHER_MODE_CBC &&
- ( POLARSSL_AES_C || POLARSSL_CAMELLIA_C ) */
+#endif /* MBEDTLS_CIPHER_MODE_CBC &&
+ ( MBEDTLS_AES_C || MBEDTLS_CAMELLIA_C ) */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_BUF( 4, "raw buffer after decryption",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "raw buffer after decryption",
ssl->in_msg, ssl->in_msglen );
/*
* Authenticate if not done yet.
* Compute the MAC regardless of the padding result (RFC4346, CBCTIME).
*/
-#if defined(POLARSSL_SOME_MODES_USE_MAC)
+#if defined(MBEDTLS_SOME_MODES_USE_MAC)
if( auth_done == 0 )
{
- unsigned char tmp[POLARSSL_SSL_MAX_MAC_SIZE];
+ unsigned char tmp[MBEDTLS_SSL_MAX_MAC_SIZE];
ssl->in_msglen -= ssl->transform_in->maclen;
@@ -1903,8 +1903,8 @@
memcpy( tmp, ssl->in_msg + ssl->in_msglen, ssl->transform_in->maclen );
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl_mac( &ssl->transform_in->md_ctx_dec,
ssl->transform_in->mac_dec,
@@ -1912,10 +1912,10 @@
ssl->in_ctr, ssl->in_msgtype );
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver > SSL_MINOR_VERSION_0 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver > MBEDTLS_SSL_MINOR_VERSION_0 )
{
/*
* Process MAC and always update for padlen afterwards to make
@@ -1936,35 +1936,35 @@
extra_run &= correct * 0xFF;
- md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_ctr, 8 );
- md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_hdr, 3 );
- md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_len, 2 );
- md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_msg,
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_ctr, 8 );
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_hdr, 3 );
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_len, 2 );
+ mbedtls_md_hmac_update( &ssl->transform_in->md_ctx_dec, ssl->in_msg,
ssl->in_msglen );
- md_hmac_finish( &ssl->transform_in->md_ctx_dec,
+ mbedtls_md_hmac_finish( &ssl->transform_in->md_ctx_dec,
ssl->in_msg + ssl->in_msglen );
for( j = 0; j < extra_run; j++ )
- md_process( &ssl->transform_in->md_ctx_dec, ssl->in_msg );
+ mbedtls_md_process( &ssl->transform_in->md_ctx_dec, ssl->in_msg );
- md_hmac_reset( &ssl->transform_in->md_ctx_dec );
+ mbedtls_md_hmac_reset( &ssl->transform_in->md_ctx_dec );
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 || \
- POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
+ MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_BUF( 4, "message mac", tmp, ssl->transform_in->maclen );
- SSL_DEBUG_BUF( 4, "computed mac", ssl->in_msg + ssl->in_msglen,
+ MBEDTLS_SSL_DEBUG_BUF( 4, "message mac", tmp, ssl->transform_in->maclen );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "computed mac", ssl->in_msg + ssl->in_msglen,
ssl->transform_in->maclen );
- if( safer_memcmp( tmp, ssl->in_msg + ssl->in_msglen,
+ if( mbedtls_ssl_safer_memcmp( tmp, ssl->in_msg + ssl->in_msglen,
ssl->transform_in->maclen ) != 0 )
{
-#if defined(POLARSSL_SSL_DEBUG_ALL)
- SSL_DEBUG_MSG( 1, ( "message mac does not match" ) );
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "message mac does not match" ) );
#endif
correct = 0;
}
@@ -1974,15 +1974,15 @@
* Finally check the correct flag
*/
if( correct == 0 )
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
-#endif /* POLARSSL_SOME_MODES_USE_MAC */
+#endif /* MBEDTLS_SOME_MODES_USE_MAC */
/* Make extra sure authentication was performed, exactly once */
if( auth_done != 1 )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( ssl->in_msglen == 0 )
@@ -1995,16 +1995,16 @@
*/
if( ssl->nb_zero > 3 )
{
- SSL_DEBUG_MSG( 1, ( "received four consecutive empty "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "received four consecutive empty "
"messages, possible DoS attack" ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
}
else
ssl->nb_zero = 0;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
; /* in_ctr read from peer, not maintained internally */
}
@@ -2018,12 +2018,12 @@
/* The loop goes to its end iff the counter is wrapping */
if( i == ssl_ep_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "incoming message counter would wrap" ) );
- return( POLARSSL_ERR_SSL_COUNTER_WRAPPING );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "incoming message counter would wrap" ) );
+ return( MBEDTLS_ERR_SSL_COUNTER_WRAPPING );
}
}
- SSL_DEBUG_MSG( 2, ( "<= decrypt buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= decrypt buf" ) );
return( 0 );
}
@@ -2032,108 +2032,108 @@
#undef MAC_PLAINTEXT
#undef MAC_CIPHERTEXT
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
/*
* Compression/decompression functions
*/
-static int ssl_compress_buf( ssl_context *ssl )
+static int ssl_compress_buf( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *msg_post = ssl->out_msg;
size_t len_pre = ssl->out_msglen;
unsigned char *msg_pre = ssl->compress_buf;
- SSL_DEBUG_MSG( 2, ( "=> compress buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> compress buf" ) );
if( len_pre == 0 )
return( 0 );
memcpy( msg_pre, ssl->out_msg, len_pre );
- SSL_DEBUG_MSG( 3, ( "before compression: msglen = %d, ",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "before compression: msglen = %d, ",
ssl->out_msglen ) );
- SSL_DEBUG_BUF( 4, "before compression: output payload",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "before compression: output payload",
ssl->out_msg, ssl->out_msglen );
ssl->transform_out->ctx_deflate.next_in = msg_pre;
ssl->transform_out->ctx_deflate.avail_in = len_pre;
ssl->transform_out->ctx_deflate.next_out = msg_post;
- ssl->transform_out->ctx_deflate.avail_out = SSL_BUFFER_LEN;
+ ssl->transform_out->ctx_deflate.avail_out = MBEDTLS_SSL_BUFFER_LEN;
ret = deflate( &ssl->transform_out->ctx_deflate, Z_SYNC_FLUSH );
if( ret != Z_OK )
{
- SSL_DEBUG_MSG( 1, ( "failed to perform compression (%d)", ret ) );
- return( POLARSSL_ERR_SSL_COMPRESSION_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "failed to perform compression (%d)", ret ) );
+ return( MBEDTLS_ERR_SSL_COMPRESSION_FAILED );
}
- ssl->out_msglen = SSL_BUFFER_LEN -
+ ssl->out_msglen = MBEDTLS_SSL_BUFFER_LEN -
ssl->transform_out->ctx_deflate.avail_out;
- SSL_DEBUG_MSG( 3, ( "after compression: msglen = %d, ",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "after compression: msglen = %d, ",
ssl->out_msglen ) );
- SSL_DEBUG_BUF( 4, "after compression: output payload",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "after compression: output payload",
ssl->out_msg, ssl->out_msglen );
- SSL_DEBUG_MSG( 2, ( "<= compress buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= compress buf" ) );
return( 0 );
}
-static int ssl_decompress_buf( ssl_context *ssl )
+static int ssl_decompress_buf( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *msg_post = ssl->in_msg;
size_t len_pre = ssl->in_msglen;
unsigned char *msg_pre = ssl->compress_buf;
- SSL_DEBUG_MSG( 2, ( "=> decompress buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> decompress buf" ) );
if( len_pre == 0 )
return( 0 );
memcpy( msg_pre, ssl->in_msg, len_pre );
- SSL_DEBUG_MSG( 3, ( "before decompression: msglen = %d, ",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "before decompression: msglen = %d, ",
ssl->in_msglen ) );
- SSL_DEBUG_BUF( 4, "before decompression: input payload",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "before decompression: input payload",
ssl->in_msg, ssl->in_msglen );
ssl->transform_in->ctx_inflate.next_in = msg_pre;
ssl->transform_in->ctx_inflate.avail_in = len_pre;
ssl->transform_in->ctx_inflate.next_out = msg_post;
- ssl->transform_in->ctx_inflate.avail_out = SSL_MAX_CONTENT_LEN;
+ ssl->transform_in->ctx_inflate.avail_out = MBEDTLS_SSL_MAX_CONTENT_LEN;
ret = inflate( &ssl->transform_in->ctx_inflate, Z_SYNC_FLUSH );
if( ret != Z_OK )
{
- SSL_DEBUG_MSG( 1, ( "failed to perform decompression (%d)", ret ) );
- return( POLARSSL_ERR_SSL_COMPRESSION_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "failed to perform decompression (%d)", ret ) );
+ return( MBEDTLS_ERR_SSL_COMPRESSION_FAILED );
}
- ssl->in_msglen = SSL_MAX_CONTENT_LEN -
+ ssl->in_msglen = MBEDTLS_SSL_MAX_CONTENT_LEN -
ssl->transform_in->ctx_inflate.avail_out;
- SSL_DEBUG_MSG( 3, ( "after decompression: msglen = %d, ",
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "after decompression: msglen = %d, ",
ssl->in_msglen ) );
- SSL_DEBUG_BUF( 4, "after decompression: input payload",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "after decompression: input payload",
ssl->in_msg, ssl->in_msglen );
- SSL_DEBUG_MSG( 2, ( "<= decompress buf" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= decompress buf" ) );
return( 0 );
}
-#endif /* POLARSSL_ZLIB_SUPPORT */
+#endif /* MBEDTLS_ZLIB_SUPPORT */
-#if defined(POLARSSL_SSL_SRV_C) && defined(POLARSSL_SSL_RENEGOTIATION)
-static int ssl_write_hello_request( ssl_context *ssl );
+#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
+static int ssl_write_hello_request( mbedtls_ssl_context *ssl );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
-static int ssl_resend_hello_request( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+static int ssl_resend_hello_request( mbedtls_ssl_context *ssl )
{
/* If renegotiation is not enforced, retransmit until we would reach max
* timeout if we were using the usual handshake doubling scheme */
@@ -2150,7 +2150,7 @@
if( ++ssl->renego_records_seen > doublings )
{
- SSL_DEBUG_MSG( 0, ( "no longer retransmitting hello request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 0, ( "no longer retransmitting hello request" ) );
return( 0 );
}
}
@@ -2158,7 +2158,7 @@
return( ssl_write_hello_request( ssl ) );
}
#endif
-#endif /* POLARSSL_SSL_SRV_C && POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */
/*
* Fill the input message buffer by appending data to it.
@@ -2175,28 +2175,28 @@
* For DTLS, it is up to the caller to set ssl->next_record_offset when
* they're done reading a record.
*/
-int ssl_fetch_input( ssl_context *ssl, size_t nb_want )
+int mbedtls_ssl_fetch_input( mbedtls_ssl_context *ssl, size_t nb_want )
{
int ret;
size_t len;
- SSL_DEBUG_MSG( 2, ( "=> fetch input" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> fetch input" ) );
if( ssl->f_recv == NULL && ssl->f_recv_timeout == NULL )
{
- SSL_DEBUG_MSG( 1, ( "Bad usage of ssl_set_bio() "
- "or ssl_set_bio_timeout()" ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "Bad usage of mbedtls_ssl_set_bio() "
+ "or mbedtls_ssl_set_bio_timeout()" ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
- if( nb_want > SSL_BUFFER_LEN - (size_t)( ssl->in_hdr - ssl->in_buf ) )
+ if( nb_want > MBEDTLS_SSL_BUFFER_LEN - (size_t)( ssl->in_hdr - ssl->in_buf ) )
{
- SSL_DEBUG_MSG( 1, ( "requesting more data than fits" ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "requesting more data than fits" ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
uint32_t timeout;
@@ -2214,15 +2214,15 @@
{
if( ssl->in_left < ssl->next_record_offset )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->in_left -= ssl->next_record_offset;
if( ssl->in_left != 0 )
{
- SSL_DEBUG_MSG( 2, ( "next record in same datagram, offset: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "next record in same datagram, offset: %d",
ssl->next_record_offset ) );
memmove( ssl->in_hdr,
ssl->in_hdr + ssl->next_record_offset,
@@ -2232,7 +2232,7 @@
ssl->next_record_offset = 0;
}
- SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
/*
@@ -2240,7 +2240,7 @@
*/
if( nb_want <= ssl->in_left)
{
- SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
return( 0 );
}
@@ -2251,11 +2251,11 @@
*/
if( ssl->in_left != 0 )
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- SSL_DEBUG_MSG( 3, ( "current timer: %u", ssl->time_limit ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "current timer: %u", ssl->time_limit ) );
/*
* Don't even try to read if time's out already.
@@ -2263,17 +2263,17 @@
* that will end up being dropped.
*/
if( ssl_check_timer( ssl ) != 0 )
- ret = POLARSSL_ERR_NET_TIMEOUT;
+ ret = MBEDTLS_ERR_NET_TIMEOUT;
else
{
- len = SSL_BUFFER_LEN - ( ssl->in_hdr - ssl->in_buf );
+ len = MBEDTLS_SSL_BUFFER_LEN - ( ssl->in_hdr - ssl->in_buf );
- if( ssl->state != SSL_HANDSHAKE_OVER )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
timeout = ssl->handshake->retransmit_timeout;
else
timeout = ssl->read_timeout;
- SSL_DEBUG_MSG( 3, ( "f_recv_timeout: %u ms", timeout ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "f_recv_timeout: %u ms", timeout ) );
if( ssl->f_recv_timeout != NULL && timeout != 0 )
ret = ssl->f_recv_timeout( ssl->p_bio, ssl->in_hdr, len,
@@ -2281,46 +2281,46 @@
else
ret = ssl->f_recv( ssl->p_bio, ssl->in_hdr, len );
- SSL_DEBUG_RET( 2, "ssl->f_recv(_timeout)", ret );
+ MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_recv(_timeout)", ret );
if( ret == 0 )
- return( POLARSSL_ERR_SSL_CONN_EOF );
+ return( MBEDTLS_ERR_SSL_CONN_EOF );
}
- if( ret == POLARSSL_ERR_NET_TIMEOUT )
+ if( ret == MBEDTLS_ERR_NET_TIMEOUT )
{
- SSL_DEBUG_MSG( 2, ( "timeout" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "timeout" ) );
ssl_set_timer( ssl, 0 );
- if( ssl->state != SSL_HANDSHAKE_OVER )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
if( ssl_double_retransmit_timeout( ssl ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "handshake timeout" ) );
- return( POLARSSL_ERR_NET_TIMEOUT );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake timeout" ) );
+ return( MBEDTLS_ERR_NET_TIMEOUT );
}
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_resend", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_resend", ret );
return( ret );
}
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
-#if defined(POLARSSL_SSL_SRV_C) && defined(POLARSSL_SSL_RENEGOTIATION)
- else if( ssl->endpoint == SSL_IS_SERVER &&
- ssl->renego_status == SSL_RENEGOTIATION_PENDING )
+#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
+ else if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ( ret = ssl_resend_hello_request( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
return( ret );
}
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
-#endif /* POLARSSL_SSL_SRV_C && POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */
}
if( ret < 0 )
@@ -2331,7 +2331,7 @@
else
#endif
{
- SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
while( ssl->in_left < nb_want )
@@ -2339,12 +2339,12 @@
len = nb_want - ssl->in_left;
ret = ssl->f_recv( ssl->p_bio, ssl->in_hdr + ssl->in_left, len );
- SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "in_left: %d, nb_want: %d",
ssl->in_left, nb_want ) );
- SSL_DEBUG_RET( 2, "ssl->f_recv", ret );
+ MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_recv", ret );
if( ret == 0 )
- return( POLARSSL_ERR_SSL_CONN_EOF );
+ return( MBEDTLS_ERR_SSL_CONN_EOF );
if( ret < 0 )
return( ret );
@@ -2353,7 +2353,7 @@
}
}
- SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= fetch input" ) );
return( 0 );
}
@@ -2361,37 +2361,37 @@
/*
* Flush any data not yet written
*/
-int ssl_flush_output( ssl_context *ssl )
+int mbedtls_ssl_flush_output( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *buf, i;
- SSL_DEBUG_MSG( 2, ( "=> flush output" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> flush output" ) );
if( ssl->f_send == NULL )
{
- SSL_DEBUG_MSG( 1, ( "Bad usage of ssl_set_bio() "
- "or ssl_set_bio_timeout()" ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "Bad usage of mbedtls_ssl_set_bio() "
+ "or mbedtls_ssl_set_bio_timeout()" ) );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/* Avoid incrementing counter if data is flushed */
if( ssl->out_left == 0 )
{
- SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
return( 0 );
}
while( ssl->out_left > 0 )
{
- SSL_DEBUG_MSG( 2, ( "message length: %d, out_left: %d",
- ssl_hdr_len( ssl ) + ssl->out_msglen, ssl->out_left ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "message length: %d, out_left: %d",
+ mbedtls_ssl_hdr_len( ssl ) + ssl->out_msglen, ssl->out_left ) );
- buf = ssl->out_hdr + ssl_hdr_len( ssl ) +
+ buf = ssl->out_hdr + mbedtls_ssl_hdr_len( ssl ) +
ssl->out_msglen - ssl->out_left;
ret = ssl->f_send( ssl->p_bio, buf, ssl->out_left );
- SSL_DEBUG_RET( 2, "ssl->f_send", ret );
+ MBEDTLS_SSL_DEBUG_RET( 2, "ssl->f_send", ret );
if( ret <= 0 )
return( ret );
@@ -2406,11 +2406,11 @@
/* The loop goes to its end iff the counter is wrapping */
if( i == ssl_ep_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "outgoing message counter would wrap" ) );
- return( POLARSSL_ERR_SSL_COUNTER_WRAPPING );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "outgoing message counter would wrap" ) );
+ return( MBEDTLS_ERR_SSL_COUNTER_WRAPPING );
}
- SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= flush output" ) );
return( 0 );
}
@@ -2418,27 +2418,27 @@
/*
* Functions to handle the DTLS retransmission state machine
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
/*
* Append current handshake message to current outgoing flight
*/
-static int ssl_flight_append( ssl_context *ssl )
+static int ssl_flight_append( mbedtls_ssl_context *ssl )
{
- ssl_flight_item *msg;
+ mbedtls_ssl_flight_item *msg;
/* Allocate space for current message */
- if( ( msg = polarssl_malloc( sizeof( ssl_flight_item ) ) ) == NULL )
+ if( ( msg = mbedtls_malloc( sizeof( mbedtls_ssl_flight_item ) ) ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc %d bytes failed",
- sizeof( ssl_flight_item ) ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc %d bytes failed",
+ sizeof( mbedtls_ssl_flight_item ) ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
- if( ( msg->p = polarssl_malloc( ssl->out_msglen ) ) == NULL )
+ if( ( msg->p = mbedtls_malloc( ssl->out_msglen ) ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc %d bytes failed", ssl->out_msglen ) );
- polarssl_free( msg );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc %d bytes failed", ssl->out_msglen ) );
+ mbedtls_free( msg );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
/* Copy current handshake message with headers */
@@ -2452,7 +2452,7 @@
ssl->handshake->flight = msg;
else
{
- ssl_flight_item *cur = ssl->handshake->flight;
+ mbedtls_ssl_flight_item *cur = ssl->handshake->flight;
while( cur->next != NULL )
cur = cur->next;
cur->next = msg;
@@ -2464,41 +2464,41 @@
/*
* Free the current flight of handshake messages
*/
-static void ssl_flight_free( ssl_flight_item *flight )
+static void ssl_flight_free( mbedtls_ssl_flight_item *flight )
{
- ssl_flight_item *cur = flight;
- ssl_flight_item *next;
+ mbedtls_ssl_flight_item *cur = flight;
+ mbedtls_ssl_flight_item *next;
while( cur != NULL )
{
next = cur->next;
- polarssl_free( cur->p );
- polarssl_free( cur );
+ mbedtls_free( cur->p );
+ mbedtls_free( cur );
cur = next;
}
}
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
-static void ssl_dtls_replay_reset( ssl_context *ssl );
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+static void ssl_dtls_replay_reset( mbedtls_ssl_context *ssl );
#endif
/*
* Swap transform_out and out_ctr with the alternative ones
*/
-static void ssl_swap_epochs( ssl_context *ssl )
+static void ssl_swap_epochs( mbedtls_ssl_context *ssl )
{
- ssl_transform *tmp_transform;
+ mbedtls_ssl_transform *tmp_transform;
unsigned char tmp_out_ctr[8];
if( ssl->transform_out == ssl->handshake->alt_transform_out )
{
- SSL_DEBUG_MSG( 3, ( "skip swap epochs" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "skip swap epochs" ) );
return;
}
- SSL_DEBUG_MSG( 3, ( "swap epochs" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "swap epochs" ) );
/* Swap transforms */
tmp_transform = ssl->transform_out;
@@ -2512,7 +2512,7 @@
/* Adjust to the newly activated transform */
if( ssl->transform_out != NULL &&
- ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+ ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
{
ssl->out_msg = ssl->out_iv + ssl->transform_out->ivlen -
ssl->transform_out->fixed_ivlen;
@@ -2520,13 +2520,13 @@
else
ssl->out_msg = ssl->out_iv;
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_activate != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_activate != NULL )
{
- if( ( ret = ssl_hw_record_activate( ssl, SSL_CHANNEL_OUTBOUND ) ) != 0 )
+ if( ( ret = mbedtls_ssl_hw_record_activate( ssl, MBEDTLS_SSL_CHANNEL_OUTBOUND ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_activate", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_activate", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
#endif
@@ -2539,30 +2539,30 @@
* WANT_WRITE, causing us to exit this function and come back later.
* This function must be called until state is no longer SENDING.
*/
-int ssl_resend( ssl_context *ssl )
+int mbedtls_ssl_resend( mbedtls_ssl_context *ssl )
{
- SSL_DEBUG_MSG( 2, ( "=> ssl_resend" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> mbedtls_ssl_resend" ) );
- if( ssl->handshake->retransmit_state != SSL_RETRANS_SENDING )
+ if( ssl->handshake->retransmit_state != MBEDTLS_SSL_RETRANS_SENDING )
{
- SSL_DEBUG_MSG( 2, ( "initialise resending" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "initialise resending" ) );
ssl->handshake->cur_msg = ssl->handshake->flight;
ssl_swap_epochs( ssl );
- ssl->handshake->retransmit_state = SSL_RETRANS_SENDING;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_SENDING;
}
while( ssl->handshake->cur_msg != NULL )
{
int ret;
- ssl_flight_item *cur = ssl->handshake->cur_msg;
+ mbedtls_ssl_flight_item *cur = ssl->handshake->cur_msg;
/* Swap epochs before sending Finished: we can't do it after
* sending ChangeCipherSpec, in case write returns WANT_READ.
* Must be done before copying, may change out_msg pointer */
- if( cur->type == SSL_MSG_HANDSHAKE &&
- cur->p[0] == SSL_HS_FINISHED )
+ if( cur->type == MBEDTLS_SSL_MSG_HANDSHAKE &&
+ cur->p[0] == MBEDTLS_SSL_HS_FINISHED )
{
ssl_swap_epochs( ssl );
}
@@ -2573,24 +2573,24 @@
ssl->handshake->cur_msg = cur->next;
- SSL_DEBUG_BUF( 3, "resent handshake message header", ssl->out_msg, 12 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "resent handshake message header", ssl->out_msg, 12 );
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
}
- if( ssl->state == SSL_HANDSHAKE_OVER )
- ssl->handshake->retransmit_state = SSL_RETRANS_FINISHED;
+ if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;
else
{
- ssl->handshake->retransmit_state = SSL_RETRANS_WAITING;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;
ssl_set_timer( ssl, ssl->handshake->retransmit_timeout );
}
- SSL_DEBUG_MSG( 2, ( "<= ssl_resend" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= mbedtls_ssl_resend" ) );
return( 0 );
}
@@ -2598,7 +2598,7 @@
/*
* To be called when the last message of an incoming flight is received.
*/
-void ssl_recv_flight_completed( ssl_context *ssl )
+void mbedtls_ssl_recv_flight_completed( mbedtls_ssl_context *ssl )
{
/* We won't need to resend that one any more */
ssl_flight_free( ssl->handshake->flight );
@@ -2611,32 +2611,32 @@
/* Cancel timer */
ssl_set_timer( ssl, 0 );
- if( ssl->in_msgtype == SSL_MSG_HANDSHAKE &&
- ssl->in_msg[0] == SSL_HS_FINISHED )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
+ ssl->in_msg[0] == MBEDTLS_SSL_HS_FINISHED )
{
- ssl->handshake->retransmit_state = SSL_RETRANS_FINISHED;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;
}
else
- ssl->handshake->retransmit_state = SSL_RETRANS_PREPARING;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;
}
/*
* To be called when the last message of an outgoing flight is send.
*/
-void ssl_send_flight_completed( ssl_context *ssl )
+void mbedtls_ssl_send_flight_completed( mbedtls_ssl_context *ssl )
{
ssl_reset_retransmit_timeout( ssl );
ssl_set_timer( ssl, ssl->handshake->retransmit_timeout );
- if( ssl->in_msgtype == SSL_MSG_HANDSHAKE &&
- ssl->in_msg[0] == SSL_HS_FINISHED )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
+ ssl->in_msg[0] == MBEDTLS_SSL_HS_FINISHED )
{
- ssl->handshake->retransmit_state = SSL_RETRANS_FINISHED;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;
}
else
- ssl->handshake->retransmit_state = SSL_RETRANS_WAITING;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
/*
* Record layer functions
@@ -2646,23 +2646,23 @@
* Write current record.
* Uses ssl->out_msgtype, ssl->out_msglen and bytes at ssl->out_msg.
*/
-int ssl_write_record( ssl_context *ssl )
+int mbedtls_ssl_write_record( mbedtls_ssl_context *ssl )
{
int ret, done = 0;
size_t len = ssl->out_msglen;
- SSL_DEBUG_MSG( 2, ( "=> write record" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write record" ) );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL &&
- ssl->handshake->retransmit_state == SSL_RETRANS_SENDING )
+ ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
; /* Skip special handshake treatment when resending */
}
else
#endif
- if( ssl->out_msgtype == SSL_MSG_HANDSHAKE )
+ if( ssl->out_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE )
{
ssl->out_msg[1] = (unsigned char)( ( len - 4 ) >> 16 );
ssl->out_msg[2] = (unsigned char)( ( len - 4 ) >> 8 );
@@ -2675,8 +2675,8 @@
* uint24 fragment_offset;
* uint24 fragment_length;
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Make room for the additional DTLS fields */
memmove( ssl->out_msg + 12, ssl->out_msg + 4, len - 4 );
@@ -2684,7 +2684,7 @@
len += 8;
/* Write message_seq and update it, except for HelloRequest */
- if( ssl->out_msg[0] != SSL_HS_HELLO_REQUEST )
+ if( ssl->out_msg[0] != MBEDTLS_SSL_HS_HELLO_REQUEST )
{
ssl->out_msg[4] = ( ssl->handshake->out_msg_seq >> 8 ) & 0xFF;
ssl->out_msg[5] = ( ssl->handshake->out_msg_seq ) & 0xFF;
@@ -2700,62 +2700,62 @@
memset( ssl->out_msg + 6, 0x00, 3 );
memcpy( ssl->out_msg + 9, ssl->out_msg + 1, 3 );
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
- if( ssl->out_msg[0] != SSL_HS_HELLO_REQUEST )
+ if( ssl->out_msg[0] != MBEDTLS_SSL_HS_HELLO_REQUEST )
ssl->handshake->update_checksum( ssl, ssl->out_msg, len );
}
/* Save handshake and CCS messages for resending */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL &&
- ssl->handshake->retransmit_state != SSL_RETRANS_SENDING &&
- ( ssl->out_msgtype == SSL_MSG_CHANGE_CIPHER_SPEC ||
- ssl->out_msgtype == SSL_MSG_HANDSHAKE ) )
+ ssl->handshake->retransmit_state != MBEDTLS_SSL_RETRANS_SENDING &&
+ ( ssl->out_msgtype == MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC ||
+ ssl->out_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE ) )
{
if( ( ret = ssl_flight_append( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_flight_append", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_flight_append", ret );
return( ret );
}
}
#endif
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
if( ssl->transform_out != NULL &&
- ssl->session_out->compression == SSL_COMPRESS_DEFLATE )
+ ssl->session_out->compression == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
if( ( ret = ssl_compress_buf( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_compress_buf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_compress_buf", ret );
return( ret );
}
len = ssl->out_msglen;
}
-#endif /*POLARSSL_ZLIB_SUPPORT */
+#endif /*MBEDTLS_ZLIB_SUPPORT */
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_write != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_write != NULL )
{
- SSL_DEBUG_MSG( 2, ( "going for ssl_hw_record_write()" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_write()" ) );
- ret = ssl_hw_record_write( ssl );
- if( ret != 0 && ret != POLARSSL_ERR_SSL_HW_ACCEL_FALLTHROUGH )
+ ret = mbedtls_ssl_hw_record_write( ssl );
+ if( ret != 0 && ret != MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_write", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_write", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
if( ret == 0 )
done = 1;
}
-#endif /* POLARSSL_SSL_HW_RECORD_ACCEL */
+#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
if( !done )
{
ssl->out_hdr[0] = (unsigned char) ssl->out_msgtype;
- ssl_write_version( ssl->major_ver, ssl->minor_ver,
+ mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->transport, ssl->out_hdr + 1 );
ssl->out_len[0] = (unsigned char)( len >> 8 );
@@ -2765,7 +2765,7 @@
{
if( ( ret = ssl_encrypt_buf( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_encrypt_buf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_encrypt_buf", ret );
return( ret );
}
@@ -2774,29 +2774,29 @@
ssl->out_len[1] = (unsigned char)( len );
}
- ssl->out_left = ssl_hdr_len( ssl ) + ssl->out_msglen;
+ ssl->out_left = mbedtls_ssl_hdr_len( ssl ) + ssl->out_msglen;
- SSL_DEBUG_MSG( 3, ( "output record: msgtype = %d, "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "output record: msgtype = %d, "
"version = [%d:%d], msglen = %d",
ssl->out_hdr[0], ssl->out_hdr[1], ssl->out_hdr[2],
( ssl->out_len[0] << 8 ) | ssl->out_len[1] ) );
- SSL_DEBUG_BUF( 4, "output record sent to network",
- ssl->out_hdr, ssl_hdr_len( ssl ) + ssl->out_msglen );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "output record sent to network",
+ ssl->out_hdr, mbedtls_ssl_hdr_len( ssl ) + ssl->out_msglen );
}
- if( ( ret = ssl_flush_output( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_flush_output", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_flush_output", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write record" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write record" ) );
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
/*
* Mark bits in bitmask (used for DTLS HS reassembly)
*/
@@ -2866,7 +2866,7 @@
* - the second holds a bitmask indicating which parts of the message
* (excluding headers) have been received so far.
*/
-static int ssl_reassemble_dtls_handshake( ssl_context *ssl )
+static int ssl_reassemble_dtls_handshake( mbedtls_ssl_context *ssl )
{
unsigned char *msg, *bitmask;
size_t frag_len, frag_off;
@@ -2874,8 +2874,8 @@
if( ssl->handshake == NULL )
{
- SSL_DEBUG_MSG( 1, ( "not supported outside handshake (for now)" ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "not supported outside handshake (for now)" ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
/*
@@ -2885,23 +2885,23 @@
{
size_t alloc_len;
- SSL_DEBUG_MSG( 2, ( "initialize reassembly, total length = %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "initialize reassembly, total length = %d",
msg_len ) );
- if( ssl->in_hslen > SSL_MAX_CONTENT_LEN )
+ if( ssl->in_hslen > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- SSL_DEBUG_MSG( 1, ( "handshake message too large" ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake message too large" ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
/* The bitmask needs one bit per byte of message excluding header */
alloc_len = 12 + msg_len + msg_len / 8 + ( msg_len % 8 != 0 );
- ssl->handshake->hs_msg = polarssl_malloc( alloc_len );
+ ssl->handshake->hs_msg = mbedtls_malloc( alloc_len );
if( ssl->handshake->hs_msg == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc failed (%d bytes)", alloc_len ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc failed (%d bytes)", alloc_len ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
memset( ssl->handshake->hs_msg, 0, alloc_len );
@@ -2918,8 +2918,8 @@
/* Make sure msg_type and length are consistent */
if( memcmp( ssl->handshake->hs_msg, ssl->in_msg, 4 ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "fragment header mismatch" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "fragment header mismatch" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
}
@@ -2938,19 +2938,19 @@
if( frag_off + frag_len > msg_len )
{
- SSL_DEBUG_MSG( 1, ( "invalid fragment offset/len: %d + %d > %d",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid fragment offset/len: %d + %d > %d",
frag_off, frag_len, msg_len ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
if( frag_len + 12 > ssl->in_msglen )
{
- SSL_DEBUG_MSG( 1, ( "invalid fragment length: %d + 12 > %d",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid fragment length: %d + 12 > %d",
frag_len, ssl->in_msglen ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
- SSL_DEBUG_MSG( 2, ( "adding fragment, offset = %d, length = %d",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "adding fragment, offset = %d, length = %d",
frag_off, frag_len ) );
memcpy( msg + frag_off, ssl->in_msg + 12, frag_len );
@@ -2962,11 +2962,11 @@
*/
if( ssl_bitmask_check( bitmask, msg_len ) != 0 )
{
- SSL_DEBUG_MSG( 2, ( "message is not complete yet" ) );
- return( POLARSSL_ERR_NET_WANT_READ );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "message is not complete yet" ) );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
- SSL_DEBUG_MSG( 2, ( "handshake message completed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake message completed" ) );
if( frag_len + 12 < ssl->in_msglen )
{
@@ -2975,8 +2975,8 @@
* This case is not handled now because no know implementation does
* that and it's hard to test, so we prefer to fail cleanly for now.
*/
- SSL_DEBUG_MSG( 1, ( "last fragment not alone in its record" ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "last fragment not alone in its record" ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
if( ssl->in_left > ssl->next_record_offset )
@@ -2994,11 +2994,11 @@
ssl->next_record_offset = new_remain - ssl->in_hdr;
ssl->in_left = ssl->next_record_offset + remain_len;
- if( ssl->in_left > SSL_BUFFER_LEN -
+ if( ssl->in_left > MBEDTLS_SSL_BUFFER_LEN -
(size_t)( ssl->in_hdr - ssl->in_buf ) )
{
- SSL_DEBUG_MSG( 1, ( "reassembled message too large for buffer" ) );
- return( POLARSSL_ERR_SSL_BUFFER_TOO_SMALL );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "reassembled message too large for buffer" ) );
+ return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
}
memmove( new_remain, cur_remain, remain_len );
@@ -3006,36 +3006,36 @@
memcpy( ssl->in_msg, ssl->handshake->hs_msg, ssl->in_hslen );
- polarssl_free( ssl->handshake->hs_msg );
+ mbedtls_free( ssl->handshake->hs_msg );
ssl->handshake->hs_msg = NULL;
- SSL_DEBUG_BUF( 3, "reassembled handshake message",
+ MBEDTLS_SSL_DEBUG_BUF( 3, "reassembled handshake message",
ssl->in_msg, ssl->in_hslen );
return( 0 );
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
-static int ssl_prepare_handshake_record( ssl_context *ssl )
+static int ssl_prepare_handshake_record( mbedtls_ssl_context *ssl )
{
- if( ssl->in_msglen < ssl_hs_hdr_len( ssl ) )
+ if( ssl->in_msglen < mbedtls_ssl_hs_hdr_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "handshake message too short: %d",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake message too short: %d",
ssl->in_msglen ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
- ssl->in_hslen = ssl_hs_hdr_len( ssl ) + (
+ ssl->in_hslen = mbedtls_ssl_hs_hdr_len( ssl ) + (
( ssl->in_msg[1] << 16 ) |
( ssl->in_msg[2] << 8 ) |
ssl->in_msg[3] );
- SSL_DEBUG_MSG( 3, ( "handshake message: msglen ="
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "handshake message: msglen ="
" %d, type = %d, hslen = %d",
ssl->in_msglen, ssl->in_msg[0], ssl->in_hslen ) );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
int ret;
unsigned int recv_msg_seq = ( ssl->in_msg[4] << 8 ) | ssl->in_msg[5];
@@ -3048,28 +3048,28 @@
* too many retransmissions.
* Besides, No sane server ever retransmits HelloVerifyRequest */
if( recv_msg_seq == ssl->handshake->in_flight_start_seq - 1 &&
- ssl->in_msg[0] != SSL_HS_HELLO_VERIFY_REQUEST )
+ ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST )
{
- SSL_DEBUG_MSG( 2, ( "received message from last flight, "
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "received message from last flight, "
"message_seq = %d, start_of_flight = %d",
recv_msg_seq,
ssl->handshake->in_flight_start_seq ) );
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_resend", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_resend", ret );
return( ret );
}
}
else
{
- SSL_DEBUG_MSG( 2, ( "dropping out-of-sequence message: "
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "dropping out-of-sequence message: "
"message_seq = %d, expected = %d",
recv_msg_seq,
ssl->handshake->in_msg_seq ) );
}
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
/* Wait until message completion to increment in_msg_seq */
@@ -3080,30 +3080,30 @@
memcmp( ssl->in_msg + 9, ssl->in_msg + 1, 3 ) != 0 ||
( ssl->handshake != NULL && ssl->handshake->hs_msg != NULL ) )
{
- SSL_DEBUG_MSG( 2, ( "found fragmented DTLS handshake message" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "found fragmented DTLS handshake message" ) );
if( ( ret = ssl_reassemble_dtls_handshake( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_reassemble_dtls_handshake", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_reassemble_dtls_handshake", ret );
return( ret );
}
}
}
else
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
/* With TLS we don't handle fragmentation (for now) */
if( ssl->in_msglen < ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "TLS handshake fragmentation not supported" ) );
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "TLS handshake fragmentation not supported" ) );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
- if( ssl->state != SSL_HANDSHAKE_OVER )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
ssl->handshake->update_checksum( ssl, ssl->in_msg, ssl->in_hslen );
/* Handshake message is complete, increment counter */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL )
{
ssl->handshake->in_msg_seq++;
@@ -3123,8 +3123,8 @@
* in_window is set. The only exception is the initial state (record number 0
* not seen yet).
*/
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
-static void ssl_dtls_replay_reset( ssl_context *ssl )
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+static void ssl_dtls_replay_reset( mbedtls_ssl_context *ssl )
{
ssl->in_window_top = 0;
ssl->in_window = 0;
@@ -3143,12 +3143,12 @@
/*
* Return 0 if sequence number is acceptable, -1 otherwise
*/
-int ssl_dtls_replay_check( ssl_context *ssl )
+int mbedtls_ssl_dtls_replay_check( mbedtls_ssl_context *ssl )
{
uint64_t rec_seqnum = ssl_load_six_bytes( ssl->in_ctr + 2 );
uint64_t bit;
- if( ssl->anti_replay == SSL_ANTI_REPLAY_DISABLED )
+ if( ssl->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED )
return( 0 );
if( rec_seqnum > ssl->in_window_top )
@@ -3168,11 +3168,11 @@
/*
* Update replay window on new validated record
*/
-void ssl_dtls_replay_update( ssl_context *ssl )
+void mbedtls_ssl_dtls_replay_update( mbedtls_ssl_context *ssl )
{
uint64_t rec_seqnum = ssl_load_six_bytes( ssl->in_ctr + 2 );
- if( ssl->anti_replay == SSL_ANTI_REPLAY_DISABLED )
+ if( ssl->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED )
return;
if( rec_seqnum > ssl->in_window_top )
@@ -3199,7 +3199,7 @@
ssl->in_window |= (uint64_t) 1 << bit;
}
}
-#endif /* POLARSSL_SSL_DTLS_ANTI_REPLAY */
+#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
/*
* ContentType type;
@@ -3208,64 +3208,64 @@
* uint48 sequence_number; // DTLS only
* uint16 length;
*/
-static int ssl_parse_record_header( ssl_context *ssl )
+static int ssl_parse_record_header( mbedtls_ssl_context *ssl )
{
int ret;
int major_ver, minor_ver;
- SSL_DEBUG_BUF( 4, "input record header", ssl->in_hdr, ssl_hdr_len( ssl ) );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "input record header", ssl->in_hdr, mbedtls_ssl_hdr_len( ssl ) );
ssl->in_msgtype = ssl->in_hdr[0];
ssl->in_msglen = ( ssl->in_len[0] << 8 ) | ssl->in_len[1];
- ssl_read_version( &major_ver, &minor_ver, ssl->transport, ssl->in_hdr + 1 );
+ mbedtls_ssl_read_version( &major_ver, &minor_ver, ssl->transport, ssl->in_hdr + 1 );
- SSL_DEBUG_MSG( 3, ( "input record: msgtype = %d, "
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "input record: msgtype = %d, "
"version = [%d:%d], msglen = %d",
ssl->in_msgtype,
major_ver, minor_ver, ssl->in_msglen ) );
/* Check record type */
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE &&
- ssl->in_msgtype != SSL_MSG_ALERT &&
- ssl->in_msgtype != SSL_MSG_CHANGE_CIPHER_SPEC &&
- ssl->in_msgtype != SSL_MSG_APPLICATION_DATA )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE &&
+ ssl->in_msgtype != MBEDTLS_SSL_MSG_ALERT &&
+ ssl->in_msgtype != MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC &&
+ ssl->in_msgtype != MBEDTLS_SSL_MSG_APPLICATION_DATA )
{
- SSL_DEBUG_MSG( 1, ( "unknown record type" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "unknown record type" ) );
- if( ( ret = ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_UNEXPECTED_MESSAGE ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE ) ) != 0 )
{
return( ret );
}
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Drop unexpected ChangeCipherSpec messages */
- if( ssl->in_msgtype == SSL_MSG_CHANGE_CIPHER_SPEC &&
- ssl->state != SSL_CLIENT_CHANGE_CIPHER_SPEC &&
- ssl->state != SSL_SERVER_CHANGE_CIPHER_SPEC )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC &&
+ ssl->state != MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC &&
+ ssl->state != MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC )
{
- SSL_DEBUG_MSG( 1, ( "dropping unexpected ChangeCipherSpec" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "dropping unexpected ChangeCipherSpec" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
/* Drop unexpected ApplicationData records,
* except at the beginning of renegotiations */
- if( ssl->in_msgtype == SSL_MSG_APPLICATION_DATA &&
- ssl->state != SSL_HANDSHAKE_OVER
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- && ! ( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS &&
- ssl->state == SSL_SERVER_HELLO )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA &&
+ ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ && ! ( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
+ ssl->state == MBEDTLS_SSL_SERVER_HELLO )
#endif
)
{
- SSL_DEBUG_MSG( 1, ( "dropping unexpected ApplicationData" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "dropping unexpected ApplicationData" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
}
#endif
@@ -3273,85 +3273,85 @@
/* Check version */
if( major_ver != ssl->major_ver )
{
- SSL_DEBUG_MSG( 1, ( "major version mismatch" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "major version mismatch" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
if( minor_ver > ssl->max_minor_ver )
{
- SSL_DEBUG_MSG( 1, ( "minor version mismatch" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "minor version mismatch" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
/* Check epoch (and sequence number) with DTLS */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
unsigned int rec_epoch = ( ssl->in_ctr[0] << 8 ) | ssl->in_ctr[1];
if( rec_epoch != ssl->in_epoch )
{
- SSL_DEBUG_MSG( 1, ( "record from another epoch: "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "record from another epoch: "
"expected %d, received %d",
ssl->in_epoch, rec_epoch ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
- if( ssl_dtls_replay_check( ssl ) != 0 )
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+ if( mbedtls_ssl_dtls_replay_check( ssl ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "replayed record" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "replayed record" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
#endif
}
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
/* Check length against the size of our buffer */
- if( ssl->in_msglen > SSL_BUFFER_LEN
+ if( ssl->in_msglen > MBEDTLS_SSL_BUFFER_LEN
- (size_t)( ssl->in_msg - ssl->in_buf ) )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
/* Check length against bounds of the current transform and version */
if( ssl->transform_in == NULL )
{
if( ssl->in_msglen < 1 ||
- ssl->in_msglen > SSL_MAX_CONTENT_LEN )
+ ssl->in_msglen > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
}
else
{
if( ssl->in_msglen < ssl->transform_in->minlen )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 &&
- ssl->in_msglen > ssl->transform_in->minlen + SSL_MAX_CONTENT_LEN )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 &&
+ ssl->in_msglen > ssl->transform_in->minlen + MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
/*
* TLS encrypted messages can have up to 256 bytes of padding
*/
- if( ssl->minor_ver >= SSL_MINOR_VERSION_1 &&
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 &&
ssl->in_msglen > ssl->transform_in->minlen +
- SSL_MAX_CONTENT_LEN + 256 )
+ MBEDTLS_SSL_MAX_CONTENT_LEN + 256 )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
#endif
}
@@ -3362,54 +3362,54 @@
/*
* If applicable, decrypt (and decompress) record content
*/
-static int ssl_prepare_record_content( ssl_context *ssl )
+static int ssl_prepare_record_content( mbedtls_ssl_context *ssl )
{
int ret, done = 0;
- SSL_DEBUG_BUF( 4, "input record from network",
- ssl->in_hdr, ssl_hdr_len( ssl ) + ssl->in_msglen );
+ MBEDTLS_SSL_DEBUG_BUF( 4, "input record from network",
+ ssl->in_hdr, mbedtls_ssl_hdr_len( ssl ) + ssl->in_msglen );
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_read != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_read != NULL )
{
- SSL_DEBUG_MSG( 2, ( "going for ssl_hw_record_read()" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_read()" ) );
- ret = ssl_hw_record_read( ssl );
- if( ret != 0 && ret != POLARSSL_ERR_SSL_HW_ACCEL_FALLTHROUGH )
+ ret = mbedtls_ssl_hw_record_read( ssl );
+ if( ret != 0 && ret != MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_read", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_read", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
if( ret == 0 )
done = 1;
}
-#endif /* POLARSSL_SSL_HW_RECORD_ACCEL */
+#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
if( !done && ssl->transform_in != NULL )
{
if( ( ret = ssl_decrypt_buf( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_decrypt_buf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_decrypt_buf", ret );
return( ret );
}
- SSL_DEBUG_BUF( 4, "input payload after decrypt",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "input payload after decrypt",
ssl->in_msg, ssl->in_msglen );
- if( ssl->in_msglen > SSL_MAX_CONTENT_LEN )
+ if( ssl->in_msglen > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- SSL_DEBUG_MSG( 1, ( "bad message length" ) );
- return( POLARSSL_ERR_SSL_INVALID_RECORD );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad message length" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
}
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
if( ssl->transform_in != NULL &&
- ssl->session_in->compression == SSL_COMPRESS_DEFLATE )
+ ssl->session_in->compression == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
if( ( ret = ssl_decompress_buf( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_decompress_buf", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_decompress_buf", ret );
return( ret );
}
@@ -3417,19 +3417,19 @@
ssl->in_len[0] = (unsigned char)( ssl->in_msglen >> 8 );
ssl->in_len[1] = (unsigned char)( ssl->in_msglen );
}
-#endif /* POLARSSL_ZLIB_SUPPORT */
+#endif /* MBEDTLS_ZLIB_SUPPORT */
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
- ssl_dtls_replay_update( ssl );
+ mbedtls_ssl_dtls_replay_update( ssl );
}
#endif
return( 0 );
}
-static void ssl_handshake_wrapup_free_hs_transform( ssl_context *ssl );
+static void ssl_handshake_wrapup_free_hs_transform( mbedtls_ssl_context *ssl );
/*
* Read a record.
@@ -3437,11 +3437,11 @@
* For DTLS, silently ignore invalid records (RFC 4.1.2.7.)
* and continue reading until a valid record is found.
*/
-int ssl_read_record( ssl_context *ssl )
+int mbedtls_ssl_read_record( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> read record" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> read record" ) );
if( ssl->in_hslen != 0 && ssl->in_hslen < ssl->in_msglen )
{
@@ -3453,7 +3453,7 @@
memmove( ssl->in_msg, ssl->in_msg + ssl->in_hslen,
ssl->in_msglen );
- SSL_DEBUG_BUF( 4, "remaining content in record",
+ MBEDTLS_SSL_DEBUG_BUF( 4, "remaining content in record",
ssl->in_msg, ssl->in_msglen );
if( ( ret = ssl_prepare_handshake_record( ssl ) ) != 0 )
@@ -3467,19 +3467,19 @@
/*
* Read the record header and parse it
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
read_record_header:
#endif
- if( ( ret = ssl_fetch_input( ssl, ssl_hdr_len( ssl ) ) ) != 0 )
+ if( ( ret = mbedtls_ssl_fetch_input( ssl, mbedtls_ssl_hdr_len( ssl ) ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_fetch_input", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
if( ( ret = ssl_parse_record_header( ssl ) ) != 0 )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Ignore bad record and get next one; drop the whole datagram
* since current header cannot be trusted to find the next record
@@ -3487,7 +3487,7 @@
ssl->next_record_offset = 0;
ssl->in_left = 0;
- SSL_DEBUG_MSG( 1, ( "discarding invalid record (header)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "discarding invalid record (header)" ) );
goto read_record_header;
}
#endif
@@ -3497,40 +3497,40 @@
/*
* Read and optionally decrypt the message contents
*/
- if( ( ret = ssl_fetch_input( ssl,
- ssl_hdr_len( ssl ) + ssl->in_msglen ) ) != 0 )
+ if( ( ret = mbedtls_ssl_fetch_input( ssl,
+ mbedtls_ssl_hdr_len( ssl ) + ssl->in_msglen ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_fetch_input", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
/* Done reading this record, get ready for the next one */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl->next_record_offset = ssl->in_msglen + ssl_hdr_len( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ ssl->next_record_offset = ssl->in_msglen + mbedtls_ssl_hdr_len( ssl );
else
#endif
ssl->in_left = 0;
if( ( ret = ssl_prepare_record_content( ssl ) ) != 0 )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Silently discard invalid records */
- if( ret == POLARSSL_ERR_SSL_INVALID_RECORD ||
- ret == POLARSSL_ERR_SSL_INVALID_MAC )
+ if( ret == MBEDTLS_ERR_SSL_INVALID_RECORD ||
+ ret == MBEDTLS_ERR_SSL_INVALID_MAC )
{
-#if defined(POLARSSL_SSL_DTLS_BADMAC_LIMIT)
+#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
if( ssl->badmac_limit != 0 &&
++ssl->badmac_seen >= ssl->badmac_limit )
{
- SSL_DEBUG_MSG( 1, ( "too many records with bad MAC" ) );
- return( POLARSSL_ERR_SSL_INVALID_MAC );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "too many records with bad MAC" ) );
+ return( MBEDTLS_ERR_SSL_INVALID_MAC );
}
#endif
- SSL_DEBUG_MSG( 1, ( "discarding invalid record (mac)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "discarding invalid record (mac)" ) );
goto read_record_header;
}
@@ -3540,12 +3540,12 @@
#endif
{
/* Error out (and send alert) on invalid records */
-#if defined(POLARSSL_SSL_ALL_ALERT_MESSAGES)
- if( ret == POLARSSL_ERR_SSL_INVALID_MAC )
+#if defined(MBEDTLS_SSL_ALL_ALERT_MESSAGES)
+ if( ret == MBEDTLS_ERR_SSL_INVALID_MAC )
{
- ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_BAD_RECORD_MAC );
+ mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC );
}
#endif
return( ret );
@@ -3567,23 +3567,23 @@
* finishes the current handshake first, avoiding the new ClientHello
* being mistaken for an ancient message in the current handshake.
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake != NULL &&
- ssl->state == SSL_HANDSHAKE_OVER )
+ ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
{
- if( ssl->in_msgtype == SSL_MSG_HANDSHAKE &&
- ssl->in_msg[0] == SSL_HS_FINISHED )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
+ ssl->in_msg[0] == MBEDTLS_SSL_HS_FINISHED )
{
- SSL_DEBUG_MSG( 2, ( "received retransmit of last flight" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "received retransmit of last flight" ) );
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_resend", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_resend", ret );
return( ret );
}
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
else
{
@@ -3595,47 +3595,47 @@
/*
* Handle particular types of records
*/
- if( ssl->in_msgtype == SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE )
{
if( ( ret = ssl_prepare_handshake_record( ssl ) ) != 0 )
return( ret );
}
- if( ssl->in_msgtype == SSL_MSG_ALERT )
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT )
{
- SSL_DEBUG_MSG( 2, ( "got an alert message, type: [%d:%d]",
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "got an alert message, type: [%d:%d]",
ssl->in_msg[0], ssl->in_msg[1] ) );
/*
* Ignore non-fatal alerts, except close_notify
*/
- if( ssl->in_msg[0] == SSL_ALERT_LEVEL_FATAL )
+ if( ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_FATAL )
{
- SSL_DEBUG_MSG( 1, ( "is a fatal alert message (msg %d)",
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "is a fatal alert message (msg %d)",
ssl->in_msg[1] ) );
- return( POLARSSL_ERR_SSL_FATAL_ALERT_MESSAGE );
+ return( MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE );
}
- if( ssl->in_msg[0] == SSL_ALERT_LEVEL_WARNING &&
- ssl->in_msg[1] == SSL_ALERT_MSG_CLOSE_NOTIFY )
+ if( ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_WARNING &&
+ ssl->in_msg[1] == MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY )
{
- SSL_DEBUG_MSG( 2, ( "is a close notify message" ) );
- return( POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "is a close notify message" ) );
+ return( MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY );
}
}
- SSL_DEBUG_MSG( 2, ( "<= read record" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= read record" ) );
return( 0 );
}
-int ssl_send_fatal_handshake_failure( ssl_context *ssl )
+int mbedtls_ssl_send_fatal_handshake_failure( mbedtls_ssl_context *ssl )
{
int ret;
- if( ( ret = ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_FATAL,
- SSL_ALERT_MSG_HANDSHAKE_FAILURE ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_FATAL,
+ MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE ) ) != 0 )
{
return( ret );
}
@@ -3643,26 +3643,26 @@
return( 0 );
}
-int ssl_send_alert_message( ssl_context *ssl,
+int mbedtls_ssl_send_alert_message( mbedtls_ssl_context *ssl,
unsigned char level,
unsigned char message )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> send alert message" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> send alert message" ) );
- ssl->out_msgtype = SSL_MSG_ALERT;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_ALERT;
ssl->out_msglen = 2;
ssl->out_msg[0] = level;
ssl->out_msg[1] = message;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= send alert message" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= send alert message" ) );
return( 0 );
}
@@ -3670,110 +3670,110 @@
/*
* Handshake functions
*/
-#if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) && \
- !defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
-int ssl_write_certificate( ssl_context *ssl )
+#if !defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) && \
+ !defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+int mbedtls_ssl_write_certificate( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
-int ssl_parse_certificate( ssl_context *ssl )
+int mbedtls_ssl_parse_certificate( mbedtls_ssl_context *ssl )
{
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else
-int ssl_write_certificate( ssl_context *ssl )
+int mbedtls_ssl_write_certificate( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, n;
- const x509_crt *crt;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_x509_crt *crt;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
ssl->state++;
return( 0 );
}
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
if( ssl->client_auth == 0 )
{
- SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate" ) );
ssl->state++;
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
/*
* If using SSLv3 and got no cert, send an Alert message
* (otherwise an empty Certificate message will be sent).
*/
- if( ssl_own_cert( ssl ) == NULL &&
- ssl->minor_ver == SSL_MINOR_VERSION_0 )
+ if( mbedtls_ssl_own_cert( ssl ) == NULL &&
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl->out_msglen = 2;
- ssl->out_msgtype = SSL_MSG_ALERT;
- ssl->out_msg[0] = SSL_ALERT_LEVEL_WARNING;
- ssl->out_msg[1] = SSL_ALERT_MSG_NO_CERT;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_ALERT;
+ ssl->out_msg[0] = MBEDTLS_SSL_ALERT_LEVEL_WARNING;
+ ssl->out_msg[1] = MBEDTLS_SSL_ALERT_MSG_NO_CERT;
- SSL_DEBUG_MSG( 2, ( "got no certificate to send" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "got no certificate to send" ) );
goto write_msg;
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
}
-#endif /* POLARSSL_SSL_CLI_C */
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER )
+#endif /* MBEDTLS_SSL_CLI_C */
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
{
- if( ssl_own_cert( ssl ) == NULL )
+ if( mbedtls_ssl_own_cert( ssl ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "got no certificate to send" ) );
- return( POLARSSL_ERR_SSL_CERTIFICATE_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no certificate to send" ) );
+ return( MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED );
}
}
#endif
- SSL_DEBUG_CRT( 3, "own certificate", ssl_own_cert( ssl ) );
+ MBEDTLS_SSL_DEBUG_CRT( 3, "own certificate", mbedtls_ssl_own_cert( ssl ) );
/*
* 0 . 0 handshake type
@@ -3785,16 +3785,16 @@
* n+3 . ... upper level cert, etc.
*/
i = 7;
- crt = ssl_own_cert( ssl );
+ crt = mbedtls_ssl_own_cert( ssl );
while( crt != NULL )
{
n = crt->raw.len;
- if( n > SSL_MAX_CONTENT_LEN - 3 - i )
+ if( n > MBEDTLS_SSL_MAX_CONTENT_LEN - 3 - i )
{
- SSL_DEBUG_MSG( 1, ( "certificate too large, %d > %d",
- i + 3 + n, SSL_MAX_CONTENT_LEN ) );
- return( POLARSSL_ERR_SSL_CERTIFICATE_TOO_LARGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "certificate too large, %d > %d",
+ i + 3 + n, MBEDTLS_SSL_MAX_CONTENT_LEN ) );
+ return( MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE );
}
ssl->out_msg[i ] = (unsigned char)( n >> 16 );
@@ -3810,153 +3810,153 @@
ssl->out_msg[6] = (unsigned char)( ( i - 7 ) );
ssl->out_msglen = i;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_CERTIFICATE;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE;
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
write_msg:
#endif
ssl->state++;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate" ) );
return( ret );
}
-int ssl_parse_certificate( ssl_context *ssl )
+int mbedtls_ssl_parse_certificate( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, n;
- const ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
- SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
- if( ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK )
+ if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER &&
- ( ssl->authmode == SSL_VERIFY_NONE ||
- ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ) )
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ( ssl->authmode == MBEDTLS_SSL_VERIFY_NONE ||
+ ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ) )
{
- ssl->session_negotiate->verify_result = BADCERT_SKIP_VERIFY;
- SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
+ ssl->session_negotiate->verify_result = MBEDTLS_BADCERT_SKIP_VERIFY;
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate" ) );
ssl->state++;
return( 0 );
}
#endif
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
ssl->state++;
-#if defined(POLARSSL_SSL_SRV_C)
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_SRV_C)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
/*
* Check if the client sent an empty certificate
*/
- if( ssl->endpoint == SSL_IS_SERVER &&
- ssl->minor_ver == SSL_MINOR_VERSION_0 )
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
if( ssl->in_msglen == 2 &&
- ssl->in_msgtype == SSL_MSG_ALERT &&
- ssl->in_msg[0] == SSL_ALERT_LEVEL_WARNING &&
- ssl->in_msg[1] == SSL_ALERT_MSG_NO_CERT )
+ ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT &&
+ ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_WARNING &&
+ ssl->in_msg[1] == MBEDTLS_SSL_ALERT_MSG_NO_CERT )
{
- SSL_DEBUG_MSG( 1, ( "SSLv3 client has no certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "SSLv3 client has no certificate" ) );
- ssl->session_negotiate->verify_result = BADCERT_MISSING;
- if( ssl->authmode == SSL_VERIFY_OPTIONAL )
+ ssl->session_negotiate->verify_result = MBEDTLS_BADCERT_MISSING;
+ if( ssl->authmode == MBEDTLS_SSL_VERIFY_OPTIONAL )
return( 0 );
else
- return( POLARSSL_ERR_SSL_NO_CLIENT_CERTIFICATE );
+ return( MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE );
}
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->endpoint == SSL_IS_SERVER &&
- ssl->minor_ver != SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
- if( ssl->in_hslen == 3 + ssl_hs_hdr_len( ssl ) &&
- ssl->in_msgtype == SSL_MSG_HANDSHAKE &&
- ssl->in_msg[0] == SSL_HS_CERTIFICATE &&
- memcmp( ssl->in_msg + ssl_hs_hdr_len( ssl ), "\0\0\0", 3 ) == 0 )
+ if( ssl->in_hslen == 3 + mbedtls_ssl_hs_hdr_len( ssl ) &&
+ ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
+ ssl->in_msg[0] == MBEDTLS_SSL_HS_CERTIFICATE &&
+ memcmp( ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl ), "\0\0\0", 3 ) == 0 )
{
- SSL_DEBUG_MSG( 1, ( "TLSv1 client has no certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "TLSv1 client has no certificate" ) );
- ssl->session_negotiate->verify_result = BADCERT_MISSING;
- if( ssl->authmode == SSL_VERIFY_REQUIRED )
- return( POLARSSL_ERR_SSL_NO_CLIENT_CERTIFICATE );
+ ssl->session_negotiate->verify_result = MBEDTLS_BADCERT_MISSING;
+ if( ssl->authmode == MBEDTLS_SSL_VERIFY_REQUIRED )
+ return( MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE );
else
return( 0 );
}
}
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 || \
- POLARSSL_SSL_PROTO_TLS1_2 */
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
+ MBEDTLS_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_SRV_C */
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
- if( ssl->in_msg[0] != SSL_HS_CERTIFICATE ||
- ssl->in_hslen < ssl_hs_hdr_len( ssl ) + 3 + 3 )
+ if( ssl->in_msg[0] != MBEDTLS_SSL_HS_CERTIFICATE ||
+ ssl->in_hslen < mbedtls_ssl_hs_hdr_len( ssl ) + 3 + 3 )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
- i = ssl_hs_hdr_len( ssl );
+ i = mbedtls_ssl_hs_hdr_len( ssl );
/*
- * Same message structure as in ssl_write_certificate()
+ * Same message structure as in mbedtls_ssl_write_certificate()
*/
n = ( ssl->in_msg[i+1] << 8 ) | ssl->in_msg[i+2];
if( ssl->in_msg[i] != 0 ||
- ssl->in_hslen != n + 3 + ssl_hs_hdr_len( ssl ) )
+ ssl->in_hslen != n + 3 + mbedtls_ssl_hs_hdr_len( ssl ) )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
/* In case we tried to reuse a session but it failed */
if( ssl->session_negotiate->peer_cert != NULL )
{
- x509_crt_free( ssl->session_negotiate->peer_cert );
- polarssl_free( ssl->session_negotiate->peer_cert );
+ mbedtls_x509_crt_free( ssl->session_negotiate->peer_cert );
+ mbedtls_free( ssl->session_negotiate->peer_cert );
}
- if( ( ssl->session_negotiate->peer_cert = polarssl_malloc(
- sizeof( x509_crt ) ) ) == NULL )
+ if( ( ssl->session_negotiate->peer_cert = mbedtls_malloc(
+ sizeof( mbedtls_x509_crt ) ) ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed",
- sizeof( x509_crt ) ) );
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed",
+ sizeof( mbedtls_x509_crt ) ) );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
- x509_crt_init( ssl->session_negotiate->peer_cert );
+ mbedtls_x509_crt_init( ssl->session_negotiate->peer_cert );
i += 3;
@@ -3964,8 +3964,8 @@
{
if( ssl->in_msg[i] != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
n = ( (unsigned int) ssl->in_msg[i + 1] << 8 )
@@ -3974,35 +3974,35 @@
if( n < 128 || i + n > ssl->in_hslen )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
- ret = x509_crt_parse_der( ssl->session_negotiate->peer_cert,
+ ret = mbedtls_x509_crt_parse_der( ssl->session_negotiate->peer_cert,
ssl->in_msg + i, n );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, " x509_crt_parse_der", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, " mbedtls_x509_crt_parse_der", ret );
return( ret );
}
i += n;
}
- SSL_DEBUG_CRT( 3, "peer certificate", ssl->session_negotiate->peer_cert );
+ MBEDTLS_SSL_DEBUG_CRT( 3, "peer certificate", ssl->session_negotiate->peer_cert );
/*
* On client, make sure the server cert doesn't change during renego to
* avoid "triple handshake" attack: https://secure-resumption.com/
*/
-#if defined(POLARSSL_SSL_RENEGOTIATION) && defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT &&
- ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+#if defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT &&
+ ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
if( ssl->session->peer_cert == NULL )
{
- SSL_DEBUG_MSG( 1, ( "new server cert during renegotiation" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "new server cert during renegotiation" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
if( ssl->session->peer_cert->raw.len !=
@@ -4011,154 +4011,154 @@
ssl->session_negotiate->peer_cert->raw.p,
ssl->session->peer_cert->raw.len ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "server cert changed during renegotiation" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "server cert changed during renegotiation" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
}
}
-#endif /* POLARSSL_SSL_RENEGOTIATION && POLARSSL_SSL_CLI_C */
+#endif /* MBEDTLS_SSL_RENEGOTIATION && MBEDTLS_SSL_CLI_C */
- if( ssl->authmode != SSL_VERIFY_NONE )
+ if( ssl->authmode != MBEDTLS_SSL_VERIFY_NONE )
{
if( ssl->ca_chain == NULL )
{
- SSL_DEBUG_MSG( 1, ( "got no CA chain" ) );
- return( POLARSSL_ERR_SSL_CA_CHAIN_REQUIRED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no CA chain" ) );
+ return( MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED );
}
/*
* Main check: verify certificate
*/
- ret = x509_crt_verify( ssl->session_negotiate->peer_cert,
+ ret = mbedtls_x509_crt_verify( ssl->session_negotiate->peer_cert,
ssl->ca_chain, ssl->ca_crl, ssl->peer_cn,
&ssl->session_negotiate->verify_result,
ssl->f_vrfy, ssl->p_vrfy );
if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "x509_verify_cert", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "x509_verify_cert", ret );
}
/*
* Secondary checks: always done, but change 'ret' only if it was 0
*/
-#if defined(POLARSSL_SSL_SET_CURVES)
+#if defined(MBEDTLS_SSL_SET_CURVES)
{
- const pk_context *pk = &ssl->session_negotiate->peer_cert->pk;
+ const mbedtls_pk_context *pk = &ssl->session_negotiate->peer_cert->pk;
/* If certificate uses an EC key, make sure the curve is OK */
- if( pk_can_do( pk, POLARSSL_PK_ECKEY ) &&
- ! ssl_curve_is_acceptable( ssl, pk_ec( *pk )->grp.id ) )
+ if( mbedtls_pk_can_do( pk, MBEDTLS_PK_ECKEY ) &&
+ ! mbedtls_ssl_curve_is_acceptable( ssl, mbedtls_pk_ec( *pk )->grp.id ) )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate (EC key curve)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate (EC key curve)" ) );
if( ret == 0 )
- ret = POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE;
+ ret = MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE;
}
}
-#endif /* POLARSSL_SSL_SET_CURVES */
+#endif /* MBEDTLS_SSL_SET_CURVES */
- if( ssl_check_cert_usage( ssl->session_negotiate->peer_cert,
+ if( mbedtls_ssl_check_cert_usage( ssl->session_negotiate->peer_cert,
ciphersuite_info,
! ssl->endpoint ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad certificate (usage extensions)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate (usage extensions)" ) );
if( ret == 0 )
- ret = POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE;
+ ret = MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE;
}
- if( ssl->authmode != SSL_VERIFY_REQUIRED )
+ if( ssl->authmode != MBEDTLS_SSL_VERIFY_REQUIRED )
ret = 0;
}
- SSL_DEBUG_MSG( 2, ( "<= parse certificate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate" ) );
return( ret );
}
-#endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED
- !POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED
- !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED
- !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED
- !POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
- !POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED
- !POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#endif /* !MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED
+ !MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-int ssl_write_change_cipher_spec( ssl_context *ssl )
+int mbedtls_ssl_write_change_cipher_spec( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> write change cipher spec" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write change cipher spec" ) );
- ssl->out_msgtype = SSL_MSG_CHANGE_CIPHER_SPEC;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC;
ssl->out_msglen = 1;
ssl->out_msg[0] = 1;
ssl->state++;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write change cipher spec" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write change cipher spec" ) );
return( 0 );
}
-int ssl_parse_change_cipher_spec( ssl_context *ssl )
+int mbedtls_ssl_parse_change_cipher_spec( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> parse change cipher spec" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse change cipher spec" ) );
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_CHANGE_CIPHER_SPEC )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC )
{
- SSL_DEBUG_MSG( 1, ( "bad change cipher spec message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad change cipher spec message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
if( ssl->in_msglen != 1 || ssl->in_msg[0] != 1 )
{
- SSL_DEBUG_MSG( 1, ( "bad change cipher spec message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad change cipher spec message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC );
}
/*
* Switch to our negotiated transform and session parameters for inbound
* data.
*/
- SSL_DEBUG_MSG( 3, ( "switching to new transform spec for inbound data" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "switching to new transform spec for inbound data" ) );
ssl->transform_in = ssl->transform_negotiate;
ssl->session_in = ssl->session_negotiate;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
ssl_dtls_replay_reset( ssl );
#endif
/* Increment epoch */
if( ++ssl->in_epoch == 0 )
{
- SSL_DEBUG_MSG( 1, ( "DTLS epoch would wrap" ) );
- return( POLARSSL_ERR_SSL_COUNTER_WRAPPING );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "DTLS epoch would wrap" ) );
+ return( MBEDTLS_ERR_SSL_COUNTER_WRAPPING );
}
}
else
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
memset( ssl->in_ctr, 0, 8 );
/*
* Set the in_msg pointer to the correct location based on IV length
*/
- if( ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
{
ssl->in_msg = ssl->in_iv + ssl->transform_negotiate->ivlen -
ssl->transform_negotiate->fixed_ivlen;
@@ -4166,136 +4166,136 @@
else
ssl->in_msg = ssl->in_iv;
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_activate != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_activate != NULL )
{
- if( ( ret = ssl_hw_record_activate( ssl, SSL_CHANNEL_INBOUND ) ) != 0 )
+ if( ( ret = mbedtls_ssl_hw_record_activate( ssl, MBEDTLS_SSL_CHANNEL_INBOUND ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_activate", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_activate", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
#endif
ssl->state++;
- SSL_DEBUG_MSG( 2, ( "<= parse change cipher spec" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse change cipher spec" ) );
return( 0 );
}
-void ssl_optimize_checksum( ssl_context *ssl,
- const ssl_ciphersuite_t *ciphersuite_info )
+void mbedtls_ssl_optimize_checksum( mbedtls_ssl_context *ssl,
+ const mbedtls_ssl_ciphersuite_t *ciphersuite_info )
{
((void) ciphersuite_info);
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- if( ssl->minor_ver < SSL_MINOR_VERSION_3 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
ssl->handshake->update_checksum = ssl_update_checksum_md5sha1;
else
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA512_C)
- if( ciphersuite_info->mac == POLARSSL_MD_SHA384 )
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA512_C)
+ if( ciphersuite_info->mac == MBEDTLS_MD_SHA384 )
ssl->handshake->update_checksum = ssl_update_checksum_sha384;
else
#endif
-#if defined(POLARSSL_SHA256_C)
- if( ciphersuite_info->mac != POLARSSL_MD_SHA384 )
+#if defined(MBEDTLS_SHA256_C)
+ if( ciphersuite_info->mac != MBEDTLS_MD_SHA384 )
ssl->handshake->update_checksum = ssl_update_checksum_sha256;
else
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return;
}
}
-void ssl_reset_checksum( ssl_context *ssl )
+void mbedtls_ssl_reset_checksum( mbedtls_ssl_context *ssl )
{
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- md5_starts( &ssl->handshake->fin_md5 );
- sha1_starts( &ssl->handshake->fin_sha1 );
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ mbedtls_md5_starts( &ssl->handshake->fin_md5 );
+ mbedtls_sha1_starts( &ssl->handshake->fin_sha1 );
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
- sha256_starts( &ssl->handshake->fin_sha256, 0 );
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+ mbedtls_sha256_starts( &ssl->handshake->fin_sha256, 0 );
#endif
-#if defined(POLARSSL_SHA512_C)
- sha512_starts( &ssl->handshake->fin_sha512, 1 );
+#if defined(MBEDTLS_SHA512_C)
+ mbedtls_sha512_starts( &ssl->handshake->fin_sha512, 1 );
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}
-static void ssl_update_checksum_start( ssl_context *ssl,
+static void ssl_update_checksum_start( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- md5_update( &ssl->handshake->fin_md5 , buf, len );
- sha1_update( &ssl->handshake->fin_sha1, buf, len );
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ mbedtls_md5_update( &ssl->handshake->fin_md5 , buf, len );
+ mbedtls_sha1_update( &ssl->handshake->fin_sha1, buf, len );
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
- sha256_update( &ssl->handshake->fin_sha256, buf, len );
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+ mbedtls_sha256_update( &ssl->handshake->fin_sha256, buf, len );
#endif
-#if defined(POLARSSL_SHA512_C)
- sha512_update( &ssl->handshake->fin_sha512, buf, len );
+#if defined(MBEDTLS_SHA512_C)
+ mbedtls_sha512_update( &ssl->handshake->fin_sha512, buf, len );
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
-static void ssl_update_checksum_md5sha1( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+static void ssl_update_checksum_md5sha1( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
- md5_update( &ssl->handshake->fin_md5 , buf, len );
- sha1_update( &ssl->handshake->fin_sha1, buf, len );
+ mbedtls_md5_update( &ssl->handshake->fin_md5 , buf, len );
+ mbedtls_sha1_update( &ssl->handshake->fin_sha1, buf, len );
}
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
-static void ssl_update_checksum_sha256( ssl_context *ssl,
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+static void ssl_update_checksum_sha256( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
- sha256_update( &ssl->handshake->fin_sha256, buf, len );
+ mbedtls_sha256_update( &ssl->handshake->fin_sha256, buf, len );
}
#endif
-#if defined(POLARSSL_SHA512_C)
-static void ssl_update_checksum_sha384( ssl_context *ssl,
+#if defined(MBEDTLS_SHA512_C)
+static void ssl_update_checksum_sha384( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
- sha512_update( &ssl->handshake->fin_sha512, buf, len );
+ mbedtls_sha512_update( &ssl->handshake->fin_sha512, buf, len );
}
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
static void ssl_calc_finished_ssl(
- ssl_context *ssl, unsigned char *buf, int from )
+ mbedtls_ssl_context *ssl, unsigned char *buf, int from )
{
const char *sender;
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
unsigned char padbuf[48];
unsigned char md5sum[16];
unsigned char sha1sum[20];
- ssl_session *session = ssl->session_negotiate;
+ mbedtls_ssl_session *session = ssl->session_negotiate;
if( !session )
session = ssl->session;
- SSL_DEBUG_MSG( 2, ( "=> calc finished ssl" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc finished ssl" ) );
- memcpy( &md5 , &ssl->handshake->fin_md5 , sizeof(md5_context) );
- memcpy( &sha1, &ssl->handshake->fin_sha1, sizeof(sha1_context) );
+ memcpy( &mbedtls_md5 , &ssl->handshake->fin_md5 , sizeof(mbedtls_md5_context) );
+ memcpy( &mbedtls_sha1, &ssl->handshake->fin_sha1, sizeof(mbedtls_sha1_context) );
/*
* SSLv3:
@@ -4306,76 +4306,76 @@
* SHA1( handshake + sender + master + pad1 ) )
*/
-#if !defined(POLARSSL_MD5_ALT)
- SSL_DEBUG_BUF( 4, "finished md5 state", (unsigned char *)
- md5.state, sizeof( md5.state ) );
+#if !defined(MBEDTLS_MD5_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished mbedtls_md5 state", (unsigned char *)
+ mbedtls_md5.state, sizeof( mbedtls_md5.state ) );
#endif
-#if !defined(POLARSSL_SHA1_ALT)
- SSL_DEBUG_BUF( 4, "finished sha1 state", (unsigned char *)
- sha1.state, sizeof( sha1.state ) );
+#if !defined(MBEDTLS_SHA1_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished mbedtls_sha1 state", (unsigned char *)
+ mbedtls_sha1.state, sizeof( mbedtls_sha1.state ) );
#endif
- sender = ( from == SSL_IS_CLIENT ) ? "CLNT"
+ sender = ( from == MBEDTLS_SSL_IS_CLIENT ) ? "CLNT"
: "SRVR";
memset( padbuf, 0x36, 48 );
- md5_update( &md5, (const unsigned char *) sender, 4 );
- md5_update( &md5, session->master, 48 );
- md5_update( &md5, padbuf, 48 );
- md5_finish( &md5, md5sum );
+ mbedtls_md5_update( &mbedtls_md5, (const unsigned char *) sender, 4 );
+ mbedtls_md5_update( &mbedtls_md5, session->master, 48 );
+ mbedtls_md5_update( &mbedtls_md5, padbuf, 48 );
+ mbedtls_md5_finish( &mbedtls_md5, md5sum );
- sha1_update( &sha1, (const unsigned char *) sender, 4 );
- sha1_update( &sha1, session->master, 48 );
- sha1_update( &sha1, padbuf, 40 );
- sha1_finish( &sha1, sha1sum );
+ mbedtls_sha1_update( &mbedtls_sha1, (const unsigned char *) sender, 4 );
+ mbedtls_sha1_update( &mbedtls_sha1, session->master, 48 );
+ mbedtls_sha1_update( &mbedtls_sha1, padbuf, 40 );
+ mbedtls_sha1_finish( &mbedtls_sha1, sha1sum );
memset( padbuf, 0x5C, 48 );
- md5_starts( &md5 );
- md5_update( &md5, session->master, 48 );
- md5_update( &md5, padbuf, 48 );
- md5_update( &md5, md5sum, 16 );
- md5_finish( &md5, buf );
+ mbedtls_md5_starts( &mbedtls_md5 );
+ mbedtls_md5_update( &mbedtls_md5, session->master, 48 );
+ mbedtls_md5_update( &mbedtls_md5, padbuf, 48 );
+ mbedtls_md5_update( &mbedtls_md5, md5sum, 16 );
+ mbedtls_md5_finish( &mbedtls_md5, buf );
- sha1_starts( &sha1 );
- sha1_update( &sha1, session->master, 48 );
- sha1_update( &sha1, padbuf , 40 );
- sha1_update( &sha1, sha1sum, 20 );
- sha1_finish( &sha1, buf + 16 );
+ mbedtls_sha1_starts( &mbedtls_sha1 );
+ mbedtls_sha1_update( &mbedtls_sha1, session->master, 48 );
+ mbedtls_sha1_update( &mbedtls_sha1, padbuf , 40 );
+ mbedtls_sha1_update( &mbedtls_sha1, sha1sum, 20 );
+ mbedtls_sha1_finish( &mbedtls_sha1, buf + 16 );
- SSL_DEBUG_BUF( 3, "calc finished result", buf, 36 );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calc finished result", buf, 36 );
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
- polarssl_zeroize( padbuf, sizeof( padbuf ) );
- polarssl_zeroize( md5sum, sizeof( md5sum ) );
- polarssl_zeroize( sha1sum, sizeof( sha1sum ) );
+ mbedtls_zeroize( padbuf, sizeof( padbuf ) );
+ mbedtls_zeroize( md5sum, sizeof( md5sum ) );
+ mbedtls_zeroize( sha1sum, sizeof( sha1sum ) );
- SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
}
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1)
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1)
static void ssl_calc_finished_tls(
- ssl_context *ssl, unsigned char *buf, int from )
+ mbedtls_ssl_context *ssl, unsigned char *buf, int from )
{
int len = 12;
const char *sender;
- md5_context md5;
- sha1_context sha1;
+ mbedtls_md5_context mbedtls_md5;
+ mbedtls_sha1_context mbedtls_sha1;
unsigned char padbuf[36];
- ssl_session *session = ssl->session_negotiate;
+ mbedtls_ssl_session *session = ssl->session_negotiate;
if( !session )
session = ssl->session;
- SSL_DEBUG_MSG( 2, ( "=> calc finished tls" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc finished tls" ) );
- memcpy( &md5 , &ssl->handshake->fin_md5 , sizeof(md5_context) );
- memcpy( &sha1, &ssl->handshake->fin_sha1, sizeof(sha1_context) );
+ memcpy( &mbedtls_md5 , &ssl->handshake->fin_md5 , sizeof(mbedtls_md5_context) );
+ memcpy( &mbedtls_sha1, &ssl->handshake->fin_sha1, sizeof(mbedtls_sha1_context) );
/*
* TLSv1:
@@ -4383,54 +4383,54 @@
* MD5( handshake ) + SHA1( handshake ) )[0..11]
*/
-#if !defined(POLARSSL_MD5_ALT)
- SSL_DEBUG_BUF( 4, "finished md5 state", (unsigned char *)
- md5.state, sizeof( md5.state ) );
+#if !defined(MBEDTLS_MD5_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished mbedtls_md5 state", (unsigned char *)
+ mbedtls_md5.state, sizeof( mbedtls_md5.state ) );
#endif
-#if !defined(POLARSSL_SHA1_ALT)
- SSL_DEBUG_BUF( 4, "finished sha1 state", (unsigned char *)
- sha1.state, sizeof( sha1.state ) );
+#if !defined(MBEDTLS_SHA1_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished mbedtls_sha1 state", (unsigned char *)
+ mbedtls_sha1.state, sizeof( mbedtls_sha1.state ) );
#endif
- sender = ( from == SSL_IS_CLIENT )
+ sender = ( from == MBEDTLS_SSL_IS_CLIENT )
? "client finished"
: "server finished";
- md5_finish( &md5, padbuf );
- sha1_finish( &sha1, padbuf + 16 );
+ mbedtls_md5_finish( &mbedtls_md5, padbuf );
+ mbedtls_sha1_finish( &mbedtls_sha1, padbuf + 16 );
ssl->handshake->tls_prf( session->master, 48, sender,
padbuf, 36, buf, len );
- SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
- md5_free( &md5 );
- sha1_free( &sha1 );
+ mbedtls_md5_free( &mbedtls_md5 );
+ mbedtls_sha1_free( &mbedtls_sha1 );
- polarssl_zeroize( padbuf, sizeof( padbuf ) );
+ mbedtls_zeroize( padbuf, sizeof( padbuf ) );
- SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
}
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
static void ssl_calc_finished_tls_sha256(
- ssl_context *ssl, unsigned char *buf, int from )
+ mbedtls_ssl_context *ssl, unsigned char *buf, int from )
{
int len = 12;
const char *sender;
- sha256_context sha256;
+ mbedtls_sha256_context mbedtls_sha256;
unsigned char padbuf[32];
- ssl_session *session = ssl->session_negotiate;
+ mbedtls_ssl_session *session = ssl->session_negotiate;
if( !session )
session = ssl->session;
- SSL_DEBUG_MSG( 2, ( "=> calc finished tls sha256" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc finished tls mbedtls_sha256" ) );
- memcpy( &sha256, &ssl->handshake->fin_sha256, sizeof(sha256_context) );
+ memcpy( &mbedtls_sha256, &ssl->handshake->fin_sha256, sizeof(mbedtls_sha256_context) );
/*
* TLSv1.2:
@@ -4438,46 +4438,46 @@
* Hash( handshake ) )[0.11]
*/
-#if !defined(POLARSSL_SHA256_ALT)
- SSL_DEBUG_BUF( 4, "finished sha2 state", (unsigned char *)
- sha256.state, sizeof( sha256.state ) );
+#if !defined(MBEDTLS_SHA256_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished sha2 state", (unsigned char *)
+ mbedtls_sha256.state, sizeof( mbedtls_sha256.state ) );
#endif
- sender = ( from == SSL_IS_CLIENT )
+ sender = ( from == MBEDTLS_SSL_IS_CLIENT )
? "client finished"
: "server finished";
- sha256_finish( &sha256, padbuf );
+ mbedtls_sha256_finish( &mbedtls_sha256, padbuf );
ssl->handshake->tls_prf( session->master, 48, sender,
padbuf, 32, buf, len );
- SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
- sha256_free( &sha256 );
+ mbedtls_sha256_free( &mbedtls_sha256 );
- polarssl_zeroize( padbuf, sizeof( padbuf ) );
+ mbedtls_zeroize( padbuf, sizeof( padbuf ) );
- SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
}
-#endif /* POLARSSL_SHA256_C */
+#endif /* MBEDTLS_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
+#if defined(MBEDTLS_SHA512_C)
static void ssl_calc_finished_tls_sha384(
- ssl_context *ssl, unsigned char *buf, int from )
+ mbedtls_ssl_context *ssl, unsigned char *buf, int from )
{
int len = 12;
const char *sender;
- sha512_context sha512;
+ mbedtls_sha512_context mbedtls_sha512;
unsigned char padbuf[48];
- ssl_session *session = ssl->session_negotiate;
+ mbedtls_ssl_session *session = ssl->session_negotiate;
if( !session )
session = ssl->session;
- SSL_DEBUG_MSG( 2, ( "=> calc finished tls sha384" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc finished tls sha384" ) );
- memcpy( &sha512, &ssl->handshake->fin_sha512, sizeof(sha512_context) );
+ memcpy( &mbedtls_sha512, &ssl->handshake->fin_sha512, sizeof(mbedtls_sha512_context) );
/*
* TLSv1.2:
@@ -4485,40 +4485,40 @@
* Hash( handshake ) )[0.11]
*/
-#if !defined(POLARSSL_SHA512_ALT)
- SSL_DEBUG_BUF( 4, "finished sha512 state", (unsigned char *)
- sha512.state, sizeof( sha512.state ) );
+#if !defined(MBEDTLS_SHA512_ALT)
+ MBEDTLS_SSL_DEBUG_BUF( 4, "finished mbedtls_sha512 state", (unsigned char *)
+ mbedtls_sha512.state, sizeof( mbedtls_sha512.state ) );
#endif
- sender = ( from == SSL_IS_CLIENT )
+ sender = ( from == MBEDTLS_SSL_IS_CLIENT )
? "client finished"
: "server finished";
- sha512_finish( &sha512, padbuf );
+ mbedtls_sha512_finish( &mbedtls_sha512, padbuf );
ssl->handshake->tls_prf( session->master, 48, sender,
padbuf, 48, buf, len );
- SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
+ MBEDTLS_SSL_DEBUG_BUF( 3, "calc finished result", buf, len );
- sha512_free( &sha512 );
+ mbedtls_sha512_free( &mbedtls_sha512 );
- polarssl_zeroize( padbuf, sizeof( padbuf ) );
+ mbedtls_zeroize( padbuf, sizeof( padbuf ) );
- SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= calc finished" ) );
}
-#endif /* POLARSSL_SHA512_C */
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SHA512_C */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
-static void ssl_handshake_wrapup_free_hs_transform( ssl_context *ssl )
+static void ssl_handshake_wrapup_free_hs_transform( mbedtls_ssl_context *ssl )
{
- SSL_DEBUG_MSG( 3, ( "=> handshake wrapup: final free" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "=> handshake wrapup: final free" ) );
/*
* Free our handshake params
*/
- ssl_handshake_free( ssl->handshake );
- polarssl_free( ssl->handshake );
+ mbedtls_ssl_handshake_free( ssl->handshake );
+ mbedtls_free( ssl->handshake );
ssl->handshake = NULL;
/*
@@ -4526,25 +4526,25 @@
*/
if( ssl->transform )
{
- ssl_transform_free( ssl->transform );
- polarssl_free( ssl->transform );
+ mbedtls_ssl_transform_free( ssl->transform );
+ mbedtls_free( ssl->transform );
}
ssl->transform = ssl->transform_negotiate;
ssl->transform_negotiate = NULL;
- SSL_DEBUG_MSG( 3, ( "<= handshake wrapup: final free" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "<= handshake wrapup: final free" ) );
}
-void ssl_handshake_wrapup( ssl_context *ssl )
+void mbedtls_ssl_handshake_wrapup( mbedtls_ssl_context *ssl )
{
int resume = ssl->handshake->resume;
- SSL_DEBUG_MSG( 3, ( "=> handshake wrapup" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "=> handshake wrapup" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->renego_status == SSL_RENEGOTIATION_IN_PROGRESS )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
- ssl->renego_status = SSL_RENEGOTIATION_DONE;
+ ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_DONE;
ssl->renego_records_seen = 0;
}
#endif
@@ -4554,14 +4554,14 @@
*/
if( ssl->session )
{
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
/* RFC 7366 3.1: keep the EtM state */
ssl->session_negotiate->encrypt_then_mac =
ssl->session->encrypt_then_mac;
#endif
- ssl_session_free( ssl->session );
- polarssl_free( ssl->session );
+ mbedtls_ssl_session_free( ssl->session );
+ mbedtls_free( ssl->session );
}
ssl->session = ssl->session_negotiate;
ssl->session_negotiate = NULL;
@@ -4574,11 +4574,11 @@
resume == 0 )
{
if( ssl->f_set_cache( ssl->p_set_cache, ssl->session ) != 0 )
- SSL_DEBUG_MSG( 1, ( "cache did not store session" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "cache did not store session" ) );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->flight != NULL )
{
/* Cancel handshake timer */
@@ -4586,7 +4586,7 @@
/* Keep last flight around in case we need to resend it:
* we need the handshake and transform structures for that */
- SSL_DEBUG_MSG( 3, ( "skip freeing handshake and transform" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "skip freeing handshake and transform" ) );
}
else
#endif
@@ -4594,19 +4594,19 @@
ssl->state++;
- SSL_DEBUG_MSG( 3, ( "<= handshake wrapup" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "<= handshake wrapup" ) );
}
-int ssl_write_finished( ssl_context *ssl )
+int mbedtls_ssl_write_finished( mbedtls_ssl_context *ssl )
{
int ret, hash_len;
- SSL_DEBUG_MSG( 2, ( "=> write finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write finished" ) );
/*
* Set the out_msg pointer to the correct location based on IV length
*/
- if( ssl->minor_ver >= SSL_MINOR_VERSION_2 )
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_2 )
{
ssl->out_msg = ssl->out_iv + ssl->transform_negotiate->ivlen -
ssl->transform_negotiate->fixed_ivlen;
@@ -4617,16 +4617,16 @@
ssl->handshake->calc_finished( ssl, ssl->out_msg + 4, ssl->endpoint );
// TODO TLS/1.2 Hash length is determined by cipher suite (Page 63)
- hash_len = ( ssl->minor_ver == SSL_MINOR_VERSION_0 ) ? 36 : 12;
+ hash_len = ( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ) ? 36 : 12;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->verify_data_len = hash_len;
memcpy( ssl->own_verify_data, ssl->out_msg + 4, hash_len );
#endif
ssl->out_msglen = 4 + hash_len;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_FINISHED;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_FINISHED;
/*
* In case of session resuming, invert the client and server
@@ -4634,13 +4634,13 @@
*/
if( ssl->handshake->resume != 0 )
{
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
- ssl->state = SSL_HANDSHAKE_WRAPUP;
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
+ ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
#endif
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER )
- ssl->state = SSL_CLIENT_CHANGE_CIPHER_SPEC;
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
+ ssl->state = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
#endif
}
else
@@ -4650,10 +4650,10 @@
* Switch to our negotiated transform and session parameters for outbound
* data.
*/
- SSL_DEBUG_MSG( 3, ( "switching to new transform spec for outbound data" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "switching to new transform spec for outbound data" ) );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
unsigned char i;
@@ -4672,181 +4672,181 @@
/* The loop goes to its end iff the counter is wrapping */
if( i == 0 )
{
- SSL_DEBUG_MSG( 1, ( "DTLS epoch would wrap" ) );
- return( POLARSSL_ERR_SSL_COUNTER_WRAPPING );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "DTLS epoch would wrap" ) );
+ return( MBEDTLS_ERR_SSL_COUNTER_WRAPPING );
}
}
else
-#endif /* POLARSSL_SSL_PROTO_DTLS */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
memset( ssl->out_ctr, 0, 8 );
ssl->transform_out = ssl->transform_negotiate;
ssl->session_out = ssl->session_negotiate;
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_activate != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_activate != NULL )
{
- if( ( ret = ssl_hw_record_activate( ssl, SSL_CHANNEL_OUTBOUND ) ) != 0 )
+ if( ( ret = mbedtls_ssl_hw_record_activate( ssl, MBEDTLS_SSL_CHANNEL_OUTBOUND ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_activate", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_activate", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
#endif
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_send_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_send_flight_completed( ssl );
#endif
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write finished" ) );
return( 0 );
}
-#if defined(POLARSSL_SSL_PROTO_SSL3)
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
#define SSL_MAX_HASH_LEN 36
#else
#define SSL_MAX_HASH_LEN 12
#endif
-int ssl_parse_finished( ssl_context *ssl )
+int mbedtls_ssl_parse_finished( mbedtls_ssl_context *ssl )
{
int ret;
unsigned int hash_len;
unsigned char buf[SSL_MAX_HASH_LEN];
- SSL_DEBUG_MSG( 2, ( "=> parse finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse finished" ) );
ssl->handshake->calc_finished( ssl, buf, ssl->endpoint ^ 1 );
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
- if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
/* There is currently no ciphersuite using another length with TLS 1.2 */
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
hash_len = 36;
else
#endif
hash_len = 12;
- if( ssl->in_msg[0] != SSL_HS_FINISHED ||
- ssl->in_hslen != ssl_hs_hdr_len( ssl ) + hash_len )
+ if( ssl->in_msg[0] != MBEDTLS_SSL_HS_FINISHED ||
+ ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + hash_len )
{
- SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_FINISHED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_FINISHED );
}
- if( safer_memcmp( ssl->in_msg + ssl_hs_hdr_len( ssl ),
+ if( mbedtls_ssl_safer_memcmp( ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl ),
buf, hash_len ) != 0 )
{
- SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
- return( POLARSSL_ERR_SSL_BAD_HS_FINISHED );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad finished message" ) );
+ return( MBEDTLS_ERR_SSL_BAD_HS_FINISHED );
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->verify_data_len = hash_len;
memcpy( ssl->peer_verify_data, buf, hash_len );
#endif
if( ssl->handshake->resume != 0 )
{
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
- ssl->state = SSL_CLIENT_CHANGE_CIPHER_SPEC;
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
+ ssl->state = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
#endif
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER )
- ssl->state = SSL_HANDSHAKE_WRAPUP;
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
+ ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
#endif
}
else
ssl->state++;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- ssl_recv_flight_completed( ssl );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ mbedtls_ssl_recv_flight_completed( ssl );
#endif
- SSL_DEBUG_MSG( 2, ( "<= parse finished" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse finished" ) );
return( 0 );
}
-static void ssl_handshake_params_init( ssl_handshake_params *handshake )
+static void ssl_handshake_params_init( mbedtls_ssl_handshake_params *handshake )
{
- memset( handshake, 0, sizeof( ssl_handshake_params ) );
+ memset( handshake, 0, sizeof( mbedtls_ssl_handshake_params ) );
-#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_1)
- md5_init( &handshake->fin_md5 );
- sha1_init( &handshake->fin_sha1 );
- md5_starts( &handshake->fin_md5 );
- sha1_starts( &handshake->fin_sha1 );
+#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ mbedtls_md5_init( &handshake->fin_md5 );
+ mbedtls_sha1_init( &handshake->fin_sha1 );
+ mbedtls_md5_starts( &handshake->fin_md5 );
+ mbedtls_sha1_starts( &handshake->fin_sha1 );
#endif
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
-#if defined(POLARSSL_SHA256_C)
- sha256_init( &handshake->fin_sha256 );
- sha256_starts( &handshake->fin_sha256, 0 );
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+#if defined(MBEDTLS_SHA256_C)
+ mbedtls_sha256_init( &handshake->fin_sha256 );
+ mbedtls_sha256_starts( &handshake->fin_sha256, 0 );
#endif
-#if defined(POLARSSL_SHA512_C)
- sha512_init( &handshake->fin_sha512 );
- sha512_starts( &handshake->fin_sha512, 1 );
+#if defined(MBEDTLS_SHA512_C)
+ mbedtls_sha512_init( &handshake->fin_sha512 );
+ mbedtls_sha512_starts( &handshake->fin_sha512, 1 );
#endif
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
handshake->update_checksum = ssl_update_checksum_start;
- handshake->sig_alg = SSL_HASH_SHA1;
+ handshake->sig_alg = MBEDTLS_SSL_HASH_SHA1;
-#if defined(POLARSSL_DHM_C)
- dhm_init( &handshake->dhm_ctx );
+#if defined(MBEDTLS_DHM_C)
+ mbedtls_dhm_init( &handshake->dhm_ctx );
#endif
-#if defined(POLARSSL_ECDH_C)
- ecdh_init( &handshake->ecdh_ctx );
+#if defined(MBEDTLS_ECDH_C)
+ mbedtls_ecdh_init( &handshake->ecdh_ctx );
#endif
}
-static void ssl_transform_init( ssl_transform *transform )
+static void ssl_transform_init( mbedtls_ssl_transform *transform )
{
- memset( transform, 0, sizeof(ssl_transform) );
+ memset( transform, 0, sizeof(mbedtls_ssl_transform) );
- cipher_init( &transform->cipher_ctx_enc );
- cipher_init( &transform->cipher_ctx_dec );
+ mbedtls_cipher_init( &transform->cipher_ctx_enc );
+ mbedtls_cipher_init( &transform->cipher_ctx_dec );
- md_init( &transform->md_ctx_enc );
- md_init( &transform->md_ctx_dec );
+ mbedtls_md_init( &transform->md_ctx_enc );
+ mbedtls_md_init( &transform->md_ctx_dec );
}
-void ssl_session_init( ssl_session *session )
+void mbedtls_ssl_session_init( mbedtls_ssl_session *session )
{
- memset( session, 0, sizeof(ssl_session) );
+ memset( session, 0, sizeof(mbedtls_ssl_session) );
}
-static int ssl_handshake_init( ssl_context *ssl )
+static int ssl_handshake_init( mbedtls_ssl_context *ssl )
{
/* Clear old handshake information if present */
if( ssl->transform_negotiate )
- ssl_transform_free( ssl->transform_negotiate );
+ mbedtls_ssl_transform_free( ssl->transform_negotiate );
if( ssl->session_negotiate )
- ssl_session_free( ssl->session_negotiate );
+ mbedtls_ssl_session_free( ssl->session_negotiate );
if( ssl->handshake )
- ssl_handshake_free( ssl->handshake );
+ mbedtls_ssl_handshake_free( ssl->handshake );
/*
* Either the pointers are now NULL or cleared properly and can be freed.
@@ -4854,17 +4854,17 @@
*/
if( ssl->transform_negotiate == NULL )
{
- ssl->transform_negotiate = polarssl_malloc( sizeof(ssl_transform) );
+ ssl->transform_negotiate = mbedtls_malloc( sizeof(mbedtls_ssl_transform) );
}
if( ssl->session_negotiate == NULL )
{
- ssl->session_negotiate = polarssl_malloc( sizeof(ssl_session) );
+ ssl->session_negotiate = mbedtls_malloc( sizeof(mbedtls_ssl_session) );
}
if( ssl->handshake == NULL )
{
- ssl->handshake = polarssl_malloc( sizeof(ssl_handshake_params) );
+ ssl->handshake = mbedtls_malloc( sizeof(mbedtls_ssl_handshake_params) );
}
/* All pointers should exist and can be directly freed without issue */
@@ -4872,25 +4872,25 @@
ssl->transform_negotiate == NULL ||
ssl->session_negotiate == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc() of ssl sub-contexts failed" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc() of ssl sub-contexts failed" ) );
- polarssl_free( ssl->handshake );
- polarssl_free( ssl->transform_negotiate );
- polarssl_free( ssl->session_negotiate );
+ mbedtls_free( ssl->handshake );
+ mbedtls_free( ssl->transform_negotiate );
+ mbedtls_free( ssl->session_negotiate );
ssl->handshake = NULL;
ssl->transform_negotiate = NULL;
ssl->session_negotiate = NULL;
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
/* Initialize structures */
- ssl_session_init( ssl->session_negotiate );
+ mbedtls_ssl_session_init( ssl->session_negotiate );
ssl_transform_init( ssl->transform_negotiate );
ssl_handshake_params_init( ssl->handshake );
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
ssl->handshake->key_cert = ssl->key_cert;
#endif
@@ -4898,20 +4898,20 @@
* We may not know yet if we're using DTLS,
* so always initiliase DTLS-specific fields.
*/
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
ssl->handshake->alt_transform_out = ssl->transform_out;
// TODO: not the right place, we may not know endpoint yet
- if( ssl->endpoint == SSL_IS_CLIENT )
- ssl->handshake->retransmit_state = SSL_RETRANS_PREPARING;
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;
else
- ssl->handshake->retransmit_state = SSL_RETRANS_WAITING;
+ ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;
#endif
return( 0 );
}
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
/* Dummy cookie callbacks for defaults */
static int ssl_cookie_write_dummy( void *ctx,
unsigned char **p, unsigned char *end,
@@ -4923,7 +4923,7 @@
((void) cli_id);
((void) cli_id_len);
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
static int ssl_cookie_check_dummy( void *ctx,
@@ -4936,45 +4936,45 @@
((void) cli_id);
((void) cli_id_len);
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
/*
* Initialize an SSL context
*/
-int ssl_init( ssl_context *ssl )
+int mbedtls_ssl_init( mbedtls_ssl_context *ssl )
{
int ret;
- int len = SSL_BUFFER_LEN;
+ int len = MBEDTLS_SSL_BUFFER_LEN;
- memset( ssl, 0, sizeof( ssl_context ) );
+ memset( ssl, 0, sizeof( mbedtls_ssl_context ) );
/*
* Sane defaults
*/
- ssl->min_major_ver = SSL_MAJOR_VERSION_3;
- ssl->min_minor_ver = SSL_MINOR_VERSION_1; /* TLS 1.0 */
- ssl->max_major_ver = SSL_MAX_MAJOR_VERSION;
- ssl->max_minor_ver = SSL_MAX_MINOR_VERSION;
+ ssl->min_major_ver = MBEDTLS_SSL_MAJOR_VERSION_3;
+ ssl->min_minor_ver = MBEDTLS_SSL_MINOR_VERSION_1; /* TLS 1.0 */
+ ssl->max_major_ver = MBEDTLS_SSL_MAX_MAJOR_VERSION;
+ ssl->max_minor_ver = MBEDTLS_SSL_MAX_MINOR_VERSION;
- ssl_set_ciphersuites( ssl, ssl_list_ciphersuites() );
+ mbedtls_ssl_set_ciphersuites( ssl, mbedtls_ssl_list_ciphersuites() );
- ssl_set_arc4_support( ssl, SSL_ARC4_DISABLED );
+ mbedtls_ssl_set_arc4_support( ssl, MBEDTLS_SSL_ARC4_DISABLED );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- ssl->renego_max_records = SSL_RENEGO_MAX_RECORDS_DEFAULT;
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ ssl->renego_max_records = MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT;
memset( ssl->renego_period, 0xFF, 7 );
ssl->renego_period[7] = 0x00;
#endif
-#if defined(POLARSSL_DHM_C)
- if( ( ret = mpi_read_string( &ssl->dhm_P, 16,
- POLARSSL_DHM_RFC5114_MODP_1024_P) ) != 0 ||
- ( ret = mpi_read_string( &ssl->dhm_G, 16,
- POLARSSL_DHM_RFC5114_MODP_1024_G) ) != 0 )
+#if defined(MBEDTLS_DHM_C)
+ if( ( ret = mbedtls_mpi_read_string( &ssl->dhm_P, 16,
+ MBEDTLS_DHM_RFC5114_MODP_1024_P) ) != 0 ||
+ ( ret = mbedtls_mpi_read_string( &ssl->dhm_G, 16,
+ MBEDTLS_DHM_RFC5114_MODP_1024_G) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_read_string", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_read_string", ret );
return( ret );
}
#endif
@@ -4982,49 +4982,49 @@
/*
* Prepare base structures
*/
- if( ( ssl->in_buf = polarssl_malloc( len ) ) == NULL ||
- ( ssl->out_buf = polarssl_malloc( len ) ) == NULL )
+ if( ( ssl->in_buf = mbedtls_malloc( len ) ) == NULL ||
+ ( ssl->out_buf = mbedtls_malloc( len ) ) == NULL )
{
- SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed", len ) );
- polarssl_free( ssl->in_buf );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "malloc(%d bytes) failed", len ) );
+ mbedtls_free( ssl->in_buf );
ssl->in_buf = NULL;
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
- memset( ssl-> in_buf, 0, SSL_BUFFER_LEN );
- memset( ssl->out_buf, 0, SSL_BUFFER_LEN );
+ memset( ssl-> in_buf, 0, MBEDTLS_SSL_BUFFER_LEN );
+ memset( ssl->out_buf, 0, MBEDTLS_SSL_BUFFER_LEN );
- /* No error is possible, SSL_TRANSPORT_STREAM always valid */
- (void) ssl_set_transport( ssl, SSL_TRANSPORT_STREAM );
+ /* No error is possible, MBEDTLS_SSL_TRANSPORT_STREAM always valid */
+ (void) mbedtls_ssl_set_transport( ssl, MBEDTLS_SSL_TRANSPORT_STREAM );
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- ssl->encrypt_then_mac = SSL_ETM_ENABLED;
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ ssl->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
#endif
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
- ssl->extended_ms = SSL_EXTENDED_MS_ENABLED;
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+ ssl->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- ssl->ticket_lifetime = SSL_DEFAULT_TICKET_LIFETIME;
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ ssl->ticket_lifetime = MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME;
#endif
-#if defined(POLARSSL_SSL_SET_CURVES)
- ssl->curve_list = ecp_grp_id_list( );
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ ssl->curve_list = mbedtls_ecp_grp_id_list( );
#endif
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
ssl->f_cookie_write = ssl_cookie_write_dummy;
ssl->f_cookie_check = ssl_cookie_check_dummy;
#endif
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
- ssl->anti_replay = SSL_ANTI_REPLAY_ENABLED;
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+ ssl->anti_replay = MBEDTLS_SSL_ANTI_REPLAY_ENABLED;
#endif
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- ssl->hs_timeout_min = SSL_DTLS_TIMEOUT_DFL_MIN;
- ssl->hs_timeout_max = SSL_DTLS_TIMEOUT_DFL_MAX;
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ ssl->hs_timeout_min = MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN;
+ ssl->hs_timeout_max = MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX;
#endif
if( ( ret = ssl_handshake_init( ssl ) ) != 0 )
@@ -5037,21 +5037,21 @@
* Reset an initialized and used SSL context for re-use while retaining
* all application-set variables, function pointers and data.
*/
-int ssl_session_reset( ssl_context *ssl )
+int mbedtls_ssl_session_reset( mbedtls_ssl_context *ssl )
{
int ret;
- ssl->state = SSL_HELLO_REQUEST;
+ ssl->state = MBEDTLS_SSL_HELLO_REQUEST;
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- ssl->renego_status = SSL_INITIAL_HANDSHAKE;
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ ssl->renego_status = MBEDTLS_SSL_INITIAL_HANDSHAKE;
ssl->renego_records_seen = 0;
ssl->verify_data_len = 0;
- memset( ssl->own_verify_data, 0, SSL_VERIFY_DATA_MAX_LEN );
- memset( ssl->peer_verify_data, 0, SSL_VERIFY_DATA_MAX_LEN );
+ memset( ssl->own_verify_data, 0, MBEDTLS_SSL_VERIFY_DATA_MAX_LEN );
+ memset( ssl->peer_verify_data, 0, MBEDTLS_SSL_VERIFY_DATA_MAX_LEN );
#endif
- ssl->secure_renegotiation = SSL_LEGACY_RENEGOTIATION;
+ ssl->secure_renegotiation = MBEDTLS_SSL_LEGACY_RENEGOTIATION;
ssl->in_offt = NULL;
@@ -5059,11 +5059,11 @@
ssl->in_msgtype = 0;
ssl->in_msglen = 0;
ssl->in_left = 0;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
ssl->next_record_offset = 0;
ssl->in_epoch = 0;
#endif
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
ssl_dtls_replay_reset( ssl );
#endif
@@ -5075,49 +5075,49 @@
ssl->out_msgtype = 0;
ssl->out_msglen = 0;
ssl->out_left = 0;
-#if defined(POLARSSL_SSL_CBC_RECORD_SPLITTING)
- if( ssl->split_done != SSL_CBC_RECORD_SPLITTING_DISABLED )
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+ if( ssl->split_done != MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED )
ssl->split_done = 0;
#endif
ssl->transform_in = NULL;
ssl->transform_out = NULL;
- memset( ssl->out_buf, 0, SSL_BUFFER_LEN );
- memset( ssl->in_buf, 0, SSL_BUFFER_LEN );
+ memset( ssl->out_buf, 0, MBEDTLS_SSL_BUFFER_LEN );
+ memset( ssl->in_buf, 0, MBEDTLS_SSL_BUFFER_LEN );
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_reset != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_reset != NULL )
{
- SSL_DEBUG_MSG( 2, ( "going for ssl_hw_record_reset()" ) );
- if( ( ret = ssl_hw_record_reset( ssl ) ) != 0 )
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_reset()" ) );
+ if( ( ret = mbedtls_ssl_hw_record_reset( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_hw_record_reset", ret );
- return( POLARSSL_ERR_SSL_HW_ACCEL_FAILED );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_hw_record_reset", ret );
+ return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
}
}
#endif
if( ssl->transform )
{
- ssl_transform_free( ssl->transform );
- polarssl_free( ssl->transform );
+ mbedtls_ssl_transform_free( ssl->transform );
+ mbedtls_free( ssl->transform );
ssl->transform = NULL;
}
if( ssl->session )
{
- ssl_session_free( ssl->session );
- polarssl_free( ssl->session );
+ mbedtls_ssl_session_free( ssl->session );
+ mbedtls_free( ssl->session );
ssl->session = NULL;
}
-#if defined(POLARSSL_SSL_ALPN)
+#if defined(MBEDTLS_SSL_ALPN)
ssl->alpn_chosen = NULL;
#endif
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
- polarssl_free( ssl->cli_id );
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+ mbedtls_free( ssl->cli_id );
ssl->cli_id = NULL;
ssl->cli_id_len = 0;
#endif
@@ -5128,54 +5128,54 @@
return( 0 );
}
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-static void ssl_ticket_keys_free( ssl_ticket_keys *tkeys )
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+static void ssl_ticket_keys_free( mbedtls_ssl_ticket_keys *tkeys )
{
- aes_free( &tkeys->enc );
- aes_free( &tkeys->dec );
+ mbedtls_aes_free( &tkeys->enc );
+ mbedtls_aes_free( &tkeys->dec );
- polarssl_zeroize( tkeys, sizeof(ssl_ticket_keys) );
+ mbedtls_zeroize( tkeys, sizeof(mbedtls_ssl_ticket_keys) );
}
/*
* Allocate and initialize ticket keys
*/
-static int ssl_ticket_keys_init( ssl_context *ssl )
+static int ssl_ticket_keys_init( mbedtls_ssl_context *ssl )
{
int ret;
- ssl_ticket_keys *tkeys;
+ mbedtls_ssl_ticket_keys *tkeys;
unsigned char buf[16];
if( ssl->ticket_keys != NULL )
return( 0 );
- tkeys = polarssl_malloc( sizeof(ssl_ticket_keys) );
+ tkeys = mbedtls_malloc( sizeof(mbedtls_ssl_ticket_keys) );
if( tkeys == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
- aes_init( &tkeys->enc );
- aes_init( &tkeys->dec );
+ mbedtls_aes_init( &tkeys->enc );
+ mbedtls_aes_init( &tkeys->dec );
if( ( ret = ssl->f_rng( ssl->p_rng, tkeys->key_name, 16 ) ) != 0 )
{
ssl_ticket_keys_free( tkeys );
- polarssl_free( tkeys );
+ mbedtls_free( tkeys );
return( ret );
}
if( ( ret = ssl->f_rng( ssl->p_rng, buf, 16 ) ) != 0 ||
- ( ret = aes_setkey_enc( &tkeys->enc, buf, 128 ) ) != 0 ||
- ( ret = aes_setkey_dec( &tkeys->dec, buf, 128 ) ) != 0 )
+ ( ret = mbedtls_aes_setkey_enc( &tkeys->enc, buf, 128 ) ) != 0 ||
+ ( ret = mbedtls_aes_setkey_dec( &tkeys->dec, buf, 128 ) ) != 0 )
{
ssl_ticket_keys_free( tkeys );
- polarssl_free( tkeys );
+ mbedtls_free( tkeys );
return( ret );
}
if( ( ret = ssl->f_rng( ssl->p_rng, tkeys->mac_key, 16 ) ) != 0 )
{
ssl_ticket_keys_free( tkeys );
- polarssl_free( tkeys );
+ mbedtls_free( tkeys );
return( ret );
}
@@ -5183,34 +5183,34 @@
return( 0 );
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
/*
* SSL set accessors
*/
-void ssl_set_endpoint( ssl_context *ssl, int endpoint )
+void mbedtls_ssl_set_endpoint( mbedtls_ssl_context *ssl, int endpoint )
{
ssl->endpoint = endpoint;
-#if defined(POLARSSL_SSL_SESSION_TICKETS) && \
- defined(POLARSSL_SSL_CLI_C)
- if( endpoint == SSL_IS_CLIENT )
+#if defined(MBEDTLS_SSL_SESSION_TICKETS) && \
+ defined(MBEDTLS_SSL_CLI_C)
+ if( endpoint == MBEDTLS_SSL_IS_CLIENT )
{
- ssl->session_tickets = SSL_SESSION_TICKETS_ENABLED;
- ssl->authmode = SSL_VERIFY_REQUIRED;
+ ssl->session_tickets = MBEDTLS_SSL_SESSION_TICKETS_ENABLED;
+ ssl->authmode = MBEDTLS_SSL_VERIFY_REQUIRED;
}
#endif
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
- if( endpoint == SSL_IS_SERVER )
- ssl->trunc_hmac = SSL_TRUNC_HMAC_ENABLED;
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+ if( endpoint == MBEDTLS_SSL_IS_SERVER )
+ ssl->trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED;
#endif
}
-int ssl_set_transport( ssl_context *ssl, int transport )
+int mbedtls_ssl_set_transport( mbedtls_ssl_context *ssl, int transport )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
ssl->transport = transport;
@@ -5227,17 +5227,17 @@
ssl->in_msg = ssl->in_buf + 13;
/* DTLS starts with TLS1.1 */
- if( ssl->min_minor_ver < SSL_MINOR_VERSION_2 )
- ssl->min_minor_ver = SSL_MINOR_VERSION_2;
+ if( ssl->min_minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 )
+ ssl->min_minor_ver = MBEDTLS_SSL_MINOR_VERSION_2;
- if( ssl->max_minor_ver < SSL_MINOR_VERSION_2 )
- ssl->max_minor_ver = SSL_MINOR_VERSION_2;
+ if( ssl->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 )
+ ssl->max_minor_ver = MBEDTLS_SSL_MINOR_VERSION_2;
return( 0 );
}
#endif
- if( transport == SSL_TRANSPORT_STREAM )
+ if( transport == MBEDTLS_SSL_TRANSPORT_STREAM )
{
ssl->transport = transport;
@@ -5256,47 +5256,47 @@
return( 0 );
}
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
-void ssl_set_dtls_anti_replay( ssl_context *ssl, char mode )
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+void mbedtls_ssl_set_dtls_anti_replay( mbedtls_ssl_context *ssl, char mode )
{
ssl->anti_replay = mode;
}
#endif
-#if defined(POLARSSL_SSL_DTLS_BADMAC_LIMIT)
-void ssl_set_dtls_badmac_limit( ssl_context *ssl, unsigned limit )
+#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
+void mbedtls_ssl_set_dtls_badmac_limit( mbedtls_ssl_context *ssl, unsigned limit )
{
ssl->badmac_limit = limit;
}
#endif
-#if defined(POLARSSL_SSL_PROTO_DTLS)
-void ssl_set_handshake_timeout( ssl_context *ssl, uint32_t min, uint32_t max )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+void mbedtls_ssl_set_handshake_timeout( mbedtls_ssl_context *ssl, uint32_t min, uint32_t max )
{
ssl->hs_timeout_min = min;
ssl->hs_timeout_max = max;
}
#endif
-void ssl_set_authmode( ssl_context *ssl, int authmode )
+void mbedtls_ssl_set_authmode( mbedtls_ssl_context *ssl, int authmode )
{
ssl->authmode = authmode;
}
-#if defined(POLARSSL_X509_CRT_PARSE_C)
-void ssl_set_verify( ssl_context *ssl,
- int (*f_vrfy)(void *, x509_crt *, int, int *),
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+void mbedtls_ssl_set_verify( mbedtls_ssl_context *ssl,
+ int (*f_vrfy)(void *, mbedtls_x509_crt *, int, int *),
void *p_vrfy )
{
ssl->f_vrfy = f_vrfy;
ssl->p_vrfy = p_vrfy;
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-void ssl_set_rng( ssl_context *ssl,
+void mbedtls_ssl_set_rng( mbedtls_ssl_context *ssl,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -5304,7 +5304,7 @@
ssl->p_rng = p_rng;
}
-void ssl_set_dbg( ssl_context *ssl,
+void mbedtls_ssl_set_dbg( mbedtls_ssl_context *ssl,
void (*f_dbg)(void *, int, const char *),
void *p_dbg )
{
@@ -5312,8 +5312,8 @@
ssl->p_dbg = p_dbg;
}
-#if ! defined(POLARSSL_DEPRECATED_REMOVED)
-void ssl_set_bio( ssl_context *ssl,
+#if ! defined(MBEDTLS_DEPRECATED_REMOVED)
+void mbedtls_ssl_set_bio( mbedtls_ssl_context *ssl,
int (*f_recv)(void *, unsigned char *, size_t), void *p_recv,
int (*f_send)(void *, const unsigned char *, size_t), void *p_send )
{
@@ -5329,9 +5329,9 @@
ssl->f_send = f_send;
ssl->p_bio = p_send;
}
-#endif /* POLARSSL_DEPRECATED_REMOVED */
+#endif /* MBEDTLS_DEPRECATED_REMOVED */
-void ssl_set_bio_timeout( ssl_context *ssl,
+void mbedtls_ssl_set_bio_timeout( mbedtls_ssl_context *ssl,
void *p_bio,
int (*f_send)(void *, const unsigned char *, size_t),
int (*f_recv)(void *, unsigned char *, size_t),
@@ -5345,29 +5345,29 @@
ssl->read_timeout = timeout;
}
-#if defined(POLARSSL_SSL_SRV_C)
-void ssl_set_session_cache( ssl_context *ssl,
- int (*f_get_cache)(void *, ssl_session *), void *p_get_cache,
- int (*f_set_cache)(void *, const ssl_session *), void *p_set_cache )
+#if defined(MBEDTLS_SSL_SRV_C)
+void mbedtls_ssl_set_session_cache( mbedtls_ssl_context *ssl,
+ int (*f_get_cache)(void *, mbedtls_ssl_session *), void *p_get_cache,
+ int (*f_set_cache)(void *, const mbedtls_ssl_session *), void *p_set_cache )
{
ssl->f_get_cache = f_get_cache;
ssl->p_get_cache = p_get_cache;
ssl->f_set_cache = f_set_cache;
ssl->p_set_cache = p_set_cache;
}
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_SRV_C */
-#if defined(POLARSSL_SSL_CLI_C)
-int ssl_set_session( ssl_context *ssl, const ssl_session *session )
+#if defined(MBEDTLS_SSL_CLI_C)
+int mbedtls_ssl_set_session( mbedtls_ssl_context *ssl, const mbedtls_ssl_session *session )
{
int ret;
if( ssl == NULL ||
session == NULL ||
ssl->session_negotiate == NULL ||
- ssl->endpoint != SSL_IS_CLIENT )
+ ssl->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
if( ( ret = ssl_session_copy( ssl->session_negotiate, session ) ) != 0 )
@@ -5377,40 +5377,40 @@
return( 0 );
}
-#endif /* POLARSSL_SSL_CLI_C */
+#endif /* MBEDTLS_SSL_CLI_C */
-void ssl_set_ciphersuites( ssl_context *ssl, const int *ciphersuites )
+void mbedtls_ssl_set_ciphersuites( mbedtls_ssl_context *ssl, const int *ciphersuites )
{
- ssl->ciphersuite_list[SSL_MINOR_VERSION_0] = ciphersuites;
- ssl->ciphersuite_list[SSL_MINOR_VERSION_1] = ciphersuites;
- ssl->ciphersuite_list[SSL_MINOR_VERSION_2] = ciphersuites;
- ssl->ciphersuite_list[SSL_MINOR_VERSION_3] = ciphersuites;
+ ssl->ciphersuite_list[MBEDTLS_SSL_MINOR_VERSION_0] = ciphersuites;
+ ssl->ciphersuite_list[MBEDTLS_SSL_MINOR_VERSION_1] = ciphersuites;
+ ssl->ciphersuite_list[MBEDTLS_SSL_MINOR_VERSION_2] = ciphersuites;
+ ssl->ciphersuite_list[MBEDTLS_SSL_MINOR_VERSION_3] = ciphersuites;
}
-void ssl_set_ciphersuites_for_version( ssl_context *ssl,
+void mbedtls_ssl_set_ciphersuites_for_version( mbedtls_ssl_context *ssl,
const int *ciphersuites,
int major, int minor )
{
- if( major != SSL_MAJOR_VERSION_3 )
+ if( major != MBEDTLS_SSL_MAJOR_VERSION_3 )
return;
- if( minor < SSL_MINOR_VERSION_0 || minor > SSL_MINOR_VERSION_3 )
+ if( minor < MBEDTLS_SSL_MINOR_VERSION_0 || minor > MBEDTLS_SSL_MINOR_VERSION_3 )
return;
ssl->ciphersuite_list[minor] = ciphersuites;
}
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
/* Add a new (empty) key_cert entry an return a pointer to it */
-static ssl_key_cert *ssl_add_key_cert( ssl_context *ssl )
+static mbedtls_ssl_key_cert *ssl_add_key_cert( mbedtls_ssl_context *ssl )
{
- ssl_key_cert *key_cert, *last;
+ mbedtls_ssl_key_cert *key_cert, *last;
- key_cert = polarssl_malloc( sizeof(ssl_key_cert) );
+ key_cert = mbedtls_malloc( sizeof(mbedtls_ssl_key_cert) );
if( key_cert == NULL )
return( NULL );
- memset( key_cert, 0, sizeof( ssl_key_cert ) );
+ memset( key_cert, 0, sizeof( mbedtls_ssl_key_cert ) );
/* Append the new key_cert to the (possibly empty) current list */
if( ssl->key_cert == NULL )
@@ -5430,51 +5430,51 @@
return( key_cert );
}
-void ssl_set_ca_chain( ssl_context *ssl, x509_crt *ca_chain,
- x509_crl *ca_crl, const char *peer_cn )
+void mbedtls_ssl_set_ca_chain( mbedtls_ssl_context *ssl, mbedtls_x509_crt *ca_chain,
+ mbedtls_x509_crl *ca_crl, const char *peer_cn )
{
ssl->ca_chain = ca_chain;
ssl->ca_crl = ca_crl;
ssl->peer_cn = peer_cn;
}
-int ssl_set_own_cert( ssl_context *ssl, x509_crt *own_cert,
- pk_context *pk_key )
+int mbedtls_ssl_set_own_cert( mbedtls_ssl_context *ssl, mbedtls_x509_crt *own_cert,
+ mbedtls_pk_context *pk_key )
{
- ssl_key_cert *key_cert = ssl_add_key_cert( ssl );
+ mbedtls_ssl_key_cert *key_cert = ssl_add_key_cert( ssl );
if( key_cert == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
key_cert->cert = own_cert;
key_cert->key = pk_key;
return( 0 );
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
-int ssl_set_psk( ssl_context *ssl, const unsigned char *psk, size_t psk_len,
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
+int mbedtls_ssl_set_psk( mbedtls_ssl_context *ssl, const unsigned char *psk, size_t psk_len,
const unsigned char *psk_identity, size_t psk_identity_len )
{
if( psk == NULL || psk_identity == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- if( psk_len > POLARSSL_PSK_MAX_LEN )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( psk_len > MBEDTLS_PSK_MAX_LEN )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( ssl->psk != NULL || ssl->psk_identity != NULL )
{
- polarssl_free( ssl->psk );
- polarssl_free( ssl->psk_identity );
+ mbedtls_free( ssl->psk );
+ mbedtls_free( ssl->psk_identity );
}
- if( ( ssl->psk = polarssl_malloc( psk_len ) ) == NULL ||
- ( ssl->psk_identity = polarssl_malloc( psk_identity_len ) ) == NULL )
+ if( ( ssl->psk = mbedtls_malloc( psk_len ) ) == NULL ||
+ ( ssl->psk_identity = mbedtls_malloc( psk_identity_len ) ) == NULL )
{
- polarssl_free( ssl->psk );
+ mbedtls_free( ssl->psk );
ssl->psk = NULL;
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
}
ssl->psk_len = psk_len;
@@ -5486,81 +5486,81 @@
return( 0 );
}
-void ssl_set_psk_cb( ssl_context *ssl,
- int (*f_psk)(void *, ssl_context *, const unsigned char *,
+void mbedtls_ssl_set_psk_cb( mbedtls_ssl_context *ssl,
+ int (*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *,
size_t),
void *p_psk )
{
ssl->f_psk = f_psk;
ssl->p_psk = p_psk;
}
-#endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
+#endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
-#if defined(POLARSSL_DHM_C)
-int ssl_set_dh_param( ssl_context *ssl, const char *dhm_P, const char *dhm_G )
+#if defined(MBEDTLS_DHM_C)
+int mbedtls_ssl_set_dh_param( mbedtls_ssl_context *ssl, const char *dhm_P, const char *dhm_G )
{
int ret;
- if( ( ret = mpi_read_string( &ssl->dhm_P, 16, dhm_P ) ) != 0 )
+ if( ( ret = mbedtls_mpi_read_string( &ssl->dhm_P, 16, dhm_P ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_read_string", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_read_string", ret );
return( ret );
}
- if( ( ret = mpi_read_string( &ssl->dhm_G, 16, dhm_G ) ) != 0 )
+ if( ( ret = mbedtls_mpi_read_string( &ssl->dhm_G, 16, dhm_G ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_read_string", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_read_string", ret );
return( ret );
}
return( 0 );
}
-int ssl_set_dh_param_ctx( ssl_context *ssl, dhm_context *dhm_ctx )
+int mbedtls_ssl_set_dh_param_ctx( mbedtls_ssl_context *ssl, mbedtls_dhm_context *dhm_ctx )
{
int ret;
- if( ( ret = mpi_copy( &ssl->dhm_P, &dhm_ctx->P ) ) != 0 )
+ if( ( ret = mbedtls_mpi_copy( &ssl->dhm_P, &dhm_ctx->P ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_copy", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_copy", ret );
return( ret );
}
- if( ( ret = mpi_copy( &ssl->dhm_G, &dhm_ctx->G ) ) != 0 )
+ if( ( ret = mbedtls_mpi_copy( &ssl->dhm_G, &dhm_ctx->G ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "mpi_copy", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_mpi_copy", ret );
return( ret );
}
return( 0 );
}
-#endif /* POLARSSL_DHM_C */
+#endif /* MBEDTLS_DHM_C */
-#if defined(POLARSSL_SSL_SET_CURVES)
+#if defined(MBEDTLS_SSL_SET_CURVES)
/*
* Set the allowed elliptic curves
*/
-void ssl_set_curves( ssl_context *ssl, const ecp_group_id *curve_list )
+void mbedtls_ssl_set_curves( mbedtls_ssl_context *ssl, const mbedtls_ecp_group_id *curve_list )
{
ssl->curve_list = curve_list;
}
#endif
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
-int ssl_set_hostname( ssl_context *ssl, const char *hostname )
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
+int mbedtls_ssl_set_hostname( mbedtls_ssl_context *ssl, const char *hostname )
{
if( hostname == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
ssl->hostname_len = strlen( hostname );
if( ssl->hostname_len + 1 == 0 )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- ssl->hostname = polarssl_malloc( ssl->hostname_len + 1 );
+ ssl->hostname = mbedtls_malloc( ssl->hostname_len + 1 );
if( ssl->hostname == NULL )
- return( POLARSSL_ERR_SSL_MALLOC_FAILED );
+ return( MBEDTLS_ERR_SSL_MALLOC_FAILED );
memcpy( ssl->hostname, (const unsigned char *) hostname,
ssl->hostname_len );
@@ -5570,18 +5570,18 @@
return( 0 );
}
-void ssl_set_sni( ssl_context *ssl,
- int (*f_sni)(void *, ssl_context *,
+void mbedtls_ssl_set_sni( mbedtls_ssl_context *ssl,
+ int (*f_sni)(void *, mbedtls_ssl_context *,
const unsigned char *, size_t),
void *p_sni )
{
ssl->f_sni = f_sni;
ssl->p_sni = p_sni;
}
-#endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
-#if defined(POLARSSL_SSL_ALPN)
-int ssl_set_alpn_protocols( ssl_context *ssl, const char **protos )
+#if defined(MBEDTLS_SSL_ALPN)
+int mbedtls_ssl_set_alpn_protocols( mbedtls_ssl_context *ssl, const char **protos )
{
size_t cur_len, tot_len;
const char **p;
@@ -5597,7 +5597,7 @@
tot_len += cur_len;
if( cur_len == 0 || cur_len > 255 || tot_len > 65535 )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
ssl->alpn_list = protos;
@@ -5605,23 +5605,23 @@
return( 0 );
}
-const char *ssl_get_alpn_protocol( const ssl_context *ssl )
+const char *mbedtls_ssl_get_alpn_protocol( const mbedtls_ssl_context *ssl )
{
return( ssl->alpn_chosen );
}
-#endif /* POLARSSL_SSL_ALPN */
+#endif /* MBEDTLS_SSL_ALPN */
-static int ssl_check_version( const ssl_context *ssl, int major, int minor )
+static int ssl_check_version( const mbedtls_ssl_context *ssl, int major, int minor )
{
- if( major < SSL_MIN_MAJOR_VERSION || major > SSL_MAX_MAJOR_VERSION ||
- minor < SSL_MIN_MINOR_VERSION || minor > SSL_MAX_MINOR_VERSION )
+ if( major < MBEDTLS_SSL_MIN_MAJOR_VERSION || major > MBEDTLS_SSL_MAX_MAJOR_VERSION ||
+ minor < MBEDTLS_SSL_MIN_MINOR_VERSION || minor > MBEDTLS_SSL_MAX_MINOR_VERSION )
{
return( -1 );
}
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
- minor < SSL_MINOR_VERSION_2 )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
+ minor < MBEDTLS_SSL_MINOR_VERSION_2 )
{
return( -1 );
}
@@ -5632,10 +5632,10 @@
return( 0 );
}
-int ssl_set_max_version( ssl_context *ssl, int major, int minor )
+int mbedtls_ssl_set_max_version( mbedtls_ssl_context *ssl, int major, int minor )
{
if( ssl_check_version( ssl, major, minor ) != 0 )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
ssl->max_major_ver = major;
ssl->max_minor_ver = minor;
@@ -5643,10 +5643,10 @@
return( 0 );
}
-int ssl_set_min_version( ssl_context *ssl, int major, int minor )
+int mbedtls_ssl_set_min_version( mbedtls_ssl_context *ssl, int major, int minor )
{
if( ssl_check_version( ssl, major, minor ) != 0 )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
ssl->min_major_ver = major;
ssl->min_minor_ver = minor;
@@ -5654,120 +5654,120 @@
return( 0 );
}
-#if defined(POLARSSL_SSL_FALLBACK_SCSV) && defined(POLARSSL_SSL_CLI_C)
-void ssl_set_fallback( ssl_context *ssl, char fallback )
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C)
+void mbedtls_ssl_set_fallback( mbedtls_ssl_context *ssl, char fallback )
{
ssl->fallback = fallback;
}
#endif
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
-void ssl_set_encrypt_then_mac( ssl_context *ssl, char etm )
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+void mbedtls_ssl_set_encrypt_then_mac( mbedtls_ssl_context *ssl, char etm )
{
ssl->encrypt_then_mac = etm;
}
#endif
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
-void ssl_set_extended_master_secret( ssl_context *ssl, char ems )
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+void mbedtls_ssl_set_extended_master_secret( mbedtls_ssl_context *ssl, char ems )
{
ssl->extended_ms = ems;
}
#endif
-void ssl_set_arc4_support( ssl_context *ssl, char arc4 )
+void mbedtls_ssl_set_arc4_support( mbedtls_ssl_context *ssl, char arc4 )
{
ssl->arc4_disabled = arc4;
}
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
-int ssl_set_max_frag_len( ssl_context *ssl, unsigned char mfl_code )
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+int mbedtls_ssl_set_max_frag_len( mbedtls_ssl_context *ssl, unsigned char mfl_code )
{
- if( mfl_code >= SSL_MAX_FRAG_LEN_INVALID ||
- mfl_code_to_length[mfl_code] > SSL_MAX_CONTENT_LEN )
+ if( mfl_code >= MBEDTLS_SSL_MAX_FRAG_LEN_INVALID ||
+ mfl_code_to_length[mfl_code] > MBEDTLS_SSL_MAX_CONTENT_LEN )
{
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
ssl->mfl_code = mfl_code;
return( 0 );
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
-int ssl_set_truncated_hmac( ssl_context *ssl, int truncate )
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+int mbedtls_ssl_set_truncated_hmac( mbedtls_ssl_context *ssl, int truncate )
{
ssl->trunc_hmac = truncate;
return( 0 );
}
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_CBC_RECORD_SPLITTING)
-void ssl_set_cbc_record_splitting( ssl_context *ssl, char split )
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+void mbedtls_ssl_set_cbc_record_splitting( mbedtls_ssl_context *ssl, char split )
{
ssl->split_done = split;
}
#endif
-void ssl_legacy_renegotiation( ssl_context *ssl, int allow_legacy )
+void mbedtls_ssl_legacy_renegotiation( mbedtls_ssl_context *ssl, int allow_legacy )
{
ssl->allow_legacy_renegotiation = allow_legacy;
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
-void ssl_set_renegotiation( ssl_context *ssl, int renegotiation )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+void mbedtls_ssl_set_renegotiation( mbedtls_ssl_context *ssl, int renegotiation )
{
ssl->disable_renegotiation = renegotiation;
}
-void ssl_set_renegotiation_enforced( ssl_context *ssl, int max_records )
+void mbedtls_ssl_set_renegotiation_enforced( mbedtls_ssl_context *ssl, int max_records )
{
ssl->renego_max_records = max_records;
}
-void ssl_set_renegotiation_period( ssl_context *ssl,
+void mbedtls_ssl_set_renegotiation_period( mbedtls_ssl_context *ssl,
const unsigned char period[8] )
{
memcpy( ssl->renego_period, period, 8 );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
-int ssl_set_session_tickets( ssl_context *ssl, int use_tickets )
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+int mbedtls_ssl_set_session_tickets( mbedtls_ssl_context *ssl, int use_tickets )
{
ssl->session_tickets = use_tickets;
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
return( 0 );
#endif
- if( use_tickets == SSL_SESSION_TICKETS_DISABLED )
+ if( use_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED )
return( 0 );
if( ssl->f_rng == NULL )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
return( ssl_ticket_keys_init( ssl ) );
}
-void ssl_set_session_ticket_lifetime( ssl_context *ssl, int lifetime )
+void mbedtls_ssl_set_session_ticket_lifetime( mbedtls_ssl_context *ssl, int lifetime )
{
ssl->ticket_lifetime = lifetime;
}
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
/*
* SSL get accessors
*/
-size_t ssl_get_bytes_avail( const ssl_context *ssl )
+size_t mbedtls_ssl_get_bytes_avail( const mbedtls_ssl_context *ssl )
{
return( ssl->in_offt == NULL ? 0 : ssl->in_msglen );
}
-int ssl_get_verify_result( const ssl_context *ssl )
+int mbedtls_ssl_get_verify_result( const mbedtls_ssl_context *ssl )
{
if( ssl->session != NULL )
return( ssl->session->verify_result );
@@ -5778,25 +5778,25 @@
return( -1 );
}
-const char *ssl_get_ciphersuite( const ssl_context *ssl )
+const char *mbedtls_ssl_get_ciphersuite( const mbedtls_ssl_context *ssl )
{
if( ssl == NULL || ssl->session == NULL )
return( NULL );
- return ssl_get_ciphersuite_name( ssl->session->ciphersuite );
+ return mbedtls_ssl_get_ciphersuite_name( ssl->session->ciphersuite );
}
-const char *ssl_get_version( const ssl_context *ssl )
+const char *mbedtls_ssl_get_version( const mbedtls_ssl_context *ssl )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
switch( ssl->minor_ver )
{
- case SSL_MINOR_VERSION_2:
+ case MBEDTLS_SSL_MINOR_VERSION_2:
return( "DTLSv1.0" );
- case SSL_MINOR_VERSION_3:
+ case MBEDTLS_SSL_MINOR_VERSION_3:
return( "DTLSv1.2" );
default:
@@ -5807,16 +5807,16 @@
switch( ssl->minor_ver )
{
- case SSL_MINOR_VERSION_0:
+ case MBEDTLS_SSL_MINOR_VERSION_0:
return( "SSLv3.0" );
- case SSL_MINOR_VERSION_1:
+ case MBEDTLS_SSL_MINOR_VERSION_1:
return( "TLSv1.0" );
- case SSL_MINOR_VERSION_2:
+ case MBEDTLS_SSL_MINOR_VERSION_2:
return( "TLSv1.1" );
- case SSL_MINOR_VERSION_3:
+ case MBEDTLS_SSL_MINOR_VERSION_3:
return( "TLSv1.2" );
default:
@@ -5824,79 +5824,79 @@
}
}
-int ssl_get_record_expansion( const ssl_context *ssl )
+int mbedtls_ssl_get_record_expansion( const mbedtls_ssl_context *ssl )
{
int transform_expansion;
- const ssl_transform *transform = ssl->transform_out;
+ const mbedtls_ssl_transform *transform = ssl->transform_out;
-#if defined(POLARSSL_ZLIB_SUPPORT)
- if( ssl->session_out->compression != SSL_COMPRESS_NULL )
- return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
+#if defined(MBEDTLS_ZLIB_SUPPORT)
+ if( ssl->session_out->compression != MBEDTLS_SSL_COMPRESS_NULL )
+ return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
#endif
if( transform == NULL )
- return( ssl_hdr_len( ssl ) );
+ return( mbedtls_ssl_hdr_len( ssl ) );
- switch( cipher_get_cipher_mode( &transform->cipher_ctx_enc ) )
+ switch( mbedtls_cipher_get_cipher_mode( &transform->cipher_ctx_enc ) )
{
- case POLARSSL_MODE_GCM:
- case POLARSSL_MODE_CCM:
- case POLARSSL_MODE_STREAM:
+ case MBEDTLS_MODE_GCM:
+ case MBEDTLS_MODE_CCM:
+ case MBEDTLS_MODE_STREAM:
transform_expansion = transform->minlen;
break;
- case POLARSSL_MODE_CBC:
+ case MBEDTLS_MODE_CBC:
transform_expansion = transform->maclen
- + cipher_get_block_size( &transform->cipher_ctx_enc );
+ + mbedtls_cipher_get_block_size( &transform->cipher_ctx_enc );
break;
default:
- SSL_DEBUG_MSG( 0, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 0, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
- return( ssl_hdr_len( ssl ) + transform_expansion );
+ return( mbedtls_ssl_hdr_len( ssl ) + transform_expansion );
}
-#if defined(POLARSSL_X509_CRT_PARSE_C)
-const x509_crt *ssl_get_peer_cert( const ssl_context *ssl )
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+const mbedtls_x509_crt *mbedtls_ssl_get_peer_cert( const mbedtls_ssl_context *ssl )
{
if( ssl == NULL || ssl->session == NULL )
return( NULL );
return( ssl->session->peer_cert );
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-#if defined(POLARSSL_SSL_CLI_C)
-int ssl_get_session( const ssl_context *ssl, ssl_session *dst )
+#if defined(MBEDTLS_SSL_CLI_C)
+int mbedtls_ssl_get_session( const mbedtls_ssl_context *ssl, mbedtls_ssl_session *dst )
{
if( ssl == NULL ||
dst == NULL ||
ssl->session == NULL ||
- ssl->endpoint != SSL_IS_CLIENT )
+ ssl->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ssl_session_copy( dst, ssl->session ) );
}
-#endif /* POLARSSL_SSL_CLI_C */
+#endif /* MBEDTLS_SSL_CLI_C */
/*
* Perform a single step of the SSL handshake
*/
-int ssl_handshake_step( ssl_context *ssl )
+int mbedtls_ssl_handshake_step( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT )
- ret = ssl_handshake_client_step( ssl );
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
+ ret = mbedtls_ssl_handshake_client_step( ssl );
#endif
-#if defined(POLARSSL_SSL_SRV_C)
- if( ssl->endpoint == SSL_IS_SERVER )
- ret = ssl_handshake_server_step( ssl );
+#if defined(MBEDTLS_SSL_SRV_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
+ ret = mbedtls_ssl_handshake_server_step( ssl );
#endif
return( ret );
@@ -5905,93 +5905,93 @@
/*
* Perform the SSL handshake
*/
-int ssl_handshake( ssl_context *ssl )
+int mbedtls_ssl_handshake( mbedtls_ssl_context *ssl )
{
int ret = 0;
- SSL_DEBUG_MSG( 2, ( "=> handshake" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> handshake" ) );
- while( ssl->state != SSL_HANDSHAKE_OVER )
+ while( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
- ret = ssl_handshake_step( ssl );
+ ret = mbedtls_ssl_handshake_step( ssl );
if( ret != 0 )
break;
}
- SSL_DEBUG_MSG( 2, ( "<= handshake" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= handshake" ) );
return( ret );
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
-#if defined(POLARSSL_SSL_SRV_C)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_SRV_C)
/*
* Write HelloRequest to request renegotiation on server
*/
-static int ssl_write_hello_request( ssl_context *ssl )
+static int ssl_write_hello_request( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> write hello request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write hello request" ) );
ssl->out_msglen = 4;
- ssl->out_msgtype = SSL_MSG_HANDSHAKE;
- ssl->out_msg[0] = SSL_HS_HELLO_REQUEST;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
+ ssl->out_msg[0] = MBEDTLS_SSL_HS_HELLO_REQUEST;
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= write hello request" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write hello request" ) );
return( 0 );
}
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_SRV_C */
/*
* Actually renegotiate current connection, triggered by either:
- * - any side: calling ssl_renegotiate(),
- * - client: receiving a HelloRequest during ssl_read(),
- * - server: receiving any handshake message on server during ssl_read() after
+ * - any side: calling mbedtls_ssl_renegotiate(),
+ * - client: receiving a HelloRequest during mbedtls_ssl_read(),
+ * - server: receiving any handshake message on server during mbedtls_ssl_read() after
* the initial handshake is completed.
* If the handshake doesn't complete due to waiting for I/O, it will continue
- * during the next calls to ssl_renegotiate() or ssl_read() respectively.
+ * during the next calls to mbedtls_ssl_renegotiate() or mbedtls_ssl_read() respectively.
*/
-static int ssl_start_renegotiation( ssl_context *ssl )
+static int ssl_start_renegotiation( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> renegotiate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> renegotiate" ) );
if( ( ret = ssl_handshake_init( ssl ) ) != 0 )
return( ret );
/* RFC 6347 4.2.2: "[...] the HelloRequest will have message_seq = 0 and
* the ServerHello will have message_seq = 1" */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
- ssl->renego_status == SSL_RENEGOTIATION_PENDING )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
+ ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
- if( ssl->endpoint == SSL_IS_SERVER )
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
ssl->handshake->out_msg_seq = 1;
else
ssl->handshake->in_msg_seq = 1;
}
#endif
- ssl->state = SSL_HELLO_REQUEST;
- ssl->renego_status = SSL_RENEGOTIATION_IN_PROGRESS;
+ ssl->state = MBEDTLS_SSL_HELLO_REQUEST;
+ ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS;
- if( ( ret = ssl_handshake( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_handshake( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_handshake", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
- SSL_DEBUG_MSG( 2, ( "<= renegotiate" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= renegotiate" ) );
return( 0 );
}
@@ -6000,52 +6000,52 @@
* Renegotiate current connection on client,
* or request renegotiation on server
*/
-int ssl_renegotiate( ssl_context *ssl )
+int mbedtls_ssl_renegotiate( mbedtls_ssl_context *ssl )
{
- int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
+ int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
-#if defined(POLARSSL_SSL_SRV_C)
+#if defined(MBEDTLS_SSL_SRV_C)
/* On server, just send the request */
- if( ssl->endpoint == SSL_IS_SERVER )
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER )
{
- if( ssl->state != SSL_HANDSHAKE_OVER )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
- ssl->renego_status = SSL_RENEGOTIATION_PENDING;
+ ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_PENDING;
/* Did we already try/start sending HelloRequest? */
if( ssl->out_left != 0 )
- return( ssl_flush_output( ssl ) );
+ return( mbedtls_ssl_flush_output( ssl ) );
return( ssl_write_hello_request( ssl ) );
}
-#endif /* POLARSSL_SSL_SRV_C */
+#endif /* MBEDTLS_SSL_SRV_C */
-#if defined(POLARSSL_SSL_CLI_C)
+#if defined(MBEDTLS_SSL_CLI_C)
/*
* On client, either start the renegotiation process or,
* if already in progress, continue the handshake
*/
- if( ssl->renego_status != SSL_RENEGOTIATION_IN_PROGRESS )
+ if( ssl->renego_status != MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
- if( ssl->state != SSL_HANDSHAKE_OVER )
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( ( ret = ssl_start_renegotiation( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_start_renegotiation", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_start_renegotiation", ret );
return( ret );
}
}
else
{
- if( ( ret = ssl_handshake( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_handshake( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_handshake", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
}
-#endif /* POLARSSL_SSL_CLI_C */
+#endif /* MBEDTLS_SSL_CLI_C */
return( ret );
}
@@ -6053,11 +6053,11 @@
/*
* Check record counters and renegotiate if they're above the limit.
*/
-static int ssl_check_ctr_renegotiate( ssl_context *ssl )
+static int ssl_check_ctr_renegotiate( mbedtls_ssl_context *ssl )
{
- if( ssl->state != SSL_HANDSHAKE_OVER ||
- ssl->renego_status == SSL_RENEGOTIATION_PENDING ||
- ssl->disable_renegotiation == SSL_RENEGOTIATION_DISABLED )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER ||
+ ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING ||
+ ssl->disable_renegotiation == MBEDTLS_SSL_RENEGOTIATION_DISABLED )
{
return( 0 );
}
@@ -6069,61 +6069,61 @@
return( 0 );
}
- SSL_DEBUG_MSG( 0, ( "record counter limit reached: renegotiate" ) );
- return( ssl_renegotiate( ssl ) );
+ MBEDTLS_SSL_DEBUG_MSG( 0, ( "record counter limit reached: renegotiate" ) );
+ return( mbedtls_ssl_renegotiate( ssl ) );
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
/*
* Receive application data decrypted from the SSL layer
*/
-int ssl_read( ssl_context *ssl, unsigned char *buf, size_t len )
+int mbedtls_ssl_read( mbedtls_ssl_context *ssl, unsigned char *buf, size_t len )
{
int ret, record_read = 0;
size_t n;
- SSL_DEBUG_MSG( 2, ( "=> read" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> read" ) );
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
- if( ( ret = ssl_flush_output( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
if( ssl->handshake != NULL &&
- ssl->handshake->retransmit_state == SSL_RETRANS_SENDING )
+ ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
- if( ( ret = ssl_resend( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 )
return( ret );
}
}
#endif
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ( ret = ssl_check_ctr_renegotiate( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_check_ctr_renegotiate", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_check_ctr_renegotiate", ret );
return( ret );
}
#endif
- if( ssl->state != SSL_HANDSHAKE_OVER )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
- ret = ssl_handshake( ssl );
- if( ret == POLARSSL_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
+ ret = mbedtls_ssl_handshake( ssl );
+ if( ret == MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
{
record_read = 1;
}
else if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_handshake", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
}
if( ssl->in_offt == NULL )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
/* Start timer if not already running */
if( ssl->time_limit == 0 )
ssl_set_timer( ssl, ssl->read_timeout );
@@ -6131,180 +6131,180 @@
if( ! record_read )
{
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- if( ret == POLARSSL_ERR_SSL_CONN_EOF )
+ if( ret == MBEDTLS_ERR_SSL_CONN_EOF )
return( 0 );
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
}
if( ssl->in_msglen == 0 &&
- ssl->in_msgtype == SSL_MSG_APPLICATION_DATA )
+ ssl->in_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA )
{
/*
* OpenSSL sends empty messages to randomize the IV
*/
- if( ( ret = ssl_read_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_read_record( ssl ) ) != 0 )
{
- if( ret == POLARSSL_ERR_SSL_CONN_EOF )
+ if( ret == MBEDTLS_ERR_SSL_CONN_EOF )
return( 0 );
- SSL_DEBUG_RET( 1, "ssl_read_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
}
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->in_msgtype == SSL_MSG_HANDSHAKE )
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE )
{
- SSL_DEBUG_MSG( 1, ( "received handshake message" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "received handshake message" ) );
-#if defined(POLARSSL_SSL_CLI_C)
- if( ssl->endpoint == SSL_IS_CLIENT &&
- ( ssl->in_msg[0] != SSL_HS_HELLO_REQUEST ||
- ssl->in_hslen != ssl_hs_hdr_len( ssl ) ) )
+#if defined(MBEDTLS_SSL_CLI_C)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_CLIENT &&
+ ( ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_REQUEST ||
+ ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) ) )
{
- SSL_DEBUG_MSG( 1, ( "handshake received (not HelloRequest)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake received (not HelloRequest)" ) );
/* With DTLS, drop the packet (probably from last handshake) */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- return( POLARSSL_ERR_NET_WANT_READ );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ return( MBEDTLS_ERR_NET_WANT_READ );
#endif
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
- if( ssl->endpoint == SSL_IS_SERVER &&
- ssl->in_msg[0] != SSL_HS_CLIENT_HELLO )
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_HELLO )
{
- SSL_DEBUG_MSG( 1, ( "handshake received (not ClientHello)" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake received (not ClientHello)" ) );
/* With DTLS, drop the packet (probably from last handshake) */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
- return( POLARSSL_ERR_NET_WANT_READ );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
+ return( MBEDTLS_ERR_NET_WANT_READ );
#endif
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
#endif
- if( ssl->disable_renegotiation == SSL_RENEGOTIATION_DISABLED ||
- ( ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
+ if( ssl->disable_renegotiation == MBEDTLS_SSL_RENEGOTIATION_DISABLED ||
+ ( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
ssl->allow_legacy_renegotiation ==
- SSL_LEGACY_NO_RENEGOTIATION ) )
+ MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION ) )
{
- SSL_DEBUG_MSG( 3, ( "refusing renegotiation, sending alert" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 3, ( "refusing renegotiation, sending alert" ) );
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- if( ssl->minor_ver == SSL_MINOR_VERSION_0 )
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
/*
* SSLv3 does not have a "no_renegotiation" alert
*/
- if( ( ret = ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_fatal_handshake_failure( ssl ) ) != 0 )
return( ret );
}
else
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
- defined(POLARSSL_SSL_PROTO_TLS1_2)
- if( ssl->minor_ver >= SSL_MINOR_VERSION_1 )
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
+ defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ if( ssl->minor_ver >= MBEDTLS_SSL_MINOR_VERSION_1 )
{
- if( ( ret = ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_WARNING,
- SSL_ALERT_MSG_NO_RENEGOTIATION ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_WARNING,
+ MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION ) ) != 0 )
{
return( ret );
}
}
else
-#endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 ||
- POLARSSL_SSL_PROTO_TLS1_2 */
+#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 ||
+ MBEDTLS_SSL_PROTO_TLS1_2 */
{
- SSL_DEBUG_MSG( 1, ( "should never happen" ) );
- return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
+ return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
{
/* DTLS clients need to know renego is server-initiated */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM &&
- ssl->endpoint == SSL_IS_CLIENT )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
+ ssl->endpoint == MBEDTLS_SSL_IS_CLIENT )
{
- ssl->renego_status = SSL_RENEGOTIATION_PENDING;
+ ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_PENDING;
}
#endif
ret = ssl_start_renegotiation( ssl );
- if( ret == POLARSSL_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
+ if( ret == MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO )
{
record_read = 1;
}
else if( ret != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_start_renegotiation", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_start_renegotiation", ret );
return( ret );
}
}
/* If a non-handshake record was read during renego, fallthrough,
- * else tell the user they should call ssl_read() again */
+ * else tell the user they should call mbedtls_ssl_read() again */
if( ! record_read )
- return( POLARSSL_ERR_NET_WANT_READ );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
- else if( ssl->renego_status == SSL_RENEGOTIATION_PENDING )
+ else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ssl->renego_max_records >= 0 )
{
if( ++ssl->renego_records_seen > ssl->renego_max_records )
{
- SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation requested, "
"but not honored by client" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
}
}
-#endif /* POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
- /* Fatal and closure alerts handled by ssl_read_record() */
- if( ssl->in_msgtype == SSL_MSG_ALERT )
+ /* Fatal and closure alerts handled by mbedtls_ssl_read_record() */
+ if( ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT )
{
- SSL_DEBUG_MSG( 2, ( "ignoring non-fatal non-closure alert" ) );
- return( POLARSSL_ERR_NET_WANT_READ );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "ignoring non-fatal non-closure alert" ) );
+ return( MBEDTLS_ERR_NET_WANT_READ );
}
- if( ssl->in_msgtype != SSL_MSG_APPLICATION_DATA )
+ if( ssl->in_msgtype != MBEDTLS_SSL_MSG_APPLICATION_DATA )
{
- SSL_DEBUG_MSG( 1, ( "bad application data message" ) );
- return( POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE );
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad application data message" ) );
+ return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
ssl->in_offt = ssl->in_msg;
-#if defined(POLARSSL_SSL_PROTO_DTLS)
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
/* We're going to return something now, cancel timer,
* except if handshake (renegotiation) is in progress */
- if( ssl->state == SSL_HANDSHAKE_OVER )
+ if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
ssl_set_timer( ssl, 0 );
/* If we requested renego but received AppData, resend HelloRequest.
* Do it now, after setting in_offt, to avoid taking this branch
* again if ssl_write_hello_request() returns WANT_WRITE */
-#if defined(POLARSSL_SSL_SRV_C) && defined(POLARSSL_SSL_RENEGOTIATION)
- if( ssl->endpoint == SSL_IS_SERVER &&
- ssl->renego_status == SSL_RENEGOTIATION_PENDING )
+#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
+ if( ssl->endpoint == MBEDTLS_SSL_IS_SERVER &&
+ ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING )
{
if( ( ret = ssl_resend_hello_request( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_resend_hello_request", ret );
return( ret );
}
}
-#endif /* POLARSSL_SSL_SRV_C && POLARSSL_SSL_RENEGOTIATION */
+#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */
#endif
}
@@ -6321,7 +6321,7 @@
/* more data available */
ssl->in_offt += n;
- SSL_DEBUG_MSG( 2, ( "<= read" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= read" ) );
return( (int) n );
}
@@ -6329,37 +6329,37 @@
/*
* Send application data to be encrypted by the SSL layer
*/
-#if defined(POLARSSL_SSL_CBC_RECORD_SPLITTING)
-static int ssl_write_real( ssl_context *ssl, const unsigned char *buf, size_t len )
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+static int ssl_write_real( mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len )
#else
-int ssl_write( ssl_context *ssl, const unsigned char *buf, size_t len )
+int mbedtls_ssl_write( mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len )
#endif
{
int ret;
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
unsigned int max_len;
#endif
- SSL_DEBUG_MSG( 2, ( "=> write" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write" ) );
-#if defined(POLARSSL_SSL_RENEGOTIATION)
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ( ret = ssl_check_ctr_renegotiate( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_check_ctr_renegotiate", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "ssl_check_ctr_renegotiate", ret );
return( ret );
}
#endif
- if( ssl->state != SSL_HANDSHAKE_OVER )
+ if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
- if( ( ret = ssl_handshake( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_handshake( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_handshake", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_handshake", ret );
return( ret );
}
}
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
/*
* Assume mfl_code is correct since it was checked when set
*/
@@ -6376,42 +6376,42 @@
if( len > max_len )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( ssl->transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( ssl->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
- SSL_DEBUG_MSG( 1, ( "fragment larger than the (negotiated) "
+ MBEDTLS_SSL_DEBUG_MSG( 1, ( "fragment larger than the (negotiated) "
"maximum fragment length: %d > %d",
len, max_len ) );
- return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
else
#endif
len = max_len;
}
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
if( ssl->out_left != 0 )
{
- if( ( ret = ssl_flush_output( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_flush_output", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_flush_output", ret );
return( ret );
}
}
else
{
ssl->out_msglen = len;
- ssl->out_msgtype = SSL_MSG_APPLICATION_DATA;
+ ssl->out_msgtype = MBEDTLS_SSL_MSG_APPLICATION_DATA;
memcpy( ssl->out_msg, buf, len );
- if( ( ret = ssl_write_record( ssl ) ) != 0 )
+ if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_write_record", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
}
- SSL_DEBUG_MSG( 2, ( "<= write" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write" ) );
return( (int) len );
}
@@ -6423,16 +6423,16 @@
* then the caller will call us again with the same arguments, so
* remember wether we already did the split or not.
*/
-#if defined(POLARSSL_SSL_CBC_RECORD_SPLITTING)
-int ssl_write( ssl_context *ssl, const unsigned char *buf, size_t len )
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+int mbedtls_ssl_write( mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len )
{
int ret;
- if( ssl->split_done == SSL_CBC_RECORD_SPLITTING_DISABLED ||
+ if( ssl->split_done == MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED ||
len <= 1 ||
- ssl->minor_ver > SSL_MINOR_VERSION_1 ||
- cipher_get_cipher_mode( &ssl->transform_out->cipher_ctx_enc )
- != POLARSSL_MODE_CBC )
+ ssl->minor_ver > MBEDTLS_SSL_MINOR_VERSION_1 ||
+ mbedtls_cipher_get_cipher_mode( &ssl->transform_out->cipher_ctx_enc )
+ != MBEDTLS_MODE_CBC )
{
return( ssl_write_real( ssl, buf, len ) );
}
@@ -6450,407 +6450,407 @@
return( ret + 1 );
}
-#endif /* POLARSSL_SSL_CBC_RECORD_SPLITTING */
+#endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */
/*
* Notify the peer that the connection is being closed
*/
-int ssl_close_notify( ssl_context *ssl )
+int mbedtls_ssl_close_notify( mbedtls_ssl_context *ssl )
{
int ret;
- SSL_DEBUG_MSG( 2, ( "=> write close notify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write close notify" ) );
if( ssl->out_left != 0 )
- return( ssl_flush_output( ssl ) );
+ return( mbedtls_ssl_flush_output( ssl ) );
- if( ssl->state == SSL_HANDSHAKE_OVER )
+ if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER )
{
- if( ( ret = ssl_send_alert_message( ssl,
- SSL_ALERT_LEVEL_WARNING,
- SSL_ALERT_MSG_CLOSE_NOTIFY ) ) != 0 )
+ if( ( ret = mbedtls_ssl_send_alert_message( ssl,
+ MBEDTLS_SSL_ALERT_LEVEL_WARNING,
+ MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY ) ) != 0 )
{
- SSL_DEBUG_RET( 1, "ssl_send_alert_message", ret );
+ MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_send_alert_message", ret );
return( ret );
}
}
- SSL_DEBUG_MSG( 2, ( "<= write close notify" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write close notify" ) );
return( 0 );
}
-void ssl_transform_free( ssl_transform *transform )
+void mbedtls_ssl_transform_free( mbedtls_ssl_transform *transform )
{
if( transform == NULL )
return;
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
deflateEnd( &transform->ctx_deflate );
inflateEnd( &transform->ctx_inflate );
#endif
- cipher_free( &transform->cipher_ctx_enc );
- cipher_free( &transform->cipher_ctx_dec );
+ mbedtls_cipher_free( &transform->cipher_ctx_enc );
+ mbedtls_cipher_free( &transform->cipher_ctx_dec );
- md_free( &transform->md_ctx_enc );
- md_free( &transform->md_ctx_dec );
+ mbedtls_md_free( &transform->md_ctx_enc );
+ mbedtls_md_free( &transform->md_ctx_dec );
- polarssl_zeroize( transform, sizeof( ssl_transform ) );
+ mbedtls_zeroize( transform, sizeof( mbedtls_ssl_transform ) );
}
-#if defined(POLARSSL_X509_CRT_PARSE_C)
-static void ssl_key_cert_free( ssl_key_cert *key_cert )
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+static void ssl_key_cert_free( mbedtls_ssl_key_cert *key_cert )
{
- ssl_key_cert *cur = key_cert, *next;
+ mbedtls_ssl_key_cert *cur = key_cert, *next;
while( cur != NULL )
{
next = cur->next;
- polarssl_free( cur );
+ mbedtls_free( cur );
cur = next;
}
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
-void ssl_handshake_free( ssl_handshake_params *handshake )
+void mbedtls_ssl_handshake_free( mbedtls_ssl_handshake_params *handshake )
{
if( handshake == NULL )
return;
-#if defined(POLARSSL_DHM_C)
- dhm_free( &handshake->dhm_ctx );
+#if defined(MBEDTLS_DHM_C)
+ mbedtls_dhm_free( &handshake->dhm_ctx );
#endif
-#if defined(POLARSSL_ECDH_C)
- ecdh_free( &handshake->ecdh_ctx );
+#if defined(MBEDTLS_ECDH_C)
+ mbedtls_ecdh_free( &handshake->ecdh_ctx );
#endif
-#if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
+#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
/* explicit void pointer cast for buggy MS compiler */
- polarssl_free( (void *) handshake->curves );
+ mbedtls_free( (void *) handshake->curves );
#endif
-#if defined(POLARSSL_X509_CRT_PARSE_C) && \
- defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
+#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
+ defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
/*
* Free only the linked list wrapper, not the keys themselves
* since the belong to the SNI callback
*/
if( handshake->sni_key_cert != NULL )
{
- ssl_key_cert *cur = handshake->sni_key_cert, *next;
+ mbedtls_ssl_key_cert *cur = handshake->sni_key_cert, *next;
while( cur != NULL )
{
next = cur->next;
- polarssl_free( cur );
+ mbedtls_free( cur );
cur = next;
}
}
-#endif /* POLARSSL_X509_CRT_PARSE_C && POLARSSL_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_SERVER_NAME_INDICATION */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- polarssl_free( handshake->verify_cookie );
- polarssl_free( handshake->hs_msg );
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ mbedtls_free( handshake->verify_cookie );
+ mbedtls_free( handshake->hs_msg );
ssl_flight_free( handshake->flight );
#endif
- polarssl_zeroize( handshake, sizeof( ssl_handshake_params ) );
+ mbedtls_zeroize( handshake, sizeof( mbedtls_ssl_handshake_params ) );
}
-void ssl_session_free( ssl_session *session )
+void mbedtls_ssl_session_free( mbedtls_ssl_session *session )
{
if( session == NULL )
return;
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( session->peer_cert != NULL )
{
- x509_crt_free( session->peer_cert );
- polarssl_free( session->peer_cert );
+ mbedtls_x509_crt_free( session->peer_cert );
+ mbedtls_free( session->peer_cert );
}
#endif
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- polarssl_free( session->ticket );
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ mbedtls_free( session->ticket );
#endif
- polarssl_zeroize( session, sizeof( ssl_session ) );
+ mbedtls_zeroize( session, sizeof( mbedtls_ssl_session ) );
}
/*
* Free an SSL context
*/
-void ssl_free( ssl_context *ssl )
+void mbedtls_ssl_free( mbedtls_ssl_context *ssl )
{
if( ssl == NULL )
return;
- SSL_DEBUG_MSG( 2, ( "=> free" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> free" ) );
if( ssl->out_buf != NULL )
{
- polarssl_zeroize( ssl->out_buf, SSL_BUFFER_LEN );
- polarssl_free( ssl->out_buf );
+ mbedtls_zeroize( ssl->out_buf, MBEDTLS_SSL_BUFFER_LEN );
+ mbedtls_free( ssl->out_buf );
}
if( ssl->in_buf != NULL )
{
- polarssl_zeroize( ssl->in_buf, SSL_BUFFER_LEN );
- polarssl_free( ssl->in_buf );
+ mbedtls_zeroize( ssl->in_buf, MBEDTLS_SSL_BUFFER_LEN );
+ mbedtls_free( ssl->in_buf );
}
-#if defined(POLARSSL_ZLIB_SUPPORT)
+#if defined(MBEDTLS_ZLIB_SUPPORT)
if( ssl->compress_buf != NULL )
{
- polarssl_zeroize( ssl->compress_buf, SSL_BUFFER_LEN );
- polarssl_free( ssl->compress_buf );
+ mbedtls_zeroize( ssl->compress_buf, MBEDTLS_SSL_BUFFER_LEN );
+ mbedtls_free( ssl->compress_buf );
}
#endif
-#if defined(POLARSSL_DHM_C)
- mpi_free( &ssl->dhm_P );
- mpi_free( &ssl->dhm_G );
+#if defined(MBEDTLS_DHM_C)
+ mbedtls_mpi_free( &ssl->dhm_P );
+ mbedtls_mpi_free( &ssl->dhm_G );
#endif
if( ssl->transform )
{
- ssl_transform_free( ssl->transform );
- polarssl_free( ssl->transform );
+ mbedtls_ssl_transform_free( ssl->transform );
+ mbedtls_free( ssl->transform );
}
if( ssl->handshake )
{
- ssl_handshake_free( ssl->handshake );
- ssl_transform_free( ssl->transform_negotiate );
- ssl_session_free( ssl->session_negotiate );
+ mbedtls_ssl_handshake_free( ssl->handshake );
+ mbedtls_ssl_transform_free( ssl->transform_negotiate );
+ mbedtls_ssl_session_free( ssl->session_negotiate );
- polarssl_free( ssl->handshake );
- polarssl_free( ssl->transform_negotiate );
- polarssl_free( ssl->session_negotiate );
+ mbedtls_free( ssl->handshake );
+ mbedtls_free( ssl->transform_negotiate );
+ mbedtls_free( ssl->session_negotiate );
}
if( ssl->session )
{
- ssl_session_free( ssl->session );
- polarssl_free( ssl->session );
+ mbedtls_ssl_session_free( ssl->session );
+ mbedtls_free( ssl->session );
}
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->ticket_keys )
{
ssl_ticket_keys_free( ssl->ticket_keys );
- polarssl_free( ssl->ticket_keys );
+ mbedtls_free( ssl->ticket_keys );
}
#endif
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->hostname != NULL )
{
- polarssl_zeroize( ssl->hostname, ssl->hostname_len );
- polarssl_free( ssl->hostname );
+ mbedtls_zeroize( ssl->hostname, ssl->hostname_len );
+ mbedtls_free( ssl->hostname );
ssl->hostname_len = 0;
}
#endif
-#if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
+#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
if( ssl->psk != NULL )
{
- polarssl_zeroize( ssl->psk, ssl->psk_len );
- polarssl_zeroize( ssl->psk_identity, ssl->psk_identity_len );
- polarssl_free( ssl->psk );
- polarssl_free( ssl->psk_identity );
+ mbedtls_zeroize( ssl->psk, ssl->psk_len );
+ mbedtls_zeroize( ssl->psk_identity, ssl->psk_identity_len );
+ mbedtls_free( ssl->psk );
+ mbedtls_free( ssl->psk_identity );
ssl->psk_len = 0;
ssl->psk_identity_len = 0;
}
#endif
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
ssl_key_cert_free( ssl->key_cert );
#endif
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- if( ssl_hw_record_finish != NULL )
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ if( mbedtls_ssl_hw_record_finish != NULL )
{
- SSL_DEBUG_MSG( 2, ( "going for ssl_hw_record_finish()" ) );
- ssl_hw_record_finish( ssl );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "going for mbedtls_ssl_hw_record_finish()" ) );
+ mbedtls_ssl_hw_record_finish( ssl );
}
#endif
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
- polarssl_free( ssl->cli_id );
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+ mbedtls_free( ssl->cli_id );
#endif
- SSL_DEBUG_MSG( 2, ( "<= free" ) );
+ MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= free" ) );
/* Actually clear after last debug message */
- polarssl_zeroize( ssl, sizeof( ssl_context ) );
+ mbedtls_zeroize( ssl, sizeof( mbedtls_ssl_context ) );
}
-#if defined(POLARSSL_PK_C)
+#if defined(MBEDTLS_PK_C)
/*
- * Convert between POLARSSL_PK_XXX and SSL_SIG_XXX
+ * Convert between MBEDTLS_PK_XXX and SSL_SIG_XXX
*/
-unsigned char ssl_sig_from_pk( pk_context *pk )
+unsigned char mbedtls_ssl_sig_from_pk( mbedtls_pk_context *pk )
{
-#if defined(POLARSSL_RSA_C)
- if( pk_can_do( pk, POLARSSL_PK_RSA ) )
- return( SSL_SIG_RSA );
+#if defined(MBEDTLS_RSA_C)
+ if( mbedtls_pk_can_do( pk, MBEDTLS_PK_RSA ) )
+ return( MBEDTLS_SSL_SIG_RSA );
#endif
-#if defined(POLARSSL_ECDSA_C)
- if( pk_can_do( pk, POLARSSL_PK_ECDSA ) )
- return( SSL_SIG_ECDSA );
+#if defined(MBEDTLS_ECDSA_C)
+ if( mbedtls_pk_can_do( pk, MBEDTLS_PK_ECDSA ) )
+ return( MBEDTLS_SSL_SIG_ECDSA );
#endif
- return( SSL_SIG_ANON );
+ return( MBEDTLS_SSL_SIG_ANON );
}
-pk_type_t ssl_pk_alg_from_sig( unsigned char sig )
+mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig( unsigned char sig )
{
switch( sig )
{
-#if defined(POLARSSL_RSA_C)
- case SSL_SIG_RSA:
- return( POLARSSL_PK_RSA );
+#if defined(MBEDTLS_RSA_C)
+ case MBEDTLS_SSL_SIG_RSA:
+ return( MBEDTLS_PK_RSA );
#endif
-#if defined(POLARSSL_ECDSA_C)
- case SSL_SIG_ECDSA:
- return( POLARSSL_PK_ECDSA );
+#if defined(MBEDTLS_ECDSA_C)
+ case MBEDTLS_SSL_SIG_ECDSA:
+ return( MBEDTLS_PK_ECDSA );
#endif
default:
- return( POLARSSL_PK_NONE );
+ return( MBEDTLS_PK_NONE );
}
}
-#endif /* POLARSSL_PK_C */
+#endif /* MBEDTLS_PK_C */
/*
- * Convert between SSL_HASH_XXX and POLARSSL_MD_XXX
+ * Convert between SSL_HASH_XXX and MBEDTLS_MD_XXX
*/
-md_type_t ssl_md_alg_from_hash( unsigned char hash )
+mbedtls_md_type_t mbedtls_ssl_md_alg_from_hash( unsigned char hash )
{
switch( hash )
{
-#if defined(POLARSSL_MD5_C)
- case SSL_HASH_MD5:
- return( POLARSSL_MD_MD5 );
+#if defined(MBEDTLS_MD5_C)
+ case MBEDTLS_SSL_HASH_MD5:
+ return( MBEDTLS_MD_MD5 );
#endif
-#if defined(POLARSSL_SHA1_C)
- case SSL_HASH_SHA1:
- return( POLARSSL_MD_SHA1 );
+#if defined(MBEDTLS_SHA1_C)
+ case MBEDTLS_SSL_HASH_SHA1:
+ return( MBEDTLS_MD_SHA1 );
#endif
-#if defined(POLARSSL_SHA256_C)
- case SSL_HASH_SHA224:
- return( POLARSSL_MD_SHA224 );
- case SSL_HASH_SHA256:
- return( POLARSSL_MD_SHA256 );
+#if defined(MBEDTLS_SHA256_C)
+ case MBEDTLS_SSL_HASH_SHA224:
+ return( MBEDTLS_MD_SHA224 );
+ case MBEDTLS_SSL_HASH_SHA256:
+ return( MBEDTLS_MD_SHA256 );
#endif
-#if defined(POLARSSL_SHA512_C)
- case SSL_HASH_SHA384:
- return( POLARSSL_MD_SHA384 );
- case SSL_HASH_SHA512:
- return( POLARSSL_MD_SHA512 );
+#if defined(MBEDTLS_SHA512_C)
+ case MBEDTLS_SSL_HASH_SHA384:
+ return( MBEDTLS_MD_SHA384 );
+ case MBEDTLS_SSL_HASH_SHA512:
+ return( MBEDTLS_MD_SHA512 );
#endif
default:
- return( POLARSSL_MD_NONE );
+ return( MBEDTLS_MD_NONE );
}
}
-#if defined(POLARSSL_SSL_SET_CURVES)
+#if defined(MBEDTLS_SSL_SET_CURVES)
/*
* Check is a curve proposed by the peer is in our list.
* Return 1 if we're willing to use it, 0 otherwise.
*/
-int ssl_curve_is_acceptable( const ssl_context *ssl, ecp_group_id grp_id )
+int mbedtls_ssl_curve_is_acceptable( const mbedtls_ssl_context *ssl, mbedtls_ecp_group_id grp_id )
{
- const ecp_group_id *gid;
+ const mbedtls_ecp_group_id *gid;
- for( gid = ssl->curve_list; *gid != POLARSSL_ECP_DP_NONE; gid++ )
+ for( gid = ssl->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++ )
if( *gid == grp_id )
return( 1 );
return( 0 );
}
-#endif /* POLARSSL_SSL_SET_CURVES */
+#endif /* MBEDTLS_SSL_SET_CURVES */
-#if defined(POLARSSL_X509_CRT_PARSE_C)
-int ssl_check_cert_usage( const x509_crt *cert,
- const ssl_ciphersuite_t *ciphersuite,
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+int mbedtls_ssl_check_cert_usage( const mbedtls_x509_crt *cert,
+ const mbedtls_ssl_ciphersuite_t *ciphersuite,
int cert_endpoint )
{
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
int usage = 0;
#endif
-#if defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
+#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
const char *ext_oid;
size_t ext_len;
#endif
-#if !defined(POLARSSL_X509_CHECK_KEY_USAGE) && \
- !defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
+#if !defined(MBEDTLS_X509_CHECK_KEY_USAGE) && \
+ !defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
((void) cert);
((void) cert_endpoint);
#endif
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
- if( cert_endpoint == SSL_IS_SERVER )
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
+ if( cert_endpoint == MBEDTLS_SSL_IS_SERVER )
{
/* Server part of the key exchange */
switch( ciphersuite->key_exchange )
{
- case POLARSSL_KEY_EXCHANGE_RSA:
- case POLARSSL_KEY_EXCHANGE_RSA_PSK:
- usage = KU_KEY_ENCIPHERMENT;
+ case MBEDTLS_KEY_EXCHANGE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
+ usage = MBEDTLS_KU_KEY_ENCIPHERMENT;
break;
- case POLARSSL_KEY_EXCHANGE_DHE_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDHE_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA:
- usage = KU_DIGITAL_SIGNATURE;
+ case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
+ usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
break;
- case POLARSSL_KEY_EXCHANGE_ECDH_RSA:
- case POLARSSL_KEY_EXCHANGE_ECDH_ECDSA:
- usage = KU_KEY_AGREEMENT;
+ case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
+ case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
+ usage = MBEDTLS_KU_KEY_AGREEMENT;
break;
/* Don't use default: we want warnings when adding new values */
- case POLARSSL_KEY_EXCHANGE_NONE:
- case POLARSSL_KEY_EXCHANGE_PSK:
- case POLARSSL_KEY_EXCHANGE_DHE_PSK:
- case POLARSSL_KEY_EXCHANGE_ECDHE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_NONE:
+ case MBEDTLS_KEY_EXCHANGE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
+ case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
usage = 0;
}
}
else
{
- /* Client auth: we only implement rsa_sign and ecdsa_sign for now */
- usage = KU_DIGITAL_SIGNATURE;
+ /* Client auth: we only implement rsa_sign and mbedtls_ecdsa_sign for now */
+ usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
}
- if( x509_crt_check_key_usage( cert, usage ) != 0 )
+ if( mbedtls_x509_crt_check_key_usage( cert, usage ) != 0 )
return( -1 );
#else
((void) ciphersuite);
-#endif /* POLARSSL_X509_CHECK_KEY_USAGE */
+#endif /* MBEDTLS_X509_CHECK_KEY_USAGE */
-#if defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
- if( cert_endpoint == SSL_IS_SERVER )
+#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
+ if( cert_endpoint == MBEDTLS_SSL_IS_SERVER )
{
- ext_oid = OID_SERVER_AUTH;
- ext_len = OID_SIZE( OID_SERVER_AUTH );
+ ext_oid = MBEDTLS_OID_SERVER_AUTH;
+ ext_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_SERVER_AUTH );
}
else
{
- ext_oid = OID_CLIENT_AUTH;
- ext_len = OID_SIZE( OID_CLIENT_AUTH );
+ ext_oid = MBEDTLS_OID_CLIENT_AUTH;
+ ext_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_CLIENT_AUTH );
}
- if( x509_crt_check_extended_key_usage( cert, ext_oid, ext_len ) != 0 )
+ if( mbedtls_x509_crt_check_extended_key_usage( cert, ext_oid, ext_len ) != 0 )
return( -1 );
-#endif /* POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE */
+#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
return( 0 );
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
/*
* Convert version numbers to/from wire format
@@ -6861,13 +6861,13 @@
* 1.0 <-> 3.2 (DTLS 1.0 is based on TLS 1.1)
* 1.x <-> 3.x+1 for x != 0 (DTLS 1.2 based on TLS 1.2)
*/
-void ssl_write_version( int major, int minor, int transport,
+void mbedtls_ssl_write_version( int major, int minor, int transport,
unsigned char ver[2] )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
- if( minor == SSL_MINOR_VERSION_2 )
+ if( minor == MBEDTLS_SSL_MINOR_VERSION_2 )
--minor; /* DTLS 1.0 stored as TLS 1.1 internally */
ver[0] = (unsigned char)( 255 - ( major - 2 ) );
@@ -6883,16 +6883,16 @@
}
}
-void ssl_read_version( int *major, int *minor, int transport,
+void mbedtls_ssl_read_version( int *major, int *minor, int transport,
const unsigned char ver[2] )
{
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- if( transport == SSL_TRANSPORT_DATAGRAM )
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ if( transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
*major = 255 - ver[0] + 2;
*minor = 255 - ver[1] + 1;
- if( *minor == SSL_MINOR_VERSION_1 )
+ if( *minor == MBEDTLS_SSL_MINOR_VERSION_1 )
++*minor; /* DTLS 1.0 stored as TLS 1.1 internally */
}
else
@@ -6905,4 +6905,4 @@
}
}
-#endif /* POLARSSL_SSL_TLS_C */
+#endif /* MBEDTLS_SSL_TLS_C */
diff --git a/library/threading.c b/library/threading.c
index b383efe..787efec 100644
--- a/library/threading.c
+++ b/library/threading.c
@@ -20,91 +20,91 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_THREADING_C)
+#if defined(MBEDTLS_THREADING_C)
#include "mbedtls/threading.h"
-#if defined(POLARSSL_THREADING_PTHREAD)
-static int threading_mutex_init_pthread( threading_mutex_t *mutex )
+#if defined(MBEDTLS_THREADING_PTHREAD)
+static int threading_mutex_init_pthread( mbedtls_threading_mutex_t *mutex )
{
if( mutex == NULL )
- return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
if( pthread_mutex_init( mutex, NULL ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
return( 0 );
}
-static int threading_mutex_free_pthread( threading_mutex_t *mutex )
+static int threading_mutex_free_pthread( mbedtls_threading_mutex_t *mutex )
{
if( mutex == NULL )
- return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
if( pthread_mutex_destroy( mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
return( 0 );
}
-static int threading_mutex_lock_pthread( threading_mutex_t *mutex )
+static int threading_mutex_lock_pthread( mbedtls_threading_mutex_t *mutex )
{
if( mutex == NULL )
- return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
if( pthread_mutex_lock( mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
return( 0 );
}
-static int threading_mutex_unlock_pthread( threading_mutex_t *mutex )
+static int threading_mutex_unlock_pthread( mbedtls_threading_mutex_t *mutex )
{
if( mutex == NULL )
- return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
if( pthread_mutex_unlock( mutex ) != 0 )
- return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+ return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
return( 0 );
}
-int (*polarssl_mutex_init)( threading_mutex_t * ) = threading_mutex_init_pthread;
-int (*polarssl_mutex_free)( threading_mutex_t * ) = threading_mutex_free_pthread;
-int (*polarssl_mutex_lock)( threading_mutex_t * ) = threading_mutex_lock_pthread;
-int (*polarssl_mutex_unlock)( threading_mutex_t * ) = threading_mutex_unlock_pthread;
-#endif /* POLARSSL_THREADING_PTHREAD */
+int (*mbedtls_mutex_init)( mbedtls_threading_mutex_t * ) = threading_mutex_init_pthread;
+int (*mbedtls_mutex_free)( mbedtls_threading_mutex_t * ) = threading_mutex_free_pthread;
+int (*mbedtls_mutex_lock)( mbedtls_threading_mutex_t * ) = threading_mutex_lock_pthread;
+int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t * ) = threading_mutex_unlock_pthread;
+#endif /* MBEDTLS_THREADING_PTHREAD */
-#if defined(POLARSSL_THREADING_ALT)
-static int threading_mutex_fail( threading_mutex_t *mutex )
+#if defined(MBEDTLS_THREADING_ALT)
+static int threading_mutex_fail( mbedtls_threading_mutex_t *mutex )
{
((void) mutex );
- return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_THREADING_BAD_INPUT_DATA );
}
-int (*polarssl_mutex_init)( threading_mutex_t * ) = threading_mutex_fail;
-int (*polarssl_mutex_free)( threading_mutex_t * ) = threading_mutex_fail;
-int (*polarssl_mutex_lock)( threading_mutex_t * ) = threading_mutex_fail;
-int (*polarssl_mutex_unlock)( threading_mutex_t * ) = threading_mutex_fail;
+int (*mbedtls_mutex_init)( mbedtls_threading_mutex_t * ) = threading_mutex_fail;
+int (*mbedtls_mutex_free)( mbedtls_threading_mutex_t * ) = threading_mutex_fail;
+int (*mbedtls_mutex_lock)( mbedtls_threading_mutex_t * ) = threading_mutex_fail;
+int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t * ) = threading_mutex_fail;
-int threading_set_alt( int (*mutex_init)( threading_mutex_t * ),
- int (*mutex_free)( threading_mutex_t * ),
- int (*mutex_lock)( threading_mutex_t * ),
- int (*mutex_unlock)( threading_mutex_t * ) )
+int mbedtls_threading_set_alt( int (*mutex_init)( mbedtls_threading_mutex_t * ),
+ int (*mutex_free)( mbedtls_threading_mutex_t * ),
+ int (*mutex_lock)( mbedtls_threading_mutex_t * ),
+ int (*mutex_unlock)( mbedtls_threading_mutex_t * ) )
{
- polarssl_mutex_init = mutex_init;
- polarssl_mutex_free = mutex_free;
- polarssl_mutex_lock = mutex_lock;
- polarssl_mutex_unlock = mutex_unlock;
+ mbedtls_mutex_init = mutex_init;
+ mbedtls_mutex_free = mutex_free;
+ mbedtls_mutex_lock = mutex_lock;
+ mbedtls_mutex_unlock = mutex_unlock;
return( 0 );
}
-#endif /* POLARSSL_THREADING_ALT */
+#endif /* MBEDTLS_THREADING_ALT */
-#endif /* POLARSSL_THREADING_C */
+#endif /* MBEDTLS_THREADING_C */
diff --git a/library/timing.c b/library/timing.c
index 751b0b4..33f5239 100644
--- a/library/timing.c
+++ b/library/timing.c
@@ -20,20 +20,20 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_SELF_TEST) && defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
+#define mbedtls_printf printf
#endif
-#if defined(POLARSSL_TIMING_C) && !defined(POLARSSL_TIMING_ALT)
+#if defined(MBEDTLS_TIMING_C) && !defined(MBEDTLS_TIMING_ALT)
#include "mbedtls/timing.h"
@@ -62,57 +62,57 @@
#endif /* _WIN32 && !EFIX64 && !EFI32 */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
( defined(_MSC_VER) && defined(_M_IX86) ) || defined(__WATCOMC__)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long tsc;
__asm rdtsc
__asm mov [tsc], eax
return( tsc );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
( _MSC_VER && _M_IX86 ) || __WATCOMC__ */
/* some versions of mingw-64 have 32-bit longs even on x84_64 */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && ( defined(__i386__) || ( \
( defined(__amd64__) || defined( __x86_64__) ) && __SIZEOF_LONG__ == 4 ) )
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long lo, hi;
asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );
return( lo );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && __i386__ */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && ( defined(__amd64__) || defined(__x86_64__) )
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long lo, hi;
asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );
return( lo | ( hi << 32 ) );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && ( __amd64__ || __x86_64__ ) */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && ( defined(__powerpc__) || defined(__ppc__) )
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long tbl, tbu0, tbu1;
@@ -126,76 +126,76 @@
return( tbl );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && ( __powerpc__ || __ppc__ ) */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && defined(__sparc64__)
#if defined(__OpenBSD__)
#warning OpenBSD does not allow access to tick register using software version instead
#else
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long tick;
asm volatile( "rdpr %%tick, %0;" : "=&r" (tick) );
return( tick );
}
#endif /* __OpenBSD__ */
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && __sparc64__ */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && defined(__sparc__) && !defined(__sparc64__)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long tick;
asm volatile( ".byte 0x83, 0x41, 0x00, 0x00" );
asm volatile( "mov %%g1, %0" : "=r" (tick) );
return( tick );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && __sparc__ && !__sparc64__ */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && defined(__alpha__)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long cc;
asm volatile( "rpcc %0" : "=r" (cc) );
return( cc & 0xFFFFFFFF );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && __alpha__ */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
defined(__GNUC__) && defined(__ia64__)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
unsigned long itc;
asm volatile( "mov %0 = ar.itc" : "=r" (itc) );
return( itc );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && POLARSSL_HAVE_ASM &&
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
__GNUC__ && __ia64__ */
-#if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(_MSC_VER) && \
+#if !defined(MBEDTLS_HAVE_HARDCLOCK) && defined(_MSC_VER) && \
!defined(EFIX64) && !defined(EFI32)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
LARGE_INTEGER offset;
@@ -203,16 +203,16 @@
return( (unsigned long)( offset.QuadPart ) );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK && _MSC_VER && !EFIX64 && !EFI32 */
+#endif /* !MBEDTLS_HAVE_HARDCLOCK && _MSC_VER && !EFIX64 && !EFI32 */
-#if !defined(POLARSSL_HAVE_HARDCLOCK)
+#if !defined(MBEDTLS_HAVE_HARDCLOCK)
-#define POLARSSL_HAVE_HARDCLOCK
+#define MBEDTLS_HAVE_HARDCLOCK
static int hardclock_init = 0;
static struct timeval tv_init;
-unsigned long hardclock( void )
+unsigned long mbedtls_timing_hardclock( void )
{
struct timeval tv_cur;
@@ -226,13 +226,13 @@
return( ( tv_cur.tv_sec - tv_init.tv_sec ) * 1000000
+ ( tv_cur.tv_usec - tv_init.tv_usec ) );
}
-#endif /* !POLARSSL_HAVE_HARDCLOCK */
+#endif /* !MBEDTLS_HAVE_HARDCLOCK */
-volatile int alarmed = 0;
+volatile int mbedtls_timing_alarmed = 0;
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
-unsigned long get_timer( struct hr_time *val, int reset )
+unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )
{
unsigned long delta;
LARGE_INTEGER offset, hfreq;
@@ -258,27 +258,27 @@
{
((void) TimerContext);
Sleep( alarmMs );
- alarmed = 1;
+ mbedtls_timing_alarmed = 1;
return( TRUE );
}
-void set_alarm( int seconds )
+void mbedtls_set_alarm( int seconds )
{
DWORD ThreadId;
- alarmed = 0;
+ mbedtls_timing_alarmed = 0;
alarmMs = seconds * 1000;
CloseHandle( CreateThread( NULL, 0, TimerProc, NULL, 0, &ThreadId ) );
}
-void m_sleep( int milliseconds )
+void mbedtls_timing_m_sleep( int milliseconds )
{
Sleep( milliseconds );
}
#else /* _WIN32 && !EFIX64 && !EFI32 */
-unsigned long get_timer( struct hr_time *val, int reset )
+unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )
{
unsigned long delta;
struct timeval offset;
@@ -300,7 +300,7 @@
}
#if defined(INTEGRITY)
-void m_sleep( int milliseconds )
+void mbedtls_timing_m_sleep( int milliseconds )
{
usleep( milliseconds * 1000 );
}
@@ -309,18 +309,18 @@
static void sighandler( int signum )
{
- alarmed = 1;
+ mbedtls_timing_alarmed = 1;
signal( signum, sighandler );
}
-void set_alarm( int seconds )
+void mbedtls_set_alarm( int seconds )
{
- alarmed = 0;
+ mbedtls_timing_alarmed = 0;
signal( SIGALRM, sighandler );
alarm( seconds );
}
-void m_sleep( int milliseconds )
+void mbedtls_timing_m_sleep( int milliseconds )
{
struct timeval tv;
@@ -333,26 +333,26 @@
#endif /* _WIN32 && !EFIX64 && !EFI32 */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
-/* To test net_usleep against our functions */
-#if defined(POLARSSL_NET_C) && defined(POLARSSL_HAVE_TIME)
+/* To test mbedtls_net_usleep against our functions */
+#if defined(MBEDTLS_NET_C) && defined(MBEDTLS_HAVE_TIME)
#include "mbedtls/net.h"
#endif
/*
* Busy-waits for the given number of milliseconds.
- * Used for testing hardclock.
+ * Used for testing mbedtls_timing_hardclock.
*/
static void busy_msleep( unsigned long msec )
{
- struct hr_time hires;
+ struct mbedtls_timing_hr_time hires;
unsigned long i = 0; /* for busy-waiting */
volatile unsigned long j; /* to prevent optimisation */
- (void) get_timer( &hires, 1 );
+ (void) mbedtls_timing_get_timer( &hires, 1 );
- while( get_timer( &hires, 0 ) < msec )
+ while( mbedtls_timing_get_timer( &hires, 0 ) < msec )
i++;
j = i;
@@ -365,66 +365,66 @@
* Warning: this is work in progress, some tests may not be reliable enough
* yet! False positives may happen.
*/
-int timing_self_test( int verbose )
+int mbedtls_timing_self_test( int verbose )
{
unsigned long cycles, ratio;
unsigned long millisecs, secs;
int hardfail;
- struct hr_time hires;
+ struct mbedtls_timing_hr_time hires;
if( verbose != 0 )
- polarssl_printf( " TIMING tests note: will take some time!\n" );
+ mbedtls_printf( " TIMING tests note: will take some time!\n" );
if( verbose != 0 )
- polarssl_printf( " TIMING test #1 (m_sleep / get_timer): " );
+ mbedtls_printf( " TIMING test #1 (m_sleep / get_timer): " );
for( secs = 1; secs <= 3; secs++ )
{
- (void) get_timer( &hires, 1 );
+ (void) mbedtls_timing_get_timer( &hires, 1 );
- m_sleep( (int)( 500 * secs ) );
+ mbedtls_timing_m_sleep( (int)( 500 * secs ) );
- millisecs = get_timer( &hires, 0 );
+ millisecs = mbedtls_timing_get_timer( &hires, 0 );
if( millisecs < 450 * secs || millisecs > 550 * secs )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " TIMING test #2 (set_alarm / get_timer): " );
+ mbedtls_printf( " TIMING test #2 (set_alarm / get_timer): " );
for( secs = 1; secs <= 3; secs++ )
{
- (void) get_timer( &hires, 1 );
+ (void) mbedtls_timing_get_timer( &hires, 1 );
- set_alarm( (int) secs );
- while( !alarmed )
+ mbedtls_set_alarm( (int) secs );
+ while( !mbedtls_timing_alarmed )
;
- millisecs = get_timer( &hires, 0 );
+ millisecs = mbedtls_timing_get_timer( &hires, 0 );
if( millisecs < 900 * secs || millisecs > 1100 * secs )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
if( verbose != 0 )
- polarssl_printf( " TIMING test #3 (hardclock / get_timer): " );
+ mbedtls_printf( " TIMING test #3 (hardclock / get_timer): " );
/*
* Allow one failure for possible counter wrapping.
@@ -437,24 +437,24 @@
if( hardfail > 1 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
/* Get a reference ratio cycles/ms */
millisecs = 1;
- cycles = hardclock();
+ cycles = mbedtls_timing_hardclock();
busy_msleep( millisecs );
- cycles = hardclock() - cycles;
+ cycles = mbedtls_timing_hardclock() - cycles;
ratio = cycles / millisecs;
/* Check that the ratio is mostly constant */
for( millisecs = 2; millisecs <= 4; millisecs++ )
{
- cycles = hardclock();
+ cycles = mbedtls_timing_hardclock();
busy_msleep( millisecs );
- cycles = hardclock() - cycles;
+ cycles = mbedtls_timing_hardclock() - cycles;
/* Allow variation up to 20% */
if( cycles / millisecs < ratio - ratio / 5 ||
@@ -466,39 +466,39 @@
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
-#if defined(POLARSSL_NET_C) && defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_NET_C) && defined(MBEDTLS_HAVE_TIME)
if( verbose != 0 )
- polarssl_printf( " TIMING test #4 (net_usleep/ get_timer): " );
+ mbedtls_printf( " TIMING test #4 (net_usleep/ get_timer): " );
for( secs = 1; secs <= 3; secs++ )
{
- (void) get_timer( &hires, 1 );
+ (void) mbedtls_timing_get_timer( &hires, 1 );
- net_usleep( 500000 * secs );
+ mbedtls_net_usleep( 500000 * secs );
- millisecs = get_timer( &hires, 0 );
+ millisecs = mbedtls_timing_get_timer( &hires, 0 );
if( millisecs < 450 * secs || millisecs > 550 * secs )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
-#endif /* POLARSSL_NET_C */
+ mbedtls_printf( "passed\n" );
+#endif /* MBEDTLS_NET_C */
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
return( 0 );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_TIMING_C && !POLARSSL_TIMING_ALT */
+#endif /* MBEDTLS_TIMING_C && !MBEDTLS_TIMING_ALT */
diff --git a/library/version.c b/library/version.c
index c3af429..4e881f0 100644
--- a/library/version.c
+++ b/library/version.c
@@ -20,32 +20,32 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_VERSION_C)
+#if defined(MBEDTLS_VERSION_C)
#include "mbedtls/version.h"
#include <string.h>
-unsigned int version_get_number()
+unsigned int mbedtls_version_get_number()
{
- return( POLARSSL_VERSION_NUMBER );
+ return( MBEDTLS_VERSION_NUMBER );
}
-void version_get_string( char *string )
+void mbedtls_version_get_string( char *string )
{
- memcpy( string, POLARSSL_VERSION_STRING,
- sizeof( POLARSSL_VERSION_STRING ) );
+ memcpy( string, MBEDTLS_VERSION_STRING,
+ sizeof( MBEDTLS_VERSION_STRING ) );
}
-void version_get_string_full( char *string )
+void mbedtls_version_get_string_full( char *string )
{
- memcpy( string, POLARSSL_VERSION_STRING_FULL,
- sizeof( POLARSSL_VERSION_STRING_FULL ) );
+ memcpy( string, MBEDTLS_VERSION_STRING_FULL,
+ sizeof( MBEDTLS_VERSION_STRING_FULL ) );
}
-#endif /* POLARSSL_VERSION_C */
+#endif /* MBEDTLS_VERSION_C */
diff --git a/library/version_features.c b/library/version_features.c
index bba5dc0..e03dfbe 100644
--- a/library/version_features.c
+++ b/library/version_features.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_VERSION_C)
+#if defined(MBEDTLS_VERSION_C)
#include "mbedtls/version.h"
@@ -38,567 +38,567 @@
#endif
static const char *features[] = {
-#if defined(POLARSSL_VERSION_FEATURES)
-#if defined(POLARSSL_HAVE_INT8)
- "POLARSSL_HAVE_INT8",
-#endif /* POLARSSL_HAVE_INT8 */
-#if defined(POLARSSL_HAVE_INT16)
- "POLARSSL_HAVE_INT16",
-#endif /* POLARSSL_HAVE_INT16 */
-#if defined(POLARSSL_HAVE_LONGLONG)
- "POLARSSL_HAVE_LONGLONG",
-#endif /* POLARSSL_HAVE_LONGLONG */
-#if defined(POLARSSL_HAVE_ASM)
- "POLARSSL_HAVE_ASM",
-#endif /* POLARSSL_HAVE_ASM */
-#if defined(POLARSSL_HAVE_SSE2)
- "POLARSSL_HAVE_SSE2",
-#endif /* POLARSSL_HAVE_SSE2 */
-#if defined(POLARSSL_HAVE_TIME)
- "POLARSSL_HAVE_TIME",
-#endif /* POLARSSL_HAVE_TIME */
-#if defined(POLARSSL_HAVE_IPV6)
- "POLARSSL_HAVE_IPV6",
-#endif /* POLARSSL_HAVE_IPV6 */
-#if defined(POLARSSL_PLATFORM_MEMORY)
- "POLARSSL_PLATFORM_MEMORY",
-#endif /* POLARSSL_PLATFORM_MEMORY */
-#if defined(POLARSSL_PLATFORM_NO_STD_FUNCTIONS)
- "POLARSSL_PLATFORM_NO_STD_FUNCTIONS",
-#endif /* POLARSSL_PLATFORM_NO_STD_FUNCTIONS */
-#if defined(POLARSSL_PLATFORM_EXIT_ALT)
- "POLARSSL_PLATFORM_EXIT_ALT",
-#endif /* POLARSSL_PLATFORM_EXIT_ALT */
-#if defined(POLARSSL_PLATFORM_FPRINTF_ALT)
- "POLARSSL_PLATFORM_FPRINTF_ALT",
-#endif /* POLARSSL_PLATFORM_FPRINTF_ALT */
-#if defined(POLARSSL_PLATFORM_PRINTF_ALT)
- "POLARSSL_PLATFORM_PRINTF_ALT",
-#endif /* POLARSSL_PLATFORM_PRINTF_ALT */
-#if defined(POLARSSL_PLATFORM_SNPRINTF_ALT)
- "POLARSSL_PLATFORM_SNPRINTF_ALT",
-#endif /* POLARSSL_PLATFORM_SNPRINTF_ALT */
-#if defined(POLARSSL_DEPRECATED_WARNING)
- "POLARSSL_DEPRECATED_WARNING",
-#endif /* POLARSSL_DEPRECATED_WARNING */
-#if defined(POLARSSL_DEPRECATED_REMOVED)
- "POLARSSL_DEPRECATED_REMOVED",
-#endif /* POLARSSL_DEPRECATED_REMOVED */
-#if defined(POLARSSL_TIMING_ALT)
- "POLARSSL_TIMING_ALT",
-#endif /* POLARSSL_TIMING_ALT */
-#if defined(POLARSSL_AES_ALT)
- "POLARSSL_AES_ALT",
-#endif /* POLARSSL_AES_ALT */
-#if defined(POLARSSL_ARC4_ALT)
- "POLARSSL_ARC4_ALT",
-#endif /* POLARSSL_ARC4_ALT */
-#if defined(POLARSSL_BLOWFISH_ALT)
- "POLARSSL_BLOWFISH_ALT",
-#endif /* POLARSSL_BLOWFISH_ALT */
-#if defined(POLARSSL_CAMELLIA_ALT)
- "POLARSSL_CAMELLIA_ALT",
-#endif /* POLARSSL_CAMELLIA_ALT */
-#if defined(POLARSSL_DES_ALT)
- "POLARSSL_DES_ALT",
-#endif /* POLARSSL_DES_ALT */
-#if defined(POLARSSL_XTEA_ALT)
- "POLARSSL_XTEA_ALT",
-#endif /* POLARSSL_XTEA_ALT */
-#if defined(POLARSSL_MD2_ALT)
- "POLARSSL_MD2_ALT",
-#endif /* POLARSSL_MD2_ALT */
-#if defined(POLARSSL_MD4_ALT)
- "POLARSSL_MD4_ALT",
-#endif /* POLARSSL_MD4_ALT */
-#if defined(POLARSSL_MD5_ALT)
- "POLARSSL_MD5_ALT",
-#endif /* POLARSSL_MD5_ALT */
-#if defined(POLARSSL_RIPEMD160_ALT)
- "POLARSSL_RIPEMD160_ALT",
-#endif /* POLARSSL_RIPEMD160_ALT */
-#if defined(POLARSSL_SHA1_ALT)
- "POLARSSL_SHA1_ALT",
-#endif /* POLARSSL_SHA1_ALT */
-#if defined(POLARSSL_SHA256_ALT)
- "POLARSSL_SHA256_ALT",
-#endif /* POLARSSL_SHA256_ALT */
-#if defined(POLARSSL_SHA512_ALT)
- "POLARSSL_SHA512_ALT",
-#endif /* POLARSSL_SHA512_ALT */
-#if defined(POLARSSL_MD2_PROCESS_ALT)
- "POLARSSL_MD2_PROCESS_ALT",
-#endif /* POLARSSL_MD2_PROCESS_ALT */
-#if defined(POLARSSL_MD4_PROCESS_ALT)
- "POLARSSL_MD4_PROCESS_ALT",
-#endif /* POLARSSL_MD4_PROCESS_ALT */
-#if defined(POLARSSL_MD5_PROCESS_ALT)
- "POLARSSL_MD5_PROCESS_ALT",
-#endif /* POLARSSL_MD5_PROCESS_ALT */
-#if defined(POLARSSL_RIPEMD160_PROCESS_ALT)
- "POLARSSL_RIPEMD160_PROCESS_ALT",
-#endif /* POLARSSL_RIPEMD160_PROCESS_ALT */
-#if defined(POLARSSL_SHA1_PROCESS_ALT)
- "POLARSSL_SHA1_PROCESS_ALT",
-#endif /* POLARSSL_SHA1_PROCESS_ALT */
-#if defined(POLARSSL_SHA256_PROCESS_ALT)
- "POLARSSL_SHA256_PROCESS_ALT",
-#endif /* POLARSSL_SHA256_PROCESS_ALT */
-#if defined(POLARSSL_SHA512_PROCESS_ALT)
- "POLARSSL_SHA512_PROCESS_ALT",
-#endif /* POLARSSL_SHA512_PROCESS_ALT */
-#if defined(POLARSSL_AES_ROM_TABLES)
- "POLARSSL_AES_ROM_TABLES",
-#endif /* POLARSSL_AES_ROM_TABLES */
-#if defined(POLARSSL_CAMELLIA_SMALL_MEMORY)
- "POLARSSL_CAMELLIA_SMALL_MEMORY",
-#endif /* POLARSSL_CAMELLIA_SMALL_MEMORY */
-#if defined(POLARSSL_CIPHER_MODE_CBC)
- "POLARSSL_CIPHER_MODE_CBC",
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#if defined(POLARSSL_CIPHER_MODE_CFB)
- "POLARSSL_CIPHER_MODE_CFB",
-#endif /* POLARSSL_CIPHER_MODE_CFB */
-#if defined(POLARSSL_CIPHER_MODE_CTR)
- "POLARSSL_CIPHER_MODE_CTR",
-#endif /* POLARSSL_CIPHER_MODE_CTR */
-#if defined(POLARSSL_CIPHER_NULL_CIPHER)
- "POLARSSL_CIPHER_NULL_CIPHER",
-#endif /* POLARSSL_CIPHER_NULL_CIPHER */
-#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
- "POLARSSL_CIPHER_PADDING_PKCS7",
-#endif /* POLARSSL_CIPHER_PADDING_PKCS7 */
-#if defined(POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS)
- "POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS",
-#endif /* POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS */
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN)
- "POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN",
-#endif /* POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN */
-#if defined(POLARSSL_CIPHER_PADDING_ZEROS)
- "POLARSSL_CIPHER_PADDING_ZEROS",
-#endif /* POLARSSL_CIPHER_PADDING_ZEROS */
-#if defined(POLARSSL_ENABLE_WEAK_CIPHERSUITES)
- "POLARSSL_ENABLE_WEAK_CIPHERSUITES",
-#endif /* POLARSSL_ENABLE_WEAK_CIPHERSUITES */
-#if defined(POLARSSL_REMOVE_ARC4_CIPHERSUITES)
- "POLARSSL_REMOVE_ARC4_CIPHERSUITES",
-#endif /* POLARSSL_REMOVE_ARC4_CIPHERSUITES */
-#if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
- "POLARSSL_ECP_DP_SECP192R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP192R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
- "POLARSSL_ECP_DP_SECP224R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP224R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
- "POLARSSL_ECP_DP_SECP256R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP256R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
- "POLARSSL_ECP_DP_SECP384R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP384R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
- "POLARSSL_ECP_DP_SECP521R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP521R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP192K1_ENABLED)
- "POLARSSL_ECP_DP_SECP192K1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP192K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP224K1_ENABLED)
- "POLARSSL_ECP_DP_SECP224K1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP224K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_SECP256K1_ENABLED)
- "POLARSSL_ECP_DP_SECP256K1_ENABLED",
-#endif /* POLARSSL_ECP_DP_SECP256K1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP256R1_ENABLED)
- "POLARSSL_ECP_DP_BP256R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_BP256R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP384R1_ENABLED)
- "POLARSSL_ECP_DP_BP384R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_BP384R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_BP512R1_ENABLED)
- "POLARSSL_ECP_DP_BP512R1_ENABLED",
-#endif /* POLARSSL_ECP_DP_BP512R1_ENABLED */
-#if defined(POLARSSL_ECP_DP_M221_ENABLED)
- "POLARSSL_ECP_DP_M221_ENABLED",
-#endif /* POLARSSL_ECP_DP_M221_ENABLED */
-#if defined(POLARSSL_ECP_DP_M255_ENABLED)
- "POLARSSL_ECP_DP_M255_ENABLED",
-#endif /* POLARSSL_ECP_DP_M255_ENABLED */
-#if defined(POLARSSL_ECP_DP_M383_ENABLED)
- "POLARSSL_ECP_DP_M383_ENABLED",
-#endif /* POLARSSL_ECP_DP_M383_ENABLED */
-#if defined(POLARSSL_ECP_DP_M511_ENABLED)
- "POLARSSL_ECP_DP_M511_ENABLED",
-#endif /* POLARSSL_ECP_DP_M511_ENABLED */
-#if defined(POLARSSL_ECP_NIST_OPTIM)
- "POLARSSL_ECP_NIST_OPTIM",
-#endif /* POLARSSL_ECP_NIST_OPTIM */
-#if defined(POLARSSL_ECDSA_DETERMINISTIC)
- "POLARSSL_ECDSA_DETERMINISTIC",
-#endif /* POLARSSL_ECDSA_DETERMINISTIC */
-#if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
- "POLARSSL_KEY_EXCHANGE_PSK_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
- "POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
- "POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
- "POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_RSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
-#if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED)
- "POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED",
-#endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED */
-#if defined(POLARSSL_PK_PARSE_EC_EXTENDED)
- "POLARSSL_PK_PARSE_EC_EXTENDED",
-#endif /* POLARSSL_PK_PARSE_EC_EXTENDED */
-#if defined(POLARSSL_ERROR_STRERROR_DUMMY)
- "POLARSSL_ERROR_STRERROR_DUMMY",
-#endif /* POLARSSL_ERROR_STRERROR_DUMMY */
-#if defined(POLARSSL_GENPRIME)
- "POLARSSL_GENPRIME",
-#endif /* POLARSSL_GENPRIME */
-#if defined(POLARSSL_FS_IO)
- "POLARSSL_FS_IO",
-#endif /* POLARSSL_FS_IO */
-#if defined(POLARSSL_NO_DEFAULT_ENTROPY_SOURCES)
- "POLARSSL_NO_DEFAULT_ENTROPY_SOURCES",
-#endif /* POLARSSL_NO_DEFAULT_ENTROPY_SOURCES */
-#if defined(POLARSSL_NO_PLATFORM_ENTROPY)
- "POLARSSL_NO_PLATFORM_ENTROPY",
-#endif /* POLARSSL_NO_PLATFORM_ENTROPY */
-#if defined(POLARSSL_ENTROPY_FORCE_SHA256)
- "POLARSSL_ENTROPY_FORCE_SHA256",
-#endif /* POLARSSL_ENTROPY_FORCE_SHA256 */
-#if defined(POLARSSL_MEMORY_DEBUG)
- "POLARSSL_MEMORY_DEBUG",
-#endif /* POLARSSL_MEMORY_DEBUG */
-#if defined(POLARSSL_MEMORY_BACKTRACE)
- "POLARSSL_MEMORY_BACKTRACE",
-#endif /* POLARSSL_MEMORY_BACKTRACE */
-#if defined(POLARSSL_PK_RSA_ALT_SUPPORT)
- "POLARSSL_PK_RSA_ALT_SUPPORT",
-#endif /* POLARSSL_PK_RSA_ALT_SUPPORT */
-#if defined(POLARSSL_PKCS1_V15)
- "POLARSSL_PKCS1_V15",
-#endif /* POLARSSL_PKCS1_V15 */
-#if defined(POLARSSL_PKCS1_V21)
- "POLARSSL_PKCS1_V21",
-#endif /* POLARSSL_PKCS1_V21 */
-#if defined(POLARSSL_RSA_NO_CRT)
- "POLARSSL_RSA_NO_CRT",
-#endif /* POLARSSL_RSA_NO_CRT */
-#if defined(POLARSSL_SELF_TEST)
- "POLARSSL_SELF_TEST",
-#endif /* POLARSSL_SELF_TEST */
-#if defined(POLARSSL_SSL_AEAD_RANDOM_IV)
- "POLARSSL_SSL_AEAD_RANDOM_IV",
-#endif /* POLARSSL_SSL_AEAD_RANDOM_IV */
-#if defined(POLARSSL_SSL_ALL_ALERT_MESSAGES)
- "POLARSSL_SSL_ALL_ALERT_MESSAGES",
-#endif /* POLARSSL_SSL_ALL_ALERT_MESSAGES */
-#if defined(POLARSSL_SSL_DEBUG_ALL)
- "POLARSSL_SSL_DEBUG_ALL",
-#endif /* POLARSSL_SSL_DEBUG_ALL */
-#if defined(POLARSSL_SSL_ENCRYPT_THEN_MAC)
- "POLARSSL_SSL_ENCRYPT_THEN_MAC",
-#endif /* POLARSSL_SSL_ENCRYPT_THEN_MAC */
-#if defined(POLARSSL_SSL_EXTENDED_MASTER_SECRET)
- "POLARSSL_SSL_EXTENDED_MASTER_SECRET",
-#endif /* POLARSSL_SSL_EXTENDED_MASTER_SECRET */
-#if defined(POLARSSL_SSL_FALLBACK_SCSV)
- "POLARSSL_SSL_FALLBACK_SCSV",
-#endif /* POLARSSL_SSL_FALLBACK_SCSV */
-#if defined(POLARSSL_SSL_HW_RECORD_ACCEL)
- "POLARSSL_SSL_HW_RECORD_ACCEL",
-#endif /* POLARSSL_SSL_HW_RECORD_ACCEL */
-#if defined(POLARSSL_SSL_CBC_RECORD_SPLITTING)
- "POLARSSL_SSL_CBC_RECORD_SPLITTING",
-#endif /* POLARSSL_SSL_CBC_RECORD_SPLITTING */
-#if defined(POLARSSL_SSL_RENEGOTIATION)
- "POLARSSL_SSL_RENEGOTIATION",
-#endif /* POLARSSL_SSL_RENEGOTIATION */
-#if defined(POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
- "POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO",
-#endif /* POLARSSL_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
-#if defined(POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
- "POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE",
-#endif /* POLARSSL_SSL_SRV_RESPECT_CLIENT_PREFERENCE */
-#if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
- "POLARSSL_SSL_MAX_FRAGMENT_LENGTH",
-#endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
-#if defined(POLARSSL_SSL_PROTO_SSL3)
- "POLARSSL_SSL_PROTO_SSL3",
-#endif /* POLARSSL_SSL_PROTO_SSL3 */
-#if defined(POLARSSL_SSL_PROTO_TLS1)
- "POLARSSL_SSL_PROTO_TLS1",
-#endif /* POLARSSL_SSL_PROTO_TLS1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_1)
- "POLARSSL_SSL_PROTO_TLS1_1",
-#endif /* POLARSSL_SSL_PROTO_TLS1_1 */
-#if defined(POLARSSL_SSL_PROTO_TLS1_2)
- "POLARSSL_SSL_PROTO_TLS1_2",
-#endif /* POLARSSL_SSL_PROTO_TLS1_2 */
-#if defined(POLARSSL_SSL_PROTO_DTLS)
- "POLARSSL_SSL_PROTO_DTLS",
-#endif /* POLARSSL_SSL_PROTO_DTLS */
-#if defined(POLARSSL_SSL_ALPN)
- "POLARSSL_SSL_ALPN",
-#endif /* POLARSSL_SSL_ALPN */
-#if defined(POLARSSL_SSL_DTLS_ANTI_REPLAY)
- "POLARSSL_SSL_DTLS_ANTI_REPLAY",
-#endif /* POLARSSL_SSL_DTLS_ANTI_REPLAY */
-#if defined(POLARSSL_SSL_DTLS_HELLO_VERIFY)
- "POLARSSL_SSL_DTLS_HELLO_VERIFY",
-#endif /* POLARSSL_SSL_DTLS_HELLO_VERIFY */
-#if defined(POLARSSL_SSL_DTLS_BADMAC_LIMIT)
- "POLARSSL_SSL_DTLS_BADMAC_LIMIT",
-#endif /* POLARSSL_SSL_DTLS_BADMAC_LIMIT */
-#if defined(POLARSSL_SSL_SESSION_TICKETS)
- "POLARSSL_SSL_SESSION_TICKETS",
-#endif /* POLARSSL_SSL_SESSION_TICKETS */
-#if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
- "POLARSSL_SSL_SERVER_NAME_INDICATION",
-#endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
-#if defined(POLARSSL_SSL_TRUNCATED_HMAC)
- "POLARSSL_SSL_TRUNCATED_HMAC",
-#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
-#if defined(POLARSSL_SSL_SET_CURVES)
- "POLARSSL_SSL_SET_CURVES",
-#endif /* POLARSSL_SSL_SET_CURVES */
-#if defined(POLARSSL_THREADING_ALT)
- "POLARSSL_THREADING_ALT",
-#endif /* POLARSSL_THREADING_ALT */
-#if defined(POLARSSL_THREADING_PTHREAD)
- "POLARSSL_THREADING_PTHREAD",
-#endif /* POLARSSL_THREADING_PTHREAD */
-#if defined(POLARSSL_VERSION_FEATURES)
- "POLARSSL_VERSION_FEATURES",
-#endif /* POLARSSL_VERSION_FEATURES */
-#if defined(POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3)
- "POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3",
-#endif /* POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3 */
-#if defined(POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
- "POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION",
-#endif /* POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION */
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
- "POLARSSL_X509_CHECK_KEY_USAGE",
-#endif /* POLARSSL_X509_CHECK_KEY_USAGE */
-#if defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
- "POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE",
-#endif /* POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE */
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- "POLARSSL_X509_RSASSA_PSS_SUPPORT",
-#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
-#if defined(POLARSSL_ZLIB_SUPPORT)
- "POLARSSL_ZLIB_SUPPORT",
-#endif /* POLARSSL_ZLIB_SUPPORT */
-#if defined(POLARSSL_AESNI_C)
- "POLARSSL_AESNI_C",
-#endif /* POLARSSL_AESNI_C */
-#if defined(POLARSSL_AES_C)
- "POLARSSL_AES_C",
-#endif /* POLARSSL_AES_C */
-#if defined(POLARSSL_ARC4_C)
- "POLARSSL_ARC4_C",
-#endif /* POLARSSL_ARC4_C */
-#if defined(POLARSSL_ASN1_PARSE_C)
- "POLARSSL_ASN1_PARSE_C",
-#endif /* POLARSSL_ASN1_PARSE_C */
-#if defined(POLARSSL_ASN1_WRITE_C)
- "POLARSSL_ASN1_WRITE_C",
-#endif /* POLARSSL_ASN1_WRITE_C */
-#if defined(POLARSSL_BASE64_C)
- "POLARSSL_BASE64_C",
-#endif /* POLARSSL_BASE64_C */
-#if defined(POLARSSL_BIGNUM_C)
- "POLARSSL_BIGNUM_C",
-#endif /* POLARSSL_BIGNUM_C */
-#if defined(POLARSSL_BLOWFISH_C)
- "POLARSSL_BLOWFISH_C",
-#endif /* POLARSSL_BLOWFISH_C */
-#if defined(POLARSSL_CAMELLIA_C)
- "POLARSSL_CAMELLIA_C",
-#endif /* POLARSSL_CAMELLIA_C */
-#if defined(POLARSSL_CCM_C)
- "POLARSSL_CCM_C",
-#endif /* POLARSSL_CCM_C */
-#if defined(POLARSSL_CERTS_C)
- "POLARSSL_CERTS_C",
-#endif /* POLARSSL_CERTS_C */
-#if defined(POLARSSL_CIPHER_C)
- "POLARSSL_CIPHER_C",
-#endif /* POLARSSL_CIPHER_C */
-#if defined(POLARSSL_CTR_DRBG_C)
- "POLARSSL_CTR_DRBG_C",
-#endif /* POLARSSL_CTR_DRBG_C */
-#if defined(POLARSSL_DEBUG_C)
- "POLARSSL_DEBUG_C",
-#endif /* POLARSSL_DEBUG_C */
-#if defined(POLARSSL_DES_C)
- "POLARSSL_DES_C",
-#endif /* POLARSSL_DES_C */
-#if defined(POLARSSL_DHM_C)
- "POLARSSL_DHM_C",
-#endif /* POLARSSL_DHM_C */
-#if defined(POLARSSL_ECDH_C)
- "POLARSSL_ECDH_C",
-#endif /* POLARSSL_ECDH_C */
-#if defined(POLARSSL_ECDSA_C)
- "POLARSSL_ECDSA_C",
-#endif /* POLARSSL_ECDSA_C */
-#if defined(POLARSSL_ECP_C)
- "POLARSSL_ECP_C",
-#endif /* POLARSSL_ECP_C */
-#if defined(POLARSSL_ENTROPY_C)
- "POLARSSL_ENTROPY_C",
-#endif /* POLARSSL_ENTROPY_C */
-#if defined(POLARSSL_ERROR_C)
- "POLARSSL_ERROR_C",
-#endif /* POLARSSL_ERROR_C */
-#if defined(POLARSSL_GCM_C)
- "POLARSSL_GCM_C",
-#endif /* POLARSSL_GCM_C */
-#if defined(POLARSSL_HAVEGE_C)
- "POLARSSL_HAVEGE_C",
-#endif /* POLARSSL_HAVEGE_C */
-#if defined(POLARSSL_HMAC_DRBG_C)
- "POLARSSL_HMAC_DRBG_C",
-#endif /* POLARSSL_HMAC_DRBG_C */
-#if defined(POLARSSL_MD_C)
- "POLARSSL_MD_C",
-#endif /* POLARSSL_MD_C */
-#if defined(POLARSSL_MD2_C)
- "POLARSSL_MD2_C",
-#endif /* POLARSSL_MD2_C */
-#if defined(POLARSSL_MD4_C)
- "POLARSSL_MD4_C",
-#endif /* POLARSSL_MD4_C */
-#if defined(POLARSSL_MD5_C)
- "POLARSSL_MD5_C",
-#endif /* POLARSSL_MD5_C */
-#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
- "POLARSSL_MEMORY_BUFFER_ALLOC_C",
-#endif /* POLARSSL_MEMORY_BUFFER_ALLOC_C */
-#if defined(POLARSSL_NET_C)
- "POLARSSL_NET_C",
-#endif /* POLARSSL_NET_C */
-#if defined(POLARSSL_OID_C)
- "POLARSSL_OID_C",
-#endif /* POLARSSL_OID_C */
-#if defined(POLARSSL_PADLOCK_C)
- "POLARSSL_PADLOCK_C",
-#endif /* POLARSSL_PADLOCK_C */
-#if defined(POLARSSL_PEM_PARSE_C)
- "POLARSSL_PEM_PARSE_C",
-#endif /* POLARSSL_PEM_PARSE_C */
-#if defined(POLARSSL_PEM_WRITE_C)
- "POLARSSL_PEM_WRITE_C",
-#endif /* POLARSSL_PEM_WRITE_C */
-#if defined(POLARSSL_PK_C)
- "POLARSSL_PK_C",
-#endif /* POLARSSL_PK_C */
-#if defined(POLARSSL_PK_PARSE_C)
- "POLARSSL_PK_PARSE_C",
-#endif /* POLARSSL_PK_PARSE_C */
-#if defined(POLARSSL_PK_WRITE_C)
- "POLARSSL_PK_WRITE_C",
-#endif /* POLARSSL_PK_WRITE_C */
-#if defined(POLARSSL_PKCS5_C)
- "POLARSSL_PKCS5_C",
-#endif /* POLARSSL_PKCS5_C */
-#if defined(POLARSSL_PKCS11_C)
- "POLARSSL_PKCS11_C",
-#endif /* POLARSSL_PKCS11_C */
-#if defined(POLARSSL_PKCS12_C)
- "POLARSSL_PKCS12_C",
-#endif /* POLARSSL_PKCS12_C */
-#if defined(POLARSSL_PLATFORM_C)
- "POLARSSL_PLATFORM_C",
-#endif /* POLARSSL_PLATFORM_C */
-#if defined(POLARSSL_RIPEMD160_C)
- "POLARSSL_RIPEMD160_C",
-#endif /* POLARSSL_RIPEMD160_C */
-#if defined(POLARSSL_RSA_C)
- "POLARSSL_RSA_C",
-#endif /* POLARSSL_RSA_C */
-#if defined(POLARSSL_SHA1_C)
- "POLARSSL_SHA1_C",
-#endif /* POLARSSL_SHA1_C */
-#if defined(POLARSSL_SHA256_C)
- "POLARSSL_SHA256_C",
-#endif /* POLARSSL_SHA256_C */
-#if defined(POLARSSL_SHA512_C)
- "POLARSSL_SHA512_C",
-#endif /* POLARSSL_SHA512_C */
-#if defined(POLARSSL_SSL_CACHE_C)
- "POLARSSL_SSL_CACHE_C",
-#endif /* POLARSSL_SSL_CACHE_C */
-#if defined(POLARSSL_SSL_COOKIE_C)
- "POLARSSL_SSL_COOKIE_C",
-#endif /* POLARSSL_SSL_COOKIE_C */
-#if defined(POLARSSL_SSL_CLI_C)
- "POLARSSL_SSL_CLI_C",
-#endif /* POLARSSL_SSL_CLI_C */
-#if defined(POLARSSL_SSL_SRV_C)
- "POLARSSL_SSL_SRV_C",
-#endif /* POLARSSL_SSL_SRV_C */
-#if defined(POLARSSL_SSL_TLS_C)
- "POLARSSL_SSL_TLS_C",
-#endif /* POLARSSL_SSL_TLS_C */
-#if defined(POLARSSL_THREADING_C)
- "POLARSSL_THREADING_C",
-#endif /* POLARSSL_THREADING_C */
-#if defined(POLARSSL_TIMING_C)
- "POLARSSL_TIMING_C",
-#endif /* POLARSSL_TIMING_C */
-#if defined(POLARSSL_VERSION_C)
- "POLARSSL_VERSION_C",
-#endif /* POLARSSL_VERSION_C */
-#if defined(POLARSSL_X509_USE_C)
- "POLARSSL_X509_USE_C",
-#endif /* POLARSSL_X509_USE_C */
-#if defined(POLARSSL_X509_CRT_PARSE_C)
- "POLARSSL_X509_CRT_PARSE_C",
-#endif /* POLARSSL_X509_CRT_PARSE_C */
-#if defined(POLARSSL_X509_CRL_PARSE_C)
- "POLARSSL_X509_CRL_PARSE_C",
-#endif /* POLARSSL_X509_CRL_PARSE_C */
-#if defined(POLARSSL_X509_CSR_PARSE_C)
- "POLARSSL_X509_CSR_PARSE_C",
-#endif /* POLARSSL_X509_CSR_PARSE_C */
-#if defined(POLARSSL_X509_CREATE_C)
- "POLARSSL_X509_CREATE_C",
-#endif /* POLARSSL_X509_CREATE_C */
-#if defined(POLARSSL_X509_CRT_WRITE_C)
- "POLARSSL_X509_CRT_WRITE_C",
-#endif /* POLARSSL_X509_CRT_WRITE_C */
-#if defined(POLARSSL_X509_CSR_WRITE_C)
- "POLARSSL_X509_CSR_WRITE_C",
-#endif /* POLARSSL_X509_CSR_WRITE_C */
-#if defined(POLARSSL_XTEA_C)
- "POLARSSL_XTEA_C",
-#endif /* POLARSSL_XTEA_C */
-#endif /* POLARSSL_VERSION_FEATURES */
+#if defined(MBEDTLS_VERSION_FEATURES)
+#if defined(MBEDTLS_HAVE_INT8)
+ "MBEDTLS_HAVE_INT8",
+#endif /* MBEDTLS_HAVE_INT8 */
+#if defined(MBEDTLS_HAVE_INT16)
+ "MBEDTLS_HAVE_INT16",
+#endif /* MBEDTLS_HAVE_INT16 */
+#if defined(MBEDTLS_HAVE_LONGLONG)
+ "MBEDTLS_HAVE_LONGLONG",
+#endif /* MBEDTLS_HAVE_LONGLONG */
+#if defined(MBEDTLS_HAVE_ASM)
+ "MBEDTLS_HAVE_ASM",
+#endif /* MBEDTLS_HAVE_ASM */
+#if defined(MBEDTLS_HAVE_SSE2)
+ "MBEDTLS_HAVE_SSE2",
+#endif /* MBEDTLS_HAVE_SSE2 */
+#if defined(MBEDTLS_HAVE_TIME)
+ "MBEDTLS_HAVE_TIME",
+#endif /* MBEDTLS_HAVE_TIME */
+#if defined(MBEDTLS_HAVE_IPV6)
+ "MBEDTLS_HAVE_IPV6",
+#endif /* MBEDTLS_HAVE_IPV6 */
+#if defined(MBEDTLS_PLATFORM_MEMORY)
+ "MBEDTLS_PLATFORM_MEMORY",
+#endif /* MBEDTLS_PLATFORM_MEMORY */
+#if defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
+ "MBEDTLS_PLATFORM_NO_STD_FUNCTIONS",
+#endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
+#if defined(MBEDTLS_PLATFORM_EXIT_ALT)
+ "MBEDTLS_PLATFORM_EXIT_ALT",
+#endif /* MBEDTLS_PLATFORM_EXIT_ALT */
+#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
+ "MBEDTLS_PLATFORM_FPRINTF_ALT",
+#endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
+#if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
+ "MBEDTLS_PLATFORM_PRINTF_ALT",
+#endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
+#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
+ "MBEDTLS_PLATFORM_SNPRINTF_ALT",
+#endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
+#if defined(MBEDTLS_DEPRECATED_WARNING)
+ "MBEDTLS_DEPRECATED_WARNING",
+#endif /* MBEDTLS_DEPRECATED_WARNING */
+#if defined(MBEDTLS_DEPRECATED_REMOVED)
+ "MBEDTLS_DEPRECATED_REMOVED",
+#endif /* MBEDTLS_DEPRECATED_REMOVED */
+#if defined(MBEDTLS_TIMING_ALT)
+ "MBEDTLS_TIMING_ALT",
+#endif /* MBEDTLS_TIMING_ALT */
+#if defined(MBEDTLS_AES_ALT)
+ "MBEDTLS_AES_ALT",
+#endif /* MBEDTLS_AES_ALT */
+#if defined(MBEDTLS_ARC4_ALT)
+ "MBEDTLS_ARC4_ALT",
+#endif /* MBEDTLS_ARC4_ALT */
+#if defined(MBEDTLS_BLOWFISH_ALT)
+ "MBEDTLS_BLOWFISH_ALT",
+#endif /* MBEDTLS_BLOWFISH_ALT */
+#if defined(MBEDTLS_CAMELLIA_ALT)
+ "MBEDTLS_CAMELLIA_ALT",
+#endif /* MBEDTLS_CAMELLIA_ALT */
+#if defined(MBEDTLS_DES_ALT)
+ "MBEDTLS_DES_ALT",
+#endif /* MBEDTLS_DES_ALT */
+#if defined(MBEDTLS_XTEA_ALT)
+ "MBEDTLS_XTEA_ALT",
+#endif /* MBEDTLS_XTEA_ALT */
+#if defined(MBEDTLS_MD2_ALT)
+ "MBEDTLS_MD2_ALT",
+#endif /* MBEDTLS_MD2_ALT */
+#if defined(MBEDTLS_MD4_ALT)
+ "MBEDTLS_MD4_ALT",
+#endif /* MBEDTLS_MD4_ALT */
+#if defined(MBEDTLS_MD5_ALT)
+ "MBEDTLS_MD5_ALT",
+#endif /* MBEDTLS_MD5_ALT */
+#if defined(MBEDTLS_RIPEMD160_ALT)
+ "MBEDTLS_RIPEMD160_ALT",
+#endif /* MBEDTLS_RIPEMD160_ALT */
+#if defined(MBEDTLS_SHA1_ALT)
+ "MBEDTLS_SHA1_ALT",
+#endif /* MBEDTLS_SHA1_ALT */
+#if defined(MBEDTLS_SHA256_ALT)
+ "MBEDTLS_SHA256_ALT",
+#endif /* MBEDTLS_SHA256_ALT */
+#if defined(MBEDTLS_SHA512_ALT)
+ "MBEDTLS_SHA512_ALT",
+#endif /* MBEDTLS_SHA512_ALT */
+#if defined(MBEDTLS_MD2_PROCESS_ALT)
+ "MBEDTLS_MD2_PROCESS_ALT",
+#endif /* MBEDTLS_MD2_PROCESS_ALT */
+#if defined(MBEDTLS_MD4_PROCESS_ALT)
+ "MBEDTLS_MD4_PROCESS_ALT",
+#endif /* MBEDTLS_MD4_PROCESS_ALT */
+#if defined(MBEDTLS_MD5_PROCESS_ALT)
+ "MBEDTLS_MD5_PROCESS_ALT",
+#endif /* MBEDTLS_MD5_PROCESS_ALT */
+#if defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
+ "MBEDTLS_RIPEMD160_PROCESS_ALT",
+#endif /* MBEDTLS_RIPEMD160_PROCESS_ALT */
+#if defined(MBEDTLS_SHA1_PROCESS_ALT)
+ "MBEDTLS_SHA1_PROCESS_ALT",
+#endif /* MBEDTLS_SHA1_PROCESS_ALT */
+#if defined(MBEDTLS_SHA256_PROCESS_ALT)
+ "MBEDTLS_SHA256_PROCESS_ALT",
+#endif /* MBEDTLS_SHA256_PROCESS_ALT */
+#if defined(MBEDTLS_SHA512_PROCESS_ALT)
+ "MBEDTLS_SHA512_PROCESS_ALT",
+#endif /* MBEDTLS_SHA512_PROCESS_ALT */
+#if defined(MBEDTLS_AES_ROM_TABLES)
+ "MBEDTLS_AES_ROM_TABLES",
+#endif /* MBEDTLS_AES_ROM_TABLES */
+#if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
+ "MBEDTLS_CAMELLIA_SMALL_MEMORY",
+#endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ "MBEDTLS_CIPHER_MODE_CBC",
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_CIPHER_MODE_CFB)
+ "MBEDTLS_CIPHER_MODE_CFB",
+#endif /* MBEDTLS_CIPHER_MODE_CFB */
+#if defined(MBEDTLS_CIPHER_MODE_CTR)
+ "MBEDTLS_CIPHER_MODE_CTR",
+#endif /* MBEDTLS_CIPHER_MODE_CTR */
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+ "MBEDTLS_CIPHER_NULL_CIPHER",
+#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
+#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
+ "MBEDTLS_CIPHER_PADDING_PKCS7",
+#endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
+#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
+ "MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS",
+#endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
+ "MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN",
+#endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
+#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
+ "MBEDTLS_CIPHER_PADDING_ZEROS",
+#endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
+#if defined(MBEDTLS_ENABLE_WEAK_CIPHERSUITES)
+ "MBEDTLS_ENABLE_WEAK_CIPHERSUITES",
+#endif /* MBEDTLS_ENABLE_WEAK_CIPHERSUITES */
+#if defined(MBEDTLS_REMOVE_ARC4_CIPHERSUITES)
+ "MBEDTLS_REMOVE_ARC4_CIPHERSUITES",
+#endif /* MBEDTLS_REMOVE_ARC4_CIPHERSUITES */
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP192R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP224R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP256R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP384R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP521R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP192K1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP224K1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
+ "MBEDTLS_ECP_DP_SECP256K1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
+ "MBEDTLS_ECP_DP_BP256R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
+ "MBEDTLS_ECP_DP_BP384R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
+ "MBEDTLS_ECP_DP_BP512R1_ENABLED",
+#endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
+#if defined(MBEDTLS_ECP_DP_M221_ENABLED)
+ "MBEDTLS_ECP_DP_M221_ENABLED",
+#endif /* MBEDTLS_ECP_DP_M221_ENABLED */
+#if defined(MBEDTLS_ECP_DP_M255_ENABLED)
+ "MBEDTLS_ECP_DP_M255_ENABLED",
+#endif /* MBEDTLS_ECP_DP_M255_ENABLED */
+#if defined(MBEDTLS_ECP_DP_M383_ENABLED)
+ "MBEDTLS_ECP_DP_M383_ENABLED",
+#endif /* MBEDTLS_ECP_DP_M383_ENABLED */
+#if defined(MBEDTLS_ECP_DP_M511_ENABLED)
+ "MBEDTLS_ECP_DP_M511_ENABLED",
+#endif /* MBEDTLS_ECP_DP_M511_ENABLED */
+#if defined(MBEDTLS_ECP_NIST_OPTIM)
+ "MBEDTLS_ECP_NIST_OPTIM",
+#endif /* MBEDTLS_ECP_NIST_OPTIM */
+#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
+ "MBEDTLS_ECDSA_DETERMINISTIC",
+#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
+#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_PSK_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_RSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
+#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
+ "MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED",
+#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
+#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
+ "MBEDTLS_PK_PARSE_EC_EXTENDED",
+#endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
+#if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
+ "MBEDTLS_ERROR_STRERROR_DUMMY",
+#endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
+#if defined(MBEDTLS_GENPRIME)
+ "MBEDTLS_GENPRIME",
+#endif /* MBEDTLS_GENPRIME */
+#if defined(MBEDTLS_FS_IO)
+ "MBEDTLS_FS_IO",
+#endif /* MBEDTLS_FS_IO */
+#if defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
+ "MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES",
+#endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
+#if defined(MBEDTLS_NO_PLATFORM_ENTROPY)
+ "MBEDTLS_NO_PLATFORM_ENTROPY",
+#endif /* MBEDTLS_NO_PLATFORM_ENTROPY */
+#if defined(MBEDTLS_ENTROPY_FORCE_SHA256)
+ "MBEDTLS_ENTROPY_FORCE_SHA256",
+#endif /* MBEDTLS_ENTROPY_FORCE_SHA256 */
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ "MBEDTLS_MEMORY_DEBUG",
+#endif /* MBEDTLS_MEMORY_DEBUG */
+#if defined(MBEDTLS_MEMORY_BACKTRACE)
+ "MBEDTLS_MEMORY_BACKTRACE",
+#endif /* MBEDTLS_MEMORY_BACKTRACE */
+#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
+ "MBEDTLS_PK_RSA_ALT_SUPPORT",
+#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
+#if defined(MBEDTLS_PKCS1_V15)
+ "MBEDTLS_PKCS1_V15",
+#endif /* MBEDTLS_PKCS1_V15 */
+#if defined(MBEDTLS_PKCS1_V21)
+ "MBEDTLS_PKCS1_V21",
+#endif /* MBEDTLS_PKCS1_V21 */
+#if defined(MBEDTLS_RSA_NO_CRT)
+ "MBEDTLS_RSA_NO_CRT",
+#endif /* MBEDTLS_RSA_NO_CRT */
+#if defined(MBEDTLS_SELF_TEST)
+ "MBEDTLS_SELF_TEST",
+#endif /* MBEDTLS_SELF_TEST */
+#if defined(MBEDTLS_SSL_AEAD_RANDOM_IV)
+ "MBEDTLS_SSL_AEAD_RANDOM_IV",
+#endif /* MBEDTLS_SSL_AEAD_RANDOM_IV */
+#if defined(MBEDTLS_SSL_ALL_ALERT_MESSAGES)
+ "MBEDTLS_SSL_ALL_ALERT_MESSAGES",
+#endif /* MBEDTLS_SSL_ALL_ALERT_MESSAGES */
+#if defined(MBEDTLS_SSL_DEBUG_ALL)
+ "MBEDTLS_SSL_DEBUG_ALL",
+#endif /* MBEDTLS_SSL_DEBUG_ALL */
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+ "MBEDTLS_SSL_ENCRYPT_THEN_MAC",
+#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+ "MBEDTLS_SSL_EXTENDED_MASTER_SECRET",
+#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
+ "MBEDTLS_SSL_FALLBACK_SCSV",
+#endif /* MBEDTLS_SSL_FALLBACK_SCSV */
+#if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
+ "MBEDTLS_SSL_HW_RECORD_ACCEL",
+#endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+ "MBEDTLS_SSL_CBC_RECORD_SPLITTING",
+#endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+ "MBEDTLS_SSL_RENEGOTIATION",
+#endif /* MBEDTLS_SSL_RENEGOTIATION */
+#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
+ "MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO",
+#endif /* MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
+#if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
+ "MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE",
+#endif /* MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE */
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+ "MBEDTLS_SSL_MAX_FRAGMENT_LENGTH",
+#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
+#if defined(MBEDTLS_SSL_PROTO_SSL3)
+ "MBEDTLS_SSL_PROTO_SSL3",
+#endif /* MBEDTLS_SSL_PROTO_SSL3 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1)
+ "MBEDTLS_SSL_PROTO_TLS1",
+#endif /* MBEDTLS_SSL_PROTO_TLS1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1_1)
+ "MBEDTLS_SSL_PROTO_TLS1_1",
+#endif /* MBEDTLS_SSL_PROTO_TLS1_1 */
+#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
+ "MBEDTLS_SSL_PROTO_TLS1_2",
+#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+ "MBEDTLS_SSL_PROTO_DTLS",
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
+#if defined(MBEDTLS_SSL_ALPN)
+ "MBEDTLS_SSL_ALPN",
+#endif /* MBEDTLS_SSL_ALPN */
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+ "MBEDTLS_SSL_DTLS_ANTI_REPLAY",
+#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
+#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
+ "MBEDTLS_SSL_DTLS_HELLO_VERIFY",
+#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
+#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
+ "MBEDTLS_SSL_DTLS_BADMAC_LIMIT",
+#endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+ "MBEDTLS_SSL_SESSION_TICKETS",
+#endif /* MBEDTLS_SSL_SESSION_TICKETS */
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
+ "MBEDTLS_SSL_SERVER_NAME_INDICATION",
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+ "MBEDTLS_SSL_TRUNCATED_HMAC",
+#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
+#if defined(MBEDTLS_SSL_SET_CURVES)
+ "MBEDTLS_SSL_SET_CURVES",
+#endif /* MBEDTLS_SSL_SET_CURVES */
+#if defined(MBEDTLS_THREADING_ALT)
+ "MBEDTLS_THREADING_ALT",
+#endif /* MBEDTLS_THREADING_ALT */
+#if defined(MBEDTLS_THREADING_PTHREAD)
+ "MBEDTLS_THREADING_PTHREAD",
+#endif /* MBEDTLS_THREADING_PTHREAD */
+#if defined(MBEDTLS_VERSION_FEATURES)
+ "MBEDTLS_VERSION_FEATURES",
+#endif /* MBEDTLS_VERSION_FEATURES */
+#if defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
+ "MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3",
+#endif /* MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3 */
+#if defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
+ "MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION",
+#endif /* MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION */
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
+ "MBEDTLS_X509_CHECK_KEY_USAGE",
+#endif /* MBEDTLS_X509_CHECK_KEY_USAGE */
+#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
+ "MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE",
+#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ "MBEDTLS_X509_RSASSA_PSS_SUPPORT",
+#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
+#if defined(MBEDTLS_ZLIB_SUPPORT)
+ "MBEDTLS_ZLIB_SUPPORT",
+#endif /* MBEDTLS_ZLIB_SUPPORT */
+#if defined(MBEDTLS_AESNI_C)
+ "MBEDTLS_AESNI_C",
+#endif /* MBEDTLS_AESNI_C */
+#if defined(MBEDTLS_AES_C)
+ "MBEDTLS_AES_C",
+#endif /* MBEDTLS_AES_C */
+#if defined(MBEDTLS_ARC4_C)
+ "MBEDTLS_ARC4_C",
+#endif /* MBEDTLS_ARC4_C */
+#if defined(MBEDTLS_ASN1_PARSE_C)
+ "MBEDTLS_ASN1_PARSE_C",
+#endif /* MBEDTLS_ASN1_PARSE_C */
+#if defined(MBEDTLS_ASN1_WRITE_C)
+ "MBEDTLS_ASN1_WRITE_C",
+#endif /* MBEDTLS_ASN1_WRITE_C */
+#if defined(MBEDTLS_BASE64_C)
+ "MBEDTLS_BASE64_C",
+#endif /* MBEDTLS_BASE64_C */
+#if defined(MBEDTLS_BIGNUM_C)
+ "MBEDTLS_BIGNUM_C",
+#endif /* MBEDTLS_BIGNUM_C */
+#if defined(MBEDTLS_BLOWFISH_C)
+ "MBEDTLS_BLOWFISH_C",
+#endif /* MBEDTLS_BLOWFISH_C */
+#if defined(MBEDTLS_CAMELLIA_C)
+ "MBEDTLS_CAMELLIA_C",
+#endif /* MBEDTLS_CAMELLIA_C */
+#if defined(MBEDTLS_CCM_C)
+ "MBEDTLS_CCM_C",
+#endif /* MBEDTLS_CCM_C */
+#if defined(MBEDTLS_CERTS_C)
+ "MBEDTLS_CERTS_C",
+#endif /* MBEDTLS_CERTS_C */
+#if defined(MBEDTLS_CIPHER_C)
+ "MBEDTLS_CIPHER_C",
+#endif /* MBEDTLS_CIPHER_C */
+#if defined(MBEDTLS_CTR_DRBG_C)
+ "MBEDTLS_CTR_DRBG_C",
+#endif /* MBEDTLS_CTR_DRBG_C */
+#if defined(MBEDTLS_DEBUG_C)
+ "MBEDTLS_DEBUG_C",
+#endif /* MBEDTLS_DEBUG_C */
+#if defined(MBEDTLS_DES_C)
+ "MBEDTLS_DES_C",
+#endif /* MBEDTLS_DES_C */
+#if defined(MBEDTLS_DHM_C)
+ "MBEDTLS_DHM_C",
+#endif /* MBEDTLS_DHM_C */
+#if defined(MBEDTLS_ECDH_C)
+ "MBEDTLS_ECDH_C",
+#endif /* MBEDTLS_ECDH_C */
+#if defined(MBEDTLS_ECDSA_C)
+ "MBEDTLS_ECDSA_C",
+#endif /* MBEDTLS_ECDSA_C */
+#if defined(MBEDTLS_ECP_C)
+ "MBEDTLS_ECP_C",
+#endif /* MBEDTLS_ECP_C */
+#if defined(MBEDTLS_ENTROPY_C)
+ "MBEDTLS_ENTROPY_C",
+#endif /* MBEDTLS_ENTROPY_C */
+#if defined(MBEDTLS_ERROR_C)
+ "MBEDTLS_ERROR_C",
+#endif /* MBEDTLS_ERROR_C */
+#if defined(MBEDTLS_GCM_C)
+ "MBEDTLS_GCM_C",
+#endif /* MBEDTLS_GCM_C */
+#if defined(MBEDTLS_HAVEGE_C)
+ "MBEDTLS_HAVEGE_C",
+#endif /* MBEDTLS_HAVEGE_C */
+#if defined(MBEDTLS_HMAC_DRBG_C)
+ "MBEDTLS_HMAC_DRBG_C",
+#endif /* MBEDTLS_HMAC_DRBG_C */
+#if defined(MBEDTLS_MD_C)
+ "MBEDTLS_MD_C",
+#endif /* MBEDTLS_MD_C */
+#if defined(MBEDTLS_MD2_C)
+ "MBEDTLS_MD2_C",
+#endif /* MBEDTLS_MD2_C */
+#if defined(MBEDTLS_MD4_C)
+ "MBEDTLS_MD4_C",
+#endif /* MBEDTLS_MD4_C */
+#if defined(MBEDTLS_MD5_C)
+ "MBEDTLS_MD5_C",
+#endif /* MBEDTLS_MD5_C */
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ "MBEDTLS_MEMORY_BUFFER_ALLOC_C",
+#endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
+#if defined(MBEDTLS_NET_C)
+ "MBEDTLS_NET_C",
+#endif /* MBEDTLS_NET_C */
+#if defined(MBEDTLS_OID_C)
+ "MBEDTLS_OID_C",
+#endif /* MBEDTLS_OID_C */
+#if defined(MBEDTLS_PADLOCK_C)
+ "MBEDTLS_PADLOCK_C",
+#endif /* MBEDTLS_PADLOCK_C */
+#if defined(MBEDTLS_PEM_PARSE_C)
+ "MBEDTLS_PEM_PARSE_C",
+#endif /* MBEDTLS_PEM_PARSE_C */
+#if defined(MBEDTLS_PEM_WRITE_C)
+ "MBEDTLS_PEM_WRITE_C",
+#endif /* MBEDTLS_PEM_WRITE_C */
+#if defined(MBEDTLS_PK_C)
+ "MBEDTLS_PK_C",
+#endif /* MBEDTLS_PK_C */
+#if defined(MBEDTLS_PK_PARSE_C)
+ "MBEDTLS_PK_PARSE_C",
+#endif /* MBEDTLS_PK_PARSE_C */
+#if defined(MBEDTLS_PK_WRITE_C)
+ "MBEDTLS_PK_WRITE_C",
+#endif /* MBEDTLS_PK_WRITE_C */
+#if defined(MBEDTLS_PKCS5_C)
+ "MBEDTLS_PKCS5_C",
+#endif /* MBEDTLS_PKCS5_C */
+#if defined(MBEDTLS_PKCS11_C)
+ "MBEDTLS_PKCS11_C",
+#endif /* MBEDTLS_PKCS11_C */
+#if defined(MBEDTLS_PKCS12_C)
+ "MBEDTLS_PKCS12_C",
+#endif /* MBEDTLS_PKCS12_C */
+#if defined(MBEDTLS_PLATFORM_C)
+ "MBEDTLS_PLATFORM_C",
+#endif /* MBEDTLS_PLATFORM_C */
+#if defined(MBEDTLS_RIPEMD160_C)
+ "MBEDTLS_RIPEMD160_C",
+#endif /* MBEDTLS_RIPEMD160_C */
+#if defined(MBEDTLS_RSA_C)
+ "MBEDTLS_RSA_C",
+#endif /* MBEDTLS_RSA_C */
+#if defined(MBEDTLS_SHA1_C)
+ "MBEDTLS_SHA1_C",
+#endif /* MBEDTLS_SHA1_C */
+#if defined(MBEDTLS_SHA256_C)
+ "MBEDTLS_SHA256_C",
+#endif /* MBEDTLS_SHA256_C */
+#if defined(MBEDTLS_SHA512_C)
+ "MBEDTLS_SHA512_C",
+#endif /* MBEDTLS_SHA512_C */
+#if defined(MBEDTLS_SSL_CACHE_C)
+ "MBEDTLS_SSL_CACHE_C",
+#endif /* MBEDTLS_SSL_CACHE_C */
+#if defined(MBEDTLS_SSL_COOKIE_C)
+ "MBEDTLS_SSL_COOKIE_C",
+#endif /* MBEDTLS_SSL_COOKIE_C */
+#if defined(MBEDTLS_SSL_CLI_C)
+ "MBEDTLS_SSL_CLI_C",
+#endif /* MBEDTLS_SSL_CLI_C */
+#if defined(MBEDTLS_SSL_SRV_C)
+ "MBEDTLS_SSL_SRV_C",
+#endif /* MBEDTLS_SSL_SRV_C */
+#if defined(MBEDTLS_SSL_TLS_C)
+ "MBEDTLS_SSL_TLS_C",
+#endif /* MBEDTLS_SSL_TLS_C */
+#if defined(MBEDTLS_THREADING_C)
+ "MBEDTLS_THREADING_C",
+#endif /* MBEDTLS_THREADING_C */
+#if defined(MBEDTLS_TIMING_C)
+ "MBEDTLS_TIMING_C",
+#endif /* MBEDTLS_TIMING_C */
+#if defined(MBEDTLS_VERSION_C)
+ "MBEDTLS_VERSION_C",
+#endif /* MBEDTLS_VERSION_C */
+#if defined(MBEDTLS_X509_USE_C)
+ "MBEDTLS_X509_USE_C",
+#endif /* MBEDTLS_X509_USE_C */
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+ "MBEDTLS_X509_CRT_PARSE_C",
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
+#if defined(MBEDTLS_X509_CRL_PARSE_C)
+ "MBEDTLS_X509_CRL_PARSE_C",
+#endif /* MBEDTLS_X509_CRL_PARSE_C */
+#if defined(MBEDTLS_X509_CSR_PARSE_C)
+ "MBEDTLS_X509_CSR_PARSE_C",
+#endif /* MBEDTLS_X509_CSR_PARSE_C */
+#if defined(MBEDTLS_X509_CREATE_C)
+ "MBEDTLS_X509_CREATE_C",
+#endif /* MBEDTLS_X509_CREATE_C */
+#if defined(MBEDTLS_X509_CRT_WRITE_C)
+ "MBEDTLS_X509_CRT_WRITE_C",
+#endif /* MBEDTLS_X509_CRT_WRITE_C */
+#if defined(MBEDTLS_X509_CSR_WRITE_C)
+ "MBEDTLS_X509_CSR_WRITE_C",
+#endif /* MBEDTLS_X509_CSR_WRITE_C */
+#if defined(MBEDTLS_XTEA_C)
+ "MBEDTLS_XTEA_C",
+#endif /* MBEDTLS_XTEA_C */
+#endif /* MBEDTLS_VERSION_FEATURES */
NULL
};
-int version_check_feature( const char *feature )
+int mbedtls_version_check_feature( const char *feature )
{
const char **idx = features;
@@ -617,4 +617,4 @@
return( -1 );
}
-#endif /* POLARSSL_VERSION_C */
+#endif /* MBEDTLS_VERSION_C */
diff --git a/library/x509.c b/library/x509.c
index 1095b83..eb14720 100644
--- a/library/x509.c
+++ b/library/x509.c
@@ -30,13 +30,13 @@
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_USE_C)
+#if defined(MBEDTLS_X509_USE_C)
#include "mbedtls/x509.h"
#include "mbedtls/asn1.h"
@@ -45,19 +45,19 @@
#include <stdio.h>
#include <string.h>
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
#include <stdlib.h>
-#define polarssl_free free
-#define polarssl_malloc malloc
-#define polarssl_printf printf
-#define polarssl_snprintf snprintf
+#define mbedtls_free free
+#define mbedtls_malloc malloc
+#define mbedtls_printf printf
+#define mbedtls_snprintf snprintf
#endif
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
@@ -66,7 +66,7 @@
#include <time.h>
#endif
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#if !defined(_WIN32)
#include <sys/types.h>
@@ -80,24 +80,24 @@
/*
* CertificateSerialNumber ::= INTEGER
*/
-int x509_get_serial( unsigned char **p, const unsigned char *end,
- x509_buf *serial )
+int mbedtls_x509_get_serial( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_buf *serial )
{
int ret;
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_SERIAL +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_SERIAL +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- if( **p != ( ASN1_CONTEXT_SPECIFIC | ASN1_PRIMITIVE | 2 ) &&
- **p != ASN1_INTEGER )
- return( POLARSSL_ERR_X509_INVALID_SERIAL +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( **p != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_PRIMITIVE | 2 ) &&
+ **p != MBEDTLS_ASN1_INTEGER )
+ return( MBEDTLS_ERR_X509_INVALID_SERIAL +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
serial->tag = *(*p)++;
- if( ( ret = asn1_get_len( p, end, &serial->len ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_SERIAL + ret );
+ if( ( ret = mbedtls_asn1_get_len( p, end, &serial->len ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_SERIAL + ret );
serial->p = *p;
*p += serial->len;
@@ -111,13 +111,13 @@
* algorithm OBJECT IDENTIFIER,
* parameters ANY DEFINED BY algorithm OPTIONAL }
*/
-int x509_get_alg_null( unsigned char **p, const unsigned char *end,
- x509_buf *alg )
+int mbedtls_x509_get_alg_null( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_buf *alg )
{
int ret;
- if( ( ret = asn1_get_alg_null( p, end, alg ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_alg_null( p, end, alg ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
return( 0 );
}
@@ -125,18 +125,18 @@
/*
* Parse an algorithm identifier with (optional) paramaters
*/
-int x509_get_alg( unsigned char **p, const unsigned char *end,
- x509_buf *alg, x509_buf *params )
+int mbedtls_x509_get_alg( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_buf *alg, mbedtls_x509_buf *params )
{
int ret;
- if( ( ret = asn1_get_alg( p, end, alg, params ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_alg( p, end, alg, params ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
return( 0 );
}
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
/*
* HashAlgorithm ::= AlgorithmIdentifier
*
@@ -146,49 +146,49 @@
*
* For HashAlgorithm, parameters MUST be NULL or absent.
*/
-static int x509_get_hash_alg( const x509_buf *alg, md_type_t *md_alg )
+static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg )
{
int ret;
unsigned char *p;
const unsigned char *end;
- x509_buf md_oid;
+ mbedtls_x509_buf md_oid;
size_t len;
/* Make sure we got a SEQUENCE and setup bounds */
- if( alg->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
p = (unsigned char *) alg->p;
end = p + alg->len;
if( p >= end )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
/* Parse md_oid */
md_oid.tag = *p;
- if( ( ret = asn1_get_tag( &p, end, &md_oid.len, ASN1_OID ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &md_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
md_oid.p = p;
p += md_oid.len;
/* Get md_alg from md_oid */
- if( ( ret = oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
/* Make sure params is absent of NULL */
if( p == end )
return( 0 );
- if( ( ret = asn1_get_tag( &p, end, &len, ASN1_NULL ) ) != 0 || len != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_NULL ) ) != 0 || len != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -205,25 +205,25 @@
* of trailerField MUST be 1, and PKCS#1 v2.2 doesn't even define any other
* option. Enfore this at parsing time.
*/
-int x509_get_rsassa_pss_params( const x509_buf *params,
- md_type_t *md_alg, md_type_t *mgf_md,
+int mbedtls_x509_get_rsassa_pss_params( const mbedtls_x509_buf *params,
+ mbedtls_md_type_t *md_alg, mbedtls_md_type_t *mgf_md,
int *salt_len )
{
int ret;
unsigned char *p;
const unsigned char *end, *end2;
size_t len;
- x509_buf alg_id, alg_params;
+ mbedtls_x509_buf alg_id, alg_params;
/* First set everything to defaults */
- *md_alg = POLARSSL_MD_SHA1;
- *mgf_md = POLARSSL_MD_SHA1;
+ *md_alg = MBEDTLS_MD_SHA1;
+ *mgf_md = MBEDTLS_MD_SHA1;
*salt_len = 20;
/* Make sure params is a SEQUENCE and setup bounds */
- if( params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
p = (unsigned char *) params->p;
end = p + params->len;
@@ -234,24 +234,24 @@
/*
* HashAlgorithm
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
{
end2 = p + len;
/* HashAlgorithm ::= AlgorithmIdentifier (without parameters) */
- if( ( ret = x509_get_alg_null( &p, end2, &alg_id ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_alg_null( &p, end2, &alg_id ) ) != 0 )
return( ret );
- if( ( ret = oid_get_md_alg( &alg_id, md_alg ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_oid_get_md_alg( &alg_id, md_alg ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end2 )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p == end )
return( 0 );
@@ -259,30 +259,30 @@
/*
* MaskGenAlgorithm
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 1 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
{
end2 = p + len;
/* MaskGenAlgorithm ::= AlgorithmIdentifier (params = HashAlgorithm) */
- if( ( ret = x509_get_alg( &p, end2, &alg_id, &alg_params ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_alg( &p, end2, &alg_id, &alg_params ) ) != 0 )
return( ret );
/* Only MFG1 is recognised for now */
- if( OID_CMP( OID_MGF1, &alg_id ) != 0 )
- return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE +
- POLARSSL_ERR_OID_NOT_FOUND );
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_MGF1, &alg_id ) != 0 )
+ return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE +
+ MBEDTLS_ERR_OID_NOT_FOUND );
/* Parse HashAlgorithm */
if( ( ret = x509_get_hash_alg( &alg_params, mgf_md ) ) != 0 )
return( ret );
if( p != end2 )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p == end )
return( 0 );
@@ -290,20 +290,20 @@
/*
* salt_len
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 2 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 2 ) ) == 0 )
{
end2 = p + len;
- if( ( ret = asn1_get_int( &p, end2, salt_len ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end2, salt_len ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end2 )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p == end )
return( 0 );
@@ -311,33 +311,33 @@
/*
* trailer_field (if present, must be 1)
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 3 ) ) == 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 3 ) ) == 0 )
{
int trailer_field;
end2 = p + len;
- if( ( ret = asn1_get_int( &p, end2, &trailer_field ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ if( ( ret = mbedtls_asn1_get_int( &p, end2, &trailer_field ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end2 )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
if( trailer_field != 1 )
- return( POLARSSL_ERR_X509_INVALID_ALG );
+ return( MBEDTLS_ERR_X509_INVALID_ALG );
}
- else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- return( POLARSSL_ERR_X509_INVALID_ALG + ret );
+ else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
if( p != end )
- return( POLARSSL_ERR_X509_INVALID_ALG +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_ALG +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
-#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
+#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
/*
* AttributeTypeAndValue ::= SEQUENCE {
@@ -350,46 +350,46 @@
*/
static int x509_get_attr_type_value( unsigned char **p,
const unsigned char *end,
- x509_name *cur )
+ mbedtls_x509_name *cur )
{
int ret;
size_t len;
- x509_buf *oid;
- x509_buf *val;
+ mbedtls_x509_buf *oid;
+ mbedtls_x509_buf *val;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_NAME + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_NAME +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_NAME +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
oid = &cur->oid;
oid->tag = **p;
- if( ( ret = asn1_get_tag( p, end, &oid->len, ASN1_OID ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_NAME + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &oid->len, MBEDTLS_ASN1_OID ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
oid->p = *p;
*p += oid->len;
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_NAME +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_NAME +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- if( **p != ASN1_BMP_STRING && **p != ASN1_UTF8_STRING &&
- **p != ASN1_T61_STRING && **p != ASN1_PRINTABLE_STRING &&
- **p != ASN1_IA5_STRING && **p != ASN1_UNIVERSAL_STRING &&
- **p != ASN1_BIT_STRING )
- return( POLARSSL_ERR_X509_INVALID_NAME +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( **p != MBEDTLS_ASN1_BMP_STRING && **p != MBEDTLS_ASN1_UTF8_STRING &&
+ **p != MBEDTLS_ASN1_T61_STRING && **p != MBEDTLS_ASN1_PRINTABLE_STRING &&
+ **p != MBEDTLS_ASN1_IA5_STRING && **p != MBEDTLS_ASN1_UNIVERSAL_STRING &&
+ **p != MBEDTLS_ASN1_BIT_STRING )
+ return( MBEDTLS_ERR_X509_INVALID_NAME +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
val = &cur->val;
val->tag = *(*p)++;
- if( ( ret = asn1_get_len( p, end, &val->len ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_NAME + ret );
+ if( ( ret = mbedtls_asn1_get_len( p, end, &val->len ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
val->p = *p;
*p += val->len;
@@ -420,10 +420,10 @@
* one element, which is represented as a list of AttributeTypeAndValue.
* For the general case we still use a flat list, but we mark elements of the
* same set so that they are "merged" together in the functions that consume
- * this list, eg x509_dn_gets().
+ * this list, eg mbedtls_x509_dn_gets().
*/
-int x509_get_name( unsigned char **p, const unsigned char *end,
- x509_name *cur )
+int mbedtls_x509_get_name( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_name *cur )
{
int ret;
size_t set_len;
@@ -435,9 +435,9 @@
/*
* parse SET
*/
- if( ( ret = asn1_get_tag( p, end, &set_len,
- ASN1_CONSTRUCTED | ASN1_SET ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_NAME + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &set_len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
end_set = *p + set_len;
@@ -452,12 +452,12 @@
/* Mark this item as being only one in a set */
cur->next_merged = 1;
- cur->next = polarssl_malloc( sizeof( x509_name ) );
+ cur->next = mbedtls_malloc( sizeof( mbedtls_x509_name ) );
if( cur->next == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
- memset( cur->next, 0, sizeof( x509_name ) );
+ memset( cur->next, 0, sizeof( mbedtls_x509_name ) );
cur = cur->next;
}
@@ -468,12 +468,12 @@
if( *p == end )
return( 0 );
- cur->next = polarssl_malloc( sizeof( x509_name ) );
+ cur->next = mbedtls_malloc( sizeof( mbedtls_x509_name ) );
if( cur->next == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
- memset( cur->next, 0, sizeof( x509_name ) );
+ memset( cur->next, 0, sizeof( mbedtls_x509_name ) );
cur = cur->next;
}
@@ -482,7 +482,7 @@
static int x509_parse_int(unsigned char **p, unsigned n, int *res){
*res = 0;
for( ; n > 0; --n ){
- if( ( **p < '0') || ( **p > '9' ) ) return POLARSSL_ERR_X509_INVALID_DATE;
+ if( ( **p < '0') || ( **p > '9' ) ) return MBEDTLS_ERR_X509_INVALID_DATE;
*res *= 10;
*res += (*(*p)++ - '0');
}
@@ -494,26 +494,26 @@
* utcTime UTCTime,
* generalTime GeneralizedTime }
*/
-int x509_get_time( unsigned char **p, const unsigned char *end,
- x509_time *time )
+int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_time *time )
{
int ret;
size_t len;
unsigned char tag;
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_DATE +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_DATE +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
tag = **p;
- if( tag == ASN1_UTC_TIME )
+ if( tag == MBEDTLS_ASN1_UTC_TIME )
{
(*p)++;
- ret = asn1_get_len( p, end, &len );
+ ret = mbedtls_asn1_get_len( p, end, &len );
if( ret != 0 )
- return( POLARSSL_ERR_X509_INVALID_DATE + ret );
+ return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
CHECK( x509_parse_int( p, 2, &time->year ) );
CHECK( x509_parse_int( p, 2, &time->mon ) );
@@ -523,20 +523,20 @@
if( len > 10 )
CHECK( x509_parse_int( p, 2, &time->sec ) );
if( len > 12 && *(*p)++ != 'Z' )
- return( POLARSSL_ERR_X509_INVALID_DATE );
+ return( MBEDTLS_ERR_X509_INVALID_DATE );
time->year += 100 * ( time->year < 50 );
time->year += 1900;
return( 0 );
}
- else if( tag == ASN1_GENERALIZED_TIME )
+ else if( tag == MBEDTLS_ASN1_GENERALIZED_TIME )
{
(*p)++;
- ret = asn1_get_len( p, end, &len );
+ ret = mbedtls_asn1_get_len( p, end, &len );
if( ret != 0 )
- return( POLARSSL_ERR_X509_INVALID_DATE + ret );
+ return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
CHECK( x509_parse_int( p, 4, &time->year ) );
CHECK( x509_parse_int( p, 2, &time->mon ) );
@@ -546,28 +546,28 @@
if( len > 12 )
CHECK( x509_parse_int( p, 2, &time->sec ) );
if( len > 14 && *(*p)++ != 'Z' )
- return( POLARSSL_ERR_X509_INVALID_DATE );
+ return( MBEDTLS_ERR_X509_INVALID_DATE );
return( 0 );
}
else
- return( POLARSSL_ERR_X509_INVALID_DATE +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ return( MBEDTLS_ERR_X509_INVALID_DATE +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
-int x509_get_sig( unsigned char **p, const unsigned char *end, x509_buf *sig )
+int mbedtls_x509_get_sig( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *sig )
{
int ret;
size_t len;
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_SIGNATURE +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_SIGNATURE +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
sig->tag = **p;
- if( ( ret = asn1_get_bitstring_null( p, end, &len ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_SIGNATURE + ret );
+ if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + ret );
sig->len = len;
sig->p = *p;
@@ -580,46 +580,46 @@
/*
* Get signature algorithm from alg OID and optional parameters
*/
-int x509_get_sig_alg( const x509_buf *sig_oid, const x509_buf *sig_params,
- md_type_t *md_alg, pk_type_t *pk_alg,
+int mbedtls_x509_get_sig_alg( const mbedtls_x509_buf *sig_oid, const mbedtls_x509_buf *sig_params,
+ mbedtls_md_type_t *md_alg, mbedtls_pk_type_t *pk_alg,
void **sig_opts )
{
int ret;
if( *sig_opts != NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- if( ( ret = oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
- return( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG + ret );
+ if( ( ret = mbedtls_oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
+ return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + ret );
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- if( *pk_alg == POLARSSL_PK_RSASSA_PSS )
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ if( *pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
- pk_rsassa_pss_options *pss_opts;
+ mbedtls_pk_rsassa_pss_options *pss_opts;
- pss_opts = polarssl_malloc( sizeof( pk_rsassa_pss_options ) );
+ pss_opts = mbedtls_malloc( sizeof( mbedtls_pk_rsassa_pss_options ) );
if( pss_opts == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
- ret = x509_get_rsassa_pss_params( sig_params,
+ ret = mbedtls_x509_get_rsassa_pss_params( sig_params,
md_alg,
&pss_opts->mgf1_hash_id,
&pss_opts->expected_salt_len );
if( ret != 0 )
{
- polarssl_free( pss_opts );
+ mbedtls_free( pss_opts );
return( ret );
}
*sig_opts = (void *) pss_opts;
}
else
-#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
+#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
{
/* Make sure parameters are absent or NULL */
- if( ( sig_params->tag != ASN1_NULL && sig_params->tag != 0 ) ||
+ if( ( sig_params->tag != MBEDTLS_ASN1_NULL && sig_params->tag != 0 ) ||
sig_params->len != 0 )
- return( POLARSSL_ERR_X509_INVALID_ALG );
+ return( MBEDTLS_ERR_X509_INVALID_ALG );
}
return( 0 );
@@ -629,8 +629,8 @@
* X.509 Extensions (No parsing of extensions, pointer should
* be either manually updated or extensions should be parsed!
*/
-int x509_get_ext( unsigned char **p, const unsigned char *end,
- x509_buf *ext, int tag )
+int mbedtls_x509_get_ext( unsigned char **p, const unsigned char *end,
+ mbedtls_x509_buf *ext, int tag )
{
int ret;
size_t len;
@@ -640,8 +640,8 @@
ext->tag = **p;
- if( ( ret = asn1_get_tag( p, end, &ext->len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | tag ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag ) ) != 0 )
return( ret );
ext->p = *p;
@@ -655,13 +655,13 @@
* critical BOOLEAN DEFAULT FALSE,
* extnValue OCTET STRING }
*/
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( end != *p + len )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -702,7 +702,7 @@
#define snprintf compat_snprintf
#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
-#define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
+#define MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL -2
#define SAFE_SNPRINTF() \
{ \
@@ -711,7 +711,7 @@
\
if( (unsigned int) ret > n ) { \
p[n - 1] = '\0'; \
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL ); \
} \
\
n -= (unsigned int) ret; \
@@ -722,14 +722,14 @@
* Store the name in printable form into buf; no more
* than size characters will be written
*/
-int x509_dn_gets( char *buf, size_t size, const x509_name *dn )
+int mbedtls_x509_dn_gets( char *buf, size_t size, const mbedtls_x509_name *dn )
{
int ret;
size_t i, n;
unsigned char c, merge = 0;
- const x509_name *name;
+ const mbedtls_x509_name *name;
const char *short_name = NULL;
- char s[X509_MAX_DN_NAME_SIZE], *p;
+ char s[MBEDTLS_X509_MAX_DN_NAME_SIZE], *p;
memset( s, 0, sizeof( s ) );
@@ -747,16 +747,16 @@
if( name != dn )
{
- ret = polarssl_snprintf( p, n, merge ? " + " : ", " );
+ ret = mbedtls_snprintf( p, n, merge ? " + " : ", " );
SAFE_SNPRINTF();
}
- ret = oid_get_attr_short_name( &name->oid, &short_name );
+ ret = mbedtls_oid_get_attr_short_name( &name->oid, &short_name );
if( ret == 0 )
- ret = polarssl_snprintf( p, n, "%s=", short_name );
+ ret = mbedtls_snprintf( p, n, "%s=", short_name );
else
- ret = polarssl_snprintf( p, n, "\?\?=" );
+ ret = mbedtls_snprintf( p, n, "\?\?=" );
SAFE_SNPRINTF();
for( i = 0; i < name->val.len; i++ )
@@ -770,7 +770,7 @@
else s[i] = c;
}
s[i] = '\0';
- ret = polarssl_snprintf( p, n, "%s", s );
+ ret = mbedtls_snprintf( p, n, "%s", s );
SAFE_SNPRINTF();
merge = name->next_merged;
@@ -784,7 +784,7 @@
* Store the serial in printable form into buf; no more
* than size characters will be written
*/
-int x509_serial_gets( char *buf, size_t size, const x509_buf *serial )
+int mbedtls_x509_serial_gets( char *buf, size_t size, const mbedtls_x509_buf *serial )
{
int ret;
size_t i, n, nr;
@@ -801,14 +801,14 @@
if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
continue;
- ret = polarssl_snprintf( p, n, "%02X%s",
+ ret = mbedtls_snprintf( p, n, "%02X%s",
serial->p[i], ( i < nr - 1 ) ? ":" : "" );
SAFE_SNPRINTF();
}
if( nr != serial->len )
{
- ret = polarssl_snprintf( p, n, "...." );
+ ret = mbedtls_snprintf( p, n, "...." );
SAFE_SNPRINTF();
}
@@ -818,8 +818,8 @@
/*
* Helper for writing signature algorithms
*/
-int x509_sig_alg_gets( char *buf, size_t size, const x509_buf *sig_oid,
- pk_type_t pk_alg, md_type_t md_alg,
+int mbedtls_x509_sig_alg_gets( char *buf, size_t size, const mbedtls_x509_buf *sig_oid,
+ mbedtls_pk_type_t pk_alg, mbedtls_md_type_t md_alg,
const void *sig_opts )
{
int ret;
@@ -827,27 +827,27 @@
size_t n = size;
const char *desc = NULL;
- ret = oid_get_sig_alg_desc( sig_oid, &desc );
+ ret = mbedtls_oid_get_sig_alg_desc( sig_oid, &desc );
if( ret != 0 )
- ret = polarssl_snprintf( p, n, "???" );
+ ret = mbedtls_snprintf( p, n, "???" );
else
- ret = polarssl_snprintf( p, n, "%s", desc );
+ ret = mbedtls_snprintf( p, n, "%s", desc );
SAFE_SNPRINTF();
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- if( pk_alg == POLARSSL_PK_RSASSA_PSS )
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
- const pk_rsassa_pss_options *pss_opts;
- const md_info_t *md_info, *mgf_md_info;
+ const mbedtls_pk_rsassa_pss_options *pss_opts;
+ const mbedtls_md_info_t *md_info, *mgf_md_info;
- pss_opts = (const pk_rsassa_pss_options *) sig_opts;
+ pss_opts = (const mbedtls_pk_rsassa_pss_options *) sig_opts;
- md_info = md_info_from_type( md_alg );
- mgf_md_info = md_info_from_type( pss_opts->mgf1_hash_id );
+ md_info = mbedtls_md_info_from_type( md_alg );
+ mgf_md_info = mbedtls_md_info_from_type( pss_opts->mgf1_hash_id );
- ret = polarssl_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
- md_info ? md_get_name( md_info ) : "???",
- mgf_md_info ? md_get_name( mgf_md_info ) : "???",
+ ret = mbedtls_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
+ md_info ? mbedtls_md_get_name( md_info ) : "???",
+ mgf_md_info ? mbedtls_md_get_name( mgf_md_info ) : "???",
pss_opts->expected_salt_len );
SAFE_SNPRINTF();
}
@@ -855,7 +855,7 @@
((void) pk_alg);
((void) md_alg);
((void) sig_opts);
-#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
+#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
return( (int)( size - n ) );
}
@@ -863,27 +863,27 @@
/*
* Helper for writing "RSA key size", "EC key size", etc
*/
-int x509_key_size_helper( char *buf, size_t size, const char *name )
+int mbedtls_x509_key_size_helper( char *buf, size_t size, const char *name )
{
char *p = buf;
size_t n = size;
int ret;
if( strlen( name ) + sizeof( " key size" ) > size )
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL );
- ret = polarssl_snprintf( p, n, "%s key size", name );
+ ret = mbedtls_snprintf( p, n, "%s key size", name );
SAFE_SNPRINTF();
return( 0 );
}
/*
- * Return 0 if the x509_time is still valid, or 1 otherwise.
+ * Return 0 if the mbedtls_x509_time is still valid, or 1 otherwise.
*/
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
-static void x509_get_current_time( x509_time *now )
+static void x509_get_current_time( mbedtls_x509_time *now )
{
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
SYSTEMTIME st;
@@ -915,7 +915,7 @@
/*
* Return 0 if before <= after, 1 otherwise
*/
-static int x509_check_time( const x509_time *before, const x509_time *after )
+static int x509_check_time( const mbedtls_x509_time *before, const mbedtls_x509_time *after )
{
if( before->year > after->year )
return( 1 );
@@ -953,40 +953,40 @@
return( 0 );
}
-int x509_time_expired( const x509_time *to )
+int mbedtls_x509_time_expired( const mbedtls_x509_time *to )
{
- x509_time now;
+ mbedtls_x509_time now;
x509_get_current_time( &now );
return( x509_check_time( &now, to ) );
}
-int x509_time_future( const x509_time *from )
+int mbedtls_x509_time_future( const mbedtls_x509_time *from )
{
- x509_time now;
+ mbedtls_x509_time now;
x509_get_current_time( &now );
return( x509_check_time( from, &now ) );
}
-#else /* POLARSSL_HAVE_TIME */
+#else /* MBEDTLS_HAVE_TIME */
-int x509_time_expired( const x509_time *to )
+int mbedtls_x509_time_expired( const mbedtls_x509_time *to )
{
((void) to);
return( 0 );
}
-int x509_time_future( const x509_time *from )
+int mbedtls_x509_time_future( const mbedtls_x509_time *from )
{
((void) from);
return( 0 );
}
-#endif /* POLARSSL_HAVE_TIME */
+#endif /* MBEDTLS_HAVE_TIME */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
#include "mbedtls/x509_crt.h"
#include "mbedtls/certs.h"
@@ -994,68 +994,68 @@
/*
* Checkup routine
*/
-int x509_self_test( int verbose )
+int mbedtls_x509_self_test( int verbose )
{
-#if defined(POLARSSL_CERTS_C) && defined(POLARSSL_SHA1_C)
+#if defined(MBEDTLS_CERTS_C) && defined(MBEDTLS_SHA1_C)
int ret;
int flags;
- x509_crt cacert;
- x509_crt clicert;
+ mbedtls_x509_crt cacert;
+ mbedtls_x509_crt clicert;
if( verbose != 0 )
- polarssl_printf( " X.509 certificate load: " );
+ mbedtls_printf( " X.509 certificate load: " );
- x509_crt_init( &clicert );
+ mbedtls_x509_crt_init( &clicert );
- ret = x509_crt_parse( &clicert, (const unsigned char *) test_cli_crt,
- strlen( test_cli_crt ) );
+ ret = mbedtls_x509_crt_parse( &clicert, (const unsigned char *) mbedtls_test_cli_crt,
+ strlen( mbedtls_test_cli_crt ) );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( ret );
}
- x509_crt_init( &cacert );
+ mbedtls_x509_crt_init( &cacert );
- ret = x509_crt_parse( &cacert, (const unsigned char *) test_ca_crt,
- strlen( test_ca_crt ) );
+ ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_ca_crt,
+ strlen( mbedtls_test_ca_crt ) );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
return( ret );
}
if( verbose != 0 )
- polarssl_printf( "passed\n X.509 signature verify: ");
+ mbedtls_printf( "passed\n X.509 signature verify: ");
- ret = x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
+ ret = mbedtls_x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
if( ret != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
- polarssl_printf( "ret = %d, &flags = %04x\n", ret, flags );
+ mbedtls_printf( "ret = %d, &flags = %04x\n", ret, flags );
return( ret );
}
if( verbose != 0 )
- polarssl_printf( "passed\n\n");
+ mbedtls_printf( "passed\n\n");
- x509_crt_free( &cacert );
- x509_crt_free( &clicert );
+ mbedtls_x509_crt_free( &cacert );
+ mbedtls_x509_crt_free( &clicert );
return( 0 );
#else
((void) verbose);
- return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
-#endif /* POLARSSL_CERTS_C && POLARSSL_SHA1_C */
+ return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
+#endif /* MBEDTLS_CERTS_C && MBEDTLS_SHA1_C */
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_X509_USE_C */
+#endif /* MBEDTLS_X509_USE_C */
diff --git a/library/x509_create.c b/library/x509_create.c
index 5318cd3..9a22052 100644
--- a/library/x509_create.c
+++ b/library/x509_create.c
@@ -20,13 +20,13 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CREATE_C)
+#if defined(MBEDTLS_X509_CREATE_C)
#include "mbedtls/x509.h"
#include "mbedtls/asn1write.h"
@@ -49,34 +49,34 @@
static const x509_attr_descriptor_t x509_attrs[] =
{
- { ADD_STRLEN( "CN" ), OID_AT_CN },
- { ADD_STRLEN( "commonName" ), OID_AT_CN },
- { ADD_STRLEN( "C" ), OID_AT_COUNTRY },
- { ADD_STRLEN( "countryName" ), OID_AT_COUNTRY },
- { ADD_STRLEN( "O" ), OID_AT_ORGANIZATION },
- { ADD_STRLEN( "organizationName" ), OID_AT_ORGANIZATION },
- { ADD_STRLEN( "L" ), OID_AT_LOCALITY },
- { ADD_STRLEN( "locality" ), OID_AT_LOCALITY },
- { ADD_STRLEN( "R" ), OID_PKCS9_EMAIL },
- { ADD_STRLEN( "OU" ), OID_AT_ORG_UNIT },
- { ADD_STRLEN( "organizationalUnitName" ), OID_AT_ORG_UNIT },
- { ADD_STRLEN( "ST" ), OID_AT_STATE },
- { ADD_STRLEN( "stateOrProvinceName" ), OID_AT_STATE },
- { ADD_STRLEN( "emailAddress" ), OID_PKCS9_EMAIL },
- { ADD_STRLEN( "serialNumber" ), OID_AT_SERIAL_NUMBER },
- { ADD_STRLEN( "postalAddress" ), OID_AT_POSTAL_ADDRESS },
- { ADD_STRLEN( "postalCode" ), OID_AT_POSTAL_CODE },
- { ADD_STRLEN( "dnQualifier" ), OID_AT_DN_QUALIFIER },
- { ADD_STRLEN( "title" ), OID_AT_TITLE },
- { ADD_STRLEN( "surName" ), OID_AT_SUR_NAME },
- { ADD_STRLEN( "SN" ), OID_AT_SUR_NAME },
- { ADD_STRLEN( "givenName" ), OID_AT_GIVEN_NAME },
- { ADD_STRLEN( "GN" ), OID_AT_GIVEN_NAME },
- { ADD_STRLEN( "initials" ), OID_AT_INITIALS },
- { ADD_STRLEN( "pseudonym" ), OID_AT_PSEUDONYM },
- { ADD_STRLEN( "generationQualifier" ), OID_AT_GENERATION_QUALIFIER },
- { ADD_STRLEN( "domainComponent" ), OID_DOMAIN_COMPONENT },
- { ADD_STRLEN( "DC" ), OID_DOMAIN_COMPONENT },
+ { ADD_STRLEN( "CN" ), MBEDTLS_OID_AT_CN },
+ { ADD_STRLEN( "commonName" ), MBEDTLS_OID_AT_CN },
+ { ADD_STRLEN( "C" ), MBEDTLS_OID_AT_COUNTRY },
+ { ADD_STRLEN( "countryName" ), MBEDTLS_OID_AT_COUNTRY },
+ { ADD_STRLEN( "O" ), MBEDTLS_OID_AT_ORGANIZATION },
+ { ADD_STRLEN( "organizationName" ), MBEDTLS_OID_AT_ORGANIZATION },
+ { ADD_STRLEN( "L" ), MBEDTLS_OID_AT_LOCALITY },
+ { ADD_STRLEN( "locality" ), MBEDTLS_OID_AT_LOCALITY },
+ { ADD_STRLEN( "R" ), MBEDTLS_OID_PKCS9_EMAIL },
+ { ADD_STRLEN( "OU" ), MBEDTLS_OID_AT_ORG_UNIT },
+ { ADD_STRLEN( "organizationalUnitName" ), MBEDTLS_OID_AT_ORG_UNIT },
+ { ADD_STRLEN( "ST" ), MBEDTLS_OID_AT_STATE },
+ { ADD_STRLEN( "stateOrProvinceName" ), MBEDTLS_OID_AT_STATE },
+ { ADD_STRLEN( "emailAddress" ), MBEDTLS_OID_PKCS9_EMAIL },
+ { ADD_STRLEN( "serialNumber" ), MBEDTLS_OID_AT_SERIAL_NUMBER },
+ { ADD_STRLEN( "postalAddress" ), MBEDTLS_OID_AT_POSTAL_ADDRESS },
+ { ADD_STRLEN( "postalCode" ), MBEDTLS_OID_AT_POSTAL_CODE },
+ { ADD_STRLEN( "dnQualifier" ), MBEDTLS_OID_AT_DN_QUALIFIER },
+ { ADD_STRLEN( "title" ), MBEDTLS_OID_AT_TITLE },
+ { ADD_STRLEN( "surName" ), MBEDTLS_OID_AT_SUR_NAME },
+ { ADD_STRLEN( "SN" ), MBEDTLS_OID_AT_SUR_NAME },
+ { ADD_STRLEN( "givenName" ), MBEDTLS_OID_AT_GIVEN_NAME },
+ { ADD_STRLEN( "GN" ), MBEDTLS_OID_AT_GIVEN_NAME },
+ { ADD_STRLEN( "initials" ), MBEDTLS_OID_AT_INITIALS },
+ { ADD_STRLEN( "pseudonym" ), MBEDTLS_OID_AT_PSEUDONYM },
+ { ADD_STRLEN( "generationQualifier" ), MBEDTLS_OID_AT_GENERATION_QUALIFIER },
+ { ADD_STRLEN( "domainComponent" ), MBEDTLS_OID_DOMAIN_COMPONENT },
+ { ADD_STRLEN( "DC" ), MBEDTLS_OID_DOMAIN_COMPONENT },
{ NULL, 0, NULL }
};
@@ -92,18 +92,18 @@
return( cur->oid );
}
-int x509_string_to_names( asn1_named_data **head, const char *name )
+int mbedtls_x509_string_to_names( mbedtls_asn1_named_data **head, const char *name )
{
int ret = 0;
const char *s = name, *c = s;
const char *end = s + strlen( s );
const char *oid = NULL;
int in_tag = 1;
- char data[X509_MAX_DN_NAME_SIZE];
+ char data[MBEDTLS_X509_MAX_DN_NAME_SIZE];
char *d = data;
/* Clear existing chain if present */
- asn1_free_named_data_list( head );
+ mbedtls_asn1_free_named_data_list( head );
while( c <= end )
{
@@ -111,7 +111,7 @@
{
if( ( oid = x509_at_oid_from_name( s, c - s ) ) == NULL )
{
- ret = POLARSSL_ERR_X509_UNKNOWN_OID;
+ ret = MBEDTLS_ERR_X509_UNKNOWN_OID;
goto exit;
}
@@ -127,17 +127,17 @@
/* Check for valid escaped characters */
if( c == end || *c != ',' )
{
- ret = POLARSSL_ERR_X509_INVALID_NAME;
+ ret = MBEDTLS_ERR_X509_INVALID_NAME;
goto exit;
}
}
else if( !in_tag && ( *c == ',' || c == end ) )
{
- if( asn1_store_named_data( head, oid, strlen( oid ),
+ if( mbedtls_asn1_store_named_data( head, oid, strlen( oid ),
(unsigned char *) data,
d - data ) == NULL )
{
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
}
while( c < end && *(c + 1) == ' ' )
@@ -151,9 +151,9 @@
{
*(d++) = *c;
- if( d - data == X509_MAX_DN_NAME_SIZE )
+ if( d - data == MBEDTLS_X509_MAX_DN_NAME_SIZE )
{
- ret = POLARSSL_ERR_X509_INVALID_NAME;
+ ret = MBEDTLS_ERR_X509_INVALID_NAME;
goto exit;
}
}
@@ -166,18 +166,18 @@
return( ret );
}
-/* The first byte of the value in the asn1_named_data structure is reserved
+/* The first byte of the value in the mbedtls_asn1_named_data structure is reserved
* to store the critical boolean for us
*/
-int x509_set_extension( asn1_named_data **head, const char *oid, size_t oid_len,
+int mbedtls_x509_set_extension( mbedtls_asn1_named_data **head, const char *oid, size_t oid_len,
int critical, const unsigned char *val, size_t val_len )
{
- asn1_named_data *cur;
+ mbedtls_asn1_named_data *cur;
- if( ( cur = asn1_store_named_data( head, oid, oid_len,
+ if( ( cur = mbedtls_asn1_store_named_data( head, oid, oid_len,
NULL, val_len + 1 ) ) == NULL )
{
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
}
cur->val.p[0] = critical;
@@ -205,60 +205,60 @@
int ret;
size_t len = 0;
- // Write PrintableString for all except OID_PKCS9_EMAIL
+ // Write PrintableString for all except MBEDTLS_OID_PKCS9_EMAIL
//
- if( OID_SIZE( OID_PKCS9_EMAIL ) == oid_len &&
- memcmp( oid, OID_PKCS9_EMAIL, oid_len ) == 0 )
+ if( MBEDTLS_OID_SIZE( MBEDTLS_OID_PKCS9_EMAIL ) == oid_len &&
+ memcmp( oid, MBEDTLS_OID_PKCS9_EMAIL, oid_len ) == 0 )
{
- ASN1_CHK_ADD( len, asn1_write_ia5_string( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_ia5_string( p, start,
(const char *) name,
name_len ) );
}
else
{
- ASN1_CHK_ADD( len, asn1_write_printable_string( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_printable_string( p, start,
(const char *) name,
name_len ) );
}
// Write OID
//
- ASN1_CHK_ADD( len, asn1_write_oid( p, start, oid, oid_len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( p, start, oid, oid_len ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_CONSTRUCTED |
- ASN1_SET ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SET ) );
return( (int) len );
}
-int x509_write_names( unsigned char **p, unsigned char *start,
- asn1_named_data *first )
+int mbedtls_x509_write_names( unsigned char **p, unsigned char *start,
+ mbedtls_asn1_named_data *first )
{
int ret;
size_t len = 0;
- asn1_named_data *cur = first;
+ mbedtls_asn1_named_data *cur = first;
while( cur != NULL )
{
- ASN1_CHK_ADD( len, x509_write_name( p, start, (char *) cur->oid.p,
+ MBEDTLS_ASN1_CHK_ADD( len, x509_write_name( p, start, (char *) cur->oid.p,
cur->oid.len,
cur->val.p, cur->val.len ) );
cur = cur->next;
}
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
-int x509_write_sig( unsigned char **p, unsigned char *start,
+int mbedtls_x509_write_sig( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len,
unsigned char *sig, size_t size )
{
@@ -266,7 +266,7 @@
size_t len = 0;
if( *p - start < (int) size + 1 )
- return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size;
(*p) -= len;
@@ -275,41 +275,41 @@
*--(*p) = 0;
len += 1;
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_BIT_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BIT_STRING ) );
// Write OID
//
- ASN1_CHK_ADD( len, asn1_write_algorithm_identifier( p, start, oid,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_algorithm_identifier( p, start, oid,
oid_len, 0 ) );
return( (int) len );
}
static int x509_write_extension( unsigned char **p, unsigned char *start,
- asn1_named_data *ext )
+ mbedtls_asn1_named_data *ext )
{
int ret;
size_t len = 0;
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start, ext->val.p + 1,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, ext->val.p + 1,
ext->val.len - 1 ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, ext->val.len - 1 ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_OCTET_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, ext->val.len - 1 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OCTET_STRING ) );
if( ext->val.p[0] != 0 )
{
- ASN1_CHK_ADD( len, asn1_write_bool( p, start, 1 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_bool( p, start, 1 ) );
}
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start, ext->oid.p,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, ext->oid.p,
ext->oid.len ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, ext->oid.len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_OID ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, ext->oid.len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OID ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
@@ -324,20 +324,20 @@
* -- by extnID
* }
*/
-int x509_write_extensions( unsigned char **p, unsigned char *start,
- asn1_named_data *first )
+int mbedtls_x509_write_extensions( unsigned char **p, unsigned char *start,
+ mbedtls_asn1_named_data *first )
{
int ret;
size_t len = 0;
- asn1_named_data *cur_ext = first;
+ mbedtls_asn1_named_data *cur_ext = first;
while( cur_ext != NULL )
{
- ASN1_CHK_ADD( len, x509_write_extension( p, start, cur_ext ) );
+ MBEDTLS_ASN1_CHK_ADD( len, x509_write_extension( p, start, cur_ext ) );
cur_ext = cur_ext->next;
}
return( (int) len );
}
-#endif /* POLARSSL_X509_CREATE_C */
+#endif /* MBEDTLS_X509_CREATE_C */
diff --git a/library/x509_crl.c b/library/x509_crl.c
index 7d1693b..dd3302b 100644
--- a/library/x509_crl.c
+++ b/library/x509_crl.c
@@ -30,31 +30,31 @@
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CRL_PARSE_C)
+#if defined(MBEDTLS_X509_CRL_PARSE_C)
#include "mbedtls/x509_crl.h"
#include "mbedtls/oid.h"
#include <string.h>
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
#include <stdio.h>
-#define polarssl_free free
-#define polarssl_malloc malloc
-#define polarssl_snprintf snprintf
+#define mbedtls_free free
+#define mbedtls_malloc malloc
+#define mbedtls_snprintf snprintf
#endif
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
@@ -63,12 +63,12 @@
#include <time.h>
#endif
-#if defined(POLARSSL_FS_IO) || defined(EFIX64) || defined(EFI32)
+#if defined(MBEDTLS_FS_IO) || defined(EFIX64) || defined(EFI32)
#include <stdio.h>
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -81,15 +81,15 @@
{
int ret;
- if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
*ver = 0;
return( 0 );
}
- return( POLARSSL_ERR_X509_INVALID_VERSION + ret );
+ return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
}
return( 0 );
@@ -100,15 +100,15 @@
*/
static int x509_get_crl_ext( unsigned char **p,
const unsigned char *end,
- x509_buf *ext )
+ mbedtls_x509_buf *ext )
{
int ret;
size_t len = 0;
/* Get explicit tag */
- if( ( ret = x509_get_ext( p, end, ext, 0) ) != 0 )
+ if( ( ret = mbedtls_x509_get_ext( p, end, ext, 0) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
@@ -116,16 +116,16 @@
while( *p < end )
{
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
*p += len;
}
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -135,7 +135,7 @@
*/
static int x509_get_crl_entry_ext( unsigned char **p,
const unsigned char *end,
- x509_buf *ext )
+ mbedtls_x509_buf *ext )
{
int ret;
size_t len = 0;
@@ -151,35 +151,35 @@
* Get CRL-entry extension sequence header
* crlEntryExtensions Extensions OPTIONAL -- if present, MUST be v2
*/
- if( ( ret = asn1_get_tag( p, end, &ext->len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
ext->p = NULL;
return( 0 );
}
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
}
end = *p + ext->len;
if( end != *p + ext->len )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
*p += len;
}
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -189,19 +189,19 @@
*/
static int x509_get_entries( unsigned char **p,
const unsigned char *end,
- x509_crl_entry *entry )
+ mbedtls_x509_crl_entry *entry )
{
int ret;
size_t entry_len;
- x509_crl_entry *cur_entry = entry;
+ mbedtls_x509_crl_entry *cur_entry = entry;
if( *p == end )
return( 0 );
- if( ( ret = asn1_get_tag( p, end, &entry_len,
- ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &entry_len,
+ MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
@@ -214,8 +214,8 @@
size_t len2;
const unsigned char *end2;
- if( ( ret = asn1_get_tag( p, end, &len2,
- ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len2,
+ MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )
{
return( ret );
}
@@ -225,10 +225,10 @@
cur_entry->raw.len = len2;
end2 = *p + len2;
- if( ( ret = x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )
return( ret );
- if( ( ret = x509_get_time( p, end2,
+ if( ( ret = mbedtls_x509_get_time( p, end2,
&cur_entry->revocation_date ) ) != 0 )
return( ret );
@@ -238,12 +238,12 @@
if( *p < end )
{
- cur_entry->next = polarssl_malloc( sizeof( x509_crl_entry ) );
+ cur_entry->next = mbedtls_malloc( sizeof( mbedtls_x509_crl_entry ) );
if( cur_entry->next == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
- memset( cur_entry->next, 0, sizeof( x509_crl_entry ) );
+ memset( cur_entry->next, 0, sizeof( mbedtls_x509_crl_entry ) );
cur_entry = cur_entry->next;
}
}
@@ -254,24 +254,24 @@
/*
* Parse one CRLs in DER format and append it to the chained list
*/
-int x509_crl_parse_der( x509_crl *chain,
+int mbedtls_x509_crl_parse_der( mbedtls_x509_crl *chain,
const unsigned char *buf, size_t buflen )
{
int ret;
size_t len;
unsigned char *p, *end;
- x509_buf sig_params1, sig_params2, sig_oid2;
- x509_crl *crl = chain;
+ mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
+ mbedtls_x509_crl *crl = chain;
/*
* Check for valid input
*/
if( crl == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- memset( &sig_params1, 0, sizeof( x509_buf ) );
- memset( &sig_params2, 0, sizeof( x509_buf ) );
- memset( &sig_oid2, 0, sizeof( x509_buf ) );
+ memset( &sig_params1, 0, sizeof( mbedtls_x509_buf ) );
+ memset( &sig_params2, 0, sizeof( mbedtls_x509_buf ) );
+ memset( &sig_oid2, 0, sizeof( mbedtls_x509_buf ) );
/*
* Add new CRL on the end of the chain if needed.
@@ -281,23 +281,23 @@
if( crl->version != 0 && crl->next == NULL )
{
- crl->next = polarssl_malloc( sizeof( x509_crl ) );
+ crl->next = mbedtls_malloc( sizeof( mbedtls_x509_crl ) );
if( crl->next == NULL )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
}
- x509_crl_init( crl->next );
+ mbedtls_x509_crl_init( crl->next );
crl = crl->next;
}
/*
* Copy raw DER-encoded CRL
*/
- if( ( p = polarssl_malloc( buflen ) ) == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ if( ( p = mbedtls_malloc( buflen ) ) == NULL )
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
memcpy( p, buf, buflen );
@@ -312,18 +312,18 @@
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT );
}
if( len != (size_t) ( end - p ) )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
/*
@@ -331,11 +331,11 @@
*/
crl->tbs.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = p + len;
@@ -348,9 +348,9 @@
* signature AlgorithmIdentifier
*/
if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 ||
- ( ret = x509_get_alg( &p, end, &crl->sig_oid, &sig_params1 ) ) != 0 )
+ ( ret = mbedtls_x509_get_alg( &p, end, &crl->sig_oid, &sig_params1 ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
@@ -358,16 +358,16 @@
if( crl->version > 2 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_UNKNOWN_VERSION );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
}
- if( ( ret = x509_get_sig_alg( &crl->sig_oid, &sig_params1,
+ if( ( ret = mbedtls_x509_get_sig_alg( &crl->sig_oid, &sig_params1,
&crl->sig_md, &crl->sig_pk,
&crl->sig_opts ) ) != 0 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG );
}
/*
@@ -375,16 +375,16 @@
*/
crl->issuer_raw.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
- if( ( ret = x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
@@ -394,20 +394,20 @@
* thisUpdate Time
* nextUpdate Time OPTIONAL
*/
- if( ( ret = x509_get_time( &p, end, &crl->this_update ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_time( &p, end, &crl->this_update ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
- if( ( ret = x509_get_time( &p, end, &crl->next_update ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_time( &p, end, &crl->next_update ) ) != 0 )
{
- if( ret != ( POLARSSL_ERR_X509_INVALID_DATE +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) &&
- ret != ( POLARSSL_ERR_X509_INVALID_DATE +
- POLARSSL_ERR_ASN1_OUT_OF_DATA ) )
+ if( ret != ( MBEDTLS_ERR_X509_INVALID_DATE +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) &&
+ ret != ( MBEDTLS_ERR_X509_INVALID_DATE +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA ) )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
}
@@ -422,7 +422,7 @@
*/
if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
@@ -436,16 +436,16 @@
if( ret != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
}
if( p != end )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
end = crl->raw.p + crl->raw.len;
@@ -454,9 +454,9 @@
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING
*/
- if( ( ret = x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
@@ -465,21 +465,21 @@
sig_params1.len != sig_params2.len ||
memcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_SIG_MISMATCH );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_SIG_MISMATCH );
}
- if( ( ret = x509_get_sig( &p, end, &crl->sig ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_sig( &p, end, &crl->sig ) ) != 0 )
{
- x509_crl_free( crl );
+ mbedtls_x509_crl_free( crl );
return( ret );
}
if( p != end )
{
- x509_crl_free( crl );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crl_free( crl );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return( 0 );
@@ -488,21 +488,21 @@
/*
* Parse one or more CRLs and add them to the chained list
*/
-int x509_crl_parse( x509_crl *chain, const unsigned char *buf, size_t buflen )
+int mbedtls_x509_crl_parse( mbedtls_x509_crl *chain, const unsigned char *buf, size_t buflen )
{
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
int ret;
size_t use_len;
- pem_context pem;
+ mbedtls_pem_context pem;
int is_pem = 0;
if( chain == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
do
{
- pem_init( &pem );
- ret = pem_read_buffer( &pem,
+ mbedtls_pem_init( &pem );
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN X509 CRL-----",
"-----END X509 CRL-----",
buf, NULL, 0, &use_len );
@@ -517,17 +517,17 @@
buflen -= use_len;
buf += use_len;
- if( ( ret = x509_crl_parse_der( chain,
+ if( ( ret = mbedtls_x509_crl_parse_der( chain,
pem.buf, pem.buflen ) ) != 0 )
{
return( ret );
}
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
}
@@ -536,31 +536,31 @@
if( is_pem )
return( 0 );
else
-#endif /* POLARSSL_PEM_PARSE_C */
- return( x509_crl_parse_der( chain, buf, buflen ) );
+#endif /* MBEDTLS_PEM_PARSE_C */
+ return( mbedtls_x509_crl_parse_der( chain, buf, buflen ) );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* Load one or more CRLs and add them to the chained list
*/
-int x509_crl_parse_file( x509_crl *chain, const char *path )
+int mbedtls_x509_crl_parse_file( mbedtls_x509_crl *chain, const char *path )
{
int ret;
size_t n;
unsigned char *buf;
- if( ( ret = pk_load_file( path, &buf, &n ) ) != 0 )
+ if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
- ret = x509_crl_parse( chain, buf, n );
+ ret = mbedtls_x509_crl_parse( chain, buf, n );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
!defined(EFI32)
@@ -598,7 +598,7 @@
#define snprintf compat_snprintf
#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
-#define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
+#define MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL -2
#define SAFE_SNPRINTF() \
{ \
@@ -607,7 +607,7 @@
\
if( (unsigned int) ret > n ) { \
p[n - 1] = '\0'; \
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL ); \
} \
\
n -= (unsigned int) ret; \
@@ -622,34 +622,34 @@
/*
* Return an informational string about the CRL.
*/
-int x509_crl_info( char *buf, size_t size, const char *prefix,
- const x509_crl *crl )
+int mbedtls_x509_crl_info( char *buf, size_t size, const char *prefix,
+ const mbedtls_x509_crl *crl )
{
int ret;
size_t n;
char *p;
- const x509_crl_entry *entry;
+ const mbedtls_x509_crl_entry *entry;
p = buf;
n = size;
- ret = polarssl_snprintf( p, n, "%sCRL version : %d",
+ ret = mbedtls_snprintf( p, n, "%sCRL version : %d",
prefix, crl->version );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%sissuer name : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
SAFE_SNPRINTF();
- ret = x509_dn_gets( p, n, &crl->issuer );
+ ret = mbedtls_x509_dn_gets( p, n, &crl->issuer );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%sthis update : " \
+ ret = mbedtls_snprintf( p, n, "\n%sthis update : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crl->this_update.year, crl->this_update.mon,
crl->this_update.day, crl->this_update.hour,
crl->this_update.min, crl->this_update.sec );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%snext update : " \
+ ret = mbedtls_snprintf( p, n, "\n%snext update : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crl->next_update.year, crl->next_update.mon,
crl->next_update.day, crl->next_update.hour,
@@ -658,20 +658,20 @@
entry = &crl->entry;
- ret = polarssl_snprintf( p, n, "\n%sRevoked certificates:",
+ ret = mbedtls_snprintf( p, n, "\n%sRevoked certificates:",
prefix );
SAFE_SNPRINTF();
while( entry != NULL && entry->raw.len != 0 )
{
- ret = polarssl_snprintf( p, n, "\n%sserial number: ",
+ ret = mbedtls_snprintf( p, n, "\n%sserial number: ",
prefix );
SAFE_SNPRINTF();
- ret = x509_serial_gets( p, n, &entry->serial );
+ ret = mbedtls_x509_serial_gets( p, n, &entry->serial );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, " revocation date: " \
+ ret = mbedtls_snprintf( p, n, " revocation date: " \
"%04d-%02d-%02d %02d:%02d:%02d",
entry->revocation_date.year, entry->revocation_date.mon,
entry->revocation_date.day, entry->revocation_date.hour,
@@ -681,14 +681,14 @@
entry = entry->next;
}
- ret = polarssl_snprintf( p, n, "\n%ssigned using : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
SAFE_SNPRINTF();
- ret = x509_sig_alg_gets( p, n, &crl->sig_oid, crl->sig_pk, crl->sig_md,
+ ret = mbedtls_x509_sig_alg_gets( p, n, &crl->sig_oid, crl->sig_pk, crl->sig_md,
crl->sig_opts );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n" );
+ ret = mbedtls_snprintf( p, n, "\n" );
SAFE_SNPRINTF();
return( (int) ( size - n ) );
@@ -697,30 +697,30 @@
/*
* Initialize a CRL chain
*/
-void x509_crl_init( x509_crl *crl )
+void mbedtls_x509_crl_init( mbedtls_x509_crl *crl )
{
- memset( crl, 0, sizeof(x509_crl) );
+ memset( crl, 0, sizeof(mbedtls_x509_crl) );
}
/*
* Unallocate all CRL data
*/
-void x509_crl_free( x509_crl *crl )
+void mbedtls_x509_crl_free( mbedtls_x509_crl *crl )
{
- x509_crl *crl_cur = crl;
- x509_crl *crl_prv;
- x509_name *name_cur;
- x509_name *name_prv;
- x509_crl_entry *entry_cur;
- x509_crl_entry *entry_prv;
+ mbedtls_x509_crl *crl_cur = crl;
+ mbedtls_x509_crl *crl_prv;
+ mbedtls_x509_name *name_cur;
+ mbedtls_x509_name *name_prv;
+ mbedtls_x509_crl_entry *entry_cur;
+ mbedtls_x509_crl_entry *entry_prv;
if( crl == NULL )
return;
do
{
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- polarssl_free( crl_cur->sig_opts );
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ mbedtls_free( crl_cur->sig_opts );
#endif
name_cur = crl_cur->issuer.next;
@@ -728,8 +728,8 @@
{
name_prv = name_cur;
name_cur = name_cur->next;
- polarssl_zeroize( name_prv, sizeof( x509_name ) );
- polarssl_free( name_prv );
+ mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
+ mbedtls_free( name_prv );
}
entry_cur = crl_cur->entry.next;
@@ -737,14 +737,14 @@
{
entry_prv = entry_cur;
entry_cur = entry_cur->next;
- polarssl_zeroize( entry_prv, sizeof( x509_crl_entry ) );
- polarssl_free( entry_prv );
+ mbedtls_zeroize( entry_prv, sizeof( mbedtls_x509_crl_entry ) );
+ mbedtls_free( entry_prv );
}
if( crl_cur->raw.p != NULL )
{
- polarssl_zeroize( crl_cur->raw.p, crl_cur->raw.len );
- polarssl_free( crl_cur->raw.p );
+ mbedtls_zeroize( crl_cur->raw.p, crl_cur->raw.len );
+ mbedtls_free( crl_cur->raw.p );
}
crl_cur = crl_cur->next;
@@ -757,11 +757,11 @@
crl_prv = crl_cur;
crl_cur = crl_cur->next;
- polarssl_zeroize( crl_prv, sizeof( x509_crl ) );
+ mbedtls_zeroize( crl_prv, sizeof( mbedtls_x509_crl ) );
if( crl_prv != crl )
- polarssl_free( crl_prv );
+ mbedtls_free( crl_prv );
}
while( crl_cur != NULL );
}
-#endif /* POLARSSL_X509_CRL_PARSE_C */
+#endif /* MBEDTLS_X509_CRL_PARSE_C */
diff --git a/library/x509_crt.c b/library/x509_crt.c
index b911c4e..78dfabb 100644
--- a/library/x509_crt.c
+++ b/library/x509_crt.c
@@ -30,13 +30,13 @@
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CRT_PARSE_C)
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
#include "mbedtls/x509_crt.h"
#include "mbedtls/oid.h"
@@ -44,20 +44,20 @@
#include <stdio.h>
#include <string.h>
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
-#define polarssl_free free
-#define polarssl_malloc malloc
-#define polarssl_snprintf snprintf
+#define mbedtls_free free
+#define mbedtls_malloc malloc
+#define mbedtls_snprintf snprintf
#endif
-#if defined(POLARSSL_THREADING_C)
+#if defined(MBEDTLS_THREADING_C)
#include "mbedtls/threading.h"
#endif
@@ -67,7 +67,7 @@
#include <time.h>
#endif
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
#if !defined(_WIN32) || defined(EFIX64) || defined(EFI32)
#include <sys/types.h>
@@ -77,7 +77,7 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -91,10 +91,10 @@
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
*ver = 0;
return( 0 );
@@ -105,12 +105,12 @@
end = *p + len;
- if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_VERSION + ret );
+ if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_VERSION +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_VERSION +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -122,27 +122,27 @@
*/
static int x509_get_dates( unsigned char **p,
const unsigned char *end,
- x509_time *from,
- x509_time *to )
+ mbedtls_x509_time *from,
+ mbedtls_x509_time *to )
{
int ret;
size_t len;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_DATE + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
end = *p + len;
- if( ( ret = x509_get_time( p, end, from ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
return( ret );
- if( ( ret = x509_get_time( p, end, to ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
return( ret );
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_DATE +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_DATE +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -152,7 +152,7 @@
*/
static int x509_get_uid( unsigned char **p,
const unsigned char *end,
- x509_buf *uid, int n )
+ mbedtls_x509_buf *uid, int n )
{
int ret;
@@ -161,10 +161,10 @@
uid->tag = **p;
- if( ( ret = asn1_get_tag( p, end, &uid->len,
- ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | n ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
@@ -192,20 +192,20 @@
*ca_istrue = 0; /* DEFAULT FALSE */
*max_pathlen = 0; /* endless */
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p == end )
return( 0 );
- if( ( ret = asn1_get_bool( p, end, ca_istrue ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
- ret = asn1_get_int( p, end, ca_istrue );
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
+ ret = mbedtls_asn1_get_int( p, end, ca_istrue );
if( ret != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *ca_istrue != 0 )
*ca_istrue = 1;
@@ -214,12 +214,12 @@
if( *p == end )
return( 0 );
- if( ( ret = asn1_get_int( p, end, max_pathlen ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
(*max_pathlen)++;
@@ -231,14 +231,14 @@
unsigned char *ns_cert_type)
{
int ret;
- x509_bitstring bs = { 0, 0, NULL };
+ mbedtls_x509_bitstring bs = { 0, 0, NULL };
- if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( bs.len != 1 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* Get actual bitstring */
*ns_cert_type = *bs.p;
@@ -250,14 +250,14 @@
unsigned int *key_usage)
{
int ret;
- x509_bitstring bs = { 0, 0, NULL };
+ mbedtls_x509_bitstring bs = { 0, 0, NULL };
- if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( bs.len < 1 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* Get actual bitstring */
*key_usage = *bs.p;
@@ -271,17 +271,17 @@
*/
static int x509_get_ext_key_usage( unsigned char **p,
const unsigned char *end,
- x509_sequence *ext_key_usage)
+ mbedtls_x509_sequence *ext_key_usage)
{
int ret;
- if( ( ret = asn1_get_sequence_of( p, end, ext_key_usage, ASN1_OID ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_sequence_of( p, end, ext_key_usage, MBEDTLS_ASN1_OID ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/* Sequence length must be >= 1 */
if( ext_key_usage->buf.p == NULL )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_INVALID_LENGTH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_INVALID_LENGTH );
return( 0 );
}
@@ -314,40 +314,40 @@
*/
static int x509_get_subject_alt_name( unsigned char **p,
const unsigned char *end,
- x509_sequence *subject_alt_name )
+ mbedtls_x509_sequence *subject_alt_name )
{
int ret;
size_t len, tag_len;
- asn1_buf *buf;
+ mbedtls_asn1_buf *buf;
unsigned char tag;
- asn1_sequence *cur = subject_alt_name;
+ mbedtls_asn1_sequence *cur = subject_alt_name;
/* Get main sequence tag */
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p + len != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
tag = **p;
(*p)++;
- if( ( ret = asn1_get_len( p, end, &tag_len ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_len( p, end, &tag_len ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
- if( ( tag & ASN1_CONTEXT_SPECIFIC ) != ASN1_CONTEXT_SPECIFIC )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ if( ( tag & MBEDTLS_ASN1_CONTEXT_SPECIFIC ) != MBEDTLS_ASN1_CONTEXT_SPECIFIC )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
/* Skip everything but DNS name */
- if( tag != ( ASN1_CONTEXT_SPECIFIC | 2 ) )
+ if( tag != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | 2 ) )
{
*p += tag_len;
continue;
@@ -357,15 +357,15 @@
if( cur->buf.p != NULL )
{
if( cur->next != NULL )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
- cur->next = polarssl_malloc( sizeof( asn1_sequence ) );
+ cur->next = mbedtls_malloc( sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_MALLOC_FAILED );
- memset( cur->next, 0, sizeof( asn1_sequence ) );
+ memset( cur->next, 0, sizeof( mbedtls_asn1_sequence ) );
cur = cur->next;
}
@@ -380,8 +380,8 @@
cur->next = NULL;
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -395,15 +395,15 @@
*/
static int x509_get_crt_ext( unsigned char **p,
const unsigned char *end,
- x509_crt *crt )
+ mbedtls_x509_crt *crt )
{
int ret;
size_t len;
unsigned char *end_ext_data, *end_ext_octet;
- if( ( ret = x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
@@ -417,61 +417,61 @@
* critical BOOLEAN DEFAULT FALSE,
* extnValue OCTET STRING }
*/
- x509_buf extn_oid = {0, 0, NULL};
+ mbedtls_x509_buf extn_oid = {0, 0, NULL};
int is_critical = 0; /* DEFAULT FALSE */
int ext_type = 0;
- if( ( ret = asn1_get_tag( p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
end_ext_data = *p + len;
/* Get extension ID */
extn_oid.tag = **p;
- if( ( ret = asn1_get_tag( p, end, &extn_oid.len, ASN1_OID ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end, &extn_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
extn_oid.p = *p;
*p += extn_oid.len;
if( ( end - *p ) < 1 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_OUT_OF_DATA );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_OUT_OF_DATA );
/* Get optional critical */
- if( ( ret = asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
- ( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
+ ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/* Data should be octet string type */
- if( ( ret = asn1_get_tag( p, end_ext_data, &len,
- ASN1_OCTET_STRING ) ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
+ if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
+ MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
end_ext_octet = *p + len;
if( end_ext_octet != end_ext_data )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/*
* Detect supported extensions
*/
- ret = oid_get_x509_ext_type( &extn_oid, &ext_type );
+ ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
if( ret != 0 )
{
/* No parser found, skip extension */
*p = end_ext_octet;
-#if !defined(POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
+#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
{
/* Data is marked as critical: fail */
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
#endif
continue;
@@ -479,41 +479,41 @@
/* Forbid repeated extensions */
if( ( crt->ext_types & ext_type ) != 0 )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
crt->ext_types |= ext_type;
switch( ext_type )
{
- case EXT_BASIC_CONSTRAINTS:
+ case MBEDTLS_EXT_BASIC_CONSTRAINTS:
/* Parse basic constraints */
if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
&crt->ca_istrue, &crt->max_pathlen ) ) != 0 )
return( ret );
break;
- case EXT_KEY_USAGE:
+ case MBEDTLS_X509_EXT_KEY_USAGE:
/* Parse key usage */
if( ( ret = x509_get_key_usage( p, end_ext_octet,
&crt->key_usage ) ) != 0 )
return( ret );
break;
- case EXT_EXTENDED_KEY_USAGE:
+ case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
/* Parse extended key usage */
if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
&crt->ext_key_usage ) ) != 0 )
return( ret );
break;
- case EXT_SUBJECT_ALT_NAME:
+ case MBEDTLS_EXT_SUBJECT_ALT_NAME:
/* Parse subject alt name */
if( ( ret = x509_get_subject_alt_name( p, end_ext_octet,
&crt->subject_alt_names ) ) != 0 )
return( ret );
break;
- case EXT_NS_CERT_TYPE:
+ case MBEDTLS_X509_EXT_NS_CERT_TYPE:
/* Parse netscape certificate type */
if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
&crt->ns_cert_type ) ) != 0 )
@@ -521,13 +521,13 @@
break;
default:
- return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
+ return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
}
}
if( *p != end )
- return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
@@ -535,27 +535,27 @@
/*
* Parse and fill a single X.509 certificate in DER format
*/
-static int x509_crt_parse_der_core( x509_crt *crt, const unsigned char *buf,
+static int x509_crt_parse_der_core( mbedtls_x509_crt *crt, const unsigned char *buf,
size_t buflen )
{
int ret;
size_t len;
unsigned char *p, *end, *crt_end;
- x509_buf sig_params1, sig_params2, sig_oid2;
+ mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
- memset( &sig_params1, 0, sizeof( x509_buf ) );
- memset( &sig_params2, 0, sizeof( x509_buf ) );
- memset( &sig_oid2, 0, sizeof( x509_buf ) );
+ memset( &sig_params1, 0, sizeof( mbedtls_x509_buf ) );
+ memset( &sig_params2, 0, sizeof( mbedtls_x509_buf ) );
+ memset( &sig_oid2, 0, sizeof( mbedtls_x509_buf ) );
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- p = polarssl_malloc( len = buflen );
+ p = mbedtls_malloc( len = buflen );
if( p == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
memcpy( p, buf, buflen );
@@ -569,18 +569,18 @@
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT );
}
if( len > (size_t) ( end - p ) )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
crt_end = p + len;
@@ -589,11 +589,11 @@
*/
crt->tbs.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = p + len;
@@ -607,11 +607,11 @@
* signature AlgorithmIdentifier
*/
if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 ||
- ( ret = x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
- ( ret = x509_get_alg( &p, end, &crt->sig_oid,
+ ( ret = mbedtls_x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
+ ( ret = mbedtls_x509_get_alg( &p, end, &crt->sig_oid,
&sig_params1 ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -619,15 +619,15 @@
if( crt->version > 3 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_UNKNOWN_VERSION );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
}
- if( ( ret = x509_get_sig_alg( &crt->sig_oid, &sig_params1,
+ if( ( ret = mbedtls_x509_get_sig_alg( &crt->sig_oid, &sig_params1,
&crt->sig_md, &crt->sig_pk,
&crt->sig_opts ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -636,16 +636,16 @@
*/
crt->issuer_raw.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
- if( ( ret = x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -660,7 +660,7 @@
if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
&crt->valid_to ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -669,16 +669,16 @@
*/
crt->subject_raw.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
- if( len && ( ret = x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
+ if( len && ( ret = mbedtls_x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -687,9 +687,9 @@
/*
* SubjectPublicKeyInfo
*/
- if( ( ret = pk_parse_subpubkey( &p, end, &crt->pk ) ) != 0 )
+ if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &crt->pk ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -706,7 +706,7 @@
ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
if( ret != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
}
@@ -716,28 +716,28 @@
ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
if( ret != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
}
-#if !defined(POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3)
+#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
if( crt->version == 3 )
#endif
{
ret = x509_get_crt_ext( &p, end, crt );
if( ret != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
}
if( p != end )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
end = crt_end;
@@ -749,9 +749,9 @@
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING
*/
- if( ( ret = x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
@@ -760,21 +760,21 @@
sig_params1.len != sig_params2.len ||
memcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_SIG_MISMATCH );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_SIG_MISMATCH );
}
- if( ( ret = x509_get_sig( &p, end, &crt->sig ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_sig( &p, end, &crt->sig ) ) != 0 )
{
- x509_crt_free( crt );
+ mbedtls_x509_crt_free( crt );
return( ret );
}
if( p != end )
{
- x509_crt_free( crt );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_crt_free( crt );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return( 0 );
@@ -784,17 +784,17 @@
* Parse one X.509 certificate in DER format from a buffer and add them to a
* chained list
*/
-int x509_crt_parse_der( x509_crt *chain, const unsigned char *buf,
+int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain, const unsigned char *buf,
size_t buflen )
{
int ret;
- x509_crt *crt = chain, *prev = NULL;
+ mbedtls_x509_crt *crt = chain, *prev = NULL;
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
while( crt->version != 0 && crt->next != NULL )
{
@@ -807,13 +807,13 @@
*/
if( crt->version != 0 && crt->next == NULL )
{
- crt->next = polarssl_malloc( sizeof( x509_crt ) );
+ crt->next = mbedtls_malloc( sizeof( mbedtls_x509_crt ) );
if( crt->next == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
prev = crt;
- x509_crt_init( crt->next );
+ mbedtls_x509_crt_init( crt->next );
crt = crt->next;
}
@@ -823,7 +823,7 @@
prev->next = NULL;
if( crt != chain )
- polarssl_free( crt );
+ mbedtls_free( crt );
return( ret );
}
@@ -835,41 +835,41 @@
* Parse one or more PEM certificates from a buffer and add them to the chained
* list
*/
-int x509_crt_parse( x509_crt *chain, const unsigned char *buf, size_t buflen )
+int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain, const unsigned char *buf, size_t buflen )
{
int success = 0, first_error = 0, total_failed = 0;
- int buf_format = X509_FORMAT_DER;
+ int buf_format = MBEDTLS_X509_FORMAT_DER;
/*
* Check for valid input
*/
if( chain == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
/*
* Determine buffer content. Buffer contains either one DER certificate or
* one or more PEM certificates.
*/
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
if( strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
- buf_format = X509_FORMAT_PEM;
+ buf_format = MBEDTLS_X509_FORMAT_PEM;
#endif
- if( buf_format == X509_FORMAT_DER )
- return x509_crt_parse_der( chain, buf, buflen );
+ if( buf_format == MBEDTLS_X509_FORMAT_DER )
+ return mbedtls_x509_crt_parse_der( chain, buf, buflen );
-#if defined(POLARSSL_PEM_PARSE_C)
- if( buf_format == X509_FORMAT_PEM )
+#if defined(MBEDTLS_PEM_PARSE_C)
+ if( buf_format == MBEDTLS_X509_FORMAT_PEM )
{
int ret;
- pem_context pem;
+ mbedtls_pem_context pem;
while( buflen > 0 )
{
size_t use_len;
- pem_init( &pem );
+ mbedtls_pem_init( &pem );
- ret = pem_read_buffer( &pem,
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN CERTIFICATE-----",
"-----END CERTIFICATE-----",
buf, NULL, 0, &use_len );
@@ -882,13 +882,13 @@
buflen -= use_len;
buf += use_len;
}
- else if( ret == POLARSSL_ERR_PEM_BAD_INPUT_DATA )
+ else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
{
return( ret );
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
/*
* PEM header and footer were found
@@ -905,16 +905,16 @@
else
break;
- ret = x509_crt_parse_der( chain, pem.buf, pem.buflen );
+ ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
if( ret != 0 )
{
/*
* Quit parsing on a memory error
*/
- if( ret == POLARSSL_ERR_X509_MALLOC_FAILED )
+ if( ret == MBEDTLS_ERR_X509_MALLOC_FAILED )
return( ret );
if( first_error == 0 )
@@ -927,42 +927,42 @@
success = 1;
}
}
-#endif /* POLARSSL_PEM_PARSE_C */
+#endif /* MBEDTLS_PEM_PARSE_C */
if( success )
return( total_failed );
else if( first_error )
return( first_error );
else
- return( POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT );
+ return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* Load one or more certificates and add them to the chained list
*/
-int x509_crt_parse_file( x509_crt *chain, const char *path )
+int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
{
int ret;
size_t n;
unsigned char *buf;
- if( ( ret = pk_load_file( path, &buf, &n ) ) != 0 )
+ if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
- ret = x509_crt_parse( chain, buf, n );
+ ret = mbedtls_x509_crt_parse( chain, buf, n );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
-#if defined(POLARSSL_THREADING_PTHREAD)
-static threading_mutex_t readdir_mutex = PTHREAD_MUTEX_INITIALIZER;
+#if defined(MBEDTLS_THREADING_PTHREAD)
+static mbedtls_threading_mutex_t readdir_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif
-int x509_crt_parse_path( x509_crt *chain, const char *path )
+int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
{
int ret = 0;
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
@@ -976,7 +976,7 @@
HANDLE hFind;
if( len > MAX_PATH - 3 )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
memset( szDir, 0, sizeof(szDir) );
memset( filename, 0, MAX_PATH );
@@ -988,11 +988,11 @@
w_ret = MultiByteToWideChar( CP_ACP, 0, filename, len, szDir,
MAX_PATH - 3 );
if( w_ret == 0 )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
hFind = FindFirstFileW( szDir, &file_data );
if( hFind == INVALID_HANDLE_VALUE )
- return( POLARSSL_ERR_X509_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
len = MAX_PATH - len;
do
@@ -1007,9 +1007,9 @@
p, len - 1,
NULL, NULL );
if( w_ret == 0 )
- return( POLARSSL_ERR_X509_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
- w_ret = x509_crt_parse_file( chain, filename );
+ w_ret = mbedtls_x509_crt_parse_file( chain, filename );
if( w_ret < 0 )
ret++;
else
@@ -1018,7 +1018,7 @@
while( FindNextFileW( hFind, &file_data ) != 0 );
if( GetLastError() != ERROR_NO_MORE_FILES )
- ret = POLARSSL_ERR_X509_FILE_IO_ERROR;
+ ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
FindClose( hFind );
#else /* _WIN32 */
@@ -1029,21 +1029,21 @@
DIR *dir = opendir( path );
if( dir == NULL )
- return( POLARSSL_ERR_X509_FILE_IO_ERROR );
+ return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
-#if defined(POLARSSL_THREADING_PTHREAD)
- if( ( ret = polarssl_mutex_lock( &readdir_mutex ) ) != 0 )
+#if defined(MBEDTLS_THREADING_PTHREAD)
+ if( ( ret = mbedtls_mutex_lock( &readdir_mutex ) ) != 0 )
return( ret );
#endif
while( ( entry = readdir( dir ) ) != NULL )
{
- polarssl_snprintf( entry_name, sizeof entry_name, "%s/%s", path, entry->d_name );
+ mbedtls_snprintf( entry_name, sizeof entry_name, "%s/%s", path, entry->d_name );
if( stat( entry_name, &sb ) == -1 )
{
closedir( dir );
- ret = POLARSSL_ERR_X509_FILE_IO_ERROR;
+ ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
goto cleanup;
}
@@ -1052,7 +1052,7 @@
// Ignore parse errors
//
- t_ret = x509_crt_parse_file( chain, entry_name );
+ t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
if( t_ret < 0 )
ret++;
else
@@ -1061,16 +1061,16 @@
closedir( dir );
cleanup:
-#if defined(POLARSSL_THREADING_PTHREAD)
- if( polarssl_mutex_unlock( &readdir_mutex ) != 0 )
- ret = POLARSSL_ERR_THREADING_MUTEX_ERROR;
+#if defined(MBEDTLS_THREADING_PTHREAD)
+ if( mbedtls_mutex_unlock( &readdir_mutex ) != 0 )
+ ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
#endif
#endif /* _WIN32 */
return( ret );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
!defined(EFI32)
@@ -1108,7 +1108,7 @@
#define snprintf compat_snprintf
#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
-#define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
+#define MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL -2
#define SAFE_SNPRINTF() \
{ \
@@ -1117,7 +1117,7 @@
\
if( (unsigned int) ret > n ) { \
p[n - 1] = '\0'; \
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL ); \
} \
\
n -= (unsigned int) ret; \
@@ -1125,12 +1125,12 @@
}
static int x509_info_subject_alt_name( char **buf, size_t *size,
- const x509_sequence *subject_alt_name )
+ const mbedtls_x509_sequence *subject_alt_name )
{
size_t i;
size_t n = *size;
char *p = *buf;
- const x509_sequence *cur = subject_alt_name;
+ const mbedtls_x509_sequence *cur = subject_alt_name;
const char *sep = "";
size_t sep_len = 0;
@@ -1139,7 +1139,7 @@
if( cur->buf.len + sep_len >= n )
{
*p = '\0';
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL );
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL );
}
n -= cur->buf.len + sep_len;
@@ -1164,7 +1164,7 @@
#define PRINT_ITEM(i) \
{ \
- ret = polarssl_snprintf( p, n, "%s" i, sep ); \
+ ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
SAFE_SNPRINTF(); \
sep = ", "; \
}
@@ -1181,14 +1181,14 @@
char *p = *buf;
const char *sep = "";
- CERT_TYPE( NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
- CERT_TYPE( NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
- CERT_TYPE( NS_CERT_TYPE_EMAIL, "Email" );
- CERT_TYPE( NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
- CERT_TYPE( NS_CERT_TYPE_RESERVED, "Reserved" );
- CERT_TYPE( NS_CERT_TYPE_SSL_CA, "SSL CA" );
- CERT_TYPE( NS_CERT_TYPE_EMAIL_CA, "Email CA" );
- CERT_TYPE( NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
+ CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
+ CERT_TYPE( MBEDTLS_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
+ CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
+ CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
+ CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
+ CERT_TYPE( MBEDTLS_NS_CERT_TYPE_SSL_CA, "SSL CA" );
+ CERT_TYPE( MBEDTLS_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
+ CERT_TYPE( MBEDTLS_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
*size = n;
*buf = p;
@@ -1208,13 +1208,13 @@
char *p = *buf;
const char *sep = "";
- KEY_USAGE( KU_DIGITAL_SIGNATURE, "Digital Signature" );
- KEY_USAGE( KU_NON_REPUDIATION, "Non Repudiation" );
- KEY_USAGE( KU_KEY_ENCIPHERMENT, "Key Encipherment" );
- KEY_USAGE( KU_DATA_ENCIPHERMENT, "Data Encipherment" );
- KEY_USAGE( KU_KEY_AGREEMENT, "Key Agreement" );
- KEY_USAGE( KU_KEY_CERT_SIGN, "Key Cert Sign" );
- KEY_USAGE( KU_CRL_SIGN, "CRL Sign" );
+ KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
+ KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
+ KEY_USAGE( MBEDTLS_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
+ KEY_USAGE( MBEDTLS_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
+ KEY_USAGE( MBEDTLS_KU_KEY_AGREEMENT, "Key Agreement" );
+ KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
+ KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
*size = n;
*buf = p;
@@ -1223,21 +1223,21 @@
}
static int x509_info_ext_key_usage( char **buf, size_t *size,
- const x509_sequence *extended_key_usage )
+ const mbedtls_x509_sequence *extended_key_usage )
{
int ret;
const char *desc;
size_t n = *size;
char *p = *buf;
- const x509_sequence *cur = extended_key_usage;
+ const mbedtls_x509_sequence *cur = extended_key_usage;
const char *sep = "";
while( cur != NULL )
{
- if( oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
+ if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
desc = "???";
- ret = polarssl_snprintf( p, n, "%s%s", sep, desc );
+ ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
SAFE_SNPRINTF();
sep = ", ";
@@ -1256,8 +1256,8 @@
*/
#define BEFORE_COLON 18
#define BC "18"
-int x509_crt_info( char *buf, size_t size, const char *prefix,
- const x509_crt *crt )
+int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
+ const mbedtls_x509_crt *crt )
{
int ret;
size_t n;
@@ -1267,78 +1267,78 @@
p = buf;
n = size;
- ret = polarssl_snprintf( p, n, "%scert. version : %d\n",
+ ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
prefix, crt->version );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "%sserial number : ",
+ ret = mbedtls_snprintf( p, n, "%sserial number : ",
prefix );
SAFE_SNPRINTF();
- ret = x509_serial_gets( p, n, &crt->serial );
+ ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%sissuer name : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
SAFE_SNPRINTF();
- ret = x509_dn_gets( p, n, &crt->issuer );
+ ret = mbedtls_x509_dn_gets( p, n, &crt->issuer );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%ssubject name : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
SAFE_SNPRINTF();
- ret = x509_dn_gets( p, n, &crt->subject );
+ ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%sissued on : " \
+ ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_from.year, crt->valid_from.mon,
crt->valid_from.day, crt->valid_from.hour,
crt->valid_from.min, crt->valid_from.sec );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%sexpires on : " \
+ ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_to.year, crt->valid_to.mon,
crt->valid_to.day, crt->valid_to.hour,
crt->valid_to.min, crt->valid_to.sec );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%ssigned using : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
SAFE_SNPRINTF();
- ret = x509_sig_alg_gets( p, n, &crt->sig_oid, crt->sig_pk,
+ ret = mbedtls_x509_sig_alg_gets( p, n, &crt->sig_oid, crt->sig_pk,
crt->sig_md, crt->sig_opts );
SAFE_SNPRINTF();
/* Key size */
- if( ( ret = x509_key_size_helper( key_size_str, BEFORE_COLON,
- pk_get_name( &crt->pk ) ) ) != 0 )
+ if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
+ mbedtls_pk_get_name( &crt->pk ) ) ) != 0 )
{
return( ret );
}
- ret = polarssl_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
- (int) pk_get_size( &crt->pk ) );
+ ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
+ (int) mbedtls_pk_get_size( &crt->pk ) );
SAFE_SNPRINTF();
/*
* Optional extensions
*/
- if( crt->ext_types & EXT_BASIC_CONSTRAINTS )
+ if( crt->ext_types & MBEDTLS_EXT_BASIC_CONSTRAINTS )
{
- ret = polarssl_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
+ ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
crt->ca_istrue ? "true" : "false" );
SAFE_SNPRINTF();
if( crt->max_pathlen > 0 )
{
- ret = polarssl_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
+ ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
SAFE_SNPRINTF();
}
}
- if( crt->ext_types & EXT_SUBJECT_ALT_NAME )
+ if( crt->ext_types & MBEDTLS_EXT_SUBJECT_ALT_NAME )
{
- ret = polarssl_snprintf( p, n, "\n%ssubject alt name : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
SAFE_SNPRINTF();
if( ( ret = x509_info_subject_alt_name( &p, &n,
@@ -1346,27 +1346,27 @@
return( ret );
}
- if( crt->ext_types & EXT_NS_CERT_TYPE )
+ if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
{
- ret = polarssl_snprintf( p, n, "\n%scert. type : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
SAFE_SNPRINTF();
if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) != 0 )
return( ret );
}
- if( crt->ext_types & EXT_KEY_USAGE )
+ if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
{
- ret = polarssl_snprintf( p, n, "\n%skey usage : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
SAFE_SNPRINTF();
if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) != 0 )
return( ret );
}
- if( crt->ext_types & EXT_EXTENDED_KEY_USAGE )
+ if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
{
- ret = polarssl_snprintf( p, n, "\n%sext key usage : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
SAFE_SNPRINTF();
if( ( ret = x509_info_ext_key_usage( &p, &n,
@@ -1374,32 +1374,32 @@
return( ret );
}
- ret = polarssl_snprintf( p, n, "\n" );
+ ret = mbedtls_snprintf( p, n, "\n" );
SAFE_SNPRINTF();
return( (int) ( size - n ) );
}
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
-int x509_crt_check_key_usage( const x509_crt *crt, unsigned int usage )
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
+int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt, unsigned int usage )
{
- if( ( crt->ext_types & EXT_KEY_USAGE ) != 0 &&
+ if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) != 0 &&
( crt->key_usage & usage ) != usage )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
return( 0 );
}
#endif
-#if defined(POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE)
-int x509_crt_check_extended_key_usage( const x509_crt *crt,
+#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
+int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
const char *usage_oid,
size_t usage_len )
{
- const x509_sequence *cur;
+ const mbedtls_x509_sequence *cur;
/* Extension is not mandatory, absent means no restriction */
- if( ( crt->ext_types & EXT_EXTENDED_KEY_USAGE ) == 0 )
+ if( ( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
return( 0 );
/*
@@ -1407,7 +1407,7 @@
*/
for( cur = &crt->ext_key_usage; cur != NULL; cur = cur->next )
{
- const x509_buf *cur_oid = &cur->buf;
+ const mbedtls_x509_buf *cur_oid = &cur->buf;
if( cur_oid->len == usage_len &&
memcmp( cur_oid->p, usage_oid, usage_len ) == 0 )
@@ -1415,28 +1415,28 @@
return( 0 );
}
- if( OID_CMP( OID_ANY_EXTENDED_KEY_USAGE, cur_oid ) == 0 )
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE, cur_oid ) == 0 )
return( 0 );
}
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
}
-#endif /* POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE */
+#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
-#if defined(POLARSSL_X509_CRL_PARSE_C)
+#if defined(MBEDTLS_X509_CRL_PARSE_C)
/*
* Return 1 if the certificate is revoked, or 0 otherwise.
*/
-int x509_crt_revoked( const x509_crt *crt, const x509_crl *crl )
+int mbedtls_x509_crt_revoked( const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl )
{
- const x509_crl_entry *cur = &crl->entry;
+ const mbedtls_x509_crl_entry *cur = &crl->entry;
while( cur != NULL && cur->serial.len != 0 )
{
if( crt->serial.len == cur->serial.len &&
memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
{
- if( x509_time_expired( &cur->revocation_date ) )
+ if( mbedtls_x509_time_expired( &cur->revocation_date ) )
return( 1 );
}
@@ -1449,12 +1449,12 @@
/*
* Check that the given certificate is valid according to the CRL.
*/
-static int x509_crt_verifycrl( x509_crt *crt, x509_crt *ca,
- x509_crl *crl_list)
+static int x509_crt_verifycrl( mbedtls_x509_crt *crt, mbedtls_x509_crt *ca,
+ mbedtls_x509_crl *crl_list)
{
int flags = 0;
- unsigned char hash[POLARSSL_MD_MAX_SIZE];
- const md_info_t *md_info;
+ unsigned char hash[MBEDTLS_MD_MAX_SIZE];
+ const mbedtls_md_info_t *md_info;
if( ca == NULL )
return( flags );
@@ -1479,10 +1479,10 @@
/*
* Check if the CA is configured to sign CRLs
*/
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
- if( x509_crt_check_key_usage( ca, KU_CRL_SIGN ) != 0 )
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
+ if( mbedtls_x509_crt_check_key_usage( ca, MBEDTLS_X509_KU_CRL_SIGN ) != 0 )
{
- flags |= BADCRL_NOT_TRUSTED;
+ flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
#endif
@@ -1490,41 +1490,41 @@
/*
* Check if CRL is correctly signed by the trusted CA
*/
- md_info = md_info_from_type( crl_list->sig_md );
+ md_info = mbedtls_md_info_from_type( crl_list->sig_md );
if( md_info == NULL )
{
/*
* Cannot check 'unknown' hash
*/
- flags |= BADCRL_NOT_TRUSTED;
+ flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
- md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash );
+ mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash );
- if( pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, &ca->pk,
- crl_list->sig_md, hash, md_get_size( md_info ),
+ if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, &ca->pk,
+ crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
crl_list->sig.p, crl_list->sig.len ) != 0 )
{
- flags |= BADCRL_NOT_TRUSTED;
+ flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
/*
* Check for validity of CRL (Do not drop out)
*/
- if( x509_time_expired( &crl_list->next_update ) )
- flags |= BADCRL_EXPIRED;
+ if( mbedtls_x509_time_expired( &crl_list->next_update ) )
+ flags |= MBEDTLS_X509_BADCRL_EXPIRED;
- if( x509_time_future( &crl_list->this_update ) )
- flags |= BADCRL_FUTURE;
+ if( mbedtls_x509_time_future( &crl_list->this_update ) )
+ flags |= MBEDTLS_BADCRL_FUTURE;
/*
* Check if certificate is revoked
*/
- if( x509_crt_revoked( crt, crl_list ) )
+ if( mbedtls_x509_crt_revoked( crt, crl_list ) )
{
- flags |= BADCERT_REVOKED;
+ flags |= MBEDTLS_X509_BADCERT_REVOKED;
break;
}
@@ -1532,7 +1532,7 @@
}
return( flags );
}
-#endif /* POLARSSL_X509_CRL_PARSE_C */
+#endif /* MBEDTLS_X509_CRL_PARSE_C */
/*
* Like memcmp, but case-insensitive and always returns -1 if different
@@ -1567,7 +1567,7 @@
* Return 1 if match, 0 if not
* TODO: inverted return value!
*/
-static int x509_wildcard_verify( const char *cn, x509_buf *name )
+static int x509_wildcard_verify( const char *cn, mbedtls_x509_buf *name )
{
size_t i;
size_t cn_idx = 0, cn_len = strlen( cn );
@@ -1602,7 +1602,7 @@
*
* Return 0 if equal, -1 otherwise.
*/
-static int x509_string_cmp( const x509_buf *a, const x509_buf *b )
+static int x509_string_cmp( const mbedtls_x509_buf *a, const mbedtls_x509_buf *b )
{
if( a->tag == b->tag &&
a->len == b->len &&
@@ -1611,8 +1611,8 @@
return( 0 );
}
- if( ( a->tag == ASN1_UTF8_STRING || a->tag == ASN1_PRINTABLE_STRING ) &&
- ( b->tag == ASN1_UTF8_STRING || b->tag == ASN1_PRINTABLE_STRING ) &&
+ if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
+ ( b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
a->len == b->len &&
x509_memcasecmp( a->p, b->p, b->len ) == 0 )
{
@@ -1632,7 +1632,7 @@
*
* Return 0 if equal, -1 otherwise.
*/
-static int x509_name_cmp( const x509_name *a, const x509_name *b )
+static int x509_name_cmp( const mbedtls_x509_name *a, const mbedtls_x509_name *b )
{
/* Avoid recursion, it might not be optimised by the compiler */
while( a != NULL || b != NULL )
@@ -1671,8 +1671,8 @@
* top means parent is a locally-trusted certificate
* bottom means child is the end entity cert
*/
-static int x509_crt_check_parent( const x509_crt *child,
- const x509_crt *parent,
+static int x509_crt_check_parent( const mbedtls_x509_crt *child,
+ const mbedtls_x509_crt *parent,
int top, int bottom )
{
int need_ca_bit;
@@ -1699,9 +1699,9 @@
if( need_ca_bit && ! parent->ca_istrue )
return( -1 );
-#if defined(POLARSSL_X509_CHECK_KEY_USAGE)
+#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
if( need_ca_bit &&
- x509_crt_check_key_usage( parent, KU_KEY_CERT_SIGN ) != 0 )
+ mbedtls_x509_crt_check_key_usage( parent, MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
{
return( -1 );
}
@@ -1711,28 +1711,28 @@
}
static int x509_crt_verify_top(
- x509_crt *child, x509_crt *trust_ca,
- x509_crl *ca_crl, int path_cnt, int *flags,
- int (*f_vrfy)(void *, x509_crt *, int, int *),
+ mbedtls_x509_crt *child, mbedtls_x509_crt *trust_ca,
+ mbedtls_x509_crl *ca_crl, int path_cnt, int *flags,
+ int (*f_vrfy)(void *, mbedtls_x509_crt *, int, int *),
void *p_vrfy )
{
int ret;
int ca_flags = 0, check_path_cnt = path_cnt + 1;
- unsigned char hash[POLARSSL_MD_MAX_SIZE];
- const md_info_t *md_info;
+ unsigned char hash[MBEDTLS_MD_MAX_SIZE];
+ const mbedtls_md_info_t *md_info;
- if( x509_time_expired( &child->valid_to ) )
- *flags |= BADCERT_EXPIRED;
+ if( mbedtls_x509_time_expired( &child->valid_to ) )
+ *flags |= MBEDTLS_BADCERT_EXPIRED;
- if( x509_time_future( &child->valid_from ) )
- *flags |= BADCERT_FUTURE;
+ if( mbedtls_x509_time_future( &child->valid_from ) )
+ *flags |= MBEDTLS_X509_BADCERT_FUTURE;
/*
* Child is the top of the chain. Check against the trust_ca list.
*/
- *flags |= BADCERT_NOT_TRUSTED;
+ *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
- md_info = md_info_from_type( child->sig_md );
+ md_info = mbedtls_md_info_from_type( child->sig_md );
if( md_info == NULL )
{
/*
@@ -1741,7 +1741,7 @@
trust_ca = NULL;
}
else
- md( md_info, child->tbs.p, child->tbs.len, hash );
+ mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash );
for( /* trust_ca */ ; trust_ca != NULL; trust_ca = trust_ca->next )
{
@@ -1765,8 +1765,8 @@
continue;
}
- if( pk_verify_ext( child->sig_pk, child->sig_opts, &trust_ca->pk,
- child->sig_md, hash, md_get_size( md_info ),
+ if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &trust_ca->pk,
+ child->sig_md, hash, mbedtls_md_get_size( md_info ),
child->sig.p, child->sig.len ) != 0 )
{
continue;
@@ -1775,7 +1775,7 @@
/*
* Top of chain is signed by a trusted CA
*/
- *flags &= ~BADCERT_NOT_TRUSTED;
+ *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
break;
}
@@ -1789,18 +1789,18 @@
memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
child->issuer_raw.len ) != 0 ) )
{
-#if defined(POLARSSL_X509_CRL_PARSE_C)
+#if defined(MBEDTLS_X509_CRL_PARSE_C)
/* Check trusted CA's CRL for the chain's top crt */
*flags |= x509_crt_verifycrl( child, trust_ca, ca_crl );
#else
((void) ca_crl);
#endif
- if( x509_time_expired( &trust_ca->valid_to ) )
- ca_flags |= BADCERT_EXPIRED;
+ if( mbedtls_x509_time_expired( &trust_ca->valid_to ) )
+ ca_flags |= MBEDTLS_BADCERT_EXPIRED;
- if( x509_time_future( &trust_ca->valid_from ) )
- ca_flags |= BADCERT_FUTURE;
+ if( mbedtls_x509_time_future( &trust_ca->valid_from ) )
+ ca_flags |= MBEDTLS_X509_BADCERT_FUTURE;
if( NULL != f_vrfy )
{
@@ -1825,51 +1825,51 @@
}
static int x509_crt_verify_child(
- x509_crt *child, x509_crt *parent, x509_crt *trust_ca,
- x509_crl *ca_crl, int path_cnt, int *flags,
- int (*f_vrfy)(void *, x509_crt *, int, int *),
+ mbedtls_x509_crt *child, mbedtls_x509_crt *parent, mbedtls_x509_crt *trust_ca,
+ mbedtls_x509_crl *ca_crl, int path_cnt, int *flags,
+ int (*f_vrfy)(void *, mbedtls_x509_crt *, int, int *),
void *p_vrfy )
{
int ret;
int parent_flags = 0;
- unsigned char hash[POLARSSL_MD_MAX_SIZE];
- x509_crt *grandparent;
- const md_info_t *md_info;
+ unsigned char hash[MBEDTLS_MD_MAX_SIZE];
+ mbedtls_x509_crt *grandparent;
+ const mbedtls_md_info_t *md_info;
/* path_cnt is 0 for the first intermediate CA */
- if( 1 + path_cnt > POLARSSL_X509_MAX_INTERMEDIATE_CA )
+ if( 1 + path_cnt > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
{
- *flags |= BADCERT_NOT_TRUSTED;
- return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED );
+ *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
+ return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
}
- if( x509_time_expired( &child->valid_to ) )
- *flags |= BADCERT_EXPIRED;
+ if( mbedtls_x509_time_expired( &child->valid_to ) )
+ *flags |= MBEDTLS_BADCERT_EXPIRED;
- if( x509_time_future( &child->valid_from ) )
- *flags |= BADCERT_FUTURE;
+ if( mbedtls_x509_time_future( &child->valid_from ) )
+ *flags |= MBEDTLS_X509_BADCERT_FUTURE;
- md_info = md_info_from_type( child->sig_md );
+ md_info = mbedtls_md_info_from_type( child->sig_md );
if( md_info == NULL )
{
/*
* Cannot check 'unknown' hash
*/
- *flags |= BADCERT_NOT_TRUSTED;
+ *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
}
else
{
- md( md_info, child->tbs.p, child->tbs.len, hash );
+ mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash );
- if( pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk,
- child->sig_md, hash, md_get_size( md_info ),
+ if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk,
+ child->sig_md, hash, mbedtls_md_get_size( md_info ),
child->sig.p, child->sig.len ) != 0 )
{
- *flags |= BADCERT_NOT_TRUSTED;
+ *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
}
}
-#if defined(POLARSSL_X509_CRL_PARSE_C)
+#if defined(MBEDTLS_X509_CRL_PARSE_C)
/* Check trusted CA's CRL for the given crt */
*flags |= x509_crt_verifycrl(child, parent, ca_crl);
#endif
@@ -1913,19 +1913,19 @@
/*
* Verify the certificate validity
*/
-int x509_crt_verify( x509_crt *crt,
- x509_crt *trust_ca,
- x509_crl *ca_crl,
+int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
+ mbedtls_x509_crt *trust_ca,
+ mbedtls_x509_crl *ca_crl,
const char *cn, int *flags,
- int (*f_vrfy)(void *, x509_crt *, int, int *),
+ int (*f_vrfy)(void *, mbedtls_x509_crt *, int, int *),
void *p_vrfy )
{
size_t cn_len;
int ret;
int pathlen = 0;
- x509_crt *parent;
- x509_name *name;
- x509_sequence *cur = NULL;
+ mbedtls_x509_crt *parent;
+ mbedtls_x509_name *name;
+ mbedtls_x509_sequence *cur = NULL;
*flags = 0;
@@ -1934,7 +1934,7 @@
name = &crt->subject;
cn_len = strlen( cn );
- if( crt->ext_types & EXT_SUBJECT_ALT_NAME )
+ if( crt->ext_types & MBEDTLS_EXT_SUBJECT_ALT_NAME )
{
cur = &crt->subject_alt_names;
@@ -1953,13 +1953,13 @@
}
if( cur == NULL )
- *flags |= BADCERT_CN_MISMATCH;
+ *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
else
{
while( name != NULL )
{
- if( OID_CMP( OID_AT_CN, &name->oid ) == 0 )
+ if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, &name->oid ) == 0 )
{
if( name->val.len == cn_len &&
x509_memcasecmp( name->val.p, cn, cn_len ) == 0 )
@@ -1975,7 +1975,7 @@
}
if( name == NULL )
- *flags |= BADCERT_CN_MISMATCH;
+ *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
}
@@ -2003,7 +2003,7 @@
}
if( *flags != 0 )
- return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED );
+ return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
return( 0 );
}
@@ -2011,32 +2011,32 @@
/*
* Initialize a certificate chain
*/
-void x509_crt_init( x509_crt *crt )
+void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
{
- memset( crt, 0, sizeof(x509_crt) );
+ memset( crt, 0, sizeof(mbedtls_x509_crt) );
}
/*
* Unallocate all certificate data
*/
-void x509_crt_free( x509_crt *crt )
+void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
{
- x509_crt *cert_cur = crt;
- x509_crt *cert_prv;
- x509_name *name_cur;
- x509_name *name_prv;
- x509_sequence *seq_cur;
- x509_sequence *seq_prv;
+ mbedtls_x509_crt *cert_cur = crt;
+ mbedtls_x509_crt *cert_prv;
+ mbedtls_x509_name *name_cur;
+ mbedtls_x509_name *name_prv;
+ mbedtls_x509_sequence *seq_cur;
+ mbedtls_x509_sequence *seq_prv;
if( crt == NULL )
return;
do
{
- pk_free( &cert_cur->pk );
+ mbedtls_pk_free( &cert_cur->pk );
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- polarssl_free( cert_cur->sig_opts );
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ mbedtls_free( cert_cur->sig_opts );
#endif
name_cur = cert_cur->issuer.next;
@@ -2044,8 +2044,8 @@
{
name_prv = name_cur;
name_cur = name_cur->next;
- polarssl_zeroize( name_prv, sizeof( x509_name ) );
- polarssl_free( name_prv );
+ mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
+ mbedtls_free( name_prv );
}
name_cur = cert_cur->subject.next;
@@ -2053,8 +2053,8 @@
{
name_prv = name_cur;
name_cur = name_cur->next;
- polarssl_zeroize( name_prv, sizeof( x509_name ) );
- polarssl_free( name_prv );
+ mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
+ mbedtls_free( name_prv );
}
seq_cur = cert_cur->ext_key_usage.next;
@@ -2062,8 +2062,8 @@
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
- polarssl_zeroize( seq_prv, sizeof( x509_sequence ) );
- polarssl_free( seq_prv );
+ mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
+ mbedtls_free( seq_prv );
}
seq_cur = cert_cur->subject_alt_names.next;
@@ -2071,14 +2071,14 @@
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
- polarssl_zeroize( seq_prv, sizeof( x509_sequence ) );
- polarssl_free( seq_prv );
+ mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
+ mbedtls_free( seq_prv );
}
if( cert_cur->raw.p != NULL )
{
- polarssl_zeroize( cert_cur->raw.p, cert_cur->raw.len );
- polarssl_free( cert_cur->raw.p );
+ mbedtls_zeroize( cert_cur->raw.p, cert_cur->raw.len );
+ mbedtls_free( cert_cur->raw.p );
}
cert_cur = cert_cur->next;
@@ -2091,11 +2091,11 @@
cert_prv = cert_cur;
cert_cur = cert_cur->next;
- polarssl_zeroize( cert_prv, sizeof( x509_crt ) );
+ mbedtls_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
if( cert_prv != crt )
- polarssl_free( cert_prv );
+ mbedtls_free( cert_prv );
}
while( cert_cur != NULL );
}
-#endif /* POLARSSL_X509_CRT_PARSE_C */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
diff --git a/library/x509_csr.c b/library/x509_csr.c
index e62417e..2e5aa3c 100644
--- a/library/x509_csr.c
+++ b/library/x509_csr.c
@@ -30,39 +30,39 @@
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CSR_PARSE_C)
+#if defined(MBEDTLS_X509_CSR_PARSE_C)
#include "mbedtls/x509_csr.h"
#include "mbedtls/oid.h"
#include <string.h>
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
#include "mbedtls/pem.h"
#endif
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
#include <stdio.h>
-#define polarssl_free free
-#define polarssl_malloc malloc
-#define polarssl_snprintf snprintf
+#define mbedtls_free free
+#define mbedtls_malloc malloc
+#define mbedtls_snprintf snprintf
#endif
-#if defined(POLARSSL_FS_IO) || defined(EFIX64) || defined(EFI32)
+#if defined(MBEDTLS_FS_IO) || defined(EFIX64) || defined(EFI32)
#include <stdio.h>
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -75,15 +75,15 @@
{
int ret;
- if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
{
- if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
+ if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
*ver = 0;
return( 0 );
}
- return( POLARSSL_ERR_X509_INVALID_VERSION + ret );
+ return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
}
return( 0 );
@@ -92,31 +92,31 @@
/*
* Parse a CSR in DER format
*/
-int x509_csr_parse_der( x509_csr *csr,
+int mbedtls_x509_csr_parse_der( mbedtls_x509_csr *csr,
const unsigned char *buf, size_t buflen )
{
int ret;
size_t len;
unsigned char *p, *end;
- x509_buf sig_params;
+ mbedtls_x509_buf sig_params;
- memset( &sig_params, 0, sizeof( x509_buf ) );
+ memset( &sig_params, 0, sizeof( mbedtls_x509_buf ) );
/*
* Check for valid input
*/
if( csr == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- x509_csr_init( csr );
+ mbedtls_x509_csr_init( csr );
/*
* first copy the raw DER data
*/
- p = polarssl_malloc( len = buflen );
+ p = mbedtls_malloc( len = buflen );
if( p == NULL )
- return( POLARSSL_ERR_X509_MALLOC_FAILED );
+ return( MBEDTLS_ERR_X509_MALLOC_FAILED );
memcpy( p, buf, buflen );
@@ -131,18 +131,18 @@
* signature BIT STRING
* }
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT );
}
if( len != (size_t) ( end - p ) )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
/*
@@ -150,11 +150,11 @@
*/
csr->cri.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = p + len;
@@ -165,7 +165,7 @@
*/
if( ( ret = x509_csr_get_version( &p, end, &csr->version ) ) != 0 )
{
- x509_csr_free( csr );
+ mbedtls_x509_csr_free( csr );
return( ret );
}
@@ -173,8 +173,8 @@
if( csr->version != 1 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_UNKNOWN_VERSION );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
}
/*
@@ -182,16 +182,16 @@
*/
csr->subject_raw.p = p;
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
- if( ( ret = x509_get_name( &p, p + len, &csr->subject ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_name( &p, p + len, &csr->subject ) ) != 0 )
{
- x509_csr_free( csr );
+ mbedtls_x509_csr_free( csr );
return( ret );
}
@@ -200,20 +200,20 @@
/*
* subjectPKInfo SubjectPublicKeyInfo
*/
- if( ( ret = pk_parse_subpubkey( &p, end, &csr->pk ) ) != 0 )
+ if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &csr->pk ) ) != 0 )
{
- x509_csr_free( csr );
+ mbedtls_x509_csr_free( csr );
return( ret );
}
/*
* attributes [0] Attributes
*/
- if( ( ret = asn1_get_tag( &p, end, &len,
- ASN1_CONSTRUCTED | ASN1_CONTEXT_SPECIFIC ) ) != 0 )
+ if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC ) ) != 0 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT + ret );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
// TODO Parse Attributes / extension requests
@@ -225,31 +225,31 @@
* signatureAlgorithm AlgorithmIdentifier,
* signature BIT STRING
*/
- if( ( ret = x509_get_alg( &p, end, &csr->sig_oid, &sig_params ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_alg( &p, end, &csr->sig_oid, &sig_params ) ) != 0 )
{
- x509_csr_free( csr );
+ mbedtls_x509_csr_free( csr );
return( ret );
}
- if( ( ret = x509_get_sig_alg( &csr->sig_oid, &sig_params,
+ if( ( ret = mbedtls_x509_get_sig_alg( &csr->sig_oid, &sig_params,
&csr->sig_md, &csr->sig_pk,
&csr->sig_opts ) ) != 0 )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG );
}
- if( ( ret = x509_get_sig( &p, end, &csr->sig ) ) != 0 )
+ if( ( ret = mbedtls_x509_get_sig( &p, end, &csr->sig ) ) != 0 )
{
- x509_csr_free( csr );
+ mbedtls_x509_csr_free( csr );
return( ret );
}
if( p != end )
{
- x509_csr_free( csr );
- return( POLARSSL_ERR_X509_INVALID_FORMAT +
- POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
+ mbedtls_x509_csr_free( csr );
+ return( MBEDTLS_ERR_X509_INVALID_FORMAT +
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return( 0 );
@@ -258,23 +258,23 @@
/*
* Parse a CSR, allowing for PEM or raw DER encoding
*/
-int x509_csr_parse( x509_csr *csr, const unsigned char *buf, size_t buflen )
+int mbedtls_x509_csr_parse( mbedtls_x509_csr *csr, const unsigned char *buf, size_t buflen )
{
int ret;
-#if defined(POLARSSL_PEM_PARSE_C)
+#if defined(MBEDTLS_PEM_PARSE_C)
size_t use_len;
- pem_context pem;
+ mbedtls_pem_context pem;
#endif
/*
* Check for valid input
*/
if( csr == NULL || buf == NULL )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
-#if defined(POLARSSL_PEM_PARSE_C)
- pem_init( &pem );
- ret = pem_read_buffer( &pem,
+#if defined(MBEDTLS_PEM_PARSE_C)
+ mbedtls_pem_init( &pem );
+ ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN CERTIFICATE REQUEST-----",
"-----END CERTIFICATE REQUEST-----",
buf, NULL, 0, &use_len );
@@ -284,43 +284,43 @@
/*
* Was PEM encoded, parse the result
*/
- if( ( ret = x509_csr_parse_der( csr, pem.buf, pem.buflen ) ) != 0 )
+ if( ( ret = mbedtls_x509_csr_parse_der( csr, pem.buf, pem.buflen ) ) != 0 )
return( ret );
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( 0 );
}
- else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
+ else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
- pem_free( &pem );
+ mbedtls_pem_free( &pem );
return( ret );
}
else
-#endif /* POLARSSL_PEM_PARSE_C */
- return( x509_csr_parse_der( csr, buf, buflen ) );
+#endif /* MBEDTLS_PEM_PARSE_C */
+ return( mbedtls_x509_csr_parse_der( csr, buf, buflen ) );
}
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
/*
* Load a CSR into the structure
*/
-int x509_csr_parse_file( x509_csr *csr, const char *path )
+int mbedtls_x509_csr_parse_file( mbedtls_x509_csr *csr, const char *path )
{
int ret;
size_t n;
unsigned char *buf;
- if( ( ret = pk_load_file( path, &buf, &n ) ) != 0 )
+ if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
- ret = x509_csr_parse( csr, buf, n );
+ ret = mbedtls_x509_csr_parse( csr, buf, n );
- polarssl_zeroize( buf, n + 1 );
- polarssl_free( buf );
+ mbedtls_zeroize( buf, n + 1 );
+ mbedtls_free( buf );
return( ret );
}
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
!defined(EFI32)
@@ -358,7 +358,7 @@
#define snprintf compat_snprintf
#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
-#define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
+#define MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL -2
#define SAFE_SNPRINTF() \
{ \
@@ -367,7 +367,7 @@
\
if( (unsigned int) ret > n ) { \
p[n - 1] = '\0'; \
- return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL ); \
+ return( MBEDTLS_ERR_DEBUG_BUF_TOO_SMALL ); \
} \
\
n -= (unsigned int) ret; \
@@ -379,8 +379,8 @@
/*
* Return an informational string about the CSR.
*/
-int x509_csr_info( char *buf, size_t size, const char *prefix,
- const x509_csr *csr )
+int mbedtls_x509_csr_info( char *buf, size_t size, const char *prefix,
+ const mbedtls_x509_csr *csr )
{
int ret;
size_t n;
@@ -390,30 +390,30 @@
p = buf;
n = size;
- ret = polarssl_snprintf( p, n, "%sCSR version : %d",
+ ret = mbedtls_snprintf( p, n, "%sCSR version : %d",
prefix, csr->version );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%ssubject name : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
SAFE_SNPRINTF();
- ret = x509_dn_gets( p, n, &csr->subject );
+ ret = mbedtls_x509_dn_gets( p, n, &csr->subject );
SAFE_SNPRINTF();
- ret = polarssl_snprintf( p, n, "\n%ssigned using : ", prefix );
+ ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
SAFE_SNPRINTF();
- ret = x509_sig_alg_gets( p, n, &csr->sig_oid, csr->sig_pk, csr->sig_md,
+ ret = mbedtls_x509_sig_alg_gets( p, n, &csr->sig_oid, csr->sig_pk, csr->sig_md,
csr->sig_opts );
SAFE_SNPRINTF();
- if( ( ret = x509_key_size_helper( key_size_str, BEFORE_COLON,
- pk_get_name( &csr->pk ) ) ) != 0 )
+ if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
+ mbedtls_pk_get_name( &csr->pk ) ) ) != 0 )
{
return( ret );
}
- ret = polarssl_snprintf( p, n, "\n%s%-" BC "s: %d bits\n", prefix, key_size_str,
- (int) pk_get_size( &csr->pk ) );
+ ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits\n", prefix, key_size_str,
+ (int) mbedtls_pk_get_size( &csr->pk ) );
SAFE_SNPRINTF();
return( (int) ( size - n ) );
@@ -422,26 +422,26 @@
/*
* Initialize a CSR
*/
-void x509_csr_init( x509_csr *csr )
+void mbedtls_x509_csr_init( mbedtls_x509_csr *csr )
{
- memset( csr, 0, sizeof(x509_csr) );
+ memset( csr, 0, sizeof(mbedtls_x509_csr) );
}
/*
* Unallocate all CSR data
*/
-void x509_csr_free( x509_csr *csr )
+void mbedtls_x509_csr_free( mbedtls_x509_csr *csr )
{
- x509_name *name_cur;
- x509_name *name_prv;
+ mbedtls_x509_name *name_cur;
+ mbedtls_x509_name *name_prv;
if( csr == NULL )
return;
- pk_free( &csr->pk );
+ mbedtls_pk_free( &csr->pk );
-#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
- polarssl_free( csr->sig_opts );
+#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
+ mbedtls_free( csr->sig_opts );
#endif
name_cur = csr->subject.next;
@@ -449,17 +449,17 @@
{
name_prv = name_cur;
name_cur = name_cur->next;
- polarssl_zeroize( name_prv, sizeof( x509_name ) );
- polarssl_free( name_prv );
+ mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
+ mbedtls_free( name_prv );
}
if( csr->raw.p != NULL )
{
- polarssl_zeroize( csr->raw.p, csr->raw.len );
- polarssl_free( csr->raw.p );
+ mbedtls_zeroize( csr->raw.p, csr->raw.len );
+ mbedtls_free( csr->raw.p );
}
- polarssl_zeroize( csr, sizeof( x509_csr ) );
+ mbedtls_zeroize( csr, sizeof( mbedtls_x509_csr ) );
}
-#endif /* POLARSSL_X509_CSR_PARSE_C */
+#endif /* MBEDTLS_X509_CSR_PARSE_C */
diff --git a/library/x509write_crt.c b/library/x509write_crt.c
index 89a2988..e8bb709 100644
--- a/library/x509write_crt.c
+++ b/library/x509write_crt.c
@@ -26,13 +26,13 @@
* - attributes: PKCS#9 v2.0 aka RFC 2985
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CRT_WRITE_C)
+#if defined(MBEDTLS_X509_CRT_WRITE_C)
#include "mbedtls/x509_crt.h"
#include "mbedtls/oid.h"
@@ -41,102 +41,102 @@
#include <string.h>
-#if defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
-#endif /* POLARSSL_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_WRITE_C */
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-void x509write_crt_init( x509write_cert *ctx )
+void mbedtls_x509write_crt_init( mbedtls_x509write_cert *ctx )
{
- memset( ctx, 0, sizeof(x509write_cert) );
+ memset( ctx, 0, sizeof(mbedtls_x509write_cert) );
- mpi_init( &ctx->serial );
- ctx->version = X509_CRT_VERSION_3;
+ mbedtls_mpi_init( &ctx->serial );
+ ctx->version = MBEDTLS_X509_CRT_VERSION_3;
}
-void x509write_crt_free( x509write_cert *ctx )
+void mbedtls_x509write_crt_free( mbedtls_x509write_cert *ctx )
{
- mpi_free( &ctx->serial );
+ mbedtls_mpi_free( &ctx->serial );
- asn1_free_named_data_list( &ctx->subject );
- asn1_free_named_data_list( &ctx->issuer );
- asn1_free_named_data_list( &ctx->extensions );
+ mbedtls_asn1_free_named_data_list( &ctx->subject );
+ mbedtls_asn1_free_named_data_list( &ctx->issuer );
+ mbedtls_asn1_free_named_data_list( &ctx->extensions );
- polarssl_zeroize( ctx, sizeof(x509write_cert) );
+ mbedtls_zeroize( ctx, sizeof(mbedtls_x509write_cert) );
}
-void x509write_crt_set_version( x509write_cert *ctx, int version )
+void mbedtls_x509write_crt_set_version( mbedtls_x509write_cert *ctx, int version )
{
ctx->version = version;
}
-void x509write_crt_set_md_alg( x509write_cert *ctx, md_type_t md_alg )
+void mbedtls_x509write_crt_set_md_alg( mbedtls_x509write_cert *ctx, mbedtls_md_type_t md_alg )
{
ctx->md_alg = md_alg;
}
-void x509write_crt_set_subject_key( x509write_cert *ctx, pk_context *key )
+void mbedtls_x509write_crt_set_subject_key( mbedtls_x509write_cert *ctx, mbedtls_pk_context *key )
{
ctx->subject_key = key;
}
-void x509write_crt_set_issuer_key( x509write_cert *ctx, pk_context *key )
+void mbedtls_x509write_crt_set_issuer_key( mbedtls_x509write_cert *ctx, mbedtls_pk_context *key )
{
ctx->issuer_key = key;
}
-int x509write_crt_set_subject_name( x509write_cert *ctx,
+int mbedtls_x509write_crt_set_subject_name( mbedtls_x509write_cert *ctx,
const char *subject_name )
{
- return x509_string_to_names( &ctx->subject, subject_name );
+ return mbedtls_x509_string_to_names( &ctx->subject, subject_name );
}
-int x509write_crt_set_issuer_name( x509write_cert *ctx,
+int mbedtls_x509write_crt_set_issuer_name( mbedtls_x509write_cert *ctx,
const char *issuer_name )
{
- return x509_string_to_names( &ctx->issuer, issuer_name );
+ return mbedtls_x509_string_to_names( &ctx->issuer, issuer_name );
}
-int x509write_crt_set_serial( x509write_cert *ctx, const mpi *serial )
+int mbedtls_x509write_crt_set_serial( mbedtls_x509write_cert *ctx, const mbedtls_mpi *serial )
{
int ret;
- if( ( ret = mpi_copy( &ctx->serial, serial ) ) != 0 )
+ if( ( ret = mbedtls_mpi_copy( &ctx->serial, serial ) ) != 0 )
return( ret );
return( 0 );
}
-int x509write_crt_set_validity( x509write_cert *ctx, const char *not_before,
+int mbedtls_x509write_crt_set_validity( mbedtls_x509write_cert *ctx, const char *not_before,
const char *not_after )
{
- if( strlen( not_before ) != X509_RFC5280_UTC_TIME_LEN - 1 ||
- strlen( not_after ) != X509_RFC5280_UTC_TIME_LEN - 1 )
+ if( strlen( not_before ) != MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1 ||
+ strlen( not_after ) != MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1 )
{
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
}
- strncpy( ctx->not_before, not_before, X509_RFC5280_UTC_TIME_LEN );
- strncpy( ctx->not_after , not_after , X509_RFC5280_UTC_TIME_LEN );
- ctx->not_before[X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
- ctx->not_after[X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
+ strncpy( ctx->not_before, not_before, MBEDTLS_X509_RFC5280_UTC_TIME_LEN );
+ strncpy( ctx->not_after , not_after , MBEDTLS_X509_RFC5280_UTC_TIME_LEN );
+ ctx->not_before[MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
+ ctx->not_after[MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
return( 0 );
}
-int x509write_crt_set_extension( x509write_cert *ctx,
+int mbedtls_x509write_crt_set_extension( mbedtls_x509write_cert *ctx,
const char *oid, size_t oid_len,
int critical,
const unsigned char *val, size_t val_len )
{
- return x509_set_extension( &ctx->extensions, oid, oid_len,
+ return mbedtls_x509_set_extension( &ctx->extensions, oid, oid_len,
critical, val, val_len );
}
-int x509write_crt_set_basic_constraints( x509write_cert *ctx,
+int mbedtls_x509write_crt_set_basic_constraints( mbedtls_x509write_cert *ctx,
int is_ca, int max_pathlen )
{
int ret;
@@ -147,77 +147,77 @@
memset( buf, 0, sizeof(buf) );
if( is_ca && max_pathlen > 127 )
- return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
+ return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
if( is_ca )
{
if( max_pathlen >= 0 )
{
- ASN1_CHK_ADD( len, asn1_write_int( &c, buf, max_pathlen ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, max_pathlen ) );
}
- ASN1_CHK_ADD( len, asn1_write_bool( &c, buf, 1 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_bool( &c, buf, 1 ) );
}
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
- return x509write_crt_set_extension( ctx, OID_BASIC_CONSTRAINTS,
- OID_SIZE( OID_BASIC_CONSTRAINTS ),
+ return mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_BASIC_CONSTRAINTS,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_BASIC_CONSTRAINTS ),
0, buf + sizeof(buf) - len, len );
}
-#if defined(POLARSSL_SHA1_C)
-int x509write_crt_set_subject_key_identifier( x509write_cert *ctx )
+#if defined(MBEDTLS_SHA1_C)
+int mbedtls_x509write_crt_set_subject_key_identifier( mbedtls_x509write_cert *ctx )
{
int ret;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
unsigned char *c = buf + sizeof(buf);
size_t len = 0;
memset( buf, 0, sizeof(buf) );
- ASN1_CHK_ADD( len, pk_write_pubkey( &c, buf, ctx->subject_key ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_pk_write_pubkey( &c, buf, ctx->subject_key ) );
- sha1( buf + sizeof(buf) - len, len, buf + sizeof(buf) - 20 );
+ mbedtls_sha1( buf + sizeof(buf) - len, len, buf + sizeof(buf) - 20 );
c = buf + sizeof(buf) - 20;
len = 20;
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_OCTET_STRING ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_OCTET_STRING ) );
- return x509write_crt_set_extension( ctx, OID_SUBJECT_KEY_IDENTIFIER,
- OID_SIZE( OID_SUBJECT_KEY_IDENTIFIER ),
+ return mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_SUBJECT_KEY_IDENTIFIER,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_SUBJECT_KEY_IDENTIFIER ),
0, buf + sizeof(buf) - len, len );
}
-int x509write_crt_set_authority_key_identifier( x509write_cert *ctx )
+int mbedtls_x509write_crt_set_authority_key_identifier( mbedtls_x509write_cert *ctx )
{
int ret;
- unsigned char buf[POLARSSL_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
+ unsigned char buf[MBEDTLS_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
unsigned char *c = buf + sizeof(buf);
size_t len = 0;
memset( buf, 0, sizeof(buf) );
- ASN1_CHK_ADD( len, pk_write_pubkey( &c, buf, ctx->issuer_key ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_pk_write_pubkey( &c, buf, ctx->issuer_key ) );
- sha1( buf + sizeof(buf) - len, len, buf + sizeof(buf) - 20 );
+ mbedtls_sha1( buf + sizeof(buf) - len, len, buf + sizeof(buf) - 20 );
c = buf + sizeof(buf) - 20;
len = 20;
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONTEXT_SPECIFIC | 0 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONTEXT_SPECIFIC | 0 ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
- return x509write_crt_set_extension( ctx, OID_AUTHORITY_KEY_IDENTIFIER,
- OID_SIZE( OID_AUTHORITY_KEY_IDENTIFIER ),
+ return mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_AUTHORITY_KEY_IDENTIFIER,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_AUTHORITY_KEY_IDENTIFIER ),
0, buf + sizeof(buf) - len, len );
}
-#endif /* POLARSSL_SHA1_C */
+#endif /* MBEDTLS_SHA1_C */
-int x509write_crt_set_key_usage( x509write_cert *ctx, unsigned char key_usage )
+int mbedtls_x509write_crt_set_key_usage( mbedtls_x509write_cert *ctx, unsigned char key_usage )
{
unsigned char buf[4];
unsigned char *c;
@@ -225,11 +225,11 @@
c = buf + 4;
- if( ( ret = asn1_write_bitstring( &c, buf, &key_usage, 7 ) ) != 4 )
+ if( ( ret = mbedtls_asn1_write_bitstring( &c, buf, &key_usage, 7 ) ) != 4 )
return( ret );
- ret = x509write_crt_set_extension( ctx, OID_KEY_USAGE,
- OID_SIZE( OID_KEY_USAGE ),
+ ret = mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_KEY_USAGE,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_KEY_USAGE ),
1, buf, 4 );
if( ret != 0 )
return( ret );
@@ -237,7 +237,7 @@
return( 0 );
}
-int x509write_crt_set_ns_cert_type( x509write_cert *ctx,
+int mbedtls_x509write_crt_set_ns_cert_type( mbedtls_x509write_cert *ctx,
unsigned char ns_cert_type )
{
unsigned char buf[4];
@@ -246,11 +246,11 @@
c = buf + 4;
- if( ( ret = asn1_write_bitstring( &c, buf, &ns_cert_type, 8 ) ) != 4 )
+ if( ( ret = mbedtls_asn1_write_bitstring( &c, buf, &ns_cert_type, 8 ) ) != 4 )
return( ret );
- ret = x509write_crt_set_extension( ctx, OID_NS_CERT_TYPE,
- OID_SIZE( OID_NS_CERT_TYPE ),
+ ret = mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_NS_CERT_TYPE,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_NS_CERT_TYPE ),
0, buf, 4 );
if( ret != 0 )
return( ret );
@@ -265,29 +265,29 @@
size_t len = 0;
/*
- * write ASN1_UTC_TIME if year < 2050 (2 bytes shorter)
+ * write MBEDTLS_ASN1_UTC_TIME if year < 2050 (2 bytes shorter)
*/
if( time[0] == '2' && time[1] == '0' && time [2] < '5' )
{
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) time + 2,
size - 2 ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_UTC_TIME ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_UTC_TIME ) );
}
else
{
- ASN1_CHK_ADD( len, asn1_write_raw_buffer( p, start,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) time,
size ) );
- ASN1_CHK_ADD( len, asn1_write_len( p, start, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( p, start, ASN1_GENERALIZED_TIME ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_GENERALIZED_TIME ) );
}
return( (int) len );
}
-int x509write_crt_der( x509write_cert *ctx, unsigned char *buf, size_t size,
+int mbedtls_x509write_crt_der( mbedtls_x509write_cert *ctx, unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -296,11 +296,11 @@
size_t sig_oid_len = 0;
unsigned char *c, *c2;
unsigned char hash[64];
- unsigned char sig[POLARSSL_MPI_MAX_SIZE];
+ unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
unsigned char tmp_buf[2048];
size_t sub_len = 0, pub_len = 0, sig_and_oid_len = 0, sig_len;
size_t len = 0;
- pk_type_t pk_alg;
+ mbedtls_pk_type_t pk_alg;
/*
* Prepare data to be signed in tmp_buf
@@ -308,11 +308,11 @@
c = tmp_buf + sizeof( tmp_buf );
/* Signature algorithm needed in TBS, and later for actual signature */
- pk_alg = pk_get_type( ctx->issuer_key );
- if( pk_alg == POLARSSL_PK_ECKEY )
- pk_alg = POLARSSL_PK_ECDSA;
+ pk_alg = mbedtls_pk_get_type( ctx->issuer_key );
+ if( pk_alg == MBEDTLS_PK_ECKEY )
+ pk_alg = MBEDTLS_PK_ECDSA;
- if( ( ret = oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg,
+ if( ( ret = mbedtls_oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg,
&sig_oid, &sig_oid_len ) ) != 0 )
{
return( ret );
@@ -321,18 +321,18 @@
/*
* Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
*/
- ASN1_CHK_ADD( len, x509_write_extensions( &c, tmp_buf, ctx->extensions ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONTEXT_SPECIFIC |
- ASN1_CONSTRUCTED | 3 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_extensions( &c, tmp_buf, ctx->extensions ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONTEXT_SPECIFIC |
+ MBEDTLS_ASN1_CONSTRUCTED | 3 ) );
/*
* SubjectPublicKeyInfo
*/
- ASN1_CHK_ADD( pub_len, pk_write_pubkey_der( ctx->subject_key,
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_pk_write_pubkey_der( ctx->subject_key,
tmp_buf, c - tmp_buf ) );
c -= pub_len;
len += pub_len;
@@ -340,7 +340,7 @@
/*
* Subject ::= Name
*/
- ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->subject ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_names( &c, tmp_buf, ctx->subject ) );
/*
* Validity ::= SEQUENCE {
@@ -349,53 +349,53 @@
*/
sub_len = 0;
- ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_after,
- X509_RFC5280_UTC_TIME_LEN ) );
+ MBEDTLS_ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_after,
+ MBEDTLS_X509_RFC5280_UTC_TIME_LEN ) );
- ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_before,
- X509_RFC5280_UTC_TIME_LEN ) );
+ MBEDTLS_ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_before,
+ MBEDTLS_X509_RFC5280_UTC_TIME_LEN ) );
len += sub_len;
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, sub_len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, sub_len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
/*
* Issuer ::= Name
*/
- ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->issuer ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_names( &c, tmp_buf, ctx->issuer ) );
/*
* Signature ::= AlgorithmIdentifier
*/
- ASN1_CHK_ADD( len, asn1_write_algorithm_identifier( &c, tmp_buf,
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_algorithm_identifier( &c, tmp_buf,
sig_oid, strlen( sig_oid ), 0 ) );
/*
* Serial ::= INTEGER
*/
- ASN1_CHK_ADD( len, asn1_write_mpi( &c, tmp_buf, &ctx->serial ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, tmp_buf, &ctx->serial ) );
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
sub_len = 0;
- ASN1_CHK_ADD( sub_len, asn1_write_int( &c, tmp_buf, ctx->version ) );
+ MBEDTLS_ASN1_CHK_ADD( sub_len, mbedtls_asn1_write_int( &c, tmp_buf, ctx->version ) );
len += sub_len;
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, sub_len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONTEXT_SPECIFIC |
- ASN1_CONSTRUCTED | 0 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, sub_len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONTEXT_SPECIFIC |
+ MBEDTLS_ASN1_CONSTRUCTED | 0 ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
/*
* Make signature
*/
- md( md_info_from_type( ctx->md_alg ), c, len, hash );
+ mbedtls_md( mbedtls_md_info_from_type( ctx->md_alg ), c, len, hash );
- if( ( ret = pk_sign( ctx->issuer_key, ctx->md_alg, hash, 0, sig, &sig_len,
+ if( ( ret = mbedtls_pk_sign( ctx->issuer_key, ctx->md_alg, hash, 0, sig, &sig_len,
f_rng, p_rng ) ) != 0 )
{
return( ret );
@@ -405,16 +405,16 @@
* Write data to output buffer
*/
c2 = buf + size;
- ASN1_CHK_ADD( sig_and_oid_len, x509_write_sig( &c2, buf,
+ MBEDTLS_ASN1_CHK_ADD( sig_and_oid_len, mbedtls_x509_write_sig( &c2, buf,
sig_oid, sig_oid_len, sig, sig_len ) );
c2 -= len;
memcpy( c2, c, len );
len += sig_and_oid_len;
- ASN1_CHK_ADD( len, asn1_write_len( &c2, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c2, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c2, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c2, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
@@ -422,8 +422,8 @@
#define PEM_BEGIN_CRT "-----BEGIN CERTIFICATE-----\n"
#define PEM_END_CRT "-----END CERTIFICATE-----\n"
-#if defined(POLARSSL_PEM_WRITE_C)
-int x509write_crt_pem( x509write_cert *crt, unsigned char *buf, size_t size,
+#if defined(MBEDTLS_PEM_WRITE_C)
+int mbedtls_x509write_crt_pem( mbedtls_x509write_cert *crt, unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -431,13 +431,13 @@
unsigned char output_buf[4096];
size_t olen = 0;
- if( ( ret = x509write_crt_der( crt, output_buf, sizeof(output_buf),
+ if( ( ret = mbedtls_x509write_crt_der( crt, output_buf, sizeof(output_buf),
f_rng, p_rng ) ) < 0 )
{
return( ret );
}
- if( ( ret = pem_write_buffer( PEM_BEGIN_CRT, PEM_END_CRT,
+ if( ( ret = mbedtls_pem_write_buffer( PEM_BEGIN_CRT, PEM_END_CRT,
output_buf + sizeof(output_buf) - ret,
ret, buf, size, &olen ) ) != 0 )
{
@@ -446,6 +446,6 @@
return( 0 );
}
-#endif /* POLARSSL_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_WRITE_C */
-#endif /* POLARSSL_X509_CRT_WRITE_C */
+#endif /* MBEDTLS_X509_CRT_WRITE_C */
diff --git a/library/x509write_csr.c b/library/x509write_csr.c
index 6c112e6..4095ba1 100644
--- a/library/x509write_csr.c
+++ b/library/x509write_csr.c
@@ -25,13 +25,13 @@
* - attributes: PKCS#9 v2.0 aka RFC 2985
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_X509_CSR_WRITE_C)
+#if defined(MBEDTLS_X509_CSR_WRITE_C)
#include "mbedtls/x509_csr.h"
#include "mbedtls/oid.h"
@@ -40,53 +40,53 @@
#include <string.h>
#include <stdlib.h>
-#if defined(POLARSSL_PEM_WRITE_C)
+#if defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
#endif
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
-void x509write_csr_init( x509write_csr *ctx )
+void mbedtls_x509write_csr_init( mbedtls_x509write_csr *ctx )
{
- memset( ctx, 0, sizeof(x509write_csr) );
+ memset( ctx, 0, sizeof(mbedtls_x509write_csr) );
}
-void x509write_csr_free( x509write_csr *ctx )
+void mbedtls_x509write_csr_free( mbedtls_x509write_csr *ctx )
{
- asn1_free_named_data_list( &ctx->subject );
- asn1_free_named_data_list( &ctx->extensions );
+ mbedtls_asn1_free_named_data_list( &ctx->subject );
+ mbedtls_asn1_free_named_data_list( &ctx->extensions );
- polarssl_zeroize( ctx, sizeof(x509write_csr) );
+ mbedtls_zeroize( ctx, sizeof(mbedtls_x509write_csr) );
}
-void x509write_csr_set_md_alg( x509write_csr *ctx, md_type_t md_alg )
+void mbedtls_x509write_csr_set_md_alg( mbedtls_x509write_csr *ctx, mbedtls_md_type_t md_alg )
{
ctx->md_alg = md_alg;
}
-void x509write_csr_set_key( x509write_csr *ctx, pk_context *key )
+void mbedtls_x509write_csr_set_key( mbedtls_x509write_csr *ctx, mbedtls_pk_context *key )
{
ctx->key = key;
}
-int x509write_csr_set_subject_name( x509write_csr *ctx,
+int mbedtls_x509write_csr_set_subject_name( mbedtls_x509write_csr *ctx,
const char *subject_name )
{
- return x509_string_to_names( &ctx->subject, subject_name );
+ return mbedtls_x509_string_to_names( &ctx->subject, subject_name );
}
-int x509write_csr_set_extension( x509write_csr *ctx,
+int mbedtls_x509write_csr_set_extension( mbedtls_x509write_csr *ctx,
const char *oid, size_t oid_len,
const unsigned char *val, size_t val_len )
{
- return x509_set_extension( &ctx->extensions, oid, oid_len,
+ return mbedtls_x509_set_extension( &ctx->extensions, oid, oid_len,
0, val, val_len );
}
-int x509write_csr_set_key_usage( x509write_csr *ctx, unsigned char key_usage )
+int mbedtls_x509write_csr_set_key_usage( mbedtls_x509write_csr *ctx, unsigned char key_usage )
{
unsigned char buf[4];
unsigned char *c;
@@ -94,11 +94,11 @@
c = buf + 4;
- if( ( ret = asn1_write_bitstring( &c, buf, &key_usage, 7 ) ) != 4 )
+ if( ( ret = mbedtls_asn1_write_bitstring( &c, buf, &key_usage, 7 ) ) != 4 )
return( ret );
- ret = x509write_csr_set_extension( ctx, OID_KEY_USAGE,
- OID_SIZE( OID_KEY_USAGE ),
+ ret = mbedtls_x509write_csr_set_extension( ctx, MBEDTLS_OID_KEY_USAGE,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_KEY_USAGE ),
buf, 4 );
if( ret != 0 )
return( ret );
@@ -106,7 +106,7 @@
return( 0 );
}
-int x509write_csr_set_ns_cert_type( x509write_csr *ctx,
+int mbedtls_x509write_csr_set_ns_cert_type( mbedtls_x509write_csr *ctx,
unsigned char ns_cert_type )
{
unsigned char buf[4];
@@ -115,11 +115,11 @@
c = buf + 4;
- if( ( ret = asn1_write_bitstring( &c, buf, &ns_cert_type, 8 ) ) != 4 )
+ if( ( ret = mbedtls_asn1_write_bitstring( &c, buf, &ns_cert_type, 8 ) ) != 4 )
return( ret );
- ret = x509write_csr_set_extension( ctx, OID_NS_CERT_TYPE,
- OID_SIZE( OID_NS_CERT_TYPE ),
+ ret = mbedtls_x509write_csr_set_extension( ctx, MBEDTLS_OID_NS_CERT_TYPE,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_NS_CERT_TYPE ),
buf, 4 );
if( ret != 0 )
return( ret );
@@ -127,7 +127,7 @@
return( 0 );
}
-int x509write_csr_der( x509write_csr *ctx, unsigned char *buf, size_t size,
+int mbedtls_x509write_csr_der( mbedtls_x509write_csr *ctx, unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -136,42 +136,42 @@
size_t sig_oid_len = 0;
unsigned char *c, *c2;
unsigned char hash[64];
- unsigned char sig[POLARSSL_MPI_MAX_SIZE];
+ unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
unsigned char tmp_buf[2048];
size_t pub_len = 0, sig_and_oid_len = 0, sig_len;
size_t len = 0;
- pk_type_t pk_alg;
+ mbedtls_pk_type_t pk_alg;
/*
* Prepare data to be signed in tmp_buf
*/
c = tmp_buf + sizeof( tmp_buf );
- ASN1_CHK_ADD( len, x509_write_extensions( &c, tmp_buf, ctx->extensions ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_extensions( &c, tmp_buf, ctx->extensions ) );
if( len )
{
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SET ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SET ) );
- ASN1_CHK_ADD( len, asn1_write_oid( &c, tmp_buf, OID_PKCS9_CSR_EXT_REQ,
- OID_SIZE( OID_PKCS9_CSR_EXT_REQ ) ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( &c, tmp_buf, MBEDTLS_OID_PKCS9_CSR_EXT_REQ,
+ MBEDTLS_OID_SIZE( MBEDTLS_OID_PKCS9_CSR_EXT_REQ ) ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
}
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_CONTEXT_SPECIFIC ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_CONTEXT_SPECIFIC ) );
- ASN1_CHK_ADD( pub_len, pk_write_pubkey_der( ctx->key,
+ MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_pk_write_pubkey_der( ctx->key,
tmp_buf, c - tmp_buf ) );
c -= pub_len;
len += pub_len;
@@ -179,29 +179,29 @@
/*
* Subject ::= Name
*/
- ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->subject ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_names( &c, tmp_buf, ctx->subject ) );
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
- ASN1_CHK_ADD( len, asn1_write_int( &c, tmp_buf, 0 ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, tmp_buf, 0 ) );
- ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, tmp_buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, tmp_buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
/*
* Prepare signature
*/
- md( md_info_from_type( ctx->md_alg ), c, len, hash );
+ mbedtls_md( mbedtls_md_info_from_type( ctx->md_alg ), c, len, hash );
- pk_alg = pk_get_type( ctx->key );
- if( pk_alg == POLARSSL_PK_ECKEY )
- pk_alg = POLARSSL_PK_ECDSA;
+ pk_alg = mbedtls_pk_get_type( ctx->key );
+ if( pk_alg == MBEDTLS_PK_ECKEY )
+ pk_alg = MBEDTLS_PK_ECDSA;
- if( ( ret = pk_sign( ctx->key, ctx->md_alg, hash, 0, sig, &sig_len,
+ if( ( ret = mbedtls_pk_sign( ctx->key, ctx->md_alg, hash, 0, sig, &sig_len,
f_rng, p_rng ) ) != 0 ||
- ( ret = oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg,
+ ( ret = mbedtls_oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg,
&sig_oid, &sig_oid_len ) ) != 0 )
{
return( ret );
@@ -211,16 +211,16 @@
* Write data to output buffer
*/
c2 = buf + size;
- ASN1_CHK_ADD( sig_and_oid_len, x509_write_sig( &c2, buf,
+ MBEDTLS_ASN1_CHK_ADD( sig_and_oid_len, mbedtls_x509_write_sig( &c2, buf,
sig_oid, sig_oid_len, sig, sig_len ) );
c2 -= len;
memcpy( c2, c, len );
len += sig_and_oid_len;
- ASN1_CHK_ADD( len, asn1_write_len( &c2, buf, len ) );
- ASN1_CHK_ADD( len, asn1_write_tag( &c2, buf, ASN1_CONSTRUCTED |
- ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c2, buf, len ) );
+ MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c2, buf, MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
@@ -228,8 +228,8 @@
#define PEM_BEGIN_CSR "-----BEGIN CERTIFICATE REQUEST-----\n"
#define PEM_END_CSR "-----END CERTIFICATE REQUEST-----\n"
-#if defined(POLARSSL_PEM_WRITE_C)
-int x509write_csr_pem( x509write_csr *ctx, unsigned char *buf, size_t size,
+#if defined(MBEDTLS_PEM_WRITE_C)
+int mbedtls_x509write_csr_pem( mbedtls_x509write_csr *ctx, unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
@@ -237,13 +237,13 @@
unsigned char output_buf[4096];
size_t olen = 0;
- if( ( ret = x509write_csr_der( ctx, output_buf, sizeof(output_buf),
+ if( ( ret = mbedtls_x509write_csr_der( ctx, output_buf, sizeof(output_buf),
f_rng, p_rng ) ) < 0 )
{
return( ret );
}
- if( ( ret = pem_write_buffer( PEM_BEGIN_CSR, PEM_END_CSR,
+ if( ( ret = mbedtls_pem_write_buffer( PEM_BEGIN_CSR, PEM_END_CSR,
output_buf + sizeof(output_buf) - ret,
ret, buf, size, &olen ) ) != 0 )
{
@@ -252,6 +252,6 @@
return( 0 );
}
-#endif /* POLARSSL_PEM_WRITE_C */
+#endif /* MBEDTLS_PEM_WRITE_C */
-#endif /* POLARSSL_X509_CSR_WRITE_C */
+#endif /* MBEDTLS_X509_CSR_WRITE_C */
diff --git a/library/xtea.c b/library/xtea.c
index 8fac8c1..c44892e 100644
--- a/library/xtea.c
+++ b/library/xtea.c
@@ -20,31 +20,31 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
#endif
-#if defined(POLARSSL_XTEA_C)
+#if defined(MBEDTLS_XTEA_C)
#include "mbedtls/xtea.h"
#include <string.h>
-#if defined(POLARSSL_SELF_TEST)
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
-#define polarssl_printf printf
-#endif /* POLARSSL_PLATFORM_C */
-#endif /* POLARSSL_SELF_TEST */
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
-#if !defined(POLARSSL_XTEA_ALT)
+#if !defined(MBEDTLS_XTEA_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
volatile unsigned char *p = v; while( n-- ) *p++ = 0;
}
@@ -71,27 +71,27 @@
}
#endif
-void xtea_init( xtea_context *ctx )
+void mbedtls_xtea_init( mbedtls_xtea_context *ctx )
{
- memset( ctx, 0, sizeof( xtea_context ) );
+ memset( ctx, 0, sizeof( mbedtls_xtea_context ) );
}
-void xtea_free( xtea_context *ctx )
+void mbedtls_xtea_free( mbedtls_xtea_context *ctx )
{
if( ctx == NULL )
return;
- polarssl_zeroize( ctx, sizeof( xtea_context ) );
+ mbedtls_zeroize( ctx, sizeof( mbedtls_xtea_context ) );
}
/*
* XTEA key schedule
*/
-void xtea_setup( xtea_context *ctx, const unsigned char key[16] )
+void mbedtls_xtea_setup( mbedtls_xtea_context *ctx, const unsigned char key[16] )
{
int i;
- memset( ctx, 0, sizeof(xtea_context) );
+ memset( ctx, 0, sizeof(mbedtls_xtea_context) );
for( i = 0; i < 4; i++ )
{
@@ -102,7 +102,7 @@
/*
* XTEA encrypt function
*/
-int xtea_crypt_ecb( xtea_context *ctx, int mode,
+int mbedtls_xtea_crypt_ecb( mbedtls_xtea_context *ctx, int mode,
const unsigned char input[8], unsigned char output[8])
{
uint32_t *k, v0, v1, i;
@@ -112,7 +112,7 @@
GET_UINT32_BE( v0, input, 0 );
GET_UINT32_BE( v1, input, 4 );
- if( mode == XTEA_ENCRYPT )
+ if( mode == MBEDTLS_XTEA_ENCRYPT )
{
uint32_t sum = 0, delta = 0x9E3779B9;
@@ -123,7 +123,7 @@
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
}
}
- else /* XTEA_DECRYPT */
+ else /* MBEDTLS_XTEA_DECRYPT */
{
uint32_t delta = 0x9E3779B9, sum = delta * 32;
@@ -141,11 +141,11 @@
return( 0 );
}
-#if defined(POLARSSL_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* XTEA-CBC buffer encryption/decryption
*/
-int xtea_crypt_cbc( xtea_context *ctx, int mode, size_t length,
+int mbedtls_xtea_crypt_cbc( mbedtls_xtea_context *ctx, int mode, size_t length,
unsigned char iv[8], const unsigned char *input,
unsigned char *output)
{
@@ -153,14 +153,14 @@
unsigned char temp[8];
if( length % 8 )
- return( POLARSSL_ERR_XTEA_INVALID_INPUT_LENGTH );
+ return( MBEDTLS_ERR_XTEA_INVALID_INPUT_LENGTH );
- if( mode == XTEA_DECRYPT )
+ if( mode == MBEDTLS_XTEA_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 8 );
- xtea_crypt_ecb( ctx, mode, input, output );
+ mbedtls_xtea_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
@@ -179,7 +179,7 @@
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
- xtea_crypt_ecb( ctx, mode, output, output );
+ mbedtls_xtea_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 8 );
input += 8;
@@ -190,10 +190,10 @@
return( 0 );
}
-#endif /* POLARSSL_CIPHER_MODE_CBC */
-#endif /* !POLARSSL_XTEA_ALT */
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#endif /* !MBEDTLS_XTEA_ALT */
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
/*
* XTEA tests vectors (non-official)
@@ -238,45 +238,45 @@
/*
* Checkup routine
*/
-int xtea_self_test( int verbose )
+int mbedtls_xtea_self_test( int verbose )
{
int i, ret = 0;
unsigned char buf[8];
- xtea_context ctx;
+ mbedtls_xtea_context ctx;
- xtea_init( &ctx );
+ mbedtls_xtea_init( &ctx );
for( i = 0; i < 6; i++ )
{
if( verbose != 0 )
- polarssl_printf( " XTEA test #%d: ", i + 1 );
+ mbedtls_printf( " XTEA test #%d: ", i + 1 );
memcpy( buf, xtea_test_pt[i], 8 );
- xtea_setup( &ctx, xtea_test_key[i] );
- xtea_crypt_ecb( &ctx, XTEA_ENCRYPT, buf, buf );
+ mbedtls_xtea_setup( &ctx, xtea_test_key[i] );
+ mbedtls_xtea_crypt_ecb( &ctx, MBEDTLS_XTEA_ENCRYPT, buf, buf );
if( memcmp( buf, xtea_test_ct[i], 8 ) != 0 )
{
if( verbose != 0 )
- polarssl_printf( "failed\n" );
+ mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
- polarssl_printf( "passed\n" );
+ mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
- polarssl_printf( "\n" );
+ mbedtls_printf( "\n" );
exit:
- xtea_free( &ctx );
+ mbedtls_xtea_free( &ctx );
return( ret );
}
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
-#endif /* POLARSSL_XTEA_C */
+#endif /* MBEDTLS_XTEA_C */
