/*
 *************************************************************************
 * Ralink Tech Inc.
 * 5F., No.36, Taiyuan St., Jhubei City,
 * Hsinchu County 302,
 * Taiwan, R.O.C.
 *
 * (c) Copyright 2002-2007, Ralink Technology, Inc.
 *
 * This program is free software; you can redistribute it and/or modify  *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation; either version 2 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * This program is distributed in the hope that it will be useful,       *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have received a copy of the GNU General Public License     *
 * along with this program; if not, write to the                         *
 * Free Software Foundation, Inc.,                                       *
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 *                                                                       *
 *************************************************************************

    Module Name:
	cmm_profile.c

    Abstract:

    Revision History:
    Who          When          What
    ---------    ----------    ----------------------------------------------
 */

#include "crypt_biginteger.h"

#ifdef __KERNEL__
#define DEBUGPRINT(fmt, args...) printk(KERN_ERR fmt, ## args)
#else
#define DEBUGPRINT(fmt, args...) printf(fmt, ## args)
#endif /* __KERNEL__ */

#define UINT32_HBITS(value)	(((value) >> 0x10) & 0xffff)
#define UINT32_LBITS(value)	((value) & 0xffff)
#define UINT32_GETBYTE(value, index)	(((value) >> ((index)*8)) & 0xff)
#define UINT64_HBITS(value)	(((value) >> 0x20) & 0xffffffff)
#define UINT64_LBITS(value)	((value) & 0xffffffff)

static UINT8 WPS_DH_P_VALUE[192] =
{
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
    0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
    0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
    0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22,
    0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
    0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B,
    0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
    0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
    0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
    0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
    0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
    0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5,
    0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
    0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
    0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05,
    0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A,
    0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
    0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96,
    0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
    0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
    0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04,
    0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x23, 0x73, 0x27,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};

static UINT8 WPS_DH_R_VALUE[193] =
{
    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00,
};

static UINT8 WPS_DH_X_VALUE[184] =
{
    0x36, 0xf0, 0x25, 0x5d, 0xde, 0x97, 0x3d, 0xcb,
    0x3b, 0x39, 0x9d, 0x74, 0x7f, 0x23, 0xe3, 0x2e,
    0xd6, 0xfd, 0xb1, 0xf7, 0x75, 0x98, 0x33, 0x8b,
    0xfd, 0xf4, 0x41, 0x59, 0xc4, 0xec, 0x64, 0xdd,
    0xae, 0xb5, 0xf7, 0x86, 0x71, 0xcb, 0xfb, 0x22,
    0x10, 0x6a, 0xe6, 0x4c, 0x32, 0xc5, 0xbc, 0xe4,
    0xcf, 0xd4, 0xf5, 0x92, 0x0d, 0xa0, 0xeb, 0xc8,
    0xb0, 0x1e, 0xca, 0x92, 0x92, 0xae, 0x3d, 0xba,
    0x1b, 0x7a, 0x4a, 0x89, 0x9d, 0xa1, 0x81, 0x39,
    0x0b, 0xb3, 0xbd, 0x16, 0x59, 0xc8, 0x12, 0x94,
    0xf4, 0x00, 0xa3, 0x49, 0x0b, 0xf9, 0x48, 0x12,
    0x11, 0xc7, 0x94, 0x04, 0xa5, 0x76, 0x60, 0x5a,
    0x51, 0x60, 0xdb, 0xee, 0x83, 0xb4, 0xe0, 0x19,
    0xb6, 0xd7, 0x99, 0xae, 0x13, 0x1b, 0xa4, 0xc2,
    0x3d, 0xff, 0x83, 0x47, 0x5e, 0x9c, 0x40, 0xfa,
    0x67, 0x25, 0xb7, 0xc9, 0xe3, 0xaa, 0x2c, 0x65,
    0x96, 0xe9, 0xc0, 0x57, 0x02, 0xdb, 0x30, 0xa0,
    0x7c, 0x9a, 0xa2, 0xdc, 0x23, 0x5c, 0x52, 0x69,
    0xe3, 0x9d, 0x0c, 0xa9, 0xdf, 0x7a, 0xad, 0x44,
    0x61, 0x2a, 0xd6, 0xf8, 0x8f, 0x69, 0x69, 0x92,
    0x98, 0xf3, 0xca, 0xb1, 0xb5, 0x43, 0x67, 0xfb,
    0x0e, 0x8b, 0x93, 0xf7, 0x35, 0xdc, 0x8c, 0xd8,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
};

static UINT8 WPS_DH_RRModP_VALUE[192] =
{
	0xe3, 0xb3, 0x3c, 0x72, 0x59, 0x54, 0x1c, 0x01,
	0xee, 0x9c, 0x9a, 0x21, 0x6c, 0xc1, 0xeb, 0xd2,
	0xae, 0x59, 0x41, 0x04, 0x79, 0x29, 0xa1, 0xc7,
	0xe9, 0xc3, 0xfa, 0x02, 0xcc, 0x24, 0x56, 0xef,
	0x10, 0x26, 0x30, 0xfa, 0x9a, 0x36, 0xa5, 0x1f,
	0x57, 0xb5, 0x93, 0x48, 0x67, 0x98, 0x44, 0x60,
	0x0b, 0xe4, 0x96, 0x47, 0xa8, 0x7c, 0x7b, 0x37,
	0xf8, 0x05, 0x65, 0x64, 0x96, 0x9b, 0x7f, 0x02,
	0xdc, 0x54, 0x1a, 0x4e, 0xd4, 0x05, 0x3f, 0x54,
	0xd6, 0x2a, 0x0e, 0xea, 0xb2, 0x70, 0x52, 0x1b,
	0x22, 0xc2, 0x96, 0xe9, 0xd4, 0x6f, 0xec, 0x23,
	0x8e, 0x1a, 0xbd, 0x78, 0x02, 0x23, 0xb7, 0x6b,
	0xb8, 0xfe, 0x61, 0x21, 0x19, 0x6b, 0x7e, 0x88,
	0x1c, 0x72, 0x9c, 0x7e, 0x04, 0xb9, 0xf7, 0x96,
	0x07, 0xcd, 0x0a, 0x62, 0x8e, 0x43, 0x41, 0x30,
	0x04, 0xa5, 0x41, 0xff, 0x93, 0xae, 0x1c, 0xeb,
	0xb0, 0x04, 0xa7, 0x50, 0xdb, 0x10, 0x2d, 0x39,
	0xb9, 0x05, 0x2b, 0xb4, 0x7a, 0x58, 0xf1, 0x70,
	0x7e, 0x8c, 0xd2, 0xac, 0x98, 0xb5, 0xfb, 0x62,
	0x8f, 0x23, 0x31, 0xb1, 0x3b, 0x01, 0xe0, 0x18,
	0xf4, 0x66, 0xee, 0x5f, 0xbc, 0xd4, 0x9d, 0x68,
	0xd0, 0xab, 0x92, 0xe1, 0x83, 0x97, 0xf2, 0x45,
	0x8e, 0x0e, 0x3e, 0x21, 0x67, 0x47, 0x8c, 0x73,
	0xf1, 0x15, 0xd2, 0x7d, 0x32, 0xc6, 0x95, 0xe0,
};

