rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/u-boot/tools/rockchip/trust_merger.c

955 lines
24 KiB
C
Raw Blame History

/*
* Rockchip trust image generator
*
* (C) Copyright 2008-2015 Fuzhou Rockchip Electronics Co., Ltd
* Peter, Software Engineering, <superpeter.cai@gmail.com>.
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <sys/stat.h>
#include <u-boot/sha256.h>
#include "trust_merger.h"
#include "sha2.h"
/* #define DEBUG */
static bool gDebug =
#ifdef DEBUG
true;
#else
false;
#endif /* DEBUG */
#define LOGE(fmt, args...) fprintf(stderr, "E: [%s] " fmt, __func__, ##args)
#define LOGD(fmt, args...) \
do { \
if (gDebug) \
fprintf(stderr, "D: [%s] " fmt, __func__, ##args); \
} while (0)
/* trust image has g_trust_max_num backups */
static uint32_t g_trust_max_num = 2;
static uint32_t g_trust_max_size = 2 * 1024 * 1024;
/* config sha and rsa */
#define SHA_SEL_256 3 /* little endian */
#define SHA_SEL_256_RK 2 /* big endian: only rk3368 need it */
#define SHA_SEL_160 1
#define SHA_SEL_NONE 0
#define RSA_SEL_2048_PSS 3 /* only RK3326, PX30, RK3308 */
#define RSA_SEL_2048 2 /* most platforms except above PSS */
#define RSA_SEL_1024 1
#define RSA_SEL_NONE 0
#define is_digit(c) ((c) >= '0' && (c) <= '9')
static char *gConfigPath;
static OPT_T gOpts;
#define BL3X_FILESIZE_MAX (512 * 1024)
static uint8_t gBuf[BL3X_FILESIZE_MAX];
static bool gSubfix;
static char *gLegacyPath;
static char *gNewPath;
static char *gPrePath;
static uint8_t gRSAmode = RSA_SEL_2048;
static uint8_t gSHAmode = SHA_SEL_256;
static bool gIgnoreBL32;
const uint8_t gBl3xID[BL_MAX_SEC][4] = { { 'B', 'L', '3', '0' },
{ 'B', 'L', '3', '1' },
{ 'B', 'L', '3', '2' },
{ 'B', 'L', '3', '3' }
};
static inline uint32_t getBCD(uint16_t value)
{
uint8_t tmp[2] = { 0 };
int i;
uint32_t ret;
if (value > 0xFFFF) {
return 0;
}
for (i = 0; i < 2; i++) {
tmp[i] = (((value / 10) % 10) << 4) | (value % 10);
value /= 100;
}
ret = ((uint16_t)(tmp[1] << 8)) | tmp[0];
LOGD("ret:%x\n", ret);
return ret & 0xFF;
}
static inline void fixPath(char *path)
{
int i, len = strlen(path);
char tmp[MAX_LINE_LEN];
char *start, *end;
for (i = 0; i < len; i++) {
if (path[i] == '\\')
path[i] = '/';
else if (path[i] == '\r' || path[i] == '\n')
path[i] = '\0';
}
if (gLegacyPath && gNewPath) {
start = strstr(path, gLegacyPath);
if (start) {
end = start + strlen(gLegacyPath);
/* Backup, so tmp can be src for strcat() */
strcpy(tmp, end);
/* Terminate, so path can be dest for strcat() */
*start = '\0';
strcat(path, gNewPath);
strcat(path, tmp);
} else {
strcpy(tmp, path);
strcpy(path, gNewPath);
strcat(path, tmp);
}
} else if ((ulong)path != (ulong)gOpts.outPath && /* ignore output */
gPrePath && strncmp(path, gPrePath, strlen(gPrePath))) {
strcpy(tmp, path);
strcpy(path, gPrePath);
strcat(path, tmp);
}
}
static bool parseVersion(FILE *file)
{
int d = 0;
if (SCANF_EAT(file) != 0) {
return false;
}
if (fscanf(file, OPT_MAJOR "=%d", &d) != 1)
return false;
gOpts.major = (uint16_t) d;
if (SCANF_EAT(file) != 0) {
return false;
}
if (fscanf(file, OPT_MINOR "=%d", &d) != 1)
return false;
gOpts.minor = (uint16_t) d;
LOGD("major:%d, minor:%d\n", gOpts.major, gOpts.minor);
return true;
}
static bool parseBL3x(FILE *file, int bl3x_id)
{
int pos;
int sec;
char buf[MAX_LINE_LEN];
bl_entry_t *pbl3x = NULL;
if (bl3x_id >= BL_MAX_SEC) {
return false;
}
pbl3x = &gOpts.bl3x[bl3x_id];
/* SEC */
if (SCANF_EAT(file) != 0) {
return false;
}
if (fscanf(file, OPT_SEC "=%d", &sec) != 1) {
return false;
}
if ((gSubfix) && (bl3x_id == BL32_SEC)) {
if (sec == 0) {
sec = 1;
printf("BL3%d adjust sec from 0 to 1\n", bl3x_id);
}
} else if (gIgnoreBL32 && (bl3x_id == BL32_SEC)) {
if (sec == 1) {
sec = 0;
printf("BL3%d adjust sec from 1 to 0\n", bl3x_id);
}
}
pbl3x->sec = sec;
LOGD("bl3%d sec: %d\n", bl3x_id, pbl3x->sec);
/* PATH */
if (SCANF_EAT(file) != 0) {
return false;
}
memset(buf, 0, MAX_LINE_LEN);
if (fscanf(file, OPT_PATH "=%s", buf) != 1) {
if (pbl3x->sec)
return false;
} else {
if (strlen(buf) != 0) {
fixPath(buf);
strcpy(pbl3x->path, buf);
LOGD("bl3%d path:%s\n", bl3x_id, pbl3x->path);
}
}
/* ADDR */
if (SCANF_EAT(file) != 0) {
return false;
}
memset(buf, 0, MAX_LINE_LEN);
if (fscanf(file, OPT_ADDR "=%s", buf) != 1) {
if (pbl3x->sec)
return false;
} else {
if (strlen(buf) != 0) {
pbl3x->addr = strtoul(buf, NULL, 16);
LOGD("bl3%d addr:0x%x\n", bl3x_id, pbl3x->addr);
}
}
pos = ftell(file);
if (pos < 0) {
return false;
}
if (SCANF_EAT(file) != 0) {
return false;
}
return true;
}
static bool parseOut(FILE *file)
{
if (SCANF_EAT(file) != 0) {
return false;
}
if (fscanf(file, OPT_OUT_PATH "=%[^\r^\n]", gOpts.outPath) != 1)
return false;
/* fixPath(gOpts.outPath); */
printf("out:%s\n", gOpts.outPath);
return true;
}
void printOpts(FILE *out)
{
fprintf(out, SEC_BL30 "\n" OPT_SEC "=%d\n", gOpts.bl3x[BL30_SEC].sec);
if (gOpts.bl3x[BL30_SEC].sec) {
fprintf(out, OPT_PATH "=%s\n", gOpts.bl3x[BL30_SEC].path);
fprintf(out, OPT_ADDR "=0x%08x\n", gOpts.bl3x[BL30_SEC].addr);
}
fprintf(out, SEC_BL31 "\n" OPT_SEC "=%d\n", gOpts.bl3x[BL31_SEC].sec);
if (gOpts.bl3x[BL31_SEC].sec) {
fprintf(out, OPT_PATH "=%s\n", gOpts.bl3x[BL31_SEC].path);
fprintf(out, OPT_ADDR "=0x%08x\n", gOpts.bl3x[BL31_SEC].addr);
}
fprintf(out, SEC_BL32 "\n" OPT_SEC "=%d\n", gOpts.bl3x[BL32_SEC].sec);
if (gOpts.bl3x[BL32_SEC].sec) {
fprintf(out, OPT_PATH "=%s\n", gOpts.bl3x[BL32_SEC].path);
fprintf(out, OPT_ADDR "=0x%08x\n", gOpts.bl3x[BL32_SEC].addr);
}
fprintf(out, SEC_BL33 "\n" OPT_SEC "=%d\n", gOpts.bl3x[BL33_SEC].sec);
if (gOpts.bl3x[BL33_SEC].sec) {
fprintf(out, OPT_PATH "=%s\n", gOpts.bl3x[BL33_SEC].path);
fprintf(out, OPT_ADDR "=0x%08x\n", gOpts.bl3x[BL33_SEC].addr);
}
fprintf(out, SEC_OUT "\n" OPT_OUT_PATH "=%s\n", gOpts.outPath);
}
static bool parseOpts(void)
{
FILE *file = NULL;
char *configPath = (gConfigPath == NULL) ? DEF_CONFIG_FILE : gConfigPath;
bool bl30ok = false, bl31ok = false, bl32ok = false, bl33ok = false;
bool outOk = false;
bool versionOk = false;
char buf[MAX_LINE_LEN];
bool ret = false;
file = fopen(configPath, "r");
if (!file) {
fprintf(stderr, "config(%s) not found!\n", configPath);
if (configPath == (char *)DEF_CONFIG_FILE) {
file = fopen(DEF_CONFIG_FILE, "w");
if (file) {
fprintf(stderr, "create defconfig\n");
printOpts(file);
}
}
goto end;
}
LOGD("start parse\n");
if (SCANF_EAT(file) != 0) {
goto end;
}
while (fscanf(file, "%s", buf) == 1) {
if (!strcmp(buf, SEC_VERSION)) {
versionOk = parseVersion(file);
if (!versionOk) {
LOGE("parseVersion failed!\n");
goto end;
}
} else if (!strcmp(buf, SEC_BL30)) {
bl30ok = parseBL3x(file, BL30_SEC);
if (!bl30ok) {
LOGE("parseBL30 failed!\n");
goto end;
}
} else if (!strcmp(buf, SEC_BL31)) {
bl31ok = parseBL3x(file, BL31_SEC);
if (!bl31ok) {
LOGE("parseBL31 failed!\n");
goto end;
}
} else if (!strcmp(buf, SEC_BL32)) {
bl32ok = parseBL3x(file, BL32_SEC);
if (!bl32ok) {
LOGE("parseBL32 failed!\n");
goto end;
}
} else if (!strcmp(buf, SEC_BL33)) {
bl33ok = parseBL3x(file, BL33_SEC);
if (!bl33ok) {
LOGE("parseBL33 failed!\n");
goto end;
}
} else if (!strcmp(buf, SEC_OUT)) {
outOk = parseOut(file);
if (!outOk) {
LOGE("parseOut failed!\n");
goto end;
}
} else if (buf[0] == '#') {
continue;
} else {
LOGD("unknown sec: %s!\n", buf);
continue;
}
if (SCANF_EAT(file) != 0) {
goto end;
}
}
if (bl30ok && bl31ok && bl32ok && bl33ok && outOk)
ret = true;
end:
if (file)
fclose(file);
return ret;
}
bool initOpts(void)
{
memset(&gOpts, 0, sizeof(gOpts));
gOpts.major = DEF_MAJOR;
gOpts.minor = DEF_MINOR;
memcpy(&gOpts.bl3x[BL30_SEC].id, gBl3xID[BL30_SEC], 4);
strcpy(gOpts.bl3x[BL30_SEC].path, DEF_BL30_PATH);
memcpy(&gOpts.bl3x[BL31_SEC].id, gBl3xID[BL31_SEC], 4);
strcpy(gOpts.bl3x[BL31_SEC].path, DEF_BL31_PATH);
memcpy(&gOpts.bl3x[BL32_SEC].id, gBl3xID[BL32_SEC], 4);
strcpy(gOpts.bl3x[BL32_SEC].path, DEF_BL32_PATH);
memcpy(&gOpts.bl3x[BL33_SEC].id, gBl3xID[BL33_SEC], 4);
strcpy(gOpts.bl3x[BL33_SEC].path, DEF_BL33_PATH);
strcpy(gOpts.outPath, DEF_OUT_PATH);
return parseOpts();
}
static inline bool getFileSize(const char *path, uint32_t *size)
{
struct stat st;
if (stat(path, &st) < 0)
return false;
*size = st.st_size;
LOGD("path:%s, size:%d\n", path, *size);
return true;
}
void fill_file(FILE *file, char ch, uint32_t fill_size)
{
uint8_t fill_buffer[1024];
uint32_t cur_write;
memset(fill_buffer, ch, 1024);
while (fill_size > 0) {
cur_write = (fill_size >= 1024) ? 1024 : fill_size;
fwrite(fill_buffer, 1, cur_write, file);
fill_size -= cur_write;
}
}
bool filter_elf(uint32_t index, uint8_t *pMeta, uint32_t *pMetaNum,
bool *bElf)
{
bool ret = false;
FILE *file = NULL;
uint8_t *file_buffer = NULL;
uint32_t file_size, read_size, i;
Elf32_Ehdr *pElfHeader32;
Elf32_Phdr *pElfProgram32;
Elf64_Ehdr *pElfHeader64;
Elf64_Phdr *pElfProgram64;
bl_entry_t *pEntry = (bl_entry_t *)(pMeta + sizeof(bl_entry_t) * (*pMetaNum));
LOGD("index=%d,file=%s\n", index, gOpts.bl3x[index].path);
if (!getFileSize(gOpts.bl3x[index].path, &file_size))
goto exit_fileter_elf;
file = fopen(gOpts.bl3x[index].path, "rb");
if (!file) {
LOGE("open file(%s) failed\n", gOpts.bl3x[index].path);
goto exit_fileter_elf;
}
file_buffer = malloc(file_size);
if (!file_buffer)
goto exit_fileter_elf;
read_size = fread(file_buffer, 1, file_size, file);
if (read_size != file_size)
goto exit_fileter_elf;
if (*((uint32_t *)file_buffer) != ELF_MAGIC) {
ret = true;
*bElf = false;
goto exit_fileter_elf;
}
*bElf = true;
if (file_buffer[5] != 1) { /* only support little endian */
goto exit_fileter_elf;
}
if (*((uint16_t *)(file_buffer + EI_NIDENT)) !=
2) { /* only support executable case */
goto exit_fileter_elf;
}
if (file_buffer[4] == 2) {
pElfHeader64 = (Elf64_Ehdr *)file_buffer;
for (i = 0; i < pElfHeader64->e_phnum; i++) {
pElfProgram64 = (Elf64_Phdr *)(file_buffer + pElfHeader64->e_phoff +
i * pElfHeader64->e_phentsize);
if (pElfProgram64->p_type == 1) { /* PT_LOAD */
pEntry->id = gOpts.bl3x[index].id;
strcpy(pEntry->path, gOpts.bl3x[index].path);
pEntry->size = (uint32_t) pElfProgram64->p_filesz;
pEntry->offset = (uint32_t) pElfProgram64->p_offset;
pEntry->align_size = DO_ALIGN(pEntry->size, ENTRY_ALIGN);
pEntry->addr = (uint32_t) pElfProgram64->p_paddr;
if (pEntry->align_size > BL3X_FILESIZE_MAX) {
LOGE("elf_file %s too large,segment=%d.\n", pEntry->path, i);
goto exit_fileter_elf;
}
LOGD("bl3%d: filesize = %d, imagesize = %d, segment=%d\n", index,
pEntry->size, pEntry->align_size, i);
pEntry++;
(*pMetaNum)++;
}
}
} else {
pElfHeader32 = (Elf32_Ehdr *)file_buffer;
for (i = 0; i < pElfHeader32->e_phnum; i++) {
pElfProgram32 = (Elf32_Phdr *)(file_buffer + pElfHeader32->e_phoff +
i * pElfHeader32->e_phentsize);
if (pElfProgram32->p_type == 1) { /* PT_LOAD */
pEntry->id = gOpts.bl3x[index].id;
strcpy(pEntry->path, gOpts.bl3x[index].path);
pEntry->size = pElfProgram32->p_filesz;
pEntry->offset = pElfProgram32->p_offset;
pEntry->align_size = DO_ALIGN(pEntry->size, ENTRY_ALIGN);
pEntry->addr = pElfProgram32->p_paddr;
if (pEntry->align_size > BL3X_FILESIZE_MAX) {
LOGE("elf_file %s too large,segment=%d.\n", pEntry->path, i);
goto exit_fileter_elf;
}
LOGD("bl3%d: filesize = %d, imagesize = %d, segment=%d\n", index,
pEntry->size, pEntry->align_size, i);
pEntry++;
(*pMetaNum)++;
}
}
}
ret = true;
exit_fileter_elf:
if (file)
fclose(file);
if (file_buffer)
free(file_buffer);
return ret;
}
#define SHA256_CHECK_SZ ((uint32_t)(256 * 1024))
static bool bl3xHash256(uint8_t *pHash, uint8_t *pData, uint32_t nDataSize)
{
uint32_t nHashSize, nHasHashSize;
if (!pHash || !pData || !nDataSize) {
return false;
}
nHasHashSize = 0;
if (gSHAmode == SHA_SEL_256_RK) {
sha256_ctx ctx;
sha256_begin(&ctx);
while (nDataSize > 0) {
nHashSize = (nDataSize >= SHA256_CHECK_SZ) ? SHA256_CHECK_SZ : nDataSize;
sha256_hash(&ctx, pData + nHasHashSize, nHashSize);
nHasHashSize += nHashSize;
nDataSize -= nHashSize;
}
sha256_end(&ctx, pHash);
} else {
sha256_context ctx;
sha256_starts(&ctx);
while (nDataSize > 0) {
nHashSize = (nDataSize >= SHA256_CHECK_SZ) ? SHA256_CHECK_SZ : nDataSize;
sha256_update(&ctx, pData + nHasHashSize, nHashSize);
nHasHashSize += nHashSize;
nDataSize -= nHashSize;
}
sha256_finish(&ctx, pHash);
}
return true;
}
static bool mergetrust(void)
{
FILE *outFile = NULL;
uint32_t OutFileSize;
uint32_t SrcFileNum, SignOffset, nComponentNum;
TRUST_HEADER *pHead = NULL;
COMPONENT_DATA *pComponentData = NULL;
TRUST_COMPONENT *pComponent = NULL;
bool ret = false, bElf;
uint32_t i, n;
uint8_t *outBuf = NULL, *pbuf = NULL, *pMetaBuf = NULL;
bl_entry_t *pEntry = NULL;
if (!initOpts())
return false;
if (gDebug) {
printf("---------------\nUSING CONFIG:\n");
printOpts(stdout);
printf("---------------\n\n");
}
pMetaBuf = malloc(sizeof(bl_entry_t) * 32);
if (!pMetaBuf) {
LOGE("Merge trust image: malloc buffer error.\n");
goto end;
}
nComponentNum = SrcFileNum = 0;
for (i = BL30_SEC; i < BL_MAX_SEC; i++) {
if (gOpts.bl3x[i].sec) {
if (!filter_elf(i, pMetaBuf, &nComponentNum, &bElf)) {
LOGE("filter_elf %s file failed\n", gOpts.bl3x[i].path);
goto end;
}
if (!bElf) {
pEntry = (bl_entry_t *)(pMetaBuf + sizeof(bl_entry_t) * nComponentNum);
pEntry->id = gOpts.bl3x[i].id;
strcpy(pEntry->path, gOpts.bl3x[i].path);
getFileSize(pEntry->path, &pEntry->size);
pEntry->offset = 0;
pEntry->align_size = DO_ALIGN(pEntry->size, ENTRY_ALIGN);
pEntry->addr = gOpts.bl3x[i].addr;
if (pEntry->align_size > BL3X_FILESIZE_MAX) {
LOGE("file %s too large.\n", gOpts.bl3x[i].path);
goto end;
}
LOGD("bl3%d: filesize = %d, imagesize = %d\n", i, pEntry->size,
pEntry->align_size);
pEntry++;
nComponentNum++;
}
}
}
LOGD("bl3x bin sec = %d\n", nComponentNum);
/* 2048bytes for head */
memset(gBuf, 0, TRUST_HEADER_SIZE);
/* Trust Head */
pHead = (TRUST_HEADER *)gBuf;
memcpy(&pHead->tag, TRUST_HEAD_TAG, 4);
pHead->version = (getBCD(gOpts.major) << 8) | getBCD(gOpts.minor);
pHead->flags = 0;
pHead->flags |= (gSHAmode << 0);
pHead->flags |= (gRSAmode << 4);
SignOffset = sizeof(TRUST_HEADER) + nComponentNum * sizeof(COMPONENT_DATA);
LOGD("trust bin sign offset = %d\n", SignOffset);
pHead->size = (nComponentNum << 16) | (SignOffset >> 2);
pComponent = (TRUST_COMPONENT *)(gBuf + SignOffset + SIGNATURE_SIZE);
pComponentData = (COMPONENT_DATA *)(gBuf + sizeof(TRUST_HEADER));
OutFileSize = TRUST_HEADER_SIZE;
pEntry = (bl_entry_t *)pMetaBuf;
for (i = 0; i < nComponentNum; i++) {
/* bl3x load and run address */
pComponentData->LoadAddr = pEntry->addr;
pComponent->ComponentID = pEntry->id;
pComponent->StorageAddr = (OutFileSize >> 9);
pComponent->ImageSize = (pEntry->align_size >> 9);
pComponentData->LoadSize = pComponent->ImageSize;
LOGD("bl3%c: LoadAddr = 0x%08x, StorageAddr = %d, ImageSize = %d\n",
(char)((pEntry->id & 0xFF000000) >> 24), pComponentData->LoadAddr,
pComponent->StorageAddr, pComponent->ImageSize);
OutFileSize += pEntry->align_size;
pComponentData++;
pComponent++;
pEntry++;
}
/* create out file */
outFile = fopen(gOpts.outPath, "wb+");
if (!outFile) {
LOGE("open out file(%s) failed\n", gOpts.outPath);
outFile = fopen(DEF_OUT_PATH, "wb");
if (!outFile) {
LOGE("open default out file:%s failed!\n", DEF_OUT_PATH);
goto end;
}
}
/* 0 for g_trust_max_num backups */
#if 0
/* save trust head to out file */
if (!fwrite(gBuf, TRUST_HEADER_SIZE, 1, outFile))
goto end;
/* save trust bl3x bin */
for (i = BL30_SEC; i < BL_MAX_SEC; i++) {
if (gOpts.bl3x[i].sec) {
FILE *inFile = fopen(gOpts.bl3x[i].path, "rb");
if (!inFile)
goto end;
memset(gBuf, 0, imagesize[i]);
if (!fread(gBuf, filesize[i], 1, inFile))
goto end;
fclose(inFile);
if (!fwrite(gBuf, imagesize[i], 1, outFile))
goto end;
}
}
#else
/* check bin size */
if (OutFileSize > g_trust_max_size) {
LOGE("Merge trust image: trust bin size overfull.\n");
goto end;
}
/* malloc buffer */
pbuf = outBuf = calloc(g_trust_max_size, g_trust_max_num);
if (!outBuf) {
LOGE("Merge trust image: calloc buffer error.\n");
goto end;
}
memset(outBuf, 0, (g_trust_max_size * g_trust_max_num));
/* save trust head data */
memcpy(pbuf, gBuf, TRUST_HEADER_SIZE);
pbuf += TRUST_HEADER_SIZE;
uint8_t *pHashData = NULL;
pComponentData = (COMPONENT_DATA *)(outBuf + sizeof(TRUST_HEADER));
/* save trust bl3x bin */
pEntry = (bl_entry_t *)pMetaBuf;
for (i = 0; i < nComponentNum; i++) {
FILE *inFile = fopen(pEntry->path, "rb");
if (!inFile)
goto end;
memset(gBuf, 0, pEntry->align_size);
fseek(inFile, pEntry->offset, SEEK_SET);
if (!fread(gBuf, pEntry->size, 1, inFile))
goto end;
fclose(inFile);
/* bl3x bin hash256 */
pHashData = (uint8_t *)&pComponentData->HashData[0];
bl3xHash256(pHashData, gBuf, pEntry->align_size);
memcpy(pbuf, gBuf, pEntry->align_size);
pComponentData++;
pbuf += pEntry->align_size;
pEntry++;
}
/* copy other (g_trust_max_num - 1) backup bin */
for (n = 1; n < g_trust_max_num; n++) {
memcpy(outBuf + g_trust_max_size * n, outBuf, g_trust_max_size);
}
/* save date to file */
if (!fwrite(outBuf, g_trust_max_size * g_trust_max_num, 1, outFile)) {
LOGE("Merge trust image: write file error.\n");
goto end;
}
#endif
ret = true;
end:
/*
for (i = BL30_SEC; i < BL_MAX_SEC; i++) {
if (gOpts.bl3x[i].sec != false) {
if (gOpts.bl3x[i].is_elf) {
if (stat(gOpts.bl3x[i].path, &st) >= 0)
remove(gOpts.bl3x[i].path);
}
}
}
*/
if (pMetaBuf)
free(pMetaBuf);
if (outBuf)
free(outBuf);
if (outFile)
fclose(outFile);
return ret;
}
static int saveDatatoFile(char *FileName, void *pBuf, uint32_t size)
{
FILE *OutFile = NULL;
int ret = -1;
OutFile = fopen(FileName, "wb");
if (!OutFile) {
printf("open OutPutFlie:%s failed!\n", FileName);
goto end;
}
if (1 != fwrite(pBuf, size, 1, OutFile)) {
printf("write output file failed!\n");
goto end;
}
ret = 0;
end:
if (OutFile)
fclose(OutFile);
return ret;
}
static bool unpacktrust(char *path)
{
FILE *FileSrc = NULL;
uint32_t FileSize;
uint8_t *pBuf = NULL;
uint32_t SrcFileNum, SignOffset;
TRUST_HEADER *pHead = NULL;
COMPONENT_DATA *pComponentData = NULL;
TRUST_COMPONENT *pComponent = NULL;
char str[MAX_LINE_LEN];
bool ret = false;
uint32_t i;
FileSrc = fopen(path, "rb");
if (FileSrc == NULL) {
printf("open %s failed!\n", path);
goto end;
}
if (getFileSize(path, &FileSize) == false) {
printf("File Size failed!\n");
goto end;
}
printf("File Size = %d\n", FileSize);
pBuf = (uint8_t *)malloc(FileSize);
if (1 != fread(pBuf, FileSize, 1, FileSrc)) {
printf("read input file failed!\n");
goto end;
}
pHead = (TRUST_HEADER *)pBuf;
memcpy(str, &pHead->tag, 4);
str[4] = '\0';
printf("Header Tag:%s\n", str);
printf("Header version:%d\n", pHead->version);
printf("Header flag:%d\n", pHead->flags);
SrcFileNum = (pHead->size >> 16) & 0xffff;
SignOffset = (pHead->size & 0xffff) << 2;
printf("SrcFileNum:%d\n", SrcFileNum);
printf("SignOffset:%d\n", SignOffset);
pComponent = (TRUST_COMPONENT *)(pBuf + SignOffset + SIGNATURE_SIZE);
pComponentData = (COMPONENT_DATA *)(pBuf + sizeof(TRUST_HEADER));
for (i = 0; i < SrcFileNum; i++) {
printf("Component %d:\n", i);
memcpy(str, &pComponent->ComponentID, 4);
str[4] = '\0';
printf("ComponentID:%s\n", str);
printf("StorageAddr:0x%x\n", pComponent->StorageAddr);
printf("ImageSize:0x%x\n", pComponent->ImageSize);
printf("LoadAddr:0x%x\n", pComponentData->LoadAddr);
saveDatatoFile(str, pBuf + (pComponent->StorageAddr << 9),
pComponent->ImageSize << 9);
pComponentData++;
pComponent++;
}
ret = true;
end:
if (FileSrc)
fclose(FileSrc);
if (pBuf)
free(pBuf);
return ret;
}
static void printHelp(void)
{
printf("Usage: trust_merger [options]... FILE\n");
printf(
"Merge or unpack Rockchip's trust image (Default action is to merge.)\n");
printf("Options:\n");
printf("\t" OPT_MERGE "\t\t\tMerge trust with specified config.\n");
printf("\t" OPT_UNPACK "\t\tUnpack specified trust to current dir.\n");
printf("\t" OPT_VERBOSE "\t\tDisplay more runtime informations.\n");
printf("\t" OPT_HELP "\t\t\tDisplay this information.\n");
printf("\t" OPT_VERSION "\t\tDisplay version information.\n");
printf("\t" OPT_SUBFIX "\t\tSpec subfix.\n");
printf("\t" OPT_REPLACE "\t\tReplace some part of binary path.\n");
printf("\t" OPT_PREPATH "\t\tAdd prefix path of binary path.\n");
printf("\t" OPT_RSA "\t\t\tRSA mode.\"--rsa [mode]\", [mode] can be: "
"0(none), 1(1024), 2(2048), 3(2048 pss).\n");
printf("\t" OPT_SHA
"\t\t\tSHA mode.\"--sha [mode]\", [mode] can be: 0(none), 1(160), "
"2(256 RK big endian), 3(256 little endian).\n");
printf("\t" OPT_SIZE "\t\t\tTrustImage size.\"--size [per image KB size] "
"[copy count]\", per image must be 64KB aligned\n");
}
int main(int argc, char **argv)
{
bool merge = true;
char *optPath = NULL;
int i;
gConfigPath = NULL;
for (i = 1; i < argc; i++) {
if (!strcmp(OPT_VERBOSE, argv[i])) {
gDebug = true;
} else if (!strcmp(OPT_HELP, argv[i])) {
printHelp();
return 0;
} else if (!strcmp(OPT_VERSION, argv[i])) {
printf("trust_merger (cwz@rock-chips.com)\t" VERSION "\n");
return 0;
} else if (!strcmp(OPT_MERGE, argv[i])) {
merge = true;
} else if (!strcmp(OPT_UNPACK, argv[i])) {
merge = false;
} else if (!strcmp(OPT_SUBFIX, argv[i])) {
gSubfix = true;
printf("trust_merger: Spec subfix!\n");
} else if (!strcmp(OPT_REPLACE, argv[i])) {
i++;
gLegacyPath = argv[i];
i++;
gNewPath = argv[i];
} else if (!strcmp(OPT_PREPATH, argv[i])) {
i++;
gPrePath = argv[i];
} else if (!strcmp(OPT_RSA, argv[i])) {
i++;
if (!is_digit(*(argv[i]))) {
printHelp();
return -1;
}
gRSAmode = *(argv[i]) - '0';
LOGD("rsa mode:%d\n", gRSAmode);
} else if (!strcmp(OPT_SHA, argv[i])) {
i++;
if (!is_digit(*(argv[i]))) {
printHelp();
return -1;
}
gSHAmode = *(argv[i]) - '0';
LOGD("sha mode:%d\n", gSHAmode);
} else if (!strcmp(OPT_SIZE, argv[i])) {
/* Per trust image size */
g_trust_max_size = strtoul(argv[++i], NULL, 10);
/*
* Usually, it must be at 512kb align due to preloader
* detects every 512kb. But some product has critial
* flash size requirement, we have to make it small than
* 512KB.
*/
if (g_trust_max_size % 64) {
printHelp();
return -1;
}
g_trust_max_size *= 1024; /* bytes */
/* Total backup numbers */
g_trust_max_num = strtoul(argv[++i], NULL, 10);
} else if (!strcmp(OPT_IGNORE_BL32, argv[i])) {
gIgnoreBL32 = true;
} else {
if (optPath) {
fprintf(stderr, "only need one path arg, but we have:\n%s\n%s.\n",
optPath, argv[i]);
printHelp();
return -1;
}
optPath = argv[i];
}
}
if (!merge && !optPath) {
fprintf(stderr, "need set out path to unpack!\n");
printHelp();
return -1;
}
if (merge) {
LOGD("do_merge\n");
gConfigPath = optPath;
if (!mergetrust()) {
fprintf(stderr, "merge failed!\n");
return -1;
}
printf("merge success(%s)\n", gOpts.outPath);
} else {
LOGD("do_unpack\n");
if (!unpacktrust(optPath)) {
fprintf(stderr, "unpack failed!\n");
return -1;
}
printf("unpack success\n");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink