← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/srtp/crypto/cipher/aes_cbc.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/srtp/crypto/cipher/aes_cbc.c
1
 
/*
2
 
 * aes_cbc.c
3
 
 *
4
 
 * AES Cipher Block Chaining Mode
5
 
 *
6
 
 * David A. McGrew
7
 
 * Cisco Systems, Inc.
8
 
 */
9
 
 
10
 
/*
11
 
 *
12
 
 * Copyright (c) 2001-2006, Cisco Systems, Inc.
13
 
 * All rights reserved.
14
 
 *
15
 
 * Redistribution and use in source and binary forms, with or without
16
 
 * modification, are permitted provided that the following conditions
17
 
 * are met:
18
 
 *
19
 
 *   Redistributions of source code must retain the above copyright
20
 
 *   notice, this list of conditions and the following disclaimer.
21
 
 *
22
 
 *   Redistributions in binary form must reproduce the above
23
 
 *   copyright notice, this list of conditions and the following
24
 
 *   disclaimer in the documentation and/or other materials provided
25
 
 *   with the distribution.
26
 
 *
27
 
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
28
 
 *   contributors may be used to endorse or promote products derived
29
 
 *   from this software without specific prior written permission.
30
 
 *
31
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32
 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33
 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
34
 
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
35
 
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
36
 
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37
 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
38
 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40
 
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
41
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
42
 
 * OF THE POSSIBILITY OF SUCH DAMAGE.
43
 
 *
44
 
 */
45
 
 
46
 
 
47
 
#include "aes_cbc.h"
48
 
#include "alloc.h"
49
 
 
50
 
debug_module_t mod_aes_cbc = {
51
 
  0,                 /* debugging is off by default */
52
 
  "aes cbc"          /* printable module name       */
53
 
};
54
 
 
55
 
 
56
 
 
57
 
err_status_t
58
 
aes_cbc_alloc(cipher_t **c, int key_len) {
59
 
  extern cipher_type_t aes_cbc;
60
 
  uint8_t *pointer;
61
 
  int tmp;
62
 
 
63
 
  debug_print(mod_aes_cbc,
64
 
              "allocating cipher with key length %d", key_len);
65
 
 
66
 
  if (key_len != 16)
67
 
    return err_status_bad_param;
68
 
 
69
 
  /* allocate memory a cipher of type aes_icm */
70
 
  tmp = (sizeof(aes_cbc_ctx_t) + sizeof(cipher_t));
71
 
  pointer = (uint8_t*)crypto_alloc(tmp);
72
 
  if (pointer == NULL)
73
 
    return err_status_alloc_fail;
74
 
 
75
 
  /* set pointers */
76
 
  *c = (cipher_t *)pointer;
77
 
  (*c)->type = &aes_cbc;
78
 
  (*c)->state = pointer + sizeof(cipher_t);
79
 
 
80
 
  /* increment ref_count */
81
 
  aes_cbc.ref_count++;
82
 
 
83
 
  /* set key size        */
84
 
  (*c)->key_len = key_len;
85
 
 
86
 
  return err_status_ok;
87
 
}
88
 
 
89
 
err_status_t
90
 
aes_cbc_dealloc(cipher_t *c) {
91
 
  extern cipher_type_t aes_cbc;
92
 
 
93
 
  /* zeroize entire state*/
94
 
  octet_string_set_to_zero((uint8_t *)c,
95
 
                           sizeof(aes_cbc_ctx_t) + sizeof(cipher_t));
96
 
 
97
 
  /* free memory */
98
 
  crypto_free(c);
99
 
 
100
 
  /* decrement ref_count */
101
 
  aes_cbc.ref_count--;
102
 
 
103
 
  return err_status_ok;
104
 
}
105
 
 
106
 
err_status_t
107
 
aes_cbc_context_init(aes_cbc_ctx_t *c, const uint8_t *key,
108
 
                     cipher_direction_t dir) {
109
 
  v128_t tmp_key;
110
 
 
111
 
  /* set tmp_key (for alignment) */
112
 
  v128_copy_octet_string(&tmp_key, key);
113
 
 
114
 
  debug_print(mod_aes_cbc,
115
 
              "key:  %s", v128_hex_string(&tmp_key));
116
 
 
117
 
  /* expand key for the appropriate direction */
118
 
  switch (dir) {
119
 
  case (direction_encrypt):
120
 
    aes_expand_encryption_key(&tmp_key, c->expanded_key);
121
 
    break;
122
 
  case (direction_decrypt):
123
 
    aes_expand_decryption_key(&tmp_key, c->expanded_key);
124
 
    break;
125
 
  default:
126
 
    return err_status_bad_param;
127
 
  }
128
 
 
129
 
 
130
 
  return err_status_ok;
131
 
}
132
 
 
133
 
 
134
 
