Skip to content

Instantly share code, notes, and snippets.

@dilworks

dilworks/rdbruteforcekeygen.c

Last active August 30, 2018 17:41
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save dilworks/a3aca66d6d613da455466aec4ae75f49 to your computer and use it in GitHub Desktop.
Save dilworks/a3aca66d6d613da455466aec4ae75f49 to your computer and use it in GitHub Desktop.
Download ZIP
Brute Force RegKey for RichDiamond [modified for GCC/Linux]
Raw
rdbruteforcekeygen.c
// Brute Force RegKey for RichDiamond
// change VERSIONKEY to your generated VersionKey
// Linux: gcc -std=gnu99 -O3 -fopenmp -march=native -o rdbruteforcekeygen rdbruteforcekeygen.c
// Windows: test with VC++2008/2010?
#define VERSIONKEY 0xCE9190D8;
#include <stdio.h>
#ifdef _MSC_VER
#include <windows.h>
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
typedef int bool;
#define false 0
#define true 1
#else
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
#endif
#include <omp.h>
// ' ' '-' -> block seperators-->ignored
// base 24 without vowels
static const char Base24Array[24] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'B', 'C', 'D', 'F', 'G', 'H',
'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R'
};
static const uint8_t ConversionTable[5][24] = {
{0xFF, 0x0C, 0xFF, 0xFF, 0x02, 0x09, 0x0D, 0xFF,
0x01, 0x05, 0x07, 0x04, 0x0B, 0x03, 0x06, 0x0F,
0xFF, 0x00, 0x0E, 0xFF, 0xFF, 0xFF, 0x0A, 0x08},
{0x04, 0xFF, 0x03, 0x0A, 0x02, 0x07, 0xFF, 0x00,
0xFF, 0xFF, 0x0C, 0x0D, 0x0E, 0x01, 0x0F, 0x08,
0x09, 0x05, 0x0B, 0xFF, 0xFF, 0x06, 0xFF, 0xFF},
{0x01, 0x08, 0xFF, 0x0C, 0x07, 0xFF, 0x02, 0x03,
0x0B, 0x06, 0x0F, 0x09, 0x0A, 0x0E, 0xFF, 0xFF,
0xFF, 0xFF, 0x04, 0xFF, 0x00, 0x0D, 0x05, 0xFF},
{0xFF, 0x0D, 0x06, 0x09, 0x02, 0xFF, 0x05, 0x0C,
0x0A, 0x01, 0xFF, 0xFF, 0x0B, 0xFF, 0xFF, 0x04,
0x0F, 0xFF, 0x07, 0x08, 0x0E, 0xFF, 0x03, 0x00},
{0x0C, 0x04, 0xFF, 0x09, 0x07, 0x06, 0xFF, 0xFF,
0xFF, 0x0D, 0x0E, 0xFF, 0x02, 0xFF, 0xFF, 0x03,
0x05, 0x0A, 0x00, 0x08, 0x0F, 0x0B, 0xFF, 0x01}
};
static const uint8_t ArraySelectors[5][24] = {
{0xFF, 0x01, 0xFF, 0xFF, 0x02, 0x04, 0x01, 0xFF,
0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x00,
0xFF, 0x00, 0x02, 0xFF, 0xFF, 0xFF, 0x04, 0x04},
{0x02, 0xFF, 0x00, 0x02, 0x03, 0x02, 0xFF, 0x03,
0xFF, 0xFF, 0x03, 0x04, 0x02, 0x02, 0x02, 0x01,
0x03, 0x04, 0x04, 0xFF, 0xFF, 0x03, 0xFF, 0xFF},
{0x02, 0x04, 0xFF, 0x03, 0x01, 0xFF, 0x01, 0x00,
0x02, 0x03, 0x04, 0x03, 0x01, 0x03, 0xFF, 0xFF,
0xFF, 0xFF, 0x01, 0xFF, 0x01, 0x04, 0x01, 0xFF},
{0xFF, 0x01, 0x01, 0x04, 0x00, 0xFF, 0x03, 0x00,
0x04, 0x00, 0xFF, 0xFF, 0x02, 0xFF, 0xFF, 0x04,
0x00, 0xFF, 0x00, 0x02, 0x03, 0xFF, 0x04, 0x02},
{0x00, 0x02, 0xFF, 0x03, 0x04, 0x03, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0xFF, 0x02, 0xFF, 0xFF, 0x03,
0x00, 0x01, 0x04, 0x03, 0x01, 0x04, 0xFF, 0x03}
};
static const char * ConvertToAuthCode(uint64_t Value) {
static char AuthCode[17];
int i, j;
unsigned ArraySelector = 0;
while(Value && !(Value>>60) ) {
Value<<=4;
}
for(i=0; Value; i++) {
for(j=0; j<24; j++) {
if(ConversionTable[ArraySelector][j] == (Value>>60)) {
AuthCode[i] = Base24Array[j];
ArraySelector = ArraySelectors[ArraySelector][j];
break;
}
}
Value<<=4;
}
AuthCode[i] = 0;
return AuthCode;
}
static const uint8_t SomeByteArray1[2][8] = {
{0x07, 0x0B, 0x0D, 0x11, 0x16, 0x10, 0x0E, 0x18},
{0x07, 0x0D, 0x14, 0x18, 0x14, 0x10, 0x07, 0x0B}
};
static const uint8_t SomeByteArray2[2][8] = {
{0x10, 0x0E, 0x16, 0x14, 0x18, 0x07, 0x11, 0x0B},
{0x10, 0x18, 0x07, 0x0D, 0x0B, 0x11, 0x11, 0x0E}
};
static const uint8_t SomeByteArray3[2][8] = {
{0x11, 0x14, 0x0B, 0x0D, 0x0E, 0x16, 0x18, 0x07},
{0x11, 0x10, 0x0B, 0x11, 0x0D, 0x18, 0x16, 0x07}
};
static const uint8_t SomeByteArray4[2][8] = {
{0x14, 0x0D, 0x0E, 0x18, 0x07, 0x0B, 0x10, 0x11},
{0x14, 0x16, 0x11, 0x0E, 0x16, 0x0B, 0x10, 0x18}
};
static const uint8_t SomeByteArray5[8] = {
0x09, 0x17, 0x06, 0x19, 0x15, 0x17, 0x19, 0x09
};
static const uint8_t SomeByteArray6[8] = {
0x00, 0x0D, 0x0D, 0x08, 0x01, 0x04, 0x07, 0x07
};
static const uint8_t SomeByteArray7[8] = {
0x04, 0x01, 0x00, 0x07, 0x0D, 0x08, 0x00, 0x04
};
static const uint32_t KeyValues[23] = {
// key for main program
0x436F7265,
// keys for single levels
0x76951662, //106
0x4721E265, //108
0x579BF236, //109
0x98599C6D, //110
0x6BD8F0B9, //111
0xBF6569E8, //112
0xE1331E2A, //113
0x4D02B694, //114
0xB807175C, //115
0xDC61F92B, //116
0xFB64CC1D, //117
0x5DB192C8, //118
0x484DDFB4, //119
0x455702CA, //121
0x73527E14, //122
0xDDB10EDE, //126
0x64DE7EE8, //124
0x28B93B85, //106
// multi-level keys, missing: 117, 124, 126
0xEBDAD7F1, // (106, 108, 109, 110, 111)
0x21033974, // (106, 108, 109, 110, 111)
0x5391E536, // (112, 113, 114, 115, 116)
0xC7C23136 // (118, 119, 121, 122)
//0xFB64CC1D, 0x64DE7EE8, 0xDDB10EDE, 0xEBDAD7F1, 0x5391E536, 0xC7C23136
};
static inline bool HasOddNumberOfBits(uint32_t x) {
#if 1
return __builtin_parity(x);
#else
x = x ^ (x >> 16);
x = x ^ (x >> 8);
x = x ^ (x >> 4);
x = x ^ (x >> 2);
return ((x >> 1) & 1) ^ (x & 1);
#endif
}
static inline uint32_t NumberOfBits(uint32_t x) {
#if 1
return __builtin_popcount(x);
#else
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
x = (x + (x >> 4)) & 0x0F0F0F0F;
x = x + (x >> 8);
x = x + (x >> 16);
return x & 0x0000003F;
#endif
}
/*
isValid: 1, Time: 18323.544884 seconds, iAuthCode: 129646A25C, iAuthCode2: 12964549, Value1: 9646A25C Value2: 12 Progress: 7.260553%
isValid: 0, Time: 44753.829474 seconds, iAuthCode: 2AFFFDFBCF, iAuthCode2: 2AFFFFFF, Value1: FFFDFBCF Value2: 2A Progress: 16.796863%
0x52
*/
int main() {
uint64_t iValue2, secondsTotal;
uint32_t VersionKey;
uint32_t hours, minutes, seconds;
uint64_t start, end;
#ifdef _MSC_VER
LARGE_INTEGER li1, li2;
double PCFreq = 0.0;
__int64 CounterStart;
QueryPerformanceFrequency(&li1);
PCFreq = (double)li1.QuadPart/1000.0;
QueryPerformanceCounter(&li1);
CounterStart = li1.QuadPart;
#else
struct timespec li1, li2;
int64_t CounterStart;
clock_gettime(CLOCK_MONOTONIC, &li1);
CounterStart = li1.tv_sec + (li1.tv_nsec / 1E9);
#endif
VersionKey = VERSIONKEY;
iValue2=0;
start = 0;
end = 0x8000000000;
//start = 0;
//end = 281474976710656ULL; // 48-bit
#pragma omp parallel for private(li2, iValue2)
for(uint64_t iValue=start; iValue<end; iValue++) {
bool isValid;
uint8_t array3[16];
uint32_t dArray[29];
uint32_t ValueVersionKey, bv1, bv2;
uint32_t dv1, dv2, dv3, dv4, dv5;
uint64_t Value = iValue;
//i == 0x3F && HasOddNumberOfBits(Value1 & 0xFFFF0000)
if (
!!(Value&0x8)^
!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x200000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x80000000000)^
!!(Value&0x200000000000)^!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1) ^ HasOddNumberOfBits(Value2))
if(
/*
!!(Value&0x4)^!!(Value&0x8)^
!!(Value&0x10)^!!(Value&0x20)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x4000000)^!!(Value&0x8000000)^
*/
/*
!!(Value&0x8)^
!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x200000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x80000000000)^
!!(Value&0x200000000000)^!!(Value&0x800000000000)^
*/
!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x800000)^
!!(Value&0x2000000)^!!(Value&0x8000000)^
!!(Value&0x20000000)^!!(Value&0x80000000)^
!!(Value&0x400000000)^
!!(Value&0x2000000000)
)
continue;
//i == 0x3F && HasOddNumberOfBits(Value2)
if(
!!(Value&0x4)^!!(Value&0x8)^
!!(Value&0x10)^!!(Value&0x20)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x4000000)^!!(Value&0x8000000)
)
continue;
//i == 0x3F && (Value1 & 0x2000)
if(
!!(Value&0x1)^!!(Value&0x8)^
!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x100)^!!(Value&0x200)^!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x10000)^!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x200000)^!!(Value&0x400000)^!!(Value&0x800000)^
!!(Value&0x1000000)^!!(Value&0x2000000)^!!(Value&0x4000000)^!!(Value&0x8000000)^
!!(Value&0x10000000)^!!(Value&0x20000000)^!!(Value&0x80000000)^
!!(Value&0x100000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xAAAAAAAA) ^ HasOddNumberOfBits(Value2 & 0xAAAA))
if(
!!(Value&0x1)^
!!(Value&0x10)^!!(Value&0x80)^
!!(Value&0x800)^
!!(Value&0x8000)^
!!(Value&0x40000)^
!!(Value&0x100000)^!!(Value&0x400000)^!!(Value&0x800000)^
!!(Value&0x4000000)^
!!(Value&0x40000000)^!!(Value&0x80000000)^
!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x4000000000)^!!(Value&0x8000000000)^
!!(Value&0x40000000000)^!!(Value&0x80000000000)^
!!(Value&0x400000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xCCCCCCCC) ^ HasOddNumberOfBits(Value2 & 0xCCCC))
if(
!!(Value&0x1)^!!(Value&0x2)^!!(Value&0x4)^
!!(Value&0x10)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x800000)^
!!(Value&0x8000000)^
!!(Value&0x10000000)^!!(Value&0x20000000)^!!(Value&0x40000000)^
!!(Value&0x100000000)^!!(Value&0x200000000)^!!(Value&0x400000000)^
!!(Value&0x1000000000)^!!(Value&0x2000000000)^!!(Value&0x4000000000)^
!!(Value&0x10000000000)^!!(Value&0x20000000000)^!!(Value&0x40000000000)^
!!(Value&0x100000000000)^!!(Value&0x200000000000)^!!(Value&0x400000000000)^!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xF0F0F0F0) ^ HasOddNumberOfBits(Value2 & 0xF0F0))
if(
!!(Value&0x1)^!!(Value&0x4)^
!!(Value&0x20)^
!!(Value&0x100)^!!(Value&0x200)^!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x1000)^!!(Value&0x2000)^
!!(Value&0x10000)^!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^
!!(Value&0x2000000)^!!(Value&0x8000000)^
!!(Value&0x40000000)^!!(Value&0x80000000)^
!!(Value&0x200000000)^!!(Value&0x400000000)^
!!(Value&0x4000000000)^!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x40000000000)^
!!(Value&0x400000000000)
)
continue;
//i == 0x3F && HasOddNumberOfBits(Value1 & 0xFF00FF00) == HasOddNumberOfBits(Value2 & 0xFF00)
if(
!!(Value&0x8)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x2000000)^
!!(Value&0x80000000)^
!!(Value&0x400000000)^
!!(Value&0x2000000000)^
!!(Value&0x20000000000)^!!(Value&0x40000000000)^!!(Value&0x80000000000)^
!!(Value&0x800000000000)
)
continue;
for(int i=0; i<0x60; i++) {
uint64_t tmp = !!(Value&0x01)^!!(Value&0x02)^!!(Value&0x08)^!!(Value&0x10)^!!(Value&0x40)^!!(Value&0x800000000000);
Value = (Value >> 1) | (tmp << 47);
uint32_t Value1 = Value & 0xFFFFFFFF;
uint32_t Value2 = (Value >> 32) & 0xFFFF;
switch(i) {
case 0x0F:
array3[0x06] = (Value1 >> 12) & 3;
array3[0x07] = ((Value1 >> 19) & 1) | ((Value1 >> 2) & 2);
array3[0x09] = (Value1 >> 7) & 3;
array3[0x0C] = (Value1 >> 15) & 3;
dArray[0x05] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x1F:
array3[0x05] = Value1 & 3;
array3[0x08] = ((Value1 >> 17) & 1) | ((Value1 >> 15) & 2);
array3[0x02] = (Value1 >> 10) & 3;
array3[0x01] = (Value1 >> 21) & 3;
dArray[0x1B] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x2F:
array3[0x0A] = (Value1 >> 12) & 3;
array3[0x0D] = ((Value1 >> 1) & 1) | ((Value1 >> 9) & 2);
array3[0x04] = Value1 & 3;
array3[0x00] = (Value1 >> 17) & 3;
dArray[0x1C] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x3F:
array3[0x08] = (Value1 >> 6) & 3;
array3[0x07] = ((Value1 >> 4) & 2) | ((Value1 >> 3) & 1);
array3[0x09] = (Value1 >> 11) & 3;
array3[0x0A] = (Value1 >> 9) & 3;
dArray[0x1B] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x4F:
array3[0x00] = (Value1 >> 5) & 3;
array3[0x04] = ((Value1 >> 19) & 2) | ((Value1 >> 11) & 1);
array3[0x02] = (Value1 >> 2) & 3;
array3[0x06] = (Value1 >> 12) & 3;
dArray[0x05] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x5F:
array3[0x05] = (Value1 >> 18) & 3;
array3[0x01] = ((Value1 >> 8) & 2) | ((Value1 >> 6) & 1);
array3[0x0D] = (Value1 >> 22) & 3;
array3[0x0C] = (Value1 >> 3) & 3;
dArray[0x13] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
}
}
bv1 = isValid = 0;
dv1 = dv2 = dv3 = dv4 = 0;
iValue2++;
dArray[0x06] = 0x80200401;
dArray[0x17] = 0x84010011;
dArray[0x19] = 0x81000802;
dArray[0x15] = 0x90001004;
dArray[0x09] = 0x80080202;
for(int i=0, ArraySelector=0; i<13; i++, ArraySelector = !!(bv2&0x08) != !!(bv2&0x10)) {
if(i<8) {
ValueVersionKey = VersionKey;
dv1 = dArray[SomeByteArray1[ArraySelector][i]];
dv2 = dArray[SomeByteArray2[ArraySelector][i]];
dv3 = dArray[SomeByteArray3[ArraySelector][i]];
dv4 = dArray[SomeByteArray4[ArraySelector][i]];
dv5 = dArray[SomeByteArray5[i]];
bv1 = array3[SomeByteArray6[i]];
bv2 = array3[SomeByteArray7[i]];
} else {
switch(i) {
case 8:
ValueVersionKey = dArray[0x1C] ^ dArray[0x07];
dv5 = 0x80200401;
bv1 = array3[0x0C];
bv2 = array3[0x02];
break;
case 9:
ValueVersionKey = dArray[0x1B] ^ dArray[0x14];
dv5 = 0x80040003;
bv1 = array3[0x09];
bv2 = array3[0x0A];
break;
case 10:
ValueVersionKey = dArray[0x05] ^ dArray[0x18];
dv5 = 0x80040003;
bv1 = array3[0x06];
bv2 = array3[0x05];
break;
case 11:
ValueVersionKey = dArray[0x13] ^ dArray[0x16];
dv5 = 0x80200401;
bv1 = array3[0x0C];
bv2 = array3[0x02];
break;
case 12:
ValueVersionKey = dArray[0x1B] ^ dArray[0x0D];
dv5 = 0x80040003;
bv1 = array3[0x09];
bv2 = array3[0x0A];
break;
default: break;
}
}
bv2 &= 3;
for(int j=0; j<0x40; j++) {
if(j==0x20) {
if(bv1!=(bv2&7)) {
bv2^=0x18;
}
}
else if(j==0x30) {
if(bv1<(bv2&3)) {
bv2 ^= 0x08;
} else if (bv1>(bv2&7)) {
bv2 ^= 0x10;
}
}
uint8_t cl = bv1 + NumberOfBits(dv5&ValueVersionKey);
ValueVersionKey = (ValueVersionKey >> 1) | (cl << 31);
bv1 = (cl >> 1);
if(j==0x07||j==0x1f||j==0x3a) {
dv1 = ValueVersionKey;
}
if(j==0x17||j==0x23||j==0x2f) {
dv2 = ValueVersionKey;
}
if(j==0x10||j==0x35||j==0x1A) {
dv3 = ValueVersionKey;
}
if(j==0x29||j==0x16||j==0x2d) {
dv4 = ValueVersionKey;
}
if(j==0x33||j==0x3e) {
dv5 = ValueVersionKey;
}
if(j==0x37||j==0x38) {
if(bv1==(bv2&3)) {
bv2^=0x58;
}
}
}
if(i<8) {
dArray[SomeByteArray1[ArraySelector][i]] = dv1;
dArray[SomeByteArray2[ArraySelector][i]] = dv2;
dArray[SomeByteArray3[ArraySelector][i]] = dv3;
dArray[SomeByteArray4[ArraySelector][i]] = dv4;
dArray[SomeByteArray5[i]] = dv5;
array3[SomeByteArray7[i]] = bv2;
} else {
switch(i) {
case 8:
//printf("%X\n", dv3);
for(int l=0; l<1/*23*/; l++) {
if(dv3 == KeyValues[l]) {
printf("Found Key @0: %u %X\n", l, KeyValues[l]);
//isValid = 1; // TODO: only works in RDLevSet.exe
}
}
break;
case 10:
//printf("%X\n", dv4);
for(int l=0; l<1/*23*/; l++) {
if(dv4 == KeyValues[l]) {
printf("Found Key @2: %u %X\n", l, KeyValues[l]);
//isValid = 1; // TODO: only works in RDLevSet.exe
}
}
break;
case 11:
//printf("%X\n", dv1);
for(int l=0; l<1/*23*/; l++) {
if(dv1 == KeyValues[l]) {
printf("Found Key @3: %u %X\n", l, KeyValues[l]);
isValid = 1;
}
}
break;
case 9:
case 12:
//printf("%X\n", dv2);
for(int l=0; l<1/*23*/; l++) {
if(dv2 == KeyValues[l]) {
printf("Found Key @1/4: %u %X\n", l, KeyValues[l]);
isValid = 1;
}
}
break;
}
}
}
if(isValid || ((iValue2&0xFFFFFF) == 0xFFFFFF)) {
/*for(int k=0; k<29; k++) {
if(dArray[k]) printf("%02X: %08X\n", k, dArray[k]);
}*/
#ifdef _MSC_VER
QueryPerformanceCounter(&li2);
secondsTotal = (li2.QuadPart-CounterStart)/PCFreq/1000;
#else
clock_gettime(CLOCK_MONOTONIC, &li2);
secondsTotal = (li2.tv_sec + li2.tv_nsec / 1E9) - CounterStart;
#endif
hours = (secondsTotal/60)/60;
minutes = (secondsTotal/60)%60;
seconds = secondsTotal%60;
printf("isValid: %u, AuthCode: %s, iValue2: %I64X, Value1: %I64X, Value2: %I64X, %u:%02u:%02u hours, Progress: %lf\n", isValid, ConvertToAuthCode(iValue), iValue2, iValue&0xFFFFFFFF, iValue>>32, hours, minutes, seconds, 100*(double)(iValue - start)/(end - start));
//printf("0: %X %X %X %X %X\n", dv3, dv2, dv4, dv1, dv2);
}
}
#ifdef _MSC_VER
QueryPerformanceCounter(&li2);
secondsTotal = (li2.QuadPart-CounterStart)/PCFreq/1000;
#else
clock_gettime(CLOCK_MONOTONIC, &li2);
secondsTotal = (li2.tv_sec + li2.tv_nsec / 1E9) - CounterStart;
#endif
hours = (secondsTotal/60)/60;
minutes = (secondsTotal/60)%60;
seconds = secondsTotal%60;
printf("Finished in %u:%02u:%02u hours\n", hours, minutes, seconds);
return 0;
}
'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R'
};
static const uint8_t ConversionTable[5][24] = {
{0xFF, 0x0C, 0xFF, 0xFF, 0x02, 0x09, 0x0D, 0xFF,
0x01, 0x05, 0x07, 0x04, 0x0B, 0x03, 0x06, 0x0F,
0xFF, 0x00, 0x0E, 0xFF, 0xFF, 0xFF, 0x0A, 0x08},
{0x04, 0xFF, 0x03, 0x0A, 0x02, 0x07, 0xFF, 0x00,
0xFF, 0xFF, 0x0C, 0x0D, 0x0E, 0x01, 0x0F, 0x08,
0x09, 0x05, 0x0B, 0xFF, 0xFF, 0x06, 0xFF, 0xFF},
{0x01, 0x08, 0xFF, 0x0C, 0x07, 0xFF, 0x02, 0x03,
0x0B, 0x06, 0x0F, 0x09, 0x0A, 0x0E, 0xFF, 0xFF,
0xFF, 0xFF, 0x04, 0xFF, 0x00, 0x0D, 0x05, 0xFF},
{0xFF, 0x0D, 0x06, 0x09, 0x02, 0xFF, 0x05, 0x0C,
0x0A, 0x01, 0xFF, 0xFF, 0x0B, 0xFF, 0xFF, 0x04,
0x0F, 0xFF, 0x07, 0x08, 0x0E, 0xFF, 0x03, 0x00},
{0x0C, 0x04, 0xFF, 0x09, 0x07, 0x06, 0xFF, 0xFF,
0xFF, 0x0D, 0x0E, 0xFF, 0x02, 0xFF, 0xFF, 0x03,
0x05, 0x0A, 0x00, 0x08, 0x0F, 0x0B, 0xFF, 0x01}
};
static const uint8_t ArraySelectors[5][24] = {
{0xFF, 0x01, 0xFF, 0xFF, 0x02, 0x04, 0x01, 0xFF,
0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x00,
0xFF, 0x00, 0x02, 0xFF, 0xFF, 0xFF, 0x04, 0x04},
{0x02, 0xFF, 0x00, 0x02, 0x03, 0x02, 0xFF, 0x03,
0xFF, 0xFF, 0x03, 0x04, 0x02, 0x02, 0x02, 0x01,
0x03, 0x04, 0x04, 0xFF, 0xFF, 0x03, 0xFF, 0xFF},
{0x02, 0x04, 0xFF, 0x03, 0x01, 0xFF, 0x01, 0x00,
0x02, 0x03, 0x04, 0x03, 0x01, 0x03, 0xFF, 0xFF,
0xFF, 0xFF, 0x01, 0xFF, 0x01, 0x04, 0x01, 0xFF},
{0xFF, 0x01, 0x01, 0x04, 0x00, 0xFF, 0x03, 0x00,
0x04, 0x00, 0xFF, 0xFF, 0x02, 0xFF, 0xFF, 0x04,
0x00, 0xFF, 0x00, 0x02, 0x03, 0xFF, 0x04, 0x02},
{0x00, 0x02, 0xFF, 0x03, 0x04, 0x03, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0xFF, 0x02, 0xFF, 0xFF, 0x03,
0x00, 0x01, 0x04, 0x03, 0x01, 0x04, 0xFF, 0x03}
};
static const char * ConvertToAuthCode(uint64_t Value) {
static char AuthCode[17];
int i, j;
unsigned ArraySelector = 0;
while(Value && !(Value>>60) ) {
Value<<=4;
}
for(i=0; Value; i++) {
for(j=0; j<24; j++) {
if(ConversionTable[ArraySelector][j] == (Value>>60)) {
AuthCode[i] = Base24Array[j];
ArraySelector = ArraySelectors[ArraySelector][j];
break;
}
}
Value<<=4;
}
AuthCode[i] = 0;
return AuthCode;
}
static const uint8_t SomeByteArray1[2][8] = {
{0x07, 0x0B, 0x0D, 0x11, 0x16, 0x10, 0x0E, 0x18},
{0x07, 0x0D, 0x14, 0x18, 0x14, 0x10, 0x07, 0x0B}
};
static const uint8_t SomeByteArray2[2][8] = {
{0x10, 0x0E, 0x16, 0x14, 0x18, 0x07, 0x11, 0x0B},
{0x10, 0x18, 0x07, 0x0D, 0x0B, 0x11, 0x11, 0x0E}
};
static const uint8_t SomeByteArray3[2][8] = {
{0x11, 0x14, 0x0B, 0x0D, 0x0E, 0x16, 0x18, 0x07},
{0x11, 0x10, 0x0B, 0x11, 0x0D, 0x18, 0x16, 0x07}
};
static const uint8_t SomeByteArray4[2][8] = {
{0x14, 0x0D, 0x0E, 0x18, 0x07, 0x0B, 0x10, 0x11},
{0x14, 0x16, 0x11, 0x0E, 0x16, 0x0B, 0x10, 0x18}
};
static const uint8_t SomeByteArray5[8] = {
0x09, 0x17, 0x06, 0x19, 0x15, 0x17, 0x19, 0x09
};
static const uint8_t SomeByteArray6[8] = {
0x00, 0x0D, 0x0D, 0x08, 0x01, 0x04, 0x07, 0x07
};
static const uint8_t SomeByteArray7[8] = {
0x04, 0x01, 0x00, 0x07, 0x0D, 0x08, 0x00, 0x04
};
static const uint32_t KeyValues[23] = {
// key for main program
0x436F7265,
// keys for single levels
0x76951662, //106
0x4721E265, //108
0x579BF236, //109
0x98599C6D, //110
0x6BD8F0B9, //111
0xBF6569E8, //112
0xE1331E2A, //113
0x4D02B694, //114
0xB807175C, //115
0xDC61F92B, //116
0xFB64CC1D, //117
0x5DB192C8, //118
0x484DDFB4, //119
0x455702CA, //121
0x73527E14, //122
0xDDB10EDE, //126
0x64DE7EE8, //124
0x28B93B85, //106
// multi-level keys, missing: 117, 124, 126
0xEBDAD7F1, // (106, 108, 109, 110, 111)
0x21033974, // (106, 108, 109, 110, 111)
0x5391E536, // (112, 113, 114, 115, 116)
0xC7C23136 // (118, 119, 121, 122)
//0xFB64CC1D, 0x64DE7EE8, 0xDDB10EDE, 0xEBDAD7F1, 0x5391E536, 0xC7C23136
};
static inline bool HasOddNumberOfBits(uint32_t x) {
#if 1
return __builtin_parity(x);
#else
x = x ^ (x >> 16);
x = x ^ (x >> 8);
x = x ^ (x >> 4);
x = x ^ (x >> 2);
return ((x >> 1) & 1) ^ (x & 1);
#endif
}
static inline uint32_t NumberOfBits(uint32_t x) {
#if 1
return __builtin_popcount(x);
#else
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
x = (x + (x >> 4)) & 0x0F0F0F0F;
x = x + (x >> 8);
x = x + (x >> 16);
return x & 0x0000003F;
#endif
}
/*
isValid: 1, Time: 18323.544884 seconds, iAuthCode: 129646A25C, iAuthCode2: 12964549, Value1: 9646A25C Value2: 12 Progress: 7.260553%
isValid: 0, Time: 44753.829474 seconds, iAuthCode: 2AFFFDFBCF, iAuthCode2: 2AFFFFFF, Value1: FFFDFBCF Value2: 2A Progress: 16.796863%
0x52
*/
int main() {
uint64_t iValue2, secondsTotal;
uint32_t VersionKey;
uint32_t hours, minutes, seconds;
uint64_t start, end;
#ifdef _MSC_VER
LARGE_INTEGER li1, li2;
double PCFreq = 0.0;
__int64 CounterStart;
QueryPerformanceFrequency(&li1);
PCFreq = (double)li1.QuadPart/1000.0;
QueryPerformanceCounter(&li1);
CounterStart = li1.QuadPart;
#else
struct timespec li1, li2;
int64_t CounterStart;
clock_gettime(CLOCK_MONOTONIC, &li1);
CounterStart = li1.tv_sec + (li1.tv_nsec / 1E9);
#endif
VersionKey = 0xCE9190D8; //0x72C53A70; // Is sometimes changed if debugged
iValue2=0;
start = 0;
end = 0x8000000000;
//start = 0;
//end = 281474976710656ULL; // 48-bit
#pragma omp parallel for private(li2, iValue2)
for(uint64_t iValue=start; iValue<end; iValue++) {
bool isValid;
uint8_t array3[16];
uint32_t dArray[29];
uint32_t ValueVersionKey, bv1, bv2;
uint32_t dv1, dv2, dv3, dv4, dv5;
uint64_t Value = iValue;
//i == 0x3F && HasOddNumberOfBits(Value1 & 0xFFFF0000)
if (
!!(Value&0x8)^
!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x200000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x80000000000)^
!!(Value&0x200000000000)^!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1) ^ HasOddNumberOfBits(Value2))
if(
/*
!!(Value&0x4)^!!(Value&0x8)^
!!(Value&0x10)^!!(Value&0x20)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x4000000)^!!(Value&0x8000000)^
*/
/*
!!(Value&0x8)^
!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x200000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x80000000000)^
!!(Value&0x200000000000)^!!(Value&0x800000000000)^
*/
!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x800000)^
!!(Value&0x2000000)^!!(Value&0x8000000)^
!!(Value&0x20000000)^!!(Value&0x80000000)^
!!(Value&0x400000000)^
!!(Value&0x2000000000)
)
continue;
//i == 0x3F && HasOddNumberOfBits(Value2)
if(
!!(Value&0x4)^!!(Value&0x8)^
!!(Value&0x10)^!!(Value&0x20)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x4000000)^!!(Value&0x8000000)
)
continue;
//i == 0x3F && (Value1 & 0x2000)
if(
!!(Value&0x1)^!!(Value&0x8)^
!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x100)^!!(Value&0x200)^!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x10000)^!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x200000)^!!(Value&0x400000)^!!(Value&0x800000)^
!!(Value&0x1000000)^!!(Value&0x2000000)^!!(Value&0x4000000)^!!(Value&0x8000000)^
!!(Value&0x10000000)^!!(Value&0x20000000)^!!(Value&0x80000000)^
!!(Value&0x100000000)^!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xAAAAAAAA) ^ HasOddNumberOfBits(Value2 & 0xAAAA))
if(
!!(Value&0x1)^
!!(Value&0x10)^!!(Value&0x80)^
!!(Value&0x800)^
!!(Value&0x8000)^
!!(Value&0x40000)^
!!(Value&0x100000)^!!(Value&0x400000)^!!(Value&0x800000)^
!!(Value&0x4000000)^
!!(Value&0x40000000)^!!(Value&0x80000000)^
!!(Value&0x400000000)^!!(Value&0x800000000)^
!!(Value&0x4000000000)^!!(Value&0x8000000000)^
!!(Value&0x40000000000)^!!(Value&0x80000000000)^
!!(Value&0x400000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xCCCCCCCC) ^ HasOddNumberOfBits(Value2 & 0xCCCC))
if(
!!(Value&0x1)^!!(Value&0x2)^!!(Value&0x4)^
!!(Value&0x10)^!!(Value&0x40)^!!(Value&0x80)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x800000)^
!!(Value&0x8000000)^
!!(Value&0x10000000)^!!(Value&0x20000000)^!!(Value&0x40000000)^
!!(Value&0x100000000)^!!(Value&0x200000000)^!!(Value&0x400000000)^
!!(Value&0x1000000000)^!!(Value&0x2000000000)^!!(Value&0x4000000000)^
!!(Value&0x10000000000)^!!(Value&0x20000000000)^!!(Value&0x40000000000)^
!!(Value&0x100000000000)^!!(Value&0x200000000000)^!!(Value&0x400000000000)^!!(Value&0x800000000000)
)
continue;
//i == 0x3F && (HasOddNumberOfBits(Value1 & 0xF0F0F0F0) ^ HasOddNumberOfBits(Value2 & 0xF0F0))
if(
!!(Value&0x1)^!!(Value&0x4)^
!!(Value&0x20)^
!!(Value&0x100)^!!(Value&0x200)^!!(Value&0x400)^!!(Value&0x800)^
!!(Value&0x1000)^!!(Value&0x2000)^
!!(Value&0x10000)^!!(Value&0x20000)^!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^
!!(Value&0x2000000)^!!(Value&0x8000000)^
!!(Value&0x40000000)^!!(Value&0x80000000)^
!!(Value&0x200000000)^!!(Value&0x400000000)^
!!(Value&0x4000000000)^!!(Value&0x8000000000)^
!!(Value&0x20000000000)^!!(Value&0x40000000000)^
!!(Value&0x400000000000)
)
continue;
//i == 0x3F && HasOddNumberOfBits(Value1 & 0xFF00FF00) == HasOddNumberOfBits(Value2 & 0xFF00)
if(
!!(Value&0x8)^
!!(Value&0x1000)^!!(Value&0x2000)^!!(Value&0x4000)^!!(Value&0x8000)^
!!(Value&0x40000)^!!(Value&0x80000)^
!!(Value&0x100000)^!!(Value&0x200000)^
!!(Value&0x2000000)^
!!(Value&0x80000000)^
!!(Value&0x400000000)^
!!(Value&0x2000000000)^
!!(Value&0x20000000000)^!!(Value&0x40000000000)^!!(Value&0x80000000000)^
!!(Value&0x800000000000)
)
continue;
for(int i=0; i<0x60; i++) {
uint64_t tmp = !!(Value&0x01)^!!(Value&0x02)^!!(Value&0x08)^!!(Value&0x10)^!!(Value&0x40)^!!(Value&0x800000000000);
Value = (Value >> 1) | (tmp << 47);
uint32_t Value1 = Value & 0xFFFFFFFF;
uint32_t Value2 = (Value >> 32) & 0xFFFF;
switch(i) {
case 0x0F:
array3[0x06] = (Value1 >> 12) & 3;
array3[0x07] = ((Value1 >> 19) & 1) | ((Value1 >> 2) & 2);
array3[0x09] = (Value1 >> 7) & 3;
array3[0x0C] = (Value1 >> 15) & 3;
dArray[0x05] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x1F:
array3[0x05] = Value1 & 3;
array3[0x08] = ((Value1 >> 17) & 1) | ((Value1 >> 15) & 2);
array3[0x02] = (Value1 >> 10) & 3;
array3[0x01] = (Value1 >> 21) & 3;
dArray[0x1B] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x2F:
array3[0x0A] = (Value1 >> 12) & 3;
array3[0x0D] = ((Value1 >> 1) & 1) | ((Value1 >> 9) & 2);
array3[0x04] = Value1 & 3;
array3[0x00] = (Value1 >> 17) & 3;
dArray[0x1C] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x3F:
array3[0x08] = (Value1 >> 6) & 3;
array3[0x07] = ((Value1 >> 4) & 2) | ((Value1 >> 3) & 1);
array3[0x09] = (Value1 >> 11) & 3;
array3[0x0A] = (Value1 >> 9) & 3;
dArray[0x1B] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x4F:
array3[0x00] = (Value1 >> 5) & 3;
array3[0x04] = ((Value1 >> 19) & 2) | ((Value1 >> 11) & 1);
array3[0x02] = (Value1 >> 2) & 3;
array3[0x06] = (Value1 >> 12) & 3;
dArray[0x05] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
case 0x5F:
array3[0x05] = (Value1 >> 18) & 3;
array3[0x01] = ((Value1 >> 8) & 2) | ((Value1 >> 6) & 1);
array3[0x0D] = (Value1 >> 22) & 3;
array3[0x0C] = (Value1 >> 3) & 3;
dArray[0x13] = ((Value2 & ~1) << 16) | (((Value1 & 0xC000) | ((Value1 >> 1) & 0x7FFF0000)) >> 14);
break;
}
}
bv1 = isValid = 0;
dv1 = dv2 = dv3 = dv4 = 0;
iValue2++;
dArray[0x06] = 0x80200401;
dArray[0x17] = 0x84010011;
dArray[0x19] = 0x81000802;
dArray[0x15] = 0x90001004;
dArray[0x09] = 0x80080202;
for(int i=0, ArraySelector=0; i<13; i++, ArraySelector = !!(bv2&0x08) != !!(bv2&0x10)) {
if(i<8) {
ValueVersionKey = VersionKey;
dv1 = dArray[SomeByteArray1[ArraySelector][i]];
dv2 = dArray[SomeByteArray2[ArraySelector][i]];
dv3 = dArray[SomeByteArray3[ArraySelector][i]];
dv4 = dArray[SomeByteArray4[ArraySelector][i]];
dv5 = dArray[SomeByteArray5[i]];
bv1 = array3[SomeByteArray6[i]];
bv2 = array3[SomeByteArray7[i]];
} else {
switch(i) {
case 8:
ValueVersionKey = dArray[0x1C] ^ dArray[0x07];
dv5 = 0x80200401;
bv1 = array3[0x0C];
bv2 = array3[0x02];
break;
case 9:
ValueVersionKey = dArray[0x1B] ^ dArray[0x14];
dv5 = 0x80040003;
bv1 = array3[0x09];
bv2 = array3[0x0A];
break;
case 10:
ValueVersionKey = dArray[0x05] ^ dArray[0x18];
dv5 = 0x80040003;
bv1 = array3[0x06];
bv2 = array3[0x05];
break;
case 11:
ValueVersionKey = dArray[0x13] ^ dArray[0x16];
dv5 = 0x80200401;
bv1 = array3[0x0C];
bv2 = array3[0x02];
break;
case 12:
ValueVersionKey = dArray[0x1B] ^ dArray[0x0D];
dv5 = 0x80040003;
bv1 = array3[0x09];
bv2 = array3[0x0A];
break;
default: break;
}
}
bv2 &= 3;
for(int j=0; j<0x40; j++) {
if(j==0x20) {
if(bv1!=(bv2&7)) {
bv2^=0x18;
}
}
else if(j==0x30) {
if(bv1<(bv2&3)) {
bv2 ^= 0x08;
} else if (bv1>(bv2&7)) {
bv2 ^= 0x10;
}
}
uint8_t cl = bv1 + NumberOfBits(dv5&ValueVersionKey);
ValueVersionKey = (ValueVersionKey >> 1) | (cl << 31);
bv1 = (cl >> 1);
if(j==0x07||j==0x1f||j==0x3a) {
dv1 = ValueVersionKey;
}
if(j==0x17||j==0x23||j==0x2f) {
dv2 = ValueVersionKey;
}
if(j==0x10||j==0x35||j==0x1A) {
dv3 = ValueVersionKey;
}
if(j==0x29||j==0x16||j==0x2d) {
dv4 = ValueVersionKey;
}
if(j==0x33||j==0x3e) {
dv5 = ValueVersionKey;
}
if(j==0x37||j==0x38) {
if(bv1==(bv2&3)) {
bv2^=0x58;
}
}
}
if(i<8) {
dArray[SomeByteArray1[ArraySelector][i]] = dv1;
dArray[SomeByteArray2[ArraySelector][i]] = dv2;
dArray[SomeByteArray3[ArraySelector][i]] = dv3;
dArray[SomeByteArray4[ArraySelector][i]] = dv4;
dArray[SomeByteArray5[i]] = dv5;
array3[SomeByteArray7[i]] = bv2;
} else {
switch(i) {
case 8:
//printf("%X\n", dv3);
for(int l=0; l<1/*23*/; l++) {
if(dv3 == KeyValues[l]) {
printf("Found Key @0: %u %X\n", l, KeyValues[l]);
//isValid = 1; // TODO: only works in RDLevSet.exe
}
}
break;
case 10:
//printf("%X\n", dv4);
for(int l=0; l<1/*23*/; l++) {
if(dv4 == KeyValues[l]) {
printf("Found Key @2: %u %X\n", l, KeyValues[l]);
//isValid = 1; // TODO: only works in RDLevSet.exe
}
}
break;
case 11:
//printf("%X\n", dv1);
for(int l=0; l<1/*23*/; l++) {
if(dv1 == KeyValues[l]) {
printf("Found Key @3: %u %X\n", l, KeyValues[l]);
isValid = 1;
}
}
break;
case 9:
case 12:
//printf("%X\n", dv2);
for(int l=0; l<1/*23*/; l++) {
if(dv2 == KeyValues[l]) {
printf("Found Key @1/4: %u %X\n", l, KeyValues[l]);
isValid = 1;
}
}
break;
}
}
}
if(isValid || ((iValue2&0xFFFFFF) == 0xFFFFFF)) {
/*for(int k=0; k<29; k++) {
if(dArray[k]) printf("%02X: %08X\n", k, dArray[k]);
}*/
#ifdef _MSC_VER
QueryPerformanceCounter(&li2);
secondsTotal = (li2.QuadPart-CounterStart)/PCFreq/1000;
#else
clock_gettime(CLOCK_MONOTONIC, &li2);
secondsTotal = (li2.tv_sec + li2.tv_nsec / 1E9) - CounterStart;
#endif
hours = (secondsTotal/60)/60;
minutes = (secondsTotal/60)%60;
seconds = secondsTotal%60;
printf("isValid: %u, AuthCode: %s, iValue2: %I64X, Value1: %I64X, Value2: %I64X, %u:%02u:%02u hours, Progress: %lf\n", isValid, ConvertToAuthCode(iValue), iValue2, iValue&0xFFFFFFFF, iValue>>32, hours, minutes, seconds, 100*(double)(iValue - start)/(end - start));
//printf("0: %X %X %X %X %X\n", dv3, dv2, dv4, dv1, dv2);
}
}
#ifdef _MSC_VER
QueryPerformanceCounter(&li2);
secondsTotal = (li2.QuadPart-CounterStart)/PCFreq/1000;
#else
clock_gettime(CLOCK_MONOTONIC, &li2);
secondsTotal = (li2.tv_sec + li2.tv_nsec / 1E9) - CounterStart;
#endif
hours = (secondsTotal/60)/60;
minutes = (secondsTotal/60)%60;
seconds = secondsTotal%60;
printf("Finished in %u:%02u:%02u hours\n", hours, minutes, seconds);
return 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment