summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDominik Riebeling <Dominik.Riebeling@gmail.com>2020-08-08 21:25:50 +0200
committerDominik Riebeling <Dominik.Riebeling@gmail.com>2020-10-18 19:08:32 +0200
commit815b289cb3438ed566b3e9dc5074fe12e4b98f46 (patch)
treef4a92ac428098eda3a82da4549652b2ea079a599
parent387a45923c2ea6b223584815c7cd796ae064e22e (diff)
downloadrockbox-815b289cb3438ed566b3e9dc5074fe12e4b98f46.tar.gz
rockbox-815b289cb3438ed566b3e9dc5074fe12e4b98f46.tar.bz2
rockbox-815b289cb3438ed566b3e9dc5074fe12e4b98f46.zip
imxtools: Replace use of "byte" with its underlying uint8_t.
libtomcrypt uses a macro "byte" which conflicts with this type. Since the underlying type is uint8_t and there's no real benefit from using a custom type use the actual underlying type. Change-Id: I982c9b8bdcb657b99fa645a5235303af7afda25b
-rw-r--r--rbutil/mkimxboot/mkimxboot.c2
-rw-r--r--utils/imxtools/sbtools/crc.c4
-rw-r--r--utils/imxtools/sbtools/crypto.cpp28
-rw-r--r--utils/imxtools/sbtools/crypto.h22
-rw-r--r--utils/imxtools/sbtools/dbparser.c2
-rw-r--r--utils/imxtools/sbtools/misc.c8
-rw-r--r--utils/imxtools/sbtools/misc.h5
-rw-r--r--utils/imxtools/sbtools/sb.c68
8 files changed, 69 insertions, 70 deletions
diff --git a/rbutil/mkimxboot/mkimxboot.c b/rbutil/mkimxboot/mkimxboot.c
index 369c397d51..0483b5aeee 100644
--- a/rbutil/mkimxboot/mkimxboot.c
+++ b/rbutil/mkimxboot/mkimxboot.c
@@ -655,7 +655,7 @@ static enum imx_error_t find_model_by_md5sum(uint8_t file_md5sum[16], int *md5_i
}
for(int j = 0; j < 16; j++)
{
- byte a, b;
+ uint8_t a, b;
if(convxdigit(imx_sums[i].md5sum[2 * j], &a) || convxdigit(imx_sums[i].md5sum[2 * j + 1], &b))
{
printf("[ERR][INTERNAL] Bad checksum format: %s\n", imx_sums[i].md5sum);
diff --git a/utils/imxtools/sbtools/crc.c b/utils/imxtools/sbtools/crc.c
index eaf257ddfe..9f7146881b 100644
--- a/utils/imxtools/sbtools/crc.c
+++ b/utils/imxtools/sbtools/crc.c
@@ -68,12 +68,12 @@ static uint32_t crc_table[256] = {
0x0B8757BDA, 0x0B5365D03, 0x0B1F740B4
};
-uint32_t crc(byte *data, int size)
+uint32_t crc(uint8_t *data, int size)
{
return crc_continue(0xffffffff, data, size);
}
-uint32_t crc_continue(uint32_t previous_crc, byte *data, int size)
+uint32_t crc_continue(uint32_t previous_crc, uint8_t *data, int size)
{
uint32_t c = previous_crc;
/* normal CRC */
diff --git a/utils/imxtools/sbtools/crypto.cpp b/utils/imxtools/sbtools/crypto.cpp
index d7ef04f098..5563fcfd3b 100644
--- a/utils/imxtools/sbtools/crypto.cpp
+++ b/utils/imxtools/sbtools/crypto.cpp
@@ -30,19 +30,19 @@ namespace
{
enum crypto_method_t g_cur_method = CRYPTO_NONE;
-byte g_key[16];
+uint8_t g_key[16];
CBC_Mode<AES>::Encryption g_aes_enc;
CBC_Mode<AES>::Decryption g_aes_dec;
bool g_aes_enc_key_dirty; /* true of g_aes_enc key needs to be updated */
bool g_aes_dec_key_dirty; /* same for g_aes_dec */
int cbc_mac2(
- const byte *in_data, /* Input data */
- byte *out_data, /* Output data (or NULL) */
+ const uint8_t *in_data, /* Input data */
+ uint8_t *out_data, /* Output data (or NULL) */
int nr_blocks, /* Number of blocks to encrypt/decrypt (one block=16 bytes) */
- byte key[16], /* Key */
- byte iv[16], /* Initialisation Vector */
- byte (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
+ uint8_t key[16], /* Key */
+ uint8_t iv[16], /* Initialisation Vector */
+ uint8_t (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
bool encrypt /* 1 to encrypt, 0 to decrypt */
)
{
@@ -58,10 +58,10 @@ int cbc_mac2(
g_aes_enc_key_dirty = false;
}
g_aes_enc.Resynchronize(iv, 16);
- byte tmp[16];
+ uint8_t tmp[16];
/* we need some output buffer, either a temporary one if we are CBC-MACing
* only, or use output buffer if available */
- byte *out_ptr = (out_data == NULL) ? tmp : out_data;
+ uint8_t *out_ptr = (out_data == NULL) ? tmp : out_data;
while(nr_blocks-- > 0)
{
g_aes_enc.ProcessData(out_ptr, in_data, 16);
@@ -113,11 +113,11 @@ int crypto_setup(struct crypto_key_t *key)
}
int crypto_apply(
- byte *in_data, /* Input data */
- byte *out_data, /* Output data (or NULL) */
+ uint8_t *in_data, /* Input data */
+ uint8_t *out_data, /* Output data (or NULL) */
int nr_blocks, /* Number of blocks (one block=16 bytes) */
- byte iv[16], /* Key */
- byte (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
+ uint8_t iv[16], /* Key */
+ uint8_t (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
bool encrypt)
{
if(g_cur_method == CRYPTO_KEY)
@@ -131,7 +131,7 @@ void sha_1_init(struct sha_1_params_t *params)
params->object = new SHA1;
}
-void sha_1_update(struct sha_1_params_t *params, byte *buffer, int size)
+void sha_1_update(struct sha_1_params_t *params, uint8_t *buffer, int size)
{
reinterpret_cast<SHA1 *>(params->object)->Update(buffer, size);
}
@@ -143,7 +143,7 @@ void sha_1_finish(struct sha_1_params_t *params)
delete obj;
}
-void sha_1_output(struct sha_1_params_t *params, byte *out)
+void sha_1_output(struct sha_1_params_t *params, uint8_t *out)
{
memcpy(out, params->hash, 20);
}
diff --git a/utils/imxtools/sbtools/crypto.h b/utils/imxtools/sbtools/crypto.h
index 169197790b..bdb94bb881 100644
--- a/utils/imxtools/sbtools/crypto.h
+++ b/utils/imxtools/sbtools/crypto.h
@@ -30,8 +30,6 @@
extern "C" {
#endif
-typedef uint8_t byte;
-
/* crypto.cpp */
enum crypto_method_t
{
@@ -52,7 +50,7 @@ struct crypto_key_t
enum crypto_method_t method;
union
{
- byte key[16];
+ uint8_t key[16];
union xorcrypt_key_t xor_key[2];
}u;
};
@@ -68,28 +66,28 @@ int crypto_setup(struct crypto_key_t *key);
/* return 0 on success, <0 on error */
int crypto_apply(
- byte *in_data, /* Input data */
- byte *out_data, /* Output data (or NULL) */
+ uint8_t *in_data, /* Input data */
+ uint8_t *out_data, /* Output data (or NULL) */
int nr_blocks, /* Number of blocks (one block=16 bytes) */
- byte iv[16], /* IV */
- byte (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
+ uint8_t iv[16], /* IV */
+ uint8_t (*out_cbc_mac)[16], /* CBC-MAC of the result (or NULL) */
bool encrypt);
/* crc.c */
-uint32_t crc(byte *data, int size);
-uint32_t crc_continue(uint32_t previous_crc, byte *data, int size);
+uint32_t crc(uint8_t *data, int size);
+uint32_t crc_continue(uint32_t previous_crc, uint8_t *data, int size);
/* sha1.c */
struct sha_1_params_t
{
- byte hash[20]; /* final hash */
+ uint8_t hash[20]; /* final hash */
void *object; /* pointer to CryptoPP::SHA1 object */
};
void sha_1_init(struct sha_1_params_t *params);
-void sha_1_update(struct sha_1_params_t *params, byte *buffer, int size);
+void sha_1_update(struct sha_1_params_t *params, uint8_t *buffer, int size);
void sha_1_finish(struct sha_1_params_t *params);
-void sha_1_output(struct sha_1_params_t *params, byte *out);
+void sha_1_output(struct sha_1_params_t *params, uint8_t *out);
/* xorcrypt.c */
diff --git a/utils/imxtools/sbtools/dbparser.c b/utils/imxtools/sbtools/dbparser.c
index 1e5ee7244a..cfec7c2cd5 100644
--- a/utils/imxtools/sbtools/dbparser.c
+++ b/utils/imxtools/sbtools/dbparser.c
@@ -207,7 +207,7 @@ static void parse_number(struct context_t *ctx, struct lexem_t *lexem)
{
if(base == 10 && !isdigit(cur_char(ctx)))
break;
- byte v;
+ uint8_t v;
if(convxdigit(cur_char(ctx), &v))
break;
lexem->num = base * lexem->num + v;
diff --git a/utils/imxtools/sbtools/misc.c b/utils/imxtools/sbtools/misc.c
index 6216ae612b..c5832b6bb9 100644
--- a/utils/imxtools/sbtools/misc.c
+++ b/utils/imxtools/sbtools/misc.c
@@ -58,7 +58,7 @@ void *xmalloc(size_t s)
return r;
}
-int convxdigit(char digit, byte *val)
+int convxdigit(char digit, uint8_t *val)
{
if(digit >= '0' && digit <= '9')
{
@@ -127,7 +127,7 @@ bool parse_key(char **pstr, struct crypto_key_t *key)
{
for(int j = 0; j < 128; j++)
{
- byte a, b;
+ uint8_t a, b;
if(convxdigit(str[2 * j], &a) || convxdigit(str[2 * j + 1], &b))
return false;
key->u.xor_key[j / 64].key[j % 64] = (a << 4) | b;
@@ -143,7 +143,7 @@ bool parse_key(char **pstr, struct crypto_key_t *key)
return false;
for(int j = 0; j < 16; j++)
{
- byte a, b;
+ uint8_t a, b;
if(convxdigit(str[2 * j], &a) || convxdigit(str[2 * j + 1], &b))
return false;
key->u.key[j] = (a << 4) | b;
@@ -243,7 +243,7 @@ bool add_keys_from_file(const char *key_file)
return true;
}
-void print_hex(void *user, misc_printf_t printf, byte *data, int len, bool newline)
+void print_hex(void *user, misc_printf_t printf, uint8_t *data, int len, bool newline)
{
for(int i = 0; i < len; i++)
printf(user, "%02X ", data[i]);
diff --git a/utils/imxtools/sbtools/misc.h b/utils/imxtools/sbtools/misc.h
index 5c6b2fc007..65386a728f 100644
--- a/utils/imxtools/sbtools/misc.h
+++ b/utils/imxtools/sbtools/misc.h
@@ -22,6 +22,7 @@
#define __MISC_H__
#include <stdbool.h>
+#include <stdint.h>
#include "crypto.h"
#define _STR(a) #a
@@ -53,8 +54,8 @@ void augment_array_ex(void **arr, size_t elem_sz, int *cnt, int *capacity,
void *aug, int aug_cnt);
void generate_random_data(void *buf, size_t sz);
void *xmalloc(size_t s);
-int convxdigit(char digit, byte *val);
-void print_hex(void *user, misc_printf_t printf, byte *data, int len, bool newline);
+int convxdigit(char digit, uint8_t *val);
+void print_hex(void *user, misc_printf_t printf, uint8_t *data, int len, bool newline);
void add_keys(key_array_t ka, int kac);
bool parse_key(char **str, struct crypto_key_t *key);
bool add_keys_from_file(const char *key_file);
diff --git a/utils/imxtools/sbtools/sb.c b/utils/imxtools/sbtools/sb.c
index cbeacf9c3f..04acc2a6ad 100644
--- a/utils/imxtools/sbtools/sb.c
+++ b/utils/imxtools/sbtools/sb.c
@@ -223,7 +223,7 @@ static void produce_sb_section_header(struct sb_section_t *sec,
static uint8_t instruction_checksum(struct sb_instruction_header_t *hdr)
{
uint8_t sum = 90;
- byte *ptr = (byte *)hdr;
+ uint8_t *ptr = (uint8_t *)hdr;
for(int i = 1; i < 16; i++)
sum += ptr[i];
return sum;
@@ -287,8 +287,8 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
#define printf(c, ...) cprintf(u, false, c, __VA_ARGS__)
struct crypto_key_t real_key;
real_key.method = CRYPTO_KEY;
- byte crypto_iv[16];
- byte (*cbc_macs)[16] = xmalloc(16 * g_nr_keys);
+ uint8_t crypto_iv[16];
+ uint8_t (*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);
@@ -319,8 +319,8 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
struct sb_header_t sb_hdr;
produce_sb_header(sb, &sb_hdr);
/* allocate image */
- byte *buf = xmalloc(sb_hdr.image_size * BLOCK_SIZE);
- byte *buf_p = buf;
+ uint8_t *buf = xmalloc(sb_hdr.image_size * BLOCK_SIZE);
+ uint8_t *buf_p = buf;
#define write(p, sz) do { memcpy(buf_p, p, sz); buf_p += sz; } while(0)
#define check_crypto(expr) \
do { int err = expr; \
@@ -329,7 +329,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
cprintf(u, true, GREY, "Crypto error: %d\n", err); \
return SB_CRYPTO_ERROR; } } while(0)
- sha_1_update(&file_sha1, (byte *)&sb_hdr, sizeof(sb_hdr));
+ sha_1_update(&file_sha1, (uint8_t *)&sb_hdr, sizeof(sb_hdr));
write(&sb_hdr, sizeof(sb_hdr));
memcpy(crypto_iv, &sb_hdr, 16);
@@ -338,7 +338,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
for(int i = 0; i < g_nr_keys; i++)
{
check_crypto(crypto_setup(&g_key_array[i]));
- check_crypto(crypto_apply((byte *)&sb_hdr, NULL, sizeof(sb_hdr) / BLOCK_SIZE,
+ check_crypto(crypto_apply((uint8_t *)&sb_hdr, NULL, sizeof(sb_hdr) / BLOCK_SIZE,
cbc_macs[i], &cbc_macs[i], true));
}
@@ -347,13 +347,13 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
{
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));
+ sha_1_update(&file_sha1, (uint8_t *)&sb_sec_hdr, sizeof(sb_sec_hdr));
write(&sb_sec_hdr, sizeof(sb_sec_hdr));
/* update CBC-MACs */
for(int j = 0; j < g_nr_keys; j++)
{
check_crypto(crypto_setup(&g_key_array[j]));
- check_crypto(crypto_apply((byte *)&sb_sec_hdr, NULL,
+ check_crypto(crypto_apply((uint8_t *)&sb_sec_hdr, NULL,
sizeof(sb_sec_hdr) / BLOCK_SIZE, cbc_macs[j], &cbc_macs[j], true));
}
}
@@ -365,7 +365,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
check_crypto(crypto_setup(&g_key_array[i]));
check_crypto(crypto_apply(real_key.u.key, entry.key, 1, crypto_iv, NULL, true));
write(&entry, sizeof(entry));
- sha_1_update(&file_sha1, (byte *)&entry, sizeof(entry));
+ sha_1_update(&file_sha1, (uint8_t *)&entry, sizeof(entry));
}
/* HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK */
@@ -391,7 +391,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
unsigned init_gap = (sb->sections[0].file_offset - 1) * BLOCK_SIZE - (buf_p - buf);
if(init_gap > 0)
{
- byte *data = xmalloc(init_gap);
+ uint8_t *data = xmalloc(init_gap);
generate_random_data(data, init_gap);
sha_1_update(&file_sha1, data, init_gap);
write(data, init_gap);
@@ -407,13 +407,13 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
produce_section_tag_cmd(&sb->sections[i], &tag_cmd, (i + 1) == sb_hdr.nr_sections);
if(g_nr_keys > 0)
{
- check_crypto(crypto_apply((byte *)&tag_cmd, (byte *)&tag_cmd,
+ check_crypto(crypto_apply((uint8_t *)&tag_cmd, (uint8_t *)&tag_cmd,
sizeof(tag_cmd) / BLOCK_SIZE, crypto_iv, NULL, true));
}
- sha_1_update(&file_sha1, (byte *)&tag_cmd, sizeof(tag_cmd));
+ sha_1_update(&file_sha1, (uint8_t *)&tag_cmd, sizeof(tag_cmd));
write(&tag_cmd, sizeof(tag_cmd));
/* produce other commands */
- byte cur_cbc_mac[16];
+ uint8_t cur_cbc_mac[16];
memcpy(cur_cbc_mac, crypto_iv, 16);
for(int j = 0; j < sb->sections[i].nr_insts; j++)
{
@@ -425,17 +425,17 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
produce_sb_instruction(inst, &cmd, u, cprintf);
if(g_nr_keys > 0 && !sb->sections[i].is_cleartext)
{
- check_crypto(crypto_apply((byte *)&cmd, (byte *)&cmd,
+ check_crypto(crypto_apply((uint8_t *)&cmd, (uint8_t *)&cmd,
sizeof(cmd) / BLOCK_SIZE, cur_cbc_mac, &cur_cbc_mac, true));
}
- sha_1_update(&file_sha1, (byte *)&cmd, sizeof(cmd));
+ sha_1_update(&file_sha1, (uint8_t *)&cmd, sizeof(cmd));
write(&cmd, sizeof(cmd));
}
/* data */
if(inst->inst == SB_INST_LOAD || inst->inst == SB_INST_DATA)
{
uint32_t sz = inst->size + inst->padding_size;
- byte *data = xmalloc(sz);
+ uint8_t *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)
@@ -452,7 +452,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
uint32_t pad_size = sb->sections[i].pad_size;
if(sb->sections[i].is_data)
{
- byte *data = xmalloc(pad_size * BLOCK_SIZE);
+ uint8_t *data = xmalloc(pad_size * BLOCK_SIZE);
generate_random_data(data, pad_size * BLOCK_SIZE);
sha_1_update(&file_sha1, data, pad_size * BLOCK_SIZE);
write(data, pad_size * BLOCK_SIZE);
@@ -468,16 +468,16 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
cmd.hdr.checksum = instruction_checksum(&cmd.hdr);
if(g_nr_keys > 0 && !sb->sections[i].is_cleartext)
{
- check_crypto(crypto_apply((byte *)&cmd, (byte *)&cmd,
+ check_crypto(crypto_apply((uint8_t *)&cmd, (uint8_t *)&cmd,
sizeof(cmd) / BLOCK_SIZE, cur_cbc_mac, &cur_cbc_mac, true));
}
- sha_1_update(&file_sha1, (byte *)&cmd, sizeof(cmd));
+ sha_1_update(&file_sha1, (uint8_t *)&cmd, sizeof(cmd));
write(&cmd, sizeof(cmd));
}
}
}
/* write file SHA-1 */
- byte final_sig[32];
+ uint8_t final_sig[32];
sha_1_finish(&file_sha1);
sha_1_output(&file_sha1, final_sig);
generate_random_data(final_sig + 20, 12);
@@ -513,7 +513,7 @@ enum sb_error_t sb_write_file(struct sb_file_t *sb, const char *filename, void *
#undef printf
}
-static struct sb_section_t *read_section(bool data_sec, uint32_t id, byte *buf,
+static struct sb_section_t *read_section(bool data_sec, uint32_t id, uint8_t *buf,
int size, const char *indent, void *u, generic_printf_t cprintf, enum sb_error_t *err)
{
#define printf(c, ...) cprintf(u, false, c, __VA_ARGS__)
@@ -758,7 +758,7 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
fatal(SB_CRYPTO_ERROR, "Crypto error: %d\n", err); } while(0)
struct sha_1_params_t sha_1_params;
- byte (*cbcmacs)[16] = xmalloc(16 * g_nr_keys);
+ uint8_t (*cbcmacs)[16] = xmalloc(16 * g_nr_keys);
sb_file = xmalloc(sizeof(struct sb_file_t));
memset(sb_file, 0, sizeof(struct sb_file_t));
struct sb_header_t *sb_header = (struct sb_header_t *)buf;
@@ -790,10 +790,10 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
printf(GREEN, " SB version: ");
printf(YELLOW, "%d.%d\n", sb_header->major_ver, sb_header->minor_ver);
printf(GREEN, " Header SHA-1: ");
- byte *hdr_sha1 = sb_header->sha1_header;
+ uint8_t *hdr_sha1 = sb_header->sha1_header;
print_hex(YELLOW, hdr_sha1, 20, false);
/* Check SHA1 sum */
- byte computed_sha1[20];
+ uint8_t computed_sha1[20];
sha_1_init(&sha_1_params);
sha_1_update(&sha_1_params, &sb_header->signature[0],
sizeof(struct sb_header_t) - sizeof(sb_header->sha1_header));
@@ -876,7 +876,7 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
print_key(&printer, sb_printer, &g_key_array[i], true);
printf(GREEN, " CBC-MAC: ");
/* check it */
- byte zero[16];
+ uint8_t zero[16];
memset(zero, 0, 16);
check_crypto(crypto_setup(&g_key_array[i]));
check_crypto(crypto_apply(buf, NULL, sb_header->header_size +
@@ -906,8 +906,8 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
{
printf(RED, " Match\n");
/* decrypt */
- byte decrypted_key[16];
- byte iv[16];
+ uint8_t decrypted_key[16];
+ uint8_t iv[16];
memcpy(iv, buf, 16); /* uses the first 16-bytes of SHA-1 sig as IV */
check_crypto(crypto_setup(&g_key_array[idx]));
check_crypto(crypto_apply(dict_entry->key, decrypted_key, 1, iv, NULL, false));
@@ -1008,7 +1008,7 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
}
/* save it */
- byte *sec = xmalloc(size);
+ uint8_t *sec = xmalloc(size);
if(encrypted)
check_crypto(crypto_apply(buf + pos, sec, size / BLOCK_SIZE, buf, NULL, false));
else
@@ -1034,13 +1034,13 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
/* advanced raw mode */
printf(BLUE, "Commands\n");
uint32_t offset = sb_header->first_boot_tag_off * BLOCK_SIZE;
- byte iv[16];
+ uint8_t iv[16];
const char *indent = " ";
while(true)
{
/* restart with IV */
memcpy(iv, buf, 16);
- byte cmd[BLOCK_SIZE];
+ uint8_t cmd[BLOCK_SIZE];
if(sb_header->nr_keys > 0)
check_crypto(crypto_apply(buf + offset, cmd, 1, iv, &iv, false));
else
@@ -1106,7 +1106,7 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
}
/* save it */
- byte *sec = xmalloc(size);
+ uint8_t *sec = xmalloc(size);
if(encrypted)
check_crypto(crypto_apply(buf + pos, sec, size / BLOCK_SIZE, buf, NULL, false));
else
@@ -1147,11 +1147,11 @@ struct sb_file_t *sb_read_memory(void *_buf, size_t filesize, unsigned flags, vo
/* final signature */
printf(BLUE, "Final signature:\n");
- byte decrypted_block[32];
+ uint8_t decrypted_block[32];
if(sb_header->nr_keys > 0)
{
printf(GREEN, " Encrypted SHA-1:\n");
- byte *encrypted_block = &buf[filesize - 32];
+ uint8_t *encrypted_block = &buf[filesize - 32];
printf(OFF, " ");
print_hex(YELLOW, encrypted_block, 16, true);
printf(OFF, " ");