1
2
3
4
5
6
7
8
9
10
11
12#include <linux/crypto.h>
13#include <linux/verification.h>
14#include <crypto/hash.h>
15#include <crypto/sha.h>
16#include <crypto/algapi.h>
17#include <keys/user-type.h>
18#include <keys/asymmetric-type.h>
19
20#include "ubifs.h"
21
22
23
24
25
26
27
28
29
30int __ubifs_node_calc_hash(const struct ubifs_info *c, const void *node,
31 u8 *hash)
32{
33 const struct ubifs_ch *ch = node;
34
35 return crypto_shash_tfm_digest(c->hash_tfm, node, le32_to_cpu(ch->len),
36 hash);
37}
38
39
40
41
42
43
44
45
46
47static int ubifs_hash_calc_hmac(const struct ubifs_info *c, const u8 *hash,
48 u8 *hmac)
49{
50 return crypto_shash_tfm_digest(c->hmac_tfm, hash, c->hash_len, hmac);
51}
52
53
54
55
56
57
58
59
60
61
62
63
64int ubifs_prepare_auth_node(struct ubifs_info *c, void *node,
65 struct shash_desc *inhash)
66{
67 struct ubifs_auth_node *auth = node;
68 u8 hash[UBIFS_HASH_ARR_SZ];
69 int err;
70
71 {
72 SHASH_DESC_ON_STACK(hash_desc, c->hash_tfm);
73
74 hash_desc->tfm = c->hash_tfm;
75 ubifs_shash_copy_state(c, inhash, hash_desc);
76
77 err = crypto_shash_final(hash_desc, hash);
78 if (err)
79 return err;
80 }
81
82 err = ubifs_hash_calc_hmac(c, hash, auth->hmac);
83 if (err)
84 return err;
85
86 auth->ch.node_type = UBIFS_AUTH_NODE;
87 ubifs_prepare_node(c, auth, ubifs_auth_node_sz(c), 0);
88 return 0;
89}
90
91static struct shash_desc *ubifs_get_desc(const struct ubifs_info *c,
92 struct crypto_shash *tfm)
93{
94 struct shash_desc *desc;
95 int err;
96
97 if (!ubifs_authenticated(c))
98 return NULL;
99
100 desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
101 if (!desc)
102 return ERR_PTR(-ENOMEM);
103
104 desc->tfm = tfm;
105
106 err = crypto_shash_init(desc);
107 if (err) {
108 kfree(desc);
109 return ERR_PTR(err);
110 }
111
112 return desc;
113}
114
115
116
117
118
119
120
121
122struct shash_desc *__ubifs_hash_get_desc(const struct ubifs_info *c)
123{
124 return ubifs_get_desc(c, c->hash_tfm);
125}
126
127
128
129
130
131
132
133
134
135
136
137
138void ubifs_bad_hash(const struct ubifs_info *c, const void *node, const u8 *hash,
139 int lnum, int offs)
140{
141 int len = min(c->hash_len, 20);
142 int cropped = len != c->hash_len;
143 const char *cont = cropped ? "..." : "";
144
145 u8 calc[UBIFS_HASH_ARR_SZ];
146
147 __ubifs_node_calc_hash(c, node, calc);
148
149 ubifs_err(c, "hash mismatch on node at LEB %d:%d", lnum, offs);
150 ubifs_err(c, "hash expected: %*ph%s", len, hash, cont);
151 ubifs_err(c, "hash calculated: %*ph%s", len, calc, cont);
152}
153
154
155
156
157
158
159
160
161
162
163
164int __ubifs_node_check_hash(const struct ubifs_info *c, const void *node,
165 const u8 *expected)
166{
167 u8 calc[UBIFS_HASH_ARR_SZ];
168 int err;
169
170 err = __ubifs_node_calc_hash(c, node, calc);
171 if (err)
172 return err;
173
174 if (ubifs_check_hash(c, expected, calc))
175 return -EPERM;
176
177 return 0;
178}
179
180
181
182
183
184
185
186
187
188
189
190
191
192int ubifs_sb_verify_signature(struct ubifs_info *c,
193 const struct ubifs_sb_node *sup)
194{
195 int err;
196 struct ubifs_scan_leb *sleb;
197 struct ubifs_scan_node *snod;
198 const struct ubifs_sig_node *signode;
199
200 sleb = ubifs_scan(c, UBIFS_SB_LNUM, UBIFS_SB_NODE_SZ, c->sbuf, 0);
201 if (IS_ERR(sleb)) {
202 err = PTR_ERR(sleb);
203 return err;
204 }
205
206 if (sleb->nodes_cnt == 0) {
207 ubifs_err(c, "Unable to find signature node");
208 err = -EINVAL;
209 goto out_destroy;
210 }
211
212 snod = list_first_entry(&sleb->nodes, struct ubifs_scan_node, list);
213
214 if (snod->type != UBIFS_SIG_NODE) {
215 ubifs_err(c, "Signature node is of wrong type");
216 err = -EINVAL;
217 goto out_destroy;
218 }
219
220 signode = snod->node;
221
222 if (le32_to_cpu(signode->len) > snod->len + sizeof(struct ubifs_sig_node)) {
223 ubifs_err(c, "invalid signature len %d", le32_to_cpu(signode->len));
224 err = -EINVAL;
225 goto out_destroy;
226 }
227
228 if (le32_to_cpu(signode->type) != UBIFS_SIGNATURE_TYPE_PKCS7) {
229 ubifs_err(c, "Signature type %d is not supported\n",
230 le32_to_cpu(signode->type));
231 err = -EINVAL;
232 goto out_destroy;
233 }
234
235 err = verify_pkcs7_signature(sup, sizeof(struct ubifs_sb_node),
236 signode->sig, le32_to_cpu(signode->len),
237 NULL, VERIFYING_UNSPECIFIED_SIGNATURE,
238 NULL, NULL);
239
240 if (err)
241 ubifs_err(c, "Failed to verify signature");
242 else
243 ubifs_msg(c, "Successfully verified super block signature");
244
245out_destroy:
246 ubifs_scan_destroy(sleb);
247
248 return err;
249}
250
251
252
253
254
255
256
257int ubifs_init_authentication(struct ubifs_info *c)
258{
259 struct key *keyring_key;
260 const struct user_key_payload *ukp;
261 int err;
262 char hmac_name[CRYPTO_MAX_ALG_NAME];
263
264 if (!c->auth_hash_name) {
265 ubifs_err(c, "authentication hash name needed with authentication");
266 return -EINVAL;
267 }
268
269 c->auth_hash_algo = match_string(hash_algo_name, HASH_ALGO__LAST,
270 c->auth_hash_name);
271 if ((int)c->auth_hash_algo < 0) {
272 ubifs_err(c, "Unknown hash algo %s specified",
273 c->auth_hash_name);
274 return -EINVAL;
275 }
276
277 snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
278 c->auth_hash_name);
279
280 keyring_key = request_key(&key_type_logon, c->auth_key_name, NULL);
281
282 if (IS_ERR(keyring_key)) {
283 ubifs_err(c, "Failed to request key: %ld",
284 PTR_ERR(keyring_key));
285 return PTR_ERR(keyring_key);
286 }
287
288 down_read(&keyring_key->sem);
289
290 if (keyring_key->type != &key_type_logon) {
291 ubifs_err(c, "key type must be logon");
292 err = -ENOKEY;
293 goto out;
294 }
295
296 ukp = user_key_payload_locked(keyring_key);
297 if (!ukp) {
298
299 err = -EKEYREVOKED;
300 goto out;
301 }
302
303 c->hash_tfm = crypto_alloc_shash(c->auth_hash_name, 0, 0);
304 if (IS_ERR(c->hash_tfm)) {
305 err = PTR_ERR(c->hash_tfm);
306 ubifs_err(c, "Can not allocate %s: %d",
307 c->auth_hash_name, err);
308 goto out;
309 }
310
311 c->hash_len = crypto_shash_digestsize(c->hash_tfm);
312 if (c->hash_len > UBIFS_HASH_ARR_SZ) {
313 ubifs_err(c, "hash %s is bigger than maximum allowed hash size (%d > %d)",
314 c->auth_hash_name, c->hash_len, UBIFS_HASH_ARR_SZ);
315 err = -EINVAL;
316 goto out_free_hash;
317 }
318
319 c->hmac_tfm = crypto_alloc_shash(hmac_name, 0, 0);
320 if (IS_ERR(c->hmac_tfm)) {
321 err = PTR_ERR(c->hmac_tfm);
322 ubifs_err(c, "Can not allocate %s: %d", hmac_name, err);
323 goto out_free_hash;
324 }
325
326 c->hmac_desc_len = crypto_shash_digestsize(c->hmac_tfm);
327 if (c->hmac_desc_len > UBIFS_HMAC_ARR_SZ) {
328 ubifs_err(c, "hmac %s is bigger than maximum allowed hmac size (%d > %d)",
329 hmac_name, c->hmac_desc_len, UBIFS_HMAC_ARR_SZ);
330 err = -EINVAL;
331 goto out_free_hash;
332 }
333
334 err = crypto_shash_setkey(c->hmac_tfm, ukp->data, ukp->datalen);
335 if (err)
336 goto out_free_hmac;
337
338 c->authenticated = true;
339
340 c->log_hash = ubifs_hash_get_desc(c);
341 if (IS_ERR(c->log_hash))
342 goto out_free_hmac;
343
344 err = 0;
345
346out_free_hmac:
347 if (err)
348 crypto_free_shash(c->hmac_tfm);
349out_free_hash:
350 if (err)
351 crypto_free_shash(c->hash_tfm);
352out:
353 up_read(&keyring_key->sem);
354 key_put(keyring_key);
355
356 return err;
357}
358
359
360
361
362
363
364
365void __ubifs_exit_authentication(struct ubifs_info *c)
366{
367 if (!ubifs_authenticated(c))
368 return;
369
370 crypto_free_shash(c->hmac_tfm);
371 crypto_free_shash(c->hash_tfm);
372 kfree(c->log_hash);
373}
374
375
376
377
378
379
380
381
382
383
384
385
386
387static int ubifs_node_calc_hmac(const struct ubifs_info *c, const void *node,
388 int len, int ofs_hmac, void *hmac)
389{
390 SHASH_DESC_ON_STACK(shash, c->hmac_tfm);
391 int hmac_len = c->hmac_desc_len;
392 int err;
393
394 ubifs_assert(c, ofs_hmac > 8);
395 ubifs_assert(c, ofs_hmac + hmac_len < len);
396
397 shash->tfm = c->hmac_tfm;
398
399 err = crypto_shash_init(shash);
400 if (err)
401 return err;
402
403
404 err = crypto_shash_update(shash, node + 8, ofs_hmac - 8);
405 if (err < 0)
406 return err;
407
408
409 if (len - ofs_hmac - hmac_len > 0) {
410 err = crypto_shash_update(shash, node + ofs_hmac + hmac_len,
411 len - ofs_hmac - hmac_len);
412 if (err < 0)
413 return err;
414 }
415
416 return crypto_shash_final(shash, hmac);
417}
418
419
420
421
422
423
424
425
426
427
428
429
430
431int __ubifs_node_insert_hmac(const struct ubifs_info *c, void *node, int len,
432 int ofs_hmac)
433{
434 return ubifs_node_calc_hmac(c, node, len, ofs_hmac, node + ofs_hmac);
435}
436
437
438
439
440
441
442
443
444
445
446
447int __ubifs_node_verify_hmac(const struct ubifs_info *c, const void *node,
448 int len, int ofs_hmac)
449{
450 int hmac_len = c->hmac_desc_len;
451 u8 *hmac;
452 int err;
453
454 hmac = kmalloc(hmac_len, GFP_NOFS);
455 if (!hmac)
456 return -ENOMEM;
457
458 err = ubifs_node_calc_hmac(c, node, len, ofs_hmac, hmac);
459 if (err) {
460 kfree(hmac);
461 return err;
462 }
463
464 err = crypto_memneq(hmac, node + ofs_hmac, hmac_len);
465
466 kfree(hmac);
467
468 if (!err)
469 return 0;
470
471 return -EPERM;
472}
473
474int __ubifs_shash_copy_state(const struct ubifs_info *c, struct shash_desc *src,
475 struct shash_desc *target)
476{
477 u8 *state;
478 int err;
479
480 state = kmalloc(crypto_shash_descsize(src->tfm), GFP_NOFS);
481 if (!state)
482 return -ENOMEM;
483
484 err = crypto_shash_export(src, state);
485 if (err)
486 goto out;
487
488 err = crypto_shash_import(target, state);
489
490out:
491 kfree(state);
492
493 return err;
494}
495
496
497
498
499
500
501
502
503
504
505
506
507
508int ubifs_hmac_wkm(struct ubifs_info *c, u8 *hmac)
509{
510 SHASH_DESC_ON_STACK(shash, c->hmac_tfm);
511 int err;
512 const char well_known_message[] = "UBIFS";
513
514 if (!ubifs_authenticated(c))
515 return 0;
516
517 shash->tfm = c->hmac_tfm;
518
519 err = crypto_shash_init(shash);
520 if (err)
521 return err;
522
523 err = crypto_shash_update(shash, well_known_message,
524 sizeof(well_known_message) - 1);
525 if (err < 0)
526 return err;
527
528 err = crypto_shash_final(shash, hmac);
529 if (err)
530 return err;
531 return 0;
532}
533
534
535
536
537
538
539
540
541
542bool ubifs_hmac_zero(struct ubifs_info *c, const u8 *hmac)
543{
544 return !memchr_inv(hmac, 0, c->hmac_desc_len);
545}
546