err_status_t
135
 
aes_cbc_set_iv(aes_cbc_ctx_t *c, void *iv) {
136
 
  int i;
137
 
/*   v128_t *input = iv; */
138
 
  uint8_t *input = (uint8_t*) iv;
139
 
 
140
 
  /* set state and 'previous' block to iv */
141
 
  for (i=0; i < 16; i++)
142
 
    c->previous.v8[i] = c->state.v8[i] = input[i];
143
 
 
144
 
  debug_print(mod_aes_cbc, "setting iv: %s", v128_hex_string(&c->state));
145
 
 
146
 
  return err_status_ok;
147
 
}
148
 
 
149
 
err_status_t
150
 
aes_cbc_encrypt(aes_cbc_ctx_t *c,
151
 
                unsigned char *data,
152
 
                unsigned int *bytes_in_data) {
153
 
  int i;
154
 
  unsigned char *input  = data;   /* pointer to data being read    */
155
 
  unsigned char *output = data;   /* pointer to data being written */
156
 
  int bytes_to_encr = *bytes_in_data;
157
 
 
158
 
  /*
159
 
   * verify that we're 16-octet aligned
160
 
   */
161
 
  if (*bytes_in_data & 0xf)
162
 
    return err_status_bad_param;
163
 
 
164
 
  /*
165
 
   * note that we assume that the initialization vector has already
166
 
   * been set, e.g. by calling aes_cbc_set_iv()
167
 
   */
168
 
  debug_print(mod_aes_cbc, "iv: %s",
169
 
              v128_hex_string(&c->state));
170
 
 
171
 
  /*
172
 
   * loop over plaintext blocks, exoring state into plaintext then
173
 
   * encrypting and writing to output
174
 
   */
175
 
  while (bytes_to_encr > 0) {
176
 
 
177
 
    /* exor plaintext into state */
178
 
    for (i=0; i < 16; i++)
179
 
      c->state.v8[i] ^= *input++;
180
 
 
181
 
    debug_print(mod_aes_cbc, "inblock:  %s",
182
 
              v128_hex_string(&c->state));
183
 
 
184
 
    aes_encrypt(&c->state, c->expanded_key);
185
 
 
186
 
    debug_print(mod_aes_cbc, "outblock: %s",
187
 
              v128_hex_string(&c->state));
188
 
 
189
 
    /* copy ciphertext to output */
190
 
    for (i=0; i < 16; i++)
191
 
      *output++ = c->state.v8[i];
192
 
 
193
 
    bytes_to_encr -= 16;
194
 
  }
195
 
 
196
 
  return err_status_ok;
197
 
}
198
 
 
199
 
err_status_t
200
 
