#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>

#define VERSION "v0.3"

/* time field stucture */
struct rktime_t
{
    uint16_t year;
    uint16_t month;
    uint16_t day;
    uint16_t hour;
    uint16_t minute;
    uint16_t second;
};

/* Rock27Boot.bin header structure */
struct rkboot_info_t
{
    char     sign[32];
    uint8_t  check_values[16];
    struct   rktime_t time;
    uint32_t ui_master_version;
    uint32_t ui_slave_version;
    uint32_t s1_offset;
    int32_t  s1_len;
    uint32_t s2_offset;
    int32_t  s2_len;
    uint32_t s3_offset;
    int32_t  s3_len;
    uint32_t s4_offset;
    int32_t  s4_len;
    uint32_t version_flag;
};

/* actions */
enum {
      NONE = 0,
      INFO = 1,
      EXTRACT = 2,
      SCRAMBLE = 4
};

/* scramble mode */
enum {
      CONTINOUS_ENC, /* scramble whole block at once */
      PAGE_ENC       /* nand bootloader is scrambled in 0x200 chunks */
};

/* scrambling/descrambling reverse engineered by AleMaxx */
static void encode_page(uint8_t *inpg, uint8_t *outpg, const int size)
{

uint8_t key[] = {
        0x7C, 0x4E, 0x03, 0x04,
        0x55, 0x05, 0x09, 0x07,
        0x2D, 0x2C, 0x7B, 0x38,
        0x17, 0x0D, 0x17, 0x11
};
        int i, i3, x, val, idx;

        uint8_t key1[0x100];
        uint8_t key2[0x100];

        for (i=0; i<0x100; i++) {
                key1[i] = i;
                key2[i] = key[i&0xf];
        }

        i3 = 0;
        for (i=0; i<0x100; i++) {
                x = key1[i];
                i3 = key1[i] + i3;
                i3 += key2[i];
                i3 &= 0xff;
                key1[i] = key1[i3];
                key1[i3] = x;
        }

        idx = 0;
        for (i=0; i<size; i++) {
                x = key1[(i+1) & 0xff];
                val = x;
                idx = (x + idx) & 0xff;
                key1[(i+1) & 0xff] = key1[idx];
                key1[idx] = (x & 0xff);
                val = (key1[(i+1)&0xff] + x) & 0xff;
                val = key1[val];
                outpg[i] = val ^ inpg[i];
        }
}

static void *binary_extract(FILE *fp, uint32_t offset, uint32_t len, int descramble, int encode_mode)
{
    void *buff, *buff_ptr;
    uint32_t ret;

    if ((fp == NULL) || len == 0)
        return NULL;

        /* allocate buff */
        if ((buff = malloc(len)) == NULL)
            return NULL;

        /* seek to the begining of the data */
        fseek(fp, offset, SEEK_SET);

        /* read into the buffer */
        ret = fread(buff, 1, len, fp);

        if (ret != len)
        {
            free(buff);
            return NULL;
        }

        /* descramble */
        if ( descramble )
        {
            buff_ptr = buff;
            if (encode_mode == PAGE_ENC)
            {
                while (len >= 0x200)
                {
                    encode_page((uint8_t *)buff_ptr,
                                (uint8_t *)buff_ptr,
                                0x200);

                    buff_ptr += 0x200;
                    len -= 0x200;
                }
            }
            encode_page((uint8_t *)buff_ptr, (uint8_t *)buff_ptr, len);
        }

    return buff;
}

static usage(void)
{
    printf("Usage: rkboottool [options] Rock27Boot.bin\n");
    printf("-h|--help         This help message\n");
    printf("-e|--extract      Extract binary images from Rock27Boot.bin file\n");
    printf("-d|--descramble   Descramble extracted binary images\n");
    printf("-i|--info         Print info about Rock27Boot.bin file\n");
    printf("\n");
    printf("Usually you would like to use -d -e together to obtain raw binary\n");
    printf("(out files rkboot_s1.bin, rkboot_s2.bin, rkboot_s3.bin, rkboot_s4.bin)\n");
}

