[CodeEngn.com] Advance RCE Level 11

Mission...
Find the Name when the Serial is 94E7DB1B.
This problem has multiple solutions so post any one solution on the message board in a private thread and we will verify it for you.
Note : "Serial Accepted" must pop up for the serial.
(Difficulty : ★★☆☆☆)


Analysis...

Solution and Coding...
Reverse2L11.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...
Attachments are 'C++ Dump' and 'KeyGen' of Advance RCE level 11
Please feel free to download and test it.
For testing purpose, you can use following values. (one of working Name and Serial)

Name : 3735943886
Serial : 9FC84956

Reverse2L11_dumped.exe

(Compiled with GCC)

//
// Reverse2L11_dumped.cpp
// C++ Dump of Advance RCE L11 (CodeEngn.com)
// Made by 3735943886
// License : GPL
//

#include <iostream>
#include <string>

using namespace std;

class CppStack32
{
    public:
        unsigned __int32 pop()
        {
            if(stackpointer)
            {
                return stackbuffer[--stackpointer];
            }
            else
                return 0;
        }
        void push(unsigned __int32 dw)
        {
            stackbuffer[stackpointer] = dw;
            if(stackpointer < stacksize)
                stackpointer++;
            return;
        }
        CppStack32(size_t size = 0x100)
        {
            // Alloc memory for stack buffer
            stacksize = size;
            stackpointer = 0;
            stackbuffer = new unsigned __int32[stacksize];
        }
        ~CppStack32()
        {
            delete [] stackbuffer;
        }

    private:
        unsigned __int32 *stackbuffer;
        size_t stackpointer;
        size_t stacksize;
};

namespace code
{
    enum
    {
        PUSH = 0x22,
        END = 0x40,
        READ = 0x7E,
        WRITE = 0x2C,
        RIGHT = 0x3E,
        LEFT = 0x3C,
        DOWN = 0x76,
        UP = 0x5E,
        ADD = 0x2B,
        SUB = 0x2D,
        IMUL = 0x2A,
        IDIV = 0x2F,
        XCHG = 0x5C,
        ZERO = 0x5F,
        SKIP = 0x23,
        DUPE = 0x3A,
        LNOT = 0x21,
        ROL = 0x6C,
        CMP = 0x60,
        POP = 0x24
    };
}

void GetNextCode(char *CodePointer, char CodeStep)
{
    // 40138A
    if(*CodePointer % 20 == 0 && CodeStep == -1)
    {
        *CodePointer += 19;
    } else if(*CodePointer % 20 == 19 && CodeStep == 1)
    {
        *CodePointer -= 19;
    } else if(*CodePointer / 20 == 0 && CodeStep == -20)
    {
        *CodePointer += 60;
    } else if(*CodePointer / 20 == 3 && CodeStep == 20)
    {
        *CodePointer -= 60;
    } else *CodePointer += CodeStep;
    return;
}

void CodeExecute(char *Codes, size_t CodeSize, string Name, string *Serial)
{
    char CodePointer = 0;           // BH, BL
    char CodeStep = 1;              // CH, CL, Direction (+X, -X, +Y, -Y)
    __int32 NamePointer = 0;
    bool pushonly = false;          // MOST SIG BYTE OF EDX
    char Ch;
    unsigned __int32 i, j;
    CppStack32 s;                   // 402538

    Serial->clear();

    for(;;)
    {
        Ch = Codes[(__int32)CodePointer];
        if(Ch == code::PUSH)            // 401179, PUSH
        {
            pushonly = !pushonly;
        }
        else if(pushonly)               // 401186
        {
            s.push(Ch);
        }
        else if(Ch >= '0' && Ch <= '9')   // 4011A0
        {
            s.push(Ch - '0');
        }
        else
        {
            switch(Ch)
            {
            case code::READ:        // 4011B1, Read Name
                s.push(Name[NamePointer++]);
                break;
            case code::WRITE:       // 4011C9, Write Serial
                Serial->push_back(s.pop());
                break;
            case code::RIGHT:       // 4011E7, RIGHT
                CodeStep = 1;
                break;
            case code::LEFT:        // 4011FB, LEFT
                CodeStep = -1;
                break;
            case code::DOWN:        // 401209, DOWN
                CodeStep = 20;
                break;
            case code::UP:          // 401217, UP
                CodeStep = -20;
                break;
            case code::ADD:     // 401225, ADD
                s.push(s.pop() + s.pop());
                break;
            case code::SUB:     // 40123E, SUB
                i = s.pop();
                j = s.pop();
                s.push(i - j);
                break;
            case code::IMUL:        // 40123E, MUL
                s.push(s.pop() * s.pop());
                break;
            case code::IDIV:        // 40127E, DIV
                i = s.pop();
                j = s.pop();
                if(i)
                {
                    s.push(j % i);
                    s.push(j / i);
                }
                else
                {
                    s.push(0);      // 00401296 xor ecx, ecx -> logical err?
                    s.push(0);
                }
                break;
            case code::XCHG:        // 4012B1, XCHG
                i = s.pop();
                j = s.pop();
                s.push(i);
                s.push(j);
                break;
            case code::ZERO:        // 4012D4, TEST ZF
                CodeStep = 1 -  s.pop() * 2;
                break;
            case code::SKIP:        // 4012F3, SKIP
                GetNextCode(&CodePointer, CodeStep);
                break;
            case code::DUPE:        // 401302, DUP
                i = s.pop();
                s.push(i);
                s.push(i);
                break;
            case code::LNOT:        // 40131B, LOGIC NOT
                s.push(!s.pop());
                break;
            default:
                if(Ch == code::ROL)     // 401339, ROL
                {
                    i = s.pop();
                    i = i << 1 | i >> 31;
                    s.push(i);
                    Ch = i;     // No Brk
                }
                if(Ch == code::CMP) // 40134E, CMP
                {
                    i = s.pop();
                    j = s.pop();
                    s.push(i > j);
                    Ch = i;     // NO Brk
                }
                if(Ch == code::POP)     // 401371, POP
                {
                    Ch = s.pop();
                    break;
                }
                if(Ch == code::END)     // 4013EC, End
                    return;
            };
        }
        GetNextCode(&CodePointer, CodeStep);
    }
}

