1120 lines
40 KiB
C
1120 lines
40 KiB
C
|
/*
|
||
|
*************************************************************************
|
||
|
* 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 */
|