Sat Aug 6 00:39:33 2011

Asterisk developer's documentation


aes.h File Reference

This file contains the definitions required to use AES in C. See aesopt.h for optimisation details. More...

#include "limits.h"

Go to the source code of this file.

Data Structures

struct  aes_decrypt_ctx
struct  aes_encrypt_ctx

Defines

#define AES_128
#define AES_BLOCK_SIZE   16
#define AES_DECRYPT
#define AES_ENCRYPT
#define AES_ERR_CHK
#define aes_error   -1
#define aes_good   0
#define aes_ret   int
#define aes_rval   aes_ret
#define KS_LENGTH   64
#define N_COLS   4

Functions

aes_rval aes_decrypt (const void *in_blk, void *out_blk, const aes_decrypt_ctx cx[1])
aes_rval aes_decrypt_key128 (const void *in_key, aes_decrypt_ctx cx[1])
aes_rval aes_encrypt (const void *in_blk, void *out_blk, const aes_encrypt_ctx cx[1])
aes_rval aes_encrypt_key128 (const void *in_key, aes_encrypt_ctx cx[1])
void gen_tabs (void)


Detailed Description

This file contains the definitions required to use AES in C. See aesopt.h for optimisation details.

Definition in file aes.h.


Define Documentation

#define AES_128

Definition at line 60 of file aes.h.

#define AES_BLOCK_SIZE   16

Definition at line 85 of file aes.h.

#define AES_DECRYPT

Definition at line 68 of file aes.h.

#define AES_ENCRYPT

Definition at line 67 of file aes.h.

#define AES_ERR_CHK

Definition at line 69 of file aes.h.

#define aes_error   -1

Definition at line 97 of file aes.h.

Referenced by aes_decrypt(), and aes_encrypt().

#define aes_good   0

Definition at line 96 of file aes.h.

Referenced by aes_decrypt(), aes_decrypt_key128(), aes_encrypt(), and aes_encrypt_key128().

#define aes_ret   int

Definition at line 95 of file aes.h.

#define aes_rval   aes_ret

Definition at line 103 of file aes.h.

#define KS_LENGTH   64

Definition at line 92 of file aes.h.

#define N_COLS   4

Definition at line 86 of file aes.h.

Referenced by aes_decrypt(), aes_decrypt_key128(), aes_encrypt(), and aes_encrypt_key128().


Function Documentation

aes_rval aes_decrypt ( const void *  in_blk,
void *  out_blk,
const aes_decrypt_ctx  cx[1] 
)

Definition at line 237 of file aescrypt.c.

References aes_error, aes_good, inv_lrnd, inv_rnd, aes_decrypt_ctx::ks, l_copy, locals, N_COLS, round, state_in, and state_out.

Referenced by decrypt_memcpy(), and memcpy_decrypt().

00238 {   aes_32t        locals(b0, b1);
00239 #ifdef dec_imvars
00240     dec_imvars; /* declare variables for inv_mcol() if needed */
00241 #endif
00242 
00243     aes_32t nr = (cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] ? cx->ks[52] : 14);
00244     const aes_32t *kp = cx->ks + nr * N_COLS;
00245 
00246 #ifdef AES_ERR_CHK
00247     if(   (nr != 10 || !(cx->ks[0] | cx->ks[3] | cx->ks[4])) 
00248        && (nr != 12 || !(cx->ks[0] | cx->ks[5] | cx->ks[6]))
00249        && (nr != 14 || !(cx->ks[0] | cx->ks[7] | cx->ks[8])) )
00250         return aes_error;
00251 #endif
00252 
00253     state_in(b0, in_blk, kp);
00254 
00255 #if (DEC_UNROLL == FULL)
00256 
00257     switch(nr)
00258     {
00259     case 14:
00260         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
00261         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
00262         kp -= 2 * N_COLS;
00263     case 12:
00264         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
00265         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
00266         kp -= 2 * N_COLS;
00267     case 10:
00268         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
00269         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
00270         round(inv_rnd,  b1, b0, kp -  3 * N_COLS);
00271         round(inv_rnd,  b0, b1, kp -  4 * N_COLS);
00272         round(inv_rnd,  b1, b0, kp -  5 * N_COLS);
00273         round(inv_rnd,  b0, b1, kp -  6 * N_COLS);
00274         round(inv_rnd,  b1, b0, kp -  7 * N_COLS);
00275         round(inv_rnd,  b0, b1, kp -  8 * N_COLS);
00276         round(inv_rnd,  b1, b0, kp -  9 * N_COLS);
00277         round(inv_lrnd, b0, b1, kp - 10 * N_COLS);
00278     }
00279 
00280 #else
00281 
00282 #if (DEC_UNROLL == PARTIAL)
00283     {   aes_32t    rnd;
00284         for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
00285         {
00286             kp -= N_COLS;
00287             round(inv_rnd, b1, b0, kp);
00288             kp -= N_COLS;
00289             round(inv_rnd, b0, b1, kp);
00290         }
00291         kp -= N_COLS;
00292         round(inv_rnd, b1, b0, kp);
00293 #else
00294     {   aes_32t    rnd;
00295         for(rnd = 0; rnd < nr - 1; ++rnd)
00296         {
00297             kp -= N_COLS;
00298             round(inv_rnd, b1, b0, kp);
00299             l_copy(b0, b1);
00300         }
00301 #endif
00302         kp -= N_COLS;
00303         round(inv_lrnd, b0, b1, kp);
00304     }
00305 #endif
00306 
00307     state_out(out_blk, b0);
00308 #ifdef AES_ERR_CHK
00309     return aes_good;
00310 #endif
00311 }