static UINT8 Value_0[1] = {0x00};
static UINT8 Value_1[1] = {0x01};
static PBIG_INTEGER pBI_U = NULL, pBI_S = NULL, pBI_O = NULL;
static UINT Bits_Of_R = 0;


VOID BigInteger_Print (
    IN PBIG_INTEGER pBI)
{
    int i = 0, j = 0;

    if ((pBI == NULL) || (pBI->pIntegerArray == NULL))
        return;

    if (strlen(pBI->Name) != 0)
        DEBUGPRINT("Name=%s\n", pBI->Name);
    DEBUGPRINT("AllocSize=%d, ArrayLength=%d, IntegerLength=%d, Signed=%d\n", pBI->AllocSize, pBI->ArrayLength, pBI->IntegerLength, pBI->Signed);
    for (i = (pBI->ArrayLength - 1), j = 0;i >=0;i--,j++) {
        DEBUGPRINT("%08x, ", pBI->pIntegerArray[i]);
        if ((j%8) == 7)
            DEBUGPRINT("\n");
    } /* End od for */
    DEBUGPRINT("\n\n");
} /* End of BigInteger_Print */


VOID BigInteger_Init (
    INOUT PBIG_INTEGER *pBI)
{
    if (*pBI != NULL)
        BigInteger_Free(pBI);

    if ((*pBI = (PBIG_INTEGER) kmalloc(sizeof(BIG_INTEGER), GFP_ATOMIC)) == NULL) {
        DEBUGPRINT("BigInteger_Init: allocate %d bytes memory failure.\n", (sizeof(BIG_INTEGER)));
        return;
    } /* End of if */

    NdisZeroMemory(*pBI, sizeof(BIG_INTEGER));
    (*pBI)->pIntegerArray = NULL;
    (*pBI)->Signed = 1;
} /* End of BigInteger_Init */


VOID BigInteger_Free_AllocSize (
    IN PBIG_INTEGER *pBI)
{
    if ((*pBI != NULL) && ((*pBI)->pIntegerArray != NULL)) {
        kfree((*pBI)->pIntegerArray);
        NdisZeroMemory(*pBI, sizeof(BIG_INTEGER));
        (*pBI)->pIntegerArray = NULL;
        (*pBI)->Signed = 1;
    } /* End of if */
} /* End of BigInteger_Free_AllocSize */


VOID BigInteger_Free (
    IN PBIG_INTEGER *pBI)
{
    if (*pBI != NULL) {
        BigInteger_Free_AllocSize(pBI);
        kfree(*pBI);
    } /* End of if */

    *pBI = NULL;
} /* End of BigInteger_Free */


VOID BigInteger_AllocSize (
    IN PBIG_INTEGER *pBI,
    IN UINT Length)
{
    UINT ArrayLength = 0;

    if (Length == 0)
        return;

    if (*pBI == NULL)
        BigInteger_Init(pBI);

    /* Caculate array size */
    ArrayLength = Length >> 0x2;
    if ((Length & 0x3) != 0)
        ArrayLength++;

    if (((*pBI)->pIntegerArray != NULL) && ((*pBI)->AllocSize < (sizeof(UINT32)*ArrayLength)))
        BigInteger_Free_AllocSize(pBI);

    if ((*pBI)->pIntegerArray == NULL) {
        if (((*pBI)->pIntegerArray = (UINT32 *) kmalloc(sizeof(UINT32)*ArrayLength, GFP_ATOMIC)) == NULL) {
            DEBUGPRINT("BigInteger_AllocSize: allocate %d bytes memory failure.\n", (sizeof(UINT32)*ArrayLength));
            return;
        } /* End of if */
        (*pBI)->AllocSize = sizeof(UINT32)*ArrayLength;
    } /* End of if */

    NdisZeroMemory((*pBI)->pIntegerArray, (*pBI)->AllocSize);
    (*pBI)->ArrayLength = ArrayLength;
    (*pBI)->IntegerLength = Length;
} /* End of BigInteger_AllocSize */


VOID BigInteger_ClearHighBits (
    IN PBIG_INTEGER pBI)
{
    INT BIArrayIndex, ShiftIndex = 0;
    UINT8 value;

    if ((pBI == NULL) || (pBI->pIntegerArray == NULL))
        return;

    BIArrayIndex = pBI->ArrayLength - 1;
    while ((BIArrayIndex >= 0) && (pBI->pIntegerArray[BIArrayIndex] == 0))
	BIArrayIndex--;

    if (BIArrayIndex >= 0) {
        value = 0;
        ShiftIndex = 4;
        while (value == 0) {
            ShiftIndex--;
            value = UINT32_GETBYTE(pBI->pIntegerArray[BIArrayIndex], ShiftIndex);
	} /* End of while */
    } /* End of if */

    if ((BIArrayIndex == -1) && (ShiftIndex == -1)) {
        pBI->IntegerLength = 1;
        pBI->ArrayLength = 1;
        pBI->Signed = 1;
    } else {
        pBI->IntegerLength = (BIArrayIndex*4) + ShiftIndex + 1;
        pBI->ArrayLength = BIArrayIndex + 1;
    } /* End of if */
} /* End of BigInteger_ClearHighBits */


