LXR uboot/boot/image-sig.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (c) 2013, Google Inc.
   4 */
   5
   6#include <common.h>
   7#include <log.h>
   8#include <malloc.h>
   9#include <asm/global_data.h>
  10DECLARE_GLOBAL_DATA_PTR;
  11#include <image.h>
  12#include <relocate.h>
  13#include <u-boot/ecdsa.h>
  14#include <u-boot/rsa.h>
  15#include <u-boot/hash-checksum.h>
  16
  17#define IMAGE_MAX_HASHED_NODES          100
  18
  19struct checksum_algo checksum_algos[] = {
  20        {
  21                .name = "sha1",
  22                .checksum_len = SHA1_SUM_LEN,
  23                .der_len = SHA1_DER_LEN,
  24                .der_prefix = sha1_der_prefix,
  25                .calculate = hash_calculate,
  26        },
  27        {
  28                .name = "sha256",
  29                .checksum_len = SHA256_SUM_LEN,
  30                .der_len = SHA256_DER_LEN,
  31                .der_prefix = sha256_der_prefix,
  32                .calculate = hash_calculate,
  33        },
  34#ifdef CONFIG_SHA384
  35        {
  36                .name = "sha384",
  37                .checksum_len = SHA384_SUM_LEN,
  38                .der_len = SHA384_DER_LEN,
  39                .der_prefix = sha384_der_prefix,
  40                .calculate = hash_calculate,
  41        },
  42#endif
  43#ifdef CONFIG_SHA512
  44        {
  45                .name = "sha512",
  46                .checksum_len = SHA512_SUM_LEN,
  47                .der_len = SHA512_DER_LEN,
  48                .der_prefix = sha512_der_prefix,
  49                .calculate = hash_calculate,
  50        },
  51#endif
  52
  53};
  54
  55struct checksum_algo *image_get_checksum_algo(const char *full_name)
  56{
  57        int i;
  58        const char *name;
  59
  60        if (IS_ENABLED(CONFIG_NEEDS_MANUAL_RELOC)) {
  61                static bool done;
  62
  63                if (!done) {
  64                        done = true;
  65                        for (i = 0; i < ARRAY_SIZE(checksum_algos); i++) {
  66                                struct checksum_algo *algo = &checksum_algos[i];
  67
  68                                MANUAL_RELOC(algo->name);
  69                                MANUAL_RELOC(algo->calculate);
  70                        }
  71                }
  72        }
  73
  74        for (i = 0; i < ARRAY_SIZE(checksum_algos); i++) {
  75                name = checksum_algos[i].name;
  76                /* Make sure names match and next char is a comma */
  77                if (!strncmp(name, full_name, strlen(name)) &&
  78                    full_name[strlen(name)] == ',')
  79                        return &checksum_algos[i];
  80        }
  81
  82        return NULL;
  83}
  84
  85struct crypto_algo *image_get_crypto_algo(const char *full_name)
  86{
  87        struct crypto_algo *crypto, *end;
  88        const char *name;
  89
  90        if (IS_ENABLED(CONFIG_NEEDS_MANUAL_RELOC)) {
  91                static bool done;
  92
  93                if (!done) {
  94                        done = true;
  95                        crypto = ll_entry_start(struct crypto_algo, cryptos);
  96                        end = ll_entry_end(struct crypto_algo, cryptos);
  97                        for (; crypto < end; crypto++) {
  98                                MANUAL_RELOC(crypto->name);
  99                                MANUAL_RELOC(crypto->verify);
 100                        }
 101                }
 102        }
 103
 104        /* Move name to after the comma */
 105        name = strchr(full_name, ',');
 106        if (!name)
 107                return NULL;
 108        name += 1;
 109
 110        crypto = ll_entry_start(struct crypto_algo, cryptos);
 111        end = ll_entry_end(struct crypto_algo, cryptos);
 112        for (; crypto < end; crypto++) {
 113                if (!strcmp(crypto->name, name))
 114                        return crypto;
 115        }
 116
 117        /* Not found */
 118        return NULL;
 119}
 120
 121struct padding_algo *image_get_padding_algo(const char *name)
 122{
 123        struct padding_algo *padding, *end;
 124
 125        if (!name)
 126                return NULL;
 127
 128        padding = ll_entry_start(struct padding_algo, paddings);
 129        end = ll_entry_end(struct padding_algo, paddings);
 130        for (; padding < end; padding++) {
 131                if (!strcmp(padding->name, name))
 132                        return padding;
 133        }
 134
 135        return NULL;
 136}
 137