void memory_mempass(void)
{
uint8_t mempass[88] = {0};
#ifndef TESTING
// Encrypt data saved to memory using an AES key obfuscated by the
// compilation time and date, which is used to 'randomly' read bytes
// (i.e. the AES key) from the MCU code in flash memory.
uint8_t *mp = mempass;
int r[8] = {0};
char c[3] = {0};
sscanf(__TIME__, "%d:%d:%d", &r[0], &r[1], &r[2]);
sscanf(__DATE__, "%c%c%c %d ", &c[0], &c[1], &c[2], &r[3]);
r[7] = __LINE__ % 1028;
r[4] = c[0];
r[5] = c[1];
r[6] = c[2];
memcpy(mp + 0, (uint32_t *)IFLASH0_ADDR + r[0] * r[0], 8);
memcpy(mp + 8, (uint32_t *)IFLASH0_ADDR + r[0] * r[1], 8);
memcpy(mp + 16, (uint32_t *)IFLASH0_ADDR + r[0] * r[2], 8);
memcpy(mp + 24, (uint32_t *)IFLASH0_ADDR + r[1] * r[1], 8);
memcpy(mp + 32, (uint32_t *)IFLASH0_ADDR + r[1] * r[2], 8);
memcpy(mp + 40, (uint32_t *)IFLASH0_ADDR + r[2] * r[2], 8);
memcpy(mp + 48, (uint32_t *)IFLASH0_ADDR + r[0] * r[3], 8);
memcpy(mp + 56, (uint32_t *)IFLASH0_ADDR + r[0] * r[4], 8);
memcpy(mp + 64, (uint32_t *)IFLASH0_ADDR + r[0] * r[5], 8);
memcpy(mp + 72, (uint32_t *)IFLASH0_ADDR + r[0] * r[6], 8);
memcpy(mp + 80, (uint32_t *)IFLASH0_ADDR + r[2] + r[7], 8);
#endif
memory_write_aeskey(utils_uint8_to_hex(mempass, sizeof(mempass)), sizeof(mempass) * 2,
PASSWORD_MEMORY);
memset(mempass, 0, sizeof(mempass));
utils_clear_buffers();
}
void test_utils()
{
char hash[] = "28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1";
uint8_t *hash_bin = utils_hex_to_uint8(hash);
char *new = utils_uint8_to_hex(hash_bin, 32);
assert(strncmp(new, hash, 64) == 0);
uint64_t bigint = 0xFFFFFFFFFFFFFFFF;
char vint[255];
int outlen;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 16);
assert(strncmp("ffffffffffffffffff", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 2);
assert(strncmp("fa", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 4);
assert(strncmp("fdfa0f", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFFFFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 8);
assert(strncmp("fefaff0f00", vint, outlen) == 0);
char varint0[] = "fa";
utils_varint_to_uint64(varint0, &bigint);
assert(bigint == 250);
char varint1[] = "ffffffffffffffffff";
utils_varint_to_uint64(varint1, &bigint);
assert(bigint == 0xFFFFFFFFFFFFFFFF);
char varint2[] = "fdfa0f";
utils_varint_to_uint64(varint2, &bigint);
assert(bigint == 4090);
char varint3[] = "fefaff0f00";
utils_varint_to_uint64(varint3, &bigint);
assert(bigint == 1048570);
unsigned char data[] = {0x00, 0xFF, 0x00, 0xAA, 0x00, 0xFF, 0x00, 0xAA};
char hex[sizeof(data)*2+1];
utils_bin_to_hex(data, sizeof(data), hex);
assert(strcmp(hex, "00ff00aa00ff00aa") == 0);
unsigned char data2[sizeof(data)];
utils_hex_to_bin(hex, data2, strlen(hex), &outlen);
assert(outlen == 8);
assert(memcmp(data, data2, outlen) == 0);
}
// Encrypted storage
static int memory_eeprom_crypt(const uint8_t *write_b, uint8_t *read_b,
const int32_t addr)
{
int enc_len, dec_len;
char *enc, *dec, enc_r[MEM_PAGE_LEN * 4 + 1] = {0};
if (read_b) {
enc = aes_cbc_b64_encrypt((unsigned char *)utils_uint8_to_hex(read_b, MEM_PAGE_LEN),
MEM_PAGE_LEN * 2, &enc_len, PASSWORD_MEMORY);
if (!enc) {
goto err;
}
memcpy(enc_r, enc, enc_len);
free(enc);
}
if (write_b) {
char enc_w[MEM_PAGE_LEN * 4 + 1] = {0};
enc = aes_cbc_b64_encrypt((unsigned char *)utils_uint8_to_hex(write_b, MEM_PAGE_LEN),
MEM_PAGE_LEN * 2, &enc_len, PASSWORD_MEMORY);
if (!enc) {
goto err;
}
memcpy(enc_w, enc, enc_len);
free(enc);
if (memory_eeprom((uint8_t *)enc_w, (uint8_t *)enc_r, addr,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN, (uint8_t *)enc_r + MEM_PAGE_LEN,
addr + MEM_PAGE_LEN, MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN * 2,
(uint8_t *)enc_r + MEM_PAGE_LEN * 2, addr + MEM_PAGE_LEN * 2,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN * 3,
(uint8_t *)enc_r + MEM_PAGE_LEN * 3, addr + MEM_PAGE_LEN * 3,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
} else {
if (memory_eeprom(NULL, (uint8_t *)enc_r, addr, MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN, addr + MEM_PAGE_LEN,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN * 2, addr + MEM_PAGE_LEN * 2,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN * 3, addr + MEM_PAGE_LEN * 3,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
}
dec = aes_cbc_b64_decrypt((unsigned char *)enc_r, MEM_PAGE_LEN * 4, &dec_len,
PASSWORD_MEMORY);
if (!dec) {
goto err;
}
memcpy(read_b, utils_hex_to_uint8(dec), MEM_PAGE_LEN);
memset(dec, 0, dec_len);
free(dec);
utils_clear_buffers();
return STATUS_SUCCESS;
err:
utils_clear_buffers();
return STATUS_ERROR;
}