aes_cbc_decrypt(aes_cbc_ctx_t *c,
201
 
                unsigned char *data,
202
 
                unsigned int *bytes_in_data) {
203
 
  int i;
204
 
  v128_t state, previous;
205
 
  unsigned char *input  = data;   /* pointer to data being read    */
206
 
  unsigned char *output = data;   /* pointer to data being written */
207
 
  int bytes_to_encr = *bytes_in_data;
208
 
  uint8_t tmp;
209
 
 
210
 
  /*
211
 
   * verify that we're 16-octet aligned
212
 
   */
213
 
  if (*bytes_in_data & 0x0f)
214
 
    return err_status_bad_param;
215
 
 
216
 
  /* set 'previous' block to iv*/
217
 
  for (i=0; i < 16; i++) {
218
 
    previous.v8[i] = c->previous.v8[i];
219
 
  }
220
 
 
221
 
  debug_print(mod_aes_cbc, "iv: %s",
222
 
              v128_hex_string(&previous));
223
 
 
224
 
  /*
225
 
   * loop over ciphertext blocks, decrypting then exoring with state
226
 
   * then writing plaintext to output
227
 
   */
228
 
  while (bytes_to_encr > 0) {
229
 
 
230
 
    /* set state to ciphertext input block */
231
 
    for (i=0; i < 16; i++) {
232
 
     state.v8[i] = *input++;
233
 
    }
234
 
 
235
 
    debug_print(mod_aes_cbc, "inblock:  %s",
236
 
              v128_hex_string(&state));
237
 
 
238
 
    /* decrypt state */
239
 
    aes_decrypt(&state, c->expanded_key);
240
 
 
241
 
    debug_print(mod_aes_cbc, "outblock: %s",
242
 
              v128_hex_string(&state));
243
 
 
244
 
    /*
245
 
     * exor previous ciphertext block out of plaintext, and write new
246
 
     * plaintext block to output, while copying old ciphertext block
247
 
     * to the 'previous' block
248
 
     */
249
 
    for (i=0; i < 16; i++) {
250
 
      tmp = *output;
251
 
      *output++ = state.v8[i] ^ previous.v8[i];
252
 
      previous.v8[i] = tmp;
253
 
    }
254
 
 
255
 
    bytes_to_encr -= 16;
256
 
  }
257
 
 
258
 
  return err_status_ok;
259
 
}
260
 
 
261
 
 
262
 
err_status_t
263
 
aes_cbc_nist_encrypt(aes_cbc_ctx_t *c,
264
 
                     unsigned char *data,
265
 
                     unsigned int *bytes_in_data) {
266
 
  int i;
267
 
  unsigned char *pad_start;
268
 
  int num_pad_bytes;
269
 
  err_status_t status;
270
 
 
271
 
  /*
272
 
   * determine the number of padding bytes that we need to add -
273
 
   * this value is always between 1 and 16, inclusive.
274
 
   */
275
 
  num_pad_bytes = 16 - (*bytes_in_data & 0xf);
276
 
  pad_start = data;
277
 
  pad_start += *bytes_in_data;
278
 
  *pad_start++ = 0xa0;
279
 
  for (i=0; i < num_pad_bytes; i++)
280
 
    *pad_start++ = 0x00;
281
 
 
282
 
  /*
283
 
   * increment the data size
284
 
   */
285
 
  *bytes_in_data += num_pad_bytes;
286
 
 
287
 
  /*
288
 
   * now cbc encrypt the padded data
289
 
   */
290
 
  status = aes_cbc_encrypt(c, data, bytes_in_data);
291
 
  if (status)
292
 
    return status;
293
 
 
294
 
  return err_status_ok;
295
 
}
296
 
 
297
 
 
298
 
err_status_t
299
 
aes_cbc_nist_decrypt(aes_cbc_ctx_t *c,
300
 
                     unsigned char *data,
301
 
                     unsigned int *bytes_in_data) {
302
 
  unsigned char *pad_end;
303
 
  int num_pad_bytes;
304
 
  err_status_t status;
305
 
 
306
 
  /*
307
 
   * cbc decrypt the padded data
308
 
   */
309
 
  status = aes_cbc_decrypt(c, data, bytes_in_data);
310
 
  if (status)
311
 
    return status;
312
 
 
313
 
  /*
314
 
   * determine the number of padding bytes in the decrypted plaintext
315
 
   * - this value is always between 1 and 16, inclusive.
316
 
   */
317
 
  num_pad_bytes = 1;
318
 
  pad_end = data + (*bytes_in_data - 1);
319
 
  while (*pad_end != 0xa0) {   /* note: should check padding correctness */
320
 
    pad_end--;
321
 
    num_pad_bytes++;
322
 
  }
323
 
 
324
 
  /* decrement data size */
325
 
  *bytes_in_data -= num_pad_bytes;
326
 
 
327
 
  return err_status_ok;
328
 
}
329
 
 
330
 
 
331
 
char
332
 
aes_cbc_description[] = "aes cipher block chaining (cbc) mode";
333
 
 
334
 
/*
335
 
 * Test case 0 is derived from FIPS 197 Appendix A; it uses an
336
 
 * all-zero IV, so that the first block encryption matches the test
337
 
 * case in that appendix.  This property provides a check of the base
338
 
 * AES encryption and decryption algorithms; if CBC fails on some
339
 
 * particular platform, then you should print out AES intermediate
340
 
 * data and compare with the detailed info provided in that appendix.
341
 
 *
342
 
 */