VOID BigInteger_BI2Bin (
    IN PBIG_INTEGER pBI,
    OUT UINT8 *pValue,
    OUT UINT *Length)
{
    INT  ValueIndex, BIArrayIndex, ShiftIndex;
    UINT32  Number;

    if (pBI == NULL) {
        DEBUGPRINT("BigInteger_BI2Bin: pBI is NUll\n");
        *Length = 0;
        return;
    } /* End of if */

    if (*Length < (sizeof(UINT8) * pBI->IntegerLength)) {
        DEBUGPRINT("BigInteger_BI2Bin: length(%d) is not enough.\n", *Length);
        *Length = 0;
        return;
    } /* End of if */

    if (pBI->pIntegerArray == NULL) {
        *Length = 0;
        return;
    } /* End of if */

    BigInteger_ClearHighBits(pBI);
    if ((ShiftIndex = pBI->IntegerLength & 0x3) == 0)
       ShiftIndex = 4;
    BIArrayIndex = pBI->ArrayLength - 1;
    ValueIndex = 0;

    Number = pBI->pIntegerArray[BIArrayIndex];
    while (ValueIndex < pBI->IntegerLength)
    {
        pValue[ValueIndex++] = (UINT8) UINT32_GETBYTE(Number, ShiftIndex - 1);
        if ((--ShiftIndex) == 0) {
            ShiftIndex = 4;
            BIArrayIndex--;
            Number = pBI->pIntegerArray[BIArrayIndex];
        } /* End of if */
    } /* End of while */
    *Length = pBI->IntegerLength;
} /* End of BigInteger_BI2Bin */


VOID BigInteger_Bin2BI (
    IN UINT8 *pValue,
    IN UINT Length,
    OUT PBIG_INTEGER *pBI)
{
    INT  ValueIndex, BIArrayIndex, ShiftIndex;
    UINT32  Number;

    BigInteger_AllocSize(pBI, Length);

    if ((*pBI)->pIntegerArray != NULL) {
        Number = 0;
        if ((ShiftIndex = Length & 0x3) == 0)
            ShiftIndex = 4;
        BIArrayIndex = (*pBI)->ArrayLength - 1;
        ValueIndex = 0;
        while (ValueIndex < Length)
        {
            Number = (Number << 8) | (UINT8) pValue[ValueIndex++];
            if ((--ShiftIndex) == 0) {
                (*pBI)->pIntegerArray[BIArrayIndex] = Number;
                ShiftIndex = 4;
                BIArrayIndex--;
                Number = 0;
            } /* End of if */
        } /* End of while */
    } /* End of if */
} /* End of BigInteger_Bin2BI */


/* Calculate the bits of BigInteger, the highest bit is 1 */
VOID BigInteger_BitsOfBI (
    IN PBIG_INTEGER pBI,
    OUT UINT *Bits_Of_P)
{
    UINT32 Number, Index;

    Number = pBI->pIntegerArray[pBI->ArrayLength - 1];
    Index = 0;
    while ((!(Number & 0x80000000)) && (Index < 32)) {
        Number <<= 1;
        Index++;
    } /* End of while */
    *Bits_Of_P = (pBI->ArrayLength*sizeof(UINT32)) - Index;
} /* End of BigInteger_BitsOfBN */


INT BigInteger_GetBitValue (
    IN PBIG_INTEGER pBI,
    IN UINT Index)
{
    UINT Array = 0;
    UINT Shift = 0;

    if (Index > 0) {
        Array = (Index - 1) >> 0x5;
        Shift = (Index - 1) & 0x1F;
    }
    if (Array > pBI->ArrayLength)
        return 0;

    return ((pBI->pIntegerArray[Array] >> Shift) & 0x1);
} /* End of BigInteger_GetBitValue */


UINT8 BigInteger_GetByteValue (
    IN PBIG_INTEGER pBI,
    IN UINT Index)
{
    UINT Array = 0;
    UINT Shift = 0;

    if (Index > 0) {
        Array = (Index - 1) >> 0x2;
        Shift = (Index - 1) & 0x3;
    }
    if ((Array > pBI->ArrayLength) || (Index > pBI->IntegerLength))
        return 0;


    return (UINT8) UINT32_GETBYTE(pBI->pIntegerArray[Array], Shift - 1);
} /* End of BigInteger_GetByteValue */


VOID BigInteger_Copy (
    IN PBIG_INTEGER pBI_Copied,
    OUT PBIG_INTEGER *pBI_Result)
{
    BigInteger_AllocSize(pBI_Result, pBI_Copied->IntegerLength);
    NdisCopyMemory((*pBI_Result)->pIntegerArray, pBI_Copied->pIntegerArray, (sizeof(UINT32)*(*pBI_Result)->ArrayLength));
    (*pBI_Result)->ArrayLength = pBI_Copied->ArrayLength;
    (*pBI_Result)->IntegerLength = pBI_Copied->IntegerLength;
    (*pBI_Result)->Signed = pBI_Copied->Signed;
} /* End of BigInteger_Copy */


INT BigInteger_UnsignedCompare (
    IN PBIG_INTEGER pFirstOperand,
    IN PBIG_INTEGER pSecondOperand)
{
    INT BIArrayIndex;

    if (pFirstOperand->IntegerLength > pSecondOperand->IntegerLength)
        return 1;

    if (pFirstOperand->IntegerLength < pSecondOperand->IntegerLength)
        return -1;

    if (pFirstOperand->IntegerLength == pSecondOperand->IntegerLength) {
        for(BIArrayIndex = (pFirstOperand->ArrayLength - 1);BIArrayIndex >= 0 ; BIArrayIndex--)
        {
            if (pFirstOperand->pIntegerArray[BIArrayIndex] > pSecondOperand->pIntegerArray[BIArrayIndex])
                return 1;
            else if (pFirstOperand->pIntegerArray[BIArrayIndex] < pSecondOperand->pIntegerArray[BIArrayIndex])
                return -1;
        } /* End of for */
    } /* End of if */

    return 0;
} /* End of BigInteger_Compare */


