Add SteamCore + inviter
This commit is contained in:
BotoX
@@ -0,0 +1,634 @@
|
||||
/***
|
||||
bigint.inc - Big Integers Operation Library Functions
|
||||
|
||||
Version: 0.1
|
||||
Date: 28-12-2014
|
||||
Author: Statik
|
||||
|
||||
Provides some arithmetic and logical maths functions to operate
|
||||
with big integers.
|
||||
|
||||
**UNFINISHED**
|
||||
|
||||
***/
|
||||
|
||||
#if defined _BigInt_included
|
||||
#endinput
|
||||
#endif
|
||||
|
||||
#define _BigInt_included
|
||||
|
||||
stock modpowBigInt(base[], exponent[], modulus[], nBase, output[], oSize) // http://en.wikipedia.org/wiki/Modular_exponentiation
|
||||
{ // Modular exponentiation, Right-to-left binary method (binary exponentiation + memory efficient method)
|
||||
new eSize = getBigIntSize(exponent);
|
||||
new mSize = getBigIntSize(modulus);
|
||||
new auxSize = (mSize+1)*2; // output and base (pow base) are never bigger than modulus
|
||||
decl aux[auxSize];
|
||||
decl auxBase[auxSize]; // Is used as a replacemente of the power base, not the numeric base
|
||||
decl auxExponent[eSize+1];
|
||||
new parity[2];
|
||||
|
||||
output[0] = 1;
|
||||
output[1] = -1;
|
||||
copyBigInt(base, auxBase, auxSize);
|
||||
copyBigInt(exponent, auxExponent, eSize+1);
|
||||
modBigInt(base, modulus, nBase, auxBase, auxSize);
|
||||
|
||||
while (isBiggerThanBigNumber(auxExponent, {0,-1})) // exponent > 0
|
||||
{
|
||||
fulldivBigInt(auxExponent, {2,-1}, nBase, auxExponent, eSize+1, parity, sizeof(parity));
|
||||
if (parity[0] == 1) // (exponent % 2) == 1 / Is exponent odd?
|
||||
{
|
||||
multBigInt(output, auxBase, nBase, aux, auxSize);
|
||||
modBigInt(aux, modulus, nBase, output, oSize);
|
||||
}
|
||||
multBigInt(auxBase, auxBase, nBase, auxBase, auxSize);
|
||||
modBigInt(auxBase, modulus, nBase, auxBase, auxSize);
|
||||
}
|
||||
}
|
||||
|
||||
stock powBigInt(number[], exponent[], base, output[], oSize) // Exponentiation by squaring recursive algorithm **UNFINISHED**
|
||||
{ // http://en.wikipedia.org/wiki/Exponentiation_by_squaring
|
||||
new nSize = getBigIntSize(number);
|
||||
new eSize = getBigIntSize(exponent);
|
||||
if (!isBiggerThanBigNumber(exponent, {0,-1})) // Exponent is 0
|
||||
{
|
||||
output[0] = 1;
|
||||
output[1] = -1;
|
||||
return;
|
||||
}
|
||||
if (!isBiggerThanBigNumber(exponent, {1,-1})) // Exponent is 1
|
||||
{
|
||||
for (new i = 0; i <= nSize; i++)
|
||||
{
|
||||
output[i] = number[i];
|
||||
}
|
||||
return;
|
||||
}
|
||||
new bool:isExponentEven = (exponent[0] % 2) == 0;
|
||||
multBigInt(number, number, base, output, oSize); // number^2
|
||||
if (!isBiggerThanBigNumber(exponent, {2,-1})) return;
|
||||
|
||||
if (isExponentEven)
|
||||
{
|
||||
//powBigInt(output, exponent/2, base, output, oSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
//powBigInt(output, exponent-1/2, base, output, oSize);
|
||||
}
|
||||
}
|
||||
|
||||
stock multBigInt(n1[], n2[], base, output[], oSize)
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
if (n1Size < 40000 && n2Size < 40000)
|
||||
{
|
||||
standardMult(n1, n2, base, output, oSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
karatsubaMult(n1, n2, base, output, oSize);
|
||||
}
|
||||
}
|
||||
|
||||
stock divBigInt(n1[], n2[], base, output[], oSize)
|
||||
{
|
||||
new n2Size = getBigIntSize(n2);
|
||||
decl remainder[n2Size+1]; // Remainder is never bigger than divisor/denominator
|
||||
fulldivBigInt(n1, n2, base, output, oSize, remainder, n2Size+1);
|
||||
}
|
||||
|
||||
stock modBigInt(n1[], n2[], base, output[], oSize)
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
decl quotient[n1Size+1]; // Quotient is never bigger than dividend/numerator
|
||||
fulldivBigInt(n1, n2, base, quotient, n1Size+1, output, oSize);
|
||||
}
|
||||
|
||||
stock fulldivBigInt(n1[], n2[], base, quotient[], qSize, remainder[], rSize)
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
|
||||
if (qSize < (n1Size+1)) return;
|
||||
if (!isBiggerThanBigNumber(n2, {0,-1})) // n2 == 0
|
||||
return;
|
||||
|
||||
if (n2Size > n1Size)
|
||||
{
|
||||
quotient[0] = 0;
|
||||
quotient[1] = -1;
|
||||
copyBigInt(n1, remainder, rSize);
|
||||
return;
|
||||
}
|
||||
decl tempRemainder[rSize+1];
|
||||
tempRemainder[0] = -1;
|
||||
quotient[n1Size] = -1;
|
||||
new i;
|
||||
for (i = n1Size-1; i >= 0; i--)
|
||||
{
|
||||
leftShiftBigInt(tempRemainder, 1);
|
||||
trimBigInt(tempRemainder);
|
||||
tempRemainder[0] = n1[i];
|
||||
quotient[i] = 0;
|
||||
while (!isBiggerThanBigNumber(n2, tempRemainder)) // (tempRemainder >= n2)
|
||||
{
|
||||
subBigInt(tempRemainder, n2, base, tempRemainder, rSize);
|
||||
quotient[i]++;
|
||||
}
|
||||
}
|
||||
copyBigInt(tempRemainder, remainder, rSize);
|
||||
trimBigInt(quotient);
|
||||
}
|
||||
|
||||
stock karatsubaMult(n1[], n2[], base, output[], oSize) // Karatsuba recursive algorithm
|
||||
{ // http://en.wikipedia.org/wiki/Karatsuba_algorithm#Pseudo_Code_Implementation
|
||||
if (oSize < 2) return;
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
if (n1Size == 1 || n2Size == 1) // Base case
|
||||
{
|
||||
standardMult(n1, n2, base, output, oSize);
|
||||
return;
|
||||
}
|
||||
new m = (n1Size > n2Size) ? n1Size : n2Size;
|
||||
new m2 = m/2;
|
||||
|
||||
decl l1[oSize], h1[oSize];
|
||||
decl l2[oSize], h2[oSize];
|
||||
splitBigIntAt(n1, m2, l1, oSize, h1, oSize);
|
||||
splitBigIntAt(n2, m2, l2, oSize, h2, oSize);
|
||||
|
||||
decl z0[oSize]; // <-
|
||||
karatsubaMult(l1, l2, base, z0, oSize);
|
||||
//standardMult(l1, l2, base, z0, oSize);
|
||||
|
||||
decl z1[oSize]; // <-
|
||||
decl l1plush1[oSize];
|
||||
decl l2plush2[oSize];
|
||||
addBigInt(l1, h1, base, l1plush1, oSize);
|
||||
addBigInt(l2, h2, base, l2plush2, oSize);
|
||||
karatsubaMult(l1plush1, l2plush2, base, z1, oSize);
|
||||
//standardMult(l1plush1, l2plush2, base, z1, oSize);
|
||||
|
||||
decl z2[oSize]; // <-
|
||||
karatsubaMult(h1, h2, base, z2, oSize);
|
||||
//standardMult(h1, h2, base, z2, oSize);
|
||||
|
||||
decl z3[oSize]; // <-
|
||||
subBigInt(z1, z2, base, z3, oSize);
|
||||
subBigInt(z3, z0, base, z3, oSize);
|
||||
|
||||
leftShiftBigInt(z2, 2*m2);
|
||||
leftShiftBigInt(z3, m2);
|
||||
|
||||
addBigInt(z2, z3, base, output, oSize);
|
||||
addBigInt(output, z0, base, output, oSize);
|
||||
|
||||
trimBigInt(output);
|
||||
}
|
||||
|
||||
stock standardMult(n1[], n2[], base, output[], oSize)
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
new bool:n1b = isBiggerThanBigNumber(n1, n2); // Is n1 bigger
|
||||
new sSize = (n1b) ? n2Size : n1Size; // Smallest size
|
||||
new bSize = (n1b) ? n1Size : n2Size; // Biggest size
|
||||
new carry = 0;
|
||||
decl value[sSize][oSize];
|
||||
new temp, i, u;
|
||||
for (i = 0; i < sSize; i++)
|
||||
{
|
||||
for (u = 0; u < bSize; u++)
|
||||
{
|
||||
temp = n1[(n1b)?u:i] * n2[(n1b)?i:u] + carry;
|
||||
if (temp >= base)
|
||||
{
|
||||
carry = temp / base;
|
||||
value[i][u] = temp % base;
|
||||
}
|
||||
else
|
||||
{
|
||||
carry = 0;
|
||||
value[i][u] = temp;
|
||||
}
|
||||
}
|
||||
if (carry != 0)
|
||||
{
|
||||
value[i][u] = carry;
|
||||
value[i][u+1] = -1;
|
||||
carry = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
value[i][u] = -1;
|
||||
}
|
||||
leftShiftBigInt(value[i], i);
|
||||
}
|
||||
output[0] = -1; // Initializes output
|
||||
for (i = 0; i < sSize; i++)
|
||||
{
|
||||
addBigInt(output, value[i], base, output, oSize);
|
||||
}
|
||||
trimBigInt(output);
|
||||
}
|
||||
|
||||
stock addBigInt(n1[], n2[], base, output[], oSize) // Standard algorithm
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
new carry = 0;
|
||||
new temp;
|
||||
new i;
|
||||
for (i = 0; (i < n1Size || i < n2Size); i++)
|
||||
{
|
||||
if (i == oSize) return;
|
||||
if (i >= n1Size) temp = n2[i] + carry;
|
||||
else if (i >= n2Size) temp = n1[i] + carry;
|
||||
else temp = n1[i] + n2[i] + carry;
|
||||
|
||||
if (temp >= base)
|
||||
{
|
||||
output[i] = temp - base;
|
||||
carry = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
output[i] = temp;
|
||||
carry = 0;
|
||||
}
|
||||
}
|
||||
if (carry == 1) // Adds the last carry
|
||||
{
|
||||
output[i] = carry;
|
||||
output[i+1] = -1;
|
||||
}
|
||||
else output[i] = -1;
|
||||
trimBigInt(output);
|
||||
}
|
||||
|
||||
stock subBigInt(n1[], n2[], base, output[], oSize) // Standard algorithm
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
new carry = 0;
|
||||
new temp;
|
||||
new i;
|
||||
for (i = 0; (i < n1Size || i < n2Size); i++)
|
||||
{
|
||||
if (i == oSize) return;
|
||||
if (i >= n1Size) temp = n2[i] - carry;
|
||||
else if (i >= n2Size) temp = n1[i] - carry;
|
||||
else temp = n1[i] - n2[i] - carry;
|
||||
|
||||
if (temp < 0)
|
||||
{
|
||||
output[i] = temp + base;
|
||||
carry = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
output[i] = temp;
|
||||
carry = 0;
|
||||
}
|
||||
}
|
||||
output[i] = -1;
|
||||
trimBigInt(output);
|
||||
}
|
||||
|
||||
stock bool:splitBigIntAt(number[], index, lowOut[], loSize, highOut[], hoSize)
|
||||
{
|
||||
new nSize = getBigIntSize(number);
|
||||
if (index == 0) return false;
|
||||
if (index >= nSize) return false;
|
||||
if (index >= loSize) return false;
|
||||
if (nSize-index >= hoSize) return false;
|
||||
|
||||
new i;
|
||||
for (i = 0; i < index; i++)
|
||||
{
|
||||
lowOut[i] = number[i];
|
||||
}
|
||||
lowOut[i] = -1;
|
||||
trimBigInt(lowOut);
|
||||
|
||||
for (i = index; i < nSize; i++)
|
||||
{
|
||||
highOut[i-index] = number[i];
|
||||
}
|
||||
highOut[i-index] = -1;
|
||||
trimBigInt(highOut);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
stock bool:isEqualToBigNumber(n1[], n2[])
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
if (n1Size != n2Size) return false;
|
||||
|
||||
for (new i = 0; i < n1Size; i++)
|
||||
{
|
||||
if (n1[i] != n2[i]) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
stock bool:isBiggerThanBigNumber(n1[], n2[])
|
||||
{
|
||||
new n1Size = getBigIntSize(n1);
|
||||
new n2Size = getBigIntSize(n2);
|
||||
if (n1Size > n2Size) return true;
|
||||
if (n1Size < n2Size) return false;
|
||||
|
||||
for (new i = (n1Size-1); i >= 0; i--)
|
||||
{
|
||||
if (n1[i] == n2[i]) continue;
|
||||
else if (n1[i] > n2[i]) return true;
|
||||
else return false;
|
||||
}
|
||||
return false; // In case both numbers are the same
|
||||
}
|
||||
|
||||
stock leftShiftBigInt(number[], digits) // Logical shift
|
||||
{
|
||||
if (digits == 0) return;
|
||||
new nSize = getBigIntSize(number);
|
||||
decl temp[nSize+1];
|
||||
for (new i = 0; i <= nSize; i++) // Creates a backup
|
||||
{
|
||||
temp[i] = number[i];
|
||||
}
|
||||
for (new a = 0; a < digits; a++) // Fills with zeros
|
||||
{
|
||||
number[a] = 0;
|
||||
}
|
||||
for (new i = 0; i <= nSize; i++) // Puts the backup back in
|
||||
{
|
||||
number[i+digits] = temp[i];
|
||||
}
|
||||
trimBigInt(number);
|
||||
}
|
||||
|
||||
stock trimBigInt(number[]) // Removes left padded zeros
|
||||
{
|
||||
new nSize = getBigIntSize(number);
|
||||
for (new zeros = 0; number[nSize-zeros-1] == 0; zeros++)
|
||||
{
|
||||
if (nSize-zeros-1 != 0) number[nSize-zeros-1] = -1;
|
||||
}
|
||||
}
|
||||
|
||||
stock copyBigInt(number[], output[], oSize)
|
||||
{
|
||||
new nSize = getBigIntSize(number);
|
||||
if (oSize <= nSize) return;
|
||||
for (new i = 0; i <= nSize; i++)
|
||||
{
|
||||
output[i] = number[i];
|
||||
}
|
||||
}
|
||||
|
||||
stock getBigIntSize(number[])
|
||||
{
|
||||
new i;
|
||||
for (i = 0; number[i] != -1; i++){}
|
||||
return i;
|
||||
}
|
||||
|
||||
stock toBase256BigInt(number[], output[], oLength)
|
||||
{
|
||||
new nSize = getBigIntSize(number);
|
||||
new finalLength = nSize/2 + (nSize%2);
|
||||
if (oLength < finalLength) return 0;
|
||||
new i;
|
||||
new high, low;
|
||||
|
||||
for (i = 0; i < finalLength; i++)
|
||||
{
|
||||
if ((i == finalLength-1) && nSize%2 == 1)
|
||||
high = 0;
|
||||
else
|
||||
high = number[i*2+1];
|
||||
low = number[i*2];
|
||||
output[finalLength-i-1] = (high << 4) + low;
|
||||
}
|
||||
return finalLength;
|
||||
}
|
||||
|
||||
stock bool:hexString2BigInt(const String:hexString[], output[], oSize)
|
||||
{
|
||||
|
||||
new i;
|
||||
new temp[oSize];
|
||||
for(i = 0; hexString[i] != 0; i++)
|
||||
{
|
||||
if (i >= oSize) return false;
|
||||
temp[i] = hexChar2Int(hexString[i]);
|
||||
|
||||
if (temp[i] == -1) return false;
|
||||
}
|
||||
// Inverts number string
|
||||
for (new u = 0; u < i; u++)
|
||||
{
|
||||
output[u] = temp[i-u-1];
|
||||
}
|
||||
output[i] = -1; // Terminates the number string
|
||||
trimBigInt(output);
|
||||
return true;
|
||||
}
|
||||
|
||||
stock bool:bigInt2HexString(input[], String:hexString[], hsSize)
|
||||
{
|
||||
new nSize = getBigIntSize(input);
|
||||
new i;
|
||||
for (i = 0; i < (hsSize-1); i++)
|
||||
{
|
||||
if (i == nSize) break;
|
||||
if ((hexString[i] = int2HexChar(input[nSize-i-1])) == -1) return false;
|
||||
}
|
||||
hexString[i] = 0;
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
stock hexChar2Int(input)
|
||||
{
|
||||
if(input >= '0' && input <= '9')
|
||||
return input - '0';
|
||||
if(input >= 'A' && input <= 'F')
|
||||
return input - 'A' + 10;
|
||||
if(input >= 'a' && input <= 'f')
|
||||
return input - 'a' + 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
stock int2HexChar(input)
|
||||
{
|
||||
if (input >= 0 && input <= 9)
|
||||
return input + '0';
|
||||
if (input >= 10 && input <= 16)
|
||||
return input + 'A' - 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
test()
|
||||
{
|
||||
// LOTS OF TESTS
|
||||
PrintDebug(caller, "Modulus size: %i", getBigIntSize(modulus));
|
||||
|
||||
/// Addition test
|
||||
new n1[] = {0xC,9,4,9,0xF,0,-1};
|
||||
new n2[] = {0,0x3,5,7,-1};
|
||||
decl String:s1[7];
|
||||
decl String:s2[7];
|
||||
bigInt2HexString(n1, s1, sizeof(s1));
|
||||
bigInt2HexString(n2, s2, sizeof(s2));
|
||||
PrintDebug(caller, "HEX 1 : %s", s1);
|
||||
PrintDebug(caller, "HEX 2 : %s", s2);
|
||||
new a[20];
|
||||
addBigInt(n1, n2, 16, a, sizeof(a));
|
||||
new String:sa[20];
|
||||
bigInt2HexString(a, sa, sizeof(sa));
|
||||
PrintDebug(caller, "HEX 1 + HEX 2 = %s", sa);
|
||||
|
||||
/// Split test
|
||||
new n3[] = {4,6,8,2,5,7,3,4,7,2,-1};
|
||||
new n4[15];
|
||||
new n5[15];
|
||||
splitBigIntAt(n3, 5, n4, sizeof(n4), n5, sizeof(n5));
|
||||
new String:s3[30];
|
||||
new String:s4[15];
|
||||
new String:s5[15];
|
||||
bigInt2HexString(n3, s3, sizeof(s3));
|
||||
bigInt2HexString(n4, s4, sizeof(s4));
|
||||
bigInt2HexString(n5, s5, sizeof(s5));
|
||||
PrintDebug(caller, "%s splitted at index %i", s3, 5);
|
||||
PrintDebug(caller, "Low: %s", s4);
|
||||
PrintDebug(caller, "High: %s", s5);
|
||||
|
||||
/// Subtraction test
|
||||
new n6[] = {3,1,3,5,5,9,6,9,-1};
|
||||
new n7[] = {1,3,5,6,9,6,9,2,-1};
|
||||
decl String:s6[10];
|
||||
decl String:s7[10];
|
||||
bigInt2HexString(n6, s6, sizeof(s6));
|
||||
bigInt2HexString(n7, s7, sizeof(s7));
|
||||
new n8[10];
|
||||
new String:s8[10];
|
||||
subBigInt(n6, n7, 16, n8, sizeof(n8));
|
||||
bigInt2HexString(n8, s8, sizeof(s8));
|
||||
PrintDebug(caller, "Subtracting %s to %s...", s7, s6);
|
||||
PrintDebug(caller, "Result: %s", s8);
|
||||
|
||||
/// Shift test
|
||||
new n9[] = {3,7,9,1,5,7,8,1,-1};
|
||||
decl String:s9[15];
|
||||
bigInt2HexString(n9, s9, sizeof(s9));
|
||||
PrintDebug(caller, "Shifting %s 3 numbers to left", s9);
|
||||
leftShiftBigInt(n9, 3);
|
||||
bigInt2HexString(n9, s9, sizeof(s9));
|
||||
PrintDebug(caller, "Result: %s", s9);
|
||||
|
||||
/// Standard multiplication test
|
||||
new n10[] = {3,1,3,5,5,9,6,9,-1};
|
||||
new n11[] = {1,3,5,6,9,6,9,2,-1};
|
||||
decl String:s10[10];
|
||||
decl String:s11[10];
|
||||
bigInt2HexString(n10, s10, sizeof(s10));
|
||||
bigInt2HexString(n11, s11, sizeof(s11));
|
||||
new n12[30];
|
||||
new String:s12[30];
|
||||
standardMult(n10, n11, 16, n12, sizeof(n12));
|
||||
bigInt2HexString(n12, s12, sizeof(s12));
|
||||
PrintDebug(caller, "Multiplying (standard) %s to %s...", s10, s11);
|
||||
PrintDebug(caller, "Result: %s", s12);
|
||||
|
||||
/// Karatsuba multiplication test
|
||||
new n13[] = {3,1,3,5,5,9,6,9,-1};
|
||||
new n14[] = {1,3,5,6,9,6,9,2,-1};
|
||||
decl String:s13[10];
|
||||
decl String:s14[10];
|
||||
bigInt2HexString(n13, s13, sizeof(s13));
|
||||
bigInt2HexString(n14, s14, sizeof(s14));
|
||||
new n15[30];
|
||||
new String:s15[30];
|
||||
karatsubaMult(n13, n14, 16, n15, sizeof(n15));
|
||||
bigInt2HexString(n15, s15, sizeof(s15));
|
||||
PrintDebug(caller, "Multiplying (karatsuba) %s to %s...", s13, s14);
|
||||
PrintDebug(caller, "Result: %s", s15);
|
||||
|
||||
/// Exponentiation test
|
||||
new n16[] = {3,4,5,6,2,5,-1};
|
||||
new n17[] = {0,1,-1};
|
||||
decl String:s16[20];
|
||||
decl String:s17[20];
|
||||
bigInt2HexString(n16, s16, sizeof(s16));
|
||||
bigInt2HexString(n17, s17, sizeof(s17));
|
||||
new n18[30];
|
||||
new String:s18[30];
|
||||
powBigInt(n16, n17, 16, n18, sizeof(n18));
|
||||
bigInt2HexString(n18, s18, sizeof(s18));
|
||||
PrintDebug(caller, "Exponentiating %s to %s...", s16, s17);
|
||||
PrintDebug(caller, "Result: %s", s18);
|
||||
|
||||
/// Division test
|
||||
new n19[] = {9,0xC,7,2,-1};
|
||||
new n20[] = {6,2,6,-1};
|
||||
decl String:s19[20];
|
||||
decl String:s20[20];
|
||||
bigInt2HexString(n19, s19, sizeof(s19));
|
||||
bigInt2HexString(n20, s20, sizeof(s20));
|
||||
new n21[30];
|
||||
new String:s21[30];
|
||||
new n22[30];
|
||||
new String:s22[30];
|
||||
fulldivBigInt(n19, n20, 16, n21, sizeof(n21), n22, sizeof(n22));
|
||||
bigInt2HexString(n21, s21, sizeof(s21));
|
||||
bigInt2HexString(n22, s22, sizeof(s22));
|
||||
PrintDebug(caller, "Dividing %s to %s...", s19, s20);
|
||||
PrintDebug(caller, "Quotient: %s - Remainder: %s", s21, s22);
|
||||
|
||||
/// PKCS#1 v1.5 Padding Scheme test
|
||||
//decl String:aux[1024] = "BE629EA2D835880BF2572379CC751C5FA44F4A09B6F8CE5CB52C53EEDD0314E77AC827219E78DB1473BBA7BBE8BABC85C02CBC308B75375AE7C4B3AA31A491BB08D1946328F2B1BCE3E07E96D1CFF5E95A553C083A424CD5F6B7F2B55F89B958F0AE3B80A94CF5FEB3BD9417ABD09E1A42456E99128169CCEC176FDF7D2893A5";
|
||||
new k = strlen(hexModulus);
|
||||
new String:paddedMessage[k+1];
|
||||
pkcs1v15Pad(message, k, paddedMessage, k+1);
|
||||
PrintDebug(caller, "Padding message: %s with %i length modulus ", message, k);
|
||||
PrintDebug(caller, "Result: %i - %s", strlen(paddedMessage), paddedMessage);
|
||||
|
||||
/// Modular exponentiation test
|
||||
|
||||
decl n23[1024];
|
||||
decl n24[20];
|
||||
decl n25[1024];
|
||||
hexString2BigInt(paddedMessage, n23, 1024);
|
||||
hexString2BigInt(hexExponent, n24, 20);
|
||||
hexString2BigInt(hexModulus, n25, 1024);
|
||||
|
||||
//new n23[] = {3,2,-1};
|
||||
//new n24[] = {5,-1};
|
||||
//new n25[] = {6,2,6,-1};
|
||||
new String:s23[1024];
|
||||
new String:s24[40];
|
||||
new String:s25[1024];
|
||||
new n26[1024];
|
||||
new String:s26[1024];
|
||||
modpowBigInt(n23, n24, n25, 16, n26, sizeof(n26));
|
||||
bigInt2HexString(n23, s23, sizeof(s23));
|
||||
bigInt2HexString(n24, s24, sizeof(s24));
|
||||
bigInt2HexString(n25, s25, sizeof(s25));
|
||||
bigInt2HexString(n26, s26, sizeof(s26));
|
||||
PrintDebug(caller, "Modular Power Test");
|
||||
PrintDebug(caller, "base = %s", s23);
|
||||
PrintDebug(caller, "exponent = %s", s24);
|
||||
PrintDebug(caller, "modulus = %s", s25);
|
||||
PrintDebug(caller, "Result size: %i, result = \n%s", getBigIntSize(n26), s26);
|
||||
}
|
||||
*/
|
||||
@@ -0,0 +1,115 @@
|
||||
/***
|
||||
rsa.inc - RSA Encrypting Algorithms Library Functions
|
||||
|
||||
Version: 0.1
|
||||
Date: 28-03-2015
|
||||
Author: Statik
|
||||
|
||||
Provides RSA PKCS #1 v1.5 encrypting functions.
|
||||
|
||||
**UNFINISHED**
|
||||
|
||||
***/
|
||||
|
||||
#if defined _RSA_included
|
||||
#endinput
|
||||
#endif
|
||||
|
||||
#define _RSA_included
|
||||
|
||||
rsaEncrypt(const String:hexModulus[], const String:hexExponent[], const String:message[], String:ciphertext[], ctSize)
|
||||
{
|
||||
decl modulus[1024];
|
||||
decl exponent[16];
|
||||
|
||||
if (!hexString2BigInt(hexModulus, modulus, sizeof(modulus)))
|
||||
{
|
||||
PrintDebug(GetCaller(), "Error encrypting passphrase: Invalid modulus.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!hexString2BigInt(hexExponent, exponent, sizeof(exponent)))
|
||||
{
|
||||
PrintDebug(GetCaller(), "Error encrypting passphrase: Invalid exponent.");
|
||||
return;
|
||||
}
|
||||
|
||||
new k = strlen(hexModulus);
|
||||
new mSize = k + 1;
|
||||
if (ctSize < mSize)
|
||||
{
|
||||
PrintDebug(GetCaller(), "Error encrypting passphrase: ciphertext size is can't be smaller than modulus size");
|
||||
|
||||
}
|
||||
decl String:paddedMessage[mSize];
|
||||
pkcs1v15Pad(message, k, paddedMessage, mSize);
|
||||
PrintDebug(GetCaller(), "Padded message with PKCS#1 v1.5 standard (%i): \n%s", strlen(paddedMessage), paddedMessage);
|
||||
|
||||
decl numericMessage[mSize];
|
||||
hexString2BigInt(paddedMessage, numericMessage, mSize);
|
||||
|
||||
decl encryptedMessage[mSize];
|
||||
modpowBigInt(numericMessage, exponent, modulus, 16, encryptedMessage, mSize);
|
||||
bigInt2HexString(encryptedMessage, ciphertext, ctSize);
|
||||
}
|
||||
|
||||
pkcs1v15Pad(const String:data[], k, String:message[], maxSize) // Message must be even
|
||||
{
|
||||
new dSize = strlen(data);
|
||||
new psSize = k - (dSize*2) - 6; // Padding string Size
|
||||
decl String:ps[psSize+1]; // Padding string / 1 more to add the string delimiter
|
||||
decl String:ds[(dSize*2)+1]; // Data string
|
||||
new i;
|
||||
for (i = 0; i < psSize; i++)
|
||||
{
|
||||
if ((i % 2) == 0) ps[i] = int2HexChar(GetRandomInt(1,15));
|
||||
else ps[i] = int2HexChar(GetRandomInt(0,15));
|
||||
}
|
||||
ps[i] = 0;
|
||||
for (i = 0; i < dSize; i++)
|
||||
{
|
||||
ds[i*2] = int2HexChar(data[i] / 16); // High nibble
|
||||
ds[i*2+1] = int2HexChar(data[i] % 16); // Low nibble
|
||||
}
|
||||
ds[i*2] = 0;
|
||||
|
||||
Format(message, maxSize, "0002%s00%s", ps, ds);
|
||||
}
|
||||
|
||||
encodeBase64(input[], paddingSize, String:output[], oSize)
|
||||
{
|
||||
static const String:base64Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
new iSize = getBigIntSize(input);
|
||||
if (paddingSize < iSize) return 0;
|
||||
new zeros = paddingSize - iSize;
|
||||
for (new e = 0; e < zeros; e++) { input[iSize++] = 0; }
|
||||
new finalSize = (iSize / 6) * 4;
|
||||
if (oSize < finalSize) return 0;
|
||||
|
||||
new bitString = 0, u = 0, i;
|
||||
for (i = iSize-1; i >= 0; i-=3)
|
||||
{
|
||||
if (i == 1)
|
||||
{
|
||||
if (((iSize/3)%2) == 1) bitString = (input[i--] << 8) + (input[i--]);
|
||||
else bitString = (input[i--] << 8) + (input[i--] << 4);
|
||||
}
|
||||
else if (i == 0)
|
||||
{
|
||||
if (((iSize/3)%2) == 1) bitString = input[i--] << 8;
|
||||
else bitString = input[i--] << 4;
|
||||
}
|
||||
else bitString = (input[i] << 8) + (input[i-1] << 4) + (input[i-2]);
|
||||
|
||||
output[u++] = base64Table[(bitString & 0b111111_000000)>>6];
|
||||
output[u++] = base64Table[bitString & 0b000000_111111];
|
||||
}
|
||||
|
||||
for (new a = 0; a < (u%4); a++)
|
||||
{
|
||||
output[u++] = '=';
|
||||
}
|
||||
output[u++] = 0;
|
||||
return u;
|
||||
}
|
||||
Reference in New Issue
Block a user