343
 
 
344
 
 
345
 
uint8_t aes_cbc_test_case_0_key[16] = {
346
 
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
347
 
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
348
 
};
349
 
 
350
 
uint8_t aes_cbc_test_case_0_plaintext[64] =  {
351
 
  0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
352
 
  0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
353
 
};
354
 
 
355
 
uint8_t aes_cbc_test_case_0_ciphertext[80] = {
356
 
  0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
357
 
  0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a,
358
 
  0x03, 0x35, 0xed, 0x27, 0x67, 0xf2, 0x6d, 0xf1,
359
 
  0x64, 0x83, 0x2e, 0x23, 0x44, 0x38, 0x70, 0x8b
360
 
 
361
 
};
362
 
 
363
 
uint8_t aes_cbc_test_case_0_iv[16] = {
364
 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365
 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
366
 
};
367
 
 
368
 
 
369
 
cipher_test_case_t aes_cbc_test_case_0 = {
370
 
  16,                                    /* octets in key            */
371
 
  aes_cbc_test_case_0_key,               /* key                      */
372
 
  aes_cbc_test_case_0_iv,                /* initialization vector    */
373
 
  16,                                    /* octets in plaintext      */
374
 
  aes_cbc_test_case_0_plaintext,         /* plaintext                */
375
 
  32,                                    /* octets in ciphertext     */
376
 
  aes_cbc_test_case_0_ciphertext,        /* ciphertext               */
377
 
  NULL                                   /* pointer to next testcase */
378
 
};
379
 
 
380
 
 
381
 
/*
382
 
 * this test case is taken directly from Appendix F.2 of NIST Special
383
 
 * Publication SP 800-38A
384
 
 */
385
 
 
386
 
uint8_t aes_cbc_test_case_1_key[16] = {
387
 
  0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
388
 
  0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
389
 
};
390
 
 
391
 
uint8_t aes_cbc_test_case_1_plaintext[64] =  {
392
 
  0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
393
 
  0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
394
 
  0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
395
 
  0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
396
 
  0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
397
 
  0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
398
 
  0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
399
 
  0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
400
 
};
401
 
 
402
 
uint8_t aes_cbc_test_case_1_ciphertext[80] = {
403
 
  0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46,
404
 
  0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d,
405
 
  0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee,
406
 
  0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2,
407
 
  0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b,
408
 
  0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16,
409
 
  0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09,
410
 
  0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7,
411
 
  0x39, 0x34, 0x07, 0x03, 0x36, 0xd0, 0x77, 0x99,
412
 
  0xe0, 0xc4, 0x2f, 0xdd, 0xa8, 0xdf, 0x4c, 0xa3
413
 
};
414
 
 
415
 
uint8_t aes_cbc_test_case_1_iv[16] = {
416
 
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
417
 
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
418
 
};
419
 
 
420
 
cipher_test_case_t aes_cbc_test_case_1 = {
421
 
  16,                                    /* octets in key            */
422
 
  aes_cbc_test_case_1_key,               /* key                      */
423
 
  aes_cbc_test_case_1_iv,                /* initialization vector    */
424
 
  64,                                    /* octets in plaintext      */
425
 
  aes_cbc_test_case_1_plaintext,         /* plaintext                */
426
 
  80,                                    /* octets in ciphertext     */
427
 
  aes_cbc_test_case_1_ciphertext,        /* ciphertext               */
428
 
  &aes_cbc_test_case_0                    /* pointer to next testcase */
429
 
};
430
 
 
431
 
cipher_type_t aes_cbc = {
432
 
  (cipher_alloc_func_t)          aes_cbc_alloc,
433
 
  (cipher_dealloc_func_t)        aes_cbc_dealloc,
434
 
  (cipher_init_func_t)           aes_cbc_context_init,
435
 
  (cipher_encrypt_func_t)        aes_cbc_nist_encrypt,
436
 
  (cipher_decrypt_func_t)        aes_cbc_nist_decrypt,
437
 
  (cipher_set_iv_func_t)         aes_cbc_set_iv,
438
 
  (char *)                       aes_cbc_description,
439
 
  (int)                          0,   /* instance count */
440
 
  (cipher_test_case_t *)        &aes_cbc_test_case_0,
441
 
  (debug_module_t *)            &mod_aes_cbc
442
 
};