Creative Sound Blaster Legacy Product Activation Source Code

GenKGA

#include <mbedtls/des.h>
#include <mbedtls/md5.h>
#include <stdio.h>
#include <Windows.h>
#include <IPHlpApi.h>
#include <ShlObj.h>
#include <Shlwapi.h>
 
#define TRACE 0
 
/* In place DSA-ECB encryption */
void encryptData(const unsigned char *key, unsigned char *msg, size_t len)
{
    mbedtls_des_context ctx;
    mbedtls_des_init(&ctx);
 
    while (len >= 8) {
        mbedtls_des_setkey_enc(&ctx, key);
        mbedtls_des_crypt_ecb(&ctx, msg, msg);
 
        msg += 8;
        len -= 8;
    }
 
#if TRACE
    if (len)
        printf("encryptData: Skipping last %d bytes.\n");
#endif
    mbedtls_des_free(&ctx);
}
 
/* In place DSA-ECB decryption */
void decryptData(const unsigned char *key, unsigned char *msg, size_t len)
{
    mbedtls_des_context ctx;
    mbedtls_des_init(&ctx);
 
    while (len >= 8) {
        mbedtls_des_setkey_enc(&ctx, key);
        mbedtls_des_crypt_ecb(&ctx, msg, msg);
 
        msg += 8;
        len -= 8;
    }
 
#if TRACE
    if (len)
        printf("decryptData: Skipping last %d bytes.\n");
#endif
    mbedtls_des_free(&ctx);
}
 
/* MAC address MD5 hash */
void hashMACAddress(const BYTE *msg, size_t len, BYTE *out)
{
    unsigned char tmp[16];
    char *buf;
 
    if (msg == NULL || !len || out == NULL)
        return;
 
    buf = (char *)malloc(3 * len);
 
    sprintf(buf, "%02X", msg[0]);
    for (size_t i = 1; i < len; i++)
        sprintf(buf + 2 + 3 * (i - 1), "-%02X", msg[i]);
 
#if TRACE
    printf("Hashing interface %s\n", buf);
#endif
 
    mbedtls_md5((unsigned char *)buf, 3 * len - 1, tmp);
 
    for (size_t i = 0; i < 16; i++) {
        sprintf(buf, "%02x", tmp[i]);
        out[2 * i] = buf[0];
        out[2 * i + 1] = buf[1];
    }
 
#if TRACE
    printf("MD5 hash %.32s\n", out);
#endif
 
    free(buf);
}
 
/* Volume serial MD5 hash */
void hashVolumeSerial(DWORD msg, BYTE *out)
{
    unsigned char tmp[16];
    char buf[9];
    int i;
 
    sprintf(buf, "%08X", msg);
 
#if TRACE
    printf("Hashing volume %s\n", buf);
#endif
 
    mbedtls_md5((unsigned char *)buf, 8, tmp);
 
    for (i = 0; i < 16; i++) {
        sprintf(buf, "%02x", tmp[i]);
        out[2 * i] = buf[0];
        out[2 * i + 1] = buf[1];
    }
 
#if TRACE
    printf("MD5 hash %.32s\n", out);
#endif
}
 
/* System time MD5 hash */
void hashSystemTime(SYSTEMTIME *msg, BYTE *out)
{
    unsigned char tmp[16];
    char buf[9];
    int i;
 
    sprintf(buf, "%04d%02d%02d", msg->wYear, msg->wMonth, msg->wDay);
#if TRACE
    printf("Hashing time %s\n", buf);
#endif
 
    mbedtls_md5((unsigned char *)buf, 8, tmp);
 
    for (i = 0; i < 16; i++) {
        sprintf(buf, "%02x", tmp[i]);
        out[2 * i] = buf[0];
        out[2 * i + 1] = buf[1];
    }
 
#if TRACE
    printf("MD5 hash %.32s\n", out);
#endif
}
 
const BYTE terminator[] = "\x00\xff\xff\xff\xff\xff\xff\xff";
 
// unknown purpose, but needs to be unique
const BYTE unknown[] = "deadbeef000000000000000000000000";
 
struct KeyNamePair
{
    const char * key;
    const char * name;
};
 