VOID BigInteger_Add (
    IN PBIG_INTEGER pFirstOperand,
    IN PBIG_INTEGER pSecondOperand,
    OUT PBIG_INTEGER *pBI_Result)
{
    INT CompareResult;
    UINT32 BIArrayIndex;
    UINT64 Sum, Carry;
    PBIG_INTEGER pTempBI = NULL;

    if  ((pFirstOperand == NULL) || (pFirstOperand->pIntegerArray == NULL)
      || (pSecondOperand == NULL) || (pSecondOperand->pIntegerArray == NULL)) {
        DEBUGPRINT("BigInteger_Add: first or second operand is NULL.\n");
        return;
    } /* End of if */

    if (*pBI_Result == NULL)
        BigInteger_Init(pBI_Result);

    CompareResult = BigInteger_UnsignedCompare(pFirstOperand, pSecondOperand);
    if ((CompareResult == 0) & ((pFirstOperand->Signed * pSecondOperand->Signed) < 0)) {
        BigInteger_AllocSize(pBI_Result, 1);
        return ;
    } /* End of if */

    /*
     *  Singed table
     *  A + B || A > B || A < B
     *  ------------------------
     *  +   + ||   +   ||   +
     *  +   - ||   +   ||   -
     *  -   + ||   -   ||   +
     *  -   - ||   -   ||   -
     */
    if ((pFirstOperand->Signed * pSecondOperand->Signed) > 0) {
        if (pFirstOperand->IntegerLength > pSecondOperand->IntegerLength) {
                BigInteger_AllocSize(pBI_Result, pFirstOperand->IntegerLength + 1);
        } else {
                BigInteger_AllocSize(pBI_Result, pSecondOperand->IntegerLength + 1);
        } /* End of if */

        Carry = 0;
        for (BIArrayIndex=0; BIArrayIndex < (*pBI_Result)->ArrayLength; BIArrayIndex++)
        {

            Sum = 0;
            if (BIArrayIndex < pFirstOperand->ArrayLength)
                Sum += (UINT64) pFirstOperand->pIntegerArray[BIArrayIndex];

            if (BIArrayIndex < pSecondOperand->ArrayLength)
                Sum += (UINT64) pSecondOperand->pIntegerArray[BIArrayIndex];

            Sum += Carry;
            Carry = Sum  >> 32;
            (*pBI_Result)->pIntegerArray[BIArrayIndex] = (UINT32) (Sum & 0xffffffffUL);
        } /* End of for */
        (*pBI_Result)->Signed = pFirstOperand->Signed;
        BigInteger_ClearHighBits(*pBI_Result);
    } else {
        if  ((pFirstOperand->Signed == 1) & (pSecondOperand->Signed == -1)) {
            BigInteger_Copy(pSecondOperand, &pTempBI);
            pTempBI->Signed = 1;
            BigInteger_Sub(pFirstOperand, pTempBI, pBI_Result);
        } else if ((pFirstOperand->Signed == -1) & (pSecondOperand->Signed == 1)) {
            BigInteger_Copy(pFirstOperand, &pTempBI);
            pTempBI->Signed = 1;
            BigInteger_Sub(pSecondOperand, pTempBI, pBI_Result);
        } /* End of if */
    } /* End of if */

    BigInteger_Free(&pTempBI);
} /* End of BigInteger_Add */


VOID BigInteger_Sub (
    IN PBIG_INTEGER pFirstOperand,
    IN PBIG_INTEGER pSecondOperand,
    OUT PBIG_INTEGER *pBI_Result)
{
    INT CompareResult;
    UINT32 BIArrayIndex, Carry;
    PBIG_INTEGER pTempBI = NULL, pTempBI2 = NULL;

    if  ((pFirstOperand == NULL) || (pFirstOperand->pIntegerArray == NULL)
      || (pSecondOperand == NULL) || (pSecondOperand->pIntegerArray == NULL)) {
        DEBUGPRINT("BigInteger_Sub: first or second operand is NULL.\n");
        return;
    } /* End of if */

    if (*pBI_Result == NULL)
        BigInteger_Init(pBI_Result);

    CompareResult = BigInteger_UnsignedCompare(pFirstOperand, pSecondOperand);
    if ((CompareResult == 0) & ((pFirstOperand->Signed * pSecondOperand->Signed) > 0)) {
        BigInteger_AllocSize(pBI_Result, 1);
        return ;
    } /* End of if */

    BigInteger_Init(&pTempBI);
    BigInteger_Init(&pTempBI2);

    /*
     *  Singed table
     *  A - B || A > B || A < B
     *  ------------------------
     *  +   + ||   +   ||   -
     *  +   - ||   +   ||   +
     *  -   + ||   -   ||   -
     *  -   - ||   -   ||   +
     */
    if ((pFirstOperand->Signed * pSecondOperand->Signed) > 0) {
        if (CompareResult == 1) {
            BigInteger_Copy(pFirstOperand, &pTempBI);
            BigInteger_Copy(pSecondOperand, &pTempBI2);
        } else if (CompareResult == -1) {
            BigInteger_Copy(pSecondOperand, &pTempBI);
            BigInteger_Copy(pFirstOperand, &pTempBI2);
        } /* End of if */

        BigInteger_Copy(pTempBI, pBI_Result);
        Carry = 0;
        for (BIArrayIndex=0; BIArrayIndex < (*pBI_Result)->ArrayLength; BIArrayIndex++)
        {
            if (BIArrayIndex < pTempBI2->ArrayLength) {
                if ((*pBI_Result)->pIntegerArray[BIArrayIndex] >= (pTempBI2->pIntegerArray[BIArrayIndex] - Carry)) {
                    (*pBI_Result)->pIntegerArray[BIArrayIndex] = (*pBI_Result)->pIntegerArray[BIArrayIndex] - pTempBI2->pIntegerArray[BIArrayIndex] - Carry;
                    Carry = 0;
                } else {
                    (*pBI_Result)->pIntegerArray[BIArrayIndex] = 0xffffffffUL - pTempBI2->pIntegerArray[BIArrayIndex] - Carry + (*pBI_Result)->pIntegerArray[BIArrayIndex] + 1;
                    Carry = 1;
                } /* End of if */
            } else {
                if ((*pBI_Result)->pIntegerArray[BIArrayIndex] >= Carry) {
                    (*pBI_Result)->pIntegerArray[BIArrayIndex] -= Carry;
                    Carry = 0;
                } else {
                    (*pBI_Result)->pIntegerArray[BIArrayIndex] = 0xffffffffUL - Carry;
                    Carry = 1;
                } /* End of if */
            } /* End of if */
        } /* End of for */

        if  (((pFirstOperand->Signed == 1) & (pSecondOperand->Signed == 1) & (CompareResult == -1))
          || ((pFirstOperand->Signed == -1) & (pSecondOperand->Signed == -1) & (CompareResult == 1)))
            (*pBI_Result)->Signed = -1;

        BigInteger_ClearHighBits(*pBI_Result);
    } else {
        if  ((pFirstOperand->Signed == 1) & (pSecondOperand->Signed == -1)) {
            BigInteger_Copy(pSecondOperand, &pTempBI);
            pTempBI->Signed = 1;
            BigInteger_Add(pFirstOperand, pTempBI, pBI_Result);
        } else if ((pFirstOperand->Signed == -1) & (pSecondOperand->Signed == 1)) {
            BigInteger_Copy(pFirstOperand, &pTempBI);
            pTempBI->Signed = 1;
            BigInteger_Add(pTempBI, pSecondOperand, pBI_Result);
            (*pBI_Result)->Signed = -1;
        } /* End of if */
    } /* End of if */

    BigInteger_Free(&pTempBI);
    BigInteger_Free(&pTempBI2);
} /* End of BigInteger_Sub */


