ASR_BASE
Change-Id: Icf3719cc0afe3eeb3edc7fa80a2eb5199ca9dda1
diff --git a/package/kernel/realtek-wl/src/Driver/rtl8192cd_92fs/wapiCrypto.c b/package/kernel/realtek-wl/src/Driver/rtl8192cd_92fs/wapiCrypto.c
new file mode 100755
index 0000000..5d3b4ce
--- /dev/null
+++ b/package/kernel/realtek-wl/src/Driver/rtl8192cd_92fs/wapiCrypto.c
@@ -0,0 +1,1777 @@
+#include "8192cd_cfg.h"
+#if defined(CONFIG_RTL_WAPI_SUPPORT)
+
+#define _WAPI_CRYPTO_C_
+
+#ifdef __LINUX_2_6__
+#ifdef CONFIG_RTL8672
+#include "./romeperf.h"
+#else
+#if !defined(NOT_RTK_BSP)
+#include <net/rtl/rtl_types.h>
+#endif
+#endif
+#include <linux/jiffies.h>
+#else
+#include "../rtl865x/rtl_types.h"
+#endif
+
+#include <linux/random.h>
+#include "8192cd.h"
+#include "wapi_wai.h"
+#include "wapiCrypto.h"
+#include "8192cd_util.h"
+#include "8192cd_headers.h"
+
+/*
+ * 32-bit integer manipulation macros (big endian)
+ */
+#ifndef GET_ULONG_BE
+#define GET_ULONG_BE(n,b,i) \
+{ \
+ (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
+ | ( (unsigned long) (b)[(i) + 1] << 16 ) \
+ | ( (unsigned long) (b)[(i) + 2] << 8 ) \
+ | ( (unsigned long) (b)[(i) + 3] ); \
+}
+#endif
+
+#ifndef PUT_ULONG_BE
+#define PUT_ULONG_BE(n,b,i) \
+{ \
+ (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
+ (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
+ (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
+ (b)[(i) + 3] = (unsigned char) ( (n) ); \
+}
+#endif
+
+/*
+ * SHA-256 context setup
+ */
+void sha2_starts( sha2_context *ctx, int is224 )
+{
+ ctx->total[0] = 0;
+ ctx->total[1] = 0;
+
+ if( is224 == 0 )
+ {
+ /* SHA-256 */
+ ctx->state[0] = 0x6A09E667;
+ ctx->state[1] = 0xBB67AE85;
+ ctx->state[2] = 0x3C6EF372;
+ ctx->state[3] = 0xA54FF53A;
+ ctx->state[4] = 0x510E527F;
+ ctx->state[5] = 0x9B05688C;
+ ctx->state[6] = 0x1F83D9AB;
+ ctx->state[7] = 0x5BE0CD19;
+ }
+ else
+ {
+ /* SHA-224 */
+ ctx->state[0] = 0xC1059ED8;
+ ctx->state[1] = 0x367CD507;
+ ctx->state[2] = 0x3070DD17;
+ ctx->state[3] = 0xF70E5939;
+ ctx->state[4] = 0xFFC00B31;
+ ctx->state[5] = 0x68581511;
+ ctx->state[6] = 0x64F98FA7;
+ ctx->state[7] = 0xBEFA4FA4;
+ }
+
+ ctx->is224 = is224;
+}
+
+static void sha2_process( sha2_context *ctx, unsigned char data[64] )
+{
+ unsigned long temp1, temp2, W[64];
+ unsigned long A, B, C, D, E, F, G, H;
+
+ GET_ULONG_BE( W[ 0], data, 0 );
+ GET_ULONG_BE( W[ 1], data, 4 );
+ GET_ULONG_BE( W[ 2], data, 8 );
+ GET_ULONG_BE( W[ 3], data, 12 );
+ GET_ULONG_BE( W[ 4], data, 16 );
+ GET_ULONG_BE( W[ 5], data, 20 );
+ GET_ULONG_BE( W[ 6], data, 24 );
+ GET_ULONG_BE( W[ 7], data, 28 );
+ GET_ULONG_BE( W[ 8], data, 32 );
+ GET_ULONG_BE( W[ 9], data, 36 );
+ GET_ULONG_BE( W[10], data, 40 );
+ GET_ULONG_BE( W[11], data, 44 );
+ GET_ULONG_BE( W[12], data, 48 );
+ GET_ULONG_BE( W[13], data, 52 );
+ GET_ULONG_BE( W[14], data, 56 );
+ GET_ULONG_BE( W[15], data, 60 );
+
+#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
+#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
+
+#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
+#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
+
+#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
+#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
+
+#define F0(x,y,z) ((x & y) | (z & (x | y)))
+#define F1(x,y,z) (z ^ (x & (y ^ z)))
+
+#define R(t) \
+( \
+ W[t] = S1(W[t - 2]) + W[t - 7] + \
+ S0(W[t - 15]) + W[t - 16] \
+)
+
+#define P(a,b,c,d,e,f,g,h,x,K) \
+{ \
+ temp1 = h + S3(e) + F1(e,f,g) + K + x; \
+ temp2 = S2(a) + F0(a,b,c); \
+ d += temp1; h = temp1 + temp2; \
+}
+
+ A = ctx->state[0];
+ B = ctx->state[1];
+ C = ctx->state[2];
+ D = ctx->state[3];
+ E = ctx->state[4];
+ F = ctx->state[5];
+ G = ctx->state[6];
+ H = ctx->state[7];
+
+ P( A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98 );
+ P( H, A, B, C, D, E, F, G, W[ 1], 0x71374491 );
+ P( G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF );
+ P( F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5 );
+ P( E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B );
+ P( D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1 );
+ P( C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4 );
+ P( B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5 );
+ P( A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98 );
+ P( H, A, B, C, D, E, F, G, W[ 9], 0x12835B01 );
+ P( G, H, A, B, C, D, E, F, W[10], 0x243185BE );
+ P( F, G, H, A, B, C, D, E, W[11], 0x550C7DC3 );
+ P( E, F, G, H, A, B, C, D, W[12], 0x72BE5D74 );
+ P( D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE );
+ P( C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7 );
+ P( B, C, D, E, F, G, H, A, W[15], 0xC19BF174 );
+ P( A, B, C, D, E, F, G, H, R(16), 0xE49B69C1 );
+ P( H, A, B, C, D, E, F, G, R(17), 0xEFBE4786 );
+ P( G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6 );
+ P( F, G, H, A, B, C, D, E, R(19), 0x240CA1CC );
+ P( E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F );
+ P( D, E, F, G, H, A, B, C, R(21), 0x4A7484AA );
+ P( C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC );
+ P( B, C, D, E, F, G, H, A, R(23), 0x76F988DA );
+ P( A, B, C, D, E, F, G, H, R(24), 0x983E5152 );
+ P( H, A, B, C, D, E, F, G, R(25), 0xA831C66D );
+ P( G, H, A, B, C, D, E, F, R(26), 0xB00327C8 );
+ P( F, G, H, A, B, C, D, E, R(27), 0xBF597FC7 );
+ P( E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3 );
+ P( D, E, F, G, H, A, B, C, R(29), 0xD5A79147 );
+ P( C, D, E, F, G, H, A, B, R(30), 0x06CA6351 );
+ P( B, C, D, E, F, G, H, A, R(31), 0x14292967 );
+ P( A, B, C, D, E, F, G, H, R(32), 0x27B70A85 );
+ P( H, A, B, C, D, E, F, G, R(33), 0x2E1B2138 );
+ P( G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC );
+ P( F, G, H, A, B, C, D, E, R(35), 0x53380D13 );
+ P( E, F, G, H, A, B, C, D, R(36), 0x650A7354 );
+ P( D, E, F, G, H, A, B, C, R(37), 0x766A0ABB );
+ P( C, D, E, F, G, H, A, B, R(38), 0x81C2C92E );
+ P( B, C, D, E, F, G, H, A, R(39), 0x92722C85 );
+ P( A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1 );
+ P( H, A, B, C, D, E, F, G, R(41), 0xA81A664B );
+ P( G, H, A, B, C, D, E, F, R(42), 0xC24B8B70 );
+ P( F, G, H, A, B, C, D, E, R(43), 0xC76C51A3 );
+ P( E, F, G, H, A, B, C, D, R(44), 0xD192E819 );
+ P( D, E, F, G, H, A, B, C, R(45), 0xD6990624 );
+ P( C, D, E, F, G, H, A, B, R(46), 0xF40E3585 );
+ P( B, C, D, E, F, G, H, A, R(47), 0x106AA070 );
+ P( A, B, C, D, E, F, G, H, R(48), 0x19A4C116 );
+ P( H, A, B, C, D, E, F, G, R(49), 0x1E376C08 );
+ P( G, H, A, B, C, D, E, F, R(50), 0x2748774C );
+ P( F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5 );
+ P( E, F, G, H, A, B, C, D, R(52), 0x391C0CB3 );
+ P( D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A );
+ P( C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F );
+ P( B, C, D, E, F, G, H, A, R(55), 0x682E6FF3 );
+ P( A, B, C, D, E, F, G, H, R(56), 0x748F82EE );
+ P( H, A, B, C, D, E, F, G, R(57), 0x78A5636F );
+ P( G, H, A, B, C, D, E, F, R(58), 0x84C87814 );
+ P( F, G, H, A, B, C, D, E, R(59), 0x8CC70208 );
+ P( E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA );
+ P( D, E, F, G, H, A, B, C, R(61), 0xA4506CEB );
+ P( C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7 );
+ P( B, C, D, E, F, G, H, A, R(63), 0xC67178F2 );
+
+ ctx->state[0] += A;
+ ctx->state[1] += B;
+ ctx->state[2] += C;
+ ctx->state[3] += D;
+ ctx->state[4] += E;
+ ctx->state[5] += F;
+ ctx->state[6] += G;
+ ctx->state[7] += H;
+}
+
+/*
+ * SHA-256 process buffer
+ */
+void sha2_update( sha2_context *ctx, unsigned char *input, int ilen )
+{
+ int fill;
+ unsigned long left;
+
+ if( ilen <= 0 )
+ return;
+
+ left = ctx->total[0] & 0x3F;
+ fill = 64 - left;
+
+ ctx->total[0] += ilen;
+ ctx->total[0] &= 0xFFFFFFFF;
+
+ if( ctx->total[0] < (unsigned long) ilen )
+ ctx->total[1]++;
+
+ if( left && ilen >= fill )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, fill );
+ sha2_process( ctx, ctx->buffer );
+ input += fill;
+ ilen -= fill;
+ left = 0;
+ }
+
+ while( ilen >= 64 )
+ {
+ sha2_process( ctx, input );
+ input += 64;
+ ilen -= 64;
+ }
+
+ if( ilen > 0 )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, ilen );
+ }
+}
+
+static const unsigned char sha2_padding[64] =
+{
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/*
+ * SHA-256 final digest
+ */
+void sha2_finish( sha2_context *ctx, unsigned char output[32] )
+{
+ unsigned long last, padn;
+ unsigned long high, low;
+ unsigned char msglen[8];
+
+ high = ( ctx->total[0] >> 29 )
+ | ( ctx->total[1] << 3 );
+ low = ( ctx->total[0] << 3 );
+
+ PUT_ULONG_BE( high, msglen, 0 );
+ PUT_ULONG_BE( low, msglen, 4 );
+
+ last = ctx->total[0] & 0x3F;
+ padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
+
+ sha2_update( ctx, (unsigned char *) sha2_padding, padn );
+ sha2_update( ctx, msglen, 8 );
+
+ PUT_ULONG_BE( ctx->state[0], output, 0 );
+ PUT_ULONG_BE( ctx->state[1], output, 4 );
+ PUT_ULONG_BE( ctx->state[2], output, 8 );
+ PUT_ULONG_BE( ctx->state[3], output, 12 );
+ PUT_ULONG_BE( ctx->state[4], output, 16 );
+ PUT_ULONG_BE( ctx->state[5], output, 20 );
+ PUT_ULONG_BE( ctx->state[6], output, 24 );
+
+ if( ctx->is224 == 0 )
+ PUT_ULONG_BE( ctx->state[7], output, 28 );
+}
+
+/*
+ * output = SHA-256( input buffer )
+ */
+void sha2( unsigned char *input, int ilen,
+ unsigned char output[32], int is224 )
+{
+ sha2_context ctx;
+
+ sha2_starts( &ctx, is224 );
+ sha2_update( &ctx, input, ilen );
+ sha2_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha2_context ) );
+}
+
+#if 0
+/*
+ * output = SHA-256( file contents )
+ */
+int sha2_file( char *path, unsigned char output[32], int is224 )
+{
+ FILE *f;
+ size_t n;
+ sha2_context ctx;
+ unsigned char buf[1024];
+
+ if( ( f = fopen( path, "rb" ) ) == NULL )
+ return( 1 );
+
+ sha2_starts( &ctx, is224 );
+
+ while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
+ sha2_update( &ctx, buf, (int) n );
+
+ sha2_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha2_context ) );
+
+ if( ferror( f ) != 0 )
+ {
+ fclose( f );
+ return( 2 );
+ }
+
+ fclose( f );
+ return( 0 );
+}
+#endif
+
+/*
+ * SHA-256 HMAC context setup
+ */
+void sha2_hmac_starts( sha2_context *ctx, unsigned char *key, int keylen,
+ int is224 )
+{
+ int i;
+ unsigned char sum[32];
+
+ if( keylen > 64 )
+ {
+ sha2( key, keylen, sum, is224 );
+ keylen = ( is224 ) ? 28 : 32;
+ key = sum;
+ }
+
+ memset( ctx->ipad, 0x36, 64 );
+ memset( ctx->opad, 0x5C, 64 );
+
+ for( i = 0; i < keylen; i++ )
+ {
+ ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
+ ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
+ }
+
+ sha2_starts( ctx, is224 );
+ sha2_update( ctx, ctx->ipad, 64 );
+
+ memset( sum, 0, sizeof( sum ) );
+}
+
+/*
+ * SHA-256 HMAC process buffer
+ */
+void sha2_hmac_update( sha2_context *ctx, unsigned char *input, int ilen )
+{
+ sha2_update( ctx, input, ilen );
+}
+
+/*
+ * SHA-256 HMAC final digest
+ */
+void sha2_hmac_finish( sha2_context *ctx, unsigned char output[32] )
+{
+ int is224, hlen;
+ unsigned char tmpbuf[32];
+
+ is224 = ctx->is224;
+ hlen = ( is224 == 0 ) ? 32 : 28;
+
+ sha2_finish( ctx, tmpbuf );
+ sha2_starts( ctx, is224 );
+ sha2_update( ctx, ctx->opad, 64 );
+ sha2_update( ctx, tmpbuf, hlen );
+ sha2_finish( ctx, output );
+
+ memset( tmpbuf, 0, sizeof( tmpbuf ) );
+}
+
+/*
+ * output = HMAC-SHA-256( hmac key, input buffer )
+ */
+void sha2_hmac( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char output[32], int is224 )
+{
+ sha2_context ctx;
+
+ sha2_hmac_starts( &ctx, key, keylen, is224 );
+ sha2_hmac_update( &ctx, input, ilen );
+ sha2_hmac_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha2_context ) );
+}
+
+/*
+* output = HMAC-SHA-256 ( hmac key, input buffer )
+*/
+void sha256_hmac( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char *output, int hlen)
+{
+ unsigned char temp[32];
+ sha2_hmac(key, keylen, input, ilen, temp, 0);
+ memcpy(output, temp, hlen);
+
+ memset(temp, 0, 32);
+}
+
+void KD_hmac_sha256( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char *output, int hlen)
+{
+ int i;
+ for(i=0;hlen/32;i++, hlen-=32)
+ {
+ sha256_hmac(key, keylen, input, ilen, &output[i*32], 32);
+ input = &output[i*32];
+ ilen = 32;
+ }
+
+ if (hlen>0)
+ sha256_hmac(key, keylen, input, ilen, &output[i*32], hlen);
+}
+
+#define WapiSMS4Encryption WapiSMS4Cryption
+#define WapiSMS4Decryption WapiSMS4Cryption
+
+#if (0)
+
+void WapiSMS4Encryption(uint8 *Key, uint8 *IV, uint8 *Input, uint16 InputLength,
+ uint8 *Output, uint16 *OutputLength);
+
+
+static unsigned char data_before_mic[2][70] =
+{
+ {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
+ 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
+ 0x00, 0xe0, 0x4c, 0x72, 0x00, 0x01, 0xc0, 0xa8,
+ 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xc0, 0xa8, 0x01, 0xfe},
+ {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,
+ 0x45, 0x00, 0x00, 0x3d, 0xbc, 0x7d, 0x00, 0x00,
+ 0x40, 0x01, 0x39, 0x74, 0xc0, 0xa8, 0x01, 0xfe,
+ 0xc0, 0xa8, 0x01, 0x80, 0x00, 0x00, 0xce, 0x5b,
+ 0x03, 0x00, 0x1a, 0x00, 0x61, 0x62, 0x63, 0x64,
+ 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
+ 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
+ 0x75, 0x76, 0x77, 0x61, 0x62, 0x63, 0x64, 0x65,
+ 0x66, 0x67, 0x68, 0x69, 0x6a }
+};
+
+static unsigned short data_before_mic_len[2] = {36, 69};
+
+static unsigned char data_before_mic_key[2][16] =
+{
+ {0x56, 0x65, 0xc2, 0x87, 0x04, 0x5c, 0x2b, 0x48,
+ 0xae, 0x42, 0xec, 0x83, 0x42, 0x48, 0x83, 0xed},
+ {0x7e, 0xb4, 0x5d, 0xaf, 0x23, 0xe6, 0x9c, 0x76,
+ 0xa7, 0xb4, 0x29, 0xe8, 0x79, 0xc7, 0x6a, 0xe8}
+};
+
+static unsigned char data_before_mic_head[2][34] =
+{
+ {0x88, 0x41, 0x00, 0xa9, 0x9a, 0x88, 0x89, 0x99,
+ 0x00, 0xe0, 0x4c, 0x72, 0x00, 0x01, 0x00, 0x00,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x24},
+ {0x88, 0x42, 0x00, 0xe0, 0x4c, 0x72, 0x00, 0x01,
+ 0x00, 0xa9, 0x9a, 0x88, 0x89, 0x99, 0x00, 0x00,
+ 0x00, 0xa9, 0x9a, 0x88, 0x89, 0x99, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x45}
+};
+static unsigned char data_before_mic_head_len[2] = {34, 34};
+
+static unsigned char data_mic_iv[2][16] =
+{
+ {0x92, 0x5c, 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c,
+ 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c},
+ {0x47, 0x5c, 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c,
+ 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c, 0x36, 0x5c}
+};
+
+static unsigned char data_after_mic[2][16] =
+{
+ {0x30, 0x50, 0xe3, 0xc9, 0x5b, 0x7c, 0x6a, 0x9d,
+ 0x1c, 0x2e, 0xd5, 0x8a, 0xc4, 0x77, 0x68, 0xba},
+ {0xcd, 0x59, 0x58, 0xfe, 0x62, 0x4c, 0x36, 0xaa,
+ 0x62, 0xe2, 0x1b, 0xab, 0x71, 0x5f, 0x25, 0x99}
+};
+
+/*
+* WAPI Encrypt test
+*/
+
+static unsigned char data_before_encrypt[1][96] =
+{
+ 0x88, 0x41, 0x00, 0x00, 0x00, 0x0B, 0xC0, 0x02,
+ 0x30, 0x73, 0x00, 0xE0, 0x4C, 0x81, 0x72, 0x0A,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x40, 0x5C, 0x36, 0x5C,
+ 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C,
+ 0x36, 0x5C, 0x36, 0x5C, 0xAA, 0xAA, 0x03, 0x00,
+ 0x00, 0x00, 0x08, 0x06, 0x00, 0x01, 0x08, 0x00,
+ 0x06, 0x04, 0x00, 0x01, 0x00, 0xE0, 0x4C, 0x81,
+ 0x72, 0x0A, 0xC0, 0xA8, 0x01, 0x7B, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xC0, 0xA8, 0x01, 0x7B,
+ 0x07, 0xE7, 0x81, 0x88, 0x2F, 0x98, 0xDF, 0xDD,
+ 0x9A, 0x23, 0xE2, 0x74, 0xA6, 0xEF, 0x35, 0xC1
+};
+
+static unsigned char data_before_encrypt_len[1] = {96};
+
+static unsigned char data_before_encrypt_key[1][16] =
+{
+ 0x83, 0x32, 0x29, 0x16, 0xDE, 0x93, 0x76, 0x38,
+ 0xAC, 0x13, 0x2F, 0xB2, 0xD4, 0x9B, 0xCA, 0x5A
+};
+
+static unsigned char data_before_encrypt_PN[1][16] =
+{
+ 0x40, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C,
+ 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C
+};
+
+static unsigned char data_after_encrypt[1][96] =
+{
+ 0x88, 0x41, 0x00, 0x00, 0x00, 0x0B, 0xC0, 0x02,
+ 0x30, 0x73, 0x00, 0xE0, 0x4C, 0x81, 0x72, 0x0A,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x40, 0x5C, 0x36, 0x5C,
+ 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C,
+ 0x36, 0x5C, 0x36, 0x5C, 0xE4, 0x0B, 0xA5, 0xDF,
+ 0x57, 0x10, 0xA5, 0x0C, 0x81, 0x38, 0xB8, 0xAE,
+ 0x32, 0xE9, 0x40, 0x6E, 0x57, 0xEC, 0x03, 0xA4,
+ 0x7F, 0x3C, 0x85, 0x1E, 0xC7, 0xF8, 0xA8, 0x8C,
+ 0xAA, 0xA7, 0xBC, 0xA7, 0xDC, 0xC8, 0x54, 0x60,
+ 0xFE, 0xC6, 0xD1, 0x0D, 0x8D, 0x79, 0x0E, 0xED,
+ 0xB4, 0xAA, 0x10, 0x6E, 0xBF, 0xE1, 0x86, 0xE3
+};
+
+/*
+* WAPI test vectors
+*/
+
+static unsigned char wapi_digest_test_key[4][37] =
+{
+ {0x01,0x02,0x03,0x04,0x05,0x06,0x7,0x08,
+ 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+ 0x011,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
+ 0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20},
+ {0x01,0x02,0x03,0x04,0x05,0x06,0x7,0x08,
+ 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+ 0x011,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
+ 0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,
+ 0x21,0x22,0x23,0x24,0x25},
+ {0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,
+ 0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,
+ 0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,
+ 0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b},
+ {0x4a,0x65,0x66,0x65}
+};
+
+static unsigned char wapi_digest_test_keylen[4] =
+{ 32, 37, 32, 4 };
+
+static unsigned char wapi_digest_test_buf[4][112] =
+{
+ {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
+ {0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,
+ 0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd},
+ {"Hi There"},
+ {"what do ya want for nothing?"}
+};
+
+static unsigned char wapi_digest_test_buflen[4] =
+{ 112, 50, 8, 28 };
+
+static unsigned char wapi_digest_test_output[4][32] =
+{
+ {0x47,0x03,0x05,0xfc,0x7e,0x40,0xfe,0x34,0xd3,0xee,0xb3,0xe7,0x73,0xd9,0x5a,0xab,0x73,0xac,0xf0,0xfd,0x06,0x04,0x47,0xa5,0xeb,0x45,0x95,0xbf,0x33,0xa9,0xd1,0xa3 },
+ {0xd4,0x63,0x3c,0x17,0xf6,0xfb,0x8d,0x74,0x4c,0x66,0xde,0xe0,0xf8,0xf0,0x74,0x55,0x6e,0xc4,0xaf,0x55,0xef,0x07,0x99,0x85,0x41,0x46,0x8e,0xb4,0x9b,0xd2,0xe9,0x17 },
+ {0x19,0x8a,0x60,0x7e,0xb4,0x4b,0xfb,0xc6,0x99,0x03,0xa0,0xf1,0xcf,0x2b,0xbd,0xc5,0xba,0x0a,0xa3,0xf3,0xd9,0xae,0x3c,0x1c,0x7a,0x3b,0x16,0x96,0xa0,0xb6,0x8c,0xf7 },
+ {0x5b,0xdc,0xc1,0x46,0xbf,0x60,0x75,0x4e,0x6a,0x04,0x24,0x26,0x08,0x95,0x75,0xc7,0x5a,0x00,0x3f,0x08,0x9d,0x27,0x39,0x83,0x9d,0xec,0x58,0xb9,0x64,0xec,0x38,0x43}
+};
+
+static unsigned char wapi_test_key[3][37] =
+{
+ {0x01,0x02,0x03,0x04,0x05,0x06,0x7,0x08,
+ 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+ 0x011,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
+ 0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20},
+ {0x01,0x02,0x03,0x04,0x05,0x06,0x7,0x08,
+ 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+ 0x011,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
+ 0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,
+ 0x21,0x22,0x23,0x24,0x25},
+ {0x01,0x02,0x03,0x04,0x05,0x06,0x7,0x08,
+ 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+ 0x011,0x12,0x13,0x14,0x15}
+};
+
+static const int wapi_test_keylen[3] =
+{
+ 32, 37, 16
+};
+
+static unsigned char wapi_test_buf[3][49] =
+{
+ {"pairwise key expansion for infrastructure unicast"},
+ {"group key expansion for multicast and broadcast"},
+ {"pre-share key expansion for adhoc network"}
+};
+
+static const int wapi_test_buflen[3] =
+{
+ 49, 47, 41
+};
+
+static unsigned char wapi_test_output[9][48] =
+{
+ /* 1-3 */
+ {0xe3,0xa6,0x45,0x46,0xf2,0xd1,0xf5,0xee,0xb7,0xd1,0xee,0x06,0xd2,0xc9,0xe5,0x4a,0x2c,0xc9,0xd6,0xce,0xc3,0xb7,0x6f,0xfd,0x62,0x63,0xf4,0x26,0xdc,0x25,0x39,0xaf,0xbd,0x98,0x80,0xa5,0x27,0xa1,0xb5,0x85,0x59,0x4b,0x57,0xce,0x33,0x21,0x4f,0x0c},
+ {0x3b,0x6e,0xca,0x4f,0x08,0x76,0xc4,0x3a,0xb3,0x1b,0x26,0x3f,0x2c,0x38,0xb8,0x81,0x21,0xb5,0x68,0xe5,0xf8,0xfd,0x1d,0x4c,0xfa,0x4c,0x7f,0x8c,0x60,0x97,0x04,0x3d,0x7b,0x40,0xa8,0x63,0xb9,0x43,0xb9,0xf5,0xbb,0x37,0x2f,0x3a,0xdd,0xa5,0xda,0x27},
+ {0xbc,0x29,0xf3,0xe6,0x09,0x1f,0x6a,0xc9,0x0b,0xa0,0x20,0x61,0x92,0x12,0x48,0x69,0x5f,0xee,0xff,0x1a,0x4c,0xab,0x53,0x3b,0x11,0x67,0xd8,0x54,0x5f,0x93,0x5f,0x28,0x11,0x84,0xc9,0xbb,0x32,0xf9,0x87,0xb9,0x86,0x81,0x0f,0xfb,0x17,0xc4,0x10,0xf5},
+ /* 4-6 */
+ {
+ 0x20,0x8f,0x72,0x54,0xa4,0xbf,0x56,0xf0,0xfa,0x49,0x5f,0xe1,
+ 0x0c,0x99,0x15,0x05,0x92,0xed,0x79,0xdf,0x57,0x74,0xa9,0x6e,
+ 0x13,0x97,0x1e,0xc4,0xa1,0x5e,0x16,0xa7,0xed,0x75,0xf5,0xe5,
+ 0x44,0xbb,0xd3,0x35,0x67,0xeb,0x88,0xe7,0x83,0x24,0xa9,0xd2
+ },
+ {
+ 0x33,0x32,0x61,0x7a,0x90,0x8e,0xa5,0xa0,0x7f,0xfa,0x1d,0x23,
+ 0x79,0xf3,0xd8,0x3e,0x8b,0xe9,0x14,0x1f,0x15,0x53,0x8f,0xd3,
+ 0xef,0xde,0x58,0x01,0x19,0xe8,0xc5,0x09,0x5d,0x25,0xb2,0xd3,
+ 0x0a,0xc7,0xa6,0x35,0xad,0xb4,0x3c,0x6c,0xac,0xf0,0xaa,0x2b
+ },
+ {
+ 0xf2,0xcb,0xf1,0x1c,0x6d,0x40,0xb8,0x09,0xd0,0xc0,0xed,0x48,
+ 0x2a,0x4a,0x1b,0x6a,0x15,0x1a,0xf1,0xfb,0x4c,0x80,0xf9,0x80,
+ 0x5c,0x93,0xe5,0x6e,0xb1,0xcf,0x5c,0xb5,0xec,0xc1,0x3e,0x7a,
+ 0xbc,0xaf,0xe0,0xa7,0xd2,0x59,0x5d,0x51,0x9b,0x76,0x9a,0x24
+ },
+ /* 7-9 */
+ {
+ 0xc0,0x7a,0xd8,0x32,0x25,0x2a,0x0c,0x14,0x76,0x18,0xf4,0xc0,
+ 0xd0,0x6b,0x35,0xf4,0xf6,0xd6,0x73,0x5d,0x1a,0xa3,0x8e,0x47,
+ 0x9a,0x7e,0xe0,0xac,0x1c,0x0c,0x38,0x5b,0x2d,0x33,0x28,0x74,
+ 0x1e,0x4d,0xa0,0xc8,0x76,0xfc,0x6c,0xc9,0xe3,0x60,0xc8,0xd7
+ },
+ {
+ 0xf0,0x0b,0xee,0xf2,0xf5,0x5f,0x85,0xd8,0xee,0xb0,0x6f,0x8c,
+ 0xc4,0x1b,0xe6,0x0e,0xc2,0x69,0xf5,0x82,0x9a,0x0b,0x6e,0xfb,
+ 0x2d,0x9b,0x49,0x5e,0xb1,0x87,0xd3,0x58,0x59,0x68,0x88,0xc3,
+ 0xd2,0x6f,0x94,0x9f,0x8d,0x2e,0x41,0xfe,0xbc,0xbb,0xb9,0x9a
+ },
+ {
+ 0x05,0x8e,0xb8,0x7c,0xff,0x82,0x66,0x47,0xde,0x50,0x7b,0x14,
+ 0x17,0xac,0x99,0x6e,0xb5,0x7f,0xcf,0x11,0xfd,0xfc,0x83,0xbe,
+ 0x59,0xd5,0x85,0xf4,0xa7,0x3e,0x69,0x7d,0xd4,0x38,0xe3,0x34,
+ 0xfe,0xbb,0x06,0x7d,0x14,0x6f,0x01,0x31,0xa6,0x96,0x4f,0x26
+ },
+};
+
+static const int wapi_test_outputlen[3] =
+{
+ 48, 48, 48
+};
+
+
+/*
+ * FIPS-180-2 test vectors
+ */
+static unsigned char sha2_test_buf[3][57] =
+{
+ { "abc" },
+ { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
+ { "" }
+};
+
+static const int sha2_test_buflen[3] =
+{
+ 3, 56, 1000
+};
+
+static const unsigned char sha2_test_sum[6][32] =
+{
+ /*
+ * SHA-224 test vectors
+ */
+ { 0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22,
+ 0x86, 0x42, 0xA4, 0x77, 0xBD, 0xA2, 0x55, 0xB3,
+ 0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0, 0xB3, 0xF7,
+ 0xE3, 0x6C, 0x9D, 0xA7 },
+ { 0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC,
+ 0x5D, 0xBA, 0x5D, 0xA1, 0xFD, 0x89, 0x01, 0x50,
+ 0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5, 0x8B, 0x19,
+ 0x52, 0x52, 0x25, 0x25 },
+ { 0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8,
+ 0xBB, 0xB4, 0xC1, 0xEA, 0x97, 0x61, 0x8A, 0x4B,
+ 0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48, 0xB2, 0xEE,
+ 0x4E, 0xE7, 0xAD, 0x67 },
+
+ /*
+ * SHA-256 test vectors
+ */
+ { 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
+ 0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
+ 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
+ 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD },
+ { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
+ 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
+ 0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
+ 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 },
+ { 0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92,
+ 0x81, 0xA1, 0xC7, 0xE2, 0x84, 0xD7, 0x3E, 0x67,
+ 0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97, 0x20, 0x0E,
+ 0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0 }
+};
+
+/*
+ * RFC 4231 test vectors
+ */
+static unsigned char sha2_hmac_test_key[7][26] =
+{
+ { "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B"
+ "\x0B\x0B\x0B\x0B" },
+ { "Jefe" },
+ { "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
+ "\xAA\xAA\xAA\xAA" },
+ { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
+ "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
+ { "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C"
+ "\x0C\x0C\x0C\x0C" },
+ { "" }, /* 0xAA 131 times */
+ { "" }
+};
+
+static const int sha2_hmac_test_keylen[7] =
+{
+ 20, 4, 20, 25, 20, 131, 131
+};
+
+static unsigned char sha2_hmac_test_buf[7][153] =
+{
+ { "Hi There" },
+ { "what do ya want for nothing?" },
+ { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
+ { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
+ { "Test With Truncation" },
+ { "Test Using Larger Than Block-Size Key - Hash Key First" },
+ { "This is a test using a larger than block-size key "
+ "and a larger than block-size data. The key needs to "
+ "be hashed before being used by the HMAC algorithm." }
+};
+
+static const int sha2_hmac_test_buflen[7] =
+{
+ 8, 28, 50, 50, 20, 54, 152
+};
+
+static const unsigned char sha2_hmac_test_sum[14][32] =
+{
+ /*
+ * HMAC-SHA-224 test vectors
+ */
+ { 0x89, 0x6F, 0xB1, 0x12, 0x8A, 0xBB, 0xDF, 0x19,
+ 0x68, 0x32, 0x10, 0x7C, 0xD4, 0x9D, 0xF3, 0x3F,
+ 0x47, 0xB4, 0xB1, 0x16, 0x99, 0x12, 0xBA, 0x4F,
+ 0x53, 0x68, 0x4B, 0x22 },
+ { 0xA3, 0x0E, 0x01, 0x09, 0x8B, 0xC6, 0xDB, 0xBF,
+ 0x45, 0x69, 0x0F, 0x3A, 0x7E, 0x9E, 0x6D, 0x0F,
+ 0x8B, 0xBE, 0xA2, 0xA3, 0x9E, 0x61, 0x48, 0x00,
+ 0x8F, 0xD0, 0x5E, 0x44 },
+ { 0x7F, 0xB3, 0xCB, 0x35, 0x88, 0xC6, 0xC1, 0xF6,
+ 0xFF, 0xA9, 0x69, 0x4D, 0x7D, 0x6A, 0xD2, 0x64,
+ 0x93, 0x65, 0xB0, 0xC1, 0xF6, 0x5D, 0x69, 0xD1,
+ 0xEC, 0x83, 0x33, 0xEA },
+ { 0x6C, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3C, 0xAC,
+ 0x6A, 0x2A, 0xBC, 0x1B, 0xB3, 0x82, 0x62, 0x7C,
+ 0xEC, 0x6A, 0x90, 0xD8, 0x6E, 0xFC, 0x01, 0x2D,
+ 0xE7, 0xAF, 0xEC, 0x5A },
+ { 0x0E, 0x2A, 0xEA, 0x68, 0xA9, 0x0C, 0x8D, 0x37,
+ 0xC9, 0x88, 0xBC, 0xDB, 0x9F, 0xCA, 0x6F, 0xA8 },
+ { 0x95, 0xE9, 0xA0, 0xDB, 0x96, 0x20, 0x95, 0xAD,
+ 0xAE, 0xBE, 0x9B, 0x2D, 0x6F, 0x0D, 0xBC, 0xE2,
+ 0xD4, 0x99, 0xF1, 0x12, 0xF2, 0xD2, 0xB7, 0x27,
+ 0x3F, 0xA6, 0x87, 0x0E },
+ { 0x3A, 0x85, 0x41, 0x66, 0xAC, 0x5D, 0x9F, 0x02,
+ 0x3F, 0x54, 0xD5, 0x17, 0xD0, 0xB3, 0x9D, 0xBD,
+ 0x94, 0x67, 0x70, 0xDB, 0x9C, 0x2B, 0x95, 0xC9,
+ 0xF6, 0xF5, 0x65, 0xD1 },
+
+ /*
+ * HMAC-SHA-256 test vectors
+ */
+ { 0xB0, 0x34, 0x4C, 0x61, 0xD8, 0xDB, 0x38, 0x53,
+ 0x5C, 0xA8, 0xAF, 0xCE, 0xAF, 0x0B, 0xF1, 0x2B,
+ 0x88, 0x1D, 0xC2, 0x00, 0xC9, 0x83, 0x3D, 0xA7,
+ 0x26, 0xE9, 0x37, 0x6C, 0x2E, 0x32, 0xCF, 0xF7 },
+ { 0x5B, 0xDC, 0xC1, 0x46, 0xBF, 0x60, 0x75, 0x4E,
+ 0x6A, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xC7,
+ 0x5A, 0x00, 0x3F, 0x08, 0x9D, 0x27, 0x39, 0x83,
+ 0x9D, 0xEC, 0x58, 0xB9, 0x64, 0xEC, 0x38, 0x43 },
+ { 0x77, 0x3E, 0xA9, 0x1E, 0x36, 0x80, 0x0E, 0x46,
+ 0x85, 0x4D, 0xB8, 0xEB, 0xD0, 0x91, 0x81, 0xA7,
+ 0x29, 0x59, 0x09, 0x8B, 0x3E, 0xF8, 0xC1, 0x22,
+ 0xD9, 0x63, 0x55, 0x14, 0xCE, 0xD5, 0x65, 0xFE },
+ { 0x82, 0x55, 0x8A, 0x38, 0x9A, 0x44, 0x3C, 0x0E,
+ 0xA4, 0xCC, 0x81, 0x98, 0x99, 0xF2, 0x08, 0x3A,
+ 0x85, 0xF0, 0xFA, 0xA3, 0xE5, 0x78, 0xF8, 0x07,
+ 0x7A, 0x2E, 0x3F, 0xF4, 0x67, 0x29, 0x66, 0x5B },
+ { 0xA3, 0xB6, 0x16, 0x74, 0x73, 0x10, 0x0E, 0xE0,
+ 0x6E, 0x0C, 0x79, 0x6C, 0x29, 0x55, 0x55, 0x2B },
+ { 0x60, 0xE4, 0x31, 0x59, 0x1E, 0xE0, 0xB6, 0x7F,
+ 0x0D, 0x8A, 0x26, 0xAA, 0xCB, 0xF5, 0xB7, 0x7F,
+ 0x8E, 0x0B, 0xC6, 0x21, 0x37, 0x28, 0xC5, 0x14,
+ 0x05, 0x46, 0x04, 0x0F, 0x0E, 0xE3, 0x7F, 0x54 },
+ { 0x9B, 0x09, 0xFF, 0xA7, 0x1B, 0x94, 0x2F, 0xCB,
+ 0x27, 0x63, 0x5F, 0xBC, 0xD5, 0xB0, 0xE9, 0x44,
+ 0xBF, 0xDC, 0x63, 0x64, 0x4F, 0x07, 0x13, 0x93,
+ 0x8A, 0x7F, 0x51, 0x53, 0x5C, 0x3A, 0x35, 0xE2 }
+};
+
+extern void WapiSMS4CalculateMic(uint8 *Key, uint8 *IV, uint8 *Input1, uint8 Input1Length,
+ uint8 *Input2, uint16 Input2Length, uint8 *Output);
+
+/*
+ * Checkup routine
+ */
+int sha2_self_test( int verbose )
+{
+ int i, j, k, buflen;
+ unsigned char buf[1024];
+ unsigned char sha2sum[32];
+ sha2_context ctx;
+
+ for( i = 0; i < 6; i++ )
+ {
+ j = i % 3;
+ k = i < 3;
+
+ if( verbose != 0 )
+ printk( " SHA-%d test #%d: ", 256 - k * 32, j + 1 );
+
+ sha2_starts( &ctx, k );
+
+ if( j == 2 )
+ {
+ memset( buf, 'a', buflen = 1000 );
+
+ for( j = 0; j < 1000; j++ )
+ sha2_update( &ctx, buf, buflen );
+ }
+ else
+ sha2_update( &ctx, sha2_test_buf[j],
+ sha2_test_buflen[j] );
+
+ sha2_finish( &ctx, sha2sum );
+
+ if( memcmp( sha2sum, sha2_test_sum[i], 32 - k * 4 ) != 0 )
+ {
+ if( verbose != 0 )
+ printk( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printk( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printk( "\n" );
+
+ for( i = 0; i < 14; i++ )
+ {
+ j = i % 7;
+ k = i < 7;
+
+ if( verbose != 0 )
+ printk( " HMAC-SHA-%d test #%d: ", 256 - k * 32, j + 1 );
+
+ if( j == 5 || j == 6 )
+ {
+ memset( buf, '\xAA', buflen = 131 );
+ sha2_hmac_starts( &ctx, buf, buflen, k );
+ }
+ else
+ sha2_hmac_starts( &ctx, sha2_hmac_test_key[j],
+ sha2_hmac_test_keylen[j], k );
+
+ sha2_hmac_update( &ctx, sha2_hmac_test_buf[j],
+ sha2_hmac_test_buflen[j] );
+
+ sha2_hmac_finish( &ctx, sha2sum );
+
+ buflen = ( j == 4 ) ? 16 : 32 - k * 4;
+
+ if( memcmp( sha2sum, sha2_hmac_test_sum[i], buflen ) != 0 )
+ {
+ if( verbose != 0 )
+ printk( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printk( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printk( "\n" );
+
+ for (i=0;i<4;i++)
+ {
+ sha256_hmac(&wapi_digest_test_key[i][0], wapi_digest_test_keylen[i],
+ &wapi_digest_test_buf[i][0], wapi_digest_test_buflen[i],
+ buf, 32);
+ if ( memcmp(buf, wapi_digest_test_output[i], 32) )
+ printk("WAPI digest test failed: Case[%d]\n", i);
+ else
+ printk("WAPI digest test Passed: Case[%d]\n", i);
+ }
+
+ for(i=0;i<3;i++)
+ {
+ for(j=0;j<3;j++)
+ {
+#if 1
+ KD_hmac_sha256(&wapi_test_key[j][0],wapi_test_keylen[j],
+ &wapi_test_buf[i][0], wapi_test_buflen[i],
+ buf, 48);
+#else
+ KD_hmac_sha256(wapi_test_buf[i],wapi_test_buflen[i],
+ wapi_test_key[i], wapi_test_keylen[i],
+ buf, wapi_test_outputlen[i]);
+#endif
+ if ( memcmp(buf, &wapi_test_output[(i*3)+j][0], 48))
+ {
+ printk("WAPI test failed: Case[%d]:Index[%d]\n", i,j);
+ }
+ else
+ {
+ printk("WAPI test Passed: Case[%d]:Index[%d]\n", i,j);
+ }
+ }
+ }
+
+#if 0
+ printk("Start test WAPI Encryption:\n");
+ /* test wapi encryption */
+ {
+ uint16 buflen2;
+ char* ptrBuf;
+
+ buflen2 = 0;
+ ptrBuf = buf+44;
+ memcpy(buf, &data_before_encrypt[0][0], 44);
+ WapiSMS4Encryption(&data_before_encrypt_key[0][0], &data_before_encrypt_PN[0][0],
+ &data_before_encrypt[0][0]+44, data_before_encrypt_len[0]-44, ptrBuf, &buflen2);
+
+ if (buflen2!=data_before_encrypt_len[0]-44)
+ printk("WAPI Encryption length error: [%d]:[%d]\n", data_before_encrypt_len[0], buflen2);
+ else
+ printk("WAPI Encryption length OK: [%d]:[%d]\n", data_before_encrypt_len[0], buflen2);
+
+ if (memcmp(buf, &data_after_encrypt[0][0], buflen2+44))
+ {
+ printk("***********************************************************\n");
+ memDump(buf, buflen2+44, "buf");
+ memDump(&data_after_encrypt[0][0], buflen2+44, "enc1");
+ printk("***********************************************************\n");
+ printk("WAPI Encryption failed.\n");
+ //memDump(buf, 16, "DATA");
+ }
+ else
+ printk("WAPI Encryption OK.\n");
+ }
+
+ printk("Mic check test:\n");
+ for(i=0;i<2;i++)
+ {
+ WapiSMS4CalculateMic(&data_before_mic_key[i][0], &data_mic_iv[i][0],
+ &data_before_mic_head[i][0], data_before_mic_head_len[i],
+ &data_before_mic[i][0], data_before_mic_len[i], buf);
+
+ if (memcmp(buf, &data_after_mic[i][0], SMS4_MIC_LEN))
+ {
+ printk("***********************************************************\n");
+ memDump(buf, SMS4_MIC_LEN, "buf");
+ memDump(&data_after_mic[i][0], SMS4_MIC_LEN, "mic");
+ printk("***********************************************************\n");
+ printk("WAPI MIC idx %d check failed.\n", i);
+ }
+ else
+ printk("WAPI MIC idx %d check OK.\n", i);
+ }
+#endif
+
+ return( 0 );
+}
+
+#endif
+
+typedef unsigned char muint8;
+typedef unsigned short muint16;
+typedef unsigned int muint32;
+
+static muint8 wapiCryptoTemp[16];
+static muint8 wapiBlockIn[16], wapiTempBlock[16];
+static muint32 wapiRK[32];
+static muint8 wapiDecrytBuf[MAXDATALEN];
+static muint8 wapiDecrytHdrBuf[64];
+
+__DRAM_IN_865X
+muint8 Sbox[256];
+__DRAM_IN_865X
+muint32 CK[32];
+
+#define Rotl(_x, _y) (((_x) << (_y)) | ((_x) >> (32 - (_y))))
+
+#define ByteSub(_A) (Sbox[(_A) >> 24] << 24 ^ \
+ Sbox[(_A) >> 16 & 0xFF] << 16 ^ \
+ Sbox[(_A) >> 8 & 0xFF] << 8 ^ \
+ Sbox[(_A) & 0xFF])
+
+#define L1(_B) ((_B) ^ Rotl(_B, 2) ^ Rotl(_B, 10) ^ Rotl(_B, 18) ^ Rotl(_B, 24))
+#define L2(_B) ((_B) ^ Rotl(_B, 13) ^ Rotl(_B, 23))
+static inline void
+xor_block(void *dst, void *src1, void *src2)
+/* 128-bit xor: *dst = *src1 xor *src2. Pointers must be 32-bit aligned */
+{
+ ((uint32*)dst)[0] = ((uint32*)src1)[0] ^ ((uint32*)src2)[0];
+ ((uint32*)dst)[1] = ((uint32*)src1)[1] ^ ((uint32*)src2)[1];
+ ((uint32*)dst)[2] = ((uint32*)src1)[2] ^ ((uint32*)src2)[2];
+ ((uint32*)dst)[3] = ((uint32*)src1)[3] ^ ((uint32*)src2)[3];
+}
+int32 init_SMS4_CK_Sbox(void)
+{
+ static muint8 Sbox_tmp[256] = {
+ 0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05,
+ 0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99,
+ 0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62,
+ 0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6,
+ 0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8,
+ 0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35,
+ 0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87,
+ 0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e,
+ 0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1,
+ 0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3,
+ 0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f,
+ 0xd5,0xdb,0x37,0x45,0xde,0xfd,0x8e,0x2f,0x03,0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51,
+ 0x8d,0x1b,0xaf,0x92,0xbb,0xdd,0xbc,0x7f,0x11,0xd9,0x5c,0x41,0x1f,0x10,0x5a,0xd8,
+ 0x0a,0xc1,0x31,0x88,0xa5,0xcd,0x7b,0xbd,0x2d,0x74,0xd0,0x12,0xb8,0xe5,0xb4,0xb0,
+ 0x89,0x69,0x97,0x4a,0x0c,0x96,0x77,0x7e,0x65,0xb9,0xf1,0x09,0xc5,0x6e,0xc6,0x84,
+ 0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48
+ };
+
+ static muint32 CK_tmp[32] = {
+ 0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
+ 0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
+ 0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
+ 0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
+ 0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
+ 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
+ 0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
+ 0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279 };
+
+ memcpy(Sbox,Sbox_tmp, sizeof(muint8)*256);
+ memcpy(CK,CK_tmp,sizeof(muint32)*32);
+
+ return SUCCESS;
+}
+
+static void SMS4Crypt(muint8 *Input, muint8 *Output, muint32 *rk)
+{
+ muint32 r, mid, x0, x1, x2, x3, *p;
+ p = (muint32 *)Input;
+ x0 = p[0];
+ x1 = p[1];
+ x2 = p[2];
+ x3 = p[3];
+#ifdef _LITTLE_ENDIAN_
+ x0 = Rotl(x0, 16); x0 = ((x0 & 0x00FF00FF) << 8) ^ ((x0 & 0xFF00FF00) >> 8);
+ x1 = Rotl(x1, 16); x1 = ((x1 & 0x00FF00FF) << 8) ^ ((x1 & 0xFF00FF00) >> 8);
+ x2 = Rotl(x2, 16); x2 = ((x2 & 0x00FF00FF) << 8) ^ ((x2 & 0xFF00FF00) >> 8);
+ x3 = Rotl(x3, 16); x3 = ((x3 & 0x00FF00FF) << 8) ^ ((x3 & 0xFF00FF00) >> 8);
+#endif
+ for (r = 0; r < 32; r += 4)
+ {
+ mid = x1 ^ x2 ^ x3 ^ rk[r + 0];
+ mid = ByteSub(mid);
+ x0 ^= L1(mid);
+ mid = x2 ^ x3 ^ x0 ^ rk[r + 1];
+ mid = ByteSub(mid);
+ x1 ^= L1(mid);
+ mid = x3 ^ x0 ^ x1 ^ rk[r + 2];
+ mid = ByteSub(mid);
+ x2 ^= L1(mid);
+ mid = x0 ^ x1 ^ x2 ^ rk[r + 3];
+ mid = ByteSub(mid);
+ x3 ^= L1(mid);
+ }
+#ifdef _LITTLE_ENDIAN_
+ x0 = Rotl(x0, 16); x0 = ((x0 & 0x00FF00FF) << 8) ^ ((x0 & 0xFF00FF00) >> 8);
+ x1 = Rotl(x1, 16); x1 = ((x1 & 0x00FF00FF) << 8) ^ ((x1 & 0xFF00FF00) >> 8);
+ x2 = Rotl(x2, 16); x2 = ((x2 & 0x00FF00FF) << 8) ^ ((x2 & 0xFF00FF00) >> 8);
+ x3 = Rotl(x3, 16); x3 = ((x3 & 0x00FF00FF) << 8) ^ ((x3 & 0xFF00FF00) >> 8);
+#endif
+ p = (muint32 *)Output;
+ p[0] = x3;
+ p[1] = x2;
+ p[2] = x1;
+ p[3] = x0;
+}
+
+static void SMS4KeyExt(muint8 *Key, muint32 *rk)
+{
+ muint32 r, mid, x0, x1, x2, x3, *p;
+ p = (muint32 *)Key;
+ x0 = p[0];
+ x1 = p[1];
+ x2 = p[2];
+ x3 = p[3];
+#ifdef _LITTLE_ENDIAN_
+ x0 = Rotl(x0, 16); x0 = ((x0 & 0xFF00FF) << 8) ^ ((x0 & 0xFF00FF00) >> 8);
+ x1 = Rotl(x1, 16); x1 = ((x1 & 0xFF00FF) << 8) ^ ((x1 & 0xFF00FF00) >> 8);
+ x2 = Rotl(x2, 16); x2 = ((x2 & 0xFF00FF) << 8) ^ ((x2 & 0xFF00FF00) >> 8);
+ x3 = Rotl(x3, 16); x3 = ((x3 & 0xFF00FF) << 8) ^ ((x3 & 0xFF00FF00) >> 8);
+#endif
+
+ x0 ^= 0xa3b1bac6;
+ x1 ^= 0x56aa3350;
+ x2 ^= 0x677d9197;
+ x3 ^= 0xb27022dc;
+ for (r = 0; r < 32; r += 4)
+ {
+ mid = x1 ^ x2 ^ x3 ^ CK[r + 0];
+ mid = ByteSub(mid);
+ rk[r + 0] = x0 ^= L2(mid);
+ mid = x2 ^ x3 ^ x0 ^ CK[r + 1];
+ mid = ByteSub(mid);
+ rk[r + 1] = x1 ^= L2(mid);
+ mid = x3 ^ x0 ^ x1 ^ CK[r + 2];
+ mid = ByteSub(mid);
+ rk[r + 2] = x2 ^= L2(mid);
+ mid = x0 ^ x1 ^ x2 ^ CK[r + 3];
+ mid = ByteSub(mid);
+ rk[r + 3] = x3 ^= L2(mid);
+ }
+}
+
+void WapiSMS4Cryption(muint8 *Key, muint8 *IV, muint8 *Input, muint16 InputLength,
+ muint8 *Output, muint16 *OutputLength)
+{
+ muint32 blockNum,i,j;
+ muint16 remainder;
+ muint8 *pBlockIn, *pBlockOut, *pBlockTemp;
+
+ remainder = InputLength & 0x0F;
+ blockNum = InputLength >> 4;
+
+ for(i=0;i<16;i++)
+ wapiBlockIn[i] = IV[15-i];
+
+ SMS4KeyExt((muint8 *)Key, wapiRK);
+
+ pBlockIn = wapiBlockIn;
+ pBlockOut = wapiTempBlock;
+ for(i=0; i<blockNum; i++)
+ {
+ SMS4Crypt((muint8 *)pBlockIn, pBlockOut, wapiRK);
+ xor_block(Output, Input, pBlockOut);
+ pBlockTemp = pBlockIn;
+ pBlockIn = pBlockOut;
+ pBlockOut = pBlockTemp;
+ Output += 16;
+ Input += 16;
+ }
+
+ if (remainder>0)
+ {
+ *OutputLength = (i<<4) + remainder;
+ SMS4Crypt((muint8 *)pBlockIn, pBlockOut, wapiRK);
+
+ for(j=0; j<remainder; j++)
+ {
+ Output[j] = Input[j] ^ pBlockOut[j];
+ }
+ }
+ else
+ *OutputLength = i<<4;
+}
+
+void WapiSMS4CalculateMic(muint8 *Key, muint8 *IV, muint8 *Input1, muint8 Input1Length,
+ muint8 *Input2, muint16 Input2Length, muint8 *Output)
+{
+ muint32 blockNum,i;
+ muint32 remainder;
+ muint8 BlockOut[16];
+
+ remainder = Input1Length & 0x0F;
+ blockNum = Input1Length >> 4;
+
+ for(i=0;i<16;i++)
+ wapiBlockIn[i] = IV[15-i];
+
+ SMS4KeyExt((muint8 *)Key, wapiRK);
+ SMS4Crypt((muint8 *)wapiBlockIn, BlockOut, wapiRK);
+
+ for(i=0; i<blockNum; i++)
+ {
+ xor_block(wapiBlockIn, Input1, BlockOut);
+ SMS4Crypt((muint8 *)wapiBlockIn, BlockOut, wapiRK);
+ Input1 += 16;
+ }
+
+ if(remainder !=0)
+ {
+ memset(wapiTempBlock+remainder, 0, 16-remainder);
+ memcpy(wapiTempBlock, Input1, remainder);
+
+ xor_block(wapiBlockIn, wapiTempBlock, BlockOut);
+ SMS4Crypt((muint8 *)wapiBlockIn, BlockOut, wapiRK);
+ }
+
+ remainder = Input2Length & 0x0F;
+ blockNum = Input2Length >> 4;
+
+ for(i=0; i<blockNum; i++)
+ {
+ xor_block(wapiBlockIn, Input2, BlockOut);
+ SMS4Crypt((muint8 *)wapiBlockIn, BlockOut, wapiRK);
+ Input2 += 16;
+ }
+
+ if(remainder !=0)
+ {
+ memset(wapiTempBlock+remainder, 0, 16-remainder);
+ memcpy(wapiTempBlock, Input2, remainder);
+
+ xor_block(wapiBlockIn, wapiTempBlock, BlockOut);
+ SMS4Crypt((muint8 *)wapiBlockIn, BlockOut, wapiRK);
+ }
+
+ memcpy(Output, BlockOut, 16);
+}
+
+void WapiSMS4ForMNKEncrypt(uint8 *key, uint8*IV, uint8*input, uint32 inputLength, uint8 *output, uint8 *outputLength, uint32 CryptFlag)
+{
+ uint32 blockNum,i,j;
+ uint32 remainder;
+
+ *outputLength = 0;
+ remainder = inputLength % 16;
+ blockNum = inputLength/16;
+ if(remainder !=0)
+ blockNum++;
+
+ if(remainder !=0)
+ {
+ for(j= inputLength;j<16*blockNum;j++)
+ {
+ input[j] = 0;
+ }
+ }
+
+ memcpy(wapiBlockIn,IV,16);
+ SMS4KeyExt((uint8 *)key, wapiRK);
+
+ for(i=0;i<blockNum;i++)
+ {
+ SMS4Crypt(wapiBlockIn, wapiTempBlock, wapiRK);
+ *outputLength+=16;
+
+ for(j=0;j<16;j++)
+ {
+ output[i*16+j] = input[i*16+j] ^ wapiTempBlock[j];
+ }
+
+ memcpy(wapiBlockIn,wapiTempBlock,16);
+ }
+
+}
+
+void SecCalculateMicSMS4(
+ uint8 KeyIdx,
+ uint8* MicKey,
+ uint8* pHeader,
+ uint8* pData,
+ uint16 DataLen,
+ uint8* MicBuffer
+ )
+{
+ static uint8 TempBuf[34];
+ uint8 TempLen;
+ uint8 QosOffset;
+ uint8* IV;
+ uint16* pTemp;
+
+ /* construct the first part */
+#if 0
+ memcpy(TempBuf, pHeader, 2); //FrameCtrl
+#else
+ *((uint16*)TempBuf) = *((uint16*)pHeader);
+#endif
+ pTemp = (uint16*)TempBuf;
+
+#if 0
+#ifdef _LITTLE_ENDIAN_
+ *pTemp &= 0xc78f; //bit4,5,6,11,12,13
+#else
+ *pTemp &= 0x8fc7;
+#endif
+#else
+#ifdef _LITTLE_ENDIAN_
+ *((unsigned short*)TempBuf) &= 0xc78f;
+#else
+ *((unsigned short*)TempBuf) &= 0x8fc7;
+#endif
+#endif
+ memcpy((TempBuf+2), (pHeader+4), 12); //Addr1, Addr2
+ memcpy((TempBuf+14), (pHeader+22), 2); // SeqCtrl
+ pTemp = (uint16*)(TempBuf + 14);
+
+#if 0
+#ifdef _LITTLE_ENDIAN_
+ *pTemp &= 0x000f;
+#else
+ *pTemp &= 0x0f00;
+#endif
+#else
+#ifdef _LITTLE_ENDIAN_
+ *((uint16*)(TempBuf+14)) &= 0x000f;
+#else
+ *((uint16*)(TempBuf+14)) &= 0x0f00;
+#endif
+#endif
+ memcpy((TempBuf+16), (pHeader+16), 6); //Addr3
+
+ if (get_tofr_ds(pHeader) == 3)
+ {
+ memcpy((TempBuf+22), (pHeader+24), 6);
+ QosOffset = 30;
+ }
+ else
+ {
+ memset((TempBuf+22), 0, 6);
+ QosOffset = 24;
+ }
+
+ if( is_qos_data(pHeader) ) //QosCtrl
+ {
+ memcpy((TempBuf+28), (pHeader+QosOffset), 2);
+ TempLen = 34;
+ IV = pHeader + QosOffset + 4;
+ }
+ else
+ {
+ TempLen = 32;
+ IV = pHeader + QosOffset + 2;
+ }
+
+ TempBuf[TempLen-1] = (uint8)(DataLen & 0xff);
+ TempBuf[TempLen-2] = (uint8)((DataLen & 0xff00)>>8);
+ TempBuf[TempLen-3] = 0;
+ TempBuf[TempLen-4] = KeyIdx;
+
+ WapiSMS4CalculateMic(MicKey, IV, TempBuf, TempLen,
+ pData, DataLen, MicBuffer);
+}
+
+#if 1
+void SecSWSMS4Encryption(struct rtl8192cd_priv *priv, struct tx_insn* txcfg)
+{
+ uint16 OutputLength;
+ wapiStaInfo *wapiInfo;
+ uint8 *pHeader;
+ uint8 KeyIdx;
+ uint8 *MicBuffer;
+ uint8 *pMicKey;
+ uint8 *pDataKey;
+ uint8 *pPN;
+ wpiSMS4Hdr *SMS4Hdr;
+/* uint8 pTemp[SMS4_MIC_LEN]; */
+ uint8 *pBuf;
+ int32 bPNOverflow;
+#if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ uint32 bHWEncrypt;
+#endif
+ struct stat_info *pstat;
+
+#if 0
+ if (txcfg->fr_type != _SKB_FRAME_TYPE_)
+ return;
+#endif
+ pHeader = txcfg->phdr; /* txcfg->hdr_len */
+ {
+ WAPI_LOCK(&priv->pshare->lock);
+ if ( !txcfg->pstat )
+ {
+ /* multicast */
+ //pstat=priv->stainfo_cache.pstat;
+ pstat = priv->pstat_cache;
+ KeyIdx = priv->wapiMCastKeyId;
+ pPN = priv->txMCast;
+ pMicKey = priv->wapiMCastKey[KeyIdx].micKey;
+ pDataKey = priv->wapiMCastKey[KeyIdx].dataKey;
+ bPNOverflow = WapiIncreasePN(pPN, 1);
+ if (bPNOverflow==WAPI_RETURN_SUCCESS)
+ {
+ /* MSK update */
+ if((priv->wapiMCastKeyUpdate==1) || ((pstat)&&(pstat->wapiInfo)&&(pstat->wapiInfo->wapiUCastKeyUpdate))){
+// printk("%s(%d), during msk or usk update, do nothing! =========== \n",__FUNCTION__,__LINE__);//Added for test
+ }
+ else{
+ wapiUpdateMSK(priv, NULL);
+ }
+ }
+
+ if (priv->wapiMCastKeyUpdateCnt<=txcfg->fr_len)
+ {
+ priv->wapiMCastKeyUpdateCnt = priv->pmib->wapiInfo.wapiUpdateMCastKeyPktNum;
+ if (priv->pmib->wapiInfo.wapiUpdateMCastKeyType==wapi_pktnum_update||
+ priv->pmib->wapiInfo.wapiUpdateMCastKeyType==wapi_all_update)
+ {
+ /* MSK update */
+ if((priv->wapiMCastKeyUpdate==1) || ((pstat)&&(pstat->wapiInfo)&&(pstat->wapiInfo->wapiUCastKeyUpdate))){
+// printk("%s(%d), during msk or usk update, do nothing! =========== \n",__FUNCTION__,__LINE__);//Added for test
+ }
+ else{
+ wapiUpdateMSK(priv, NULL);
+ }
+ }
+ }
+ else
+ priv->wapiMCastKeyUpdateCnt-=txcfg->fr_len;
+
+ #if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ bHWEncrypt = priv->pmib->dot11GroupKeysTable.keyInCam;
+ #endif
+ }
+ else
+ {
+ /* unicast */
+ wapiAssert(txcfg);
+ wapiAssert(txcfg->pstat);
+ wapiAssert(txcfg->pstat->wapiInfo);
+ wapiInfo = txcfg->pstat->wapiInfo;
+ KeyIdx = wapiInfo->wapiUCastKeyId;
+ pPN = wapiInfo->wapiPN.txUCast;
+ pMicKey = wapiInfo->wapiUCastKey[KeyIdx].micKey;
+ pDataKey = wapiInfo->wapiUCastKey[KeyIdx].dataKey;
+ bPNOverflow = WapiIncreasePN(pPN, 2);
+ if (bPNOverflow==WAPI_RETURN_SUCCESS)
+ {
+ /* USK update */
+ if((wapiInfo->wapiUCastKeyUpdate==1) || (priv->wapiMCastKeyUpdate==1)){
+// printk("%s(%d), during usk or msk update, do nothing! =========== \n",__FUNCTION__,__LINE__);//Added for test
+ }
+ else{
+ wapiUpdateUSK(priv, txcfg->pstat);
+ }
+ }
+
+ if (wapiInfo->wapiUCastKeyUpdateCnt<=txcfg->fr_len)
+ {
+ wapiInfo->wapiUCastKeyUpdateCnt = priv->pmib->wapiInfo.wapiUpdateUCastKeyPktNum;
+
+ if (wapiInfo->priv->pmib->wapiInfo.wapiUpdateUCastKeyType==wapi_pktnum_update||
+ wapiInfo->priv->pmib->wapiInfo.wapiUpdateUCastKeyType==wapi_all_update)
+ {
+ /* USK update */
+ if((wapiInfo->wapiUCastKeyUpdate==1) || (priv->wapiMCastKeyUpdate==1)){
+// printk("%s(%d), during usk update, do nothing!KeyIdx(0x%x),wapiInfo->wapiUCastKeyId(0x%x),wapiInfo->wapiUCastKeyUpdateCnt(%u), priv->pmib->wapiInfo.wapiUpdateUCastKeyPktNum(%u),txcfg->fr_len(%d)=========== \n",
+// __FUNCTION__,__LINE__,KeyIdx,wapiInfo->wapiUCastKeyId,wapiInfo->wapiUCastKeyUpdateCnt,priv->pmib->wapiInfo.wapiUpdateUCastKeyPktNum,txcfg->fr_len);//Added for test
+ }
+ else{
+ wapiUpdateUSK(priv, txcfg->pstat);
+ }
+ }
+ }
+ else
+ wapiInfo->wapiUCastKeyUpdateCnt-=txcfg->fr_len;
+
+ #if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ bHWEncrypt = txcfg->pstat->dot11KeyMapping.keyInCam;
+ #endif
+ }
+
+ SMS4Hdr = (wpiSMS4Hdr*)(pHeader + txcfg->hdr_len);
+ SMS4Hdr->keyIdx = KeyIdx;
+ SMS4Hdr->reserved = 0;
+ memcpy(SMS4Hdr->pn, pPN, WAPI_PN_LEN);
+#if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ if (bHWEncrypt!=TRUE)
+#endif
+ {
+ wapiAssert((((struct sk_buff *)txcfg->pframe)->end-((struct sk_buff *)txcfg->pframe)->tail)>SMS4_MIC_LEN);
+ pBuf = ((struct sk_buff *)txcfg->pframe)->data-txcfg->llc;
+ MicBuffer = ((struct sk_buff *)txcfg->pframe)->data+txcfg->fr_len;
+
+
+ if (txcfg->llc>0)
+ {
+ memcpy(pBuf, pHeader+txcfg->hdr_len + txcfg->iv, txcfg->llc);
+ }
+
+
+ {
+ SecCalculateMicSMS4(KeyIdx, pMicKey, pHeader, pBuf, txcfg->fr_len+txcfg->llc, MicBuffer);
+
+ /* encryption for data */
+ WapiSMS4Encryption(pDataKey, pPN, pBuf, txcfg->fr_len+txcfg->llc+SMS4_MIC_LEN, pBuf, &OutputLength);
+ wapiAssert(OutputLength==txcfg->fr_len+txcfg->llc+SMS4_MIC_LEN);
+ }
+
+ //llc in wlan hdr should be sms4encrypted to deliver
+ *((uint32*)SMS4Hdr->data) = *((uint32*)pBuf);
+ *((uint32*)(SMS4Hdr->data+4)) = *((uint32*)(pBuf+4));
+ }
+#if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ else
+ txcfg->mic = 0;
+#endif
+ WAPI_UNLOCK(&priv->pshare->lock);
+ }
+}
+
+int32 SecSWSMS4Decryption(
+ struct rtl8192cd_priv *priv, struct stat_info *pstat, struct rx_frinfo* pfrinfo)
+{
+ uint8 PNOffset;
+ uint8 DataOffset;
+ uint16 OutputLength;
+ wapiStaInfo *wapiInfo;
+ uint8 *pHeader;
+ uint8 *pRA;
+ uint8 *pTA;
+ uint8 KeyIdx;
+/* uint8 MicBuffer[SMS4_MIC_LEN]; */
+ uint8 *pMicKey;
+ uint8 *pDataKey;
+ uint8 *pRecvPN;
+ uint8 *pSecData;
+ uint8 *pRecvMic;
+ uint16 DataLen;
+ uint16 PktLen;
+ wpiSMS4Hdr *SMS4Hdr;
+ uint8 qosIdx;
+ struct stat_info *rxPstat;
+#if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ uint32 bHWEncrypt;
+#endif
+
+
+ WAPI_LOCK(&priv->pshare->lock);
+ wapiInfo = pstat->wapiInfo;
+ pHeader = pfrinfo->pskb->data;
+#if 0
+ if (get_tofr_ds(pHeader) == 3)
+ {
+ if( is_qos_data(pHeader) )
+ {
+ PNOffset = WLAN_HDR_A4_QOS_LEN;
+ }
+ else
+ {
+ PNOffset = WLAN_HDR_A4_LEN;
+ }
+ }
+ else
+ {
+ if( is_qos_data(pHeader) )
+ {
+ PNOffset = WLAN_HDR_A3_QOS_LEN;
+ }
+ else
+ {
+ PNOffset = WLAN_HDR_A3_LEN;
+ }
+ }
+ printk("rx pn offset %d %d\n", pfrinfo->hdr_len, PNOffset);
+#else
+ PNOffset = pfrinfo->hdr_len;
+#endif
+
+ DataOffset = PNOffset + WAPI_EXT_LEN;
+
+ SMS4Hdr = (wpiSMS4Hdr*)(pHeader+PNOffset);
+
+ pRA = pHeader + 4;
+ pTA = pHeader + 10;
+ KeyIdx = SMS4Hdr->keyIdx;
+ pRecvPN = SMS4Hdr->pn;
+
+ if( (*pRA)&0x1 )
+ {
+ rxPstat = get_stainfo(priv, pTA);
+ if (rxPstat==NULL || rxPstat->wapiInfo==NULL ||
+ rxPstat->wapiInfo->wapiMCastEnable==0 ||
+ (KeyIdx!=priv->wapiMCastKeyId&&priv->wapiMCastKeyUpdate==0))
+ {
+
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+
+ /* need check the PN increasing, and record the last rx PN */
+ /* need check the PN increasing, and record the last rx PN */
+ if (WapiComparePN(pRecvPN, priv->rxMCast)==WAPI_RETURN_FAILED)
+ {
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+
+ memcpy(priv->rxMCast, pRecvPN, WAPI_PN_LEN);
+
+ pMicKey = priv->wapiMCastKey[KeyIdx].micKey;
+ pDataKey = priv->wapiMCastKey[KeyIdx].dataKey;
+ #if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ bHWEncrypt = priv->pmib->dot11GroupKeysTable.keyInCam;
+ #endif
+ }
+ else
+ {
+ if (wapiInfo->wapiUCastRxEnable==0
+ || (KeyIdx!=wapiInfo->wapiUCastKeyId&&priv->wapiMCastKeyUpdate==0))
+ {
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+
+#ifdef WIFI_WMM
+ {
+ if (pfrinfo->tid==0||pfrinfo->tid==3)
+ qosIdx = 0;
+ else if (pfrinfo->tid<3)
+ qosIdx = 1;
+ else if (pfrinfo->tid<6)
+ qosIdx = 2;
+ else
+ qosIdx = 3;
+ }
+#else
+ qosIdx = 0;
+#endif
+
+ /* need check the PN increasing, and record the last rx PN */
+ if ((pRecvPN[WAPI_PN_LEN-1]&0x1)==0x1)
+ {
+ wapiAssert(0);
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+
+#if 0
+ if (WapiComparePN(pRecvPN, &wapiInfo->wapiPN.rxUCast[qosIdx][0])==WAPI_RETURN_FAILED)
+ {
+ memcpy(wapiCryptoTemp, pRecvPN, WAPI_PN_LEN);
+ WapiIncreasePN(wapiCryptoTemp, ((rtl_SMS4_rxSeq[qosIdx]-pfrinfo->seq+1)<<1));
+
+ if (WapiComparePN(wapiCryptoTemp, &wapiInfo->wapiPN.rxUCast[qosIdx][0])==WAPI_RETURN_FAILED)
+ {
+ wapiAssert(0);
+ memset(rtl_SMS4_rxSeq, 0, RX_QUEUE_NUM*sizeof(unsigned short));
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+ }
+ memcpy(&wapiInfo->wapiPN.rxUCast[qosIdx][0], pRecvPN, WAPI_PN_LEN);
+ rtl_SMS4_rxSeq[qosIdx]=pfrinfo->seq;
+#else
+ if (pfrinfo->seq>=wapiInfo->wapiPN.rxSeq[qosIdx])
+ {
+ if (WapiComparePN(pRecvPN, &wapiInfo->wapiPN.rxUCast[qosIdx][0])==WAPI_RETURN_FAILED)
+ {
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+ memcpy(&wapiInfo->wapiPN.rxUCast[qosIdx][0], pRecvPN, WAPI_PN_LEN);
+ wapiInfo->wapiPN.rxSeq[qosIdx]=pfrinfo->seq;
+ }
+ else
+ {
+ memcpy(wapiCryptoTemp, pRecvPN, WAPI_PN_LEN);
+ WapiIncreasePN(wapiCryptoTemp, ((wapiInfo->wapiPN.rxSeq[qosIdx]-pfrinfo->seq+1)<<1));
+ if (WapiComparePN(wapiCryptoTemp, &wapiInfo->wapiPN.rxUCast[qosIdx][0])==WAPI_RETURN_FAILED)
+ {
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FAIL;
+ }
+ }
+#endif
+
+ pMicKey = wapiInfo->wapiUCastKey[KeyIdx].micKey;
+ pDataKey = wapiInfo->wapiUCastKey[KeyIdx].dataKey;
+ #if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ bHWEncrypt = pstat->dot11KeyMapping.keyInCam;
+ #endif
+ }
+
+#if defined(CONFIG_RTL_HW_WAPI_SUPPORT)
+ if (bHWEncrypt!=TRUE)
+#endif
+ {
+ pSecData = pHeader + DataOffset;
+ PktLen = pfrinfo->pktlen;
+ DataLen = PktLen-DataOffset;
+ pRecvMic = pHeader + PktLen - SMS4_MIC_LEN - WAPI_ALIGNMENT_OFFSET;
+
+ memcpy(wapiDecrytBuf, pSecData, DataLen);
+ memcpy(wapiDecrytHdrBuf, pHeader, DataOffset);
+
+ WapiSMS4Decryption(pDataKey, pRecvPN, wapiDecrytBuf, DataLen, pSecData-WAPI_ALIGNMENT_OFFSET, &OutputLength);
+ wapiAssert(OutputLength == DataLen);
+
+ DataLen -= SMS4_MIC_LEN;
+
+ SecCalculateMicSMS4(KeyIdx, pMicKey, wapiDecrytHdrBuf, pSecData-WAPI_ALIGNMENT_OFFSET, DataLen, wapiCryptoTemp);
+
+ if (memcmp(wapiCryptoTemp, pRecvMic, SMS4_MIC_LEN))
+ {
+ wapiAssert(0);
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return FALSE;
+ }
+ }
+
+ WAPI_UNLOCK(&priv->pshare->lock);
+ return TRUE;
+}
+#endif
+
+#endif