[CodeEngn.com] Advance RCE Level 17

Mission...
Find the Name when the Serial is 66BB16A328F74639
(The 3rd character in Name must be either bruteforced or guessed)
(Difficulty : ★★★★★)


Analysis...

Solution and Coding...
Reverse2L17.cpp
Copyright (C) 2011 3735943886

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 3 of the License, or
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, see <http://www.gnu.org/licenses/>.

Private Access Only...

Result...

Omake...
This attachment is KeyGen of Advance RCE level 17
Please feel free to download and test it.

Name : 3735943886
Serial : CC7981330F638795

Reverse2L17_keygen.exe

(Compiled with Windows SDK)

//
// Reverse2L17_keygen.cpp
// KeyGen of Advance RCE L17 (CodeEngn.com)
// Made by 3735943886
// License : GPL
//

#include <iostream>
#include <iomanip>
#include <string>
#include <windows.h>

using namespace std;

VOID AssignNameAndSerial(LPVOID lpBuffer, LPCSTR lpName = NULL, SIZE_T NameLen = 0,
  ULONG64 Serial = 0, LPCVOID lpOrigin = NULL, SIZE_T BufferSize = 0x100)
{
  // Set Name and Serial codes to buffer
  // Direct conversion ASM to C++
  // In: lpName (CHARS, optional), NameLen (SIZE_T, optional), Serial (ULONG64, optional),
  //  lpOrigin (LPCVOID, optional), BufferSize (SIZE_T, optional)
  // Out: lpBuffer (BYTES array)

  UINT32 i;

  if(lpOrigin)
    CopyMemory(lpBuffer, lpOrigin, BufferSize);
  if(lpName)
  {
    if(!NameLen)
      NameLen = strlen(lpName);
    for(i = 0; i < NameLen; i++)
    {
      ((LPBYTE)lpBuffer)[i * 16] = lpName[i];
    }
  }
  if(Serial)
    *(ULONG64*)((LPBYTE)lpBuffer + NameLen * 4) = Serial;
  return;
}

VOID CreateTemplate(LPVOID lpBuffer, const ULONG64 uSeed, LPVOID counterarray = NULL)
{
  // Create Template
  // Direct conversion ASM to C++
  // Original Codes : 004015EE - 00401633
  // In: uSeed (ULONG64)
  // Out: lpBuffer (ULONG64 array), counterarray (BYTE array, optional)

  ULONG64 key = 0;
  UINT32 i = 0, j = 0;
  BYTE bitshift;
  BOOL ecx;

  for(i = 0; i < 0x100; i++)
  {
    key = i;
    bitshift = 0;
    for(j = 0; j < 8; j++)
    {
      ecx = key & 1;
      key >>= 1;
      if(ecx)
      {
        bitshift += 1 << j;
        key ^= uSeed;
      }
    }
    ((ULONG64*)lpBuffer)[i] = key;
    if(counterarray)
      ((LPBYTE)counterarray)[bitshift] = i;
  }
  return;
}

ULONG64 GetDiff64(ULONG64 uA, ULONG64 uB, ULONG64 uSeed)
{
  // Calculate differences between A and B
  // In: A (ULONG64), B (ULONG64)
  // Out: Difference (ULONG64)

  ULONG64 uRet = 0;
  INT32 i;

  for(i = 63; i >= 0; i--)
  {
    uRet <<= 1;
    if(((uA >> i) & 1) ^ ((uB >> i) & 1))
    {
      uA ^= uSeed;
      uRet += 1;
    }
    uSeed >>= 1;
  }
  return uRet;
}

