/******************************************************************************
* RETURN SECROIMG MD LENGTH
******************************************************************************/
uint32 masp_secro_md_len (uchar *md_info)
{
uint32 index = 0;
AND_AC_MD_INFO_V3a_T* cur_md_info = NULL;
uint32 md_info_len = 0;
SMSG(FALSE,"[%s]md_info:%s \n",MOD,md_info);
if(TRUE == bSecroExist)
{
/* check if this secro supports v5 format(world phone) , in v3 format
this area should be zero.*/
if (FALSE == secroimg.m_header.world_phone_support)
{
/* read v3 format and return, it depends on first character */
if ('1' == md_info[0])
{
return secroimg.m_header.md_length;
}
else if ('2' == md_info[0])
{
return secroimg.m_header.md2_length;
}
}
/* if it supports v5 format (world phone) */
else if (TRUE == secroimg.m_header.world_phone_support)
{
if (NULL != md_info)
{
md_info_len = strlen(md_info);
}
/* check if this image's information exist */
for(index=0; index<MAX_V5_SUPPORT_MD_NUM; index++)
{
cur_md_info = &(secroimg.m_padding.md_v3a_info[index]);
if(0 == strncmp(md_info,cur_md_info->md_name+strlen("SECURE_RO_"),md_info_len))
{
SMSG(TRUE,"[%s]md[%d]len:0x%x \n",MOD,index,cur_md_info->md_len);
return cur_md_info->md_len;
}
}
if (MAX_V5_SUPPORT_MD_NUM == index)
{
/* no match found, return 0 */
SMSG(TRUE,"[%s]v5 no match \n",MOD);
return 0;
}
}
}
else
{
SMSG(TRUE,"[%s]Secro v3 does not exist \n",MOD);
return 0;
}
return 0;
}
BOOL sec_util_brom_download_recovery_check(void)
{
#ifdef KPD_DL_KEY2
if (mtk_detect_key (KPD_DL_KEY2) && FALSE==bUsbHandshakeSuccess
&& is_BR_cmd_disabled())
{
SMSG("[%s] Start checking (1500 ms)\n", MOD);
mdelay(1500);
if(false == mtk_detect_key (KPD_DL_KEY2))
{
SMSG("[%s] Key is not detected, wait for 1500ms \n", MOD);
mdelay(1500);
if(mtk_detect_key (KPD_DL_KEY2))
{
SMSG("[%s] Key is detected\n", MOD);
return sec_util_force_brom_download_recovery();
}
else
{
SMSG("[%s] Key is not detected\n", MOD);
return FALSE;
}
}
else
{
SMSG("[%s] Key is detected\n", MOD);
return FALSE;
}
}
#endif
return FALSE;
}
/* Note: this function is only for aes test */
int sec_aes_test(void)
{
int ret = SEC_OK;
uchar buf[CIPHER_BLOCK_SIZE] = "AES_TEST";
SMSG("\n[%s] SW AES test\n", MOD);
/* -------------------------- */
/* sec aes encrypt test */
/* -------------------------- */
SMSG("[%s] input = 0x%x,0x%x,0x%x,0x%x\n", MOD, buf[0], buf[1], buf[2], buf[3]);
if (SEC_OK != (ret = lib_aes_enc(buf, CIPHER_BLOCK_SIZE, buf, CIPHER_BLOCK_SIZE))) {
pr_err("[%s] error (0x%x)\n", MOD, ret);
goto _exit;
}
SMSG("[%s] cipher = 0x%x,0x%x,0x%x,0x%x\n", MOD, buf[0], buf[1], buf[2], buf[3]);
/* -------------------------- */
/* sec aes decrypt test */
/* -------------------------- */
if (SEC_OK != (ret = lib_aes_dec(buf, CIPHER_BLOCK_SIZE, buf, CIPHER_BLOCK_SIZE))) {
pr_err("[%s] error (0x%x)\n", MOD, ret);
goto _exit;
}
SMSG("[%s] plain text = 0x%x,0x%x,0x%x,0x%x\n", MOD, buf[0], buf[1], buf[2], buf[3]);
_exit:
return ret;
}
BOOL is_lk_img(void)
{
part_hdr_t *part_hdr = (part_hdr_t*)COMMON_BUFFER_ADDR;
blkdev_t *bdev = blkdev_get(CFG_BOOT_DEV);
part_t *part;
u64 src;
if (NULL == (part = part_get(PART_UBOOT)))
goto error;
src = part->startblk * bdev->blksz;
/* retrieve partition header. */
if ((blkdev_read(bdev, src, sizeof(part_hdr_t), (u8*)part_hdr) == 0) &&
(!memcmp(part_hdr->info.name, "LK", strlen("LK")))) {
SMSG ("[%s] Found LK... \n",MOD);
return TRUE;
}else{
SMSG ("[%s] LK does not exist, use uboot... \n",MOD);
return FALSE;
}
error:
SMSG ("[%s] part_get (PART_UBOOT) Fail\n",MOD);
return FALSE;
}
static int sec_get_rid(uint32 *rid)
{
uint32 obuf[5];
uint32 ibuf[4];
secpal_get_uuid(ibuf);
sha1((uchar*)ibuf, 16, (uchar*)obuf);
secpal_memcpy(rid, obuf, 16);
#ifdef SEC_DEBUG
{
int i = 0;
for (i = 0; i < 4; i++)
{
SMSG(TRUE,"IBUF[%d] = 0x%.8x\n", i, ibuf[i]);
SMSG(TRUE,"OBUF[%d] = 0x%.8x\n", i, obuf[i]);
}
}
#endif
return 0;
}
/**************************************************************************
* FUNCTION To Generate Hash by Chunk
**************************************************************************/
static int sec_signfmt_image_read(ASF_FILE fp, char* part_name, uint32 seek_offset, char* read_buf, uint32 read_len)
{
uint32 read_sz = 0;
uint32 ret = SEC_OK;
#if DUMP_MORE_FOR_DEBUG
SMSG(true,"[%s] Read image for length %d at offset 0x%x\n",MOD,read_len,seek_offset);
#endif
/* read from file */
if (ASF_FILE_NULL != fp)
{
ASF_SEEK_SET(fp, seek_offset*sizeof(char));
read_sz = ASF_READ(fp, read_buf, read_len);
return read_sz;
}
/* read from mtd */
else
{
if(SEC_OK != (ret = sec_dev_read_image ( pl2part(part_name),
(char*)read_buf,
seek_offset,
read_len,
NORMAL_ROM)))
{
SMSG(true,"[%s] read mtd '%s' fail at image offset 0x%x with length 0x%x\n",MOD,(char*)pl2part(part_name),seek_offset,read_len);
return 0;
}
return read_len;
}
}
int lib_aes_init_key(uchar* key_buf, uint32 key_len, AES_VER ver)
{
switch (ver)
{
case AES_VER_LEGACY:
g_ver = AES_VER_LEGACY;
SMSG("\n[%s] Legacy\n",MOD);
if(0 != aes_legacy_init_key(key_buf,key_len))
{
goto _err;
}
break;
case AES_VER_SO:
g_ver = AES_VER_SO;
SMSG("\n[%s] SO\n",MOD);
if(0 != aes_so_init_key(key_buf,key_len))
{
goto _err;
}
break;
default:
SMSG("\n[%s] Invalid Ver\n",MOD);
goto _err;
}
return 0;
_err:
return -1;
}
int lib_aes_init_vector(AES_VER ver)
{
switch (ver)
{
case AES_VER_LEGACY:
g_ver = AES_VER_LEGACY;
SMSG("[%s] Legacy(V)\n",MOD);
if(0 != aes_legacy_init_vector())
{
goto _err;
}
break;
case AES_VER_SO:
g_ver = AES_VER_SO;
SMSG("[%s] SO(V)\n",MOD);
if(0 != aes_so_init_vector())
{
goto _err;
}
break;
default:
SMSG("[%s] Invalid Ver(V)\n",MOD);
goto _err;
}
return 0;
_err:
return -1;
}
/**************************************************************************
* FUNCTION To Search Extension Header
**************************************************************************/
static uint32 sec_signfmt_search_extension(uchar *ext, uint32 ext_len, SEC_IMG_EXTENSTION_SET *ext_set)
{
SEC_EXTENSTION_END_MARK *search_pattern;
uchar *d_ptr,*end_ptr;
uint32 hash_only_idx = 0;
#if DUMP_MORE_FOR_DEBUG
SMSG(sec_info.bMsg,"[%s] Dump extension data ============> START\n",MOD);
sec_signfmt_dump_buffer(ext,ext_len);
SMSG(sec_info.bMsg,"[%s] Dump extension data ============> END\n",MOD);
#endif
end_ptr = ext + ext_len;
d_ptr = ext;
while( d_ptr < end_ptr )
{
search_pattern = (SEC_EXTENSTION_END_MARK *)d_ptr;
if(search_pattern->magic!=SEC_EXTENSION_HEADER_MAGIC)
{
SMSG(true,"[%s] Image extension header magic wrong\n",MOD);
return ERR_SIGN_FORMAT_EXT_HDR_MAGIC_WRONG;
}
switch(search_pattern->ext_type)
{
case SEC_EXT_HDR_CRYPTO:
ext_set->crypto = (SEC_EXTENSTION_CRYPTO *)d_ptr;
d_ptr += sizeof(SEC_EXTENSTION_CRYPTO);
break;
case SEC_EXT_HDR_FRAG_CFG:
ext_set->frag = (SEC_FRAGMENT_CFG *)d_ptr;
d_ptr += sizeof(SEC_FRAGMENT_CFG);
ext_set->hash_only = (SEC_EXTENSTION_HASH_ONLY **)ASF_MALLOC(ext_set->frag->frag_count*sizeof(SEC_EXTENSTION_HASH_ONLY *));
break;
case SEC_EXT_HDR_HASH_ONLY:
ext_set->hash_only[hash_only_idx] = (SEC_EXTENSTION_HASH_ONLY *)d_ptr;
d_ptr += sizeof(SEC_EXTENSTION_HASH_ONLY) + get_hash_size(ext_set->hash_only[hash_only_idx]->sub_type);
hash_only_idx++;
break;
case SEC_EXT_HDR_END_MARK:
ext_set->end = (SEC_EXTENSTION_END_MARK *)d_ptr;
d_ptr += sizeof(SEC_EXTENSTION_END_MARK);
break;
case SEC_EXT_HDR_HASH_SIG:
default:
SMSG(true,"[%s] Image header type not support %d\n",MOD,search_pattern->ext_type);
return ERR_SIGN_FORMAT_EXT_TYPE_NOT_SUPPORT;
}
}
if( ext_set->crypto == NULL || ext_set->frag == NULL || ext_set->hash_only == NULL || ext_set->end == NULL)
{
SMSG(true,"[%s] Some header is not searched\n",MOD);
return ERR_SIGN_FORMAT_EXT_HDR_NOT_FOUND;
}
return SEC_OK;
}
/**************************************************************************
* VERIFY SIGNATURE
**************************************************************************/
int lib_verify (uchar* data_buf, uint32 data_len, uchar* sig_buf, uint32 sig_len)
{
if (RSA_KEY_LEN != sig_len)
{
SMSG(true,"signature length is wrong (%d)\n",sig_len);
goto _err;
}
SMSG(true,"[%s] 0x%x,0x%x,0x%x,0x%x\n",MOD,data_buf[0],data_buf[1],data_buf[2],data_buf[3]);
/* hash the plain text */
sha1(data_buf, data_len, sha1sum);
/* verify this signature */
SMSG(true,"[%s] verify signature",MOD);
if( rsa_verify( &rsa, HASH_LEN, sha1sum, sig_buf ) != 0 )
{
SMSG(true, " ... failed\n" );
goto _err;
}
SMSG(true," ... pass\n");
return 0;
_err:
return -1;
}
void sec_cfg_save (U8* src)
{
U32 i = 0;
blkdev_t *bootdev = NULL;
/* --------------------- */
/* write sec cfg */
/* --------------------- */
SMSG("[%s] write '0x%x'\n",MOD,sec_cfg_info.addr);
if (NULL == (bootdev = blkdev_get(CFG_BOOT_DEV)))
{
SMSG("[%s] can't find boot device(%d)\n", MOD, CFG_BOOT_DEV);
ASSERT(0);
}
#ifndef MTK_EMMC_SUPPORT
nand_erase_data(sec_cfg_info.addr, g_nand_chip.chipsize, get_sec_cfg_cnt_size());
#endif
blkdev_write(bootdev, sec_cfg_info.addr, get_sec_cfg_cnt_size(), (u8*)src, sec_cfg_info.part_id);
/* dump first 8 bytes for debugging */
for(i=0;i<8;i++)
SMSG("0x%x,",src[i]);
SMSG("\n");
}
/******************************************************************************
* SECCFG VERSION CHECK
******************************************************************************/
int seccfg_ver_verify(void)
{
int ret = SEC_OK;
/* ----------------------------------- */
/* check seccfg magic */
/* ----------------------------------- */
if (SEC_CFG_MAGIC_NUM != seccfg.v1.magic_number) {
ret = ERR_SEC_CFG_MAGIC_INVALID;
goto _end;
}
/* ----------------------------------- */
/* check seccfg version */
/* ----------------------------------- */
switch (get_seccfg_ver()) {
case SECCFG_V1:
case SECCFG_V1_2:
SMSG(true, "[%s] seccfg id = %s\n", MOD, seccfg.v1.id);
if (0 != mcmp(seccfg.v1.id, SEC_CFG_BEGIN, SEC_CFG_BEGIN_LEN)) {
ret = ERR_SEC_CFG_INVALID_ID;
goto _end;
}
SMSG(true, "[%s] seccfg end pattern = 0x%x\n", MOD, seccfg.v1.end_pattern);
if (SEC_CFG_END_PATTERN != seccfg.v1.end_pattern) {
ret = ERR_SEC_CFG_INVALID_END_PATTERN;
goto _end;
}
break;
case SECCFG_V3:
SMSG(true, "[%s] seccfg id = %s\n", MOD, seccfg.v3.id);
if (0 != mcmp(seccfg.v3.id, SEC_CFG_BEGIN, SEC_CFG_BEGIN_LEN)) {
ret = ERR_SEC_CFG_INVALID_ID;
goto _end;
}
SMSG(true, "[%s] seccfg end pattern = 0x%x\n", MOD, seccfg.v3.end_pattern);
if (SEC_CFG_END_PATTERN != seccfg.v3.end_pattern) {
ret = ERR_SEC_CFG_INVALID_END_PATTERN;
goto _end;
}
break;
default:
ret = ERR_SEC_CFG_VERSION_INVALID;
goto _end;
}
_end:
return ret;
}
void StringTest::test03()
{
SLOG(CLS_NAME, "test03");
FixedString<10> str = "1234567890";
try
{
str.copy("1234567890a");
SASSERT("01", false);
}
catch (Exception e)
{
SMSG(slog::INFO, e.getMessage());
SASSERT("01", true);
}
try
{
FixedString<10> str2 = "1234567890a";
SASSERT("02", false);
}
catch (Exception e)
{
SMSG(slog::INFO, e.getMessage());
SASSERT("02", true);
}
}
/**************************************************************************
* [SECRO IMG]
**************************************************************************/
void sec_lib_read_secro (void)
{
#if SEC_ENV_ENABLE
U32 err;
U8 *buf = sec_util_get_secro_buf();
const U32 buf_len = sizeof(AND_SECROIMG_T);
const U32 ac_offset = sizeof(AND_AC_HEADER_T);
const U32 ac_len = sizeof(AND_AC_ANDRO_T) + sizeof(AND_AC_SV5_T);
const bAC = g_ROM_INFO.m_SEC_CTRL.m_secro_ac_en;
secroimg = NULL;
boot_arg_t *bootarg = (boot_arg_t*)BOOT_ARGUMENT_ADDR;
/* ---------------------- */
/* check status */
/* ---------------------- */
if(FALSE == seclib_sec_usbdl_enabled(TRUE))
{
SMSG("[%s] Don't read\n",MOD);
return ;
}
/* ---------------------- */
/* read secro image */
/* ---------------------- */
if(SEC_OK != (err = seclib_secroimg_read (buf, buf_len, ac_offset, ac_len, bAC)))
{
SMSG("[%s] read secroimg fail '0x%x'\n",MOD,err);
ASSERT (0);
}
else
{
secroimg = (AND_SECROIMG_T*) buf;
SMSG("[%s] secroimg '0x%x'\n",MOD, secroimg->m_andro.magic_number);
SMSG("[%s] secroimg '0x%x'\n",MOD, secroimg->m_sv5.magic_number);
/* ---------------------- */
/* check forbidden mode */
/* ---------------------- */
if(FALSE == factory_mode_valid())
{
/* ---------------------- */
/* set magic number */
/* ---------------------- */
bootarg->sec_limit.magic_num = SEC_LIMIT_MAGIC;
bootarg->sec_limit.forbid_mode = F_FACTORY_MODE;
}
}
#endif
}
/* TimedWait
* block until a count becomes available
*
* "lock" [ IN ] - externally acquired lock
*
* "tm" [ IN, NULL OKAY ] - optional timeout where
* NULL means timeout value of 0
*/
LIB_EXPORT rc_t CC KSemaphoreTimedWait ( KSemaphore *self,
struct KLock *lock, struct timeout_t *tm )
{
if ( self == NULL )
return RC ( rcPS, rcSemaphore, rcWaiting, rcSelf, rcNull );
if ( self -> avail == 0 )
{
SMSG ( "%s[%p]: avail == 0\n", __func__, self );
if ( tm == NULL )
{
SMSG ( "%s[%p]: non-blocking mode - return timeout exhausted\n", __func__, self );
return RC ( rcPS, rcSemaphore, rcWaiting, rcTimeout, rcExhausted );
}
if ( ++ self -> waiting == 1 )
{
SMSG ( "%s[%p]: first waiter\n", __func__, self );
self -> requested = self -> min_requested = 1;
self -> uniform = true;
}
else if ( self -> requested != 1 )
{
SMSG ( "%s[%p]: multiple waiters ( %u )\n", __func__, self, self -> waiting );
self -> min_requested = 1;
self -> uniform = false;
}
do
{
rc_t rc;
SMSG ( "%s[%p]: wait on condition...\n", __func__, self );
rc = KConditionTimedWait ( self -> cond, lock, tm );
SMSG ( "%s[%p]:...done, rc = %R\n", __func__, self, rc );
if ( rc != 0 )
{
SMSG ( "%s[%p]: timed out - decrementing wait count\n", __func__, self );
-- self -> waiting;
return ResetRCContext ( rc, rcPS, rcSemaphore, rcWaiting );
}
SMSG ( "%s[%p]: condition signaled - avail = %lu\n", __func__, self, self -> avail );
}
while ( self -> avail == 0 );
SMSG ( "%s[%p]: finished waiting\n", __func__, self );
-- self -> waiting;
}
SMSG ( "%s[%p]: decrementing count from %lu\n", __func__, self, self -> avail );
-- self -> avail;
return 0;
}
/******************************************************************************
* CHECK IF SECURITY CHIP IS ENABLED
******************************************************************************/
int sec_schip_enabled(void)
{
if (TRUE == masp_hal_sbc_enabled()) {
SMSG(true, "SC\n");
return 1;
} else {
SMSG(true, "NSC\n");
return 0;
}
return 0;
}
/******************************************************************************
* VALIDATE SECRO
******************************************************************************/
uint32 sec_secro_check (void)
{
uint32 ret = SEC_OK;
/* ------------------------ */
/* check header */
/* ------------------------ */
if(AC_ANDRO_MAGIC != secroimg.m_andro.magic_number)
{
ret = ERR_SECROIMG_HACC_AP_DECRYPT_FAIL;
goto _end;
}
if(AC_MD_MAGIC != secroimg.m_md.magic_number)
{
ret = ERR_SECROIMG_HACC_MD_DECRYPT_FAIL;
goto _end;
}
if(AC_MD2_MAGIC != secroimg.m_md2.magic_number)
{
ret = ERR_SECROIMG_HACC_MD_DECRYPT_FAIL;
goto _end;
}
/* ------------------------ */
/* check integrity */
/* ------------------------ */
if(FALSE == bSecroIntergiy)
{
sha1((uchar*)&secroimg, sizeof(AND_SECROIMG_T) - sizeof(secroimg.hash)
- sizeof(AND_SECROIMG_PADDING_T), sha1sum);
#if 0
SMSG(TRUE,"[%s] hash value :\n",MOD);
dump_buf(sha1sum,secroimg.m_header.hash_length);
SMSG(TRUE,"[%s] correct :\n",MOD);
dump_buf(secroimg.hash,secroimg.m_header.hash_length);
#endif
if(0 != mcmp(secroimg.hash, sha1sum, secroimg.m_header.hash_length))
{
SMSG(TRUE,"[%s] SECRO hash check fail\n",MOD);
ret = ERR_SECROIMG_HASH_CHECK_FAIL;
goto _end;
}
bSecroIntergiy = TRUE;
SMSG(TRUE,"[%s] SECRO hash check pass\n",MOD);
}
_end:
return ret;
}
/******************************************************************************
* IMAGE HASH DUMP
******************************************************************************/
void img_hash_dump(unsigned char *buf, unsigned int size)
{
unsigned int i = 0;
for (i = 0; i < size; i++) {
if (i % 4 == 0)
SMSG(true, "\n");
if (buf[i] < 0x10)
SMSG(true, "0x0%x, ", buf[i]);
else
SMSG(true, "0x%x, ", buf[i]);
}
}
/* Cancel
* signal that the count will never increase
*/
LIB_EXPORT rc_t CC KSemaphoreCancel ( KSemaphore *self )
{
if ( self == NULL )
return RC ( rcPS, rcSemaphore, rcSignaling, rcSelf, rcNull );
if ( self -> waiting != 0 )
{
SMSG ( "%s[%p]: canceling %u waiters\n", __func__, self, self -> waiting );
return KConditionBroadcast ( self -> cond );
}
SMSG ( "%s[%p]: cancel request ( no waiters )\n", __func__, self );
return 0;
}
void dump_buf(unsigned char *buf, unsigned int len)
{
unsigned int i = 1;
for (i = 1; i < len + 1; i++) {
if (0 != buf[i - 1]) {
SMSG(true, "0x%x,", buf[i - 1]);
if (0 == i % 8)
SMSG(true, "\n");
}
}
SMSG(true, "\n");
}
/**************************************************************************
* FUNCTION To check if the image is encrypted
**************************************************************************/
int sec_cipherfmt_check_cipher(ASF_FILE fp, unsigned int start_off, unsigned int *img_len)
{
CIPHER_HEADER cipher_header;
uint32 read_sz = 0;
unsigned int ret = SEC_OK;
ASF_GET_DS
memset(&cipher_header, 0x00, CIPHER_IMG_HEADER_SIZE);
if( !ASF_FILE_ERROR(fp) )
{
ASF_SEEK_SET(fp, start_off);
/* get header */
if (CIPHER_IMG_HEADER_SIZE != (read_sz = ASF_READ(fp, (char*)&cipher_header, CIPHER_IMG_HEADER_SIZE)))
{
SMSG(true,"[%s] read size '%d' != '%d'\n",MOD,read_sz,CIPHER_IMG_HEADER_SIZE);
ret = ERR_IMAGE_CIPHER_READ_FAIL;
goto _read_hdr_fail;
}
}
else
{
SMSG(true,"[%s] file pointer is NULL\n",MOD);
ret = ERR_IMAGE_CIPHER_IMG_NOT_FOUND;
goto _img_hdr_not_found;
}
#if DUMP_MORE_FOR_DEBUG
SMSG(true,"[%s] sec_cipherfmt_check_cipher - dump header\n",MOD);
sec_cipherfmt_dump_buffer((char*)&cipher_header, CIPHER_IMG_HEADER_SIZE);
#endif
if( CIPHER_IMG_MAGIC != cipher_header.magic_number )
{
SMSG(true,"[%s] magic number is wrong\n",MOD);
ret = ERR_IMAGE_CIPHER_HEADER_NOT_FOUND;
goto _img_hdr_not_found;
}
*img_len = cipher_header.image_length;
_img_hdr_not_found:
_read_hdr_fail:
ASF_PUT_DS
return ret;
}
/******************************************************************************
* WRITE IMAGE FOR S-BOOT USAGE (FROM NAND or eMMC DEVICE)
******************************************************************************/
static U32 sec_util_write_image (U8* img_name, U8 *buf, U32 offset, U32 size)
{
BOOL ret = SEC_OK;
U32 i = 0;
U32 cnt = 0;
U32 now_offset = 0;
U32 total_pages = 0;
U32 start_offset = offset;
blkdev_t *bootdev = NULL;
part_t *part = NULL;
U64 dest;
if (NULL == (bootdev = blkdev_get(CFG_BOOT_DEV)))
{
SMSG("[%s] can't find boot device(%d)\n", MOD, CFG_BOOT_DEV);
ASSERT(0);
}
/* ======================== */
/* get part info */
/* ======================== */
/* part_get should be device abstraction function */
if(NULL == (part = part_get (sec2plname(img_name))))
{
SMSG("[%s] part_get fail\n", MOD);
ASSERT(0);
}
/* ======================== */
/* write part data */
/* ======================== */
/* part_load should be device abstraction function */
if(TRUE == bDumpPartInfo)
{
SMSG("[%s] part load '0x%x'\n", MOD, part->startblk * bootdev->blksz);
bDumpPartInfo = FALSE;
}
dest = part->startblk * bootdev->blksz + offset;
if (-1 == blkdev_write(bootdev, dest, size, buf))
{
SMSG("[%s] part_store fail\n", MOD);
ASSERT(0);
}
return ret;
}
static void sec_signfmt_dump_buffer(uchar* buf, uint32 len)
{
uint32 i = 0;
for (i =1; i <len+1; i++)
{
SMSG(true,"0x%x,",buf[i-1]);
if(0 == (i%8))
SMSG(true,"\n");
}
if(0 != (len%8))
SMSG(true,"\n");
}
/**************************************************************************
* UTILITY
**************************************************************************/
void dump_buf(U8* buf, U32 len)
{
U32 i = 0;
for (i =1; i <len+1; i++)
{
SMSG("0x%x,",buf[i-1]);
if(0 == (i%8))
SMSG("\n");
}
if(0 != (len%8))
SMSG("\n");
}
void JsonTest::test02()
{
SLOG(CLS_NAME, "test01");
String str;
Json* json1 = Json::getNewObject();
Json* json2 = Json::getNewObject();
json2->add("addr", "Tokyo");
json2->add("tel", "03");
json1->add(json2);
Json* json3 = Json::getNewObject();
json3->add("addr", "Osaka");
json3->add("tel", "06");
json1->add(json3);
json1->serialize(&str);
SMSG(slog::DEBUG, "%s", str.getBuffer());
SASSERT("01", str.equals(
"["
"{\"addr\":\"Tokyo\",\"tel\":\"03\"},"
"{\"addr\":\"Osaka\",\"tel\":\"06\"}"
"]"));
delete json1;
}
static BOOL sec_util_force_brom_download_recovery(void)
{
#define SEC_PL_ERASE_SIZE 2048
u8 *sec_buf = sec_util_get_img_buf();
memset(sec_buf,0,SEC_PL_ERASE_SIZE);
if(SEC_OK != sec_util_write_image (SBOOT_PART_PL, sec_buf, 0, SEC_PL_ERASE_SIZE))
{
SMSG("[%s] Write image fail for seek offset 0x%x\n",MOD,0);
return FALSE;
}
SMSG("[%s] Force brom download recovery success\n", MOD);
return TRUE;
}
/*!
* \brief データベースバージョン取得
*
* \return データベースバージョン
*/
int32_t SequenceLogServiceDB::getVersion() const
{
SLOG(CLS_NAME, "getVersion");
int32_t version = 0;
Statement* stmt = nullptr;
try
{
const char* sql = "select version from version_info";
stmt = newStatement();
stmt->prepare(sql);
stmt->setIntResult(0, &version);
stmt->bind();
stmt->execute();
stmt->fetch();
}
catch (Exception e)
{
// 初回起動時などテーブルが存在しない場合もあるので、
// 例外が発生しても何もすることはない
SMSG(slog::DEBUG, "%s", e.getMessage());
}
delete stmt;
return version;
}
/**************************************************************************
* FUNCTION To Get Signature Length
**************************************************************************/
unsigned int sec_signfmt_get_signature_length_v3(SECURE_IMG_INFO_V3 *img_if, ASF_FILE fp, SEC_IMG_HEADER *file_img_hdr, char *ext_buf)
{
uint32 crypto_hdr_offset = 0;
uint32 read_sz = 0;
SEC_EXTENSTION_CRYPTO ext_crypto;
SEC_EXTENSTION_CRYPTO *ext_crypto_ptr = NULL;
uint32 ext_crypto_size = sizeof(SEC_EXTENSTION_CRYPTO);
/* get from seccfg's extension header */
if (ASF_FILE_NULL == fp)
{
ext_crypto_ptr = (SEC_EXTENSTION_CRYPTO *)(ext_buf + img_if->ext_offset + img_if->header.v3.signature_length);
return get_signature_size((SEC_CRYPTO_SIGNATURE_TYPE)ext_crypto_ptr->sig_type);
}
/* get from file's extension header */
else
{
memset(&ext_crypto, 0x00, ext_crypto_size);
/* seek to crypto header offset */
crypto_hdr_offset = file_img_hdr->signature_offset + file_img_hdr->signature_length;
ASF_SEEK_SET(fp, crypto_hdr_offset);
/* read crypto header */
if (ext_crypto_size != (read_sz = ASF_READ(fp, (char*)&ext_crypto, ext_crypto_size)))
{
SMSG(true,"[%s] read sz '%d' != '%d'\n",MOD,read_sz,ext_crypto_size);
return -1;
}
return get_signature_size((SEC_CRYPTO_SIGNATURE_TYPE)ext_crypto.sig_type);
}
}
int lib_aes_dec(uchar* input_buf, uint32 input_len, uchar* output_buf, uint32 output_len)
{
switch (g_ver)
{
case AES_VER_LEGACY:
if(0 != aes_legacy_dec(input_buf,input_len,output_buf,output_len))
{
goto _err;
}
break;
case AES_VER_SO:
if(0 != aes_so_dec(input_buf,input_len,output_buf,output_len))
{
goto _err;
}
break;
default:
SMSG("[%s] Invalid Ver\n",MOD);
goto _err;
}
return 0;
_err:
return -1;
}
/**************************************************************************
* SECURE BOOT
**************************************************************************/
int sec_boot_key_init (void)
{
int ret = SEC_OK;
if(TRUE == sec_info.bKeyInitDis)
{
SMSG(true,"[%s] key init disabled\n",MOD);
goto _end;
}
/* ------------------------------ */
/* init aes */
/* ------------------------------ */
if(SEC_OK != (ret = sec_aes_init()))
{
goto _end;
}
/* ------------------------------ */
/* init rsa */
/* ------------------------------ */
if(SEC_OK != (ret = sec_init_key( rom_info.m_SEC_KEY.sml_auth_rsa_n,
sizeof(rom_info.m_SEC_KEY.sml_auth_rsa_n),
rom_info.m_SEC_KEY.sml_auth_rsa_e,
sizeof(rom_info.m_SEC_KEY.sml_auth_rsa_e))))
{
goto _end;
}
_end:
return ret;
}
