src/libpolarssl/cipher.c

   1 /**
   2  * \file cipher.c
   3  *
   4  * \brief Generic cipher wrapper for PolarSSL
   5  *
   6  * \author Adriaan de Jong <dejong@fox-it.com>
   7  *
   8  *  Copyright (C) 2006-2012, Brainspark B.V.
   9  *
  10  *  This file is part of PolarSSL (http://www.polarssl.org)
  11  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
  12  *
  13  *  All rights reserved.
  14  *
  15  *  This program is free software; you can redistribute it and/or modify
  16  *  it under the terms of the GNU General Public License as published by
  17  *  the Free Software Foundation; either version 2 of the License, or
  18  *  (at your option) any later version.
  19  *
  20  *  This program is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *  GNU General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU General Public License along
  26  *  with this program; if not, write to the Free Software Foundation, Inc.,
  27  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  28  */
  29
  30 #include "config.h"
  31
  32 #if defined(POLARSSL_CIPHER_C)
  33
  34 #include "cipher.h"
  35 #include "cipher_wrap.h"
  36
  37 #include <stdlib.h>
  38
  39 #if defined _MSC_VER && !defined strcasecmp
  40 #define strcasecmp _stricmp
  41 #endif
  42
  43 static const int supported_ciphers[] = {
  44
  45 #if defined(POLARSSL_AES_C)
  46         POLARSSL_CIPHER_AES_128_CBC,
  47         POLARSSL_CIPHER_AES_192_CBC,
  48         POLARSSL_CIPHER_AES_256_CBC,
  49
  50 #if defined(POLARSSL_CIPHER_MODE_CFB)
  51         POLARSSL_CIPHER_AES_128_CFB128,
  52         POLARSSL_CIPHER_AES_192_CFB128,
  53         POLARSSL_CIPHER_AES_256_CFB128,
  54 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
  55
  56 #if defined(POLARSSL_CIPHER_MODE_CTR)
  57         POLARSSL_CIPHER_AES_128_CTR,
  58         POLARSSL_CIPHER_AES_192_CTR,
  59         POLARSSL_CIPHER_AES_256_CTR,
  60 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
  61
  62 #endif /* defined(POLARSSL_AES_C) */
  63
  64 #if defined(POLARSSL_CAMELLIA_C)
  65         POLARSSL_CIPHER_CAMELLIA_128_CBC,
  66         POLARSSL_CIPHER_CAMELLIA_192_CBC,
  67         POLARSSL_CIPHER_CAMELLIA_256_CBC,
  68
  69 #if defined(POLARSSL_CIPHER_MODE_CFB)
  70         POLARSSL_CIPHER_CAMELLIA_128_CFB128,
  71         POLARSSL_CIPHER_CAMELLIA_192_CFB128,
  72         POLARSSL_CIPHER_CAMELLIA_256_CFB128,
  73 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
  74
  75 #if defined(POLARSSL_CIPHER_MODE_CTR)
  76         POLARSSL_CIPHER_CAMELLIA_128_CTR,
  77         POLARSSL_CIPHER_CAMELLIA_192_CTR,
  78         POLARSSL_CIPHER_CAMELLIA_256_CTR,
  79 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
  80
  81 #endif /* defined(POLARSSL_CAMELLIA_C) */
  82
  83 #if defined(POLARSSL_DES_C)
  84         POLARSSL_CIPHER_DES_CBC,
  85         POLARSSL_CIPHER_DES_EDE_CBC,
  86         POLARSSL_CIPHER_DES_EDE3_CBC,
  87 #endif /* defined(POLARSSL_DES_C) */
  88
  89 #if defined(POLARSSL_BLOWFISH_C)
  90         POLARSSL_CIPHER_BLOWFISH_CBC,
  91
  92 #if defined(POLARSSL_CIPHER_MODE_CFB)
  93         POLARSSL_CIPHER_BLOWFISH_CFB64,
  94 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
  95
  96 #if defined(POLARSSL_CIPHER_MODE_CTR)
  97         POLARSSL_CIPHER_BLOWFISH_CTR,
  98 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
  99
 100 #endif /* defined(POLARSSL_BLOWFISH_C) */
 101
 102 #if defined(POLARSSL_CIPHER_NULL_CIPHER)
 103         POLARSSL_CIPHER_NULL,
 104 #endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
 105
 106         0
 107 };
 108
 109 const int *cipher_list( void )
 110 {
 111     return supported_ciphers;
 112 }
 113
 114 const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type )
 115 {
 116     /* Find static cipher information */
 117     switch ( cipher_type )
 118     {
 119 #if defined(POLARSSL_AES_C)
 120         case POLARSSL_CIPHER_AES_128_CBC:
 121             return &aes_128_cbc_info;
 122         case POLARSSL_CIPHER_AES_192_CBC:
 123             return &aes_192_cbc_info;
 124         case POLARSSL_CIPHER_AES_256_CBC:
 125             return &aes_256_cbc_info;
 126
 127 #if defined(POLARSSL_CIPHER_MODE_CFB)
 128         case POLARSSL_CIPHER_AES_128_CFB128:
 129             return &aes_128_cfb128_info;
 130         case POLARSSL_CIPHER_AES_192_CFB128:
 131             return &aes_192_cfb128_info;
 132         case POLARSSL_CIPHER_AES_256_CFB128:
 133             return &aes_256_cfb128_info;
 134 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 135
 136 #if defined(POLARSSL_CIPHER_MODE_CTR)
 137         case POLARSSL_CIPHER_AES_128_CTR:
 138             return &aes_128_ctr_info;
 139         case POLARSSL_CIPHER_AES_192_CTR:
 140             return &aes_192_ctr_info;
 141         case POLARSSL_CIPHER_AES_256_CTR:
 142             return &aes_256_ctr_info;
 143 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 144
 145 #endif
 146
 147 #if defined(POLARSSL_CAMELLIA_C)
 148         case POLARSSL_CIPHER_CAMELLIA_128_CBC:
 149             return &camellia_128_cbc_info;
 150         case POLARSSL_CIPHER_CAMELLIA_192_CBC:
 151             return &camellia_192_cbc_info;
 152         case POLARSSL_CIPHER_CAMELLIA_256_CBC:
 153             return &camellia_256_cbc_info;
 154
 155 #if defined(POLARSSL_CIPHER_MODE_CFB)
 156         case POLARSSL_CIPHER_CAMELLIA_128_CFB128:
 157             return &camellia_128_cfb128_info;
 158         case POLARSSL_CIPHER_CAMELLIA_192_CFB128:
 159             return &camellia_192_cfb128_info;
 160         case POLARSSL_CIPHER_CAMELLIA_256_CFB128:
 161             return &camellia_256_cfb128_info;
 162 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 163
 164 #if defined(POLARSSL_CIPHER_MODE_CTR)
 165         case POLARSSL_CIPHER_CAMELLIA_128_CTR:
 166             return &camellia_128_ctr_info;
 167         case POLARSSL_CIPHER_CAMELLIA_192_CTR:
 168             return &camellia_192_ctr_info;
 169         case POLARSSL_CIPHER_CAMELLIA_256_CTR:
 170             return &camellia_256_ctr_info;
 171 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 172
 173 #endif
 174
 175 #if defined(POLARSSL_DES_C)
 176         case POLARSSL_CIPHER_DES_CBC:
 177             return &des_cbc_info;
 178         case POLARSSL_CIPHER_DES_EDE_CBC:
 179             return &des_ede_cbc_info;
 180         case POLARSSL_CIPHER_DES_EDE3_CBC:
 181             return &des_ede3_cbc_info;
 182 #endif
 183
 184 #if defined(POLARSSL_BLOWFISH_C)
 185         case POLARSSL_CIPHER_BLOWFISH_CBC:
 186             return &blowfish_cbc_info;
 187
 188 #if defined(POLARSSL_CIPHER_MODE_CFB)
 189         case POLARSSL_CIPHER_BLOWFISH_CFB64:
 190             return &blowfish_cfb64_info;
 191 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 192
 193 #if defined(POLARSSL_CIPHER_MODE_CTR)
 194         case POLARSSL_CIPHER_BLOWFISH_CTR:
 195             return &blowfish_ctr_info;
 196 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 197
 198 #endif
 199
 200 #if defined(POLARSSL_CIPHER_NULL_CIPHER)
 201         case POLARSSL_CIPHER_NULL:
 202             return &null_cipher_info;
 203 #endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
 204
 205         default:
 206             return NULL;
 207     }
 208 }
 209
 210 const cipher_info_t *cipher_info_from_string( const char *cipher_name )
 211 {
 212     if( NULL == cipher_name )
 213         return NULL;
 214
 215     /* Get the appropriate cipher information */
 216 #if defined(POLARSSL_CAMELLIA_C)
 217     if( !strcasecmp( "CAMELLIA-128-CBC", cipher_name ) )
 218         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CBC );
 219     if( !strcasecmp( "CAMELLIA-192-CBC", cipher_name ) )
 220         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CBC );
 221     if( !strcasecmp( "CAMELLIA-256-CBC", cipher_name ) )
 222         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CBC );
 223
 224 #if defined(POLARSSL_CIPHER_MODE_CFB)
 225     if( !strcasecmp( "CAMELLIA-128-CFB128", cipher_name ) )
 226         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CFB128 );
 227     if( !strcasecmp( "CAMELLIA-192-CFB128", cipher_name ) )
 228         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CFB128 );
 229     if( !strcasecmp( "CAMELLIA-256-CFB128", cipher_name ) )
 230         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CFB128 );
 231 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 232
 233 #if defined(POLARSSL_CIPHER_MODE_CTR)
 234     if( !strcasecmp( "CAMELLIA-128-CTR", cipher_name ) )
 235         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CTR );
 236     if( !strcasecmp( "CAMELLIA-192-CTR", cipher_name ) )
 237         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CTR );
 238     if( !strcasecmp( "CAMELLIA-256-CTR", cipher_name ) )
 239         return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CTR );
 240 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 241 #endif
 242
 243 #if defined(POLARSSL_AES_C)
 244     if( !strcasecmp( "AES-128-CBC", cipher_name ) )
 245         return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CBC );
 246     if( !strcasecmp( "AES-192-CBC", cipher_name ) )
 247         return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CBC );
 248     if( !strcasecmp( "AES-256-CBC", cipher_name ) )
 249         return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CBC );
 250
 251 #if defined(POLARSSL_CIPHER_MODE_CFB)
 252     if( !strcasecmp( "AES-128-CFB128", cipher_name ) )
 253         return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CFB128 );
 254     if( !strcasecmp( "AES-192-CFB128", cipher_name ) )
 255         return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CFB128 );
 256     if( !strcasecmp( "AES-256-CFB128", cipher_name ) )
 257         return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CFB128 );
 258 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 259
 260 #if defined(POLARSSL_CIPHER_MODE_CTR)
 261     if( !strcasecmp( "AES-128-CTR", cipher_name ) )
 262         return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CTR );
 263     if( !strcasecmp( "AES-192-CTR", cipher_name ) )
 264         return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CTR );
 265     if( !strcasecmp( "AES-256-CTR", cipher_name ) )
 266         return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CTR );
 267 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 268 #endif
 269
 270 #if defined(POLARSSL_DES_C)
 271     if( !strcasecmp( "DES-CBC", cipher_name ) )
 272         return cipher_info_from_type( POLARSSL_CIPHER_DES_CBC );
 273     if( !strcasecmp( "DES-EDE-CBC", cipher_name ) )
 274         return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE_CBC );
 275     if( !strcasecmp( "DES-EDE3-CBC", cipher_name ) )
 276         return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE3_CBC );
 277 #endif
 278
 279 #if defined(POLARSSL_BLOWFISH_C)
 280     if( !strcasecmp( "BLOWFISH-CBC", cipher_name ) )
 281         return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CBC );
 282
 283 #if defined(POLARSSL_CIPHER_MODE_CFB)
 284     if( !strcasecmp( "BLOWFISH-CFB64", cipher_name ) )
 285         return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CFB64 );
 286 #endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 287
 288 #if defined(POLARSSL_CIPHER_MODE_CTR)
 289     if( !strcasecmp( "BLOWFISH-CTR", cipher_name ) )
 290         return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CTR );
 291 #endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 292 #endif
 293
 294 #if defined(POLARSSL_CIPHER_NULL_CIPHER)
 295     if( !strcasecmp( "NULL", cipher_name ) )
 296         return cipher_info_from_type( POLARSSL_CIPHER_NULL );
 297 #endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
 298
 299     return NULL;
 300 }
 301
 302 int cipher_init_ctx( cipher_context_t *ctx, const cipher_info_t *cipher_info )
 303 {
 304     if( NULL == cipher_info || NULL == ctx )
 305         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 306
 307     memset( ctx, 0, sizeof( cipher_context_t ) );
 308
 309     if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
 310         return POLARSSL_ERR_CIPHER_ALLOC_FAILED;
 311
 312     ctx->cipher_info = cipher_info;
 313
 314     return 0;
 315 }
 316
 317 int cipher_free_ctx( cipher_context_t *ctx )
 318 {
 319     if( ctx == NULL || ctx->cipher_info == NULL )
 320         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 321
 322     ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
 323
 324     return 0;
 325 }
 326
 327 int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
 328         int key_length, const operation_t operation )
 329 {
 330     if( NULL == ctx || NULL == ctx->cipher_info )
 331         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 332
 333     ctx->key_length = key_length;
 334     ctx->operation = operation;
 335
 336 #if defined(POLARSSL_CIPHER_NULL_CIPHER)
 337     if( ctx->cipher_info->mode == POLARSSL_MODE_NULL )
 338         return 0;
 339 #endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
 340
 341     /*
 342      * For CFB and CTR mode always use the encryption key schedule
 343      */
 344     if( POLARSSL_ENCRYPT == operation ||
 345         POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
 346         POLARSSL_MODE_CTR == ctx->cipher_info->mode )
 347     {
 348         return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
 349                 ctx->key_length );
 350     }
 351
 352     if( POLARSSL_DECRYPT == operation )
 353         return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
 354                 ctx->key_length );
 355
 356     return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 357 }
 358
 359 int cipher_reset( cipher_context_t *ctx, const unsigned char *iv )
 360 {
 361     if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
 362         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 363
 364     ctx->unprocessed_len = 0;
 365
 366     memcpy( ctx->iv, iv, cipher_get_iv_size( ctx ) );
 367
 368     return 0;
 369 }
 370
 371 int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ilen,
 372         unsigned char *output, size_t *olen )
 373 {
 374     int ret;
 375     size_t copy_len = 0;
 376
 377     if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen ||
 378         input == output )
 379     {
 380         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 381     }
 382
 383     *olen = 0;
 384
 385 #if defined(POLARSSL_CIPHER_NULL_CIPHER)
 386     if( ctx->cipher_info->mode == POLARSSL_MODE_NULL )
 387     {
 388         memcpy( output, input, ilen );
 389         *olen = ilen;
 390         return 0;
 391     }
 392 #endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
 393
 394     if( ctx->cipher_info->mode == POLARSSL_MODE_CBC )
 395     {
 396         /*
 397          * If there is not enough data for a full block, cache it.
 398          */
 399         if( ( ctx->operation == POLARSSL_DECRYPT &&
 400                 ilen + ctx->unprocessed_len <= cipher_get_block_size( ctx ) ) ||
 401              ( ctx->operation == POLARSSL_ENCRYPT &&
 402                 ilen + ctx->unprocessed_len < cipher_get_block_size( ctx ) ) )
 403         {
 404             memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
 405                     ilen );
 406
 407             ctx->unprocessed_len += ilen;
 408             return 0;
 409         }
 410
 411         /*
 412          * Process cached data first
 413          */
 414         if( ctx->unprocessed_len != 0 )
 415         {
 416             copy_len = cipher_get_block_size( ctx ) - ctx->unprocessed_len;
 417
 418             memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
 419                     copy_len );
 420
 421             if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 422                     ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
 423                     ctx->unprocessed_data, output ) ) )
 424             {
 425                 return ret;
 426             }
 427
 428             *olen += cipher_get_block_size( ctx );
 429             output += cipher_get_block_size( ctx );
 430             ctx->unprocessed_len = 0;
 431
 432             input += copy_len;
 433             ilen -= copy_len;
 434         }
 435
 436         /*
 437          * Cache final, incomplete block
 438          */
 439         if( 0 != ilen )
 440         {
 441             copy_len = ilen % cipher_get_block_size( ctx );
 442             if( copy_len == 0 && ctx->operation == POLARSSL_DECRYPT )
 443                 copy_len = cipher_get_block_size(ctx);
 444
 445             memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
 446                     copy_len );
 447
 448             ctx->unprocessed_len += copy_len;
 449             ilen -= copy_len;
 450         }
 451
 452         /*
 453          * Process remaining full blocks
 454          */
 455         if( ilen )
 456         {
 457             if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 458                     ctx->operation, ilen, ctx->iv, input, output ) ) )
 459             {
 460                 return ret;
 461             }
 462             *olen += ilen;
 463         }
 464
 465         return 0;
 466     }
 467
 468     if( ctx->cipher_info->mode == POLARSSL_MODE_CFB )
 469     {
 470         if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
 471                 ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
 472                 input, output ) ) )
 473         {
 474             return ret;
 475         }
 476
 477         *olen = ilen;
 478
 479         return 0;
 480     }
 481
 482     if( ctx->cipher_info->mode == POLARSSL_MODE_CTR )
 483     {
 484         if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
 485                 ilen, &ctx->unprocessed_len, ctx->iv,
 486                 ctx->unprocessed_data, input, output ) ) )
 487         {
 488             return ret;
 489         }
 490
 491         *olen = ilen;
 492
 493         return 0;
 494     }
 495
 496     return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
 497 }
 498
 499 static void add_pkcs_padding( unsigned char *output, size_t output_len,
 500         size_t data_len )
 501 {
 502     size_t padding_len = output_len - data_len;
 503     unsigned char i = 0;
 504
 505     for( i = 0; i < padding_len; i++ )
 506         output[data_len + i] = (unsigned char) padding_len;
 507 }
 508
 509 static int get_pkcs_padding( unsigned char *input, unsigned int input_len,
 510         size_t *data_len)
 511 {
 512     unsigned int i, padding_len = 0;
 513
 514     if( NULL == input || NULL == data_len )
 515         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 516
 517     padding_len = input[input_len - 1];
 518
 519     if( padding_len > input_len )
 520         return POLARSSL_ERR_CIPHER_INVALID_PADDING;
 521
 522     for( i = input_len - padding_len; i < input_len; i++ )
 523         if( input[i] != padding_len )
 524             return POLARSSL_ERR_CIPHER_INVALID_PADDING;
 525
 526     *data_len = input_len - padding_len;
 527
 528     return 0;
 529 }
 530
 531 int cipher_finish( cipher_context_t *ctx, unsigned char *output, size_t *olen)
 532 {
 533     int ret = 0;
 534
 535     if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
 536         return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 537
 538     *olen = 0;
 539
 540     if( POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
 541         POLARSSL_MODE_CTR == ctx->cipher_info->mode ||
 542         POLARSSL_MODE_NULL == ctx->cipher_info->mode )
 543     {
 544         return 0;
 545     }
 546
 547     if( POLARSSL_MODE_CBC == ctx->cipher_info->mode )
 548     {
 549         if( POLARSSL_ENCRYPT == ctx->operation )
 550         {
 551             add_pkcs_padding( ctx->unprocessed_data, cipher_get_iv_size( ctx ),
 552                     ctx->unprocessed_len );
 553         }
 554         else if ( cipher_get_block_size( ctx ) != ctx->unprocessed_len )
 555         {
 556             /* For decrypt operations, expect a full block */
 557             return POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED;
 558         }
 559
 560         /* cipher block */
 561         if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 562                 ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
 563                 ctx->unprocessed_data, output ) ) )
 564         {
 565             return ret;
 566         }
 567
 568         /* Set output size for decryption */
 569         if( POLARSSL_DECRYPT == ctx->operation )
 570             return get_pkcs_padding( output, cipher_get_block_size( ctx ), olen );
 571
 572         /* Set output size for encryption */
 573         *olen = cipher_get_block_size( ctx );
 574         return 0;
 575     }
 576
 577     return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
 578 }
 579
 580 #if defined(POLARSSL_SELF_TEST)
 581
 582 #include <stdio.h>
 583
 584 #define ASSERT(x) if (!(x)) { \
 585         printf( "failed with %i at %s\n", value, (#x) ); \
 586     return( 1 ); \
 587 }
 588 /*
 589  * Checkup routine
 590  */
 591
 592 int cipher_self_test( int verbose )
 593 {
 594     ((void) verbose);
 595
 596     return( 0 );
 597 }
 598
 599 #endif
 600
 601 #endif