yuzu-emu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-11-26 04:55:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merged SSL refactoring changing layer to use cipher layer

Browse Source
This commit is contained in:
Paul Bakker 2013-09-08 20:06:30 +02:00
commit 055ef61658
20 changed files with 1211 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/polarssl/arc4.h
View File

@ -55,7 +55,7 @@ arc4_context;
*
* \param ctx ARC4 context to be initialized
* \param key the secret key
* \param keylen length of the key
* \param keylen length of the key, in bytes
*/
void arc4_setup( arc4_context *ctx, const unsigned char *key, unsigned int keylen );

109
include/polarssl/cipher.h
View File

@ -30,6 +30,12 @@
#ifndef POLARSSL_CIPHER_H
#define POLARSSL_CIPHER_H
#include "config.h"
#if defined(POLARSSL_GCM_C)
#define POLARSSL_CIPHER_MODE_AEAD
#endif
#include <string.h>
#if defined(_MSC_VER) && !defined(inline)
@ -74,6 +80,7 @@ typedef enum {
POLARSSL_CIPHER_AES_192_CTR,
POLARSSL_CIPHER_AES_256_CTR,
POLARSSL_CIPHER_AES_128_GCM,
POLARSSL_CIPHER_AES_192_GCM,
POLARSSL_CIPHER_AES_256_GCM,
POLARSSL_CIPHER_CAMELLIA_128_CBC,
POLARSSL_CIPHER_CAMELLIA_192_CBC,
@ -95,7 +102,6 @@ typedef enum {
typedef enum {
POLARSSL_MODE_NONE = 0,
POLARSSL_MODE_NULL,
POLARSSL_MODE_CBC,
POLARSSL_MODE_CFB,
POLARSSL_MODE_OFB,
@ -151,6 +157,10 @@ typedef struct {
int (*ctr_func)( void *ctx, size_t length, size_t *nc_off, unsigned char *nonce_counter,
unsigned char *stream_block, const unsigned char *input, unsigned char *output );
/** Encrypt using STREAM */
int (*stream_func)( void *ctx, size_t length,
const unsigned char *input, unsigned char *output );
/** Set key for encryption purposes */
int (*setkey_enc_func)( void *ctx, const unsigned char *key, unsigned int key_length);
@ -182,9 +192,13 @@ typedef struct {
/** Name of the cipher */
const char * name;
/** IV size, in bytes */
/** IV/NONCE size, in bytes.
* For cipher that accept many sizes: recommended size */
unsigned int iv_size;
/** Flag for ciphers that accept many sizes of IV/NONCE */
int accepts_variable_iv_size;
/** block size, in bytes */
unsigned int block_size;
@ -219,6 +233,9 @@ typedef struct {
/** Current IV or NONCE_COUNTER for CTR-mode */
unsigned char iv[POLARSSL_MAX_IV_LENGTH];
/** IV size in bytes (for ciphers with variable-length IVs) */
size_t iv_size;
/** Cipher-specific context */
void *cipher_ctx;
} cipher_context_t;
@ -312,18 +329,22 @@ static inline cipher_mode_t cipher_get_cipher_mode( const cipher_context_t *ctx
}
/**
* \brief Returns the size of the cipher's IV.
* \brief Returns the size of the cipher's IV/NONCE in bytes.
*
* \param ctx cipher's context. Must have been initialised.
*
* \return size of the cipher's IV, or 0 if ctx has not been
* initialised.
* \return If IV has not been set yet: (recommended) IV size
* (0 for ciphers not using IV/NONCE).
* If IV has already been set: actual size.
*/
static inline int cipher_get_iv_size( const cipher_context_t *ctx )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return 0;
if( ctx->iv_size != 0 )
return ctx->iv_size;
return ctx->cipher_info->iv_size;
}
@ -425,15 +446,49 @@ int cipher_setkey( cipher_context_t *ctx, const unsigned char *key, int key_leng
int cipher_set_padding_mode( cipher_context_t *ctx, cipher_padding_t mode );
/**
* \brief Reset the given context, setting the IV to iv
* \brief Set the initialization vector (IV) or nonce
*
* \param iv IV to use (or NONCE_COUNTER for CTR-mode ciphers)
* \param iv_len IV length for ciphers with variable-size IV;
* discarded by ciphers with fixed-size IV.
*
* \returns O on success, or POLARSSL_ERR_CIPHER_BAD_INPUT_DATA
*
* \note Some ciphers don't use IVs nor NONCE. For these
* ciphers, this function has no effect.
*/
int cipher_set_iv( cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len );
/**
* \brief Finish preparation of the given context
*
* \param ctx generic cipher context
* \param iv IV to use or NONCE_COUNTER in the case of a CTR-mode cipher
*
* \returns 0 on success, POLARSSL_ERR_CIPHER_BAD_INPUT_DATA
* if parameter verification fails.
*/
int cipher_reset( cipher_context_t *ctx, const unsigned char *iv );
int cipher_reset( cipher_context_t *ctx );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
/**
* \brief Add additional data (for AEAD ciphers).
* This function has no effect for non-AEAD ciphers.
* For AEAD ciphers, it may or may not be called
* repeatedly, and/or interleaved with calls to
* cipher_udpate(), depending on the cipher.
* E.g. for GCM is must be called exactly once, right
* after cipher_reset().
*
* \param ctx generic cipher context
* \param ad Additional data to use.
* \param ad_len Length of ad.
*
* \returns 0 on success, or a specific error code.
*/
int cipher_update_ad( cipher_context_t *ctx,
const unsigned char *ad, size_t ad_len );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/**
* \brief Generic cipher update function. Encrypts/decrypts
@ -457,6 +512,10 @@ int cipher_reset( cipher_context_t *ctx, const unsigned char *iv );
* POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE on an
* unsupported mode for a cipher or a cipher specific
* error code.
*
* \note If the underlying cipher is GCM, all calls to this
* function, except the last one before cipher_finish(),
* must have ilen a multiple of the block size.
*/
int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen );
@ -468,7 +527,7 @@ int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ile
* the last block, and written to the output buffer.
*
* \param ctx Generic cipher context
* \param output buffer to write data to. Needs block_size data available.
* \param output buffer to write data to. Needs block_size available.
* \param olen length of the data written to the output buffer.
*
* \returns 0 on success, POLARSSL_ERR_CIPHER_BAD_INPUT_DATA if
@ -478,7 +537,37 @@ int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ile
* POLARSSL_ERR_CIPHER_INVALID_PADDING on invalid padding
* while decrypting or a cipher specific error code.
*/
int cipher_finish( cipher_context_t *ctx, unsigned char *output, size_t *olen);
int cipher_finish( cipher_context_t *ctx,
unsigned char *output, size_t *olen );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
/**
* \brief Write tag for AEAD ciphers.
* No effect for other ciphers.
* Must be called after cipher_finish().
*
* \param tag buffer to write the tag
* \param tag_len Length of the tag to write
*
* \return 0 on success, or a specific error code.
*/
int cipher_write_tag( cipher_context_t *ctx,
unsigned char *tag, size_t tag_len );
/**
* \brief Check tag for AEAD ciphers.
* No effect for other ciphers.
* Calling time depends on the cipher:
* for GCM, must be called after cipher_finish().
*
* \param tag Buffer holding the tag
* \param tag_len Length of the tag to check
*
* \return 0 on success, or a specific error code.
*/
int cipher_check_tag( cipher_context_t *ctx,
const unsigned char *tag, size_t tag_len );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/**
* \brief Checkup routine

1
include/polarssl/cipher_wrap.h
View File

@ -56,6 +56,7 @@ extern const cipher_info_t aes_256_ctr_info;
#if defined(POLARSSL_GCM_C)
extern const cipher_info_t aes_128_gcm_info;
extern const cipher_info_t aes_192_gcm_info;
extern const cipher_info_t aes_256_gcm_info;
#endif /* POLARSSL_GCM_C */

8
include/polarssl/gcm.h
View File

@ -146,7 +146,7 @@ int gcm_auth_decrypt( gcm_context *ctx,
* \param mode GCM_ENCRYPT or GCM_DECRYPT
* \param iv initialization vector
* \param iv_len length of IV
* \param add additional data
* \param add additional data (or NULL if length is 0)
* \param add_len length of additional data
*
* \return 0 if successful
@ -182,14 +182,14 @@ int gcm_update( gcm_context *ctx,
/**
* \brief Generic GCM finalisation function. Wraps up the GCM stream
* and generated the tag. The tag can have a maximum length of
* and generates the tag. The tag can have a maximum length of
* 16 bytes.
*
* \param ctx GCM context
* \param tag buffer for holding the tag
* \param tag buffer for holding the tag (may be NULL if tag_len is 0)
* \param tag_len length of the tag to generate
*
* \return 0 if successful or POLARSSL_ERR_GCM_BAD_INPUT
* \return 0 if successful or POLARSSL_ERR_GCM_BAD_INPUT
*/
int gcm_finish( gcm_context *ctx,
unsigned char *tag,

66
include/polarssl/ssl.h
View File

@ -49,30 +49,15 @@
#include "sha512.h"
#endif
// for session tickets
#if defined(POLARSSL_AES_C)
#include "aes.h"
#endif
#if defined(POLARSSL_ARC4_C)
#include "arc4.h"
#endif
#if defined(POLARSSL_DES_C)
#include "des.h"
#endif
#if defined(POLARSSL_CAMELLIA_C)
#include "camellia.h"
#endif
#if defined(POLARSSL_GCM_C)
#include "gcm.h"
#endif
#if defined(POLARSSL_X509_PARSE_C)
#include "x509.h"
#endif
#if defined(POLARSSL_RSA_C)
#include "rsa.h"
#endif
#if defined(POLARSSL_DHM_C)
#include "dhm.h"
#endif
@ -441,40 +426,6 @@ struct _ssl_session
#endif /* POLARSSL_SSL_TRUNCATED_HMAC */
};
/*
* Helpers to find the correct size of the context in _ssl_transform
* (in the long run, we'll use the cipher layer, but for now...)
*/
#define SSL_MAX(a, b) ( a > b ? a : b )
#define SSL_CTX_MAX_0 0
#if defined(POLARSSL_AES_C)
#define SSL_CTX_MAX_1 SSL_MAX( SSL_CTX_MAX_0, sizeof( aes_context ) )
#else
#define SSL_CTX_MAX_1 SSL_CTX_MAX_0
#endif
#if defined(POLARSSL_ARC4_C)
#define SSL_CTX_MAX_2 SSL_MAX( SSL_CTX_MAX_1, sizeof( arc4_context ) )
#else
#define SSL_CTX_MAX_2 SSL_CTX_MAX_1
#endif
#if defined(POLARSSL_DES_C)
#define SSL_CTX_MAX_3 SSL_MAX( SSL_CTX_MAX_2, sizeof( des_context ) )
#define SSL_CTX_MAX_4 SSL_MAX( SSL_CTX_MAX_3, sizeof( des3_context ) )
#else
#define SSL_CTX_MAX_4 SSL_CTX_MAX_2
#endif
#if defined(POLARSSL_CAMELLIA_C)
#define SSL_CTX_MAX_5 SSL_MAX( SSL_CTX_MAX_4, sizeof( camellia_context ) )
#else
#define SSL_CTX_MAX_5 SSL_CTX_MAX_4
#endif
#if defined(POLARSSL_GCM_C)
#define SSL_CTX_MAX_6 SSL_MAX( SSL_CTX_MAX_5, sizeof( gcm_context ) )
#else
#define SSL_CTX_MAX_6 SSL_CTX_MAX_5
#endif
#define SSL_CTX_MAX SSL_CTX_MAX_6
/*
* This structure contains a full set of runtime transform parameters
* either in negotiation or active.
@ -504,8 +455,8 @@ struct _ssl_transform
md_context_t md_ctx_enc; /*!< MAC (encryption) */
md_context_t md_ctx_dec; /*!< MAC (decryption) */
uint32_t ctx_enc[SSL_CTX_MAX / 4]; /*!< encryption context */
uint32_t ctx_dec[SSL_CTX_MAX / 4]; /*!< decryption context */
cipher_context_t cipher_ctx_enc; /*!< encryption context */
cipher_context_t cipher_ctx_dec; /*!< decryption context */
/*
* Session specific compression layer
@ -516,17 +467,6 @@ struct _ssl_transform
#endif
};
/* Not needed any more */
#undef SSL_MAX
#undef SSL_CTX_MAX_0
#undef SSL_CTX_MAX_1
#undef SSL_CTX_MAX_2
#undef SSL_CTX_MAX_3
#undef SSL_CTX_MAX_4
#undef SSL_CTX_MAX_5
#undef SSL_CTX_MAX_6
#undef SSL_CTX_MAX
/*
* This structure contains the parameters only needed during handshake.
*/

179
library/cipher.c
View File

@ -34,8 +34,16 @@
#include "polarssl/cipher.h"
#include "polarssl/cipher_wrap.h"
#if defined(POLARSSL_GCM_C)
#include "polarssl/gcm.h"
#endif
#include <stdlib.h>
#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER)
#define POLARSSL_CIPHER_MODE_STREAM
#endif
#if defined _MSC_VER && !defined strcasecmp
#define strcasecmp _stricmp
#endif
@ -59,8 +67,18 @@ static const int supported_ciphers[] = {
POLARSSL_CIPHER_AES_256_CTR,
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
#if defined(POLARSSL_GCM_C)
POLARSSL_CIPHER_AES_128_GCM,
POLARSSL_CIPHER_AES_192_GCM,
POLARSSL_CIPHER_AES_256_GCM,
#endif /* defined(POLARSSL_GCM_C) */
#endif /* defined(POLARSSL_AES_C) */
#if defined(POLARSSL_ARC4_C)
POLARSSL_CIPHER_ARC4_128,
#endif
#if defined(POLARSSL_CAMELLIA_C)
POLARSSL_CIPHER_CAMELLIA_128_CBC,
POLARSSL_CIPHER_CAMELLIA_192_CBC,
@ -145,6 +163,8 @@ const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type )
#if defined(POLARSSL_GCM_C)
case POLARSSL_CIPHER_AES_128_GCM:
return &aes_128_gcm_info;
case POLARSSL_CIPHER_AES_192_GCM:
return &aes_192_gcm_info;
case POLARSSL_CIPHER_AES_256_GCM:
return &aes_256_gcm_info;
#endif /* defined(POLARSSL_GCM_C) */
@ -277,6 +297,20 @@ const cipher_info_t *cipher_info_from_string( const char *cipher_name )
if( !strcasecmp( "AES-256-CTR", cipher_name ) )
return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CTR );
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
#if defined(POLARSSL_GCM_C)
if( !strcasecmp( "AES-128-GCM", cipher_name ) )
return cipher_info_from_type( POLARSSL_CIPHER_AES_128_GCM );
if( !strcasecmp( "AES-192-GCM", cipher_name ) )
return cipher_info_from_type( POLARSSL_CIPHER_AES_192_GCM );
if( !strcasecmp( "AES-256-GCM", cipher_name ) )
return cipher_info_from_type( POLARSSL_CIPHER_AES_256_GCM );
#endif
#endif /* POLARSSL_AES_C */
#if defined(POLARSSL_ARC4_C)
if( !strcasecmp( "ARC4-128", cipher_name ) )
return( cipher_info_from_type( POLARSSL_CIPHER_ARC4_128 ) );
#endif
#if defined(POLARSSL_DES_C)
@ -354,11 +388,6 @@ int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
ctx->key_length = key_length;
ctx->operation = operation;
#if defined(POLARSSL_CIPHER_NULL_CIPHER)
if( ctx->cipher_info->mode == POLARSSL_MODE_NULL )
return 0;
#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
/*
* For CFB and CTR mode always use the encryption key schedule
*/
@ -377,17 +406,53 @@ int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
}
int cipher_reset( cipher_context_t *ctx, const unsigned char *iv )
int cipher_set_iv( 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;
if( ctx->cipher_info->accepts_variable_iv_size )
actual_iv_size = iv_len;
else
actual_iv_size = ctx->cipher_info->iv_size;
memcpy( ctx->iv, iv, actual_iv_size );
ctx->iv_size = actual_iv_size;
return 0;
}
int cipher_reset( cipher_context_t *ctx )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
ctx->unprocessed_len = 0;
memcpy( ctx->iv, iv, cipher_get_iv_size( ctx ) );
return 0;
}
#if defined(POLARSSL_CIPHER_MODE_AEAD)
int cipher_update_ad( 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;
#if defined(POLARSSL_GCM_C)
if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
{
return gcm_starts( ctx->cipher_ctx, ctx->operation,
ctx->iv, ctx->iv_size, ad, ad_len );
}
#endif
return 0;
}
#endif /* POLARSSL_CIPHER_MODE_AEAD */
int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
@ -402,25 +467,20 @@ int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ile
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
}
#if defined(POLARSSL_GCM_C)
if( ctx->cipher_info->mode == POLARSSL_MODE_GCM)
{
*olen = ilen;
return gcm_update( ctx->cipher_ctx, ilen, input, output );
}
#endif
if( input == output &&
( ctx->unprocessed_len != 0 || ilen % cipher_get_block_size( ctx ) ) )
{
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
}
#if defined(POLARSSL_CIPHER_NULL_CIPHER)
if( ctx->cipher_info->mode == POLARSSL_MODE_NULL )
{
*olen = ilen;
if( output == input )
return( 0 );
memcpy( output, input, ilen );
return 0;
}
#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
if( ctx->cipher_info->mode == POLARSSL_MODE_CBC )
{
/*
@ -489,6 +549,7 @@ int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ile
{
return ret;
}
*olen += ilen;
}
@ -527,6 +588,21 @@ int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ile
}
#endif
#if defined(POLARSSL_CIPHER_MODE_STREAM)
if( ctx->cipher_info->mode == POLARSSL_MODE_STREAM )
{
if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
ilen, input, output ) ) )
{
return ret;
}
*olen = ilen;
return 0;
}
#endif
return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
}
@ -686,7 +762,8 @@ static int get_no_padding( unsigned char *input, size_t input_len,
return 0;
}
int cipher_finish( cipher_context_t *ctx, unsigned char *output, size_t *olen)
int cipher_finish( cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
int ret = 0;
@ -697,7 +774,8 @@ int cipher_finish( cipher_context_t *ctx, unsigned char *output, size_t *olen)
if( POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
POLARSSL_MODE_CTR == ctx->cipher_info->mode ||
POLARSSL_MODE_NULL == ctx->cipher_info->mode )
POLARSSL_MODE_GCM == ctx->cipher_info->mode ||
POLARSSL_MODE_STREAM == ctx->cipher_info->mode )
{
return 0;
}
@ -797,6 +875,63 @@ int cipher_set_padding_mode( cipher_context_t *ctx, cipher_padding_t mode )
return 0;
}
#if defined(POLARSSL_CIPHER_MODE_AEAD)
int cipher_write_tag( 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;
if( POLARSSL_ENCRYPT != ctx->operation )
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
#if defined(POLARSSL_GCM_C)
if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
return gcm_finish( ctx->cipher_ctx, tag, tag_len );
#endif
return 0;
}
int cipher_check_tag( 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 )
{
return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
}
#if defined(POLARSSL_GCM_C)
if( POLARSSL_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;
if( 0 != ( ret = gcm_finish( ctx->cipher_ctx, check_tag, tag_len ) ) )
return( ret );
/* Check the tag in "constant-time" */
for( diff = 0, i = 0; i < tag_len; i++ )
diff |= tag[i] ^ check_tag[i];
if( diff != 0 )
return( POLARSSL_ERR_GCM_AUTH_FAILED );
return( 0 );
}
#endif
return( 0 );
}
#endif /* POLARSSL_CIPHER_MODE_AEAD */
#if defined(POLARSSL_SELF_TEST)
#include <stdio.h>

152
library/cipher_wrap.c
View File

@ -37,6 +37,10 @@
#include "polarssl/aes.h"
#endif
#if defined(POLARSSL_ARC4_C)
#include "polarssl/arc4.h"
#endif
#if defined(POLARSSL_CAMELLIA_C)
#include "polarssl/camellia.h"
#endif
@ -49,6 +53,10 @@
#include "polarssl/blowfish.h"
#endif
#if defined(POLARSSL_GCM_C)
#include "polarssl/gcm.h"
#endif
#if defined(POLARSSL_MEMORY_C)
#include "polarssl/memory.h"
#else
@ -129,6 +137,7 @@ const cipher_base_t aes_info = {
aes_crypt_cbc_wrap,
aes_crypt_cfb128_wrap,
aes_crypt_ctr_wrap,
NULL,
aes_setkey_enc_wrap,
aes_setkey_dec_wrap,
aes_ctx_alloc,
@ -141,6 +150,7 @@ const cipher_info_t aes_128_cbc_info = {
128,
"AES-128-CBC",
16,
0,
16,
&aes_info
};
@ -151,6 +161,7 @@ const cipher_info_t aes_192_cbc_info = {
192,
"AES-192-CBC",
16,
0,
16,
&aes_info
};
@ -161,6 +172,7 @@ const cipher_info_t aes_256_cbc_info = {
256,
"AES-256-CBC",
16,
0,
16,
&aes_info
};
@ -172,6 +184,7 @@ const cipher_info_t aes_128_cfb128_info = {
128,
"AES-128-CFB128",
16,
0,
16,
&aes_info
};
@ -182,6 +195,7 @@ const cipher_info_t aes_192_cfb128_info = {
192,
"AES-192-CFB128",
16,
0,
16,
&aes_info
};
@ -192,6 +206,7 @@ const cipher_info_t aes_256_cfb128_info = {
256,
"AES-256-CFB128",
16,
0,
16,
&aes_info
};
@ -204,6 +219,7 @@ const cipher_info_t aes_128_ctr_info = {
128,
"AES-128-CTR",
16,
0,
16,
&aes_info
};
@ -214,6 +230,7 @@ const cipher_info_t aes_192_ctr_info = {
192,
"AES-192-CTR",
16,
0,
16,
&aes_info
};
@ -224,20 +241,60 @@ const cipher_info_t aes_256_ctr_info = {
256,
"AES-256-CTR",
16,
0,
16,
&aes_info
};
#endif /* POLARSSL_CIPHER_MODE_CTR */
#if defined(POLARSSL_GCM_C)
static void *gcm_ctx_alloc( void )
{
return polarssl_malloc( sizeof( gcm_context ) );
}
static void gcm_ctx_free( void *ctx )
{
polarssl_free( ctx );
}
static int gcm_setkey_wrap( void *ctx, const unsigned char *key, unsigned int key_length )
{
return gcm_init( (gcm_context *) ctx, key, key_length );
}
const cipher_base_t gcm_aes_info = {
POLARSSL_CIPHER_ID_AES,
NULL,
NULL,
NULL,
NULL,
gcm_setkey_wrap,
gcm_setkey_wrap,
gcm_ctx_alloc,
gcm_ctx_free,
};
const cipher_info_t aes_128_gcm_info = {
POLARSSL_CIPHER_AES_128_GCM,
POLARSSL_MODE_GCM,
128,
"AES-128-GCM",
12,
1,
16,
&gcm_aes_info
};
const cipher_info_t aes_192_gcm_info = {
POLARSSL_CIPHER_AES_192_GCM,
POLARSSL_MODE_GCM,
192,
"AES-192-GCM",
12,
1,
16,
&aes_info
&gcm_aes_info
};
const cipher_info_t aes_256_gcm_info = {
@ -245,9 +302,10 @@ const cipher_info_t aes_256_gcm_info = {
POLARSSL_MODE_GCM,
256,
"AES-256-GCM",
12,
1,
16,
16,
&aes_info
&gcm_aes_info
};
#endif /* POLARSSL_GCM_C */
@ -324,6 +382,7 @@ const cipher_base_t camellia_info = {
camellia_crypt_cbc_wrap,
camellia_crypt_cfb128_wrap,
camellia_crypt_ctr_wrap,
NULL,
camellia_setkey_enc_wrap,
camellia_setkey_dec_wrap,
camellia_ctx_alloc,
@ -336,6 +395,7 @@ const cipher_info_t camellia_128_cbc_info = {
128,
"CAMELLIA-128-CBC",
16,
0,
16,
&camellia_info
};
@ -346,6 +406,7 @@ const cipher_info_t camellia_192_cbc_info = {
192,
"CAMELLIA-192-CBC",
16,
0,
16,
&camellia_info
};
@ -356,6 +417,7 @@ const cipher_info_t camellia_256_cbc_info = {
256,
"CAMELLIA-256-CBC",
16,
0,
16,
&camellia_info
};
@ -367,6 +429,7 @@ const cipher_info_t camellia_128_cfb128_info = {
128,
"CAMELLIA-128-CFB128",
16,
0,
16,
&camellia_info
};
@ -377,6 +440,7 @@ const cipher_info_t camellia_192_cfb128_info = {
192,
"CAMELLIA-192-CFB128",
16,
0,
16,
&camellia_info
};
@ -387,6 +451,7 @@ const cipher_info_t camellia_256_cfb128_info = {
256,
"CAMELLIA-256-CFB128",
16,
0,
16,
&camellia_info
};
@ -399,6 +464,7 @@ const cipher_info_t camellia_128_ctr_info = {
128,
"CAMELLIA-128-CTR",
16,
0,
16,
&camellia_info
};
@ -409,6 +475,7 @@ const cipher_info_t camellia_192_ctr_info = {
192,
"CAMELLIA-192-CTR",
16,
0,
16,
&camellia_info
};
@ -419,6 +486,7 @@ const cipher_info_t camellia_256_ctr_info = {
256,
"CAMELLIA-256-CTR",
16,
0,
16,
&camellia_info
};
@ -531,6 +599,7 @@ const cipher_base_t des_info = {
des_crypt_cbc_wrap,
des_crypt_cfb128_wrap,
des_crypt_ctr_wrap,
NULL,
des_setkey_enc_wrap,
des_setkey_dec_wrap,
des_ctx_alloc,
@ -543,6 +612,7 @@ const cipher_info_t des_cbc_info = {
POLARSSL_KEY_LENGTH_DES,
"DES-CBC",
8,
0,
8,
&des_info
};
@ -552,6 +622,7 @@ const cipher_base_t des_ede_info = {
des3_crypt_cbc_wrap,
des_crypt_cfb128_wrap,
des_crypt_ctr_wrap,
NULL,
des3_set2key_enc_wrap,
des3_set2key_dec_wrap,
des3_ctx_alloc,
@ -564,6 +635,7 @@ const cipher_info_t des_ede_cbc_info = {
POLARSSL_KEY_LENGTH_DES_EDE,
"DES-EDE-CBC",
8,
0,
8,
&des_ede_info
};
@ -573,6 +645,7 @@ const cipher_base_t des_ede3_info = {
des3_crypt_cbc_wrap,
des_crypt_cfb128_wrap,
des_crypt_ctr_wrap,
NULL,
des3_set3key_enc_wrap,
des3_set3key_dec_wrap,
des3_ctx_alloc,
@ -585,6 +658,7 @@ const cipher_info_t des_ede3_cbc_info = {
POLARSSL_KEY_LENGTH_DES_EDE3,
"DES-EDE3-CBC",
8,
0,
8,
&des_ede3_info
};
@ -636,12 +710,7 @@ static int blowfish_crypt_ctr_wrap( void *ctx, size_t length,
#endif
}
static int blowfish_setkey_dec_wrap( void *ctx, const unsigned char *key, unsigned int key_length )
{
return blowfish_setkey( (blowfish_context *) ctx, key, key_length );
}
static int blowfish_setkey_enc_wrap( void *ctx, const unsigned char *key, unsigned int key_length )
static int blowfish_setkey_wrap( void *ctx, const unsigned char *key, unsigned int key_length )
{
return blowfish_setkey( (blowfish_context *) ctx, key, key_length );
}
@ -661,8 +730,9 @@ const cipher_base_t blowfish_info = {
blowfish_crypt_cbc_wrap,
blowfish_crypt_cfb64_wrap,
blowfish_crypt_ctr_wrap,
blowfish_setkey_enc_wrap,
blowfish_setkey_dec_wrap,
NULL,
blowfish_setkey_wrap,
blowfish_setkey_wrap,
blowfish_ctx_alloc,
blowfish_ctx_free
};
@ -673,6 +743,7 @@ const cipher_info_t blowfish_cbc_info = {
128,
"BLOWFISH-CBC",
8,
0,
8,
&blowfish_info
};
@ -684,6 +755,7 @@ const cipher_info_t blowfish_cfb64_info = {
128,
"BLOWFISH-CFB64",
8,
0,
8,
&blowfish_info
};
@ -696,6 +768,7 @@ const cipher_info_t blowfish_ctr_info = {
128,
"BLOWFISH-CTR",
8,
0,
8,
&blowfish_info
};
@ -703,15 +776,32 @@ const cipher_info_t blowfish_ctr_info = {
#endif /* POLARSSL_BLOWFISH_C */
#if defined(POLARSSL_ARC4_C)
static void * arc4_ctx_alloc( void )
static int arc4_crypt_stream_wrap( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
{
return (void *) 1;
return( arc4_crypt( (arc4_context *) ctx, length, input, output ) );
}
static int arc4_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_length )
{
/* we get key_length in bits, arc4 expects it in bytes */
if( key_length % 8 != 0)
return( POLARSSL_ERR_CIPHER_BAD_INPUT_DATA );
arc4_setup( (arc4_context *) ctx, key, key_length / 8 );
return( 0 );
}
static void * arc4_ctx_alloc( void )
{
return polarssl_malloc( sizeof( arc4_context ) );
}
static void arc4_ctx_free( void *ctx )
{
((void) ctx);
polarssl_free( ctx );
}
const cipher_base_t arc4_base_info = {
@ -719,8 +809,9 @@ const cipher_base_t arc4_base_info = {
NULL,
NULL,
NULL,
NULL,
NULL,
arc4_crypt_stream_wrap,
arc4_setkey_wrap,
arc4_setkey_wrap,
arc4_ctx_alloc,
arc4_ctx_free
};
@ -731,18 +822,37 @@ const cipher_info_t arc4_128_info = {
128,
"ARC4-128",
0,
0,
1,
&arc4_base_info
};
#endif /* POLARSSL_ARC4_C */
#if defined(POLARSSL_CIPHER_NULL_CIPHER)
static int null_crypt_stream( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
{
((void) ctx);
memmove( output, input, length );
return( 0 );
}
static int null_setkey( void *ctx, const unsigned char *key,
unsigned int key_length )
{
((void) ctx);
((void) key);
((void) key_length);
return( 0 );
}
static void * null_ctx_alloc( void )
{
return (void *) 1;
}
static void null_ctx_free( void *ctx )
{
((void) ctx);
@ -753,18 +863,20 @@ const cipher_base_t null_base_info = {
NULL,
NULL,
NULL,
NULL,
NULL,
null_crypt_stream,
null_setkey,
null_setkey,
null_ctx_alloc,
null_ctx_free
};
const cipher_info_t null_cipher_info = {
POLARSSL_CIPHER_NULL,
POLARSSL_MODE_NULL,
POLARSSL_MODE_STREAM,
0,
"NULL",
0,
0,
1,
&null_base_info
};

20
library/gcm.c
View File

@ -293,11 +293,12 @@ int gcm_finish( gcm_context *ctx,
uint64_t orig_len = ctx->len * 8;
uint64_t orig_add_len = ctx->add_len * 8;
memcpy( tag, ctx->base_ectr, tag_len );
if( tag_len > 16 )
return( POLARSSL_ERR_GCM_BAD_INPUT );
if( tag_len != 0 )
memcpy( tag, ctx->base_ectr, tag_len );
if( orig_len || orig_add_len )
{
memset( work_buf, 0x00, 16 );
@ -357,15 +358,22 @@ int gcm_auth_decrypt( gcm_context *ctx,
unsigned char *output )
{
unsigned char check_tag[16];
size_t i;
int diff;
gcm_crypt_and_tag( ctx, GCM_DECRYPT, length, iv, iv_len, add, add_len, input, output, tag_len, check_tag );
if( memcmp( check_tag, tag, tag_len ) == 0 )
return( 0 );
/* Check tag in "constant-time" */
for( diff = 0, i = 0; i < tag_len; i++ )
diff |= tag[i] ^ check_tag[i];
memset( output, 0, length );
if( diff != 0 )
{
memset( output, 0, length );
return( POLARSSL_ERR_GCM_AUTH_FAILED );
}
return( POLARSSL_ERR_GCM_AUTH_FAILED );
return( 0 );
}
#if defined(POLARSSL_SELF_TEST)

5
library/pkcs12.c
View File

@ -184,7 +184,10 @@ int pkcs12_pbe( asn1_buf *pbe_params, int mode,
if( ( ret = cipher_setkey( &cipher_ctx, key, keylen, mode ) ) != 0 )
goto exit;
if( ( ret = cipher_reset( &cipher_ctx, iv ) ) != 0 )
if( ( ret = cipher_set_iv( &cipher_ctx, iv, cipher_info->iv_size ) ) != 0 )
goto exit;
if( ( ret = cipher_reset( &cipher_ctx ) ) != 0 )
goto exit;
if( ( ret = cipher_update( &cipher_ctx, data, len,

5
library/pkcs5.c
View File

@ -187,7 +187,10 @@ int pkcs5_pbes2( asn1_buf *pbe_params, int mode,
if( ( ret = cipher_setkey( &cipher_ctx, key, keylen, mode ) ) != 0 )
goto exit;
if( ( ret = cipher_reset( &cipher_ctx, iv ) ) != 0 )
if( ( ret = cipher_set_iv( &cipher_ctx, iv, enc_scheme_params.len ) ) != 0 )
goto exit;
if( ( ret = cipher_reset( &cipher_ctx ) ) != 0 )
goto exit;
if( ( ret = cipher_update( &cipher_ctx, data, datalen,

477
library/ssl_tls.c
View File

@ -355,6 +355,7 @@ static void ssl_calc_finished_tls_sha384(ssl_context *,unsigned char *,int);
int ssl_derive_keys( ssl_context *ssl )
{
int ret = 0;
unsigned char tmp[64];
unsigned char keyblk[256];
unsigned char *key1;
@ -632,58 +633,62 @@ int ssl_derive_keys( ssl_context *ssl )
switch( cipher_info->type )
{
#if defined(POLARSSL_ARC4_C)
case POLARSSL_CIPHER_ARC4_128:
arc4_setup( (arc4_context *) transform->ctx_enc, key1,
transform->keylen );
arc4_setup( (arc4_context *) transform->ctx_dec, key2,
transform->keylen );
break;
#endif
#if defined(POLARSSL_DES_C)
case POLARSSL_CIPHER_DES_EDE3_CBC:
des3_set3key_enc( (des3_context *) transform->ctx_enc, key1 );
des3_set3key_dec( (des3_context *) transform->ctx_dec, key2 );
break;
#endif
#if defined(POLARSSL_AES_C)
case POLARSSL_CIPHER_AES_128_CBC:
case POLARSSL_CIPHER_AES_256_CBC:
aes_setkey_enc( (aes_context*) transform->ctx_enc, key1,
cipher_info->key_length );
aes_setkey_dec( (aes_context*) transform->ctx_dec, key2,
cipher_info->key_length );
break;
#endif
#if defined(POLARSSL_CAMELLIA_C)
case POLARSSL_CIPHER_CAMELLIA_128_CBC:
case POLARSSL_CIPHER_CAMELLIA_256_CBC:
camellia_setkey_enc( (camellia_context*) transform->ctx_enc, key1,
cipher_info->key_length );
camellia_setkey_dec( (camellia_context*) transform->ctx_dec, key2,
cipher_info->key_length );
break;
#endif
#if defined(POLARSSL_DES_C)
case POLARSSL_CIPHER_AES_128_CBC:
case POLARSSL_CIPHER_AES_256_CBC:
case POLARSSL_CIPHER_DES_CBC:
des_setkey_enc( (des_context *) transform->ctx_enc, key1 );
des_setkey_dec( (des_context *) transform->ctx_dec, key2 );
break;
#endif
#if defined(POLARSSL_GCM_C)
case POLARSSL_CIPHER_AES_128_GCM:
case POLARSSL_CIPHER_AES_256_GCM:
gcm_init( (gcm_context *) transform->ctx_enc, key1,
cipher_info->key_length );
gcm_init( (gcm_context *) transform->ctx_dec, key2,
cipher_info->key_length );
if( ( ret = cipher_init_ctx( &transform->cipher_ctx_enc,
cipher_info ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_init_ctx", ret );
return( ret );
}
if( ( ret = cipher_init_ctx( &transform->cipher_ctx_dec,
cipher_info ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_init_ctx", ret );
return( ret );
}
if( ( ret = cipher_setkey( &transform->cipher_ctx_enc, key1,
cipher_info->key_length,
POLARSSL_ENCRYPT ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_setkey", ret );
return( ret );
}
if( ( ret = cipher_setkey( &transform->cipher_ctx_dec, key2,
cipher_info->key_length,
POLARSSL_DECRYPT ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_setkey", ret );
return( ret );
}
if( cipher_info->mode == POLARSSL_MODE_CBC )
{
if( ( ret = cipher_set_padding_mode( &transform->cipher_ctx_enc,
POLARSSL_PADDING_NONE ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_padding_mode", ret );
return( ret );
}
if( ( ret = cipher_set_padding_mode( &transform->cipher_ctx_dec,
POLARSSL_PADDING_NONE ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_padding_mode", ret );
return( ret );
}
}
break;
#endif
case POLARSSL_CIPHER_NULL:
break;
@ -913,9 +918,11 @@ static int ssl_encrypt_buf( ssl_context *ssl )
}
else
#endif /* POLARSSL_CIPHER_NULL_CIPHER */
#if defined(POLARSSL_ARC4_C)
if( ssl->transform_out->ciphersuite_info->cipher == POLARSSL_CIPHER_ARC4_128 )
{
int ret;
size_t olen = 0;
padlen = 0;
SSL_DEBUG_MSG( 3, ( "before encrypt: msglen = %d, "
@ -925,17 +932,57 @@ static int ssl_encrypt_buf( ssl_context *ssl )
SSL_DEBUG_BUF( 4, "before encrypt: output payload",
ssl->out_msg, ssl->out_msglen );
arc4_crypt( (arc4_context *) ssl->transform_out->ctx_enc,
ssl->out_msglen, ssl->out_msg,
ssl->out_msg );
if( ( ret = cipher_reset( &ssl->transform_out->cipher_ctx_enc ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_reset", ret );
return( ret );
}
if( ( ret = cipher_set_iv( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_iv", ret );
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_out->cipher_ctx_enc,
ssl->out_msg, ssl->out_msglen, ssl->out_msg,
&olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_update", ret );
return( ret );
}
if( ssl->out_msglen != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect %d %d",
ssl->out_msglen, olen ) );
// TODO Real error number
return( -1 );
}
if( ( ret = cipher_finish( &ssl->transform_out->cipher_ctx_enc,
ssl->out_msg + olen, &olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_finish", ret );
return( ret );
}
if( 0 != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect %d %d",
0, olen ) );
// TODO Real error number
return( -1 );
}
}
else
#endif /* POLARSSL_ARC4_C */
#if defined(POLARSSL_GCM_C)
if( ssl->transform_out->ciphersuite_info->cipher == POLARSSL_CIPHER_AES_128_GCM ||
ssl->transform_out->ciphersuite_info->cipher == POLARSSL_CIPHER_AES_256_GCM )
{
size_t enc_msglen;
size_t enc_msglen, olen, totlen;
unsigned char *enc_msg;
unsigned char add_data[13];
int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
@ -966,6 +1013,9 @@ static int ssl_encrypt_buf( ssl_context *ssl )
ssl->transform_out->iv_enc + ssl->transform_out->fixed_ivlen,
ssl->transform_out->ivlen - ssl->transform_out->fixed_ivlen );
SSL_DEBUG_BUF( 4, "IV used", ssl->out_iv,
ssl->transform_out->ivlen - ssl->transform_out->fixed_ivlen );
/*
* Fix pointer positions and message length with added IV
*/
@ -982,25 +1032,63 @@ static int ssl_encrypt_buf( ssl_context *ssl )
ssl->out_msg, ssl->out_msglen );
/*
* Adjust for tag
* Encrypt
*/
if( ( ret = cipher_set_iv( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen ) ) != 0 ||
( ret = cipher_reset( &ssl->transform_out->cipher_ctx_enc ) ) != 0 )
{
return( ret );
}
if( ( ret = cipher_update_ad( &ssl->transform_out->cipher_ctx_enc,
add_data, 13 ) ) != 0 )
{
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_out->cipher_ctx_enc,
enc_msg, enc_msglen,
enc_msg, &olen ) ) != 0 )
{
return( ret );
}
totlen = olen;
if( ( ret = cipher_finish( &ssl->transform_out->cipher_ctx_enc,
enc_msg + olen, &olen ) ) != 0 )
{
return( ret );
}
totlen += olen;
if( totlen != enc_msglen )
{
SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( -1 );
}
/*
* Authenticate
*/
ssl->out_msglen += 16;
gcm_crypt_and_tag( (gcm_context *) ssl->transform_out->ctx_enc,
GCM_ENCRYPT, enc_msglen,
ssl->transform_out->iv_enc, ssl->transform_out->ivlen,
add_data, 13,
enc_msg, enc_msg,
16, enc_msg + enc_msglen );
if( ( ret = cipher_write_tag( &ssl->transform_out->cipher_ctx_enc,
enc_msg + enc_msglen, 16 ) ) != 0 )
{
return( ret );
}
SSL_DEBUG_BUF( 4, "after encrypt: tag",
enc_msg + enc_msglen, 16 );
SSL_DEBUG_BUF( 4, "after encrypt: tag", enc_msg + enc_msglen, 16 );
}
else
#endif /* POLARSSL_GCM_C */
{
int ret;
unsigned char *enc_msg;
size_t enc_msglen;
size_t olen = 0;
padlen = ssl->transform_out->ivlen - ( ssl->out_msglen + 1 ) %
ssl->transform_out->ivlen;
@ -1049,43 +1137,56 @@ static int ssl_encrypt_buf( ssl_context *ssl )
SSL_DEBUG_BUF( 4, "before encrypt: output payload",
ssl->out_iv, ssl->out_msglen );
switch( ssl->transform_out->ciphersuite_info->cipher )
if( ( ret = cipher_reset( &ssl->transform_out->cipher_ctx_enc ) ) != 0 )
{
#if defined(POLARSSL_DES_C)
case POLARSSL_CIPHER_DES_CBC:
des_crypt_cbc( (des_context *) ssl->transform_out->ctx_enc,
DES_ENCRYPT, enc_msglen,
ssl->transform_out->iv_enc, enc_msg, enc_msg );
break;
case POLARSSL_CIPHER_DES_EDE3_CBC:
des3_crypt_cbc( (des3_context *) ssl->transform_out->ctx_enc,
DES_ENCRYPT, enc_msglen,
ssl->transform_out->iv_enc, enc_msg, enc_msg );
break;
#endif
#if defined(POLARSSL_AES_C)
case POLARSSL_CIPHER_AES_128_CBC:
case POLARSSL_CIPHER_AES_256_CBC:
aes_crypt_cbc( (aes_context *) ssl->transform_out->ctx_enc,
AES_ENCRYPT, enc_msglen,
ssl->transform_out->iv_enc, enc_msg, enc_msg );
break;
#endif
#if defined(POLARSSL_CAMELLIA_C)
case POLARSSL_CIPHER_CAMELLIA_128_CBC:
case POLARSSL_CIPHER_CAMELLIA_256_CBC:
camellia_crypt_cbc( (camellia_context *) ssl->transform_out->ctx_enc,
CAMELLIA_ENCRYPT, enc_msglen,
ssl->transform_out->iv_enc, enc_msg, enc_msg );
break;
#endif
default:
return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
SSL_DEBUG_RET( 1, "cipher_reset", ret );
return( ret );
}
if( ( ret = cipher_set_iv( &ssl->transform_out->cipher_ctx_enc,
ssl->transform_out->iv_enc,
ssl->transform_out->ivlen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_iv", ret );
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_out->cipher_ctx_enc,
enc_msg, enc_msglen, enc_msg,
&olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_update", ret );
return( ret );
}
enc_msglen -= olen;
if( ( ret = cipher_finish( &ssl->transform_out->cipher_ctx_enc,
enc_msg + olen, &olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_finish", ret );
return( ret );
}
if( enc_msglen != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect %d %d",
enc_msglen, olen ) );
// TODO Real error number
return( -1 );
}
#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1)
if( ssl->minor_ver < SSL_MINOR_VERSION_2 )
{
/*
* Save IV in SSL3 and TLS1
*/
memcpy( ssl->transform_out->iv_enc,
ssl->transform_out->cipher_ctx_enc.iv,
ssl->transform_out->ivlen );
}
#endif
}
for( i = 8; i > 0; i-- )
@ -1123,11 +1224,53 @@ static int ssl_decrypt_buf( ssl_context *ssl )
#if defined(POLARSSL_ARC4_C)
if( ssl->transform_in->ciphersuite_info->cipher == POLARSSL_CIPHER_ARC4_128 )
{
int ret;
size_t olen = 0;
padlen = 0;
arc4_crypt( (arc4_context *) ssl->transform_in->ctx_dec,
ssl->in_msglen, ssl->in_msg,
ssl->in_msg );
if( ( ret = cipher_reset( &ssl->transform_in->cipher_ctx_dec ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_reset", ret );
return( ret );
}
if( ( ret = cipher_set_iv( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_iv", ret );
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_in->cipher_ctx_dec,
ssl->in_msg, ssl->in_msglen, ssl->in_msg,
&olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_update", ret );
return( ret );
}
if( ssl->in_msglen != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect" ) );
// TODO Real error number
return( -1 );
}
if( ( ret = cipher_finish( &ssl->transform_in->cipher_ctx_dec,
ssl->in_msg + olen, &olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_finish", ret );
return( ret );
}
if( 0 != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect" ) );
// TODO Real error number
return( -1 );
}
}
else
#endif /* POLARSSL_ARC4_C */
@ -1137,7 +1280,7 @@ static int ssl_decrypt_buf( ssl_context *ssl )
{
unsigned char *dec_msg;
unsigned char *dec_msg_result;
size_t dec_msglen;
size_t dec_msglen, olen, totlen;
unsigned char add_data[13];
int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
@ -1168,21 +1311,54 @@ static int ssl_decrypt_buf( ssl_context *ssl )
ssl->transform_in->ivlen );
SSL_DEBUG_BUF( 4, "TAG used", dec_msg + dec_msglen, 16 );
ret = gcm_auth_decrypt( (gcm_context *) ssl->transform_in->ctx_dec,
dec_msglen,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen,
add_data, 13,
dec_msg + dec_msglen, 16,
dec_msg, dec_msg_result );
if( ret != 0 )
/*
* Decrypt
*/
if( ( ret = cipher_set_iv( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen ) ) != 0 ||
( ret = cipher_reset( &ssl->transform_in->cipher_ctx_dec ) ) != 0 )
{
SSL_DEBUG_MSG( 1, ( "AEAD decrypt failed on validation (ret = -0x%02x)",
-ret ) );
return( ret );
}
if( ( ret = cipher_update_ad( &ssl->transform_in->cipher_ctx_dec,
add_data, 13 ) ) != 0 )
{
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_in->cipher_ctx_dec,
dec_msg, dec_msglen,
dec_msg_result, &olen ) ) != 0 )
{
return( ret );
}
totlen = olen;
if( ( ret = cipher_finish( &ssl->transform_in->cipher_ctx_dec,
dec_msg_result + olen, &olen ) ) != 0 )
{
return( ret );
}
totlen += olen;
if( totlen != dec_msglen )
{
SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( -1 );
}
/*
* Authenticate
*/
if( ( ret = cipher_check_tag( &ssl->transform_in->cipher_ctx_dec,
dec_msg + dec_msglen, 16 ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_check_tag", ret );
return( POLARSSL_ERR_SSL_INVALID_MAC );
}
}
else
#endif /* POLARSSL_GCM_C */
@ -1190,10 +1366,12 @@ static int ssl_decrypt_buf( ssl_context *ssl )
/*
* Decrypt and check the padding
*/
int ret;
unsigned char *dec_msg;
unsigned char *dec_msg_result;
size_t dec_msglen;
size_t minlen = 0;
size_t olen = 0;
/*
* Check immediate ciphertext sanity
@ -1236,44 +1414,55 @@ static int ssl_decrypt_buf( ssl_context *ssl )
}
#endif /* POLARSSL_SSL_PROTO_TLS1_1 || POLARSSL_SSL_PROTO_TLS1_2 */
switch( ssl->transform_in->ciphersuite_info->cipher )
if( ( ret = cipher_reset( &ssl->transform_in->cipher_ctx_dec ) ) != 0 )
{
#if defined(POLARSSL_DES_C)
case POLARSSL_CIPHER_DES_CBC:
des_crypt_cbc( (des_context *) ssl->transform_in->ctx_dec,
DES_DECRYPT, dec_msglen,
ssl->transform_in->iv_dec, dec_msg, dec_msg_result );
break;
case POLARSSL_CIPHER_DES_EDE3_CBC:
des3_crypt_cbc( (des3_context *) ssl->transform_in->ctx_dec,
DES_DECRYPT, dec_msglen,
ssl->transform_in->iv_dec, dec_msg, dec_msg_result );
break;
#endif
#if defined(POLARSSL_AES_C)
case POLARSSL_CIPHER_AES_128_CBC:
case POLARSSL_CIPHER_AES_256_CBC:
aes_crypt_cbc( (aes_context *) ssl->transform_in->ctx_dec,
AES_DECRYPT, dec_msglen,
ssl->transform_in->iv_dec, dec_msg, dec_msg_result );
break;
#endif
#if defined(POLARSSL_CAMELLIA_C)
case POLARSSL_CIPHER_CAMELLIA_128_CBC:
case POLARSSL_CIPHER_CAMELLIA_256_CBC:
camellia_crypt_cbc( (camellia_context *) ssl->transform_in->ctx_dec,
CAMELLIA_DECRYPT, dec_msglen,
ssl->transform_in->iv_dec, dec_msg, dec_msg_result );
break;
#endif
default:
return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
SSL_DEBUG_RET( 1, "cipher_reset", ret );
return( ret );
}
if( ( ret = cipher_set_iv( &ssl->transform_in->cipher_ctx_dec,
ssl->transform_in->iv_dec,
ssl->transform_in->ivlen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_set_iv", ret );
return( ret );
}
if( ( ret = cipher_update( &ssl->transform_in->cipher_ctx_dec,
dec_msg, dec_msglen, dec_msg_result,
&olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_update", ret );
return( ret );
}
dec_msglen -= olen;
if( ( ret = cipher_finish( &ssl->transform_in->cipher_ctx_dec,
dec_msg_result + olen, &olen ) ) != 0 )
{
SSL_DEBUG_RET( 1, "cipher_finish", ret );
return( ret );
}
if( dec_msglen != olen )
{
SSL_DEBUG_MSG( 1, ( "total encrypted length incorrect" ) );
// TODO Real error number
return( -1 );
}
#if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1)
if( ssl->minor_ver < SSL_MINOR_VERSION_2 )
{
/*
* Save IV in SSL3 and TLS1
*/
memcpy( ssl->transform_in->iv_dec,
ssl->transform_in->cipher_ctx_dec.iv,
ssl->transform_in->ivlen );
}
#endif
padlen = 1 + ssl->in_msg[ssl->in_msglen - 1];
if( ssl->in_msglen < ssl->transform_in->maclen + padlen )

10
programs/aes/crypt_and_hash.c
View File

@ -306,7 +306,12 @@ int main( int argc, char *argv[] )
fprintf( stderr, "cipher_setkey() returned error\n");
goto exit;
}
if( cipher_reset( &cipher_ctx, IV ) != 0 )
if( cipher_set_iv( &cipher_ctx, IV, 16 ) != 0 )
{
fprintf( stderr, "cipher_set_iv() returned error\n");
goto exit;
}
if( cipher_reset( &cipher_ctx ) != 0 )
{
fprintf( stderr, "cipher_reset() returned error\n");
goto exit;
@ -424,7 +429,8 @@ int main( int argc, char *argv[] )
cipher_setkey( &cipher_ctx, digest, cipher_info->key_length,
POLARSSL_DECRYPT );
cipher_reset( &cipher_ctx, IV);
cipher_set_iv( &cipher_ctx, IV, 16 );
cipher_reset( &cipher_ctx );
md_hmac_starts( &md_ctx, digest, 32 );

2
tests/CMakeLists.txt
View File

@ -40,9 +40,11 @@ add_test_suite(base64)
add_test_suite(blowfish)
add_test_suite(camellia)
add_test_suite(cipher cipher.aes)
add_test_suite(cipher cipher.arc4)
add_test_suite(cipher cipher.blowfish)
add_test_suite(cipher cipher.camellia)
add_test_suite(cipher cipher.des)
add_test_suite(cipher cipher.gcm)
add_test_suite(cipher cipher.null)
add_test_suite(cipher cipher.padding)
add_test_suite(ctr_drbg)

17
tests/Makefile
View File

@ -27,6 +27,7 @@ APPS = test_suite_aes.ecb test_suite_aes.cbc \
test_suite_arc4 \
test_suite_base64 test_suite_blowfish \
test_suite_camellia test_suite_cipher.aes \
test_suite_cipher.arc4 test_suite_cipher.gcm \
test_suite_cipher.blowfish \
test_suite_cipher.camellia \
test_suite_cipher.des test_suite_cipher.null \
@ -74,6 +75,14 @@ test_suite_cipher.aes.c : suites/test_suite_cipher.function suites/test_suite_ci
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.aes
test_suite_cipher.arc4.c : suites/test_suite_cipher.function suites/test_suite_cipher.arc4.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.arc4
test_suite_cipher.gcm.c : suites/test_suite_cipher.function suites/test_suite_cipher.gcm.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.gcm
test_suite_cipher.blowfish.c : suites/test_suite_cipher.function suites/test_suite_cipher.blowfish.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.blowfish
@ -158,6 +167,14 @@ test_suite_cipher.aes: test_suite_cipher.aes.c ../library/libpolarssl.a
echo " CC $@.c"
$(CC) $(CFLAGS) $(OFLAGS) $@.c $(LDFLAGS) -o $@
test_suite_cipher.arc4: test_suite_cipher.arc4.c ../library/libpolarssl.a
echo " CC $@.c"
$(CC) $(CFLAGS) $(OFLAGS) $@.c $(LDFLAGS) -o $@
test_suite_cipher.gcm: test_suite_cipher.gcm.c ../library/libpolarssl.a
echo " CC $@.c"
$(CC) $(CFLAGS) $(OFLAGS) $@.c $(LDFLAGS) -o $@
test_suite_cipher.blowfish: test_suite_cipher.blowfish.c ../library/libpolarssl.a
echo " CC $@.c"
$(CC) $(CFLAGS) $(OFLAGS) $@.c $(LDFLAGS) -o $@

28
tests/suites/test_suite_cipher.aes.data
View File

@ -764,3 +764,31 @@ enc_dec_buf_multipart:POLARSSL_CIPHER_AES_256_CBC:256:17:6:
AES Encrypt and decrypt 32 bytes in multiple parts 1
depends_on:POLARSSL_AES_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_256_CBC:256:16:16:
AES Decrypt test vector #0
depends_on:POLARSSL_AES_C:POLARSSL_CIPHER_PADDING_PKCS7
decrypt_test_vec:POLARSSL_CIPHER_AES_128_CBC:POLARSSL_PADDING_PKCS7:"ffffffffe00000000000000000000000":"00000000000000000000000000000000":"23f710842b9bb9c32f26648c786807ca":"00000000000000000000000000000000":"":"":POLARSSL_ERR_CIPHER_INVALID_PADDING:0
AES Decrypt test vector #1
depends_on:POLARSSL_AES_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_CBC:POLARSSL_PADDING_NONE:"ffffffffe00000000000000000000000":"00000000000000000000000000000000":"23f710842b9bb9c32f26648c786807ca":"00000000000000000000000000000000":"":"":0:0
AES Decrypt test vector #2
depends_on:POLARSSL_AES_C
decrypt_test_vec:POLARSSL_CIPHER_AES_192_CBC:POLARSSL_PADDING_NONE:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"707b1dbb0ffa40ef7d95def421233fae":"fffffffff80000000000000000000000":"":"":0:0
AES Decrypt test vector #3
depends_on:POLARSSL_AES_C
decrypt_test_vec:POLARSSL_CIPHER_AES_256_CBC:POLARSSL_PADDING_NONE:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"49af6b372135acef10132e548f217b17":"ff000000000000000000000000000000":"":"":0:0
AES Decrypt test vector #4
depends_on:POLARSSL_AES_C:POLARSSL_CIPHER_MODE_CFB
decrypt_test_vec:POLARSSL_CIPHER_AES_128_CFB128:-1:"fffffffe000000000000000000000000":"00000000000000000000000000000000":"1114bc2028009b923f0b01915ce5e7c4":"00000000000000000000000000000000":"":"":0:0:
AES Decrypt test vector #5
depends_on:POLARSSL_AES_C:POLARSSL_CIPHER_MODE_CFB
decrypt_test_vec:POLARSSL_CIPHER_AES_192_CFB128:-1:"ffffffffffffffffffffffffffffffffffffffffffe00000":"00000000000000000000000000000000":"60136703374f64e860b48ce31f930716":"00000000000000000000000000000000":"":"":0:0
AES Decrypt test vector #6
depends_on:POLARSSL_AES_C:POLARSSL_CIPHER_MODE_CFB
decrypt_test_vec:POLARSSL_CIPHER_AES_128_CFB128:-1:"ffffffffff800000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"be66cfea2fecd6bf0ec7b4352c99bcaa":"00000000000000000000000000000000":"":"":0:0

110
tests/suites/test_suite_cipher.arc4.data Normal file
View File

@ -0,0 +1,110 @@
Cipher Selftest
depends_on:POLARSSL_SELF_TEST
cipher_selftest:
Decrypt empty buffer
dec_empty_buf:
ARC4 Encrypt and decrypt 0 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:0:-1
ARC4 Encrypt and decrypt 1 byte
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:1:-1
ARC4 Encrypt and decrypt 2 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:2:-1
ARC4 Encrypt and decrypt 7 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:7:-1
ARC4 Encrypt and decrypt 8 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:8:-1
ARC4 Encrypt and decrypt 9 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:9:-1
ARC4 Encrypt and decrypt 15 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:15:-1
ARC4 Encrypt and decrypt 16 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:16:-1
ARC4 Encrypt and decrypt 17 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:17:-1
ARC4 Encrypt and decrypt 31 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:31:-1
ARC4 Encrypt and decrypt 32 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:32:-1
ARC4 Encrypt and decrypt 32 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:33:-1
ARC4 Encrypt and decrypt 47 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:47:-1
ARC4 Encrypt and decrypt 48 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:48:-1
ARC4 Encrypt and decrypt 49 bytes
depends_on:POLARSSL_ARC4_C
enc_dec_buf:POLARSSL_CIPHER_ARC4_128:"ARC4-128":128:49:-1
ARC4 Encrypt and decrypt 0 bytes in multiple parts
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:0:0:
ARC4 Encrypt and decrypt 1 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:1:0:
ARC4 Encrypt and decrypt 1 bytes in multiple parts 2
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:0:1:
ARC4 Encrypt and decrypt 16 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:16:0:
ARC4 Encrypt and decrypt 16 bytes in multiple parts 2
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:0:16:
ARC4 Encrypt and decrypt 16 bytes in multiple parts 3
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:1:15:
ARC4 Encrypt and decrypt 16 bytes in multiple parts 4
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:15:1:
ARC4 Encrypt and decrypt 22 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:15:7:
ARC4 Encrypt and decrypt 22 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:16:6:
ARC4 Encrypt and decrypt 22 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:17:6:
ARC4 Encrypt and decrypt 32 bytes in multiple parts 1
depends_on:POLARSSL_ARC4_C
enc_dec_buf_multipart:POLARSSL_CIPHER_ARC4_128:128:16:16:

171
tests/suites/test_suite_cipher.function
View File

@ -1,5 +1,9 @@
/* BEGIN_HEADER */
#include <polarssl/cipher.h>
#if defined(POLARSSL_GCM_C)
#include <polarssl/gcm.h>
#endif
/* END_HEADER */
/* BEGIN_DEPENDENCIES
@ -11,30 +15,26 @@
void enc_dec_buf( int cipher_id, char *cipher_string, int key_len,
int length_val, int pad_mode )
{
size_t length = length_val;
size_t length = length_val, outlen, total_len, i;
unsigned char key[32];
unsigned char iv[16];
unsigned char ad[13];
unsigned char tag[16];
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
const cipher_info_t *cipher_info;
cipher_context_t ctx_dec;
cipher_context_t ctx_enc;
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
size_t outlen = 0;
size_t total_len = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
/*
* Prepare contexts
*/
memset( &ctx_dec, 0, sizeof( ctx_dec ) );
memset( &ctx_enc, 0, sizeof( ctx_enc ) );
memset( inbuf, 5, 64 );
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
memset( key, 0x2a, sizeof( key ) );
/* Check and get info structures */
cipher_info = cipher_info_from_type( cipher_id );
@ -44,7 +44,7 @@ void enc_dec_buf( int cipher_id, char *cipher_string, int key_len,
/* Initialise enc and dec contexts */
TEST_ASSERT( 0 == cipher_init_ctx( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == cipher_init_ctx( &ctx_enc, cipher_info ) );
TEST_ASSERT( 0 == cipher_setkey( &ctx_dec, key, key_len, POLARSSL_DECRYPT ) );
TEST_ASSERT( 0 == cipher_setkey( &ctx_enc, key, key_len, POLARSSL_ENCRYPT ) );
@ -54,8 +54,29 @@ void enc_dec_buf( int cipher_id, char *cipher_string, int key_len,
TEST_ASSERT( 0 == cipher_set_padding_mode( &ctx_enc, pad_mode ) );
}
TEST_ASSERT( 0 == cipher_reset( &ctx_dec, iv ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_enc, iv ) );
/*
* Do a few encode/decode cycles
*/
for( i = 0; i < 3; i++ )
{
memset( iv , 0x00 + i, sizeof( iv ) );
memset( ad, 0x10 + i, sizeof( ad ) );
memset( inbuf, 0x20 + i, sizeof( inbuf ) );
memset( encbuf, 0, sizeof( encbuf ) );
memset( decbuf, 0, sizeof( decbuf ) );
memset( tag, 0, sizeof( tag ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_enc ) );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
TEST_ASSERT( 0 == cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
@ -69,6 +90,10 @@ void enc_dec_buf( int cipher_id, char *cipher_string, int key_len,
TEST_ASSERT( 0 == cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
TEST_ASSERT( total_len == length ||
( total_len % cipher_get_block_size( &ctx_enc ) == 0 &&
total_len > length &&
@ -86,10 +111,18 @@ void enc_dec_buf( int cipher_id, char *cipher_string, int key_len,
TEST_ASSERT( 0 == cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* check result */
TEST_ASSERT( total_len == length );
TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
}
/*
* Done
*/
TEST_ASSERT( 0 == cipher_free_ctx( &ctx_dec ) );
TEST_ASSERT( 0 == cipher_free_ctx( &ctx_enc ) );
}
@ -127,7 +160,11 @@ void enc_fail( int cipher_id, int pad_mode, int key_len,
TEST_ASSERT( 0 == cipher_init_ctx( &ctx, cipher_info ) );
TEST_ASSERT( 0 == cipher_setkey( &ctx, key, key_len, POLARSSL_ENCRYPT ) );
TEST_ASSERT( 0 == cipher_set_padding_mode( &ctx, pad_mode ) );
TEST_ASSERT( 0 == cipher_reset( &ctx, iv ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx, iv, 16 ) );
TEST_ASSERT( 0 == cipher_reset( &ctx ) );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_update_ad( &ctx, NULL, 0 ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
@ -160,7 +197,7 @@ void dec_empty_buf()
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
/* Initialise enc and dec contexts */
/* Initialise context */
cipher_info = cipher_info_from_type( POLARSSL_CIPHER_AES_128_CBC );
TEST_ASSERT( NULL != cipher_info);
@ -168,12 +205,19 @@ void dec_empty_buf()
TEST_ASSERT( 0 == cipher_setkey( &ctx_dec, key, 128, POLARSSL_DECRYPT ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_dec, iv ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_dec ) );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_update_ad( &ctx_dec, NULL, 0 ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* decode 0-byte string */
TEST_ASSERT( 0 == cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
TEST_ASSERT( 0 == outlen );
TEST_ASSERT( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED == cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
TEST_ASSERT( POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED == cipher_finish(
&ctx_dec, decbuf + outlen, &outlen ) );
TEST_ASSERT( 0 == outlen );
TEST_ASSERT( 0 == cipher_free_ctx( &ctx_dec ) );
@ -221,8 +265,16 @@ void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
TEST_ASSERT( 0 == cipher_setkey( &ctx_dec, key, key_len, POLARSSL_DECRYPT ) );
TEST_ASSERT( 0 == cipher_setkey( &ctx_enc, key, key_len, POLARSSL_ENCRYPT ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_dec, iv ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_enc, iv ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx_enc, iv, 16 ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == cipher_reset( &ctx_enc ) );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_update_ad( &ctx_dec, NULL, 0 ) );
TEST_ASSERT( 0 == cipher_update_ad( &ctx_enc, NULL, 0 ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
@ -248,7 +300,7 @@ void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % cipher_get_block_size( &ctx_dec ) == 0 &&
totaloutlen < length &&
totaloutlen + cipher_get_block_size( &ctx_dec ) > length ) );
totaloutlen + cipher_get_block_size( &ctx_dec ) >= length ) );
TEST_ASSERT( 0 == cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
totaloutlen += outlen;
@ -262,6 +314,73 @@ void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
}
/* END_CASE */
/* BEGIN_CASE */
void decrypt_test_vec( int cipher_id, int pad_mode,
char *hex_key, char *hex_iv,
char *hex_cipher, char *hex_clear,
char *hex_ad, char *hex_tag,
int finish_result, int tag_result )
{
unsigned char key[50];
unsigned char iv[50];
unsigned char cipher[200];
unsigned char clear[200];
unsigned char ad[200];
unsigned char tag[20];
size_t key_len, iv_len, cipher_len, clear_len, ad_len, tag_len;
cipher_context_t ctx;
unsigned char output[200];
size_t outlen, total_len;
memset( key, 0x00, sizeof( key ) );
memset( iv, 0x00, sizeof( iv ) );
memset( cipher, 0x00, sizeof( cipher ) );
memset( clear, 0x00, sizeof( clear ) );
memset( ad, 0x00, sizeof( ad ) );
memset( tag, 0x00, sizeof( tag ) );
memset( output, 0x00, sizeof( output ) );
key_len = unhexify( key, hex_key );
iv_len = unhexify( iv, hex_iv );
cipher_len = unhexify( cipher, hex_cipher );
clear_len = unhexify( clear, hex_clear );
ad_len = unhexify( ad, hex_ad );
tag_len = unhexify( tag, hex_tag );
/* Prepare context */
TEST_ASSERT( 0 == cipher_init_ctx( &ctx,
cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == cipher_setkey( &ctx, key, 8 * key_len, POLARSSL_DECRYPT ) );
if( pad_mode != -1 )
TEST_ASSERT( 0 == cipher_set_padding_mode( &ctx, pad_mode ) );
TEST_ASSERT( 0 == cipher_set_iv( &ctx, iv, iv_len ) );
TEST_ASSERT( 0 == cipher_reset( &ctx ) );
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( 0 == cipher_update_ad( &ctx, ad, ad_len ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* decode buffer and check tag */
total_len = 0;
TEST_ASSERT( 0 == cipher_update( &ctx, cipher, cipher_len, output, &outlen ) );
total_len += outlen;
TEST_ASSERT( finish_result == cipher_finish( &ctx, output + outlen,
&outlen ) );
total_len += outlen;
#if defined(POLARSSL_CIPHER_MODE_AEAD)
TEST_ASSERT( tag_result == cipher_check_tag( &ctx, tag, tag_len ) );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
/* check plaintext only if everything went fine */
if( 0 == finish_result && 0 == tag_result )
{
TEST_ASSERT( total_len == clear_len );
TEST_ASSERT( 0 == memcmp( output, clear, clear_len ) );
}
cipher_free_ctx( &ctx );
}
/* END_CASE */
/* BEGIN_CASE */
void set_padding( int cipher_id, int pad_mode, int ret )
{

134
tests/suites/test_suite_cipher.gcm.data Normal file
View File

@ -0,0 +1,134 @@
Cipher Selftest
depends_on:POLARSSL_SELF_TEST
cipher_selftest:
Decrypt empty buffer
dec_empty_buf:
AES-GCM Encrypt and decrypt 0 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:0:-1
AES 128 GCM Encrypt and decrypt 1 byte
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:1:-1
AES 128 GCM Encrypt and decrypt 2 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:2:-1
AES 128 GCM Encrypt and decrypt 7 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:7:-1
AES 128 GCM Encrypt and decrypt 8 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:8:-1
AES 128 GCM Encrypt and decrypt 9 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:9:-1
AES 128 GCM Encrypt and decrypt 15 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:15:-1
AES 128 GCM Encrypt and decrypt 16 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:16:-1
AES 128 GCM Encrypt and decrypt 17 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:17:-1
AES 128 GCM Encrypt and decrypt 31 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:31:-1
AES 128 GCM Encrypt and decrypt 32 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:32:-1
AES 128 GCM Encrypt and decrypt 32 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:33:-1
AES 128 GCM Encrypt and decrypt 47 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:47:-1
AES 128 GCM Encrypt and decrypt 48 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:48:-1
AES 128 GCM Encrypt and decrypt 49 bytes
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf:POLARSSL_CIPHER_AES_128_GCM:"AES-128-GCM":128:49:-1
AES 128 GCM Encrypt and decrypt 0 bytes in multiple parts
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:0:0
AES 128 GCM Encrypt and decrypt 1 bytes in multiple parts 1
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:1:0
AES 128 GCM Encrypt and decrypt 1 bytes in multiple parts 2
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:0:1
AES 128 GCM Encrypt and decrypt 16 bytes in multiple parts 1
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:16:0
AES 128 GCM Encrypt and decrypt 16 bytes in multiple parts 2
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:0:16
AES 128 GCM Encrypt and decrypt 22 bytes in multiple parts 1
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:16:6
AES 128 GCM Encrypt and decrypt 22 bytes in multiple parts 2
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:0:22
AES 128 GCM Encrypt and decrypt 32 bytes in multiple parts 1
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
enc_dec_buf_multipart:POLARSSL_CIPHER_AES_128_GCM:128:16:16
AES 128 GCM Decrypt test vector #1
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"d785dafea3e966731ef6fc6202262584":"d91a46205ee94058b3b8403997592dd2":"":"":"":"3b92a17c1b9c3578a68cffea5a5b6245":0:0
AES 128 GCM Decrypt test vector #2
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"9ab5c8ca905b5fe50461f4a68941144b":"96dd3927a96e16123f2e9d6b367d303f":"":"":"":"6e0c53ef":0:0
AES 128 GCM Decrypt test vector #3
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"b5fc7af605721a9cfe61c1ee6a4b3e22":"6b757d4055823d1035d01077666037d6":"":"":"":"e8c09ddd":0:POLARSSL_ERR_GCM_AUTH_FAILED
AES 128 GCM Decrypt test vector #4
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"03c0b4a6e508a8490db0d086a82c9db7":"ac52f6c1a05030321fa39f87e89fdb5e":"":"":"33316ca79d10a79f4fd038593e8eef09625089dc4e0ffe4bc1f2871554fa6666ab3e7fe7885edef694b410456f3ec0e513bb25f1b48d95e4820c5972c1aabb25c84c08566002dadc36df334c1ce86847964a122016d389ac873bca8c335a7a99bcef91e1b985ae5d488a2d7f78b4bf14e0c2dc715e814f4e24276057cf668172":"756292d8b4653887edef51679b161812":0:POLARSSL_ERR_GCM_AUTH_FAILED
AES 128 GCM Decrypt test vector #5
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"2bc73fba942ff105823b5dccf6befb1c":"902c3e3b69b1ef8395d7281ff74cce38":"":"":"4adec0b4ac00325a860044d9f9519daa4f7c163229a75819b0fd7d8e23319f030e61dfa8eadabff42ea27bc36bdb6cad249e801ca631b656836448b7172c11126bad2781e6a1aa4f62c4eda53409408b008c057e0b81215cc13ddabbb8f1915f4bbab854f8b00763a530ad5055d265778cd3080d0bd35b76a329bdd5b5a2d268":"ebdd7c8e87fe733138a433543542d1":0:0
AES 128 GCM Decrypt test vector #6
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"0dd358bc3f992f26e81e3a2f3aa2d517":"d8c750bb443ee1a169dfe97cfe4d855b":"87cc4fd75788c9d5cc83bae5d764dd249d178ab23224049795d4288b5ed9ea3f317068a39a7574b300c8544226e87b08e008fbe241d094545c211d56ac44437d41491a438272738968c8d371aa7787b5f606c8549a9d868d8a71380e9657d3c0337979feb01de5991fc1470dfc59eb02511efbbff3fcb479a862ba3844a25aaa":"77949b29f085bb3abb71a5386003811233056d3296eb093370f7777dadd306d93d59dcb9754d3857cf2758091ba661f845ef0582f6ae0e134328106f0d5d16b541cd74fdc756dc7b53f4f8a194daeea9369ebb1630c01ccb307b848e9527da20a39898d748fd59206f0b79d0ed946a8958033a45bd9ae673518b32606748eb65":"":"a81d13973baa22a751833d7d3f94b3b1":0:0
AES 128 GCM Decrypt test vector #7
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"9a433c612d7e1bdff881e4d63ba8b141":"8b670cf31f470f79a6c0b79e73863ca1":"ce10758332f423228b5e4ae31efda7677586934a1d8f05d9b7a0dc4e2010ec3eaacb71a527a5fff8e787d75ebd24ad163394c891b33477ed9e2a2d853c364cb1c5d0bc317fcaf4010817dbe5f1fd1037c701b291b3a66b164bc818bf5c00a4c210a1671faa574d74c7f3543f6c09aaf117e12e2eb3dae55edb1cc5b4086b617d":"":"":"8526fd25daf890e79946a205b698f287":0:POLARSSL_ERR_GCM_AUTH_FAILED
AES 128 GCM Decrypt test vector #8
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"69eedf3777e594c30e94e9c5e2bce467":"a3330638a809ba358d6c098e4342b81e":"5114e9983c96fecec3f7304ca42f52aa16cb7c6aadfb62ad537c93a3188835ca0703dad34c73cf96435b668b68a7a1d056931959316e8d3ab956bf64c4e07479c7767f9d488b0c0c351333ccf400b7e0be19a0fd173e3f2a1ae313f27e516952260fd2da9ab9daca478ebb93cd07d0b7503b32364d8e308d904d966c58f226bb":"208e6321238bf5c6e2ef55a4b8f531cbbfb0d77374fe32df6dd663486cf79beeed39bb6910c3c78dd0cc30707a0a12b226b2d06024db25dcd8a4e620f009cafa5242121e864c7f3f4360aaf1e9d4e548d99615156f156008418c1c41ff2bbc007cecf8f209c73203e6df89b32871de637b3d6af2e277d146ae03f3404d387b77":"df4e3f2b47cf0e8590228fcf9913fb8a5eb9751bba318fd2d57be68c7e788e04fabf303699b99f26313d1c4956105cd2817aad21b91c28f3b9251e9c0b354490fa5abfcea0065aa3cc9b96772eb8af06a1a9054bf12d3ae698dfb01a13f989f8b8a4bb61686cf3adf58f05873a24d403a62a092290c2481e4159588fea6b9a09":"5de3068e1e20eed469265000077b1db9":0:0
AES 128 GCM Decrypt test vector #9
depends_on:POLARSSL_AES_C:POLARSSL_GCM_C
decrypt_test_vec:POLARSSL_CIPHER_AES_128_GCM:-1:"45cc35311eedf0ba093bf901931a7036":"fed5084de3c348f5a0adf4c2fd4e848a":"5dc8d7525eaad035c19714ae1b1e538cb66a4089027245351e0ad9297410fb3a0c1155407c10a8bb95a9ca624a9c9925dac003ee78926c6e90ff4ccdba10e8a78bda1c4478162a0e302de5ff05fb0f94c89c3c7429fb94828bdcd97d21333c2ee72963ee6f056ce272b8bab007e653a42b01d1d2041ba627f169c8c0d32e6dae":"":"6e210914e4aed188d576f5ad7fc7e4cf7dd8d82f34ea3bcbdb7267cfd9045f806978dbff3460c4e8ff8c4edb6ad2edba405a8d915729d89aab2116b36a70b54f5920a97f5a571977e0329eda6c696749be940eabfc6d8b0bbd6fbdb87657b3a7695da9f5d3a7384257f20e0becd8512d3705cc246ee6ca1e610921cf92603d79":"266a895fc21da5176b44b446d7d1921d":0:POLARSSL_ERR_GCM_AUTH_FAILED

28
tests/suites/test_suite_cipher.null.data
View File

@ -7,59 +7,59 @@ dec_empty_buf:
NULL Encrypt and decrypt 0 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:0
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:0:-1
NULL Encrypt and decrypt 1 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:1
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:1:-1
NULL Encrypt and decrypt 2 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:2
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:2:-1
NULL Encrypt and decrypt 7 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:7
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:7:-1
NULL Encrypt and decrypt 8 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:8
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:8:-1
NULL Encrypt and decrypt 9 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:9
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:9:-1
NULL Encrypt and decrypt 15 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:15
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:15:-1
NULL Encrypt and decrypt 16 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:16
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:16:-1
NULL Encrypt and decrypt 31 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:31
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:31:-1
NULL Encrypt and decrypt 32 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:32
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:32:-1
NULL Encrypt and decrypt 33 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:33
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:33:-1
NULL Encrypt and decrypt 47 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:47
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:47:-1
NULL Encrypt and decrypt 48 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:48
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:48:-1
NULL Encrypt and decrypt 49 bytes
depends_on:POLARSSL_CIPHER_NULL_CIPHER
enc_dec_buf:POLARSSL_CIPHER_NULL:NULL:0:49
enc_dec_buf:POLARSSL_CIPHER_NULL:"NULL":0:49:-1
NULL Encrypt and decrypt 1 bytes in multiple parts 1
depends_on:POLARSSL_CIPHER_NULL_CIPHER

1
tests/suites/test_suite_gcm.function
View File

@ -95,6 +95,7 @@ void gcm_decrypt_and_verify( char *hex_key_string, char *hex_src_string,
}
else
{
TEST_ASSERT( ret == 0 );
hexify( dst_str, output, pt_len );
TEST_ASSERT( strcmp( (char *) dst_str, pt_result ) == 0 );