← Back to branch summary

~cpick/mongrel2/release

« back to all changes in this revision

Viewing changes to src/polarssl/cipher.c

  • Committer: Chris Pick
  • Date: 2013-06-30 16:39:57 UTC
  • mfrom: (1106.1.15)
  • Revision ID: git-v1:ec39967acb6bc9867ed9b9dc3774304ca6b9c294
Merge tag 'v1.8.1' into debian

Hotfix for github issue 148

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/polarssl/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-2010, 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 "polarssl/config.h"
 
31
 
 
32
#if defined(POLARSSL_CIPHER_C)
 
33
 
 
34
#include "polarssl/cipher.h"
 
35
#include "polarssl/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
        0
 
90
};
 
91
 
 
92
const int *cipher_list( void )
 
93
{
 
94
    return supported_ciphers;
 
95
}
 
96
 
 
97
const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type )
 
98
{
 
99
    /* Find static cipher information */
 
100
    switch ( cipher_type )
 
101
    {
 
102
#if defined(POLARSSL_AES_C)
 
103
        case POLARSSL_CIPHER_AES_128_CBC:
 
104
            return &aes_128_cbc_info;
 
105
        case POLARSSL_CIPHER_AES_192_CBC:
 
106
            return &aes_192_cbc_info;
 
107
        case POLARSSL_CIPHER_AES_256_CBC:
 
108
            return &aes_256_cbc_info;
 
109
 
 
110
#if defined(POLARSSL_CIPHER_MODE_CFB)
 
111
        case POLARSSL_CIPHER_AES_128_CFB128:
 
112
            return &aes_128_cfb128_info;
 
113
        case POLARSSL_CIPHER_AES_192_CFB128:
 
114
            return &aes_192_cfb128_info;
 
115
        case POLARSSL_CIPHER_AES_256_CFB128:
 
116
            return &aes_256_cfb128_info;
 
117
#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 
118
 
 
119
#if defined(POLARSSL_CIPHER_MODE_CTR)
 
120
        case POLARSSL_CIPHER_AES_128_CTR:
 
121
            return &aes_128_ctr_info;
 
122
        case POLARSSL_CIPHER_AES_192_CTR:
 
123
            return &aes_192_ctr_info;
 
124
        case POLARSSL_CIPHER_AES_256_CTR:
 
125
            return &aes_256_ctr_info;
 
126
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 
127
 
 
128
#endif
 
129
 
 
130
#if defined(POLARSSL_CAMELLIA_C)
 
131
        case POLARSSL_CIPHER_CAMELLIA_128_CBC:
 
132
            return &camellia_128_cbc_info;
 
133
        case POLARSSL_CIPHER_CAMELLIA_192_CBC:
 
134
            return &camellia_192_cbc_info;
 
135
        case POLARSSL_CIPHER_CAMELLIA_256_CBC:
 
136
            return &camellia_256_cbc_info;
 
137
 
 
138
#if defined(POLARSSL_CIPHER_MODE_CFB)
 
139
        case POLARSSL_CIPHER_CAMELLIA_128_CFB128:
 
140
            return &camellia_128_cfb128_info;
 
141
        case POLARSSL_CIPHER_CAMELLIA_192_CFB128:
 
142
            return &camellia_192_cfb128_info;
 
143
        case POLARSSL_CIPHER_CAMELLIA_256_CFB128:
 
144
            return &camellia_256_cfb128_info;
 
145
#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 
146
 
 
147
#if defined(POLARSSL_CIPHER_MODE_CTR)
 
148
        case POLARSSL_CIPHER_CAMELLIA_128_CTR:
 
149
            return &camellia_128_ctr_info;
 
150
        case POLARSSL_CIPHER_CAMELLIA_192_CTR:
 
151
            return &camellia_192_ctr_info;
 
152
        case POLARSSL_CIPHER_CAMELLIA_256_CTR:
 
153
            return &camellia_256_ctr_info;
 
154
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 
155
 
 
156
#endif
 
157
 
 
158
#if defined(POLARSSL_DES_C)
 
159
        case POLARSSL_CIPHER_DES_CBC:
 
160
            return &des_cbc_info;
 
161
        case POLARSSL_CIPHER_DES_EDE_CBC:
 
162
            return &des_ede_cbc_info;
 
163
        case POLARSSL_CIPHER_DES_EDE3_CBC:
 
164
            return &des_ede3_cbc_info;
 
165
#endif
 
166
 
 
167
        default:
 
168
            return NULL;
 
169
    }
 
170
}
 