VOID BigInteger_Mul (
    IN PBIG_INTEGER pFirstOperand,
    IN PBIG_INTEGER pSecondOperand,
    OUT PBIG_INTEGER *pBI_Result)
{

    UINT32 BIFirstIndex, BISecondIndex;
    UINT64 FirstValue, SecondValue, Sum, Carry;

    if  ((pFirstOperand == NULL) || (pFirstOperand->pIntegerArray == NULL)
      || (pSecondOperand == NULL) || (pSecondOperand->pIntegerArray == NULL)) {
        DEBUGPRINT("BigInteger_Mul: first or second operand is NULL.\n");
        return;
    } /* End of if */

    /* The first or second operand is zero */
    if  (((pFirstOperand->IntegerLength  == 1) && (pFirstOperand->pIntegerArray[0]  == 0))
       ||((pSecondOperand->IntegerLength == 1) && (pSecondOperand->pIntegerArray[0] == 0))) {
        BigInteger_AllocSize(pBI_Result, 1);
        goto output;
    } /* End of if */

    /* The first or second operand is one */
    if  ((pFirstOperand->IntegerLength  == 1) && (pFirstOperand->pIntegerArray[0]  == 1)) {
        BigInteger_Copy(pSecondOperand, pBI_Result);
        goto output;
    } /* End of if */
    if  ((pSecondOperand->IntegerLength  == 1) && (pSecondOperand->pIntegerArray[0]  == 1)) {
        BigInteger_Copy(pFirstOperand, pBI_Result);
        goto output;
    } /* End of if */

    BigInteger_AllocSize(pBI_Result, pFirstOperand->IntegerLength + pSecondOperand->IntegerLength);

    for (BIFirstIndex=0; BIFirstIndex < pFirstOperand->ArrayLength; BIFirstIndex++)
    {
        Carry = 0;
        FirstValue = (UINT64) pFirstOperand->pIntegerArray[BIFirstIndex];
        if (FirstValue == 0) {
            continue;
        } else {
            for (BISecondIndex=0; BISecondIndex < pSecondOperand->ArrayLength; BISecondIndex++)
            {
                SecondValue = ((UINT64) pSecondOperand->pIntegerArray[BISecondIndex])*FirstValue;
                Sum = (UINT64) ((*pBI_Result)->pIntegerArray[BIFirstIndex + BISecondIndex] + SecondValue + Carry);
                Carry = Sum >> 32;
                (*pBI_Result)->pIntegerArray[BIFirstIndex + BISecondIndex] = (UINT32) (Sum & 0xffffffffUL);
            } /* End of for */
            while (Carry != 0) {
                Sum = (UINT64) (*pBI_Result)->pIntegerArray[BIFirstIndex + BISecondIndex];
                Sum += Carry;

                Carry = Sum >> 32;
                (*pBI_Result)->pIntegerArray[BIFirstIndex + BISecondIndex] = (UINT32) (Sum & 0xffffffffUL);
                BISecondIndex++;
            } /* End of while */
        } /* End of if */
    } /* End of for */

output:
    (*pBI_Result)->Signed = pFirstOperand->Signed * pSecondOperand->Signed;
    BigInteger_ClearHighBits(*pBI_Result);
} /* End of BigInteger_Mul */


VOID BigInteger_Square (
    IN PBIG_INTEGER pBI,
    OUT PBIG_INTEGER *pBI_Result)
{
    INT BIFirstIndex, BISecondIndex;
	UINT32 HBITS_Value, LBITS_Value, Temp1_Value, Temp2_Value, Carry32;
	UINT32 *Point_Of_S, *Point_Of_Result, *Point_Of_BI;
    UINT64 Result64_1, Result64_2, Carry64, TempValue64;

    if ((pBI == NULL) || (pBI->pIntegerArray == NULL)) {
        DEBUGPRINT("\tBigInteger_Square: the operand is NULL.\n");
        return;
    } /* End of if */

    /* The operand is zero */
    if  ((pBI->IntegerLength  == 1) && (pBI->pIntegerArray[0]  ==  0)) {
        BigInteger_AllocSize(pBI_Result, 1);
        goto output;
    } /* End of if */

    BigInteger_AllocSize(pBI_Result, (pBI->IntegerLength*2) + 20);
    BigInteger_AllocSize(&pBI_S, (pBI->IntegerLength*2) + 20);
    BigInteger_AllocSize(&pBI_O, (pBI->IntegerLength*2) + 20);

    /*
     * Input: pBI = {a_0, a_1, a_2, a_3, ..., a_n}
     * Step1. calculate a_0^2, a_1^2, a_2^2, a_3^2 ... a_n^2
     */
	Point_Of_S = pBI_S->pIntegerArray;
    for (BIFirstIndex=0; BIFirstIndex < pBI->ArrayLength; BIFirstIndex++)
    {
	HBITS_Value = UINT32_HBITS(pBI->pIntegerArray[BIFirstIndex]);
		LBITS_Value = UINT32_LBITS(pBI->pIntegerArray[BIFirstIndex]);
		Temp1_Value = HBITS_Value*LBITS_Value;
		Temp2_Value = (Temp1_Value & 0x7fff) << 0x11;
		Point_Of_S[0] = (LBITS_Value*LBITS_Value) + Temp2_Value;
		Point_Of_S[1] = (HBITS_Value*HBITS_Value) + ((Temp1_Value >> 0xf) & 0x1ffff);
		if (Point_Of_S[0] < Temp2_Value)
			Point_Of_S[1] += 1;

		Point_Of_S += 2;
    } /* End of for */

    /*
     * Step2. calculate a_0*{a_1, a_2, a_3, a_4, ..., a_n}
     */
    Point_Of_BI = pBI->pIntegerArray;
    Point_Of_Result = (*pBI_Result)->pIntegerArray;
    Point_Of_Result[0] = 0;
    TempValue64 = (UINT64) Point_Of_BI[0];
    Point_Of_Result++;
    Carry64 = 0;
    for (BIFirstIndex=1; BIFirstIndex < pBI->ArrayLength; BIFirstIndex++)
    {
        Result64_1 =  (UINT64) Point_Of_BI[BIFirstIndex]*TempValue64;
        Result64_1 += Carry64;
        Carry64 = (Result64_1 >> 32);
        Point_Of_Result[0] = (UINT32) (Result64_1 & 0xffffffffUL);
        Point_Of_Result++;
    } /* End of for */
    if (Carry64 > 0)
        Point_Of_Result[0] = (UINT32) (Carry64 & 0xffffffffUL);

    /*
     * Step3. calculate
     *           a_1*{a_2, a_3, a_4, ..., a_n}
     *           a_2*{a_3, a_4, a_5, ..., a_n}
     *           a_3*{a_4, a_5, a_6, ..., a_n}
     *           a_4*{a_5, a_6, a_7, ..., a_n}
     *           ...
     *           a_n-1*{a_n}
     */
    Point_Of_BI = pBI->pIntegerArray;
    for (BIFirstIndex=1; BIFirstIndex < (pBI->ArrayLength - 1); BIFirstIndex++)
    {
        Point_Of_Result = (*pBI_Result)->pIntegerArray;
        Point_Of_Result += (BIFirstIndex*2) + 1;
        TempValue64 = (UINT64) Point_Of_BI[BIFirstIndex];
        Carry64 = 0;
        for (BISecondIndex=(BIFirstIndex + 1); BISecondIndex < pBI->ArrayLength; BISecondIndex++)
        {
            Result64_1 = ((UINT64) Point_Of_Result[0]) + Carry64;
            Result64_2 = (UINT64) Point_Of_BI[BISecondIndex]*TempValue64;
            Carry64 = (Result64_1 >> 32);
            Result64_1 = (Result64_1 & 0xffffffffUL);
            Result64_1 = Result64_1 + Result64_2;
            Carry64 += (Result64_1 >> 32);
            Point_Of_Result[0] = (UINT32) (Result64_1 & 0xffffffffUL);
            Point_Of_Result++;
        } /* End of for */
        if (Carry64 > 0)
            Point_Of_Result[0] += (UINT32) (Carry64 & 0xffffffffUL);
    } /* End of for */

    BigInteger_ClearHighBits(*pBI_Result);
    BigInteger_Copy(*pBI_Result, &pBI_O);

    Carry32 = 0;
	for (BIFirstIndex=0; BIFirstIndex < pBI_O->ArrayLength; BIFirstIndex++) {
        pBI_O->pIntegerArray[BIFirstIndex] = (pBI_O->pIntegerArray[BIFirstIndex] << 1) | Carry32;
        if (pBI_O->pIntegerArray[BIFirstIndex] < (*pBI_Result)->pIntegerArray[BIFirstIndex])
            Carry32 = 1;
        else
            Carry32 = 0;
    } /* End of for */
    pBI_O->pIntegerArray[BIFirstIndex] = Carry32;
    pBI_O->IntegerLength++;
    pBI_O->ArrayLength++;
    BigInteger_ClearHighBits(pBI_O);

    BigInteger_Add(pBI_O, pBI_S, pBI_Result);
output:
    (*pBI_Result)->Signed = 1;
    BigInteger_ClearHighBits(*pBI_Result);
} /* End of BigInteger_Square */


