fi2enc.c-Dateireferenz

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <ctype.h>
#include "zlib.h"
#include "aes128.h"

Include-Abhängigkeitsdiagramm für fi2enc.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	fi2_rec_s
struct	fi2_header_s

Typdefinitionen
typedef struct fi2_header_s	fi2_hdr_t
typedef struct fi2_header_s *	pfi2_hdr_t

Funktionen
char *	_strlwr (char *moep)
static uint32_t	read32_be (const void *src_buffer)
static void	store32_be (void *dst_buffer, uint32_t value)
static uint32_t	align128 (uint32_t value)
static int	get_hexstring (void *dst, const char *str, int len)
static int	fi2rec_size (uint32_t dryos_ver)
static int	fi2enc (char *infname, char *outfname, uint32_t *key, uint32_t *iv, uint32_t pid, uint32_t dryos_ver, int32_t cs_words)
int	main (int argc, char **argv)

Variablen
static const char *	g_str_err_malloc = "memory allocation error (requested %d bytes)\n"
static const char *	g_str_shorthelp
struct fi2_rec_s	fi2_rec_s

Dokumentation der benutzerdefinierten Typen

typedef struct fi2_header_s fi2_hdr_t

typedef struct fi2_header_s * pfi2_hdr_t

Dokumentation der Funktionen

char* _strlwr

(

char *

moep)

Definiert in Zeile 19 der Datei fi2enc.c.

                          {
     char *tmp = moep;
     while((*tmp = tolower(*tmp)))  tmp++;
     return moep;
} 

static uint32_t align128 ( uint32_t  value)

static

Definiert in Zeile 66 der Datei fi2enc.c.

{
    return ( (value + 16 - 1) & 0xFFFFFFF0ul );
}

static int fi2enc ( char *  infname, char *  outfname, uint32_t *  key, uint32_t *  iv, uint32_t  pid, uint32_t  dryos_ver, int32_t  cs_words  )

static

Definiert in Zeile 117 der Datei fi2enc.c.

