xlsxbf.c

#include <openssl/sha.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "Base64Encode.h"
#include "Base64Decode.h"

int nextPassword(int charlistLength, const char* charlist, int passwordLength, int* passwordIndex, char* password)
{
    if(passwordLength > 1) {
        if(nextPassword(charlistLength, charlist, passwordLength - 1, passwordIndex + 1, password + 1) > 0) {
            return 1;
        }
    }

    (*passwordIndex)++;
    if(*passwordIndex >= charlistLength) {
        *passwordIndex = 0;
        *password = *charlist;
        return 0;
    }
    *password = charlist[*passwordIndex];
    return 1;
}

void status(int c, char* password)
{
    time_t t;
    time(&t);
    struct tm *d = localtime(&t);
    printf("\r%d @ %04d-%02d-%02d %02d:%02d:%02d with ", c, d->tm_year+1900, d->tm_mon+1, d->tm_mday, d->tm_hour, d->tm_min, d->tm_sec);
    putchar('"');
    while(*password) {
        // Simple UTF-16 part -> UTF-8
        if(*password > 0x80 || *password < 0) {
            putchar(0xc3);
            putchar(*password - 0x40);
        } else {
            putchar(*password);
        }
        password++;
    }
    putchar('"');
    putchar('\n');
}

int main()
{
    // start of config

    const int charlistLength = 77;
    char charlist[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-.,______!$%#=@";
    charlist[65] = 0xe5; // å in UTF-16 is [0x00, 0xe5], but we only use the lower part.
    charlist[66] = 0xe4; // ä
    charlist[67] = 0xf6; // ö
    charlist[68] = 0xc5; // Å
    charlist[69] = 0xc4; // Ä
    charlist[70] = 0xd6; // Ö

    const int saltLength = 16;
    const char* saltB64 = "PBEN2sa8NDIpdtvhjLYtjQ==";

    const char* goal = "lbU0e7K9mQ54tlh+rZVF8YkCrOX0/d2frkuhBJUUmgtvJG0HEyPQXC+Q/X74HYwNF32gHCUbZmdXNmFwX+Y2yA==";

    int passwordLength = 1;
    int maxPasswordLength = 30;
    int skip = 62900-1;

    // end of config

    setvbuf(stdout, NULL, _IONBF, 0);

    int passwordIndex[maxPasswordLength];
    char password[maxPasswordLength + 1];

    int c = 0;

    for(;passwordLength <= maxPasswordLength; passwordLength++) {
        for(int i = 0; i < passwordLength; i++) {
            passwordIndex[i] = 0;
            password[i] = charlist[0];
        }
        passwordIndex[passwordLength - 1] = -1;
        password[passwordLength] = 0;

        char* salt;
        Base64Decode(saltB64, &salt);

        unsigned char initData[saltLength + passwordLength*2 + 1];
        unsigned char* data = initData;
        unsigned char* passwordStart = initData + saltLength;
        memcpy(initData, salt, saltLength);

        while(nextPassword(charlistLength, charlist, passwordLength, passwordIndex, password))
        {
            if(skip >= 0) {
                if(skip-- > 0) {
                    c++;
                    continue;
                }
                status(c + 1, password);
            }

            for(int i = 0; i < passwordLength; i++) {
                passwordStart[i*2] = password[i];
                passwordStart[i*2 + 1] = 0;
            }

            data = initData;
            unsigned char hashData1[SHA512_DIGEST_LENGTH + 4];
            unsigned char hashData2[SHA512_DIGEST_LENGTH + 4];

            unsigned char* hash = hashData1;
            unsigned char* loopIndex;// = data + SHA512_DIGEST_LENGTH;
            SHA512(data, saltLength + passwordLength*2, hash);

            for(int i = 0; i < 100000; i++) {
                if(i & 1) {
                    hash = hashData1;
                    data = hashData2;
                } else {
                    hash = hashData2;
                    data = hashData1;
                }
                loopIndex = data + SHA512_DIGEST_LENGTH;
                loopIndex[0] = (i >> 0) & 0xff;
                loopIndex[1] = (i >> 8) & 0xff;
                loopIndex[2] = (i >> 16) & 0xff;
                loopIndex[3] = (i >> 24) & 0xff;
                SHA512(data, SHA512_DIGEST_LENGTH + 4, hash);
            }

            const char* hash2 = (const char*) hash;
            char* b64;
            Base64Encode(hash2, &b64, SHA512_DIGEST_LENGTH);

            putchar('.');
            if(++c % 100 == 0) {
                status(c, password);
            }
            if(strcmp(b64, goal) == 0) {
                printf("\n%d @ '%s' => '%s'\n", c, password, b64);
                return 0;
            }
        }
    }
    return 1;
}