VOID BigInteger_Div (
    IN PBIG_INTEGER pFirstOperand,
    IN PBIG_INTEGER pSecondOperand,
    OUT PBIG_INTEGER *pBI_Result,
    OUT PBIG_INTEGER *pBI_Remainder)
{
    INT CompareResult;
    INT Index, MulIndex, ComputeSize;
    UINT32 MulStart;
    UINT AllocLength, ArrayIndex, ShiftIndex;
    PBIG_INTEGER pTempBI = NULL, pTempBI2 = NULL, pMulBI = NULL;
    UINT8 SecondHighByte;

    if  ((pFirstOperand == NULL) || (pFirstOperand->pIntegerArray == NULL)
      || (pSecondOperand == NULL) || (pSecondOperand->pIntegerArray == NULL)) {
        DEBUGPRINT("BigInteger_Div: first or second operand is NULL.\n");
        return;
    } /* End of if */

    /* The second operand is zero */
    if ((pSecondOperand->IntegerLength == 1) && (pSecondOperand->pIntegerArray[0] == 0)) {
        DEBUGPRINT("BigInteger_Div: second operand is zero.\n");
        return;
    } /* End of if */

    if (*pBI_Result == NULL)
        BigInteger_Init(pBI_Result);
    if (*pBI_Remainder == NULL)
        BigInteger_Init(pBI_Remainder);

    /* The second operand is one */
    if  ((pSecondOperand->IntegerLength  == 1) && (pSecondOperand->pIntegerArray[0]  == 1)) {
        BigInteger_Copy(pFirstOperand, pBI_Result);
        BigInteger_Bin2BI(Value_0, 1, pBI_Remainder);
        goto output;
    } /* End of if */

    CompareResult = BigInteger_UnsignedCompare(pFirstOperand, pSecondOperand);
    if (CompareResult == 0) {
        BigInteger_Bin2BI(Value_1, 1, pBI_Result);
        BigInteger_Bin2BI(Value_0, 1, pBI_Remainder);
        goto output;
    } else if (CompareResult == -1) {
        BigInteger_Bin2BI(Value_0, 1, pBI_Result);
        BigInteger_Copy(pFirstOperand, pBI_Remainder);
        goto output;
    } /* End of if */
    BigInteger_AllocSize(pBI_Result, pFirstOperand->IntegerLength - pSecondOperand->IntegerLength + 1);
    BigInteger_AllocSize(pBI_Remainder, pSecondOperand->IntegerLength);

    AllocLength = (UINT) (pFirstOperand->IntegerLength << 1);
    BigInteger_AllocSize(&pTempBI, AllocLength);
    BigInteger_AllocSize(&pTempBI2, AllocLength);
    BigInteger_AllocSize(&pMulBI, AllocLength);

    BigInteger_Copy(pFirstOperand, pBI_Remainder);
    SecondHighByte = BigInteger_GetByteValue(pSecondOperand, pSecondOperand->IntegerLength);
    ComputeSize = (INT) pFirstOperand->IntegerLength - pSecondOperand->IntegerLength + 1;
    for (Index = (INT) ComputeSize;Index >= 0;Index--) {
        if (BigInteger_UnsignedCompare(*pBI_Remainder, pSecondOperand) == -1)
            break;

        if (((pSecondOperand->IntegerLength + Index) - (*pBI_Remainder)->IntegerLength) <= 1) {
            BigInteger_AllocSize(&pMulBI, Index + 1);
            ArrayIndex = 0;
            if (Index > 0)
                ArrayIndex = (UINT) (Index - 1) >> 2 ;
            ShiftIndex = (Index & 0x03);
            if (ShiftIndex == 0)
                ShiftIndex = 4;
            ShiftIndex--;
            MulStart = 0;
            MulStart = (BigInteger_GetByteValue((*pBI_Remainder), pFirstOperand->IntegerLength + Index - ComputeSize + 1) & 0xFF) << 8;
            MulStart = MulStart | (BigInteger_GetByteValue((*pBI_Remainder), pFirstOperand->IntegerLength + Index - ComputeSize) & 0xFF);
            if (MulStart < (UINT32) SecondHighByte)
                continue;

            MulStart = MulStart / (UINT32) SecondHighByte;

            if (MulStart > 0xFF)
                MulStart = 0x100;

            for (MulIndex = (INT) MulStart;MulIndex <= 0x101;MulIndex++) { /* 0xFFFF / 0xFF = 0x101 */
                if ((MulIndex > 0xFF) && (ShiftIndex == 3))
                        pMulBI->pIntegerArray[ArrayIndex + 1] = 0x01;
                pMulBI->pIntegerArray[ArrayIndex] = ((UINT) MulIndex << (8*ShiftIndex));
                BigInteger_Mul(pSecondOperand, pMulBI , &pTempBI);
                CompareResult = BigInteger_UnsignedCompare(*pBI_Remainder, pTempBI);
                if (CompareResult < 1) {
                    if (MulIndex > 1) {
                        if (CompareResult != 0) {
                            if ((MulIndex == 0x100) && (ShiftIndex == 3))
                                   pMulBI->pIntegerArray[ArrayIndex + 1] = 0;
                            pMulBI->pIntegerArray[ArrayIndex] = ((UINT) (MulIndex - 1) << (8*ShiftIndex));
                        } /* End of if */

                        BigInteger_Mul(pSecondOperand, pMulBI, &pTempBI);
                        BigInteger_Sub(*pBI_Remainder, pTempBI, &pTempBI2);
                        BigInteger_Copy(pTempBI2, pBI_Remainder);
                        BigInteger_Add(*pBI_Result, pMulBI, &pTempBI2);
                        BigInteger_Copy(pTempBI2, pBI_Result);
                    } /* End of if */
                    break;
                } /* End of if */

                if ((MulIndex >= 0x100) && (ShiftIndex == 3))
                   pMulBI->pIntegerArray[ArrayIndex++] = 0;
                pMulBI->pIntegerArray[ArrayIndex] = 0;
            } /* End of for */
        } /* End of if */
    } /* End of for */

    BigInteger_Free(&pTempBI);
    BigInteger_Free(&pTempBI2);
    BigInteger_Free(&pMulBI);
output:
    (*pBI_Result)->Signed = pFirstOperand->Signed * pSecondOperand->Signed;
    (*pBI_Remainder)->Signed = pFirstOperand->Signed * pSecondOperand->Signed;
    BigInteger_ClearHighBits(*pBI_Result);
    BigInteger_ClearHighBits(*pBI_Remainder);
} /* End of BigInteger_Div */