ULONG64 GetFlags(ULONG64 Flag, LPCVOID lpBuffer1, LPCVOID lpBuffer2, const INT32 pStart = 0,
  const INT32 pDuration = 0x100)
{
  // Matching the serial
  // Direct conversion ASM to C++ (forward routine)
  // Original Codes : 00401634 - 0040166D
  // Backward routine is made by reversing the algorithm
  // In: Flag (ULONG64), lpBuffer1 (BYTE array) lpBuffer2 (ULONG64 array), pStart (INT32, optional),
  //  pDuration (INT32, optional)
  // Out: Calculated Flag (ULONG64)

  BYTE cBuf;
  INT32 i;

  if(pDuration > 0)
  {
    for(i = pStart; i < pStart + pDuration; i++)
    {
      cBuf = ((LPBYTE)lpBuffer1)[i] ^ (BYTE)Flag;
      Flag >>= 8;
      Flag ^= ((ULONG64*)lpBuffer2)[cBuf];
    }
  }
  else if(pDuration < 0)
  {
    for(i = pStart; i > pStart + pDuration; i--)
    {
      for(WORD j = 0; j < 0x100; j++)
      {
        if(Flag >> 56 == ((ULONG64*)lpBuffer2)[j] >> 56)
        {
          Flag ^= ((ULONG64*)lpBuffer2)[j];
          Flag <<= 8;
          Flag += ((LPBYTE)lpBuffer1)[i] ^ j;
          break;
        }
      }
    }
  }
  return Flag;
}

ULONG64 GetSerial(LPCSTR lpName, ULONG64 uEndKey, ULONG64 uSeed, LPCVOID Template)
{
  // KeyGen
  // Design: Get Flags just before Key site - A
  // Get Flags backword from end of template to just after Key site - B
  // Move 8 bytes and transform A to B
  // Bitshift of Seed and findout how to assign

  ULONG64 lBuffer[256] = {0};
  BYTE cBuffer[256] = {0};
  BYTE templatepointer[256] = {0};

  ULONG64 fKey;
  ULONG64 eKey;
  ULONG64 KeyDiff;
  INT32 NameLen = strlen(lpName);
  INT32 i;
  BYTE cBuf;

  // Prepare templates
  AssignNameAndSerial(cBuffer, lpName, NameLen, 0, Template);
  CreateTemplate(lBuffer, uSeed, templatepointer);

  // Get Keys
  fKey = GetFlags(0, cBuffer, lBuffer, 0, NameLen * 4);  // forward key
  eKey = GetFlags(uEndKey, cBuffer, lBuffer, 0xFF, NameLen * 4 - 0x100 + 8);  // backward key
  KeyDiff = GetDiff64(0, eKey, uSeed);

  // Calculate Serial
  for(i = 0; i < 8; i++)
  {
    cBuf = fKey & 0xFF;
    cBuf ^= templatepointer[((LPBYTE)&KeyDiff)[i]];
    cBuffer[i + NameLen * 4] = cBuf;
    fKey >>= 8;
    fKey ^= lBuffer[templatepointer[((LPBYTE)&KeyDiff)[i]]];
  }
  return *(ULONG64*)(cBuffer + NameLen * 4);
}

INT32 main()
{
  // Preset Variables
  const ULONG64 EndKey = 0x6963636972706163;
  const ULONG64 SeedKey = 0xC96C5795D7870F42;
  const CHAR tKeytemplate[] =
    "      GF(2^64)[X]/(x^64 + x^62 + x^57 + x^55 + x^54 + x^53 + x^52 + x^47 + x^46"
    " + x^45 + x^40 + x^39 + x^38 + x^37 + x^35 + x^33 + x^32 + x^31 + x^29 + x^27"
    " + x^24 + x^23 + x^22 + x^21 + x^19 + x^17 + x^13 + x^12 + x^10 + x^9 + x^7"
    " + x^4 + x^1 + 1)       ";
  ULONG64 Serial = 0;
  string Name;

  cout << endl << "Reverse2L17_keygen.exe" << endl;
  cout << "KeyGen of Advance RCE L17 (CodeEngn.com)" << endl;
  cout << "Made by 3735943886" << endl;
  cout << "License : GPL" << endl << endl;

  // KeyGen
  do
  {
    cout << "Input Name (4 - 15 bytes) : ";
    cin >> Name;
  } while(Name.length() > 15 || Name.length() < 4);
  Serial = GetSerial(Name.c_str(), EndKey, SeedKey, tKeytemplate);
  cout << "Serial Number : " << hex << uppercase << setw(16) << setfill('0') << Serial << endl;

  return 0;
}