cipher.h

Go to the documentation of this file.

 
#ifndef POLARSSL_CIPHER_H
#define POLARSSL_CIPHER_H
 
#if !defined(POLARSSL_CONFIG_FILE)
#include "config.h"
#else
#include POLARSSL_CONFIG_FILE
#endif
 
#if defined(POLARSSL_GCM_C) || defined(POLARSSL_CCM_C)
#define POLARSSL_CIPHER_MODE_AEAD
#endif
 
#if defined(POLARSSL_CIPHER_MODE_CBC)
#define POLARSSL_CIPHER_MODE_WITH_PADDING
#endif
 
#include <string.h>
 
#if defined(_MSC_VER) && !defined(inline)
#define inline _inline
#else
#if defined(__ARMCC_VERSION) && !defined(inline)
#define inline __inline
#endif /* __ARMCC_VERSION */
#endif /*_MSC_VER */
 
#define POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE            -0x6080  
#define POLARSSL_ERR_CIPHER_BAD_INPUT_DATA                 -0x6100  
#define POLARSSL_ERR_CIPHER_ALLOC_FAILED                   -0x6180  
#define POLARSSL_ERR_CIPHER_INVALID_PADDING                -0x6200  
#define POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED            -0x6280  
#define POLARSSL_ERR_CIPHER_AUTH_FAILED                    -0x6300  
#define POLARSSL_CIPHER_VARIABLE_IV_LEN     0x01    
#define POLARSSL_CIPHER_VARIABLE_KEY_LEN    0x02    
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    POLARSSL_CIPHER_ID_NONE = 0,
    POLARSSL_CIPHER_ID_NULL,
    POLARSSL_CIPHER_ID_AES,
    POLARSSL_CIPHER_ID_DES,
    POLARSSL_CIPHER_ID_3DES,
    POLARSSL_CIPHER_ID_CAMELLIA,
    POLARSSL_CIPHER_ID_BLOWFISH,
    POLARSSL_CIPHER_ID_ARC4,
} cipher_id_t;
 
typedef enum {
    POLARSSL_CIPHER_NONE = 0,
    POLARSSL_CIPHER_NULL,
    POLARSSL_CIPHER_AES_128_ECB,
    POLARSSL_CIPHER_AES_192_ECB,
    POLARSSL_CIPHER_AES_256_ECB,
    POLARSSL_CIPHER_AES_128_CBC,
    POLARSSL_CIPHER_AES_192_CBC,
    POLARSSL_CIPHER_AES_256_CBC,
    POLARSSL_CIPHER_AES_128_CFB128,
    POLARSSL_CIPHER_AES_192_CFB128,
    POLARSSL_CIPHER_AES_256_CFB128,
    POLARSSL_CIPHER_AES_128_CTR,
    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_ECB,
    POLARSSL_CIPHER_CAMELLIA_192_ECB,
    POLARSSL_CIPHER_CAMELLIA_256_ECB,
    POLARSSL_CIPHER_CAMELLIA_128_CBC,
    POLARSSL_CIPHER_CAMELLIA_192_CBC,
    POLARSSL_CIPHER_CAMELLIA_256_CBC,
    POLARSSL_CIPHER_CAMELLIA_128_CFB128,
    POLARSSL_CIPHER_CAMELLIA_192_CFB128,
    POLARSSL_CIPHER_CAMELLIA_256_CFB128,
    POLARSSL_CIPHER_CAMELLIA_128_CTR,
    POLARSSL_CIPHER_CAMELLIA_192_CTR,
    POLARSSL_CIPHER_CAMELLIA_256_CTR,
    POLARSSL_CIPHER_CAMELLIA_128_GCM,
    POLARSSL_CIPHER_CAMELLIA_192_GCM,
    POLARSSL_CIPHER_CAMELLIA_256_GCM,
    POLARSSL_CIPHER_DES_ECB,
    POLARSSL_CIPHER_DES_CBC,
    POLARSSL_CIPHER_DES_EDE_ECB,
    POLARSSL_CIPHER_DES_EDE_CBC,
    POLARSSL_CIPHER_DES_EDE3_ECB,
    POLARSSL_CIPHER_DES_EDE3_CBC,
    POLARSSL_CIPHER_BLOWFISH_ECB,
    POLARSSL_CIPHER_BLOWFISH_CBC,
    POLARSSL_CIPHER_BLOWFISH_CFB64,
    POLARSSL_CIPHER_BLOWFISH_CTR,
    POLARSSL_CIPHER_ARC4_128,
    POLARSSL_CIPHER_AES_128_CCM,
    POLARSSL_CIPHER_AES_192_CCM,
    POLARSSL_CIPHER_AES_256_CCM,
    POLARSSL_CIPHER_CAMELLIA_128_CCM,
    POLARSSL_CIPHER_CAMELLIA_192_CCM,
    POLARSSL_CIPHER_CAMELLIA_256_CCM,
} cipher_type_t;
 
typedef enum {
    POLARSSL_MODE_NONE = 0,
    POLARSSL_MODE_ECB,
    POLARSSL_MODE_CBC,
    POLARSSL_MODE_CFB,
    POLARSSL_MODE_OFB, /* Unused! */
    POLARSSL_MODE_CTR,
    POLARSSL_MODE_GCM,
    POLARSSL_MODE_STREAM,
    POLARSSL_MODE_CCM,
} cipher_mode_t;
 
typedef enum {
    POLARSSL_PADDING_PKCS7 = 0,     
    POLARSSL_PADDING_ONE_AND_ZEROS, 
    POLARSSL_PADDING_ZEROS_AND_LEN, 
    POLARSSL_PADDING_ZEROS,         
    POLARSSL_PADDING_NONE,          
} cipher_padding_t;
 
typedef enum {
    POLARSSL_OPERATION_NONE = -1,
    POLARSSL_DECRYPT = 0,
    POLARSSL_ENCRYPT,
} operation_t;
 
enum {
    POLARSSL_KEY_LENGTH_NONE = 0,
    POLARSSL_KEY_LENGTH_DES  = 64,
    POLARSSL_KEY_LENGTH_DES_EDE = 128,
    POLARSSL_KEY_LENGTH_DES_EDE3 = 192,
};
 
#define POLARSSL_MAX_IV_LENGTH      16
#define POLARSSL_MAX_BLOCK_LENGTH   16
 
typedef struct {
 
    cipher_id_t cipher;
 
    int (*ecb_func)( void *ctx, operation_t mode,
                     const unsigned char *input, unsigned char *output );
 
    int (*cbc_func)( void *ctx, operation_t mode, size_t length,
                     unsigned char *iv, const unsigned char *input,
                     unsigned char *output );
 
    int (*cfb_func)( void *ctx, operation_t mode, size_t length, size_t *iv_off,
                     unsigned char *iv, const unsigned char *input,
                     unsigned char *output );
 
    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 );
 
    int (*stream_func)( void *ctx, size_t length,
                        const unsigned char *input, unsigned char *output );
 
    int (*setkey_enc_func)( void *ctx, const unsigned char *key,
                            unsigned int key_length );
 
    int (*setkey_dec_func)( void *ctx, const unsigned char *key,
                            unsigned int key_length);
 
    void * (*ctx_alloc_func)( void );
 
    void (*ctx_free_func)( void *ctx );
 
} cipher_base_t;
 
typedef struct {
    cipher_type_t type;
 
    cipher_mode_t mode;
 
    unsigned int key_length;
 
    const char * name;
 
    unsigned int iv_size;
 
    int flags;
 
    unsigned int block_size;
 
    const cipher_base_t *base;
 
} cipher_info_t;
 
typedef struct {
    const cipher_info_t *cipher_info;
 
    int key_length;
 
    operation_t operation;
 
    void (*add_padding)( unsigned char *output, size_t olen, size_t data_len );
    int (*get_padding)( unsigned char *input, size_t ilen, size_t *data_len );
 
    unsigned char unprocessed_data[POLARSSL_MAX_BLOCK_LENGTH];
 
    size_t unprocessed_len;
 
    unsigned char iv[POLARSSL_MAX_IV_LENGTH];
 
    size_t iv_size;
 
    void *cipher_ctx;
} cipher_context_t;
 
const int *cipher_list( void );
 
const cipher_info_t *cipher_info_from_string( const char *cipher_name );
 
const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type );
 
const cipher_info_t *cipher_info_from_values( const cipher_id_t cipher_id,
                                              int key_length,
                                              const cipher_mode_t mode );
 
void cipher_init( cipher_context_t *ctx );
 
void cipher_free( cipher_context_t *ctx );
 
int cipher_init_ctx( cipher_context_t *ctx, const cipher_info_t *cipher_info );
 
int cipher_free_ctx( cipher_context_t *ctx );
 
static inline unsigned int cipher_get_block_size( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return 0;
 
    return ctx->cipher_info->block_size;
}
 
static inline cipher_mode_t cipher_get_cipher_mode( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return POLARSSL_MODE_NONE;
 
    return ctx->cipher_info->mode;
}
 
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 (int) ctx->iv_size;
 
    return ctx->cipher_info->iv_size;
}
 
static inline cipher_type_t cipher_get_type( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return POLARSSL_CIPHER_NONE;
 
    return ctx->cipher_info->type;
}
 
static inline const char *cipher_get_name( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return 0;
 
    return ctx->cipher_info->name;
}
 
static inline int cipher_get_key_size ( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return POLARSSL_KEY_LENGTH_NONE;
 
    return ctx->cipher_info->key_length;
}
 
static inline operation_t cipher_get_operation( const cipher_context_t *ctx )
{
    if( NULL == ctx || NULL == ctx->cipher_info )
        return POLARSSL_OPERATION_NONE;
 
    return ctx->operation;
}
 
int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
                   int key_length, const operation_t operation );
 
#if defined(POLARSSL_CIPHER_MODE_WITH_PADDING)
int cipher_set_padding_mode( cipher_context_t *ctx, cipher_padding_t mode );
#endif /* POLARSSL_CIPHER_MODE_WITH_PADDING */
 
int cipher_set_iv( cipher_context_t *ctx,
                   const unsigned char *iv, size_t iv_len );
 
int cipher_reset( cipher_context_t *ctx );
 
#if defined(POLARSSL_GCM_C)
int cipher_update_ad( cipher_context_t *ctx,
                      const unsigned char *ad, size_t ad_len );
#endif /* POLARSSL_GCM_C */
 
int cipher_update( cipher_context_t *ctx, const unsigned char *input,
                   size_t ilen, unsigned char *output, size_t *olen );
 
int cipher_finish( cipher_context_t *ctx,
                   unsigned char *output, size_t *olen );
 
#if defined(POLARSSL_GCM_C)
int cipher_write_tag( cipher_context_t *ctx,
                      unsigned char *tag, size_t tag_len );
 
int cipher_check_tag( cipher_context_t *ctx,
                      const unsigned char *tag, size_t tag_len );
#endif /* POLARSSL_GCM_C */
 
int cipher_crypt( 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 );
 
#if defined(POLARSSL_CIPHER_MODE_AEAD)
int cipher_auth_encrypt( 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 );
 
int cipher_auth_decrypt( 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 );
#endif /* POLARSSL_CIPHER_MODE_AEAD */
 
int cipher_self_test( int verbose );
 
#ifdef __cplusplus
}
#endif
 
#endif /* POLARSSL_CIPHER_H */