{
    uLongf i;
    size_t flen;
    uint32_t cs;
    FILE *fi, *fo;
    fi2_hdr_t hdr;
    struct fi2_rec_s  fi2rec;
    unsigned char *buf = NULL;
    unsigned char *upkbuf = NULL;
    unsigned char exkey[176];
    unsigned char *pblk;

    if( !infname ){
        printf("Please supply input file name.\n");
        return -1;
    }
    if( !outfname ){
        printf("Please supply target file name.\n");
        return -1;
    }
    aes128_expandkey( exkey, key );
    cs = 0;
    memset(&hdr, 0, sizeof (hdr));
    memset(&fi2rec, 0, sizeof (fi2rec));
    hdr.hwid=pid;
    hdr.unk1=0x02230000;
        hdr.id=0x01010000;
        hdr.ch=0;
        hdr.unk2=1;
    fi2rec.addr=0;
    fi2rec.fboot = 1;
    if ( !(fi = fopen(infname, "rb")) ){
        printf( "Can't open data file %s\n", infname );
        return -1;
    }
    fseek( fi, 0, SEEK_END );
    flen = ftell( fi );
    fseek( fi, 0, SEEK_SET );

    if( flen <= 0 || flen > (256  << 20) ){             // file size sanity check (256MB max)
        printf( "Data file %s have unacceptable file size (%ld)\n", infname, (unsigned long) flen );
        return -1;
    }
    upkbuf = (unsigned char*)malloc( flen );            // allocate buffer for data file
    if( !upkbuf ){
        printf( g_str_err_malloc, flen );
        return -1;
    }
    if( flen > fread( upkbuf, 1, flen, fi ) ){
        printf( "Error reading data file\n" );
        return -1;
    }
    fclose( fi );
    i = align128( 4 + compressBound( flen ) );          // determine upper bound for compressed block buffer
    buf = (unsigned char*)malloc( i );                  // allocate buffer for compressed block + blocksize
    if( !buf ){
        printf( g_str_err_malloc, i );
        return -1;
    }
    memset( buf, 0xFF, i );
    i -= 4;
    if( Z_OK !=    compress( buf + 4, &i, upkbuf, flen ) ){ 
        printf( "Data compression error\n" );
        return -1;
    }
    store32_be( buf, i );                               // store real compressed block size
    fi2rec.upklen = flen;
    fi2rec.offset = 0;                      // save data block offset
    fi2rec.len = align128( i + 4 );
    // encrypt data block
    aes128_cbc_encrypt( buf, exkey, iv, fi2rec.len );
    pblk = buf;                                 
    if (cs_words) {
        uint32_t *wbuf = (uint32_t*)buf;
        for( i = 0; i < fi2rec.len/4; i++) cs += wbuf[i];   // update block checksum
    }
    else {
        for( i = 0; i < fi2rec.len; i++) cs += buf[i];  // update block checksum
    }

    free( upkbuf ); upkbuf = NULL;
    // process next block
    // finalize header
    i = 32 + fi2rec_size(dryos_ver);
    i = align128(i); // header needs to be aligned
    store32_be( &hdr.hlen_be, i - 4 );
    hdr.nblk = 1;
    hdr.datacs = cs;
    buf = (unsigned char*)malloc( i );                          // allocate buffer for encrypted header
    if( !buf ){
        printf( g_str_err_malloc, i );
        return -1;
    }
    memset( buf, 0, i );
    memcpy( buf, &hdr, 32 );
    memcpy( buf+32, &fi2rec, fi2rec_size(dryos_ver));
    aes128_cbc_encrypt( buf, exkey, iv, i );

    // ---------------------------- save results ------------------------------
    // open target file
    printf( "Saving %s\n", outfname );
    fo = fopen(outfname,"wb");
    if(!fo){
        printf("Can't open file %s for writing\n", outfname);
        return(-1);
    }
    // save header
    if ( i != fwrite(buf, 1, i, fo ) ){
        printf("\nError writing header to %s (%ld bytes)\n", outfname, i);
        return(-1);
    }
    free( buf );
    // save data blocks
        if (fi2rec.len != fwrite( pblk, 1, fi2rec.len, fo ) ){
            printf("\nError writing data block to %s (%d bytes)\n", outfname, fi2rec.len);
            return(-1);
        }
        free( pblk );
    fclose( fo );
    return 0;
}

static int fi2rec_size ( uint32_t  dryos_ver)

static

Definiert in Zeile 100 der Datei fi2enc.c.

{
    // return the correct size to use for the block record
    if (dryos_ver >= 55)
    {
        return sizeof (fi2_rec_s);
    }
    else if (dryos_ver >= 50)
    {
        return sizeof (fi2_rec_s) - 4; // exclude the new R50 extra value
    }
    else
    {
        return sizeof (fi2_rec_s) - 8; // exclude the new R55 extra value too
    }
}

static int get_hexstring ( void *  dst, const char *  str, int  len  )

static

Definiert in Zeile 71 der Datei fi2enc.c.

{
    int i;
    unsigned char c;
    unsigned char *p = (unsigned char *)dst;

    if( !str ){
        printf( "No hex string supplied!\n" );
        return -1;
    }
    if( !p ) return -1;
    if( strlen( str ) != (size_t)len*2 ){
        printf( "Hex length mismatch in \"%s\"!\n", str );
        return -1;
    }
    for( i = 0; i < len*2; i++ ){
        c = str[i];
        if( c < ('9'+1) && c >= '0' ) c-= 0x30;
        else if( c < 'G' && c >= 'A' ) c -= ('A' - 0x0A);
        else if( c < 'g' && c >= 'a' ) c -= ('a' - 0x0A);
        else {
            printf("Non-hex character \'%c\' at %d in string %s\n", c, i+1, str );
            return -1;
        }
        p[i/2] = i & 1 ? p[i/2] | c : c << 4;
    }
    return 0;
}

