security/integrity/digsig_asymmetric.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2013 Intel Corporation
   4  *
   5  * Author:
   6  * Dmitry Kasatkin <dmitry.kasatkin@intel.com>
   7  */
   8
   9 #include <linux/err.h>
  10 #include <linux/ratelimit.h>
  11 #include <linux/key-type.h>
  12 #include <crypto/public_key.h>
  13 #include <crypto/hash_info.h>
  14 #include <keys/asymmetric-type.h>
  15 #include <keys/system_keyring.h>
  16
  17 #include "integrity.h"
  18
  19 /*
  20  * Request an asymmetric key.
  21  */
  22 static struct key *request_asymmetric_key(struct key *keyring, uint32_t keyid)
  23 {
  24         struct key *key;
  25         char name[12];
  26
  27         sprintf(name, "id:%08x", keyid);
  28
  29         pr_debug("key search: \"%s\"\n", name);
  30
  31         key = get_ima_blacklist_keyring();
  32         if (key) {
  33                 key_ref_t kref;
  34
  35                 kref = keyring_search(make_key_ref(key, 1),
  36                                       &key_type_asymmetric, name, true);
  37                 if (!IS_ERR(kref)) {
  38                         pr_err("Key '%s' is in ima_blacklist_keyring\n", name);
  39                         return ERR_PTR(-EKEYREJECTED);
  40                 }
  41         }
  42
  43         if (keyring) {
  44                 /* search in specific keyring */
  45                 key_ref_t kref;
  46
  47                 kref = keyring_search(make_key_ref(keyring, 1),
  48                                       &key_type_asymmetric, name, true);
  49                 if (IS_ERR(kref))
  50                         key = ERR_CAST(kref);
  51                 else
  52                         key = key_ref_to_ptr(kref);
  53         } else {
  54                 key = request_key(&key_type_asymmetric, name, NULL);
  55         }
  56
  57         if (IS_ERR(key)) {
  58                 if (keyring)
  59                         pr_err_ratelimited("Request for unknown key '%s' in '%s' keyring. err %ld\n",
  60                                            name, keyring->description,
  61                                            PTR_ERR(key));
  62                 else
  63                         pr_err_ratelimited("Request for unknown key '%s' err %ld\n",
  64                                            name, PTR_ERR(key));
  65
  66                 switch (PTR_ERR(key)) {
  67                         /* Hide some search errors */
  68                 case -EACCES:
  69                 case -ENOTDIR:
  70                 case -EAGAIN:
  71                         return ERR_PTR(-ENOKEY);
  72                 default:
  73                         return key;
  74                 }
  75         }
  76
  77         pr_debug("%s() = 0 [%x]\n", __func__, key_serial(key));
  78
  79         return key;
  80 }
  81
  82 int asymmetric_verify(struct key *keyring, const char *sig,
  83                       int siglen, const char *data, int datalen)
  84 {
  85         struct public_key_signature pks;
  86         struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
  87         const struct public_key *pk;
  88         struct key *key;
  89         int ret;
  90
  91         if (siglen <= sizeof(*hdr))
  92                 return -EBADMSG;
  93
  94         siglen -= sizeof(*hdr);
  95
  96         if (siglen != be16_to_cpu(hdr->sig_size))
  97                 return -EBADMSG;
  98
  99         if (hdr->hash_algo >= HASH_ALGO__LAST)
 100                 return -ENOPKG;
 101
 102         key = request_asymmetric_key(keyring, be32_to_cpu(hdr->keyid));
 103         if (IS_ERR(key))
 104                 return PTR_ERR(key);
 105
 106         memset(&pks, 0, sizeof(pks));
 107
 108         pks.hash_algo = hash_algo_name[hdr->hash_algo];
 109
 110         pk = asymmetric_key_public_key(key);
 111         pks.pkey_algo = pk->pkey_algo;
 112         if (!strcmp(pk->pkey_algo, "rsa")) {
 113                 pks.encoding = "pkcs1";
 114         } else if (!strncmp(pk->pkey_algo, "ecdsa-", 6)) {
 115                 /* edcsa-nist-p192 etc. */
 116                 pks.encoding = "x962";
 117         } else if (!strcmp(pk->pkey_algo, "ecrdsa") ||
 118                    !strcmp(pk->pkey_algo, "sm2")) {
 119                 pks.encoding = "raw";
 120         } else {
 121                 ret = -ENOPKG;
 122                 goto out;
 123         }
 124
 125         pks.digest = (u8 *)data;
 126         pks.digest_size = datalen;
 127         pks.s = hdr->sig;
 128         pks.s_size = siglen;
 129         ret = verify_signature(key, &pks);
 130 out:
 131         key_put(key);
 132         pr_debug("%s() = %d\n", __func__, ret);
 133         return ret;
 134 }
 135
 136 /**
 137  * integrity_kernel_module_request - prevent crypto-pkcs1pad(rsa,*) requests
 138  * @kmod_name: kernel module name
 139  *
 140  * We have situation, when public_key_verify_signature() in case of RSA
 141  * algorithm use alg_name to store internal information in order to
 142  * construct an algorithm on the fly, but crypto_larval_lookup() will try
 143  * to use alg_name in order to load kernel module with same name.
 144  * Since we don't have any real "crypto-pkcs1pad(rsa,*)" kernel modules,
 145  * we are safe to fail such module request from crypto_larval_lookup().
 146  *
 147  * In this way we prevent modprobe execution during digsig verification
 148  * and avoid possible deadlock if modprobe and/or it's dependencies
 149  * also signed with digsig.
 150  */
 151 int integrity_kernel_module_request(char *kmod_name)
 152 {
 153         if (strncmp(kmod_name, "crypto-pkcs1pad(rsa,", 20) == 0)
 154                 return -EINVAL;
 155
 156         return 0;
 157 }