From 66dce4b7304c976bd8dca27d934eaac9e6f4fdb9 Mon Sep 17 00:00:00 2001 From: Amaury Pouly Date: Fri, 16 Sep 2011 22:27:16 +0000 Subject: sbtools: implement more complicated integer expression in db files, implement data sections, section attributes, file options, rework command line attributes git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30562 a1c6a512-1295-4272-9138-f99709370657 --- utils/sbtools/dbparser.c | 411 +++++++++++++++++++++++++++++++++-------------- utils/sbtools/dbparser.h | 28 +++- utils/sbtools/elftosb.c | 387 +++++++++++++++++++++++++++++++------------- 3 files changed, 588 insertions(+), 238 deletions(-) (limited to 'utils/sbtools') diff --git a/utils/sbtools/dbparser.c b/utils/sbtools/dbparser.c index 20f2d66c0e..2dcc21eeba 100644 --- a/utils/sbtools/dbparser.c +++ b/utils/sbtools/dbparser.c @@ -22,6 +22,7 @@ #include #include #include +#include #include "dbparser.h" typedef uint8_t byte; @@ -45,6 +46,10 @@ enum lexem_type_t LEX_LBRACE, LEX_RBRACE, LEX_RANGLE, + LEX_OR, + LEX_LSHIFT, + LEX_COLON, + LEX_LE, LEX_EOF }; @@ -274,6 +279,8 @@ static void next_lexem(struct context_t *ctx, struct lexem_t *lexem) } if(eof(ctx)) ret_simple(LEX_EOF, 0); char c = cur_char(ctx); + bool nv = next_valid(ctx, 1); + char nc = nv ? next_char(ctx, 1) : 0; if(c == '(') ret_simple(LEX_LPAREN, 1); if(c == ')') ret_simple(LEX_RPAREN, 1); if(c == '{') ret_simple(LEX_LBRACE, 1); @@ -281,6 +288,10 @@ static void next_lexem(struct context_t *ctx, struct lexem_t *lexem) if(c == '>') ret_simple(LEX_RANGLE, 1); if(c == '=') ret_simple(LEX_EQUAL, 1); if(c == ';') ret_simple(LEX_SEMICOLON, 1); + if(c == ',') ret_simple(LEX_COLON, 1); + if(c == '|') ret_simple(LEX_OR, 1); + if(c == '<' && nv && nc == '<') ret_simple(LEX_LSHIFT, 2); + if(c == '<' && nv && nc == '=') ret_simple(LEX_LE, 2); if(c == '"') return parse_string(ctx, lexem); if(c == '\'') return parse_ascii_number(ctx, lexem); if(isdigit(c)) return parse_number(ctx, lexem); @@ -304,6 +315,8 @@ static void log_lexem(struct lexem_t *lexem) case LEX_SEMICOLON: printf(";"); break; case LEX_NUMBER: printf("num(%d)", lexem->num); break; case LEX_STRING: printf("str(%s)", lexem->str); break; + case LEX_OR: printf("|"); break; + case LEX_LSHIFT: printf("<<"); break; default: printf(""); } } @@ -321,11 +334,15 @@ struct cmd_source_t *db_find_source_by_id(struct cmd_file_t *cmd_file, const cha return NULL; } -static void generate_default_version(struct sb_version_t *ver) +struct cmd_option_t *db_find_option_by_id(struct cmd_option_t *opt, const char *name) { - ver->major = 0x999; - ver->minor = 0x999; - ver->revision = 0x999; + while(opt) + { + if(strcmp(opt->name, name) == 0) + return opt; + opt = opt->next; + } + return NULL; } #define INVALID_SB_SUBVERSION 0xffff @@ -375,6 +392,68 @@ bool db_parse_sb_version(struct sb_version_t *ver, char *str) do { fprintf(stderr, "%s:%d: ", lexem.file, lexem.line); \ fprintf(stderr, __VA_ARGS__); exit(2); } while(0) +struct lex_ctx_t +{ + struct context_t ctx; + struct lexem_t lexem; +}; + +static inline void next(struct lex_ctx_t *ctx) +{ + next_lexem(&ctx->ctx, &ctx->lexem); +} + +static uint32_t parse_term_expr(struct lex_ctx_t *ctx, struct cmd_option_t *const_list) +{ + uint32_t ret = 0; + if(ctx->lexem.type == LEX_NUMBER) + ret = ctx->lexem.num; + else if(ctx->lexem.type == LEX_IDENTIFIER) + { + struct cmd_option_t *c = db_find_option_by_id(const_list, ctx->lexem.str); + if(c == NULL) + parse_error(ctx->lexem, "Undefined reference to constant '%s'\n", ctx->lexem.str); + if(c->is_string) + parse_error(ctx->lexem, "Internal error: constant '%s' is not an integer\n", ctx->lexem.str); + ret = c->val; + } + else + parse_error(ctx->lexem, "Number or constant identifier expected\n"); + next(ctx); + return ret; +} + +static uint32_t parse_shift_expr(struct lex_ctx_t *ctx, struct cmd_option_t *const_list) +{ + uint32_t v = parse_term_expr(ctx, const_list); + while(ctx->lexem.type == LEX_LSHIFT) + { + next(ctx); + v <<= parse_term_expr(ctx, const_list); + } + return v; +} + +static uint32_t parse_or_expr(struct lex_ctx_t *ctx, struct cmd_option_t *const_list) +{ + uint32_t v = parse_shift_expr(ctx, const_list); + while(ctx->lexem.type == LEX_OR) + { + next(ctx); + v |= parse_shift_expr(ctx, const_list); + } + return v; +} + +static uint32_t parse_intexpr(struct lex_ctx_t *ctx, struct cmd_option_t *const_list) +{ + return parse_or_expr(ctx, const_list); +} + +#define NR_INITIAL_CONSTANTS 4 +static char *init_const_name[NR_INITIAL_CONSTANTS] = {"true", "false", "yes", "no"}; +static uint32_t init_const_value[NR_INITIAL_CONSTANTS] = {1, 0, 1, 0}; + struct cmd_file_t *db_parse_file(const char *file) { size_t size; @@ -394,19 +473,58 @@ struct cmd_file_t *db_parse_file(const char *file) struct cmd_file_t *cmd_file = xmalloc(sizeof(struct cmd_file_t)); memset(cmd_file, 0, sizeof(struct cmd_file_t)); - generate_default_version(&cmd_file->product_ver); - generate_default_version(&cmd_file->component_ver); + /* add initial constants */ + for(int i = 0; i < NR_INITIAL_CONSTANTS; i++) + { + struct cmd_option_t *opt = xmalloc(sizeof(struct cmd_option_t)); + memset(opt, 0, sizeof(struct cmd_option_t)); + opt->name = init_const_name[i]; + opt->is_string = false; + opt->val = init_const_value[i]; + opt->next = cmd_file->constant_list; + cmd_file->constant_list = opt; + } - struct lexem_t lexem; - struct context_t ctx; - ctx.file = file; - ctx.line = 1; - ctx.begin = buf; - ctx.ptr = buf; - ctx.end = buf + size; - #define next() next_lexem(&ctx, &lexem) + struct lex_ctx_t lctx; + lctx.ctx.file = file; + lctx.ctx.line = 1; + lctx.ctx.begin = buf; + lctx.ctx.ptr = buf; + lctx.ctx.end = buf + size; + #define next() next(&lctx) + #define lexem lctx.lexem /* init lexer */ next(); + /* constants ? */ + if(lexem.type == LEX_IDENTIFIER && !strcmp(lexem.str, "constants")) + { + next(); + if(lexem.type != LEX_LBRACE) + parse_error(lexem, "'{' expected after 'constants'\n"); + + while(true) + { + struct cmd_option_t *opt = xmalloc(sizeof(struct cmd_option_t)); + memset(opt, 0, sizeof(struct cmd_option_t)); + next(); + if(lexem.type == LEX_RBRACE) + break; + if(lexem.type != LEX_IDENTIFIER) + parse_error(lexem, "Identifier expected in constants\n"); + opt->name = lexem.str; + next(); + if(lexem.type != LEX_EQUAL) + parse_error(lexem, "'=' expected after identifier\n"); + next(); + opt->is_string = false; + opt->val = parse_intexpr(&lctx, cmd_file->constant_list); + opt->next = cmd_file->constant_list; + cmd_file->constant_list = opt; + if(lexem.type != LEX_SEMICOLON) + parse_error(lexem, "';' expected after string\n"); + } + next(); + } /* options ? */ if(lexem.type == LEX_IDENTIFIER && !strcmp(lexem.str, "options")) { @@ -416,31 +534,31 @@ struct cmd_file_t *db_parse_file(const char *file) while(true) { + struct cmd_option_t *opt = xmalloc(sizeof(struct cmd_option_t)); + memset(opt, 0, sizeof(struct cmd_option_t)); next(); if(lexem.type == LEX_RBRACE) break; if(lexem.type != LEX_IDENTIFIER) parse_error(lexem, "Identifier expected in options\n"); - char *opt = lexem.str; + opt->name = lexem.str; next(); if(lexem.type != LEX_EQUAL) parse_error(lexem, "'=' expected after identifier\n"); next(); - if(!strcmp(opt, "productVersion") || !strcmp(opt, "componentVersion")) + if(lexem.type == LEX_STRING) { - if(lexem.type != LEX_STRING) - parse_error(lexem, "String expected after '='\n"); - bool ret; - if(!strcmp(opt, "productVersion")) - ret = db_parse_sb_version(&cmd_file->product_ver, lexem.str); - else - ret = db_parse_sb_version(&cmd_file->component_ver, lexem.str); - if(!ret) - parse_error(lexem, "Invalid product/component version"); + opt->is_string = true; + opt->str = lexem.str; + next(); } else - parse_error(lexem, "Unknown option '%s'\n", opt); - next(); + { + opt->is_string = false; + opt->val = parse_intexpr(&lctx, cmd_file->constant_list); + } + opt->next = cmd_file->opt_list; + cmd_file->opt_list = opt; if(lexem.type != LEX_SEMICOLON) parse_error(lexem, "';' expected after string\n"); } @@ -460,7 +578,6 @@ struct cmd_file_t *db_parse_file(const char *file) break; struct cmd_source_t *src = xmalloc(sizeof(struct cmd_source_t)); memset(src, 0, sizeof(struct cmd_source_t)); - src->next = cmd_file->source_list; if(lexem.type != LEX_IDENTIFIER) parse_error(lexem, "identifier expected in sources\n"); src->identifier = lexem.str; @@ -468,16 +585,34 @@ struct cmd_file_t *db_parse_file(const char *file) if(lexem.type != LEX_EQUAL) parse_error(lexem, "'=' expected after identifier\n"); next(); - if(lexem.type != LEX_STRING) - parse_error(lexem, "String expected after '='\n"); - src->filename = lexem.str; - next(); + if(lexem.type == LEX_STRING) + { + src->is_extern = false; + src->filename = lexem.str; + next(); + } + else if(lexem.type == LEX_IDENTIFIER && !strcmp(lexem.str, "extern")) + { + src->is_extern = true; + src->filename = ""; + next(); + if(lexem.type != LEX_LPAREN) + parse_error(lexem, "'(' expected after 'extern'\n"); + next(); + src->extern_nr = parse_intexpr(&lctx, cmd_file->constant_list); + if(lexem.type != LEX_RPAREN) + parse_error(lexem, "')' expected\n"); + next(); + } + else + parse_error(lexem, "String or 'extern' expected after '='\n"); if(lexem.type != LEX_SEMICOLON) - parse_error(lexem, "';' expected after string\n"); + parse_error(lexem, "';' expected\n"); if(db_find_source_by_id(cmd_file, src->identifier) != NULL) parse_error(lexem, "Duplicate source identifier\n"); /* type filled later */ src->type = CMD_SRC_UNK; + src->next = cmd_file->source_list; cmd_file->source_list = src; } @@ -497,117 +632,143 @@ struct cmd_file_t *db_parse_file(const char *file) if(lexem.type != LEX_LPAREN) parse_error(lexem, "'(' expected after 'section'\n"); next(); - /* can be a number or a 4 character long string */ - if(lexem.type == LEX_NUMBER) + /* can be any number */ + sec->identifier = parse_intexpr(&lctx, cmd_file->constant_list); + /* options ? */ + if(lexem.type == LEX_SEMICOLON) { - sec->identifier = lexem.num; + do + { + next(); + struct cmd_option_t *opt = xmalloc(sizeof(struct cmd_option_t)); + memset(opt, 0, sizeof(struct cmd_option_t)); + if(lexem.type != LEX_IDENTIFIER) + parse_error(lexem, "Identifier expected for section option\n"); + opt->name = lexem.str; + next(); + if(lexem.type != LEX_EQUAL) + parse_error(lexem, "'=' expected after option identifier\n"); + next(); + if(lexem.type == LEX_STRING) + { + opt->is_string = true; + opt->str = lexem.str; + next(); + } + else + { + opt->is_string = false; + opt->val = parse_intexpr(&lctx, cmd_file->constant_list); + } + opt->next = sec->opt_list; + sec->opt_list = opt; + }while(lexem.type == LEX_COLON); } - else - parse_error(lexem, "Number expected as section identifier\n"); - - next(); if(lexem.type != LEX_RPAREN) parse_error(lexem, "')' expected after section identifier\n"); next(); - if(lexem.type != LEX_LBRACE) - parse_error(lexem, "'{' expected after section directive\n"); - /* commands */ - while(true) + if(lexem.type == LEX_LBRACE) { - struct cmd_inst_t *inst = xmalloc(sizeof(struct cmd_inst_t)); - memset(inst, 0, sizeof(struct cmd_inst_t)); - next(); - if(lexem.type == LEX_RBRACE) - break; - if(lexem.type != LEX_IDENTIFIER) - parse_error(lexem, "Instruction expected in section\n"); - if(strcmp(lexem.str, "load") == 0) - inst->type = CMD_LOAD; - else if(strcmp(lexem.str, "call") == 0) - inst->type = CMD_CALL; - else if(strcmp(lexem.str, "jump") == 0) - inst->type = CMD_JUMP; - else if(strcmp(lexem.str, "mode") == 0) - inst->type = CMD_MODE; - else - parse_error(lexem, "Instruction expected in section\n"); - next(); - - if(inst->type == CMD_LOAD) + sec->is_data = false; + /* commands */ + while(true) { + struct cmd_inst_t *inst = xmalloc(sizeof(struct cmd_inst_t)); + memset(inst, 0, sizeof(struct cmd_inst_t)); + next(); + if(lexem.type == LEX_RBRACE) + break; if(lexem.type != LEX_IDENTIFIER) - parse_error(lexem, "Identifier expected after instruction\n"); - inst->identifier = lexem.str; - if(db_find_source_by_id(cmd_file, inst->identifier) == NULL) - parse_error(lexem, "Undefined reference to source '%s'\n", inst->identifier); + parse_error(lexem, "Instruction expected in section\n"); + if(strcmp(lexem.str, "load") == 0) + inst->type = CMD_LOAD; + else if(strcmp(lexem.str, "call") == 0) + inst->type = CMD_CALL; + else if(strcmp(lexem.str, "jump") == 0) + inst->type = CMD_JUMP; + else if(strcmp(lexem.str, "mode") == 0) + inst->type = CMD_MODE; + else + parse_error(lexem, "Instruction expected in section\n"); next(); - if(lexem.type == LEX_RANGLE) - { - // load at - inst->type = CMD_LOAD_AT; - next(); - if(lexem.type != LEX_NUMBER) - parse_error(lexem, "Number expected for loading address\n"); - inst->addr = lexem.num; - next(); - } - if(lexem.type != LEX_SEMICOLON) - parse_error(lexem, "';' expected after command\n"); - } - else if(inst->type == CMD_CALL || inst->type == CMD_JUMP) - { - if(lexem.type == LEX_IDENTIFIER) + + if(inst->type == CMD_LOAD) { + if(lexem.type != LEX_IDENTIFIER) + parse_error(lexem, "Identifier expected after instruction\n"); inst->identifier = lexem.str; if(db_find_source_by_id(cmd_file, inst->identifier) == NULL) parse_error(lexem, "Undefined reference to source '%s'\n", inst->identifier); next(); + if(lexem.type == LEX_RANGLE) + { + // load at + inst->type = CMD_LOAD_AT; + next(); + inst->addr = parse_intexpr(&lctx, cmd_file->constant_list); + } + if(lexem.type != LEX_SEMICOLON) + parse_error(lexem, "';' expected after command\n"); } - else if(lexem.type == LEX_NUMBER) + else if(inst->type == CMD_CALL || inst->type == CMD_JUMP) { - inst->type = (inst->type == CMD_CALL) ? CMD_CALL_AT : CMD_JUMP_AT; - inst->addr = lexem.num; - next(); + if(lexem.type == LEX_IDENTIFIER) + { + inst->identifier = lexem.str; + if(db_find_source_by_id(cmd_file, inst->identifier) == NULL) + parse_error(lexem, "Undefined reference to source '%s'\n", inst->identifier); + next(); + } + else + { + inst->type = (inst->type == CMD_CALL) ? CMD_CALL_AT : CMD_JUMP_AT; + inst->addr = parse_intexpr(&lctx, cmd_file->constant_list); + } + + if(lexem.type == LEX_LPAREN) + { + next(); + inst->argument = parse_intexpr(&lctx, cmd_file->constant_list); + if(lexem.type != LEX_RPAREN) + parse_error(lexem, "Expected closing brace\n"); + next(); + } + if(lexem.type != LEX_SEMICOLON) + parse_error(lexem, "';' expected after command\n"); + } + else if(inst->type == CMD_MODE) + { + inst->argument = parse_intexpr(&lctx, cmd_file->constant_list); + if(lexem.type != LEX_SEMICOLON) + parse_error(lexem, "Expected ';' after command\n"); } else - parse_error(lexem, "Identifier or number expected after jump/load\n"); - - if(lexem.type == LEX_LPAREN) + parse_error(lexem, "Internal error"); + if(end_list == NULL) { - next(); - if(lexem.type != LEX_NUMBER) - parse_error(lexem, "Expected numeral expression after (\n"); - inst->argument = lexem.num; - next(); - if(lexem.type != LEX_RPAREN) - parse_error(lexem, "Expected closing brace\n"); - next(); + sec->inst_list = inst; + end_list = inst; + } + else + { + end_list->next = inst; + end_list = inst; } - if(lexem.type != LEX_SEMICOLON) - parse_error(lexem, "Expected ';' after command\n"); - } - else if(inst->type == CMD_MODE) - { - if(lexem.type != LEX_NUMBER) - parse_error(lexem, "Number expected after 'mode'\n"); - inst->argument = lexem.num; - next(); - if(lexem.type != LEX_SEMICOLON) - parse_error(lexem, "Expected ';' after command\n"); - } - else - parse_error(lexem, "Internal error"); - if(end_list == NULL) - { - sec->inst_list = inst; - end_list = inst; - } - else - { - end_list->next = inst; - end_list = inst; } } + else if(lexem.type == LEX_LE) + { + sec->is_data = true; + next(); + if(lexem.type != LEX_IDENTIFIER) + parse_error(lexem, "Identifier expected after '<='\n"); + sec->source_id = lexem.str; + next(); + if(lexem.type != LEX_SEMICOLON) + parse_error(lexem, "';' expected after identifier\n"); + } + else + parse_error(lexem, "'{' or '<=' expected after section directive\n"); if(end_sec == NULL) { @@ -620,7 +781,13 @@ struct cmd_file_t *db_parse_file(const char *file) end_sec = sec; } } + #undef lexem #undef next return cmd_file; } + +void db_generate_default_sb_version(struct sb_version_t *ver) +{ + ver->major = ver->minor = ver->revision = 0x999; +} diff --git a/utils/sbtools/dbparser.h b/utils/sbtools/dbparser.h index f1b7ffd77e..cfb1a692fa 100644 --- a/utils/sbtools/dbparser.h +++ b/utils/sbtools/dbparser.h @@ -43,7 +43,11 @@ struct bin_param_t struct cmd_source_t { char *identifier; + bool is_extern; + // + int extern_nr; char *filename; + // struct cmd_source_t *next; /* for later use */ enum cmd_source_type_t type; @@ -72,23 +76,41 @@ struct cmd_inst_t struct cmd_inst_t *next; }; +struct cmd_option_t +{ + char *name; + bool is_string; + /* */ + uint32_t val; + char *str; + /* */ + struct cmd_option_t *next; +}; + struct cmd_section_t { uint32_t identifier; - struct cmd_inst_t *inst_list; + bool is_data; + // + struct cmd_inst_t *inst_list; + char *source_id; + // struct cmd_section_t *next; + struct cmd_option_t *opt_list; }; struct cmd_file_t { - struct sb_version_t product_ver; - struct sb_version_t component_ver; + struct cmd_option_t *opt_list; + struct cmd_option_t *constant_list; /* constant all always integers */ struct cmd_source_t *source_list; struct cmd_section_t *section_list; }; struct cmd_source_t *db_find_source_by_id(struct cmd_file_t *cmd_file, const char *id); +struct cmd_option_t *db_find_option_by_id(struct cmd_option_t *opt, const char *name); bool db_parse_sb_version(struct sb_version_t *ver, char *str); +void db_generate_default_sb_version(struct sb_version_t *ver); struct cmd_file_t *db_parse_file(const char *file); #endif /* __DBPARSER__ */ diff --git a/utils/sbtools/elftosb.c b/utils/sbtools/elftosb.c index 0b659eaf26..f78c6cf64b 100644 --- a/utils/sbtools/elftosb.c +++ b/utils/sbtools/elftosb.c @@ -33,6 +33,7 @@ #include #include #include +#include #include "crypto.h" #include "elf.h" @@ -46,6 +47,8 @@ #define bugp(a) do { perror("ERROR: "a); exit(1); } while(0) bool g_debug = false; +char **g_extern; +int g_extern_count; #define ROUND_UP(val, round) ((((val) + (round) - 1) / (round)) * (round)) @@ -107,6 +110,16 @@ typedef byte (*key_array_t)[16]; int g_nr_keys; key_array_t g_key_array; +static void add_keys(key_array_t ka, int kac) +{ + key_array_t new_ka = xmalloc((g_nr_keys + kac) * 16); + memcpy(new_ka, g_key_array, g_nr_keys * 16); + memcpy(new_ka + g_nr_keys, ka, kac * 16); + free(g_key_array); + g_key_array = new_ka; + g_nr_keys += kac; +} + static key_array_t read_keys(const char *key_file, int *num_keys) { int size; @@ -168,6 +181,8 @@ static key_array_t read_keys(const char *key_file, int *num_keys) * command file to sb conversion */ +#define SB_INST_DATA 0xff + struct sb_inst_t { uint8_t inst; /* SB_INST_* */ @@ -186,6 +201,9 @@ struct sb_inst_t struct sb_section_t { uint32_t identifier; + bool is_data; + bool is_cleartext; + // data sections are handled as a single SB_INST_DATA virtual instruction int nr_insts; struct sb_inst_t *insts; /* for production use */ @@ -221,6 +239,16 @@ static void elf_printf(void *user, bool error, const char *fmt, ...) va_end(args); } +static void resolve_extern(struct cmd_source_t *src) +{ + if(!src->is_extern) + return; + src->is_extern = false; + if(src->extern_nr < 0 || src->extern_nr >= g_extern_count) + bug("There aren't enough file on command file to resolve extern(%d)\n", src->extern_nr); + src->filename = g_extern[src->extern_nr]; +} + static void load_elf_by_id(struct cmd_file_t *cmd_file, const char *id) { struct cmd_source_t *src = db_find_source_by_id(cmd_file, id); @@ -231,6 +259,9 @@ static void load_elf_by_id(struct cmd_file_t *cmd_file, const char *id) return; if(src->type != CMD_SRC_UNK) bug("source '%s' seen both as elf and binary file\n", id); + /* resolve potential extern file */ + resolve_extern(src); + /* load it */ src->type = CMD_SRC_ELF; int fd = open(src->filename, O_RDONLY); if(fd < 0) @@ -255,6 +286,9 @@ static void load_bin_by_id(struct cmd_file_t *cmd_file, const char *id) return; if(src->type != CMD_SRC_UNK) bug("source '%s' seen both as elf and binary file\n", id); + /* resolve potential extern file */ + resolve_extern(src); + /* load it */ src->type = CMD_SRC_BIN; int fd = open(src->filename, O_RDONLY); if(fd < 0) @@ -274,8 +308,8 @@ static struct sb_file_t *apply_cmd_file(struct cmd_file_t *cmd_file) struct sb_file_t *sb = xmalloc(sizeof(struct sb_file_t)); memset(sb, 0, sizeof(struct sb_file_t)); - sb->product_ver = cmd_file->product_ver; - sb->component_ver = cmd_file->component_ver; + db_generate_default_sb_version(&sb->product_ver); + db_generate_default_sb_version(&sb->component_ver); if(g_debug) printf("Applying command file...\n"); @@ -295,103 +329,136 @@ static struct sb_file_t *apply_cmd_file(struct cmd_file_t *cmd_file) { struct sb_section_t *sec = &sb->sections[i]; sec->identifier = csec->identifier; - /* count instructions */ - struct cmd_inst_t *cinst = csec->inst_list; - while(cinst) + + /* options */ + do { - if(cinst->type == CMD_LOAD) - { - load_elf_by_id(cmd_file, cinst->identifier); - struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; - sec->nr_insts += elf_get_nr_sections(elf); - } - else if(cinst->type == CMD_JUMP || cinst->type == CMD_CALL) + struct cmd_option_t *opt = db_find_option_by_id(csec->opt_list, "cleartext"); + if(opt != NULL) { - load_elf_by_id(cmd_file, cinst->identifier); - struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; - if(!elf_get_start_addr(elf, NULL)) - bug("cannot jump/call '%s' because it has no starting point !\n", cinst->identifier); - sec->nr_insts++; + if(opt->is_string) + bug("Cleartext section attribute must be an integer\n"); + if(opt->val != 0 && opt->val != 1) + bug("Cleartext section attribute must be 0 or 1\n"); + sec->is_cleartext = opt->val; } - else if(cinst->type == CMD_CALL_AT || cinst->type == CMD_JUMP_AT) - { - sec->nr_insts++; - } - else if(cinst->type == CMD_LOAD_AT) - { - load_bin_by_id(cmd_file, cinst->identifier); - sec->nr_insts++; - } - else if(cinst->type == CMD_MODE) + }while(0); + + if(csec->is_data) + { + sec->is_data = true; + sec->nr_insts = 1; + sec->insts = xmalloc(sec->nr_insts * sizeof(struct sb_inst_t)); + memset(sec->insts, 0, sec->nr_insts * sizeof(struct sb_inst_t)); + + load_bin_by_id(cmd_file, csec->source_id); + struct bin_param_t *bin = &db_find_source_by_id(cmd_file, csec->source_id)->bin; + + sec->insts[0].inst = SB_INST_DATA; + sec->insts[0].size = bin->size; + sec->insts[0].data = bin->data; + } + else + { + sec->is_data = false; + /* count instructions and loads things */ + struct cmd_inst_t *cinst = csec->inst_list; + while(cinst) { - sec->nr_insts++; + if(cinst->type == CMD_LOAD) + { + load_elf_by_id(cmd_file, cinst->identifier); + struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; + sec->nr_insts += elf_get_nr_sections(elf); + } + else if(cinst->type == CMD_JUMP || cinst->type == CMD_CALL) + { + load_elf_by_id(cmd_file, cinst->identifier); + struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; + if(!elf_get_start_addr(elf, NULL)) + bug("cannot jump/call '%s' because it has no starting point !\n", cinst->identifier); + sec->nr_insts++; + } + else if(cinst->type == CMD_CALL_AT || cinst->type == CMD_JUMP_AT) + { + sec->nr_insts++; + } + else if(cinst->type == CMD_LOAD_AT) + { + load_bin_by_id(cmd_file, cinst->identifier); + sec->nr_insts++; + } + else if(cinst->type == CMD_MODE) + { + sec->nr_insts++; + } + else + bug("die\n"); + + cinst = cinst->next; } - else - bug("die\n"); - - cinst = cinst->next; - } - sec->insts = xmalloc(sec->nr_insts * sizeof(struct sb_inst_t)); - memset(sec->insts, 0, sec->nr_insts * sizeof(struct sb_inst_t)); - /* flatten */ - int idx = 0; - cinst = csec->inst_list; - while(cinst) - { - if(cinst->type == CMD_LOAD) + sec->insts = xmalloc(sec->nr_insts * sizeof(struct sb_inst_t)); + memset(sec->insts, 0, sec->nr_insts * sizeof(struct sb_inst_t)); + /* flatten */ + int idx = 0; + cinst = csec->inst_list; + while(cinst) { - struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; - struct elf_section_t *esec = elf->first_section; - while(esec) + if(cinst->type == CMD_LOAD) { - if(esec->type == EST_LOAD) - { - sec->insts[idx].inst = SB_INST_LOAD; - sec->insts[idx].addr = esec->addr; - sec->insts[idx].size = esec->size; - sec->insts[idx++].data = esec->section; - } - else if(esec->type == EST_FILL) + struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; + struct elf_section_t *esec = elf->first_section; + while(esec) { - sec->insts[idx].inst = SB_INST_FILL; - sec->insts[idx].addr = esec->addr; - sec->insts[idx].size = esec->size; - sec->insts[idx++].pattern = esec->pattern; + if(esec->type == EST_LOAD) + { + sec->insts[idx].inst = SB_INST_LOAD; + sec->insts[idx].addr = esec->addr; + sec->insts[idx].size = esec->size; + sec->insts[idx++].data = esec->section; + } + else if(esec->type == EST_FILL) + { + sec->insts[idx].inst = SB_INST_FILL; + sec->insts[idx].addr = esec->addr; + sec->insts[idx].size = esec->size; + sec->insts[idx++].pattern = esec->pattern; + } + esec = esec->next; } - esec = esec->next; } + else if(cinst->type == CMD_JUMP || cinst->type == CMD_CALL) + { + struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; + sec->insts[idx].argument = cinst->argument; + sec->insts[idx].inst = (cinst->type == CMD_JUMP) ? SB_INST_JUMP : SB_INST_CALL; + sec->insts[idx++].addr = elf->start_addr; + } + else if(cinst->type == CMD_JUMP_AT || cinst->type == CMD_CALL_AT) + { + sec->insts[idx].argument = cinst->argument; + sec->insts[idx].inst = (cinst->type == CMD_JUMP_AT) ? SB_INST_JUMP : SB_INST_CALL; + sec->insts[idx++].addr = cinst->addr; + } + else if(cinst->type == CMD_LOAD_AT) + { + struct bin_param_t *bin = &db_find_source_by_id(cmd_file, cinst->identifier)->bin; + sec->insts[idx].inst = SB_INST_LOAD; + sec->insts[idx].addr = cinst->addr; + sec->insts[idx].data = bin->data; + sec->insts[idx++].size = bin->size; + } + else if(cinst->type == CMD_MODE) + { + sec->insts[idx].inst = SB_INST_MODE; + sec->insts[idx++].addr = cinst->argument; + } + else + bug("die\n"); + + cinst = cinst->next; } - else if(cinst->type == CMD_JUMP || cinst->type == CMD_CALL) - { - struct elf_params_t *elf = &db_find_source_by_id(cmd_file, cinst->identifier)->elf; - sec->insts[idx].argument = cinst->argument; - sec->insts[idx].inst = (cinst->type == CMD_JUMP) ? SB_INST_JUMP : SB_INST_CALL; - sec->insts[idx++].addr = elf->start_addr; - } - else if(cinst->type == CMD_JUMP_AT || cinst->type == CMD_CALL_AT) - { - sec->insts[idx].argument = cinst->argument; - sec->insts[idx].inst = (cinst->type == CMD_JUMP_AT) ? SB_INST_JUMP : SB_INST_CALL; - sec->insts[idx++].addr = cinst->addr; - } - else if(cinst->type == CMD_LOAD_AT) - { - struct bin_param_t *bin = &db_find_source_by_id(cmd_file, cinst->identifier)->bin; - sec->insts[idx].inst = SB_INST_LOAD; - sec->insts[idx].addr = cinst->addr; - sec->insts[idx].data = bin->data; - sec->insts[idx++].size = bin->size; - } - else if(cinst->type == CMD_MODE) - { - sec->insts[idx].inst = SB_INST_MODE; - sec->insts[idx++].addr = cinst->argument; - } - else - bug("die\n"); - - cinst = cinst->next; } } @@ -399,7 +466,7 @@ static struct sb_file_t *apply_cmd_file(struct cmd_file_t *cmd_file) } /** - * Sb file production + * SB file production */ static void fill_gaps(struct sb_file_t *sb) @@ -436,6 +503,16 @@ static void compute_sb_offsets(struct sb_file_t *sb) sb->image_size += sizeof(struct sb_instruction_tag_t) / BLOCK_SIZE; struct sb_section_t *sec = &sb->sections[i]; + + if(g_debug) + { + printf("%s section 0x%08x", sec->is_data ? "Data" : "Boot", + sec->identifier); + if(sec->is_cleartext) + printf(" (cleartext)"); + printf("\n"); + } + sec->file_offset = sb->image_size; for(int j = 0; j < sec->nr_insts; j++) { @@ -443,7 +520,7 @@ static void compute_sb_offsets(struct sb_file_t *sb) if(inst->inst == SB_INST_CALL || inst->inst == SB_INST_JUMP) { if(g_debug) - printf("%s | addr=0x%08x | arg=0x%08x\n", + printf(" %s | addr=0x%08x | arg=0x%08x\n", inst->inst == SB_INST_CALL ? "CALL" : "JUMP", inst->addr, inst->argument); sb->image_size += sizeof(struct sb_instruction_call_t) / BLOCK_SIZE; sec->sec_size += sizeof(struct sb_instruction_call_t) / BLOCK_SIZE; @@ -451,7 +528,7 @@ static void compute_sb_offsets(struct sb_file_t *sb) else if(inst->inst == SB_INST_FILL) { if(g_debug) - printf("FILL | addr=0x%08x | len=0x%08x | pattern=0x%08x\n", + printf(" FILL | addr=0x%08x | len=0x%08x | pattern=0x%08x\n", inst->addr, inst->size, inst->pattern); sb->image_size += sizeof(struct sb_instruction_fill_t) / BLOCK_SIZE; sec->sec_size += sizeof(struct sb_instruction_fill_t) / BLOCK_SIZE; @@ -459,7 +536,7 @@ static void compute_sb_offsets(struct sb_file_t *sb) else if(inst->inst == SB_INST_LOAD) { if(g_debug) - printf("LOAD | addr=0x%08x | len=0x%08x\n", inst->addr, inst->size); + printf(" LOAD | addr=0x%08x | len=0x%08x\n", inst->addr, inst->size); /* load header */ sb->image_size += sizeof(struct sb_instruction_load_t) / BLOCK_SIZE; sec->sec_size += sizeof(struct sb_instruction_load_t) / BLOCK_SIZE; @@ -470,10 +547,17 @@ static void compute_sb_offsets(struct sb_file_t *sb) else if(inst->inst == SB_INST_MODE) { if(g_debug) - printf("MODE | mod=0x%08x", inst->addr); + printf(" MODE | mod=0x%08x", inst->addr); sb->image_size += sizeof(struct sb_instruction_mode_t) / BLOCK_SIZE; sec->sec_size += sizeof(struct sb_instruction_mode_t) / BLOCK_SIZE; } + else if(inst->inst == SB_INST_DATA) + { + if(g_debug) + printf(" DATA | size=0x%08x\n", inst->size); + sb->image_size += ROUND_UP(inst->size, BLOCK_SIZE) / BLOCK_SIZE; + sec->sec_size += ROUND_UP(inst->size, BLOCK_SIZE) / BLOCK_SIZE; + } else bug("die on inst %d\n", inst->inst); } @@ -544,7 +628,8 @@ static void produce_sb_section_header(struct sb_section_t *sec, sec_hdr->identifier = sec->identifier; sec_hdr->offset = sec->file_offset; sec_hdr->size = sec->sec_size; - sec_hdr->flags = SECTION_BOOTABLE; + sec_hdr->flags = (sec->is_data ? 0 : SECTION_BOOTABLE) + | (sec->is_cleartext ? SECTION_CLEARTEXT : 0); } static uint8_t instruction_checksum(struct sb_instruction_header_t *hdr) @@ -563,7 +648,8 @@ static void produce_section_tag_cmd(struct sb_section_t *sec, tag->hdr.flags = is_last ? SB_INST_LAST_TAG : 0; tag->identifier = sec->identifier; tag->len = sec->sec_size; - tag->flags = SECTION_BOOTABLE; + tag->flags = (sec->is_data ? 0 : SECTION_BOOTABLE) + | (sec->is_cleartext ? SECTION_CLEARTEXT : 0); tag->hdr.checksum = instruction_checksum(&tag->hdr); } @@ -671,21 +757,24 @@ static void produce_sb_file(struct sb_file_t *sb, const char *filename) { struct sb_inst_t *inst = &sb->sections[i].insts[j]; /* command */ - struct sb_instruction_common_t cmd; - produce_sb_instruction(inst, &cmd); - if(g_nr_keys > 0) - cbc_mac((byte *)&cmd, (byte *)&cmd, sizeof(cmd) / BLOCK_SIZE, - real_key, cur_cbc_mac, &cur_cbc_mac, 1); - sha_1_update(&file_sha1, (byte *)&cmd, sizeof(cmd)); - write(fd, &cmd, sizeof(cmd)); + if(inst->inst != SB_INST_DATA) + { + struct sb_instruction_common_t cmd; + produce_sb_instruction(inst, &cmd); + if(g_nr_keys > 0 && !sb->sections[i].is_cleartext) + cbc_mac((byte *)&cmd, (byte *)&cmd, sizeof(cmd) / BLOCK_SIZE, + real_key, cur_cbc_mac, &cur_cbc_mac, 1); + sha_1_update(&file_sha1, (byte *)&cmd, sizeof(cmd)); + write(fd, &cmd, sizeof(cmd)); + } /* data */ - if(inst->inst == SB_INST_LOAD) + if(inst->inst == SB_INST_LOAD || inst->inst == SB_INST_DATA) { uint32_t sz = inst->size + inst->padding_size; byte *data = xmalloc(sz); memcpy(data, inst->data, inst->size); memcpy(data + inst->size, inst->padding, inst->padding_size); - if(g_nr_keys > 0) + if(g_nr_keys > 0 && !sb->sections[i].is_cleartext) cbc_mac(data, data, sz / BLOCK_SIZE, real_key, cur_cbc_mac, &cur_cbc_mac, 1); sha_1_update(&file_sha1, data, sz); @@ -706,22 +795,94 @@ static void produce_sb_file(struct sb_file_t *sb, const char *filename) close(fd); } -int main(int argc, const char **argv) +void usage(void) +{ + printf("Usage: elftosb [options | file]...\n"); + printf("Options:\n"); + printf(" -?/--help:\t\tDisplay this message\n"); + printf(" -o \tSet output file\n"); + printf(" -c \tSet command file\n"); + printf(" -d/--debug\tEnable debug output\n"); + printf(" -k \t\tAdd key file\n"); + printf(" -z\t\tAdd zero key\n"); + exit(1); +} + +static byte g_zero_key[16] = {0}; + +int main(int argc, char **argv) { - if(argc != 4) + char *cmd_filename = NULL; + char *output_filename = NULL; + + while(1) { - printf("Usage: %s \n",*argv); - printf("To enable debug mode, set environement variable SB_DEBUG to YES\n"); - return 1; + static struct option long_options[] = + { + {"help", no_argument, 0, '?'}, + {"debug", no_argument, 0, 'd'}, + {0, 0, 0, 0} + }; + + int c = getopt_long(argc, argv, "?do:c:k:z", long_options, NULL); + if(c == -1) + break; + switch(c) + { + case 'd': + g_debug = true; + break; + case '?': + usage(); + break; + case 'o': + output_filename = optarg; + break; + case 'c': + cmd_filename = optarg; + break; + case 'k': + { + int kac; + key_array_t ka = read_keys(optarg, &kac); + add_keys(ka, kac); + break; + } + case 'z': + { + add_keys(&g_zero_key, 1); + break; + } + default: + abort(); + } } - if(strcasecmp(s_getenv("SB_DEBUG"), "YES") == 0) - g_debug = true; + if(!cmd_filename) + bug("You must specify a command file\n"); + if(!output_filename) + bug("You must specify an output file\n"); + + g_extern = &argv[optind]; + g_extern_count = argc - optind; + + if(g_debug) + { + printf("key: %d\n", g_nr_keys); + for(int i = 0; i < g_nr_keys; i++) + { + for(int j = 0; j < 16; j++) + printf(" %02x", g_key_array[i][j]); + printf("\n"); + } + + for(int i = 0; i < g_extern_count; i++) + printf("extern(%d)=%s\n", i, g_extern[i]); + } - g_key_array = read_keys(argv[2], &g_nr_keys); - struct cmd_file_t *cmd_file = db_parse_file(argv[1]); + struct cmd_file_t *cmd_file = db_parse_file(cmd_filename); struct sb_file_t *sb_file = apply_cmd_file(cmd_file); - produce_sb_file(sb_file, argv[3]); + produce_sb_file(sb_file, output_filename); return 0; } -- cgit v1.2.3