CORE/BAP/src/bapRsnSsmAesKeyWrap.c - platform/vendor/qcom-opensource/wlan/prima - Gitiles

 /*
  * Copyright (c) 2012-2013 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all
  * copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */

 /*
  * This file was originally distributed by Qualcomm Atheros, Inc.
  * under proprietary terms before Copyright ownership was assigned
  * to the Linux Foundation.
  */

 /*
  * $File: //depot/software/projects/feature_branches/gen5_phase1/os/linux/classic/ap/apps/ssm/lib/aniSsmAesKeyWrap.c $
  *
  * Contains definitions for the AES Key Wrap algorithm from RFC 3394.
  *
  * Author:      Mayank D. Upadhyay
  * Date:        31-March-2003
  * History:-
  * Date         Modified by     Modification Information
  * ------------------------------------------------------
  *
  */

 #include "vos_types.h"
 #include "bapRsnSsmServices.h"
 #include "bapRsnSsmEapol.h"
 #include "bapRsnErrors.h"
 #include "bapInternal.h"
 #include "bapRsn8021xFsm.h"
 #include "bapRsn8021xAuthFsm.h"
 #include "vos_utils.h"
 #include "vos_memory.h"
 #include "vos_timer.h"
 #include "bapRsnTxRx.h"
 #include "bapRsnSsmAesKeyWrap.h"

 #if 0

 #include <assert.h>
 #include <stdlib.h>
 #include <openssl/aes.h>

 #include <aniAsfHdr.h>
 #include <aniUtils.h>
 #include <aniErrors.h>
 #include <aniAsfLog.h>

 #include "aniSsmAesKeyWrap.h"
 #include "aniSsmUtils.h"
 #endif

 #define ANI_SSM_AES_KEY_WRAP_IC_SIZE    ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE

 typedef struct tag_aes_key {
     tANI_U32 eK[64], dK[64];
     int Nr;
 } AES_KEY;

 static tANI_U8 gAniSsmAesKeyWrapIv[] = {
     0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6
 };

 static int
 aes(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
     tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
     tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
     tANI_U8 b[AES_BLOCK_SIZE]);

 static int
 aes_1(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
       tANI_U8 at[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
       tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
       tANI_U8 b[AES_BLOCK_SIZE]);

 static int
 xor(tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE], tANI_U32 t);

 /**
  * Implements the AES Key Wrap algorithm described in RFC 3394.
  * If n is the number of blocks in plainText, of size
  * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, then the output value is (n+1)
  * blocks. The first block is the IV from section 2.2.3 o the
  * RFC. Note: It is the caller's responsibility to free the returned
  * value.
  *
  * @param plainText the plaintext data to wrap
  * @param len the length of the plaintext, which must be a multiple of
  * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE.
  * @param keyEncKey the encryption key
  * @param keyEncKeyLen the length of keyEncKey
  * @param cipherTextPtr is set to a newly allocated array containing
  * the result if the operation succeeds. It is the caller's
  * responsibility to free this.
  *
  * @return ANI_OK if the operation succeeds
  */
 int
 aniSsmAesKeyWrap(v_U32_t cryptHandle, tANI_U8 *plainText, tANI_U32 len,
                  tANI_U8 *keyEncKey, tANI_U32 keyEncKeyLen,
                  tANI_U8 **cipherTextPtr)
 {
     int i, j, n;
     int retVal;

     tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE];
     tANI_U8 *r = NULL;
     tANI_U32 t;

     tANI_U8 b[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2];

     n = len / ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE;
     if ((len % ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                  "Illegal number of input bytes to AES Key Wrap!");
         return ANI_E_ILLEGAL_ARG;
     }

     // Allocate enough storage for 'A' as well as 'R'
     r = vos_mem_malloc((n + 1) * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     if (r == NULL) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                  "Could not allocate space for R");
         return ANI_E_MALLOC_FAILED;
     }

     vos_mem_copy(a, gAniSsmAesKeyWrapIv, sizeof(a));
     vos_mem_copy(r + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, plainText, len);

     for (j = 0; j <= 5; j++) {
         for (i = 1; i <= n; i++) {

             retVal = aes(cryptHandle, keyEncKey, keyEncKeyLen,
                          a,
                          r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                          b);

            if( !ANI_IS_STATUS_SUCCESS( retVal) ) goto error;

             vos_mem_copy(a, b, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
             t = n*j + i;
             xor(a, t);
             vos_mem_copy(r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                    b + sizeof(b) - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                    ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
         }
     }

     vos_mem_copy(r, a, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     *cipherTextPtr = r;

     return ANI_OK;

  error:
     if (r != NULL)
         vos_mem_free(r);

     return retVal;

 }

 /**
  * Implements the AES Key Unwrap algorithm described in RFC 3394.
  * If (n+1) is the number of blocks in cipherText, of size
  * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, then the output value is (n+1)
  * blocks. The actual plaintext consists of n blocks that start at the
  * second block. Note: It is the caller's responsibility to free the
  * returned value.
  *
  * @param cipherText the cipertext data to unwrap
  * @param len the length of the ciphertext, which must be a multiple of
  * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE.
  * @param keyEncKey the encryption key
  * @param keyEncKeyLen the length of keyEncKey
  * @param plainTextPtr is set to a newly allocated array containing
  * the result if the operation succeeds. It is the caller's
  * responsibility to free this.
  *
  * @return ANI_OK if the operation succeeds
  */
 int
 aniSsmAesKeyUnwrap(v_U32_t cryptHandle, tANI_U8 *cipherText, tANI_U32 len,
                    tANI_U8 *keyEncKey, tANI_U32 keyEncKeyLen,
                    tANI_U8 **plainTextPtr)
 {
     int i, j;
     int retVal;

     tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE];
     tANI_U8 *r = NULL;
     tANI_U32 n;
     tANI_U32 t;

     tANI_U8 b[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2];

     n = len / ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE - 1;
     if ((len % ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                    "Illegal number of input bytes to AES Key Unwrap!");
         return ANI_E_ILLEGAL_ARG;
     }

     // Allocate enough storage for 'A' as well as 'R'
     r = vos_mem_malloc((n + 1) *  ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     if (r == NULL) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                    "Could not allocate space for R");
         return ANI_E_MALLOC_FAILED;
     }

     vos_mem_copy(a, cipherText, sizeof(a));
     vos_mem_copy(r + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
            cipherText + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
            len - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);

     for (j = 5; j >= 0; j--) {
         for (i = n; i >= 1; i--) {

             t = n*j + i;
             xor(a, t);
             retVal = aes_1(cryptHandle, keyEncKey, keyEncKeyLen,
                            a,
                            r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                            b);
            if( !ANI_IS_STATUS_SUCCESS( retVal) ) goto error;

             vos_mem_copy(a, b, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
             vos_mem_copy(r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                    b + sizeof(b) - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
                    ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
         }
     }

     if (vos_mem_compare2(a, gAniSsmAesKeyWrapIv, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
         retVal = ANI_E_MIC_FAILED;
         goto error;
     }

     *plainTextPtr = r;

     return ANI_OK;

  error:
     if (r != NULL)
         vos_mem_free(r);

     return retVal;
 }

 static int
 aes(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
     tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
     tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
     tANI_U8 b[AES_BLOCK_SIZE]) {

     int retVal = 0;

 //    AES_KEY aesKey;

     tANI_U8 in[AES_BLOCK_SIZE];
     tANI_U8 *out;

     VOS_ASSERT (AES_BLOCK_SIZE == ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2);

     // Concatenate A and R[i]
     vos_mem_copy(in, a, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     vos_mem_copy(in + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
            ri, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     out = b;

 #if 0
     retVal = AES_set_encrypt_key(keyBytes, keyLen*8, &aesKey);
     if (retVal != 0) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                    "AES_set_encrypt_key returned %d", retVal);
         return ANI_E_FAILED;
     }

     AES_encrypt(in, out, &aesKey);
 #else // Enable to use VOS function
     retVal = vos_encrypt_AES(cryptHandle, /* Handle */
                              in, /* input */
                              out, /* output */
                              keyBytes); /* key */
     if (retVal != 0) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                    "vos_encrypt_AES returned %d", retVal);
         return ANI_E_FAILED;
     }
 #endif
     return ANI_OK;
 }

 static int
 aes_1(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
       tANI_U8 at[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
       tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
       tANI_U8 b[AES_BLOCK_SIZE]) {

     int retVal;

 //    AES_KEY aesKey;

     tANI_U8 in[AES_BLOCK_SIZE];
     tANI_U8 *out;

     VOS_ASSERT (AES_BLOCK_SIZE == ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2);

     // Concatenate A and R[i]
     vos_mem_copy(in, at, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     vos_mem_copy(in + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
            ri, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
     out = b;

 #if 0
     retVal = AES_set_decrypt_key(keyBytes, keyLen*8, &aesKey);
     if (retVal != 0) {
         ANI_SSM_LOG_E("AES_set_encrypt_key returned %d", retVal);
         assert(0 && "AES_set_encrypt_key failed!");
         return ANI_E_FAILED;
     }

     AES_decrypt(in, out, &aesKey);
 #else
     retVal = vos_decrypt_AES(cryptHandle, /* Handle */
                              in, /* input */
                              out, /* output */
                              keyBytes); /* key */
     if (retVal != 0) {
         VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
                    "vos_decrypt_AES returned %d", retVal);
     }
 #endif
     return ANI_OK;
 }

 // From File : aniAsfHdr.h


 /*
  * Put a long in host order into a char array in network order.
  *
  */
 static inline char *aniAsfWr32(char *cp, tANI_U32 x)
 {
     tAniU32ValAry r;
     int i;

     r.val = vos_cpu_to_be32(x);
     i = sizeof(tANI_U32) - 1;
     cp[3] = r.ary[i--];
     cp[2] = r.ary[i--];
     cp[1] = r.ary[i--];
     cp[0] = r.ary[i];

     return (cp + sizeof(tANI_U32));
 }

 // From file : aniAsfMisc.c

 /*
  * Put a long in host order into a char array in network order.
  *
  */
 char *aniAsfPut32(char *cp, tANI_U32 x)
 {
     return(aniAsfWr32(cp, x));
 }


 static int
 xor(tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE], tANI_U32 t)
 {
     tANI_U8 tmp[4];
     aniAsfPut32((char *)tmp, t);
     a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-1] ^= tmp[3];
     a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-2] ^= tmp[2];
     a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-3] ^= tmp[1];
     a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-4] ^= tmp[0];
     return ANI_OK;
 }
	/*
	* Copyright (c) 2012-2013 The Linux Foundation. All rights reserved.
	*
	* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
	*
	*
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all
	* copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
	* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
	* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
	* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
	* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	* PERFORMANCE OF THIS SOFTWARE.
	*/

	/*
	* This file was originally distributed by Qualcomm Atheros, Inc.
	* under proprietary terms before Copyright ownership was assigned
	* to the Linux Foundation.
	*/

	/*
	* $File: //depot/software/projects/feature_branches/gen5_phase1/os/linux/classic/ap/apps/ssm/lib/aniSsmAesKeyWrap.c $
	*
	* Contains definitions for the AES Key Wrap algorithm from RFC 3394.
	*
	* Author: Mayank D. Upadhyay
	* Date: 31-March-2003
	* History:-
	* Date Modified by Modification Information
	* ------------------------------------------------------
	*
	*/

	#include "vos_types.h"
	#include "bapRsnSsmServices.h"
	#include "bapRsnSsmEapol.h"
	#include "bapRsnErrors.h"
	#include "bapInternal.h"
	#include "bapRsn8021xFsm.h"
	#include "bapRsn8021xAuthFsm.h"
	#include "vos_utils.h"
	#include "vos_memory.h"
	#include "vos_timer.h"
	#include "bapRsnTxRx.h"
	#include "bapRsnSsmAesKeyWrap.h"

	#if 0

	#include <assert.h>
	#include <stdlib.h>
	#include <openssl/aes.h>

	#include <aniAsfHdr.h>
	#include <aniUtils.h>
	#include <aniErrors.h>
	#include <aniAsfLog.h>

	#include "aniSsmAesKeyWrap.h"
	#include "aniSsmUtils.h"
	#endif

	#define ANI_SSM_AES_KEY_WRAP_IC_SIZE ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE

	typedef struct tag_aes_key {
	tANI_U32 eK[64], dK[64];
	int Nr;
	} AES_KEY;

	static tANI_U8 gAniSsmAesKeyWrapIv[] = {
	0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6
	};

	static int
	aes(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
	tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 b[AES_BLOCK_SIZE]);

	static int
	aes_1(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
	tANI_U8 at[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 b[AES_BLOCK_SIZE]);

	static int
	xor(tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE], tANI_U32 t);

	/**
	* Implements the AES Key Wrap algorithm described in RFC 3394.
	* If n is the number of blocks in plainText, of size
	* ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, then the output value is (n+1)
	* blocks. The first block is the IV from section 2.2.3 o the
	* RFC. Note: It is the caller's responsibility to free the returned
	* value.
	*
	* @param plainText the plaintext data to wrap
	* @param len the length of the plaintext, which must be a multiple of
	* ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE.
	* @param keyEncKey the encryption key
	* @param keyEncKeyLen the length of keyEncKey
	* @param cipherTextPtr is set to a newly allocated array containing
	* the result if the operation succeeds. It is the caller's
	* responsibility to free this.
	*
	* @return ANI_OK if the operation succeeds
	*/
	int
	aniSsmAesKeyWrap(v_U32_t cryptHandle, tANI_U8 *plainText, tANI_U32 len,
	tANI_U8 *keyEncKey, tANI_U32 keyEncKeyLen,
	tANI_U8 **cipherTextPtr)
	{
	int i, j, n;
	int retVal;

	tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE];
	tANI_U8 *r = NULL;
	tANI_U32 t;

	tANI_U8 b[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2];

	n = len / ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE;
	if ((len % ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"Illegal number of input bytes to AES Key Wrap!");
	return ANI_E_ILLEGAL_ARG;
	}

	// Allocate enough storage for 'A' as well as 'R'
	r = vos_mem_malloc((n + 1) * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	if (r == NULL) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"Could not allocate space for R");
	return ANI_E_MALLOC_FAILED;
	}

	vos_mem_copy(a, gAniSsmAesKeyWrapIv, sizeof(a));
	vos_mem_copy(r + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, plainText, len);

	for (j = 0; j <= 5; j++) {
	for (i = 1; i <= n; i++) {

	retVal = aes(cryptHandle, keyEncKey, keyEncKeyLen,
	a,
	r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	b);

	if( !ANI_IS_STATUS_SUCCESS( retVal) ) goto error;

	vos_mem_copy(a, b, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	t = n*j + i;
	xor(a, t);
	vos_mem_copy(r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	b + sizeof(b) - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	}
	}

	vos_mem_copy(r, a, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	*cipherTextPtr = r;

	return ANI_OK;

	error:
	if (r != NULL)
	vos_mem_free(r);

	return retVal;

	}

	/**
	* Implements the AES Key Unwrap algorithm described in RFC 3394.
	* If (n+1) is the number of blocks in cipherText, of size
	* ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE, then the output value is (n+1)
	* blocks. The actual plaintext consists of n blocks that start at the
	* second block. Note: It is the caller's responsibility to free the
	* returned value.
	*
	* @param cipherText the cipertext data to unwrap
	* @param len the length of the ciphertext, which must be a multiple of
	* ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE.
	* @param keyEncKey the encryption key
	* @param keyEncKeyLen the length of keyEncKey
	* @param plainTextPtr is set to a newly allocated array containing
	* the result if the operation succeeds. It is the caller's
	* responsibility to free this.
	*
	* @return ANI_OK if the operation succeeds
	*/
	int
	aniSsmAesKeyUnwrap(v_U32_t cryptHandle, tANI_U8 *cipherText, tANI_U32 len,
	tANI_U8 *keyEncKey, tANI_U32 keyEncKeyLen,
	tANI_U8 **plainTextPtr)
	{
	int i, j;
	int retVal;

	tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE];
	tANI_U8 *r = NULL;
	tANI_U32 n;
	tANI_U32 t;

	tANI_U8 b[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2];

	n = len / ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE - 1;
	if ((len % ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"Illegal number of input bytes to AES Key Unwrap!");
	return ANI_E_ILLEGAL_ARG;
	}

	// Allocate enough storage for 'A' as well as 'R'
	r = vos_mem_malloc((n + 1) * ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	if (r == NULL) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"Could not allocate space for R");
	return ANI_E_MALLOC_FAILED;
	}

	vos_mem_copy(a, cipherText, sizeof(a));
	vos_mem_copy(r + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	cipherText + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	len - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);

	for (j = 5; j >= 0; j--) {
	for (i = n; i >= 1; i--) {

	t = n*j + i;
	xor(a, t);
	retVal = aes_1(cryptHandle, keyEncKey, keyEncKeyLen,
	a,
	r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	b);
	if( !ANI_IS_STATUS_SUCCESS( retVal) ) goto error;

	vos_mem_copy(a, b, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	vos_mem_copy(r + i*ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	b + sizeof(b) - ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	}
	}

	if (vos_mem_compare2(a, gAniSsmAesKeyWrapIv, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE) != 0) {
	retVal = ANI_E_MIC_FAILED;
	goto error;
	}

	*plainTextPtr = r;

	return ANI_OK;

	error:
	if (r != NULL)
	vos_mem_free(r);

	return retVal;
	}

	static int
	aes(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
	tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 b[AES_BLOCK_SIZE]) {

	int retVal = 0;

	// AES_KEY aesKey;

	tANI_U8 in[AES_BLOCK_SIZE];
	tANI_U8 *out;

	VOS_ASSERT (AES_BLOCK_SIZE == ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2);

	// Concatenate A and R[i]
	vos_mem_copy(in, a, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	vos_mem_copy(in + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	ri, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	out = b;

	#if 0
	retVal = AES_set_encrypt_key(keyBytes, keyLen*8, &aesKey);
	if (retVal != 0) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"AES_set_encrypt_key returned %d", retVal);
	return ANI_E_FAILED;
	}

	AES_encrypt(in, out, &aesKey);
	#else // Enable to use VOS function
	retVal = vos_encrypt_AES(cryptHandle, /* Handle */
	in, /* input */
	out, /* output */
	keyBytes); /* key */
	if (retVal != 0) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"vos_encrypt_AES returned %d", retVal);
	return ANI_E_FAILED;
	}
	#endif
	return ANI_OK;
	}

	static int
	aes_1(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
	tANI_U8 at[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
	tANI_U8 b[AES_BLOCK_SIZE]) {

	int retVal;

	// AES_KEY aesKey;

	tANI_U8 in[AES_BLOCK_SIZE];
	tANI_U8 *out;

	VOS_ASSERT (AES_BLOCK_SIZE == ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2);

	// Concatenate A and R[i]
	vos_mem_copy(in, at, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	vos_mem_copy(in + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
	ri, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
	out = b;

	#if 0
	retVal = AES_set_decrypt_key(keyBytes, keyLen*8, &aesKey);
	if (retVal != 0) {
	ANI_SSM_LOG_E("AES_set_encrypt_key returned %d", retVal);
	assert(0 && "AES_set_encrypt_key failed!");
	return ANI_E_FAILED;
	}

	AES_decrypt(in, out, &aesKey);
	#else
	retVal = vos_decrypt_AES(cryptHandle, /* Handle */
	in, /* input */
	out, /* output */
	keyBytes); /* key */
	if (retVal != 0) {
	VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
	"vos_decrypt_AES returned %d", retVal);
	}
	#endif
	return ANI_OK;
	}

	// From File : aniAsfHdr.h



	/*
	* Put a long in host order into a char array in network order.
	*
	*/
	static inline char aniAsfWr32(char cp, tANI_U32 x)
	{
	tAniU32ValAry r;
	int i;

	r.val = vos_cpu_to_be32(x);
	i = sizeof(tANI_U32) - 1;
	cp[3] = r.ary[i--];
	cp[2] = r.ary[i--];
	cp[1] = r.ary[i--];
	cp[0] = r.ary[i];

	return (cp + sizeof(tANI_U32));
	}

	// From file : aniAsfMisc.c

	/*
	* Put a long in host order into a char array in network order.
	*
	*/
	char aniAsfPut32(char cp, tANI_U32 x)
	{
	return(aniAsfWr32(cp, x));
	}


	static int
	xor(tANI_U8 a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE], tANI_U32 t)
	{
	tANI_U8 tmp[4];
	aniAsfPut32((char *)tmp, t);
	a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-1] ^= tmp[3];
	a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-2] ^= tmp[2];
	a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-3] ^= tmp[1];
	a[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE-4] ^= tmp[0];
	return ANI_OK;
	}