int main	(	int	argc,
		char **	argv
	)

Definiert in Zeile 241 der Datei fi2enc.c.

{
    int i;
    uint32_t key_buf[4];
    uint32_t iv_buf[4];
    uint32_t *key = NULL;
    uint32_t *iv = NULL;
    char *fni = NULL, *fno = NULL;
    uint32_t pid=0;
    uint32_t dryos_ver=0;
    char *flags = NULL;
    int32_t cs_words = 0;

    // parse command line
    for( i = 1; i < argc; i++){
        if( argv[i][0] == '/' || argv[i][0] == '-' ){   // ---- arg is option
            
            if( !strcmp( "key", _strlwr(argv[i]+1) ) ){                     // opt: key
                if ( get_hexstring( key_buf, argv[++i], sizeof key_buf ) ) return -1;
                else key = key_buf;
            }
            else if( !strcmp( "iv", _strlwr(argv[i]+1) ) ){                         // opt: iv
                if ( get_hexstring( iv_buf, argv[++i], sizeof iv_buf ) ) return -1;
                else iv = iv_buf;
            }
            else if( !strcmp( "p", _strlwr(argv[i]+1) ) ){                      // opt: pid
                    char *err=NULL;
                    pid = strtoul(argv[++i], &err, 0);
                if (*err) return -1;
            }
            else if( !strcmp( "pv", _strlwr(argv[i]+1) ) ){                     // opt: dryos_ver
                    char *err=NULL;
                    dryos_ver = strtoul(argv[++i], &err, 0);
                if (*err) return -1;
            }
            else if( !strcmp( "x", _strlwr(argv[i]+1) ) ){ // extra flags, single string without spaces
                    flags = argv[++i];
            }
            else {
                printf("Unexpected option: %s\n", argv[i]);
                return -1;
            }
        } else {    // ---- arg is not an option
            if( !fni ) fni = argv[i];       // 1st non-option is input file name
            else if( !fno ) fno = argv[i];  // 2nd non-option is output file name
            else {
                printf("Unexpected parameter: %s\n", argv[i]);
                return -1;
            }
        }
    }
    if( !key || !iv || !pid){
        fputs( g_str_shorthelp, stdout );
        return -1;
    }
    if (flags) {
        if ( strstr(flags, "W") ) {
            cs_words = 1;
        }
    }
    for( i = 0; i < 4; i ++ )  key[i] = read32_be( key+i );
        i = fi2enc( fni, fno, key, iv , pid, dryos_ver, cs_words);
    if ( !i ) printf( "Done\n" );   else printf( "Failed!\n" );
    return i;
}

static uint32_t read32_be ( const void *  src_buffer)

static

Definiert in Zeile 51 der Datei fi2enc.c.

{
    unsigned char *b = (unsigned char *)src_buffer;
    return (b[0]<<24) | (b[1] << 16) | (b[2] << 8) | b[3];
}

static void store32_be ( void *  dst_buffer, uint32_t  value  )

static

Definiert in Zeile 57 der Datei fi2enc.c.

{
    unsigned char *b = (unsigned char *)dst_buffer;
    b[0] = ( value >> 24 ) & 0xFF;
    b[1] = ( value >> 16 ) & 0xFF;
    b[2] = ( value >>  8 ) & 0xFF;
    b[3] = ( value >>  0 ) & 0xFF;
}

Variablen-Dokumentation

struct fi2_rec_s fi2_rec_s

const char* g_str_err_malloc = "memory allocation error (requested %d bytes)\n"

static

Definiert in Zeile 13 der Datei fi2enc.c.

const char* g_str_shorthelp

static

Initialisierung:

= "Usage: fi2encdec [-p PID] [-key KEY -iv IV] [-x FLAGS] in.file out.file\n"
                                     "    FLAGS: one or more of the following letters\n"
                                     "           W: checksum is word based (on new models)\n"
                                     "\n"

Definiert in Zeile 14 der Datei fi2enc.c.