171
 
 
172
const cipher_info_t *cipher_info_from_string( const char *cipher_name )
 
173
{
 
174
    if( NULL == cipher_name )
 
175
        return NULL;
 
176
 
 
177
    /* Get the appropriate cipher information */
 
178
#if defined(POLARSSL_CAMELLIA_C)
 
179
    if( !strcasecmp( "CAMELLIA-128-CBC", cipher_name ) )
 
180
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CBC );
 
181
    if( !strcasecmp( "CAMELLIA-192-CBC", cipher_name ) )
 
182
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CBC );
 
183
    if( !strcasecmp( "CAMELLIA-256-CBC", cipher_name ) )
 
184
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CBC );
 
185
 
 
186
#if defined(POLARSSL_CIPHER_MODE_CFB)
 
187
    if( !strcasecmp( "CAMELLIA-128-CFB128", cipher_name ) )
 
188
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CFB128 );
 
189
    if( !strcasecmp( "CAMELLIA-192-CFB128", cipher_name ) )
 
190
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CFB128 );
 
191
    if( !strcasecmp( "CAMELLIA-256-CFB128", cipher_name ) )
 
192
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CFB128 );
 
193
#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 
194
 
 
195
#if defined(POLARSSL_CIPHER_MODE_CTR)
 
196
    if( !strcasecmp( "CAMELLIA-128-CTR", cipher_name ) )
 
197
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CTR );
 
198
    if( !strcasecmp( "CAMELLIA-192-CTR", cipher_name ) )
 
199
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CTR );
 
200
    if( !strcasecmp( "CAMELLIA-256-CTR", cipher_name ) )
 
201
        return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CTR );
 
202
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 
203
#endif
 
204
 
 
205
#if defined(POLARSSL_AES_C)
 
206
    if( !strcasecmp( "AES-128-CBC", cipher_name ) )
 
207
        return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CBC );
 
208
    if( !strcasecmp( "AES-192-CBC", cipher_name ) )
 
209
        return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CBC );
 
210
    if( !strcasecmp( "AES-256-CBC", cipher_name ) )
 
211
        return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CBC );
 
212
 
 
213
#if defined(POLARSSL_CIPHER_MODE_CFB)
 
214
    if( !strcasecmp( "AES-128-CFB128", cipher_name ) )
 
215
        return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CFB128 );
 
216
    if( !strcasecmp( "AES-192-CFB128", cipher_name ) )
 
217
        return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CFB128 );
 
218
    if( !strcasecmp( "AES-256-CFB128", cipher_name ) )
 
219
        return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CFB128 );
 
220
#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
 
221
 
 
222
#if defined(POLARSSL_CIPHER_MODE_CTR)
 
223
    if( !strcasecmp( "AES-128-CTR", cipher_name ) )
 
224
        return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CTR );
 
225
    if( !strcasecmp( "AES-192-CTR", cipher_name ) )
 
226
        return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CTR );
 
227
    if( !strcasecmp( "AES-256-CTR", cipher_name ) )
 
228
        return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CTR );
 
229
#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
 
230
#endif
 
231
 
 
232
#if defined(POLARSSL_DES_C)
 
233
    if( !strcasecmp( "DES-CBC", cipher_name ) )
 
234
        return cipher_info_from_type( POLARSSL_CIPHER_DES_CBC );
 
235
    if( !strcasecmp( "DES-EDE-CBC", cipher_name ) )
 
236
        return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE_CBC );
 
237
    if( !strcasecmp( "DES-EDE3-CBC", cipher_name ) )
 
238
        return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE3_CBC );
 
239
#endif
 
240
    return NULL;
 
241
}
 
242
 
 
243
int cipher_init_ctx( cipher_context_t *ctx, const cipher_info_t *cipher_info )
 
244
{
 
245
    if( NULL == cipher_info || NULL == ctx )
 
246
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
247
 
 
248
    memset( ctx, 0, sizeof *ctx );
 
249
 
 
250
    if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
 
251
        return POLARSSL_ERR_CIPHER_ALLOC_FAILED;
 
252
 
 
253
    ctx->cipher_info = cipher_info;
 
254
 
 
255
    return 0;
 
256
}
 
257
 
 
258
int cipher_free_ctx( cipher_context_t *ctx )
 
259
{
 
260
    if( ctx == NULL || ctx->cipher_info == NULL )
 
261
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
262
 
 
263
    ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
 
264
 
 
265
    return 0;
 
266
}
 