int main (int argc, char **argv)
{
    struct rkboot_info_t rkboot_info;
    FILE *fp_in, *fp_out;
    int32_t i = 0, action = NONE;
    int32_t ret;
    void *buff;
    char *in_filename = NULL;

    if ( argc < 2 )
    {
        usage();
        return -1;
    }

    /* print banner */
    fprintf(stderr,"rkboottool " VERSION "\n");
    fprintf(stderr,"(C) Marcin Bukat 2011\n");
    fprintf(stderr,"This is free software; see the source for copying conditions.  There is NO\n");
    fprintf(stderr,"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");

    /* arguments handling */
    while (i < argc)
    {
        if ((strcmp(argv[i],"-i")==0) || (strcmp(argv[i],"--info")==0))
        {
            action |= INFO;
        }
        else if ((strcmp(argv[i],"-e")==0) || (strcmp(argv[i],"--extract")==0))
        {
            action |= EXTRACT;
        }
        else if ((strcmp(argv[i],"-d")==0) || (strcmp(argv[i],"--descramble")==0))
        {
            action |= SCRAMBLE;
        }
        else if ((strcmp(argv[i],"-h")==0) || (strcmp(argv[i],"--help")==0))
        {
            usage();
            return 0;
        }
        else if ( argv[i][0] != '-' )
        {
            /* file argument */
            in_filename = argv[i];
        }
        i++;
    }

    if ( (fp_in = fopen(in_filename, "rb")) == NULL )
    {
        fprintf(stderr, "error: can't open %s file for reading\n", in_filename);
        return -1;
    }

    ret = fread(&rkboot_info, 1, sizeof(rkboot_info), fp_in);

    if (ret != sizeof(rkboot_info))
    {
        fclose(fp_in);
        fprintf(stderr, "error: can't read %s file header\n", in_filename);
        fprintf(stderr, "read %d, expected %d\n", ret, sizeof(rkboot_info));
        return -2;
    }

    if (action & INFO)
    {
        printf("file: %s\n", in_filename);
        printf("signature: %s\n", rkboot_info.sign);
        printf("check bytes: ");
        for (i = 0; i < 16; i++)
            printf("0x%0x ", rkboot_info.check_values[i]);

        printf("\n");
        printf("timestamp %d.%d.%d %d:%d:%d\n", rkboot_info.time.day,
                                                rkboot_info.time.month,
                                                rkboot_info.time.year,
                                                rkboot_info.time.hour,
                                                rkboot_info.time.minute,
                                                rkboot_info.time.second);
        printf("UI master version: 0x%0x\n", rkboot_info.ui_master_version);
        printf("UI slave version: 0x%0x\n", rkboot_info.ui_slave_version);
        printf("s1 data offset: 0x%0x\n", rkboot_info.s1_offset);
        printf("s1 data len: 0x%0x\n", rkboot_info.s1_len);
        printf("s2 offset: 0x%0x\n", rkboot_info.s2_offset);
        printf("s2 len: 0x%0x\n", rkboot_info.s2_len);
        printf("s3 offset: 0x%0x\n", rkboot_info.s3_offset);
        printf("s3 len: 0x%0x\n", rkboot_info.s3_len);
        printf("s4 offset: 0x%0x\n", rkboot_info.s4_offset);
        printf("s4 len: 0x%0x\n", rkboot_info.s4_len);
        printf("UI version flag: 0x%0x\n", rkboot_info.version_flag);
    }

    if (action & EXTRACT)
    {
        /* first stage */
        buff = binary_extract(fp_in, rkboot_info.s1_offset,
                                     rkboot_info.s1_len,
                                     action & SCRAMBLE,
                                     CONTINOUS_ENC);

        if ( buff == NULL )
        {
            fclose(fp_in);
            fprintf(stderr, "error: can't extract image\n");
            return -2;
        }

        /* output */
        if ((fp_out = fopen("rkboot_s1.bin", "wb")) == NULL)
        {
            free(buff);
            fclose(fp_in);
            fprintf(stderr, "[error]: can't open rkboot_s1.bin for writing\n");
            return -3;
        }

        fwrite(buff, 1, rkboot_info.s1_len, fp_out);
 
        fprintf(stderr, "[info]: extracted rkboot_s1.bin file\n");
        free(buff);
        fclose(fp_out);

        /* second stage */
        buff = binary_extract(fp_in, rkboot_info.s2_offset,
                                     rkboot_info.s2_len,
                                     action & SCRAMBLE,
                                     CONTINOUS_ENC);

        if ( buff == NULL )
        {
            fclose(fp_in);
            fprintf(stderr, "error: can't extract image\n");
            return -2;
        }

        if ((fp_out = fopen("rkboot_s2.bin", "wb")) == NULL)
        {
            free(buff);
            fclose(fp_in);
            fprintf(stderr, "[error]: can't open rkboot_s2.bin for writing\n");
            return -4;
        }

        fwrite(buff, 1, rkboot_info.s2_len, fp_out);

        fprintf(stderr, "[info]: extracted rkboot_s2.bin file\n");
        free(buff);
        fclose(fp_out);

        /* third stage */
        buff = binary_extract(fp_in, rkboot_info.s3_offset,
                                     rkboot_info.s3_len,
                                     action & SCRAMBLE,
                                     PAGE_ENC);
        if ( buff == NULL )
        {
            fclose(fp_in);
            fprintf(stderr, "[error]: can't extract image.\n");
            return -2;
        }

        if ((fp_out = fopen("rkboot_s3.bin", "wb")) == NULL)
        {
            free(buff);
            fclose(fp_in);
            fprintf(stderr, "[error]: can't open rkboot_s3.bin for writing\n");
            return -4;
        }

        fwrite(buff, 1, rkboot_info.s3_len, fp_out);

        fprintf(stderr, "[info]: extracted rkboot_s3.bin file\n");
        free(buff);
        fclose(fp_out);

        /* forth stage */
        buff = binary_extract(fp_in, rkboot_info.s4_offset,
                                     rkboot_info.s4_len,
                                     action & SCRAMBLE,
                                     CONTINOUS_ENC);
        if ( buff == NULL )
        {
            fclose(fp_in);
            fprintf(stderr, "[error]: can't extract image\n");
            return -2;
        }

        if ((fp_out = fopen("rkboot_s4.bin", "wb")) == NULL)
        {
            free(buff);
            fclose(fp_in);
            fprintf(stderr, "[error]: can't open rkboot_s4.bin for writing\n");
            return -4;
        }

        fwrite(buff, 1, rkboot_info.s4_len, fp_out);

        fprintf(stderr, "[info]: extracted rkboot_s4.bin file\n");
        free(buff);
        fclose(fp_out);
    }

    fclose(fp_in);
    return 0;
}