开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 其他 > 查看源码
crypto.c
资源名称：1121aircrack-2.41.zip　[点击查看]
上传用户：fubang
上传日期：2009-06-18
资源大小：2071k
文件大小：30k
源码类别：

其他

开发平台：

Unix_Linux

crypto.c：源码内容
  1. /*
  2.  *  MD5, SHA-1, RC4 and AES implementations
  3.  *
  4.  *  Copyright (C) 2001-2004  Christophe Devine
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  21. #include <string.h>
  23. #include "crypto.h"
  25. #define GET_UINT32_LE(n,b,i)                    
  26. {                                               
  27.     (n) = ( (uint32) (b)[(i)    ]       )       
  28.         | ( (uint32) (b)[(i) + 1] <<  8 )       
  29.         | ( (uint32) (b)[(i) + 2] << 16 )       
  30.         | ( (uint32) (b)[(i) + 3] << 24 );      
  31. }
  33. #define PUT_UINT32_LE(n,b,i)                    
  34. {                                               
  35.     (b)[(i)    ] = (uint8) ( (n)       );       
  36.     (b)[(i) + 1] = (uint8) ( (n) >>  8 );       
  37.     (b)[(i) + 2] = (uint8) ( (n) >> 16 );       
  38.     (b)[(i) + 3] = (uint8) ( (n) >> 24 );       
  39. }
  41. #define GET_UINT32_BE(n,b,i)                    
  42. {                                               
  43.     (n) = ( (uint32) (b)[(i)    ] << 24 )       
  44.         | ( (uint32) (b)[(i) + 1] << 16 )       
  45.         | ( (uint32) (b)[(i) + 2] <<  8 )       
  46.         | ( (uint32) (b)[(i) + 3]       );      
  47. }
  49. #define PUT_UINT32_BE(n,b,i)                    
  50. {                                               
  51.     (b)[(i)    ] = (uint8) ( (n) >> 24 );       
  52.     (b)[(i) + 1] = (uint8) ( (n) >> 16 );       
  53.     (b)[(i) + 2] = (uint8) ( (n) >>  8 );       
  54.     (b)[(i) + 3] = (uint8) ( (n)       );       
  55. }
  57. /* RFC 1321 compliant MD5 implementation */
  59. void md5_starts( md5_context *ctx )
  60. {
  61.     ctx->total[0] = 0;
  62.     ctx->total[1] = 0;
  64.     ctx->state[0] = 0x67452301;
  65.     ctx->state[1] = 0xEFCDAB89;
  66.     ctx->state[2] = 0x98BADCFE;
  67.     ctx->state[3] = 0x10325476;
  68. }
  70. void md5_process( md5_context *ctx, uint8 data[64] )
  71. {
  72.     uint32 X[16], A, B, C, D;
  74.     GET_UINT32_LE( X[0],  data,  0 );
  75.     GET_UINT32_LE( X[1],  data,  4 );
  76.     GET_UINT32_LE( X[2],  data,  8 );
  77.     GET_UINT32_LE( X[3],  data, 12 );
  78.     GET_UINT32_LE( X[4],  data, 16 );
  79.     GET_UINT32_LE( X[5],  data, 20 );
  80.     GET_UINT32_LE( X[6],  data, 24 );
  81.     GET_UINT32_LE( X[7],  data, 28 );
  82.     GET_UINT32_LE( X[8],  data, 32 );
  83.     GET_UINT32_LE( X[9],  data, 36 );
  84.     GET_UINT32_LE( X[10], data, 40 );
  85.     GET_UINT32_LE( X[11], data, 44 );
  86.     GET_UINT32_LE( X[12], data, 48 );
  87.     GET_UINT32_LE( X[13], data, 52 );
  88.     GET_UINT32_LE( X[14], data, 56 );
  89.     GET_UINT32_LE( X[15], data, 60 );
  91. #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
  93. #define P(a,b,c,d,k,s,t)                                
  94. {                                                       
  95.     a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           
  96. }
  98.     A = ctx->state[0];
  99.     B = ctx->state[1];
  100.     C = ctx->state[2];
  101.     D = ctx->state[3];
  103. #define F(x,y,z) (z ^ (x & (y ^ z)))
  105.     P( A, B, C, D,  0,  7, 0xD76AA478 );
  106.     P( D, A, B, C,  1, 12, 0xE8C7B756 );
  107.     P( C, D, A, B,  2, 17, 0x242070DB );
  108.     P( B, C, D, A,  3, 22, 0xC1BDCEEE );
  109.     P( A, B, C, D,  4,  7, 0xF57C0FAF );
  110.     P( D, A, B, C,  5, 12, 0x4787C62A );
  111.     P( C, D, A, B,  6, 17, 0xA8304613 );
  112.     P( B, C, D, A,  7, 22, 0xFD469501 );
  113.     P( A, B, C, D,  8,  7, 0x698098D8 );
  114.     P( D, A, B, C,  9, 12, 0x8B44F7AF );
  115.     P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
  116.     P( B, C, D, A, 11, 22, 0x895CD7BE );
  117.     P( A, B, C, D, 12,  7, 0x6B901122 );
  118.     P( D, A, B, C, 13, 12, 0xFD987193 );
  119.     P( C, D, A, B, 14, 17, 0xA679438E );
  120.     P( B, C, D, A, 15, 22, 0x49B40821 );
  122. #undef F
  124. #define F(x,y,z) (y ^ (z & (x ^ y)))
  126.     P( A, B, C, D,  1,  5, 0xF61E2562 );
  127.     P( D, A, B, C,  6,  9, 0xC040B340 );
  128.     P( C, D, A, B, 11, 14, 0x265E5A51 );
  129.     P( B, C, D, A,  0, 20, 0xE9B6C7AA );
  130.     P( A, B, C, D,  5,  5, 0xD62F105D );
  131.     P( D, A, B, C, 10,  9, 0x02441453 );
  132.     P( C, D, A, B, 15, 14, 0xD8A1E681 );
  133.     P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
  134.     P( A, B, C, D,  9,  5, 0x21E1CDE6 );
  135.     P( D, A, B, C, 14,  9, 0xC33707D6 );
  136.     P( C, D, A, B,  3, 14, 0xF4D50D87 );
  137.     P( B, C, D, A,  8, 20, 0x455A14ED );
  138.     P( A, B, C, D, 13,  5, 0xA9E3E905 );
  139.     P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
  140.     P( C, D, A, B,  7, 14, 0x676F02D9 );
  141.     P( B, C, D, A, 12, 20, 0x8D2A4C8A );
  143. #undef F
  144.     
  145. #define F(x,y,z) (x ^ y ^ z)
  147.     P( A, B, C, D,  5,  4, 0xFFFA3942 );
  148.     P( D, A, B, C,  8, 11, 0x8771F681 );
  149.     P( C, D, A, B, 11, 16, 0x6D9D6122 );
  150.     P( B, C, D, A, 14, 23, 0xFDE5380C );
  151.     P( A, B, C, D,  1,  4, 0xA4BEEA44 );
  152.     P( D, A, B, C,  4, 11, 0x4BDECFA9 );
  153.     P( C, D, A, B,  7, 16, 0xF6BB4B60 );
  154.     P( B, C, D, A, 10, 23, 0xBEBFBC70 );
  155.     P( A, B, C, D, 13,  4, 0x289B7EC6 );
  156.     P( D, A, B, C,  0, 11, 0xEAA127FA );
  157.     P( C, D, A, B,  3, 16, 0xD4EF3085 );
  158.     P( B, C, D, A,  6, 23, 0x04881D05 );
  159.     P( A, B, C, D,  9,  4, 0xD9D4D039 );
  160.     P( D, A, B, C, 12, 11, 0xE6DB99E5 );
  161.     P( C, D, A, B, 15, 16, 0x1FA27CF8 );
  162.     P( B, C, D, A,  2, 23, 0xC4AC5665 );
  164. #undef F
  166. #define F(x,y,z) (y ^ (x | ~z))
  168.     P( A, B, C, D,  0,  6, 0xF4292244 );
  169.     P( D, A, B, C,  7, 10, 0x432AFF97 );
  170.     P( C, D, A, B, 14, 15, 0xAB9423A7 );
  171.     P( B, C, D, A,  5, 21, 0xFC93A039 );
  172.     P( A, B, C, D, 12,  6, 0x655B59C3 );
  173.     P( D, A, B, C,  3, 10, 0x8F0CCC92 );
  174.     P( C, D, A, B, 10, 15, 0xFFEFF47D );
  175.     P( B, C, D, A,  1, 21, 0x85845DD1 );
  176.     P( A, B, C, D,  8,  6, 0x6FA87E4F );
  177.     P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
  178.     P( C, D, A, B,  6, 15, 0xA3014314 );
  179.     P( B, C, D, A, 13, 21, 0x4E0811A1 );
  180.     P( A, B, C, D,  4,  6, 0xF7537E82 );
  181.     P( D, A, B, C, 11, 10, 0xBD3AF235 );
  182.     P( C, D, A, B,  2, 15, 0x2AD7D2BB );
  183.     P( B, C, D, A,  9, 21, 0xEB86D391 );
  185. #undef F
  187.     ctx->state[0] += A;
  188.     ctx->state[1] += B;
  189.     ctx->state[2] += C;
  190.     ctx->state[3] += D;
  191. }
  193. #undef P
  194. #undef S
  196. void md5_update( md5_context *ctx, uint8 *input, uint32 length )
  197. {
  198.     uint32 left, fill;
  200.     if( ! length ) return;
  202.     left = ctx->total[0] & 0x3F;
  203.     fill = 64 - left;
  205.     ctx->total[0] += length;
  206.     ctx->total[0] &= 0xFFFFFFFF;
  208.     if( ctx->total[0] < length )
  209.         ctx->total[1]++;
  211.     if( left && length >= fill )
  212.     {
  213.         memcpy( (void *) (ctx->buffer + left),
  214.                 (void *) input, fill );
  215.         md5_process( ctx, ctx->buffer );
  216.         length -= fill;
  217.         input  += fill;
  218.         left = 0;
  219.     }
  221.     while( length >= 64 )
  222.     {
  223.         md5_process( ctx, input );
  224.         length -= 64;
  225.         input  += 64;
  226.     }
  228.     if( length )
  229.     {
  230.         memcpy( (void *) (ctx->buffer + left),
  231.                 (void *) input, length );
  232.     }
  233. }
  235. static uint8 md5_padding[64] =
  236. {
  237.  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  238.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  239.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  240.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  241. };
  243. void md5_finish( md5_context *ctx, uint8 digest[16] )
  244. {
  245.     uint32 last, padn;
  246.     uint32 high, low;
  247.     uint8 msglen[8];
  249.     high = ( ctx->total[0] >> 29 )
  250.          | ( ctx->total[1] <<  3 );
  251.     low  = ( ctx->total[0] <<  3 );
  253.     PUT_UINT32_LE( low,  msglen, 0 );
  254.     PUT_UINT32_LE( high, msglen, 4 );
  256.     last = ctx->total[0] & 0x3F;
  257.     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
  259.     md5_update( ctx, md5_padding, padn );
  260.     md5_update( ctx, msglen, 8 );
  262.     PUT_UINT32_LE( ctx->state[0], digest,  0 );
  263.     PUT_UINT32_LE( ctx->state[1], digest,  4 );
  264.     PUT_UINT32_LE( ctx->state[2], digest,  8 );
  265.     PUT_UINT32_LE( ctx->state[3], digest, 12 );
  266. }
  268. void hmac_md5( uint8 *key, int keylen, uint8 *buffer, int length,
  269.                uint8 digest[16] )
  270. {
  271.     int i;
  272.     md5_context ctx;
  273.     uint8 k_ipad[64];
  274.     uint8 k_opad[64];
  275.     uint8 tmpbuf[16];
  277.     memset( k_ipad, 0, sizeof( k_ipad ) );
  278.     memset( k_opad, 0, sizeof( k_opad ) );
  280.     memcpy( k_ipad, key, keylen );
  281.     memcpy( k_opad, key, keylen );
  283.     for( i = 0; i < 64; i++ )
  284.     {
  285.         k_ipad[i] ^= 0x36;
  286.         k_opad[i] ^= 0x5C;
  287.     }
  289.     md5_starts( &ctx );
  290.     md5_update( &ctx, k_ipad, 64 );
  291.     md5_update( &ctx, buffer, length );
  292.     md5_finish( &ctx, tmpbuf );
  294.     md5_starts( &ctx );
  295.     md5_update( &ctx, k_opad, 64 );
  296.     md5_update( &ctx, tmpbuf, 16 );
  297.     md5_finish( &ctx, digest );
  298. }
  300. /* FIPS-180-1 compliant SHA-1 implementation */
  302. void sha1_starts( sha1_context *ctx )
  303. {
  304.     ctx->total[0] = 0;
  305.     ctx->total[1] = 0;
  307.     ctx->state[0] = 0x67452301;
  308.     ctx->state[1] = 0xEFCDAB89;
  309.     ctx->state[2] = 0x98BADCFE;
  310.     ctx->state[3] = 0x10325476;
  311.     ctx->state[4] = 0xC3D2E1F0;
  312. }
  314. void sha1_process( sha1_context *ctx, uint8 data[64] )
  315. {
  316.     uint32 temp, W[16], A, B, C, D, E;
  318.     GET_UINT32_BE( W[0],  data,  0 );
  319.     GET_UINT32_BE( W[1],  data,  4 );
  320.     GET_UINT32_BE( W[2],  data,  8 );
  321.     GET_UINT32_BE( W[3],  data, 12 );
  322.     GET_UINT32_BE( W[4],  data, 16 );
  323.     GET_UINT32_BE( W[5],  data, 20 );
  324.     GET_UINT32_BE( W[6],  data, 24 );
  325.     GET_UINT32_BE( W[7],  data, 28 );
  326.     GET_UINT32_BE( W[8],  data, 32 );
  327.     GET_UINT32_BE( W[9],  data, 36 );
  328.     GET_UINT32_BE( W[10], data, 40 );
  329.     GET_UINT32_BE( W[11], data, 44 );
  330.     GET_UINT32_BE( W[12], data, 48 );
  331.     GET_UINT32_BE( W[13], data, 52 );
  332.     GET_UINT32_BE( W[14], data, 56 );
  333.     GET_UINT32_BE( W[15], data, 60 );
  335. #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
  337. #define R(t)                                            
  338. (                                                       
  339.     temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^     
  340.            W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],      
  341.     ( W[t & 0x0F] = S(temp,1) )                         
  342. )
  344. #define P(a,b,c,d,e,x)                                  
  345. {                                                       
  346.     e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        
  347. }
  349.     A = ctx->state[0];
  350.     B = ctx->state[1];
  351.     C = ctx->state[2];
  352.     D = ctx->state[3];
  353.     E = ctx->state[4];
  355. #define F(x,y,z) (z ^ (x & (y ^ z)))
  356. #define K 0x5A827999
  358.     P( A, B, C, D, E, W[0]  );
  359.     P( E, A, B, C, D, W[1]  );
  360.     P( D, E, A, B, C, W[2]  );
  361.     P( C, D, E, A, B, W[3]  );
  362.     P( B, C, D, E, A, W[4]  );
  363.     P( A, B, C, D, E, W[5]  );
  364.     P( E, A, B, C, D, W[6]  );
  365.     P( D, E, A, B, C, W[7]  );
  366.     P( C, D, E, A, B, W[8]  );
  367.     P( B, C, D, E, A, W[9]  );
  368.     P( A, B, C, D, E, W[10] );
  369.     P( E, A, B, C, D, W[11] );
  370.     P( D, E, A, B, C, W[12] );
  371.     P( C, D, E, A, B, W[13] );
  372.     P( B, C, D, E, A, W[14] );
  373.     P( A, B, C, D, E, W[15] );
  374.     P( E, A, B, C, D, R(16) );
  375.     P( D, E, A, B, C, R(17) );
  376.     P( C, D, E, A, B, R(18) );
  377.     P( B, C, D, E, A, R(19) );
  379. #undef K
  380. #undef F
  382. #define F(x,y,z) (x ^ y ^ z)
  383. #define K 0x6ED9EBA1
  385.     P( A, B, C, D, E, R(20) );
  386.     P( E, A, B, C, D, R(21) );
  387.     P( D, E, A, B, C, R(22) );
  388.     P( C, D, E, A, B, R(23) );
  389.     P( B, C, D, E, A, R(24) );
  390.     P( A, B, C, D, E, R(25) );
  391.     P( E, A, B, C, D, R(26) );
  392.     P( D, E, A, B, C, R(27) );
  393.     P( C, D, E, A, B, R(28) );
  394.     P( B, C, D, E, A, R(29) );
  395.     P( A, B, C, D, E, R(30) );
  396.     P( E, A, B, C, D, R(31) );
  397.     P( D, E, A, B, C, R(32) );
  398.     P( C, D, E, A, B, R(33) );
  399.     P( B, C, D, E, A, R(34) );
  400.     P( A, B, C, D, E, R(35) );
  401.     P( E, A, B, C, D, R(36) );
  402.     P( D, E, A, B, C, R(37) );
  403.     P( C, D, E, A, B, R(38) );
  404.     P( B, C, D, E, A, R(39) );
  406. #undef K
  407. #undef F
  409. #define F(x,y,z) ((x & y) | (z & (x | y)))
  410. #define K 0x8F1BBCDC
  412.     P( A, B, C, D, E, R(40) );
  413.     P( E, A, B, C, D, R(41) );
  414.     P( D, E, A, B, C, R(42) );
  415.     P( C, D, E, A, B, R(43) );
  416.     P( B, C, D, E, A, R(44) );
  417.     P( A, B, C, D, E, R(45) );
  418.     P( E, A, B, C, D, R(46) );
  419.     P( D, E, A, B, C, R(47) );
  420.     P( C, D, E, A, B, R(48) );
  421.     P( B, C, D, E, A, R(49) );
  422.     P( A, B, C, D, E, R(50) );
  423.     P( E, A, B, C, D, R(51) );
  424.     P( D, E, A, B, C, R(52) );
  425.     P( C, D, E, A, B, R(53) );
  426.     P( B, C, D, E, A, R(54) );
  427.     P( A, B, C, D, E, R(55) );
  428.     P( E, A, B, C, D, R(56) );
  429.     P( D, E, A, B, C, R(57) );
  430.     P( C, D, E, A, B, R(58) );
  431.     P( B, C, D, E, A, R(59) );
  433. #undef K
  434. #undef F
  436. #define F(x,y,z) (x ^ y ^ z)
  437. #define K 0xCA62C1D6
  439.     P( A, B, C, D, E, R(60) );
  440.     P( E, A, B, C, D, R(61) );
  441.     P( D, E, A, B, C, R(62) );
  442.     P( C, D, E, A, B, R(63) );
  443.     P( B, C, D, E, A, R(64) );
  444.     P( A, B, C, D, E, R(65) );
  445.     P( E, A, B, C, D, R(66) );
  446.     P( D, E, A, B, C, R(67) );
  447.     P( C, D, E, A, B, R(68) );
  448.     P( B, C, D, E, A, R(69) );
  449.     P( A, B, C, D, E, R(70) );
  450.     P( E, A, B, C, D, R(71) );
  451.     P( D, E, A, B, C, R(72) );
  452.     P( C, D, E, A, B, R(73) );
  453.     P( B, C, D, E, A, R(74) );
  454.     P( A, B, C, D, E, R(75) );
  455.     P( E, A, B, C, D, R(76) );
  456.     P( D, E, A, B, C, R(77) );
  457.     P( C, D, E, A, B, R(78) );
  458.     P( B, C, D, E, A, R(79) );
  460. #undef K
  461. #undef F
  463.     ctx->state[0] += A;
  464.     ctx->state[1] += B;
  465.     ctx->state[2] += C;
  466.     ctx->state[3] += D;
  467.     ctx->state[4] += E;
  468. }
  470. #undef P
  471. #undef R
  472. #undef S
  474. void sha1_update( sha1_context *ctx, uint8 *input, uint32 length )
  475. {
  476.     uint32 left, fill;
  478.     if( ! length ) return;
  480.     left = ctx->total[0] & 0x3F;
  481.     fill = 64 - left;
  483.     ctx->total[0] += length;
  484.     ctx->total[0] &= 0xFFFFFFFF;
  486.     if( ctx->total[0] < length )
  487.         ctx->total[1]++;
  489.     if( left && length >= fill )
  490.     {
  491.         memcpy( (void *) (ctx->buffer + left),
  492.                 (void *) input, fill );
  493.         sha1_process( ctx, ctx->buffer );
  494.         length -= fill;
  495.         input  += fill;
  496.         left = 0;
  497.     }
  499.     while( length >= 64 )
  500.     {
  501.         sha1_process( ctx, input );
  502.         length -= 64;
  503.         input  += 64;
  504.     }
  506.     if( length )
  507.     {
  508.         memcpy( (void *) (ctx->buffer + left),
  509.                 (void *) input, length );
  510.     }
  511. }
  513. static uint8 sha1_padding[64] =
  514. {
  515.  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  516.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  517.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  518.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  519. };
  521. void sha1_finish( sha1_context *ctx, uint8 digest[20] )
  522. {
  523.     uint32 last, padn;
  524.     uint32 high, low;
  525.     uint8 msglen[8];
  527.     high = ( ctx->total[0] >> 29 )
  528.          | ( ctx->total[1] <<  3 );
  529.     low  = ( ctx->total[0] <<  3 );
  531.     PUT_UINT32_BE( high, msglen, 0 );
  532.     PUT_UINT32_BE( low,  msglen, 4 );
  534.     last = ctx->total[0] & 0x3F;
  535.     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
  537.     sha1_update( ctx, sha1_padding, padn );
  538.     sha1_update( ctx, msglen, 8 );
  540.     PUT_UINT32_BE( ctx->state[0], digest,  0 );
  541.     PUT_UINT32_BE( ctx->state[1], digest,  4 );
  542.     PUT_UINT32_BE( ctx->state[2], digest,  8 );
  543.     PUT_UINT32_BE( ctx->state[3], digest, 12 );
  544.     PUT_UINT32_BE( ctx->state[4], digest, 16 );
  545. }
  547. void hmac_sha1( uint8 *key, int keylen, uint8 *buffer, int length,
  548.                 uint8 digest[20] )
  549. {
  550.     int i;
  551.     sha1_context ctx;
  552.     uint8 k_ipad[64];
  553.     uint8 k_opad[64];
  554.     uint8 tmpbuf[20];
  556.     memset( k_ipad, 0, sizeof( k_ipad ) );
  557.     memset( k_opad, 0, sizeof( k_opad ) );
  559.     memcpy( k_ipad, key, keylen );
  560.     memcpy( k_opad, key, keylen );
  562.     for( i = 0; i < 64; i++ )
  563.     {
  564.         k_ipad[i] ^= 0x36;
  565.         k_opad[i] ^= 0x5C;
  566.     }
  568.     sha1_starts( &ctx );
  569.     sha1_update( &ctx, k_ipad, 64 );
  570.     sha1_update( &ctx, buffer, length );
  571.     sha1_finish( &ctx, tmpbuf );
  573.     sha1_starts( &ctx );
  574.     sha1_update( &ctx, k_opad, 64 );
  575.     sha1_update( &ctx, tmpbuf, 20 );
  576.     sha1_finish( &ctx, digest );
  577. }
  579. /* An implementation of the ARC4 algorithm */
  581. void rc4_setup( struct rc4_state *s, unsigned char *key,  int length )
  582. {
  583.     int i, j, k, *m, a;
  585.     s->x = 0;
  586.     s->y = 0;
  587.     m = s->m;
  589.     for( i = 0; i < 256; i++ )
  590.     {
  591.         m[i] = i;
  592.     }
  594.     j = k = 0;
  596.     for( i = 0; i < 256; i++ )
  597.     {
  598.         a = m[i];
  599.         j = (unsigned char) ( j + a + key[k] );
  600.         m[i] = m[j]; m[j] = a;
  601.         if( ++k >= length ) k = 0;
  602.     }
  603. }
  605. void rc4_crypt( struct rc4_state *s, unsigned char *data, int length )
  606. { 
  607.     int i, x, y, *m, a, b;
  609.     x = s->x;
  610.     y = s->y;
  611.     m = s->m;
  613.     for( i = 0; i < length; i++ )
  614.     {
  615.         x = (unsigned char) ( x + 1 ); a = m[x];
  616.         y = (unsigned char) ( y + a );
  617.         m[x] = b = m[y];
  618.         m[y] = a;
  619.         data[i] ^= m[(unsigned char) ( a + b )];
  620.     }
  622.     s->x = x;
  623.     s->y = y;
  624. }
  626. /* FIPS-197 compliant AES implementation */
  628. /* forward S-box & tables */
  630. uint32 FSb[256];
  631. uint32 FT0[256]; 
  632. uint32 FT1[256]; 
  633. uint32 FT2[256]; 
  634. uint32 FT3[256]; 
  636. /* reverse S-box & tables */
  638. uint32 RSb[256];
  639. uint32 RT0[256];
  640. uint32 RT1[256];
  641. uint32 RT2[256];
  642. uint32 RT3[256];
  644. /* round constants */
  646. uint32 RCON[10];
  648. /* tables generation flag */
  650. int do_init = 1;
  652. /* tables generation routine */
  654. #define ROTR8(x) ( ( ( x << 24 ) & 0xFFFFFFFF ) | 
  655.                    ( ( x & 0xFFFFFFFF ) >>  8 ) )
  657. #define XTIME(x) ( ( x <<  1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
  658. #define MUL(x,y) ( ( x &&  y ) ? pow[(log[x] + log[y]) % 255] : 0 )
  660. void aes_gen_tables( void )
  661. {
  662.     int i;
  663.     uint8 x, y;
  664.     uint8 pow[256];
  665.     uint8 log[256];
  667.     /* compute pow and log tables over GF(2^8) */
  669.     for( i = 0, x = 1; i < 256; i++, x ^= XTIME( x ) )
  670.     {
  671.         pow[i] = x;
  672.         log[x] = i;
  673.     }
  675.     /* calculate the round constants */
  677.     for( i = 0, x = 1; i < 10; i++, x = XTIME( x ) )
  678.     {
  679.         RCON[i] = (uint32) x << 24;
  680.     }
  682.     /* generate the forward and reverse S-boxes */
  684.     FSb[0x00] = 0x63;
  685.     RSb[0x63] = 0x00;
  687.     for( i = 1; i < 256; i++ )
  688.     {
  689.         x = pow[255 - log[i]];
  691.         y = x;  y = ( y << 1 ) | ( y >> 7 );
  692.         x ^= y; y = ( y << 1 ) | ( y >> 7 );
  693.         x ^= y; y = ( y << 1 ) | ( y >> 7 );
  694.         x ^= y; y = ( y << 1 ) | ( y >> 7 );
  695.         x ^= y ^ 0x63;
  697.         FSb[i] = x;
  698.         RSb[x] = i;
  699.     }
  701.     /* generate the forward and reverse tables */
  703.     for( i = 0; i < 256; i++ )
  704.     {
  705.         x = (unsigned char) FSb[i]; y = XTIME( x );
  707.         FT0[i] =   (uint32) ( x ^ y ) ^
  708.                  ( (uint32) x <<  8 ) ^
  709.                  ( (uint32) x << 16 ) ^
  710.                  ( (uint32) y << 24 );
  712.         FT0[i] &= 0xFFFFFFFF;
  714.         FT1[i] = ROTR8( FT0[i] );
  715.         FT2[i] = ROTR8( FT1[i] );
  716.         FT3[i] = ROTR8( FT2[i] );
  718.         y = (unsigned char) RSb[i];
  720.         RT0[i] = ( (uint32) MUL( 0x0B, y )       ) ^
  721.                  ( (uint32) MUL( 0x0D, y ) <<  8 ) ^
  722.                  ( (uint32) MUL( 0x09, y ) << 16 ) ^
  723.                  ( (uint32) MUL( 0x0E, y ) << 24 );
  725.         RT0[i] &= 0xFFFFFFFF;
  727.         RT1[i] = ROTR8( RT0[i] );
  728.         RT2[i] = ROTR8( RT1[i] );
  729.         RT3[i] = ROTR8( RT2[i] );
  730.     }
  731. }
  733. /* decryption key schedule tables */
  735. int KT_init = 1;
  737. uint32 KT0[256];
  738. uint32 KT1[256];
  739. uint32 KT2[256];
  740. uint32 KT3[256];
  742. /* AES key scheduling routine */
  744. int aes_set_key( aes_context *ctx, uint8 *key, int nbits )
  745. {
  746.     int i;
  747.     uint32 *RK, *SK;
  749.     if( do_init )
  750.     {
  751.         aes_gen_tables();
  753.         do_init = 0;
  754.     }
  756.     switch( nbits )
  757.     {
  758.         case 128: ctx->nr = 10; break;
  759.         case 192: ctx->nr = 12; break;
  760.         case 256: ctx->nr = 14; break;
  761.         default : return( 1 );
  762.     }
  764.     RK = ctx->erk;
  766.     for( i = 0; i < (nbits >> 5); i++ )
  767.     {
  768.         GET_UINT32_BE( RK[i], key, i * 4 );
  769.     }
  771.     /* setup encryption round keys */
  773.     switch( nbits )
  774.     {
  775.     case 128:
  777.         for( i = 0; i < 10; i++, RK += 4 )
  778.         {
  779.             RK[4]  = RK[0] ^ RCON[i] ^
  780.                         ( FSb[ (uint8) ( RK[3] >> 16 ) ] << 24 ) ^
  781.                         ( FSb[ (uint8) ( RK[3] >>  8 ) ] << 16 ) ^
  782.                         ( FSb[ (uint8) ( RK[3]       ) ] <<  8 ) ^
  783.                         ( FSb[ (uint8) ( RK[3] >> 24 ) ]       );
  785.             RK[5]  = RK[1] ^ RK[4];
  786.             RK[6]  = RK[2] ^ RK[5];
  787.             RK[7]  = RK[3] ^ RK[6];
  788.         }
  789.         break;
  791.     case 192:
  793.         for( i = 0; i < 8; i++, RK += 6 )
  794.         {
  795.             RK[6]  = RK[0] ^ RCON[i] ^
  796.                         ( FSb[ (uint8) ( RK[5] >> 16 ) ] << 24 ) ^
  797.                         ( FSb[ (uint8) ( RK[5] >>  8 ) ] << 16 ) ^
  798.                         ( FSb[ (uint8) ( RK[5]       ) ] <<  8 ) ^
  799.                         ( FSb[ (uint8) ( RK[5] >> 24 ) ]       );
  801.             RK[7]  = RK[1] ^ RK[6];
  802.             RK[8]  = RK[2] ^ RK[7];
  803.             RK[9]  = RK[3] ^ RK[8];
  804.             RK[10] = RK[4] ^ RK[9];
  805.             RK[11] = RK[5] ^ RK[10];
  806.         }
  807.         break;
  809.     case 256:
  811.         for( i = 0; i < 7; i++, RK += 8 )
  812.         {
  813.             RK[8]  = RK[0] ^ RCON[i] ^
  814.                         ( FSb[ (uint8) ( RK[7] >> 16 ) ] << 24 ) ^
  815.                         ( FSb[ (uint8) ( RK[7] >>  8 ) ] << 16 ) ^
  816.                         ( FSb[ (uint8) ( RK[7]       ) ] <<  8 ) ^
  817.                         ( FSb[ (uint8) ( RK[7] >> 24 ) ]       );
  819.             RK[9]  = RK[1] ^ RK[8];
  820.             RK[10] = RK[2] ^ RK[9];
  821.             RK[11] = RK[3] ^ RK[10];
  823.             RK[12] = RK[4] ^
  824.                         ( FSb[ (uint8) ( RK[11] >> 24 ) ] << 24 ) ^
  825.                         ( FSb[ (uint8) ( RK[11] >> 16 ) ] << 16 ) ^
  826.                         ( FSb[ (uint8) ( RK[11] >>  8 ) ] <<  8 ) ^
  827.                         ( FSb[ (uint8) ( RK[11]       ) ]       );
  829.             RK[13] = RK[5] ^ RK[12];
  830.             RK[14] = RK[6] ^ RK[13];
  831.             RK[15] = RK[7] ^ RK[14];
  832.         }
  833.         break;
  834.     }
  836.     /* setup decryption round keys */
  838.     if( KT_init )
  839.     {
  840.         for( i = 0; i < 256; i++ )
  841.         {
  842.             KT0[i] = RT0[ FSb[i] ];
  843.             KT1[i] = RT1[ FSb[i] ];
  844.             KT2[i] = RT2[ FSb[i] ];
  845.             KT3[i] = RT3[ FSb[i] ];
  846.         }
  848.         KT_init = 0;
  849.     }
  851.     SK = ctx->drk;
  853.     *SK++ = *RK++;
  854.     *SK++ = *RK++;
  855.     *SK++ = *RK++;
  856.     *SK++ = *RK++;
  858.     for( i = 1; i < ctx->nr; i++ )
  859.     {
  860.         RK -= 8;
  862.         *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
  863.                 KT1[ (uint8) ( *RK >> 16 ) ] ^
  864.                 KT2[ (uint8) ( *RK >>  8 ) ] ^
  865.                 KT3[ (uint8) ( *RK       ) ]; RK++;
  867.         *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
  868.                 KT1[ (uint8) ( *RK >> 16 ) ] ^
  869.                 KT2[ (uint8) ( *RK >>  8 ) ] ^
  870.                 KT3[ (uint8) ( *RK       ) ]; RK++;
  872.         *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
  873.                 KT1[ (uint8) ( *RK >> 16 ) ] ^
  874.                 KT2[ (uint8) ( *RK >>  8 ) ] ^
  875.                 KT3[ (uint8) ( *RK       ) ]; RK++;
  877.         *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
  878.                 KT1[ (uint8) ( *RK >> 16 ) ] ^
  879.                 KT2[ (uint8) ( *RK >>  8 ) ] ^
  880.                 KT3[ (uint8) ( *RK       ) ]; RK++;
  881.     }
  883.     RK -= 8;
  885.     *SK++ = *RK++;
  886.     *SK++ = *RK++;
  887.     *SK++ = *RK++;
  888.     *SK++ = *RK++;
  890.     return( 0 );
  891. }
  893. /* AES 128-bit block encryption routine */
  895. void aes_encrypt( aes_context *ctx, uint8 input[16], uint8 output[16] )
  896. {
  897.     uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
  899.     RK = ctx->erk;
  901.     GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
  902.     GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
  903.     GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
  904.     GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
  906. #define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     
  907. {                                               
  908.     RK += 4;                                    
  909.                                                 
  910.     X0 = RK[0] ^ FT0[ (uint8) ( Y0 >> 24 ) ] ^  
  911.                  FT1[ (uint8) ( Y1 >> 16 ) ] ^  
  912.                  FT2[ (uint8) ( Y2 >>  8 ) ] ^  
  913.                  FT3[ (uint8) ( Y3       ) ];   
  914.                                                 
  915.     X1 = RK[1] ^ FT0[ (uint8) ( Y1 >> 24 ) ] ^  
  916.                  FT1[ (uint8) ( Y2 >> 16 ) ] ^  
  917.                  FT2[ (uint8) ( Y3 >>  8 ) ] ^  
  918.                  FT3[ (uint8) ( Y0       ) ];   
  919.                                                 
  920.     X2 = RK[2] ^ FT0[ (uint8) ( Y2 >> 24 ) ] ^  
  921.                  FT1[ (uint8) ( Y3 >> 16 ) ] ^  
  922.                  FT2[ (uint8) ( Y0 >>  8 ) ] ^  
  923.                  FT3[ (uint8) ( Y1       ) ];   
  924.                                                 
  925.     X3 = RK[3] ^ FT0[ (uint8) ( Y3 >> 24 ) ] ^  
  926.                  FT1[ (uint8) ( Y0 >> 16 ) ] ^  
  927.                  FT2[ (uint8) ( Y1 >>  8 ) ] ^  
  928.                  FT3[ (uint8) ( Y2       ) ];   
  929. }
  931.     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 1 */
  932.     AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 2 */
  933.     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 3 */
  934.     AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 4 */
  935.     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 5 */
  936.     AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 6 */
  937.     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 7 */
  938.     AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 8 */
  939.     AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 9 */
  941.     if( ctx->nr > 10 )
  942.     {
  943.         AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 10 */
  944.         AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 11 */
  945.     }
  947.     if( ctx->nr > 12 )
  948.     {
  949.         AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 12 */
  950.         AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 13 */
  951.     }
  953.     /* last round */
  955.     RK += 4;
  957.     X0 = RK[0] ^ ( FSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
  958.                  ( FSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
  959.                  ( FSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
  960.                  ( FSb[ (uint8) ( Y3       ) ]       );
  962.     X1 = RK[1] ^ ( FSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
  963.                  ( FSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
  964.                  ( FSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
  965.                  ( FSb[ (uint8) ( Y0       ) ]       );
  967.     X2 = RK[2] ^ ( FSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
  968.                  ( FSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
  969.                  ( FSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
  970.                  ( FSb[ (uint8) ( Y1       ) ]       );
  972.     X3 = RK[3] ^ ( FSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
  973.                  ( FSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
  974.                  ( FSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
  975.                  ( FSb[ (uint8) ( Y2       ) ]       );
  977.     PUT_UINT32_BE( X0, output,  0 );
  978.     PUT_UINT32_BE( X1, output,  4 );
  979.     PUT_UINT32_BE( X2, output,  8 );
  980.     PUT_UINT32_BE( X3, output, 12 );
  981. }
  983. /* AES 128-bit block decryption routine */
  985. void aes_decrypt( aes_context *ctx, uint8 input[16], uint8 output[16] )
  986. {
  987.     uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
  989.     RK = ctx->drk;
  991.     GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
  992.     GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
  993.     GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
  994.     GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
  996. #define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     
  997. {                                               
  998.     RK += 4;                                    
  999.                                                 
  1000.     X0 = RK[0] ^ RT0[ (uint8) ( Y0 >> 24 ) ] ^  
  1001.                  RT1[ (uint8) ( Y3 >> 16 ) ] ^  
  1002.                  RT2[ (uint8) ( Y2 >>  8 ) ] ^  
  1003.                  RT3[ (uint8) ( Y1       ) ];   
  1004.                                                 
  1005.     X1 = RK[1] ^ RT0[ (uint8) ( Y1 >> 24 ) ] ^  
  1006.                  RT1[ (uint8) ( Y0 >> 16 ) ] ^  
  1007.                  RT2[ (uint8) ( Y3 >>  8 ) ] ^  
  1008.                  RT3[ (uint8) ( Y2       ) ];   
  1009.                                                 
  1010.     X2 = RK[2] ^ RT0[ (uint8) ( Y2 >> 24 ) ] ^  
  1011.                  RT1[ (uint8) ( Y1 >> 16 ) ] ^  
  1012.                  RT2[ (uint8) ( Y0 >>  8 ) ] ^  
  1013.                  RT3[ (uint8) ( Y3       ) ];   
  1014.                                                 
  1015.     X3 = RK[3] ^ RT0[ (uint8) ( Y3 >> 24 ) ] ^  
  1016.                  RT1[ (uint8) ( Y2 >> 16 ) ] ^  
  1017.                  RT2[ (uint8) ( Y1 >>  8 ) ] ^  
  1018.                  RT3[ (uint8) ( Y0       ) ];   
  1019. }
  1021.     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 1 */
  1022.     AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 2 */
  1023.     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 3 */
  1024.     AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 4 */
  1025.     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 5 */
  1026.     AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 6 */
  1027.     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 7 */
  1028.     AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 8 */
  1029.     AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 9 */
  1031.     if( ctx->nr > 10 )
  1032.     {
  1033.         AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 10 */
  1034.         AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 11 */
  1035.     }
  1037.     if( ctx->nr > 12 )
  1038.     {
  1039.         AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 12 */
  1040.         AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 13 */
  1041.     }
  1043.     /* last round */
  1045.     RK += 4;
  1047.     X0 = RK[0] ^ ( RSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
  1048.                  ( RSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
  1049.                  ( RSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
  1050.                  ( RSb[ (uint8) ( Y1       ) ]       );
  1052.     X1 = RK[1] ^ ( RSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
  1053.                  ( RSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
  1054.                  ( RSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
  1055.                  ( RSb[ (uint8) ( Y2       ) ]       );
  1057.     X2 = RK[2] ^ ( RSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
  1058.                  ( RSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
  1059.                  ( RSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
  1060.                  ( RSb[ (uint8) ( Y3       ) ]       );
  1062.     X3 = RK[3] ^ ( RSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
  1063.                  ( RSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
  1064.                  ( RSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
  1065.                  ( RSb[ (uint8) ( Y0       ) ]       );
  1067.     PUT_UINT32_BE( X0, output,  0 );
  1068.     PUT_UINT32_BE( X1, output,  4 );
  1069.     PUT_UINT32_BE( X2, output,  8 );
  1070.     PUT_UINT32_BE( X3, output, 12 );
  1071. }