VOID BigInteger_Montgomery_Reduction (
    IN PBIG_INTEGER pBI_A,
    IN PBIG_INTEGER pBI_P,
     IN PBIG_INTEGER pBI_R,
    OUT PBIG_INTEGER *pBI_Result)
{
    UINT32 *Point_P, *Point_Result;
    UINT32 LoopCount;
    UINT64 Result64_1, Result64_2, Carry64, TempValue64;
    INT FirstLoop, SecondLoop;

    BigInteger_AllocSize(pBI_Result, pBI_A->IntegerLength+ pBI_P->IntegerLength + 20);
    BigInteger_Copy(pBI_A, pBI_Result);

    Point_P = pBI_P->pIntegerArray;
    Point_Result = (*pBI_Result)->pIntegerArray;

    LoopCount = Bits_Of_R >> 0x5;
    for (FirstLoop = 0;FirstLoop < LoopCount;FirstLoop++) {
        Carry64 = 0;
        TempValue64 = (UINT64) Point_Result[0];
        for (SecondLoop = 0;SecondLoop < pBI_P->ArrayLength;SecondLoop++) {
            Result64_1 = ((UINT64) Point_Result[SecondLoop]) + Carry64;
            Result64_2 = (UINT64) Point_P[SecondLoop]*TempValue64;
            Carry64 = (Result64_1 >> 32);
            Result64_1 = (Result64_1 & 0xffffffffUL);
            Result64_1 = Result64_1 + Result64_2;
            Carry64 += (Result64_1 >> 32);
            Point_Result[SecondLoop] = (UINT32) (Result64_1 & 0xffffffffUL);
        } /* End of for */
        while (Carry64 != 0) {
          Result64_1 = ((UINT64) Point_Result[SecondLoop]) + Carry64;
          Carry64 = Result64_1 >> 32;
          Point_Result[SecondLoop] = (UINT32) (Result64_1 & 0xffffffffUL);
          SecondLoop++;
        } /* End of while */
        Point_Result++;
    } /* End of for */

    for (FirstLoop = 0;FirstLoop <= LoopCount;FirstLoop++) {
        (*pBI_Result)->pIntegerArray[FirstLoop] = (*pBI_Result)->pIntegerArray[FirstLoop + LoopCount];
    } /* End of for */
    if ((*pBI_Result)->pIntegerArray[LoopCount] != 0)
        (*pBI_Result)->ArrayLength = LoopCount + 1;
    else
        (*pBI_Result)->ArrayLength = LoopCount;

    (*pBI_Result)->IntegerLength = (*pBI_Result)->ArrayLength*4;
    BigInteger_ClearHighBits(*pBI_Result);

    if (BigInteger_UnsignedCompare(*pBI_Result, pBI_P) >= 0) {
        BigInteger_Sub(*pBI_Result, pBI_P, &pBI_U);
        BigInteger_Copy(pBI_U, pBI_Result);
    } /* End of if */
    BigInteger_ClearHighBits(*pBI_Result);
} /* End of BigInteger_Montgomery_Reduction */


