uboot启动过程详解

1万 · 2019-7-9 10:14

在android启动过程中，首先启动的便是uboot，uboot是负责引导内核装入内存启动或者是引导recovery模式的启动。现在在很多android的uboot的启动过程中，都需要对内核镜像和ramdisk进行验证，来保证android系统的安全性，如果在uboot引导过程中，如果内核镜像或ramdisk刷入的是第三方的未经过签名认证的相关镜像，则系统无法启动，这样便保证了android系统的安全性。

在uboot启动过程中，是从start.S开始的，这里详细的细节不在赘述了，该篇**主要学习uboot对内核镜像和ramdisk镜像的验证启动过程，同时学习一下里面的优秀巧妙的编码方式。

1万 · 2019-7-9 10:14

我们从arch/arm/lib/board.c的函数board_init_r函数开始，我们来看一下该代码：

void board_init_r(gd_t *id, ulong dest_addr)
{
      gd = id;

      gd->flags |= GD_**_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 ***/
         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 */
}

1万 · 2019-7-9 10:14

首先该函数做的是初始化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;
}

1万 · 2019-7-9 10:14

在该函数中，主要是用于初始化一些参数和硬件，包括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_**, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
      else
         flash_partition_read(CONFIG_PARTITION_**, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
#else
      flash_partition_read(CONFIG_PARTITION_**, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
#endif

      printf("boot image end\n");
}
#endif /* !CONFIG_COMIP_TARGETLOADER */

1万 · 2019-7-9 10:15

在这里首先需要确定内核镜像和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

1万 · 2019-7-9 10:15

在这里，我们刚刚说了，已经把相应的内核镜像数据和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;
}

1万 · 2019-7-9 10:15

在这段代码中，我们可以看出，首先是获取内核镜像数据，然后进行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
}

1万 · 2019-7-9 10:16

我们以内核启动验证为例进行讲解，ramdisk是一样的。我先来画一下内核镜像数据在flash中的分布，这样分析起代码来便会更容易理解。

1万 · 2019-7-9 10:16

首先我们需要了解的是，我们刷入的内核镜像并不是可运行的内核镜像，因为我们在真正的内核镜像之前加入了一个小小的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;
}

1万 · 2019-7-9 10:16

通过这个函数可以看到，对内核进行了两次验证，一次是通过函数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;

1万 · 2019-7-9 10:18

这里是对公钥进行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算法实现不再赘述。

1万 · 2019-8-7 10:04

感谢楼主分享

1万 · 2019-8-7 10:19

讲解的非常详细

1万 · 2019-8-7 10:50

非常感谢楼主分享

1万 · 2019-8-7 10:55

这也是很古老的问题了

1万 · 2019-8-7 10:58

但是很多人都不太会