在android启动过程中，首先启动的便是uboot，uboot是负责引导内核装入内存启动或者是引导recovery模式的启动。现在在很多android的uboot的启动过程中，都需要对内核镜像和ramdisk进行验证，来保证android系统的安全性，如果在uboot引导过程中，如果内核镜像或ramdisk刷入的是第三方的未经过签名认证的相关镜像，则系统无法启动，这样便保证了android系统的安全性。
在uboot启动过程中，是从start.S开始的，这里详细的细节不在赘述了，该篇文章主要学习uboot对内核镜像和ramdisk镜像的验证启动过程，同时学习一下里面的优秀巧妙的编码方式。
我们从arch/arm/lib/board.c的函数board_init_r函数开始，我们来看一下该代码：
void board_init_r(gd_t *id, ulong dest_addr)
{
gd = id;
gd->flags |= GD_FLG_RELOC; /* tell others: relocation done */
monitor_flash_len = _end_ofs;
debug("monitor flash len: %08lX\n", monitor_flash_len);
board_init(); /* Setup chipselects */
#if defined(CONFIG_MISC_INIT_R)
/* miscellaneous platform dependent initialisations */
misc_init_r();
#endif
#if defined(CONFIG_USE_IRQ)
/* set up exceptions */
interrupt_init();
/* enable exceptions */
enable_interrupts();
printf("init interrupt done!\n");
#endif
#if defined(CONFIG_COMIP_FASTBOOT) && defined(CONFIG_LCD_SUPPORT)
if (gd->fastboot) {
/*register lcd support*/
#if defined (CONFIG_LCD_AUO_OTM1285A_OTP)
extern int lcd_auo_otm1285a_otp_init(void);
lcd_auo_otm1285a_otp_init();
#endif
#if defined (CONFIG_LCD_AUO_R61308OTP)
extern int lcd_auo_r61308opt_init(void);
lcd_auo_r61308opt_init();
#endif
#if defined (CONFIG_LCD_AUO_NT35521)
extern int lcd_auo_nt35521_init(void);
lcd_auo_nt35521_init();
#endif
#if defined (CONFIG_LCD_SHARP_R69431)
extern int lcd_sharp_eR69431_init(void);
lcd_sharp_eR69431_init();
#endif
/*initialize lcdc & display logo*/
extern int comipfb_probe(void);
comipfb_probe();
}
#endif
#if defined(CONFIG_COMIP_TARGETLOADER)
extern int targetloader_init(void);
targetloader_init();
#elif defined(CONFIG_COMIP_FASTBOOT)
if (gd->fastboot) {
extern int fastboot_init(void);
fastboot_init();
while(1);
}
#endif
#if defined(CONFIG_ENABLE_SECURE_VERIFY_FOR_BOOT)
extern int secure_verify(void);
extern void pmic_power_off(void);
if(secure_verify()) {
printf("Secure verify failed! Shutdown now!\n");
pmic_power_off();
} else {
printf("Secure verify succeed!\n");
}
#endif
do_bootm_linux();
/* main_loop() can return to retry autoboot, if so just run it again. */
for (;;) {
//main_loop();
}
/* NOTREACHED - no way out of command loop except booting */
}
首先该函数做的是初始化board，调用board_init()函数。该函数位于board/****/***.c文件中，该文件由于属于板子厂家，所以暂时保密。我们来看一下这个函数：
int board_init(void)
{
gd->bd->bi_arch_number = MACH_TYPE_LC186X;
gd->bd->bi_boot_params = CONFIG_BOOT_PARAMS_LOADADDR;
#ifndef CONFIG_COMIP_TARGETLOADER
tl420_init();
watchdog_init();
comip_lc186x_coresight_config();
comip_lc186x_sysclk_config();
comip_lc186x_sec_config();
comip_lc186x_bus_prior_config();
#endif
#if defined(COMIP_LOW_POWER_MODE_ENABLE)
comip_lp_regs_init();
#endif
icache_enable();
//dcache_enable();
#if CONFIG_COMIP_EMMC_ENHANCE
mmc_set_dma(1);
#endif
flash_init();
#ifndef CONFIG_COMIP_TARGETLOADER
pmic_power_on_key_check();
boot_image();
pmic_power_on_key_check();
#endif
#ifdef CONFIG_PMIC_VIBRATOR
pmic_vibrator_enable_set();
#endif
return 0;
}
在该函数中，主要是用于初始化一些参数和硬件，包括arch版本号，boot加载地址，初始化watchdog，系统时钟，总线，flash，同时还需要做的就是，我们开机时的按钮监听，组合键按钮监听，启动镜像，开机震动等操作，在这里我们看一下boot_image()函数的实现。
static void boot_image(void)
{
char *kernel_name = CONFIG_PARTITION_KERNEL;
char *ramdisk_name = CONFIG_PARTITION_RAMDISK;
int pu_reason;
int key_code;
int ret;
pu_reason = pmic_power_up_reason_get();
if ((pu_reason == PU_REASON_REBOOT_RECOVERY)
|| (pu_reason == PU_REASON_REBOOT_FOTA)
|| check_recovery_misc() || check_recovery_fota()) {
gd->boot_mode = BOOT_MODE_RECOVERY;
ramdisk_name = CONFIG_PARTITION_RAMDISK_RECOVERY;
#if defined(CONFIG_USE_KERNEL_RECOVERY)
kernel_name = CONFIG_PARTITION_KERNEL_RECOVERY;
#endif
} else {
ret = keypad_init();
if (ret)
printf("keypad init failed!\n");
key_code = keypad_check();
printf("key code: %d\n", key_code);
if(pu_reason == PU_REASON_USB_CHARGER
#if defined(CONFIG_COMIP_FASTBOOT)
&& key_code != CONFIG_KEY_CODE_FASTBOOT
#endif
) {
gd->boot_mode = BOOT_MODE_NORMAL;
ramdisk_name = CONFIG_PARTITION_RAMDISK_AMT1;
} else {
switch (key_code) {
case KEY_CODE_RECOVERY:
gd->boot_mode = BOOT_MODE_RECOVERY;
ramdisk_name = CONFIG_PARTITION_RAMDISK_RECOVERY;
#if defined(CONFIG_USE_KERNEL_RECOVERY)
kernel_name = CONFIG_PARTITION_KERNEL_RECOVERY;
#endif
break;
#if defined(CONFIG_USE_RAMDISK_AMT3)
case KEY_CODE_AMT3:
gd->boot_mode = BOOT_MODE_AMT3;
ramdisk_name = CONFIG_PARTITION_RAMDISK_AMT3;
break;
#endif
default:
gd->boot_mode = BOOT_MODE_NORMAL;
ramdisk_name = CONFIG_PARTITION_RAMDISK;
break;
}
#if defined(CONFIG_COMIP_FASTBOOT)
if (key_code == CONFIG_KEY_CODE_FASTBOOT) {
printf("goto fastmode!\n");
gd->fastboot = 1;
}
#endif
}
}
printf("kernel name: %s, ramdisk name: %s\n", kernel_name, ramdisk_name);
flash_partition_read(kernel_name, (u8*)(CONFIG_KERNEL_LOADADDR - IMAGE_ADDR_OFFSET), 0xffffffff);
flash_partition_read(ramdisk_name, (u8*)(CONFIG_RAMDISK_LOADADDR - IMAGE_ADDR_OFFSET), 0xffffffff);
#if defined(CONFIG_COMIP_FASTBOOT) && defined(CONFIG_LCD_SUPPORT)
if (unlikely(gd->fastboot))
flash_partition_read(CONFIG_PARTITION_FASTBOOT_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
else
flash_partition_read(CONFIG_PARTITION_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
#else
flash_partition_read(CONFIG_PARTITION_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
#endif
printf("boot image end\n");
}
#endif /* !CONFIG_COMIP_TARGETLOADER */
在这里首先需要确定内核镜像和ramdisk镜像的地址，然后初始化按钮监听，根据不同的按钮组合按键启动不同的镜像，包括正常启动，也就是说启动内核，启动android；启动recovery镜像；启动工厂模式等。将这些镜像数据读取进入flash中引导启动。
接着我们回到board.c，程序接着运行，接着初始化misc，初始化中断，使能中断；同时在这里判断是否进去fastboot模式。接着，进入我们的重点，也就是安全启动验证阶段。
#if defined(CONFIG_ENABLE_SECURE_VERIFY_FOR_BOOT)
extern int secure_verify(void);
extern void pmic_power_off(void);
if(secure_verify()) {
printf("Secure verify failed! Shutdown now!\n");
pmic_power_off();
} else {
printf("Secure verify succeed!\n");
}
#endif
在这里，我们刚刚说了，已经把相应的内核镜像数据和ramdisk镜像数据读入到flash中了。
那么uboot又是如何验证内核镜像和ramdisk镜像的呢？我们接着看。
我们先来看函数secure_verify()函数。
int secure_verify(void)
{
getverifyimage(VERIFY_KERNEL);
if (image_rsa_verify()) {
printf("kernel verify failed!\n");
return 1;
} else {
printf("kernel verify ok!\n");
getverifyimage(VERIFY_RAMDISK);
if(image_rsa_verify()) {
printf("ramdisk verify failed!\n");
return 1;
} else {
printf("ramdisk verify ok!\n");
}
}
return 0;
}
在这段代码中，我们可以看出，首先是获取内核镜像数据，然后进行rsa签名验证，接着获取ramdisk镜像数据，接着进行签名验证。
我们来看一下如何获取内核镜像数据或者是ramdisk镜像数据，也就是getverifyimage()函数。
void getverifyimage(int whichimage)
{
int i;
unsigned int *cfgInfor = image_data_all;
int ret;
if(whichimage == VERIFY_KERNEL) {
image_data_all = CONFIG_KERNEL_LOADADDR - HEADINFOLEN;
} else if(whichimage == VERIFY_RAMDISK) {
image_data_all = CONFIG_RAMDISK_LOADADDR - HEADINFOLEN;
}
cfgInfor = (unsigned int *)image_data_all;
ORIGIN_IMAGE_LEN = cfgInfor[0];
for(i=0; i<(256/4); i++)
{
RSASIGNATURE[i] = cfgInfor[i + (RSASIGNEDLEN / 4)];
}
for(i=0; i<(524/4); i++)
{
RSAPUBKEYSTRU[i] = cfgInfor[i + (RSAPUBKEYLEN / 4)];
}
ORIGIN_IMAGE_BASEADDR = &image_data_all[HEADINFOLEN];
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
printf("image len:0x%x(%d)\n", ORIGIN_IMAGE_LEN, ORIGIN_IMAGE_LEN);
dumphex("rsa pub key", RSAPUBKEYSTRU, 524/4);
dumpint("rsa pub key", RSAPUBKEYSTRU, 524/4);
#endif
}
我们以内核启动验证为例进行讲解，ramdisk是一样的。我先来画一下内核镜像数据在flash中的分布，这样分析起代码来便会更容易理解。
首先我们需要了解的是，我们刷入的内核镜像并不是可运行的内核镜像，因为我们在真正的内核镜像之前加入了一个小小的1.5K的头，该头里面包含了内核的大小，经过私钥对内核签名后的签名，以及需要使用的公钥生成的一些属性。所以在该获取镜像的函数中，我们获取了所有的内核镜像数据，内核镜像大小，签名数据以及公钥属性数据。
下面我们就需要对其进行rsa验证。
/******************************************************
Let image to do RSA verify. If verify OK,
return 0. Otherwise, return 1.
*******************************************************/
int image_rsa_verify(void)
{
unsigned int value, i;
unsigned char *image_sha256;
unsigned char *signature;
RSAPublicKey *public_key;
SHA256_CTX ctx;
updateNum = 0;
value = rsaPubKey_sha256_verify();
if(value == 1)
return 1;
updateNum = 0;
image_sha256 = (unsigned char*)SHA256_hash(ORIGIN_IMAGE_BASEADDR, ORIGIN_IMAGE_LEN, image_sha256, &ctx);
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
dumphex("current image hash", uboot_sha256, 32);
#endif
for(i=0; i<32; i++)
ORIGIN_IMAGE_SHA[i] = image_sha256[i];
updateNum = 0;
signature = (unsigned char*)RSASIGNATURE;
public_key = (RSAPublicKey *)RSAPUBKEYSTRU;
value = RSA_verify(public_key, signature, 256, ORIGIN_IMAGE_SHA, 32);
if(value == 0)
return 1;
return 0;
}
通过这个函数可以看到，对内核进行了两次验证，一次是通过函数rsaPubKey_sha256_verify()进行验证，另外一个是通过RSA_verify进行验证，我们先来看第一个：
/****************************************************
Use SHA256 to generate digest of RSA pub-key,
which is 524 BYTES. Then compare the digest
with the original digest which is store in the
EFUSE. If the new digest equals original digest,
it means RSA pub-key is right. Otherwise, means
the RSA pub-key is wrong.
*****************************************************/
int rsaPubKey_sha256_verify(void)
{
unsigned int *digest, origDigest[8], i, result;
unsigned char *newDigest;
SHA256_CTX ctx;
digest = (unsigned int *)SHA256_hash(RSAPUBKEYSTRU, 524, newDigest, &ctx);
#if 1
origDigest[0] = *RSA_SIGNATURE0;
origDigest[1] = *RSA_SIGNATURE1;
origDigest[2] = *RSA_SIGNATURE2;
origDigest[3] = *RSA_SIGNATURE3;
origDigest[4] = *RSA_SIGNATURE4;
origDigest[5] = *RSA_SIGNATURE5;
origDigest[6] = *RSA_SIGNATURE6;
origDigest[7] = *RSA_SIGNATURE7;
#else
origDigest[0] = rsahash[0];
origDigest[1] = rsahash[1];
origDigest[2] = rsahash[2];
origDigest[3] = rsahash[3];
origDigest[4] = rsahash[4];
origDigest[5] = rsahash[5];
origDigest[6] = rsahash[6];
origDigest[7] = rsahash[7];
#endif
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
dumphex("pubkey hash", digest, 32);
dumphex("read pubkey hash", origDigest, 32);
#endif
//new key and old key xor
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
printf("read pubkey hash:\n");
#endif
for(i=0; i<8; i++)
{
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
printf("%08x ", origDigest[i]);
#endif
result = ((origDigest[i]) ^ (digest[i]));
if(result != 0) {
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
printf("ERROR! %s %d\n", __func__,__LINE__);
#endif
return 1;
}
}
#if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
dumphex("pubkey hash", digest, 32);
#endif
return 0;
这里是对公钥进行sha256签名来验证公钥是否是对的，具体的函数实现不再学习。
接着通过对内核镜像数据进行sha256获取哈希，然后，使用公钥和签名进行签名验证，验证内核镜像数据是否是正确的。这样，通过这两步，必须两步都对，才能进行内核的正常加载和运行。
ramdisk镜像的签名验证也是如何，对内核镜像和ramdisk镜像签名验证之后，接着执行下面的操作，也就是执行do_bootm_linux()函数，该函数的实现如下：
void do_bootm_linux(void)
{
bd_t *bd = gd->bd;
void (*theKernel) (int zero, int arch, uint params);
theKernel = (void (*)(int, int, uint))CONFIG_KERNEL_LOADADDR;
params = (struct tag *)bd->bi_boot_params;
params->hdr.tag = ATAG_CORE;
params->hdr.size = tag_size(tag_core);
params->u.core.flags = 0;
params->u.core.pagesize = 0;
params->u.core.rootdev = 0;
params = tag_next(params);
params = comip_set_boot_params(params);
params->hdr.tag = ATAG_NONE;
params->hdr.size = 0;
/* we assume that the kernel is in place */
printf("\nStarting kernel ...\n");
cleanup_before_linux();
theKernel(0, bd->bi_arch_number, bd->bi_boot_params);
}
在这里实际上就是通过一个theKernel函数指针，加载内核启动运行，这样，便进行内核的启动运行了。
这样，我们便把uboot的启动流程以及对内核和ramdisk进行启动验证的过程进行了一个整体的学习，其内部的RSA算法实现不再赘述。