blob: a5f6e118600ce259c2cfed28a3cc1926686eb955 [file] [log] [blame]
Paul Bakker8123e9d2011-01-06 15:37:30 +00001/**
2 * \file cipher.c
3 *
4 * \brief Generic cipher wrapper for PolarSSL
5 *
6 * \author Adriaan de Jong <dejong@fox-it.com>
7 *
Paul Bakker68884e32013-01-07 18:20:04 +01008 * Copyright (C) 2006-2013, Brainspark B.V.
Paul Bakker8123e9d2011-01-06 15:37:30 +00009 *
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
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +020037#if defined(POLARSSL_GCM_C)
38#include "polarssl/gcm.h"
39#endif
40
Paul Bakker8123e9d2011-01-06 15:37:30 +000041#include <stdlib.h>
42
Manuel Pégourié-Gonnardb5e85882013-08-28 16:36:14 +020043#if defined(POLARSSL_ARC4_C) || defined(POLARSSL_CIPHER_NULL_CIPHER)
Manuel Pégourié-Gonnard37e230c2013-08-28 13:50:42 +020044#define POLARSSL_CIPHER_MODE_STREAM
45#endif
46
Paul Bakkeraf5c85f2011-04-18 03:47:52 +000047#if defined _MSC_VER && !defined strcasecmp
48#define strcasecmp _stricmp
49#endif
50
Paul Bakker72f62662011-01-16 21:27:44 +000051static const int supported_ciphers[] = {
52
53#if defined(POLARSSL_AES_C)
54 POLARSSL_CIPHER_AES_128_CBC,
55 POLARSSL_CIPHER_AES_192_CBC,
56 POLARSSL_CIPHER_AES_256_CBC,
Paul Bakker343a8702011-06-09 14:27:58 +000057
58#if defined(POLARSSL_CIPHER_MODE_CFB)
59 POLARSSL_CIPHER_AES_128_CFB128,
60 POLARSSL_CIPHER_AES_192_CFB128,
61 POLARSSL_CIPHER_AES_256_CFB128,
62#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
63
64#if defined(POLARSSL_CIPHER_MODE_CTR)
65 POLARSSL_CIPHER_AES_128_CTR,
66 POLARSSL_CIPHER_AES_192_CTR,
67 POLARSSL_CIPHER_AES_256_CTR,
68#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
69
Paul Bakker72f62662011-01-16 21:27:44 +000070#endif /* defined(POLARSSL_AES_C) */
71
Manuel Pégourié-Gonnard37e230c2013-08-28 13:50:42 +020072#if defined(POLARSSL_ARC4_C)
73 POLARSSL_CIPHER_ARC4_128,
74#endif
75
Paul Bakker72f62662011-01-16 21:27:44 +000076#if defined(POLARSSL_CAMELLIA_C)
77 POLARSSL_CIPHER_CAMELLIA_128_CBC,
78 POLARSSL_CIPHER_CAMELLIA_192_CBC,
79 POLARSSL_CIPHER_CAMELLIA_256_CBC,
Paul Bakker343a8702011-06-09 14:27:58 +000080
81#if defined(POLARSSL_CIPHER_MODE_CFB)
82 POLARSSL_CIPHER_CAMELLIA_128_CFB128,
83 POLARSSL_CIPHER_CAMELLIA_192_CFB128,
84 POLARSSL_CIPHER_CAMELLIA_256_CFB128,
85#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
86
87#if defined(POLARSSL_CIPHER_MODE_CTR)
88 POLARSSL_CIPHER_CAMELLIA_128_CTR,
89 POLARSSL_CIPHER_CAMELLIA_192_CTR,
90 POLARSSL_CIPHER_CAMELLIA_256_CTR,
91#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
92
Paul Bakker72f62662011-01-16 21:27:44 +000093#endif /* defined(POLARSSL_CAMELLIA_C) */
94
95#if defined(POLARSSL_DES_C)
96 POLARSSL_CIPHER_DES_CBC,
97 POLARSSL_CIPHER_DES_EDE_CBC,
98 POLARSSL_CIPHER_DES_EDE3_CBC,
99#endif /* defined(POLARSSL_DES_C) */
100
Paul Bakker6132d0a2012-07-04 17:10:40 +0000101#if defined(POLARSSL_BLOWFISH_C)
102 POLARSSL_CIPHER_BLOWFISH_CBC,
103
104#if defined(POLARSSL_CIPHER_MODE_CFB)
105 POLARSSL_CIPHER_BLOWFISH_CFB64,
106#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
107
108#if defined(POLARSSL_CIPHER_MODE_CTR)
109 POLARSSL_CIPHER_BLOWFISH_CTR,
110#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
111
112#endif /* defined(POLARSSL_BLOWFISH_C) */
113
Paul Bakkerfab5c822012-02-06 16:45:10 +0000114#if defined(POLARSSL_CIPHER_NULL_CIPHER)
115 POLARSSL_CIPHER_NULL,
116#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
117
Paul Bakker72f62662011-01-16 21:27:44 +0000118 0
119};
120
121const int *cipher_list( void )
122{
123 return supported_ciphers;
124}
125
Paul Bakkerec1b9842012-01-14 18:24:43 +0000126const cipher_info_t *cipher_info_from_type( const cipher_type_t cipher_type )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000127{
128 /* Find static cipher information */
129 switch ( cipher_type )
130 {
131#if defined(POLARSSL_AES_C)
132 case POLARSSL_CIPHER_AES_128_CBC:
133 return &aes_128_cbc_info;
134 case POLARSSL_CIPHER_AES_192_CBC:
135 return &aes_192_cbc_info;
136 case POLARSSL_CIPHER_AES_256_CBC:
137 return &aes_256_cbc_info;
Paul Bakker343a8702011-06-09 14:27:58 +0000138
139#if defined(POLARSSL_CIPHER_MODE_CFB)
140 case POLARSSL_CIPHER_AES_128_CFB128:
141 return &aes_128_cfb128_info;
142 case POLARSSL_CIPHER_AES_192_CFB128:
143 return &aes_192_cfb128_info;
144 case POLARSSL_CIPHER_AES_256_CFB128:
145 return &aes_256_cfb128_info;
146#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
147
148#if defined(POLARSSL_CIPHER_MODE_CTR)
149 case POLARSSL_CIPHER_AES_128_CTR:
150 return &aes_128_ctr_info;
151 case POLARSSL_CIPHER_AES_192_CTR:
152 return &aes_192_ctr_info;
153 case POLARSSL_CIPHER_AES_256_CTR:
154 return &aes_256_ctr_info;
155#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
156
Paul Bakker68884e32013-01-07 18:20:04 +0100157#if defined(POLARSSL_GCM_C)
158 case POLARSSL_CIPHER_AES_128_GCM:
159 return &aes_128_gcm_info;
160 case POLARSSL_CIPHER_AES_256_GCM:
161 return &aes_256_gcm_info;
162#endif /* defined(POLARSSL_GCM_C) */
163
Paul Bakker8123e9d2011-01-06 15:37:30 +0000164#endif
165
166#if defined(POLARSSL_CAMELLIA_C)
167 case POLARSSL_CIPHER_CAMELLIA_128_CBC:
168 return &camellia_128_cbc_info;
169 case POLARSSL_CIPHER_CAMELLIA_192_CBC:
170 return &camellia_192_cbc_info;
171 case POLARSSL_CIPHER_CAMELLIA_256_CBC:
172 return &camellia_256_cbc_info;
Paul Bakker343a8702011-06-09 14:27:58 +0000173
174#if defined(POLARSSL_CIPHER_MODE_CFB)
175 case POLARSSL_CIPHER_CAMELLIA_128_CFB128:
176 return &camellia_128_cfb128_info;
177 case POLARSSL_CIPHER_CAMELLIA_192_CFB128:
178 return &camellia_192_cfb128_info;
179 case POLARSSL_CIPHER_CAMELLIA_256_CFB128:
180 return &camellia_256_cfb128_info;
181#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
182
183#if defined(POLARSSL_CIPHER_MODE_CTR)
184 case POLARSSL_CIPHER_CAMELLIA_128_CTR:
185 return &camellia_128_ctr_info;
186 case POLARSSL_CIPHER_CAMELLIA_192_CTR:
187 return &camellia_192_ctr_info;
188 case POLARSSL_CIPHER_CAMELLIA_256_CTR:
189 return &camellia_256_ctr_info;
190#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
191
Paul Bakker8123e9d2011-01-06 15:37:30 +0000192#endif
193
194#if defined(POLARSSL_DES_C)
195 case POLARSSL_CIPHER_DES_CBC:
196 return &des_cbc_info;
197 case POLARSSL_CIPHER_DES_EDE_CBC:
198 return &des_ede_cbc_info;
199 case POLARSSL_CIPHER_DES_EDE3_CBC:
200 return &des_ede3_cbc_info;
201#endif
202
Paul Bakker68884e32013-01-07 18:20:04 +0100203#if defined(POLARSSL_ARC4_C)
204 case POLARSSL_CIPHER_ARC4_128:
205 return &arc4_128_info;
206#endif
207
Paul Bakker6132d0a2012-07-04 17:10:40 +0000208#if defined(POLARSSL_BLOWFISH_C)
209 case POLARSSL_CIPHER_BLOWFISH_CBC:
210 return &blowfish_cbc_info;
211
212#if defined(POLARSSL_CIPHER_MODE_CFB)
213 case POLARSSL_CIPHER_BLOWFISH_CFB64:
214 return &blowfish_cfb64_info;
215#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
216
217#if defined(POLARSSL_CIPHER_MODE_CTR)
218 case POLARSSL_CIPHER_BLOWFISH_CTR:
219 return &blowfish_ctr_info;
220#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
221
222#endif
223
Paul Bakkerfab5c822012-02-06 16:45:10 +0000224#if defined(POLARSSL_CIPHER_NULL_CIPHER)
225 case POLARSSL_CIPHER_NULL:
226 return &null_cipher_info;
227#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
228
Paul Bakker8123e9d2011-01-06 15:37:30 +0000229 default:
230 return NULL;
231 }
232}
233
234const cipher_info_t *cipher_info_from_string( const char *cipher_name )
235{
236 if( NULL == cipher_name )
237 return NULL;
238
Paul Bakker343a8702011-06-09 14:27:58 +0000239 /* Get the appropriate cipher information */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000240#if defined(POLARSSL_CAMELLIA_C)
241 if( !strcasecmp( "CAMELLIA-128-CBC", cipher_name ) )
242 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CBC );
243 if( !strcasecmp( "CAMELLIA-192-CBC", cipher_name ) )
244 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CBC );
245 if( !strcasecmp( "CAMELLIA-256-CBC", cipher_name ) )
246 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CBC );
Paul Bakker343a8702011-06-09 14:27:58 +0000247
248#if defined(POLARSSL_CIPHER_MODE_CFB)
249 if( !strcasecmp( "CAMELLIA-128-CFB128", cipher_name ) )
250 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CFB128 );
251 if( !strcasecmp( "CAMELLIA-192-CFB128", cipher_name ) )
252 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CFB128 );
253 if( !strcasecmp( "CAMELLIA-256-CFB128", cipher_name ) )
254 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CFB128 );
255#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
256
257#if defined(POLARSSL_CIPHER_MODE_CTR)
258 if( !strcasecmp( "CAMELLIA-128-CTR", cipher_name ) )
259 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_128_CTR );
260 if( !strcasecmp( "CAMELLIA-192-CTR", cipher_name ) )
261 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_192_CTR );
262 if( !strcasecmp( "CAMELLIA-256-CTR", cipher_name ) )
263 return cipher_info_from_type( POLARSSL_CIPHER_CAMELLIA_256_CTR );
264#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000265#endif
Paul Bakker343a8702011-06-09 14:27:58 +0000266
Paul Bakker8123e9d2011-01-06 15:37:30 +0000267#if defined(POLARSSL_AES_C)
268 if( !strcasecmp( "AES-128-CBC", cipher_name ) )
269 return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CBC );
270 if( !strcasecmp( "AES-192-CBC", cipher_name ) )
271 return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CBC );
272 if( !strcasecmp( "AES-256-CBC", cipher_name ) )
273 return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CBC );
Paul Bakker343a8702011-06-09 14:27:58 +0000274
275#if defined(POLARSSL_CIPHER_MODE_CFB)
276 if( !strcasecmp( "AES-128-CFB128", cipher_name ) )
277 return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CFB128 );
278 if( !strcasecmp( "AES-192-CFB128", cipher_name ) )
279 return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CFB128 );
280 if( !strcasecmp( "AES-256-CFB128", cipher_name ) )
281 return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CFB128 );
282#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
283
284#if defined(POLARSSL_CIPHER_MODE_CTR)
285 if( !strcasecmp( "AES-128-CTR", cipher_name ) )
286 return cipher_info_from_type( POLARSSL_CIPHER_AES_128_CTR );
287 if( !strcasecmp( "AES-192-CTR", cipher_name ) )
288 return cipher_info_from_type( POLARSSL_CIPHER_AES_192_CTR );
289 if( !strcasecmp( "AES-256-CTR", cipher_name ) )
290 return cipher_info_from_type( POLARSSL_CIPHER_AES_256_CTR );
291#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200292
293#if defined(POLARSSL_GCM_C)
294 if( !strcasecmp( "AES-128-GCM", cipher_name ) )
295 return cipher_info_from_type( POLARSSL_CIPHER_AES_128_GCM );
296 if( !strcasecmp( "AES-256-GCM", cipher_name ) )
297 return cipher_info_from_type( POLARSSL_CIPHER_AES_256_GCM );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000298#endif
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200299#endif /* POLARSSL_AES_C */
Paul Bakker343a8702011-06-09 14:27:58 +0000300
Manuel Pégourié-Gonnard37e230c2013-08-28 13:50:42 +0200301#if defined(POLARSSL_ARC4_C)
302 if( !strcasecmp( "ARC4-128", cipher_name ) )
303 return( cipher_info_from_type( POLARSSL_CIPHER_ARC4_128 ) );
304#endif
305
Paul Bakker8123e9d2011-01-06 15:37:30 +0000306#if defined(POLARSSL_DES_C)
307 if( !strcasecmp( "DES-CBC", cipher_name ) )
308 return cipher_info_from_type( POLARSSL_CIPHER_DES_CBC );
309 if( !strcasecmp( "DES-EDE-CBC", cipher_name ) )
310 return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE_CBC );
311 if( !strcasecmp( "DES-EDE3-CBC", cipher_name ) )
312 return cipher_info_from_type( POLARSSL_CIPHER_DES_EDE3_CBC );
313#endif
Paul Bakkerfab5c822012-02-06 16:45:10 +0000314
Paul Bakker6132d0a2012-07-04 17:10:40 +0000315#if defined(POLARSSL_BLOWFISH_C)
316 if( !strcasecmp( "BLOWFISH-CBC", cipher_name ) )
317 return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CBC );
318
319#if defined(POLARSSL_CIPHER_MODE_CFB)
320 if( !strcasecmp( "BLOWFISH-CFB64", cipher_name ) )
321 return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CFB64 );
322#endif /* defined(POLARSSL_CIPHER_MODE_CFB) */
323
324#if defined(POLARSSL_CIPHER_MODE_CTR)
325 if( !strcasecmp( "BLOWFISH-CTR", cipher_name ) )
326 return cipher_info_from_type( POLARSSL_CIPHER_BLOWFISH_CTR );
327#endif /* defined(POLARSSL_CIPHER_MODE_CTR) */
328#endif
329
Paul Bakkerfab5c822012-02-06 16:45:10 +0000330#if defined(POLARSSL_CIPHER_NULL_CIPHER)
331 if( !strcasecmp( "NULL", cipher_name ) )
332 return cipher_info_from_type( POLARSSL_CIPHER_NULL );
333#endif /* defined(POLARSSL_CIPHER_NULL_CIPHER) */
334
Paul Bakker8123e9d2011-01-06 15:37:30 +0000335 return NULL;
336}
337
338int cipher_init_ctx( cipher_context_t *ctx, const cipher_info_t *cipher_info )
339{
340 if( NULL == cipher_info || NULL == ctx )
Paul Bakkerff61a782011-06-09 15:42:02 +0000341 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000342
Paul Bakker279432a2012-04-26 10:09:35 +0000343 memset( ctx, 0, sizeof( cipher_context_t ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000344
Paul Bakker343a8702011-06-09 14:27:58 +0000345 if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
Paul Bakkerff61a782011-06-09 15:42:02 +0000346 return POLARSSL_ERR_CIPHER_ALLOC_FAILED;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000347
348 ctx->cipher_info = cipher_info;
349
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200350 /*
351 * Ignore possible errors caused by a cipher mode that doesn't use padding
352 */
Paul Bakker48e93c82013-08-14 12:21:18 +0200353#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200354 (void) cipher_set_padding_mode( ctx, POLARSSL_PADDING_PKCS7 );
Paul Bakker48e93c82013-08-14 12:21:18 +0200355#else
356 (void) cipher_set_padding_mode( ctx, POLARSSL_PADDING_NONE );
357#endif
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200358
Paul Bakker8123e9d2011-01-06 15:37:30 +0000359 return 0;
360}
361
362int cipher_free_ctx( cipher_context_t *ctx )
363{
364 if( ctx == NULL || ctx->cipher_info == NULL )
Paul Bakkerff61a782011-06-09 15:42:02 +0000365 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000366
Paul Bakker343a8702011-06-09 14:27:58 +0000367 ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000368
369 return 0;
370}
371
372int cipher_setkey( cipher_context_t *ctx, const unsigned char *key,
373 int key_length, const operation_t operation )
374{
375 if( NULL == ctx || NULL == ctx->cipher_info )
Paul Bakkerff61a782011-06-09 15:42:02 +0000376 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000377
378 ctx->key_length = key_length;
379 ctx->operation = operation;
380
Paul Bakker343a8702011-06-09 14:27:58 +0000381 /*
Paul Bakker6132d0a2012-07-04 17:10:40 +0000382 * For CFB and CTR mode always use the encryption key schedule
Paul Bakker343a8702011-06-09 14:27:58 +0000383 */
384 if( POLARSSL_ENCRYPT == operation ||
Paul Bakker6132d0a2012-07-04 17:10:40 +0000385 POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
Paul Bakker343a8702011-06-09 14:27:58 +0000386 POLARSSL_MODE_CTR == ctx->cipher_info->mode )
387 {
388 return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
Paul Bakker8123e9d2011-01-06 15:37:30 +0000389 ctx->key_length );
Paul Bakker343a8702011-06-09 14:27:58 +0000390 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000391
Paul Bakker343a8702011-06-09 14:27:58 +0000392 if( POLARSSL_DECRYPT == operation )
393 return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
Paul Bakker8123e9d2011-01-06 15:37:30 +0000394 ctx->key_length );
395
Paul Bakkerff61a782011-06-09 15:42:02 +0000396 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000397}
398
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200399int cipher_set_iv( cipher_context_t *ctx,
400 const unsigned char *iv, size_t iv_len )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000401{
Manuel Pégourié-Gonnarda235b5b2013-09-03 13:25:52 +0200402 size_t actual_iv_size;
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200403
Paul Bakker8123e9d2011-01-06 15:37:30 +0000404 if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
Paul Bakkerff61a782011-06-09 15:42:02 +0000405 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000406
Manuel Pégourié-Gonnarda235b5b2013-09-03 13:25:52 +0200407 if( ctx->cipher_info->accepts_variable_iv_size )
408 actual_iv_size = iv_len;
409 else
410 actual_iv_size = ctx->cipher_info->iv_size;
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200411
Manuel Pégourié-Gonnarda235b5b2013-09-03 13:25:52 +0200412 memcpy( ctx->iv, iv, actual_iv_size );
413 ctx->iv_size = actual_iv_size;
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200414
415 return 0;
416}
417
418int cipher_reset( cipher_context_t *ctx,
419 const unsigned char *ad, size_t ad_len )
420{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000421 ctx->unprocessed_len = 0;
422
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200423#if defined(POLARSSL_GCM_C)
424 if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
425 {
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200426 return gcm_starts( ctx->cipher_ctx, ctx->operation,
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200427 ctx->iv, ctx->iv_size, ad, ad_len );
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200428 }
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200429#else
430 ((void) ad);
431 ((void) ad_len);
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200432#endif
433
Paul Bakker8123e9d2011-01-06 15:37:30 +0000434 return 0;
435}
436
Paul Bakker23986e52011-04-24 08:57:21 +0000437int cipher_update( cipher_context_t *ctx, const unsigned char *input, size_t ilen,
438 unsigned char *output, size_t *olen )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000439{
Paul Bakkerff61a782011-06-09 15:42:02 +0000440 int ret;
Paul Bakker23986e52011-04-24 08:57:21 +0000441 size_t copy_len = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000442
Paul Bakker68884e32013-01-07 18:20:04 +0100443 *olen = 0;
444
445 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
Paul Bakkera885d682011-01-20 16:35:05 +0000446 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000447 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakkera885d682011-01-20 16:35:05 +0000448 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000449
Paul Bakker68884e32013-01-07 18:20:04 +0100450 if( input == output &&
451 ( ctx->unprocessed_len != 0 || ilen % cipher_get_block_size( ctx ) ) )
452 {
453 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
454 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000455
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200456 if( ctx->cipher_info->mode == POLARSSL_MODE_CBC ||
457 ctx->cipher_info->mode == POLARSSL_MODE_GCM )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000458 {
459 /*
460 * If there is not enough data for a full block, cache it.
461 */
462 if( ( ctx->operation == POLARSSL_DECRYPT &&
463 ilen + ctx->unprocessed_len <= cipher_get_block_size( ctx ) ) ||
464 ( ctx->operation == POLARSSL_ENCRYPT &&
465 ilen + ctx->unprocessed_len < cipher_get_block_size( ctx ) ) )
466 {
467 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
468 ilen );
469
470 ctx->unprocessed_len += ilen;
471 return 0;
472 }
473
474 /*
475 * Process cached data first
476 */
477 if( ctx->unprocessed_len != 0 )
478 {
479 copy_len = cipher_get_block_size( ctx ) - ctx->unprocessed_len;
480
481 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
482 copy_len );
483
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200484#if defined(POLARSSL_GCM_C)
485 if( ctx->cipher_info->mode == POLARSSL_MODE_GCM )
486 {
487 if( 0 != ( ret = gcm_update( ctx->cipher_ctx,
488 cipher_get_block_size( ctx ),
489 ctx->unprocessed_data, output ) ) )
490 {
491 return ret;
492 }
493 }
494 else
495#endif
Paul Bakkerff61a782011-06-09 15:42:02 +0000496 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
Paul Bakker8123e9d2011-01-06 15:37:30 +0000497 ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
Paul Bakkerff61a782011-06-09 15:42:02 +0000498 ctx->unprocessed_data, output ) ) )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000499 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000500 return ret;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000501 }
502
503 *olen += cipher_get_block_size( ctx );
504 output += cipher_get_block_size( ctx );
505 ctx->unprocessed_len = 0;
506
507 input += copy_len;
508 ilen -= copy_len;
509 }
510
511 /*
512 * Cache final, incomplete block
513 */
514 if( 0 != ilen )
515 {
516 copy_len = ilen % cipher_get_block_size( ctx );
517 if( copy_len == 0 && ctx->operation == POLARSSL_DECRYPT )
518 copy_len = cipher_get_block_size(ctx);
519
520 memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
521 copy_len );
522
523 ctx->unprocessed_len += copy_len;
524 ilen -= copy_len;
525 }
526
527 /*
528 * Process remaining full blocks
529 */
530 if( ilen )
531 {
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200532#if defined(POLARSSL_GCM_C)
533 if( ctx->cipher_info->mode == POLARSSL_MODE_GCM )
534 {
535 if( 0 != ( ret = gcm_update( ctx->cipher_ctx,
536 ilen, input, output ) ) )
537 {
538 return ret;
539 }
540 }
541 else
542#endif
Paul Bakkerff61a782011-06-09 15:42:02 +0000543 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
544 ctx->operation, ilen, ctx->iv, input, output ) ) )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000545 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000546 return ret;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000547 }
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200548
Paul Bakker8123e9d2011-01-06 15:37:30 +0000549 *olen += ilen;
550 }
551
552 return 0;
553 }
554
Paul Bakker68884e32013-01-07 18:20:04 +0100555#if defined(POLARSSL_CIPHER_MODE_CFB)
Paul Bakker6132d0a2012-07-04 17:10:40 +0000556 if( ctx->cipher_info->mode == POLARSSL_MODE_CFB )
Paul Bakker343a8702011-06-09 14:27:58 +0000557 {
Paul Bakker6132d0a2012-07-04 17:10:40 +0000558 if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
Paul Bakker343a8702011-06-09 14:27:58 +0000559 ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
Paul Bakkerff61a782011-06-09 15:42:02 +0000560 input, output ) ) )
Paul Bakker343a8702011-06-09 14:27:58 +0000561 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000562 return ret;
Paul Bakker343a8702011-06-09 14:27:58 +0000563 }
564
565 *olen = ilen;
566
567 return 0;
568 }
Paul Bakker68884e32013-01-07 18:20:04 +0100569#endif
Paul Bakker343a8702011-06-09 14:27:58 +0000570
Paul Bakker68884e32013-01-07 18:20:04 +0100571#if defined(POLARSSL_CIPHER_MODE_CTR)
Paul Bakker343a8702011-06-09 14:27:58 +0000572 if( ctx->cipher_info->mode == POLARSSL_MODE_CTR )
573 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000574 if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
Paul Bakker343a8702011-06-09 14:27:58 +0000575 ilen, &ctx->unprocessed_len, ctx->iv,
Paul Bakkerff61a782011-06-09 15:42:02 +0000576 ctx->unprocessed_data, input, output ) ) )
Paul Bakker343a8702011-06-09 14:27:58 +0000577 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000578 return ret;
Paul Bakker343a8702011-06-09 14:27:58 +0000579 }
580
581 *olen = ilen;
582
583 return 0;
584 }
Paul Bakker68884e32013-01-07 18:20:04 +0100585#endif
Paul Bakker343a8702011-06-09 14:27:58 +0000586
Manuel Pégourié-Gonnard37e230c2013-08-28 13:50:42 +0200587#if defined(POLARSSL_CIPHER_MODE_STREAM)
588 if( ctx->cipher_info->mode == POLARSSL_MODE_STREAM )
589 {
590 if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
591 ilen, input, output ) ) )
592 {
593 return ret;
594 }
595
596 *olen = ilen;
597
598 return 0;
599 }
600#endif
601
Paul Bakkerff61a782011-06-09 15:42:02 +0000602 return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000603}
604
Paul Bakker48e93c82013-08-14 12:21:18 +0200605#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
Manuel Pégourié-Gonnard679f9e92013-07-26 12:46:02 +0200606/*
607 * PKCS7 (and PKCS5) padding: fill with ll bytes, with ll = padding_len
608 */
Paul Bakker23986e52011-04-24 08:57:21 +0000609static void add_pkcs_padding( unsigned char *output, size_t output_len,
610 size_t data_len )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000611{
Paul Bakker23986e52011-04-24 08:57:21 +0000612 size_t padding_len = output_len - data_len;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000613 unsigned char i = 0;
614
615 for( i = 0; i < padding_len; i++ )
Paul Bakker23986e52011-04-24 08:57:21 +0000616 output[data_len + i] = (unsigned char) padding_len;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000617}
618
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200619static int get_pkcs_padding( unsigned char *input, size_t input_len,
620 size_t *data_len )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000621{
Paul Bakkerec1b9842012-01-14 18:24:43 +0000622 unsigned int i, padding_len = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000623
Paul Bakkera885d682011-01-20 16:35:05 +0000624 if( NULL == input || NULL == data_len )
Paul Bakkerff61a782011-06-09 15:42:02 +0000625 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000626
627 padding_len = input[input_len - 1];
628
Manuel Pégourié-Gonnardb7d24bc2013-07-26 10:58:48 +0200629 if( padding_len > input_len || padding_len == 0 )
Paul Bakkerff61a782011-06-09 15:42:02 +0000630 return POLARSSL_ERR_CIPHER_INVALID_PADDING;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000631
Paul Bakkera885d682011-01-20 16:35:05 +0000632 for( i = input_len - padding_len; i < input_len; i++ )
633 if( input[i] != padding_len )
Paul Bakkerff61a782011-06-09 15:42:02 +0000634 return POLARSSL_ERR_CIPHER_INVALID_PADDING;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000635
636 *data_len = input_len - padding_len;
637
638 return 0;
639}
Paul Bakker48e93c82013-08-14 12:21:18 +0200640#endif /* POLARSSL_CIPHER_PADDING_PKCS7 */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000641
Paul Bakker48e93c82013-08-14 12:21:18 +0200642#if defined(POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS)
Manuel Pégourié-Gonnard679f9e92013-07-26 12:46:02 +0200643/*
644 * One and zeros padding: fill with 80 00 ... 00
645 */
646static void add_one_and_zeros_padding( unsigned char *output,
647 size_t output_len, size_t data_len )
648{
649 size_t padding_len = output_len - data_len;
650 unsigned char i = 0;
651
652 output[data_len] = 0x80;
653 for( i = 1; i < padding_len; i++ )
654 output[data_len + i] = 0x00;
655}
656
657static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
658 size_t *data_len )
659{
660 unsigned char *p = input + input_len - 1;
661
662 if( NULL == input || NULL == data_len )
663 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
664
665 while( *p == 0x00 && p > input )
666 --p;
667
668 if( *p != 0x80 )
669 return POLARSSL_ERR_CIPHER_INVALID_PADDING;
670
671 *data_len = p - input;
672
673 return 0;
674}
Paul Bakker48e93c82013-08-14 12:21:18 +0200675#endif /* POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS */
Manuel Pégourié-Gonnard679f9e92013-07-26 12:46:02 +0200676
Paul Bakker48e93c82013-08-14 12:21:18 +0200677#if defined(POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN)
Manuel Pégourié-Gonnard8d4291b2013-07-26 14:55:18 +0200678/*
679 * Zeros and len padding: fill with 00 ... 00 ll, where ll is padding length
680 */
681static void add_zeros_and_len_padding( unsigned char *output,
682 size_t output_len, size_t data_len )
683{
684 size_t padding_len = output_len - data_len;
685 unsigned char i = 0;
686
687 for( i = 1; i < padding_len; i++ )
688 output[data_len + i - 1] = 0x00;
689 output[output_len - 1] = (unsigned char) padding_len;
690}
691
692static int get_zeros_and_len_padding( unsigned char *input, size_t input_len,
693 size_t *data_len )
694{
695 unsigned int i, padding_len = 0;
696
697 if( NULL == input || NULL == data_len )
698 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
699
700 padding_len = input[input_len - 1];
701
702 if( padding_len > input_len || padding_len == 0 )
703 return POLARSSL_ERR_CIPHER_INVALID_PADDING;
704
705 for( i = input_len - padding_len; i < input_len - 1; i++ )
706 if( input[i] != 0x00 )
707 return POLARSSL_ERR_CIPHER_INVALID_PADDING;
708
709 *data_len = input_len - padding_len;
710
711 return 0;
712}
Paul Bakker48e93c82013-08-14 12:21:18 +0200713#endif /* POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN */
Manuel Pégourié-Gonnard8d4291b2013-07-26 14:55:18 +0200714
Paul Bakker48e93c82013-08-14 12:21:18 +0200715#if defined(POLARSSL_CIPHER_PADDING_ZEROS)
Manuel Pégourié-Gonnard0e7d2c02013-07-26 16:05:14 +0200716/*
717 * Zero padding: fill with 00 ... 00
718 */
719static void add_zeros_padding( unsigned char *output,
720 size_t output_len, size_t data_len )
721{
722 unsigned char i;
723
724 for( i = data_len; i < output_len; i++ )
725 output[i] = 0x00;
726}
727
728static int get_zeros_padding( unsigned char *input, size_t input_len,
729 size_t *data_len )
730{
731 unsigned char *p = input + input_len - 1;
732 if( NULL == input || NULL == data_len )
733 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
734
735 while( *p == 0x00 && p > input )
736 --p;
737
738 *data_len = *p == 0x00 ? 0 : p - input + 1;
739
740 return 0;
741}
Paul Bakker48e93c82013-08-14 12:21:18 +0200742#endif /* POLARSSL_CIPHER_PADDING_ZEROS */
Manuel Pégourié-Gonnard0e7d2c02013-07-26 16:05:14 +0200743
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200744/*
745 * No padding: don't pad :)
746 *
747 * There is no add_padding function (check for NULL in cipher_finish)
748 * but a trivial get_padding function
749 */
750static int get_no_padding( unsigned char *input, size_t input_len,
751 size_t *data_len )
752{
753 if( NULL == input || NULL == data_len )
754 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
755
756 *data_len = input_len;
757
758 return 0;
759}
760
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200761int cipher_finish( cipher_context_t *ctx,
762 unsigned char *output, size_t *olen,
763 unsigned char *tag, size_t tag_len )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000764{
Paul Bakkerff61a782011-06-09 15:42:02 +0000765 int ret = 0;
766
Paul Bakker8123e9d2011-01-06 15:37:30 +0000767 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
Paul Bakkerff61a782011-06-09 15:42:02 +0000768 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000769
770 *olen = 0;
771
Paul Bakker6132d0a2012-07-04 17:10:40 +0000772 if( POLARSSL_MODE_CFB == ctx->cipher_info->mode ||
Paul Bakkerfab5c822012-02-06 16:45:10 +0000773 POLARSSL_MODE_CTR == ctx->cipher_info->mode ||
Manuel Pégourié-Gonnardb5e85882013-08-28 16:36:14 +0200774 POLARSSL_MODE_STREAM == ctx->cipher_info->mode )
Paul Bakker343a8702011-06-09 14:27:58 +0000775 {
776 return 0;
777 }
778
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200779#if defined(POLARSSL_GCM_C)
780 if( POLARSSL_MODE_GCM == ctx->cipher_info->mode )
781 {
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200782 unsigned char check_tag[16];
783 size_t i;
784 int diff;
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200785
786 if( 0 != ( ret = gcm_update( ctx->cipher_ctx,
787 ctx->unprocessed_len, ctx->unprocessed_data,
788 output ) ) )
789 {
790 return( ret );
791 }
792
793 *olen += ctx->unprocessed_len;
794
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200795 if( 0 != ( ret = gcm_finish( ctx->cipher_ctx, check_tag, tag_len ) ) )
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200796 return( ret );
797
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200798 /* On encryption, write the tag */
799 if( POLARSSL_ENCRYPT == ctx->operation )
800 {
801 if( tag_len != 0 )
802 memcpy( tag, check_tag, tag_len );
803 return( 0 );
804 }
805
806 /* On decryption, check the tag (in "constant-time") */
807 for( diff = 0, i = 0; i < tag_len; i++ )
808 diff |= tag[i] ^ check_tag[i];
809
810 if( diff != 0 )
811 return( POLARSSL_ERR_GCM_AUTH_FAILED );
812
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200813 return( 0 );
814 }
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200815#else
816 ((void) tag);
817 ((void) tag_len);
Manuel Pégourié-Gonnard07f8fa52013-08-30 18:34:08 +0200818#endif
819
Paul Bakker8123e9d2011-01-06 15:37:30 +0000820 if( POLARSSL_MODE_CBC == ctx->cipher_info->mode )
821 {
822 if( POLARSSL_ENCRYPT == ctx->operation )
823 {
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200824 /* check for 'no padding' mode */
825 if( NULL == ctx->add_padding )
826 {
827 if( 0 != ctx->unprocessed_len )
828 return POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED;
829
830 return 0;
831 }
832
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200833 ctx->add_padding( ctx->unprocessed_data, cipher_get_iv_size( ctx ),
Paul Bakker8123e9d2011-01-06 15:37:30 +0000834 ctx->unprocessed_len );
835 }
836 else if ( cipher_get_block_size( ctx ) != ctx->unprocessed_len )
837 {
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200838 /*
839 * For decrypt operations, expect a full block,
840 * or an empty block if no padding
841 */
842 if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
843 return 0;
844
Paul Bakkerff61a782011-06-09 15:42:02 +0000845 return POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000846 }
847
848 /* cipher block */
Paul Bakkerff61a782011-06-09 15:42:02 +0000849 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
850 ctx->operation, cipher_get_block_size( ctx ), ctx->iv,
851 ctx->unprocessed_data, output ) ) )
Paul Bakker8123e9d2011-01-06 15:37:30 +0000852 {
Paul Bakkerff61a782011-06-09 15:42:02 +0000853 return ret;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000854 }
855
856 /* Set output size for decryption */
857 if( POLARSSL_DECRYPT == ctx->operation )
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200858 return ctx->get_padding( output, cipher_get_block_size( ctx ),
859 olen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000860
861 /* Set output size for encryption */
862 *olen = cipher_get_block_size( ctx );
863 return 0;
864 }
865
Paul Bakkerff61a782011-06-09 15:42:02 +0000866 return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000867}
868
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200869int cipher_set_padding_mode( cipher_context_t *ctx, cipher_padding_t mode )
870{
871 if( NULL == ctx ||
872 POLARSSL_MODE_CBC != ctx->cipher_info->mode )
873 {
874 return POLARSSL_ERR_CIPHER_BAD_INPUT_DATA;
875 }
876
Paul Bakker1a45d912013-08-14 12:04:26 +0200877 switch( mode )
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200878 {
Paul Bakker48e93c82013-08-14 12:21:18 +0200879#if defined(POLARSSL_CIPHER_PADDING_PKCS7)
Paul Bakker1a45d912013-08-14 12:04:26 +0200880 case POLARSSL_PADDING_PKCS7:
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200881 ctx->add_padding = add_pkcs_padding;
882 ctx->get_padding = get_pkcs_padding;
Paul Bakker1a45d912013-08-14 12:04:26 +0200883 break;
Paul Bakker48e93c82013-08-14 12:21:18 +0200884#endif
885#if defined(POLARSSL_CIPHER_PADDING_ONE_AND_ZEROS)
Paul Bakker1a45d912013-08-14 12:04:26 +0200886 case POLARSSL_PADDING_ONE_AND_ZEROS:
Manuel Pégourié-Gonnard679f9e92013-07-26 12:46:02 +0200887 ctx->add_padding = add_one_and_zeros_padding;
888 ctx->get_padding = get_one_and_zeros_padding;
Paul Bakker1a45d912013-08-14 12:04:26 +0200889 break;
Paul Bakker48e93c82013-08-14 12:21:18 +0200890#endif
891#if defined(POLARSSL_CIPHER_PADDING_ZEROS_AND_LEN)
Paul Bakker1a45d912013-08-14 12:04:26 +0200892 case POLARSSL_PADDING_ZEROS_AND_LEN:
Manuel Pégourié-Gonnard8d4291b2013-07-26 14:55:18 +0200893 ctx->add_padding = add_zeros_and_len_padding;
894 ctx->get_padding = get_zeros_and_len_padding;
Paul Bakker1a45d912013-08-14 12:04:26 +0200895 break;
Paul Bakker48e93c82013-08-14 12:21:18 +0200896#endif
897#if defined(POLARSSL_CIPHER_PADDING_ZEROS)
Paul Bakker1a45d912013-08-14 12:04:26 +0200898 case POLARSSL_PADDING_ZEROS:
Manuel Pégourié-Gonnard0e7d2c02013-07-26 16:05:14 +0200899 ctx->add_padding = add_zeros_padding;
900 ctx->get_padding = get_zeros_padding;
Paul Bakker1a45d912013-08-14 12:04:26 +0200901 break;
Paul Bakker48e93c82013-08-14 12:21:18 +0200902#endif
Paul Bakker1a45d912013-08-14 12:04:26 +0200903 case POLARSSL_PADDING_NONE:
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200904 ctx->add_padding = NULL;
905 ctx->get_padding = get_no_padding;
Paul Bakker1a45d912013-08-14 12:04:26 +0200906 break;
907
908 default:
Paul Bakker48e93c82013-08-14 12:21:18 +0200909 return POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200910 }
911
Paul Bakker1a45d912013-08-14 12:04:26 +0200912 return 0;
Manuel Pégourié-Gonnardac56a1a2013-07-25 12:31:10 +0200913}
914
Paul Bakker8123e9d2011-01-06 15:37:30 +0000915#if defined(POLARSSL_SELF_TEST)
916
917#include <stdio.h>
918
919#define ASSERT(x) if (!(x)) { \
920 printf( "failed with %i at %s\n", value, (#x) ); \
921 return( 1 ); \
922}
923/*
924 * Checkup routine
925 */
926
927int cipher_self_test( int verbose )
928{
Paul Bakkerd61e7d92011-01-18 16:17:47 +0000929 ((void) verbose);
930
Paul Bakker8123e9d2011-01-06 15:37:30 +0000931 return( 0 );
932}
933
934#endif
935
936#endif