aes_rval aes_decrypt_key128 ( const void *  in_key,
aes_decrypt_ctx  cx[1] 
)

Definition at line 318 of file aeskey.c.

References aes_good, DEC_ROUND, inv_mcol, kd4, kdf4, kdl4, ke4, aes_decrypt_ctx::ks, N_COLS, NO_TABLES, and word_in.

Referenced by build_ecx_key(), build_encryption_keys(), check_key(), and update_key().

00319 {   aes_32t    ss[5];
00320 #ifdef  d_vars
00321         d_vars;
00322 #endif
00323     cx->ks[0] = ss[0] = word_in(in_key, 0);
00324     cx->ks[1] = ss[1] = word_in(in_key, 1);
00325     cx->ks[2] = ss[2] = word_in(in_key, 2);
00326     cx->ks[3] = ss[3] = word_in(in_key, 3);
00327 
00328 #if DEC_UNROLL == NONE
00329     {   aes_32t i;
00330 
00331         for(i = 0; i < (11 * N_COLS - 1) / 4; ++i)
00332             ke4(cx->ks, i);
00333 #if !(DEC_ROUND == NO_TABLES)
00334         for(i = N_COLS; i < 10 * N_COLS; ++i)
00335             cx->ks[i] = inv_mcol(cx->ks[i]);
00336 #endif
00337     }
00338 #else
00339     kdf4(cx->ks, 0);  kd4(cx->ks, 1);
00340      kd4(cx->ks, 2);  kd4(cx->ks, 3);
00341      kd4(cx->ks, 4);  kd4(cx->ks, 5);
00342      kd4(cx->ks, 6);  kd4(cx->ks, 7);
00343      kd4(cx->ks, 8); kdl4(cx->ks, 9);
00344 #endif
00345 
00346     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
00347     /* key and must be non-zero for 128 and 192 bits keys   */
00348     cx->ks[53] = cx->ks[45] = 0;
00349     cx->ks[52] = 10;
00350 #ifdef AES_ERR_CHK
00351     return aes_good;
00352 #endif
00353 }

aes_rval aes_encrypt ( const void *  in_blk,
void *  out_blk,
const aes_encrypt_ctx  cx[1] 
)

Definition at line 113 of file aescrypt.c.

References aes_error, aes_good, dec_fmvars, fwd_lrnd, fwd_rnd, aes_encrypt_ctx::ks, l_copy, locals, N_COLS, round, state_in, and state_out.

Referenced by encrypt_memcpy(), and memcpy_encrypt().

