common/image-sig.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013, Google Inc.
   4  */
   5
   6 #ifdef USE_HOSTCC
   7 #include "mkimage.h"
   8 #include <fdt_support.h>
   9 #include <time.h>
  10 #include <linux/libfdt.h>
  11 #else
  12 #include <common.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <asm/global_data.h>
  16 DECLARE_GLOBAL_DATA_PTR;
  17 #endif /* !USE_HOSTCC*/
  18 #include <image.h>
  19 #include <u-boot/rsa.h>
  20 #include <u-boot/hash-checksum.h>
  21
  22 #define IMAGE_MAX_HASHED_NODES          100
  23
  24 struct checksum_algo checksum_algos[] = {
  25         {
  26                 .name = "sha1",
  27                 .checksum_len = SHA1_SUM_LEN,
  28                 .der_len = SHA1_DER_LEN,
  29                 .der_prefix = sha1_der_prefix,
  30 #if IMAGE_ENABLE_SIGN
  31                 .calculate_sign = EVP_sha1,
  32 #endif
  33                 .calculate = hash_calculate,
  34         },
  35         {
  36                 .name = "sha256",
  37                 .checksum_len = SHA256_SUM_LEN,
  38                 .der_len = SHA256_DER_LEN,
  39                 .der_prefix = sha256_der_prefix,
  40 #if IMAGE_ENABLE_SIGN
  41                 .calculate_sign = EVP_sha256,
  42 #endif
  43                 .calculate = hash_calculate,
  44         },
  45 #ifdef CONFIG_SHA384
  46         {
  47                 .name = "sha384",
  48                 .checksum_len = SHA384_SUM_LEN,
  49                 .der_len = SHA384_DER_LEN,
  50                 .der_prefix = sha384_der_prefix,
  51 #if IMAGE_ENABLE_SIGN
  52                 .calculate_sign = EVP_sha384,
  53 #endif
  54                 .calculate = hash_calculate,
  55         },
  56 #endif
  57 #ifdef CONFIG_SHA512
  58         {
  59                 .name = "sha512",
  60                 .checksum_len = SHA512_SUM_LEN,
  61                 .der_len = SHA512_DER_LEN,
  62                 .der_prefix = sha512_der_prefix,
  63 #if IMAGE_ENABLE_SIGN
  64                 .calculate_sign = EVP_sha512,
  65 #endif
  66                 .calculate = hash_calculate,
  67         },
  68 #endif
  69
  70 };
  71
  72 struct crypto_algo crypto_algos[] = {
  73         {
  74                 .name = "rsa2048",
  75                 .key_len = RSA2048_BYTES,
  76                 .sign = rsa_sign,
  77                 .add_verify_data = rsa_add_verify_data,
  78                 .verify = rsa_verify,
  79         },
  80         {
  81                 .name = "rsa4096",
  82                 .key_len = RSA4096_BYTES,
  83                 .sign = rsa_sign,
  84                 .add_verify_data = rsa_add_verify_data,
  85                 .verify = rsa_verify,
  86         }
  87
  88 };
  89
  90 struct padding_algo padding_algos[] = {
  91         {
  92                 .name = "pkcs-1.5",
  93                 .verify = padding_pkcs_15_verify,
  94         },
  95 #ifdef CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT
  96         {
  97                 .name = "pss",
  98                 .verify = padding_pss_verify,
  99         }
 100 #endif /* CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT */
 101 };
 102
 103 struct checksum_algo *image_get_checksum_algo(const char *full_name)
 104 {
 105         int i;
 106         const char *name;
 107
 108 #if !defined(USE_HOSTCC) && defined(CONFIG_NEEDS_MANUAL_RELOC)
 109         static bool done;
 110
 111         if (!done) {
 112                 done = true;
 113                 for (i = 0; i < ARRAY_SIZE(checksum_algos); i++) {
 114                         checksum_algos[i].name += gd->reloc_off;
 115 #if IMAGE_ENABLE_SIGN
 116                         checksum_algos[i].calculate_sign += gd->reloc_off;
 117 #endif
 118                         checksum_algos[i].calculate += gd->reloc_off;
 119                 }
 120         }
 121 #endif
 122
 123         for (i = 0; i < ARRAY_SIZE(checksum_algos); i++) {
 124                 name = checksum_algos[i].name;
 125                 /* Make sure names match and next char is a comma */
 126                 if (!strncmp(name, full_name, strlen(name)) &&
 127                     full_name[strlen(name)] == ',')
 128                         return &checksum_algos[i];
 129         }
 130
 131         return NULL;
 132 }
 133
 134 struct crypto_algo *image_get_crypto_algo(const char *full_name)
 135 {
 136         int i;
 137         const char *name;
 138
 139 #if !defined(USE_HOSTCC) && defined(CONFIG_NEEDS_MANUAL_RELOC)
 140         static bool done;
 141
 142         if (!done) {
 143                 done = true;
 144                 for (i = 0; i < ARRAY_SIZE(crypto_algos); i++) {
 145                         crypto_algos[i].name += gd->reloc_off;
 146                         crypto_algos[i].sign += gd->reloc_off;
 147                         crypto_algos[i].add_verify_data += gd->reloc_off;
 148                         crypto_algos[i].verify += gd->reloc_off;
 149                 }
 150         }
 151 #endif
 152
 153         /* Move name to after the comma */
 154         name = strchr(full_name, ',');
 155         if (!name)
 156                 return NULL;
 157         name += 1;
 158
 159         for (i = 0; i < ARRAY_SIZE(crypto_algos); i++) {
 160                 if (!strcmp(crypto_algos[i].name, name))
 161                         return &crypto_algos[i];
 162         }
 163
 164         return NULL;
 165 }
 166
 167 struct padding_algo *image_get_padding_algo(const char *name)
 168 {
 169         int i;
 170
 171         if (!name)
 172                 return NULL;
 173
 174         for (i = 0; i < ARRAY_SIZE(padding_algos); i++) {
 175                 if (!strcmp(padding_algos[i].name, name))
 176                         return &padding_algos[i];
 177         }
 178
 179         return NULL;
 180 }