image: Add RSA support for image signing
[platform/kernel/u-boot.git] / common / image-sig.c
1 /*
2  * Copyright (c) 2013, Google Inc.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of
7  * the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
17  * MA 02111-1307 USA
18  */
19
20 #ifdef USE_HOSTCC
21 #include "mkimage.h"
22 #include <time.h>
23 #else
24 #include <common.h>
25 #include <malloc.h>
26 DECLARE_GLOBAL_DATA_PTR;
27 #endif /* !USE_HOSTCC*/
28 #include <errno.h>
29 #include <image.h>
30 #include <rsa.h>
31
32 struct image_sig_algo image_sig_algos[] = {
33         {
34                 "sha1,rsa2048",
35                 rsa_sign,
36                 rsa_add_verify_data,
37                 rsa_verify,
38         }
39 };
40
41 struct image_sig_algo *image_get_sig_algo(const char *name)
42 {
43         int i;
44
45         for (i = 0; i < ARRAY_SIZE(image_sig_algos); i++) {
46                 if (!strcmp(image_sig_algos[i].name, name))
47                         return &image_sig_algos[i];
48         }
49
50         return NULL;
51 }
52
53 static int fit_image_setup_verify(struct image_sign_info *info,
54                 const void *fit, int noffset, int required_keynode,
55                 char **err_msgp)
56 {
57         char *algo_name;
58
59         if (fit_image_hash_get_algo(fit, noffset, &algo_name)) {
60                 *err_msgp = "Can't get hash algo property";
61                 return -1;
62         }
63         memset(info, '\0', sizeof(*info));
64         info->keyname = fdt_getprop(fit, noffset, "key-name-hint", NULL);
65         info->fit = (void *)fit;
66         info->node_offset = noffset;
67         info->algo = image_get_sig_algo(algo_name);
68         info->fdt_blob = gd_fdt_blob();
69         info->required_keynode = required_keynode;
70         printf("%s:%s", algo_name, info->keyname);
71
72         if (!info->algo) {
73                 *err_msgp = "Unknown signature algorithm";
74                 return -1;
75         }
76
77         return 0;
78 }
79
80 int fit_image_check_sig(const void *fit, int noffset, const void *data,
81                 size_t size, int required_keynode, char **err_msgp)
82 {
83         struct image_sign_info info;
84         struct image_region region;
85         uint8_t *fit_value;
86         int fit_value_len;
87
88         *err_msgp = NULL;
89         if (fit_image_setup_verify(&info, fit, noffset, required_keynode,
90                                    err_msgp))
91                 return -1;
92
93         if (fit_image_hash_get_value(fit, noffset, &fit_value,
94                                      &fit_value_len)) {
95                 *err_msgp = "Can't get hash value property";
96                 return -1;
97         }
98
99         region.data = data;
100         region.size = size;
101
102         if (info.algo->verify(&info, &region, 1, fit_value, fit_value_len)) {
103                 *err_msgp = "Verification failed";
104                 return -1;
105         }
106
107         return 0;
108 }
109
110 static int fit_image_verify_sig(const void *fit, int image_noffset,
111                 const char *data, size_t size, const void *sig_blob,
112                 int sig_offset)
113 {
114         int noffset;
115         char *err_msg = "";
116         int verified = 0;
117         int ret;
118
119         /* Process all hash subnodes of the component image node */
120         for (noffset = fdt_first_subnode(fit, image_noffset);
121              noffset >= 0;
122              noffset = fdt_next_subnode(fit, noffset)) {
123                 const char *name = fit_get_name(fit, noffset, NULL);
124
125                 if (!strncmp(name, FIT_SIG_NODENAME,
126                              strlen(FIT_SIG_NODENAME))) {
127                         ret = fit_image_check_sig(fit, noffset, data,
128                                                         size, -1, &err_msg);
129                         if (ret) {
130                                 puts("- ");
131                         } else {
132                                 puts("+ ");
133                                 verified = 1;
134                                 break;
135                         }
136                 }
137         }
138
139         if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
140                 err_msg = "Corrupted or truncated tree";
141                 goto error;
142         }
143
144         return verified ? 0 : -EPERM;
145
146 error:
147         printf(" error!\n%s for '%s' hash node in '%s' image node\n",
148                err_msg, fit_get_name(fit, noffset, NULL),
149                fit_get_name(fit, image_noffset, NULL));
150         return -1;
151 }
152
153 int fit_image_verify_required_sigs(const void *fit, int image_noffset,
154                 const char *data, size_t size, const void *sig_blob,
155                 int *no_sigsp)
156 {
157         int verify_count = 0;
158         int noffset;
159         int sig_node;
160
161         /* Work out what we need to verify */
162         *no_sigsp = 1;
163         sig_node = fdt_subnode_offset(sig_blob, 0, FIT_SIG_NODENAME);
164         if (sig_node < 0) {
165                 debug("%s: No signature node found: %s\n", __func__,
166                       fdt_strerror(sig_node));
167                 return 0;
168         }
169
170         for (noffset = fdt_first_subnode(sig_blob, sig_node);
171              noffset >= 0;
172              noffset = fdt_next_subnode(sig_blob, noffset)) {
173                 const char *required;
174                 int ret;
175
176                 required = fdt_getprop(sig_blob, noffset, "required", NULL);
177                 if (!required || strcmp(required, "image"))
178                         continue;
179                 ret = fit_image_verify_sig(fit, image_noffset, data, size,
180                                         sig_blob, noffset);
181                 if (ret) {
182                         printf("Failed to verify required signature '%s'\n",
183                                fit_get_name(sig_blob, noffset, NULL));
184                         return ret;
185                 }
186                 verify_count++;
187         }
188
189         if (verify_count)
190                 *no_sigsp = 0;
191
192         return 0;
193 }