267
 
 
268
int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
 
269
        int key_length, const operation_t operation )
 
270
{
 
271
    if( NULL == ctx || NULL == ctx->cipher_info )
 
272
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
273
 
 
274
    ctx->key_length = key_length;
 
275
    ctx->operation = operation;
 
276
 
 
277
    /*
 
278
     * For CFB128 and CTR mode always use the encryption key schedule
 
279
     */
 
280
    if( POLARSSL_ENCRYPT == operation ||
 
281
        POLARSSL_MODE_CFB128 == ctx->cipher_info->mode ||
 
282
        POLARSSL_MODE_CTR == ctx->cipher_info->mode )
 
283
    {
 
284
        return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
 
285
                ctx->key_length );
 
286
    }
 
287
 
 
288
    if( POLARSSL_DECRYPT == operation )
 
289
        return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
 
290
                ctx->key_length );
 
291
 
 
292
    return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
293
}
 
294
 
 
295
int cipher_reset( cipher_context_t *ctx, const unsigned char *iv )
 
296
{
 
297
    if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
 
298
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
299
 
 
300
    ctx->unprocessed_len = 0;
 
301
 
 
302
    memcpy( ctx->iv, iv, cipher_get_iv_size( ctx ) );
 
303
 
 
304
    return 0;
 
305
}
 
306
 
 
307
int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ilen,
 
308
        unsigned char *output, size_t *olen )
 
309
{
 
310
    int ret;
 
311
    size_t copy_len = 0;
 
312
 
 
313
    if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen ||
 
314
        input == output )
 
315
    {
 
316
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
317
    }
 
318
 
 
319
    *olen = 0;
 
320
 
 
321
    if( ctx->cipher_info->mode == POLARSSL_MODE_CBC )
 
322
    {
 
323
        /*
 
324
         * If there is not enough data for a full block, cache it.
 
325
         */
 
326
        if( ( ctx->operation == POLARSSL_DECRYPT &&
 
327
                ilen + ctx->unprocessed_len <= cipher_get_block_size( ctx ) ) ||
 
328
             ( ctx->operation == POLARSSL_ENCRYPT &&
 
329
                ilen + ctx->unprocessed_len < cipher_get_block_size( ctx ) ) )
 
330
        {
 
331
            memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
 
332
                    ilen );
 
333
 
 
334
            ctx->unprocessed_len += ilen;
 
335
            return 0;
 
336
        }
 
337
 
 
338
        /*
 
339
         * Process cached data first
 
340
         */
 
341
        if( ctx->unprocessed_len != 0 )
 
342
        {
 
343
            copy_len = cipher_get_block_size( ctx ) - ctx->unprocessed_len;
 
344
 
 
345
            memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
 
346
                    copy_len );
 
347
 
 
348
            if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 
349
                    ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
 
350
                    ctx->unprocessed_data, output ) ) )
 
351
            {
 
352
                return ret;
 
353
            }
 
354
 
 
355
            *olen += cipher_get_block_size( ctx );
 
356
            output += cipher_get_block_size( ctx );
 
357
            ctx->unprocessed_len = 0;
 
358
 
 
359
            input += copy_len;
 
360
            ilen -= copy_len;
 
361
        }
 
362
 
 
363
        /*
 
364
         * Cache final, incomplete block
 
365
         */
 
366
        if( 0 != ilen )
 
367
        {
 
368
            copy_len = ilen % cipher_get_block_size( ctx );
 
369
            if( copy_len == 0 && ctx->operation == POLARSSL_DECRYPT )
 
370
                copy_len = cipher_get_block_size(ctx);
 
371
 
 
372
            memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
 
373
                    copy_len );
 
374
 
 
375
            ctx->unprocessed_len += copy_len;
 
376
            ilen -= copy_len;
 
377
        }
 
378
 
 
379
        /*
 
380
         * Process remaining full blocks
 
381
         */
 
382
        if( ilen )
 
383
        {
 
384
            if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 
385
                    ctx->operation, ilen, ctx->iv, input, output ) ) )
 
386
            {
 
387
                return ret;
 
388
            }
 
389
            *olen += ilen;
 
390
        }
 
391
 
 
392
        return 0;
 
393
    }
 
394
 
 
395
    if( ctx->cipher_info->mode == POLARSSL_MODE_CFB128 )
 