00114 {   aes_32t         locals(b0, b1);
00115     const aes_32t   *kp = cx->ks;
00116 #ifdef dec_fmvars
00117     dec_fmvars; /* declare variables for fwd_mcol() if needed */
00118 #endif
00119 
00120     aes_32t nr = (kp[45] ^ kp[52] ^ kp[53] ? kp[52] : 14);
00121 
00122 #ifdef AES_ERR_CHK
00123     if(   (nr != 10 || !(kp[0] | kp[3] | kp[4])) 
00124        && (nr != 12 || !(kp[0] | kp[5] | kp[6]))
00125        && (nr != 14 || !(kp[0] | kp[7] | kp[8])) )
00126         return aes_error;
00127 #endif
00128 
00129     state_in(b0, in_blk, kp);
00130 
00131 #if (ENC_UNROLL == FULL)
00132 
00133     switch(nr)
00134     {
00135     case 14:
00136         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
00137         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
00138         kp += 2 * N_COLS;
00139     case 12:
00140         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
00141         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
00142         kp += 2 * N_COLS;
00143     case 10:
00144         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
00145         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
00146         round(fwd_rnd,  b1, b0, kp + 3 * N_COLS);
00147         round(fwd_rnd,  b0, b1, kp + 4 * N_COLS);
00148         round(fwd_rnd,  b1, b0, kp + 5 * N_COLS);
00149         round(fwd_rnd,  b0, b1, kp + 6 * N_COLS);
00150         round(fwd_rnd,  b1, b0, kp + 7 * N_COLS);
00151         round(fwd_rnd,  b0, b1, kp + 8 * N_COLS);
00152         round(fwd_rnd,  b1, b0, kp + 9 * N_COLS);
00153         round(fwd_lrnd, b0, b1, kp +10 * N_COLS);
00154     }
00155 
00156 #else
00157 
00158 #if (ENC_UNROLL == PARTIAL)
00159     {   aes_32t    rnd;
00160         for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
00161         {
00162             kp += N_COLS;
00163             round(fwd_rnd, b1, b0, kp);
00164             kp += N_COLS;
00165             round(fwd_rnd, b0, b1, kp);
00166         }
00167         kp += N_COLS;
00168         round(fwd_rnd,  b1, b0, kp);
00169 #else
00170     {   aes_32t    rnd;
00171         for(rnd = 0; rnd < nr - 1; ++rnd)
00172         {
00173             kp += N_COLS;
00174             round(fwd_rnd, b1, b0, kp);
00175             l_copy(b0, b1);
00176         }
00177 #endif
00178         kp += N_COLS;
00179         round(fwd_lrnd, b0, b1, kp);
00180     }
00181 #endif
00182 
00183     state_out(out_blk, b0);
00184 #ifdef AES_ERR_CHK
00185     return aes_good;
00186 #endif
00187 }

aes_rval aes_encrypt_key128 ( const void *  in_key,
aes_encrypt_ctx  cx[1] 
)

Definition at line 103 of file aeskey.c.

References aes_good, ke4, kel4, aes_encrypt_ctx::ks, N_COLS, and word_in.

Referenced by build_ecx_key(), check_key(), and update_key().

00104 {   aes_32t    ss[4];
00105 
00106     cx->ks[0] = ss[0] = word_in(in_key, 0);
00107     cx->ks[1] = ss[1] = word_in(in_key, 1);
00108     cx->ks[2] = ss[2] = word_in(in_key, 2);
00109     cx->ks[3] = ss[3] = word_in(in_key, 3);
00110 
00111 #if ENC_UNROLL == NONE
00112     {   aes_32t i;
00113 
00114         for(i = 0; i < ((11 * N_COLS - 1) / 4); ++i)
00115             ke4(cx->ks, i);
00116     }
00117 #else
00118     ke4(cx->ks, 0);  ke4(cx->ks, 1);
00119     ke4(cx->ks, 2);  ke4(cx->ks, 3);
00120     ke4(cx->ks, 4);  ke4(cx->ks, 5);
00121     ke4(cx->ks, 6);  ke4(cx->ks, 7);
00122     ke4(cx->ks, 8); kel4(cx->ks, 9);
00123 #endif
00124 
00125     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
00126     /* key and must be non-zero for 128 and 192 bits keys   */
00127     cx->ks[53] = cx->ks[45] = 0;
00128     cx->ks[52] = 10;
00129 #ifdef AES_ERR_CHK
00130     return aes_good;
00131 #endif
00132 }

void gen_tabs ( void   ) 

Definition at line 48 of file aestab.c.

00049 {
00050 }


Generated on Sat Aug 6 00:39:33 2011 for Asterisk - the Open Source PBX by  doxygen 1.4.7