main.c

#include <string.h>
#include <stdint.h>
#include <stdio.h>

#include <openssl/evp.h>
#include <openssl/aes.h>

static uint16_t const c_crcTable[] = {
    0x0000, 0xCC01, 0xD801, 0x1400,
    0xF001, 0x3C00, 0x2800, 0xE401,
    0xA001, 0x6C00, 0x7800, 0xB401,
    0x5000, 0x9C01, 0x8801, 0x4400
};

static uint8_t ReverseByte(uint8_t value)
{
    size_t index;
    uint8_t result;

    result = 0;

    for ( index = 0 ; index < 8 ; index++ ) {

        result <<= 1;

        if (value & 0x01)
            result |= 0x01;

        value >>= 1;
    }

    return result;
}

static uint16_t CalcCrc(const uint8_t *data, size_t size)
{
    size_t index;
    uint8_t rev;
    uint16_t result;

    result = 0;

    for ( index = 0 ; index < size ; index++ ) {

        rev = ReverseByte(data[index]);

        result = (result >> 4) ^ c_crcTable[result & 0x0F];
        result ^= c_crcTable[rev & 0x0F];
        result = (result >> 4) ^ c_crcTable[result & 0x0F];
        result ^= c_crcTable[rev >> 4];
    }

    return result;
}

static int Encrypt(const uint8_t *key, const uint8_t *src, size_t size, uint8_t *dest)
{
    int ret;
    EVP_CIPHER_CTX *ctx;
    int len;

    ctx = 0;

    ret = -1;

    do {

        ctx = EVP_CIPHER_CTX_new();
        if (!ctx) {
            ret = -1;
            break;
        }

        ret = EVP_EncryptInit_ex(ctx, EVP_aes_128_ecb(), 0, key, 0);
        if (ret != 1) {
            ret = -1;
            break;
        }

        ret = EVP_CIPHER_CTX_set_padding(ctx, 0);
        if (ret != 1) {
            ret = -1;
            break;
        }

        ret = EVP_EncryptUpdate(ctx, dest, &len, src, size);
        if (ret != 1) {
            ret = -1;
            break;
        }

        if (len < 0 || (size_t)len != size) {
            ret = -1;
            break;
        }

        ret = 0;

    } while (0);

    if (ctx)
        EVP_CIPHER_CTX_free(ctx);

    if (ret < 0) {
        printf("encryption failed\n");
        return -1;
    }

    return 0;
}

static int WriteFile(const char *filename, const uint8_t *data, size_t size)
{
    int ret;
    FILE *file;
    size_t nwrite;

    file = fopen(filename, "wb");
    if (!file) {
        printf("failed to open output file\n");
        return -1;
    }

    nwrite = fwrite(data, 1, size, file);
    if (nwrite != size) {
        printf("failed to write to output file\n");
        fclose(file);
        return -1;
    }

    ret = fclose(file);
    if (ret != 0) {
        printf("failed to finalize writing output file\n");
        return -1;
    }

    return 0;
}

static int Worker(const char *filename, const char *key, const char *password)
{
    static size_t const c_hdrSize = 48;
    static size_t const c_payloadSize = 64;
    static size_t const c_bufSize = c_hdrSize + c_payloadSize;

    int ret;
    size_t len;
    uint16_t crc;
    uint8_t aesKey0[16];
    uint8_t aesKey1[16];
    uint8_t buf[c_bufSize];
    uint8_t encBuf[c_payloadSize];
    size_t index;

    len = strlen(key);
    if (len != 16) {
        printf("invalid key length\n");
        return -1;
    }

    len = strlen(password);
    if (len < 1 || len > 16) {
        printf("invalid password length\n");
        return -1;
    }

    memset(aesKey1, 0, sizeof(aesKey1));
    memmove(aesKey1 + 16 - len, password, len);

    memmove(buf, "\xFF\x00//the//owls//are//not//what//they//seem//\x00\x00\x00\x00\xFF", 48);

    crc = CalcCrc(buf, c_hdrSize);

    for ( index = 0 ; index < 8 ; index++ ) {
        buf[c_hdrSize + index * 2 + 0] = crc >> 8;
        buf[c_hdrSize + index * 2 + 1] = crc & 0xFF;
    }

    memmove(aesKey0, buf + c_hdrSize, 16);

    memmove(buf + c_hdrSize + 16, key, 16);

    memmove(buf + c_hdrSize + 32, "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
    memmove(buf + c_hdrSize + 48, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 16);

    memmove(encBuf, buf, c_hdrSize);

    ret = Encrypt(aesKey0, buf + c_hdrSize, c_payloadSize, encBuf);
    if (ret < 0)
        return ret;

    ret = Encrypt(aesKey1, encBuf, c_payloadSize, buf + c_hdrSize);
    if (ret < 0)
        return ret;

    ret = WriteFile(filename, buf, c_bufSize);
    if (ret < 0)
        return ret;

    return 0;
}

int main(int argc, char *argv[])
{
    int ret;

    if (argc != 4) {
        printf("usage: bekgen <filename> <encryption_key> <password>\n");
        return 1;
    }

    ret = Worker(argv[1], argv[2], argv[3]);
    if (ret < 0)
        return 1;

    printf("finished successfully\n");

    return 0;
}