Veliant

// Key generator for keygen tPODt

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef unsigned long ULONG;
typedef unsigned short USHORT;

char szEnterName[40];

ULONG keys[2];

ULONG HashName(ULONG *puName)
{
    size_t i;
    ULONG hash = 0;

    for (i = 0; i < 10; i++)
        hash ^= puName[i];
    return (0x00280000 | (hash >> 16)) ^ hash;
}

int MulTable[] = { 3, 5, 7, 13 };

void GenConst(ULONG puKeys[2], ULONG uHash)
{
    size_t x, i;
    puKeys[0] = puKeys[1] = 0;
    ULONG uMask[3] = { 0, 0, 0 };
    // Генерируем спаренные позиции
    i = 0;
    while (uMask[2] != 0xF)
    {
        x = rand() % 4;
        if (!((uMask[2] >> x) & 1))
        {
            switch (i)
            {
                case 0: puKeys[0] |= MulTable[x] << 4;  uMask[0] |= (1 << x); break;
                case 1: puKeys[0] |= MulTable[x] << 8;  uMask[0] |= (1 << x); break;
                case 2: puKeys[1] |= MulTable[x] << 20; uMask[1] |= (1 << x); break;
                case 3: puKeys[1] |= MulTable[x] << 24; uMask[1] |= (1 << x); break;
            }
            i++;
            uMask[2] |= (1 << x);
        }
    }
    // Генерируем оставшиеся множители
    // Первый ключ
    i = 0;
    while (uMask[0] != 0xF)
    {
        x = rand() % 4;
        if (!((uMask[0] >> x) & 1))
        {
            switch (i)
            {
                case 0: puKeys[0] |= MulTable[x];       break;
                case 1: puKeys[0] |= MulTable[x] << 12; break;
            }
            i++;
            uMask[0] |= (1 << x);
        }
    }
    // Старшая часть = зеркальное отражение младшей
    puKeys[0] |=  puKeys[0]              << 28;
    puKeys[0] |= (puKeys[0] >> 4  & 0xF) << 24;
    puKeys[0] |= (puKeys[0] >> 8  & 0xF) << 20;
    puKeys[0] |= (puKeys[0] >> 12 & 0xF) << 16;

    // Второй ключ
    i = 0;
    while (uMask[1] != 0xF)
    {
        x = rand() % 4;
        if (!((uMask[1] >> x) & 1))
        {
            switch (i)
            {
                case 0: puKeys[1] |= MulTable[x] << 16; break;
                case 1: puKeys[1] |= MulTable[x] << 28; break;
            }
            i++;
            uMask[1] |= (1 << x);
        }
    }
    // Младшая часть = зеркальное отражение старшей
    puKeys[1] |= (puKeys[1] >> 16 & 0xF) << 12;
    puKeys[1] |= (puKeys[1] >> 20 & 0xF) << 8;
    puKeys[1] |= (puKeys[1] >> 24 & 0xF) << 4;
    puKeys[1] |=  puKeys[1] >> 28;
}

int main(int argc, char *argv[])
{
    ULONG hash;
    USHORT crc, code[6];
    int i;
    memset(&szEnterName, 0, 40);
    srand(time(NULL));
    printf("Enter your name: ");
    scanf("%s", (char *)&szEnterName);
    hash = HashName((ULONG *) & szEnterName);
    // Выводим десяток ключей
    for (i =0; i< 10; i++)
    {
        // Генерируем необходимые KEY1 и KEY2
        GenConst(keys, hash);
        // Обращаем их по найденному алгоритму
        keys[0] = (keys[0] + 0x798134)   ^ 0x9F827364;
        keys[1] = (keys[1] ^ 0x4637A819) - 0x871623;
        // Расчитываем блоки ключа
        crc = rand() % 255;
        code[0] = (keys[0] >> 16 ^ hash) & 0xFFFF;
        code[1] = (keys[0] ^ hash) & 0xFFFF;
        code[2] = (keys[1] >> 16 ^ hash) & 0xFFFF;
        code[3] = (keys[1] ^ hash) & 0xFFFF;
        code[4] = hash & 0xFFFF;
        code[5] = ((crc & 0xFF) << 8) | (crc ^ 0x5B);
        printf("Your key: %04x-%04x-%04x-%04x-%04x-%04x\n", code[0], code[1], code[2], code[3], code[4], code[5]);
    }
    return 0;
}