VOID BigInteger_Montgomery_ExpMod (
    IN PBIG_INTEGER pBI_G,
    IN PBIG_INTEGER pBI_E,
    IN PBIG_INTEGER pBI_P,
    OUT PBIG_INTEGER *pBI_Result)
{
    UINT Bits_Of_P;
    UINT32 Index, Index2, AllocLength;
	UINT32 Sliding_Value , Sliding_HighValue, Sliding_LowValue;
    PBIG_INTEGER pBI_Temp1 = NULL, pBI_Temp2 = NULL;
    PBIG_INTEGER pBI_X = NULL, pBI_R = NULL, pBI_RR = NULL, pBI_1 = NULL;
    BIG_INTEGER *pBI_A[SLIDING_WINDOW];
    UINT8 *pRValue = NULL;

    AllocLength = (pBI_G->IntegerLength + pBI_E->IntegerLength + pBI_P->IntegerLength + 300);
    BigInteger_AllocSize(&pBI_Temp1, AllocLength);
    BigInteger_AllocSize(&pBI_Temp2, AllocLength);

    /* Calculate the bits of P and E, the highest bit is 1 */
    BigInteger_BitsOfBI(pBI_P, &Bits_Of_P);

    if ((pBI_E->IntegerLength == 1) && (pBI_E->pIntegerArray[0] == 1)) {
        BigInteger_Div(pBI_G, pBI_P, &pBI_Temp1, pBI_Result);
        goto memory_free;
    } /* End of if */

    if ((pBI_E->IntegerLength == 1) && (pBI_E->pIntegerArray[0] == 2)) {
        BigInteger_Mul(pBI_G, pBI_G, &pBI_Temp1);
        BigInteger_Div(pBI_Temp1, pBI_P, &pBI_Temp2, pBI_Result);
        goto memory_free;
    } /* End of if */

    /*
     * Main algorithm
     */
    BigInteger_Init(&pBI_R);
    BigInteger_Init(&pBI_RR);
    BigInteger_Bin2BI(Value_1, 1, &pBI_1);
    BigInteger_AllocSize(&pBI_X, AllocLength);
    BigInteger_AllocSize(&pBI_U, AllocLength); // for BigInteger_Montgomery_Reduction
    BigInteger_AllocSize(&pBI_S, AllocLength); // for BigInteger_Square
    BigInteger_AllocSize(&pBI_O, AllocLength); // for BigInteger_Square

    for (Index = 0; Index < SLIDING_WINDOW; Index++) {
        pBI_A[Index] = NULL;
		BigInteger_AllocSize(&pBI_A[Index], 193);
    } /* End of for */
    BigInteger_Bin2BI(WPS_DH_P_VALUE, 192, &pBI_Temp1);
    if (NdisCmpMemory(pBI_P->pIntegerArray, pBI_Temp1->pIntegerArray, pBI_P->IntegerLength) == 0) {
        BigInteger_Bin2BI(WPS_DH_X_VALUE, 184, &pBI_X);
        BigInteger_Bin2BI(WPS_DH_R_VALUE, 193, &pBI_R);
        BigInteger_Bin2BI(WPS_DH_RRModP_VALUE, 192, &pBI_RR);
        Bits_Of_R = 1537;
    } else {
        if ((Bits_Of_P % 8) == 0) {
            AllocLength = pBI_P->IntegerLength + 1;
        } else {
            AllocLength = pBI_P->IntegerLength;
        } /* End of if */
        pRValue = (UINT8 *) kmalloc(sizeof(UINT8)*AllocLength, GFP_ATOMIC);
	if (pRValue == NULL)
	{
		DBGPRINT(RT_DEBUG_ERROR, ("%s():Alloc memory failed\n", __FUNCTION__));
		goto memory_free;
	}
        NdisZeroMemory(pRValue, sizeof(UINT8)*AllocLength);
        pRValue[0] = (UINT8) (1 << (Bits_Of_P & 0x7));
        BigInteger_Bin2BI(pRValue, AllocLength , &pBI_R);

        BigInteger_Mul(pBI_R, pBI_R, &pBI_Temp1);
        BigInteger_Div(pBI_Temp1, pBI_P, &pBI_A[1], &pBI_RR);

        /* X = 1*R (mod P) */
        BigInteger_Div(pBI_R, pBI_P, &pBI_Temp2, &pBI_X);
    } /* End of if */

    /* A = G*R (mod P) => A = MonMod(G, R^2 mod P) */
    BigInteger_Mul(pBI_G, pBI_RR, &pBI_Temp1);
    BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P , pBI_R, &pBI_A[1]);
    for (Index = 2; Index < SLIDING_WINDOW; Index++) {
        BigInteger_Mul(pBI_A[Index - 1], pBI_A[1], &pBI_Temp1);
	    BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P, pBI_R, &pBI_A[Index]);
    } /* End of for */

    for (Index = pBI_E->IntegerLength ; Index > 0 ; Index--) {
        for (Index2 = 0; Index2 < 4 ; Index2++) {
            BigInteger_Square(pBI_X, &pBI_Temp1);
			BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P, pBI_R, &pBI_X);
	    } /* End of for */

		Sliding_Value = BigInteger_GetByteValue(pBI_E, Index);
		Sliding_HighValue = (Sliding_Value >> 4);
		if (Sliding_HighValue != 0) {
            BigInteger_Mul(pBI_A[Sliding_HighValue], pBI_X, &pBI_Temp1);
			BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P, pBI_R, &pBI_X);
		} /* End of if */

        for (Index2 = 0; Index2 < 4 ; Index2++) {
            BigInteger_Square(pBI_X, &pBI_Temp1);
			BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P, pBI_R, &pBI_X);
	    } /* End of for */

		Sliding_LowValue = Sliding_Value & 0x0f;
		if (Sliding_LowValue != 0) {
            BigInteger_Mul(pBI_A[Sliding_LowValue], pBI_X, &pBI_Temp1);
			BigInteger_Montgomery_Reduction(pBI_Temp1, pBI_P, pBI_R, &pBI_X);
		} /* End of if */
    } /* End of for */
    BigInteger_Montgomery_Reduction(pBI_X, pBI_P , pBI_R, pBI_Result);

    BigInteger_Free(&pBI_X);
    BigInteger_Free(&pBI_R);
    BigInteger_Free(&pBI_RR);
    BigInteger_Free(&pBI_1);
    BigInteger_Free(&pBI_U);
    BigInteger_Free(&pBI_S);
    BigInteger_Free(&pBI_O);
    for(Index = 0; Index < SLIDING_WINDOW; Index++)
			BigInteger_Free(&pBI_A[Index]);
    if (pRValue != NULL)
        kfree(pRValue);

memory_free:
    BigInteger_Free(&pBI_Temp1);
    BigInteger_Free(&pBI_Temp2);
} /* End of BigInteger_Montgomery_ExpMod */

/* End of crypt_biginteger.c */