KeyNamePair knp[] =
{
    { "LA56KHYE", "CTLT99HB0X.kga"  },
    { "S3MP42XB", "CTLT46HL1X.kga"  },
    { "KYE08ZY3", "CTLT72HL2X.kga"  },
    { "A31OKL25", "CTLT11HL3X.kga"  },
    { "6K5YEHLA", "CTLT47H9X2.kga"  }, //
    { "PX432SBM", "CTLT21H1X2.kga"  }, //
    { "ZKY03YE8", "CTLT02H0X2.kga"  }, //
    { "OKLA2153", "CTLTD2H3X2.kga"  }, //
    { "NH5L2P13", "CTLT9SJDX2.kga"  }, //
    { "BDC5687E", "CTLXS2Q3X2.kga"  }, //
    { "23A3693F", "CTLO3H65X2.kga"  }, //
    { "OAMDWHRH", "CTLMN34SX2.kga"  }, //
    { "OTRTTRTR", "CTLNBK2HX2.kga"  }, //
    { "OARPTNDH", "CTLLAS4HX2.kga"  }, //
    { "OMNPMHHH", "CTLPS4HTX2.kga"  }, //!
    { "AKSMRTSD", "CTLI37CVX2.kga"  }, //
    { "F1GY89SE", "CTLUE8XYX2.kga"  }, //
    { "L3IUZSK3", "CTLS2SR4X2.kga"  }, //
    { "JH578SAA", "CTLT53HURX.kga"  },
    { "LWR232SZ", "CTD5H2W3DK.kga"  },
    { "XR2AG82P", "CTD1JXF23A.kga"  }, //*
    { "P23DSU4S", "CTT78HSK12.kga"  },
    { "P32LUD17", "CTT92KD23N.kga"  },
    { "X34DSL1S", "CTD3SPO23G.kga"  },
    { "ZL00SEW3", "CTLE2C3BA1.kga"  },
    { "H34T2GW2", "CTH6K23AS7.kga"  },
    { "BX32DNEK", "CTA30CF234.kga"  }, //
    { "6BDF7E41", "CTA200FF2D.kga"  }, //
    { "J8K23NM2", "CTAE90C24A.kga"  }, //
    { "IH68ULK0", "CTLD2JX234.kga"  }, //
    { "K53SFR23", "CTLD14KLI5.kga"  }, //
    { "LQW341ME", "CTL42SW23M.kga"  }, //
    { "M21PWSZ0", "CTLP22SV21.kga"  }, //
    { "GN3E92V4", "CTLA20RVB5.kga"  }, //*
    { "R260D5PX", "CTL34AF61R.kga"  }, //
};
 
void GenKga(const char * key, const char * filename)
{
    DWORD ret, adapterCount, hashCount, volumeSerial;
    ULONG len;
    PIP_ADAPTER_INFO adapters, adap;
    PBYTE hashes, hash;
    CHAR buf[256];
    INT drive;
    SYSTEMTIME time;
    FILE *file;
 
    printf("Generating %s\n", filename);
 
    adapterCount = 1;
 
    len = adapterCount * sizeof(IP_ADAPTER_INFO);
    adapters = (PIP_ADAPTER_INFO)malloc(len);
 
    if ((ret = GetAdaptersInfo(adapters, &len)) == ERROR_BUFFER_OVERFLOW)
        adapters = (PIP_ADAPTER_INFO)realloc(adapters, len);
 
    if (GetAdaptersInfo(adapters, &len) != NO_ERROR) {
        fprintf(stderr, "GetAdapterInfo failed, aborting.\n");
        free(adapters);
        exit(1);
    }
 
    adapterCount = 0;
    adap = adapters;
    while (adap) {
        if (adap->Type == MIB_IF_TYPE_ETHERNET) {
            adapterCount++;
        }
        adap = adap->Next;
    }
 
#if TRACE
    printf("Adapter count: %d\n", adapterCount);
#endif
    hashCount = adapterCount + 3;
    hash = hashes = (PBYTE)malloc((32 * hashCount) + 8);
 
    adap = adapters;
    while (adap) {
        if (adap->Type == MIB_IF_TYPE_ETHERNET) {
            if (adap->AddressLength) {
                hashMACAddress(adap->Address, adap->AddressLength, hash);
                hash += 32;
            }
            else {
                hashCount--;
            }
        }
        adap = adap->Next;
    }
    free(adapters);
 
    GetSystemDirectory(buf, 256);
    drive = PathGetDriveNumber(buf);
    sprintf(buf, "%C:\\", 'A' + drive);
    GetVolumeInformation(buf, NULL, 0, &volumeSerial, NULL, NULL, NULL, 0);
    hashVolumeSerial(volumeSerial, hash);
    hash += 32;
 
    memcpy(hash, unknown, 32);
    hash += 32;
 
    GetSystemTime(&time);
    hashSystemTime(&time, hash);
    hash += 32;
 
    memcpy(hash, terminator, 8);
 
    encryptData((unsigned char *)key, (unsigned char *)hashes, (32 * hashCount) + 8);
 
    file = fopen(filename, "wb+");
    fwrite(hashes, (32 * hashCount) + 8, 1, file);
    fclose(file);
 
    free(hashes);
 
#if TRACE
    printf("\n");
#endif
}
 
int main(int argc, char *argv[])
{
    char szPath[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_COMMON_APPDATA, NULL, SHGFP_TYPE_CURRENT, szPath)))
    {
        strcat_s(szPath, "\\Creative\\SoftwareLock");
 
        int error = SHCreateDirectoryExA(NULL, szPath, NULL);
        if (error == ERROR_SUCCESS || error == ERROR_FILE_EXISTS || error == ERROR_ALREADY_EXISTS)
            SetCurrentDirectoryA(szPath);
 
        ZeroMemory(szPath, sizeof(szPath));
    }
 
    GetCurrentDirectoryA(MAX_PATH, szPath);
    printf("%s\n", szPath);
 
    for (int i = 0; i < sizeof(knp) / sizeof(KeyNamePair); i++)
    {
        GenKga(knp[i].key, knp[i].name);
    }
 
    return 0;
}