int images_verify(Image* image) {
uint8_t hash[0x40];
int retVal = 0;
if(image == NULL) {
return 1;
}
mtd_t *dev = images_device();
if(!dev)
{
return 1;
}
mtd_prepare(dev);
if(!image->hashMatch)
retVal |= 1 << 2;
void* data = malloc(image->padded);
mtd_read(dev, data, image->offset + sizeof(Img2Header), image->padded);
calculateDataHash(data, image->padded, hash);
free(data);
if(memcmp(hash, image->dataHash, 0x40) != 0)
retVal |= 1 << 3;
mtd_finish(dev);
return retVal;
}
void images_duplicate_at(Image* image, uint32_t type, int index, int offset) {
if(image == NULL)
return;
uint32_t totalLen = sizeof(Img2Header) + image->padded;
uint8_t* buffer = (uint8_t*) malloc(totalLen);
nor_read(buffer, image->offset, totalLen);
Img2Header* header = (Img2Header*) buffer;
header->imageType = type;
if(index >= 0)
header->index = index;
calculateDataHash(buffer + sizeof(Img2Header), image->padded, header->dataHash);
uint32_t checksum = 0;
crc32(&checksum, buffer, 0x64);
header->header_checksum = checksum;
calculateHash(header, header->hash);
nor_write(buffer, offset, totalLen);
free(buffer);
images_release();
images_setup();
}
void images_write(Image* image, void* data, unsigned int length, int encrypt) {
bufferPrintf("images_write(%x, %x, %x)\r\n", image, data, length);
if(image == NULL)
return;
mtd_t *dev = images_device();
if(!dev)
return;
mtd_prepare(dev);
uint32_t padded = length;
if((length & 0xF) != 0) {
padded = (padded & ~0xF) + 0x10;
}
if(image->next != NULL && (image->offset + sizeof(Img2Header) + padded) >= image->next->offset) {
bufferPrintf("**ABORTED** requested length greater than available space.\r\n");
return;
}
uint32_t totalLen = sizeof(Img2Header) + padded;
uint8_t* writeBuffer = (uint8_t*) malloc(totalLen);
mtd_read(dev, writeBuffer, image->offset, sizeof(Img2Header));
memcpy(writeBuffer + sizeof(Img2Header), data, length);
if(encrypt)
aes_838_encrypt(writeBuffer + sizeof(Img2Header), padded, NULL);
Img2Header* header = (Img2Header*) writeBuffer;
header->dataLen = length;
header->dataLenPadded = padded;
calculateDataHash(writeBuffer + sizeof(Img2Header), padded, header->dataHash);
uint32_t checksum = 0;
crc32(&checksum, writeBuffer, 0x64);
header->header_checksum = checksum;
calculateHash(header, header->hash);
bufferPrintf("mtd_write(0x%p, %x, %x, %x)\r\n", dev, writeBuffer, image->offset, totalLen);
mtd_write(dev, writeBuffer, image->offset, totalLen);
bufferPrintf("mtd_write(0x%p, %x, %x, %x) done\r\n", dev, writeBuffer, image->offset, totalLen);
free(writeBuffer);
mtd_finish(dev);
images_release();
images_setup();
}
void images_from_template(Image* image, uint32_t type, int index, void* dataBuffer, unsigned int len, int encrypt) {
if(image == NULL)
return;
mtd_t *dev = images_device();
if(!dev)
return;
mtd_prepare(dev);
uint32_t offset = MaxOffset + (SegmentSize - (MaxOffset % SegmentSize));
uint32_t padded = len;
if((len & 0xF) != 0) {
padded = (padded & ~0xF) + 0x10;
}
uint32_t totalLen = sizeof(Img2Header) + padded;
uint8_t* buffer = (uint8_t*) malloc(totalLen);
mtd_read(dev, buffer, image->offset, sizeof(Img2Header));
Img2Header* header = (Img2Header*) buffer;
header->imageType = type;
if(index >= 0)
header->index = index;
header->dataLen = len;
header->dataLenPadded = padded;
memcpy(buffer + sizeof(Img2Header), dataBuffer, len);
if(encrypt)
aes_838_encrypt(buffer + sizeof(Img2Header), padded, NULL);
calculateDataHash(buffer + sizeof(Img2Header), image->padded, header->dataHash);
uint32_t checksum = 0;
crc32(&checksum, buffer, 0x64);
header->header_checksum = checksum;
calculateHash(header, header->hash);
mtd_write(dev, buffer, offset, totalLen);
free(buffer);
mtd_finish(dev);
images_release();
images_setup();
}
int images_verify(Image* image) {
uint8_t hash[0x40];
int retVal = 0;
if(image == NULL)
return 1;
if(!image->hashMatch)
retVal |= 1 << 2;
void* data = malloc(image->padded);
nor_read(data, image->offset + sizeof(Img2Header), image->padded);
calculateDataHash(data, image->padded, hash);
free(data);
if(memcmp(hash, image->dataHash, 0x40) != 0)
retVal |= 1 << 3;
return retVal;
}
void images_duplicate(Image* image, uint32_t type, int index) {
if(image == NULL)
return;
mtd_t *dev = images_device();
if(!dev)
return;
mtd_prepare(dev);
uint32_t offset = MaxOffset + (SegmentSize - (MaxOffset % SegmentSize));
uint32_t totalLen = sizeof(Img2Header) + image->padded;
uint8_t* buffer = (uint8_t*) malloc(totalLen);
mtd_read(dev, buffer, image->offset, totalLen);
Img2Header* header = (Img2Header*) buffer;
header->imageType = type;
if(index >= 0)
header->index = index;
calculateDataHash(buffer + sizeof(Img2Header), image->padded, header->dataHash);
uint32_t checksum = 0;
crc32(&checksum, buffer, 0x64);
header->header_checksum = checksum;
calculateHash(header, header->hash);
mtd_write(dev, buffer, offset, totalLen);
free(buffer);
mtd_finish(dev);
images_release();
images_setup();
}