396
    {
 
397
        if( 0 != ( ret = ctx->cipher_info->base->cfb128_func( ctx->cipher_ctx,
 
398
                ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
 
399
                input, output ) ) )
 
400
        {
 
401
            return ret;
 
402
        }
 
403
 
 
404
        *olen = ilen;
 
405
 
 
406
        return 0;
 
407
    }
 
408
 
 
409
    if( ctx->cipher_info->mode == POLARSSL_MODE_CTR )
 
410
    {
 
411
        if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
 
412
                ilen, &ctx->unprocessed_len, ctx->iv,
 
413
                ctx->unprocessed_data, input, output ) ) )
 
414
        {
 
415
            return ret;
 
416
        }
 
417
 
 
418
        *olen = ilen;
 
419
 
 
420
        return 0;
 
421
    }
 
422
 
 
423
    return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
 
424
}
 
425
 
 
426
static void add_pkcs_padding( unsigned char *output, size_t output_len,
 
427
        size_t data_len )
 
428
{
 
429
    size_t padding_len = output_len - data_len;
 
430
    unsigned char i = 0;
 
431
 
 
432
    for( i = 0; i < padding_len; i++ )
 
433
        output[data_len + i] = (unsigned char) padding_len;
 
434
}
 
435
 
 
436
static int get_pkcs_padding( unsigned char *input, unsigned int input_len,
 
437
        size_t *data_len)
 
438
{
 
439
    unsigned int i, padding_len = 0;
 
440
 
 
441
    if( NULL == input || NULL == data_len )
 
442
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
443
 
 
444
    padding_len = input[input_len - 1];
 
445
 
 
446
    if( padding_len > input_len )
 
447
        return POLARSSL_ERR_CIPHER_INVALID_PADDING;
 
448
 
 
449
    for( i = input_len - padding_len; i < input_len; i++ )
 
450
        if( input[i] != padding_len )
 
451
            return POLARSSL_ERR_CIPHER_INVALID_PADDING;
 
452
 
 
453
    *data_len = input_len - padding_len;
 
454
 
 
455
    return 0;
 
456
}
 
457
 
 
458
int cipher_finish( cipher_context_t *ctx, unsigned char *output, size_t *olen)
 
459
{
 
460
    int ret = 0;
 
461
 
 
462
    if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
 
463
        return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
 
464
 
 
465
    *olen = 0;
 
466
 
 
467
    if( POLARSSL_MODE_CFB128 == ctx->cipher_info->mode ||
 
468
        POLARSSL_MODE_CTR == ctx->cipher_info->mode )
 
469
    {
 
470
        return 0;
 
471
    }
 
472
 
 
473
    if( POLARSSL_MODE_CBC == ctx->cipher_info->mode )
 
474
    {
 
475
        if( POLARSSL_ENCRYPT == ctx->operation )
 
476
        {
 
477
            add_pkcs_padding( ctx->unprocessed_data, cipher_get_iv_size( ctx ),
 
478
                    ctx->unprocessed_len );
 
479
        }
 
480
        else if ( cipher_get_block_size( ctx ) != ctx->unprocessed_len )
 
481
        {
 
482
            /* For decrypt operations, expect a full block */
 
483
            return POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED;
 
484
        }
 
485
 
 
486
        /* cipher block */
 
487
        if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
 
488
                ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
 
489
                ctx->unprocessed_data, output ) ) )
 
490
        {
 
491
            return ret;
 
492
        }
 
493
 
 
494
        /* Set output size for decryption */
 
495
        if( POLARSSL_DECRYPT == ctx->operation )
 
496
            return get_pkcs_padding( output, cipher_get_block_size( ctx ), olen );
 
497
 
 
498
        /* Set output size for encryption */
 
499
        *olen = cipher_get_block_size( ctx );
 
500
        return 0;
 
501
    }
 
502
 
 
503
    return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
 
504
}
 
505
 
 
506
#if defined(POLARSSL_SELF_TEST)
 
507
 
 
508
#include <stdio.h>
 
509
 
 
510
#define ASSERT(x) if (!(x)) { \
 
511
        printf( "failed with %i at %s\n", value, (#x) ); \
 
512
    return( 1 ); \
 
513
}
 
514
/*
 
515
 * Checkup routine
 
516
 */
 
517
 
 
518
int cipher_self_test( int verbose )
 
519
{
 
520
    ((void) verbose);
 
521
 
 
522
    return( 0 );
 
523
}
 
524
 
 
525
#endif
 
526
 
 
527
#endif