drivers/md/dm-verity-verify-sig.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2019 Microsoft Corporation.
0004  *
0005  * Author:  Jaskaran Singh Khurana <jaskarankhurana@linux.microsoft.com>
0006  *
0007  */
0008 #include <linux/device-mapper.h>
0009 #include <linux/verification.h>
0010 #include <keys/user-type.h>
0011 #include <linux/module.h>
0012 #include "dm-verity.h"
0013 #include "dm-verity-verify-sig.h"
0014
0015 #define DM_VERITY_VERIFY_ERR(s) DM_VERITY_ROOT_HASH_VERIFICATION " " s
0016
0017 static bool require_signatures;
0018 module_param(require_signatures, bool, 0444);
0019 MODULE_PARM_DESC(require_signatures,
0020         "Verify the roothash of dm-verity hash tree");
0021
0022 #define DM_VERITY_IS_SIG_FORCE_ENABLED() \
0023     (require_signatures != false)
0024
0025 bool verity_verify_is_sig_opt_arg(const char *arg_name)
0026 {
0027     return (!strcasecmp(arg_name,
0028                 DM_VERITY_ROOT_HASH_VERIFICATION_OPT_SIG_KEY));
0029 }
0030
0031 static int verity_verify_get_sig_from_key(const char *key_desc,
0032                     struct dm_verity_sig_opts *sig_opts)
0033 {
0034     struct key *key;
0035     const struct user_key_payload *ukp;
0036     int ret = 0;
0037
0038     key = request_key(&key_type_user,
0039             key_desc, NULL);
0040     if (IS_ERR(key))
0041         return PTR_ERR(key);
0042
0043     down_read(&key->sem);
0044
0045     ukp = user_key_payload_locked(key);
0046     if (!ukp) {
0047         ret = -EKEYREVOKED;
0048         goto end;
0049     }
0050
0051     sig_opts->sig = kmalloc(ukp->datalen, GFP_KERNEL);
0052     if (!sig_opts->sig) {
0053         ret = -ENOMEM;
0054         goto end;
0055     }
0056     sig_opts->sig_size = ukp->datalen;
0057
0058     memcpy(sig_opts->sig, ukp->data, sig_opts->sig_size);
0059
0060 end:
0061     up_read(&key->sem);
0062     key_put(key);
0063
0064     return ret;
0065 }
0066
0067 int verity_verify_sig_parse_opt_args(struct dm_arg_set *as,
0068                      struct dm_verity *v,
0069                      struct dm_verity_sig_opts *sig_opts,
0070                      unsigned int *argc,
0071                      const char *arg_name)
0072 {
0073     struct dm_target *ti = v->ti;
0074     int ret = 0;
0075     const char *sig_key = NULL;
0076
0077     if (!*argc) {
0078         ti->error = DM_VERITY_VERIFY_ERR("Signature key not specified");
0079         return -EINVAL;
0080     }
0081
0082     sig_key = dm_shift_arg(as);
0083     (*argc)--;
0084
0085     ret = verity_verify_get_sig_from_key(sig_key, sig_opts);
0086     if (ret < 0)
0087         ti->error = DM_VERITY_VERIFY_ERR("Invalid key specified");
0088
0089     v->signature_key_desc = kstrdup(sig_key, GFP_KERNEL);
0090     if (!v->signature_key_desc)
0091         return -ENOMEM;
0092
0093     return ret;
0094 }
0095
0096 /*
0097  * verify_verify_roothash - Verify the root hash of the verity hash device
0098  *               using builtin trusted keys.
0099  *
0100  * @root_hash: For verity, the roothash/data to be verified.
0101  * @root_hash_len: Size of the roothash/data to be verified.
0102  * @sig_data: The trusted signature that verifies the roothash/data.
0103  * @sig_len: Size of the signature.
0104  *
0105  */
0106 int verity_verify_root_hash(const void *root_hash, size_t root_hash_len,
0107                 const void *sig_data, size_t sig_len)
0108 {
0109     int ret;
0110
0111     if (!root_hash || root_hash_len == 0)
0112         return -EINVAL;
0113
0114     if (!sig_data  || sig_len == 0) {
0115         if (DM_VERITY_IS_SIG_FORCE_ENABLED())
0116             return -ENOKEY;
0117         else
0118             return 0;
0119     }
0120
0121     ret = verify_pkcs7_signature(root_hash, root_hash_len, sig_data,
0122                 sig_len,
0123 #ifdef CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG_SECONDARY_KEYRING
0124                 VERIFY_USE_SECONDARY_KEYRING,
0125 #else
0126                 NULL,
0127 #endif
0128                 VERIFYING_UNSPECIFIED_SIGNATURE, NULL, NULL);
0129
0130     return ret;
0131 }
0132
0133 void verity_verify_sig_opts_cleanup(struct dm_verity_sig_opts *sig_opts)
0134 {
0135     kfree(sig_opts->sig);
0136     sig_opts->sig = NULL;
0137     sig_opts->sig_size = 0;
0138 }