int main()
{
    char Codes[] =  // 0x40127B
    {
        0x24, 0x35, 0x25, 0x24, 0x23, 0x77, 0x76, 0x23, 0x5F, 0x22,
        0x61, 0x73, 0x22, 0x2A, 0x33, 0x24, 0x24, 0x76, 0x2B, 0x38,

        0x76, 0x2A, 0x22, 0x7E, 0x78, 0x22, 0x3C, 0x5C, 0x5E, 0x60,
        0x5C, 0x22, 0x39, 0x22, 0x3A, 0x3C, 0x3B, 0x78, 0x22, 0x2D,

        0x3E, 0x7E, 0x3A, 0x21, 0x34, 0x23, 0x76, 0x24, 0x5F, 0x22,
        0x6D, 0x64, 0x38, 0x22, 0x47, 0x2B, 0x2A, 0x25, 0x2A, 0x2B,

        0x6C, 0x3A, 0x21, 0x23, 0x40, 0x5F, 0x3E, 0x38, 0x37, 0x2B,
        0x2F, 0x5C, 0x22, 0x30, 0x22, 0x5E, 0x76, 0x3E, 0x2C, 0x2B
    };

    string Name;
    string Serial1, Serial2;

    cout << endl << "Reverse2L11_dumped.cpp" << endl
        << "C++ Dump of Advance RCE L11 (CodeEngn.com)" << endl
        << "Made by 3735943886" << endl << "License : GPL" << endl << endl;

    cout << "Name : "; cin >> Name;
    cout << endl << "Serial : "; cin >> Serial1;

    CodeExecute(Codes, sizeof(Codes), Name, &Serial2);
    if(Serial1 == Serial2)
    {
        cout << endl << "Serial accepted." << endl;
        return 1;
    }
    else
    {
        cout << endl << "Invalid serial number." << endl;
        return 0;
    }
}

Reverse2L11_keygen.exe

(Compiled with GCC, function KeyGen is optimized by 3735943886)

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

#include <iostream>
#include <string>

using namespace std;

void KeyGen(string Name, string *Serial)
{
    unsigned __int32 i, NameKey = 0;

    for(i = 0; i < Name.length(); i++)
    {
        NameKey += Name.at(i);
    }
    NameKey = NameKey * 0x426c + 0x3b10;

    Serial->clear();
    while(NameKey)
    {
        i = NameKey % 0xF;
        Serial->push_back(i + '0' + (i / 10) * 8);
        NameKey = (NameKey / 0xF) * 2;
        if((NameKey & 0xff) == 0x60)
            NameKey = 1;
        if((NameKey & 0xff) == 0x40 || (NameKey & 0xff) == 0x24)
            break;
    }
    return;
}

int main()
{
    string Name;
    string Serial;

    cout << endl << "Reverse2L11_keygen.cpp" << endl
        << "KeyGen of Advance RCE L11 (CodeEngn.com)" << endl
        << "Made by 3735943886" << endl << "License : GPL" << endl << endl;

    cout << "Name : "; cin >> Name;

    KeyGen(Name, &Serial);
    cout << endl << "Serial : " << Serial << endl;

    return 0;
}