forked from len0rd/rockbox
sbtools: move sb file production to its own file with a clean api, factor key reading even more
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30851 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Amaury Pouly
parent
93c6c79e8d
commit
d2a58f3aad
7 changed files with 574 additions and 536 deletions
|
|
@ -35,6 +35,7 @@
|
|||
#include "sb.h"
|
||||
#include "dbparser.h"
|
||||
#include "misc.h"
|
||||
#include "sb.h"
|
||||
|
||||
char **g_extern;
|
||||
int g_extern_count;
|
||||
|
|
@ -51,47 +52,6 @@ int g_extern_count;
|
|||
* command file to sb conversion
|
||||
*/
|
||||
|
||||
#define SB_INST_DATA 0xff
|
||||
|
||||
struct sb_inst_t
|
||||
{
|
||||
uint8_t inst; /* SB_INST_* */
|
||||
uint32_t size;
|
||||
// <union>
|
||||
void *data;
|
||||
uint32_t pattern;
|
||||
uint32_t addr;
|
||||
// </union>
|
||||
uint32_t argument; // for call and jump
|
||||
/* for production use */
|
||||
uint32_t padding_size;
|
||||
uint8_t *padding;
|
||||
};
|
||||
|
||||
struct sb_section_t
|
||||
{
|
||||
uint32_t identifier;
|
||||
bool is_data;
|
||||
bool is_cleartext;
|
||||
uint32_t alignment;
|
||||
// data sections are handled as a single SB_INST_DATA virtual instruction
|
||||
int nr_insts;
|
||||
struct sb_inst_t *insts;
|
||||
/* for production use */
|
||||
uint32_t file_offset; /* in blocks */
|
||||
uint32_t sec_size; /* in blocks */
|
||||
};
|
||||
|
||||
struct sb_file_t
|
||||
{
|
||||
int nr_sections;
|
||||
struct sb_section_t *sections;
|
||||
struct sb_version_t product_ver;
|
||||
struct sb_version_t component_ver;
|
||||
/* for production use */
|
||||
uint32_t image_size; /* in blocks */
|
||||
};
|
||||
|
||||
static bool elf_read(void *user, uint32_t addr, void *buf, size_t count)
|
||||
{
|
||||
if(fseek((FILE *)user, addr, SEEK_SET) == -1)
|
||||
|
|
@ -355,443 +315,6 @@ static struct sb_file_t *apply_cmd_file(struct cmd_file_t *cmd_file)
|
|||
return sb;
|
||||
}
|
||||
|
||||
/**
|
||||
* SB file production
|
||||
*/
|
||||
|
||||
/* helper function to augment an array, free old array */
|
||||
void *augment_array(void *arr, size_t elem_sz, size_t cnt, void *aug, size_t aug_cnt)
|
||||
{
|
||||
void *p = xmalloc(elem_sz * (cnt + aug_cnt));
|
||||
memcpy(p, arr, elem_sz * cnt);
|
||||
memcpy(p + elem_sz * cnt, aug, elem_sz * aug_cnt);
|
||||
free(arr);
|
||||
return p;
|
||||
}
|
||||
|
||||
static void fill_gaps(struct sb_file_t *sb)
|
||||
{
|
||||
for(int i = 0; i < sb->nr_sections; i++)
|
||||
{
|
||||
struct sb_section_t *sec = &sb->sections[i];
|
||||
for(int j = 0; j < sec->nr_insts; j++)
|
||||
{
|
||||
struct sb_inst_t *inst = &sec->insts[j];
|
||||
if(inst->inst != SB_INST_LOAD)
|
||||
continue;
|
||||
inst->padding_size = ROUND_UP(inst->size, BLOCK_SIZE) - inst->size;
|
||||
/* emulate elftosb2 behaviour: generate 15 bytes (that's a safe maximum) */
|
||||
inst->padding = xmalloc(15);
|
||||
generate_random_data(inst->padding, 15);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void compute_sb_offsets(struct sb_file_t *sb)
|
||||
{
|
||||
sb->image_size = 0;
|
||||
/* sb header */
|
||||
sb->image_size += sizeof(struct sb_header_t) / BLOCK_SIZE;
|
||||
/* sections headers */
|
||||
sb->image_size += sb->nr_sections * sizeof(struct sb_section_header_t) / BLOCK_SIZE;
|
||||
/* key dictionary */
|
||||
sb->image_size += g_nr_keys * sizeof(struct sb_key_dictionary_entry_t) / BLOCK_SIZE;
|
||||
/* sections */
|
||||
for(int i = 0; i < sb->nr_sections; i++)
|
||||
{
|
||||
/* each section has a preliminary TAG command */
|
||||
sb->image_size += sizeof(struct sb_instruction_tag_t) / BLOCK_SIZE;
|
||||
/* we might need to pad the section so compute next alignment */
|
||||
uint32_t alignment = BLOCK_SIZE;
|
||||
if((i + 1) < sb->nr_sections)
|
||||
alignment = sb->sections[i + 1].alignment;
|
||||
alignment /= BLOCK_SIZE; /* alignment in block sizes */
|
||||
|
||||
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++)
|
||||
{
|
||||
struct sb_inst_t *inst = &sec->insts[j];
|
||||
if(inst->inst == SB_INST_CALL || inst->inst == SB_INST_JUMP)
|
||||
{
|
||||
if(g_debug)
|
||||
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;
|
||||
}
|
||||
else if(inst->inst == SB_INST_FILL)
|
||||
{
|
||||
if(g_debug)
|
||||
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;
|
||||
}
|
||||
else if(inst->inst == SB_INST_LOAD)
|
||||
{
|
||||
if(g_debug)
|
||||
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;
|
||||
/* data + alignment */
|
||||
sb->image_size += (inst->size + inst->padding_size) / BLOCK_SIZE;
|
||||
sec->sec_size += (inst->size + inst->padding_size) / BLOCK_SIZE;
|
||||
}
|
||||
else if(inst->inst == SB_INST_MODE)
|
||||
{
|
||||
if(g_debug)
|
||||
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);
|
||||
}
|
||||
/* we need to make sure next section starts on the right alignment.
|
||||
* Since each section starts with a boot tag, we thus need to ensure
|
||||
* that this sections ends at adress X such that X+BLOCK_SIZE is
|
||||
* a multiple of the alignment.
|
||||
* For data sections, we just add random data, otherwise we add nops */
|
||||
uint32_t missing_sz = alignment - ((sb->image_size + 1) % alignment);
|
||||
if(missing_sz != alignment)
|
||||
{
|
||||
struct sb_inst_t *aug_insts;
|
||||
int nr_aug_insts = 0;
|
||||
|
||||
if(sb->sections[i].is_data)
|
||||
{
|
||||
nr_aug_insts = 1;
|
||||
aug_insts = malloc(sizeof(struct sb_inst_t));
|
||||
memset(aug_insts, 0, sizeof(struct sb_inst_t));
|
||||
aug_insts[0].inst = SB_INST_DATA;
|
||||
aug_insts[0].size = missing_sz * BLOCK_SIZE;
|
||||
aug_insts[0].data = xmalloc(missing_sz * BLOCK_SIZE);
|
||||
generate_random_data(aug_insts[0].data, missing_sz * BLOCK_SIZE);
|
||||
if(g_debug)
|
||||
printf(" DATA | size=0x%08x\n", aug_insts[0].size);
|
||||
}
|
||||
else
|
||||
{
|
||||
nr_aug_insts = missing_sz;
|
||||
aug_insts = malloc(sizeof(struct sb_inst_t) * nr_aug_insts);
|
||||
memset(aug_insts, 0, sizeof(struct sb_inst_t) * nr_aug_insts);
|
||||
for(int j = 0; j < nr_aug_insts; j++)
|
||||
{
|
||||
aug_insts[j].inst = SB_INST_NOP;
|
||||
if(g_debug)
|
||||
printf(" NOOP\n");
|
||||
}
|
||||
}
|
||||
|
||||
sb->sections[i].insts = augment_array(sb->sections[i].insts, sizeof(struct sb_inst_t),
|
||||
sb->sections[i].nr_insts, aug_insts, nr_aug_insts);
|
||||
sb->sections[i].nr_insts += nr_aug_insts;
|
||||
|
||||
/* augment image and section size */
|
||||
sb->image_size += missing_sz;
|
||||
sec->sec_size += missing_sz;
|
||||
}
|
||||
}
|
||||
/* final signature */
|
||||
sb->image_size += 2;
|
||||
}
|
||||
|
||||
static uint64_t generate_timestamp()
|
||||
{
|
||||
struct tm tm_base = {0, 0, 0, 1, 0, 100, 0, 0, 1, 0, NULL}; /* 2000/1/1 0:00:00 */
|
||||
time_t t = time(NULL) - mktime(&tm_base);
|
||||
return (uint64_t)t * 1000000L;
|
||||
}
|
||||
|
||||
static uint16_t swap16(uint16_t t)
|
||||
{
|
||||
return (t << 8) | (t >> 8);
|
||||
}
|
||||
|
||||
static void fix_version(struct sb_version_t *ver)
|
||||
{
|
||||
ver->major = swap16(ver->major);
|
||||
ver->minor = swap16(ver->minor);
|
||||
ver->revision = swap16(ver->revision);
|
||||
}
|
||||
|
||||
static void produce_sb_header(struct sb_file_t *sb, struct sb_header_t *sb_hdr)
|
||||
{
|
||||
struct sha_1_params_t sha_1_params;
|
||||
|
||||
sb_hdr->signature[0] = 'S';
|
||||
sb_hdr->signature[1] = 'T';
|
||||
sb_hdr->signature[2] = 'M';
|
||||
sb_hdr->signature[3] = 'P';
|
||||
sb_hdr->major_ver = IMAGE_MAJOR_VERSION;
|
||||
sb_hdr->minor_ver = IMAGE_MINOR_VERSION;
|
||||
sb_hdr->flags = 0;
|
||||
sb_hdr->image_size = sb->image_size;
|
||||
sb_hdr->header_size = sizeof(struct sb_header_t) / BLOCK_SIZE;
|
||||
sb_hdr->first_boot_sec_id = sb->sections[0].identifier;
|
||||
sb_hdr->nr_keys = g_nr_keys;
|
||||
sb_hdr->nr_sections = sb->nr_sections;
|
||||
sb_hdr->sec_hdr_size = sizeof(struct sb_section_header_t) / BLOCK_SIZE;
|
||||
sb_hdr->key_dict_off = sb_hdr->header_size +
|
||||
sb_hdr->sec_hdr_size * sb_hdr->nr_sections;
|
||||
sb_hdr->first_boot_tag_off = sb_hdr->key_dict_off +
|
||||
sizeof(struct sb_key_dictionary_entry_t) * sb_hdr->nr_keys / BLOCK_SIZE;
|
||||
generate_random_data(sb_hdr->rand_pad0, sizeof(sb_hdr->rand_pad0));
|
||||
generate_random_data(sb_hdr->rand_pad1, sizeof(sb_hdr->rand_pad1));
|
||||
sb_hdr->timestamp = generate_timestamp();
|
||||
sb_hdr->product_ver = sb->product_ver;
|
||||
fix_version(&sb_hdr->product_ver);
|
||||
sb_hdr->component_ver = sb->component_ver;
|
||||
fix_version(&sb_hdr->component_ver);
|
||||
sb_hdr->drive_tag = 0;
|
||||
|
||||
sha_1_init(&sha_1_params);
|
||||
sha_1_update(&sha_1_params, &sb_hdr->signature[0],
|
||||
sizeof(struct sb_header_t) - sizeof(sb_hdr->sha1_header));
|
||||
sha_1_finish(&sha_1_params);
|
||||
sha_1_output(&sha_1_params, sb_hdr->sha1_header);
|
||||
}
|
||||
|
||||
static void produce_sb_section_header(struct sb_section_t *sec,
|
||||
struct sb_section_header_t *sec_hdr)
|
||||
{
|
||||
sec_hdr->identifier = sec->identifier;
|
||||
sec_hdr->offset = sec->file_offset;
|
||||
sec_hdr->size = sec->sec_size;
|
||||
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)
|
||||
{
|
||||
uint8_t sum = 90;
|
||||
byte *ptr = (byte *)hdr;
|
||||
for(int i = 1; i < 16; i++)
|
||||
sum += ptr[i];
|
||||
return sum;
|
||||
}
|
||||
|
||||
static void produce_section_tag_cmd(struct sb_section_t *sec,
|
||||
struct sb_instruction_tag_t *tag, bool is_last)
|
||||
{
|
||||
tag->hdr.opcode = SB_INST_TAG;
|
||||
tag->hdr.flags = is_last ? SB_INST_LAST_TAG : 0;
|
||||
tag->identifier = sec->identifier;
|
||||
tag->len = sec->sec_size;
|
||||
tag->flags = (sec->is_data ? 0 : SECTION_BOOTABLE)
|
||||
| (sec->is_cleartext ? SECTION_CLEARTEXT : 0);
|
||||
tag->hdr.checksum = instruction_checksum(&tag->hdr);
|
||||
}
|
||||
|
||||
void produce_sb_instruction(struct sb_inst_t *inst,
|
||||
struct sb_instruction_common_t *cmd)
|
||||
{
|
||||
memset(cmd, 0, sizeof(struct sb_instruction_common_t));
|
||||
cmd->hdr.opcode = inst->inst;
|
||||
switch(inst->inst)
|
||||
{
|
||||
case SB_INST_CALL:
|
||||
case SB_INST_JUMP:
|
||||
cmd->addr = inst->addr;
|
||||
cmd->data = inst->argument;
|
||||
break;
|
||||
case SB_INST_FILL:
|
||||
cmd->addr = inst->addr;
|
||||
cmd->len = inst->size;
|
||||
cmd->data = inst->pattern;
|
||||
break;
|
||||
case SB_INST_LOAD:
|
||||
cmd->addr = inst->addr;
|
||||
cmd->len = inst->size;
|
||||
cmd->data = crc_continue(crc(inst->data, inst->size),
|
||||
inst->padding, inst->padding_size);
|
||||
break;
|
||||
case SB_INST_MODE:
|
||||
cmd->data = inst->addr;
|
||||
break;
|
||||
case SB_INST_NOP:
|
||||
break;
|
||||
default:
|
||||
bug("die\n");
|
||||
}
|
||||
cmd->hdr.checksum = instruction_checksum(&cmd->hdr);
|
||||
}
|
||||
|
||||
static void produce_sb_file(struct sb_file_t *sb, const char *filename)
|
||||
{
|
||||
FILE *fd = fopen(filename, "wb");
|
||||
if(fd == NULL)
|
||||
bugp("cannot open output file");
|
||||
|
||||
struct crypto_key_t real_key;
|
||||
real_key.method = CRYPTO_KEY;
|
||||
byte crypto_iv[16];
|
||||
byte (*cbc_macs)[16] = xmalloc(16 * g_nr_keys);
|
||||
/* init CBC-MACs */
|
||||
for(int i = 0; i < g_nr_keys; i++)
|
||||
memset(cbc_macs[i], 0, 16);
|
||||
|
||||
fill_gaps(sb);
|
||||
compute_sb_offsets(sb);
|
||||
|
||||
generate_random_data(real_key.u.key, 16);
|
||||
|
||||
/* global SHA-1 */
|
||||
struct sha_1_params_t file_sha1;
|
||||
sha_1_init(&file_sha1);
|
||||
/* produce and write header */
|
||||
struct sb_header_t sb_hdr;
|
||||
produce_sb_header(sb, &sb_hdr);
|
||||
sha_1_update(&file_sha1, (byte *)&sb_hdr, sizeof(sb_hdr));
|
||||
fwrite(&sb_hdr, 1, sizeof(sb_hdr), fd);
|
||||
|
||||
memcpy(crypto_iv, &sb_hdr, 16);
|
||||
|
||||
/* update CBC-MACs */
|
||||
for(int i = 0; i < g_nr_keys; i++)
|
||||
crypto_cbc((byte *)&sb_hdr, NULL, sizeof(sb_hdr) / BLOCK_SIZE, &g_key_array[i],
|
||||
cbc_macs[i], &cbc_macs[i], 1);
|
||||
|
||||
/* produce and write section headers */
|
||||
for(int i = 0; i < sb_hdr.nr_sections; i++)
|
||||
{
|
||||
struct sb_section_header_t sb_sec_hdr;
|
||||
produce_sb_section_header(&sb->sections[i], &sb_sec_hdr);
|
||||
sha_1_update(&file_sha1, (byte *)&sb_sec_hdr, sizeof(sb_sec_hdr));
|
||||
fwrite(&sb_sec_hdr, 1, sizeof(sb_sec_hdr), fd);
|
||||
/* update CBC-MACs */
|
||||
for(int j = 0; j < g_nr_keys; j++)
|
||||
crypto_cbc((byte *)&sb_sec_hdr, NULL, sizeof(sb_sec_hdr) / BLOCK_SIZE,
|
||||
&g_key_array[j], cbc_macs[j], &cbc_macs[j], 1);
|
||||
}
|
||||
/* produce key dictionary */
|
||||
for(int i = 0; i < g_nr_keys; i++)
|
||||
{
|
||||
struct sb_key_dictionary_entry_t entry;
|
||||
memcpy(entry.hdr_cbc_mac, cbc_macs[i], 16);
|
||||
crypto_cbc(real_key.u.key, entry.key, 1, &g_key_array[i],
|
||||
crypto_iv, NULL, 1);
|
||||
|
||||
fwrite(&entry, 1, sizeof(entry), fd);
|
||||
sha_1_update(&file_sha1, (byte *)&entry, sizeof(entry));
|
||||
}
|
||||
|
||||
/* HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK */
|
||||
/* Image crafting, don't use it unless you understand what you do */
|
||||
if(strlen(s_getenv("SB_OVERRIDE_REAL_KEY")) != 0)
|
||||
{
|
||||
const char *key = s_getenv("SB_OVERRIDE_REAL_KEY");
|
||||
if(strlen(key) != 32)
|
||||
bugp("Cannot override real key: invalid key length\n");
|
||||
for(int i = 0; i < 16; i++)
|
||||
{
|
||||
byte a, b;
|
||||
if(convxdigit(key[2 * i], &a) || convxdigit(key[2 * i + 1], &b))
|
||||
bugp("Cannot override real key: key should be a 128-bit key written in hexadecimal\n");
|
||||
real_key.u.key[i] = (a << 4) | b;
|
||||
}
|
||||
}
|
||||
if(strlen(s_getenv("SB_OVERRIDE_IV")) != 0)
|
||||
{
|
||||
const char *iv = s_getenv("SB_OVERRIDE_IV");
|
||||
if(strlen(iv) != 32)
|
||||
bugp("Cannot override iv: invalid key length\n");
|
||||
for(int i = 0; i < 16; i++)
|
||||
{
|
||||
byte a, b;
|
||||
if(convxdigit(iv[2 * i], &a) || convxdigit(iv[2 * i + 1], &b))
|
||||
bugp("Cannot override iv: key should be a 128-bit key written in hexadecimal\n");
|
||||
crypto_iv[i] = (a << 4) | b;
|
||||
}
|
||||
|
||||
}
|
||||
/* KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH KCAH */
|
||||
if(g_debug)
|
||||
{
|
||||
printf("Real key: ");
|
||||
for(int j = 0; j < 16; j++)
|
||||
printf("%02x", real_key.u.key[j]);
|
||||
printf("\n");
|
||||
printf("IV : ");
|
||||
for(int j = 0; j < 16; j++)
|
||||
printf("%02x", crypto_iv[j]);
|
||||
printf("\n");
|
||||
}
|
||||
/* produce sections data */
|
||||
for(int i = 0; i< sb_hdr.nr_sections; i++)
|
||||
{
|
||||
/* produce tag command */
|
||||
struct sb_instruction_tag_t tag_cmd;
|
||||
produce_section_tag_cmd(&sb->sections[i], &tag_cmd, (i + 1) == sb_hdr.nr_sections);
|
||||
if(g_nr_keys > 0)
|
||||
crypto_cbc((byte *)&tag_cmd, (byte *)&tag_cmd, sizeof(tag_cmd) / BLOCK_SIZE,
|
||||
&real_key, crypto_iv, NULL, 1);
|
||||
sha_1_update(&file_sha1, (byte *)&tag_cmd, sizeof(tag_cmd));
|
||||
fwrite(&tag_cmd, 1, sizeof(tag_cmd), fd);
|
||||
/* produce other commands */
|
||||
byte cur_cbc_mac[16];
|
||||
memcpy(cur_cbc_mac, crypto_iv, 16);
|
||||
for(int j = 0; j < sb->sections[i].nr_insts; j++)
|
||||
{
|
||||
struct sb_inst_t *inst = &sb->sections[i].insts[j];
|
||||
/* command */
|
||||
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)
|
||||
crypto_cbc((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));
|
||||
fwrite(&cmd, 1, sizeof(cmd), fd);
|
||||
}
|
||||
/* data */
|
||||
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 && !sb->sections[i].is_cleartext)
|
||||
crypto_cbc(data, data, sz / BLOCK_SIZE,
|
||||
&real_key, cur_cbc_mac, &cur_cbc_mac, 1);
|
||||
sha_1_update(&file_sha1, data, sz);
|
||||
fwrite(data, 1, sz, fd);
|
||||
free(data);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* write file SHA-1 */
|
||||
byte final_sig[32];
|
||||
sha_1_finish(&file_sha1);
|
||||
sha_1_output(&file_sha1, final_sig);
|
||||
generate_random_data(final_sig + 20, 12);
|
||||
if(g_nr_keys > 0)
|
||||
crypto_cbc(final_sig, final_sig, 2, &real_key, crypto_iv, NULL, 1);
|
||||
fwrite(final_sig, 1, 32, fd);
|
||||
|
||||
fclose(fd);
|
||||
}
|
||||
|
||||
void usage(void)
|
||||
{
|
||||
printf("Usage: elftosb [options | file]...\n");
|
||||
|
|
@ -848,9 +371,7 @@ int main(int argc, char **argv)
|
|||
break;
|
||||
case 'k':
|
||||
{
|
||||
int kac;
|
||||
key_array_t ka = read_keys(optarg, &kac);
|
||||
add_keys(ka, kac);
|
||||
add_keys_from_file(optarg);
|
||||
break;
|
||||
}
|
||||
case 'z':
|
||||
|
|
@ -922,7 +443,7 @@ int main(int argc, char **argv)
|
|||
|
||||
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, output_filename);
|
||||
sb_produce_file(sb_file, output_filename);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue