drivers/nvdimm/security.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2018 Intel Corporation. All rights reserved. */
0003
0004 #include <linux/module.h>
0005 #include <linux/device.h>
0006 #include <linux/ndctl.h>
0007 #include <linux/slab.h>
0008 #include <linux/io.h>
0009 #include <linux/mm.h>
0010 #include <linux/cred.h>
0011 #include <linux/key.h>
0012 #include <linux/key-type.h>
0013 #include <keys/user-type.h>
0014 #include <keys/encrypted-type.h>
0015 #include "nd-core.h"
0016 #include "nd.h"
0017
0018 #define NVDIMM_BASE_KEY     0
0019 #define NVDIMM_NEW_KEY      1
0020
0021 static bool key_revalidate = true;
0022 module_param(key_revalidate, bool, 0444);
0023 MODULE_PARM_DESC(key_revalidate, "Require key validation at init.");
0024
0025 static const char zero_key[NVDIMM_PASSPHRASE_LEN];
0026
0027 static void *key_data(struct key *key)
0028 {
0029     struct encrypted_key_payload *epayload = dereference_key_locked(key);
0030
0031     lockdep_assert_held_read(&key->sem);
0032
0033     return epayload->decrypted_data;
0034 }
0035
0036 static void nvdimm_put_key(struct key *key)
0037 {
0038     if (!key)
0039         return;
0040
0041     up_read(&key->sem);
0042     key_put(key);
0043 }
0044
0045 /*
0046  * Retrieve kernel key for DIMM and request from user space if
0047  * necessary. Returns a key held for read and must be put by
0048  * nvdimm_put_key() before the usage goes out of scope.
0049  */
0050 static struct key *nvdimm_request_key(struct nvdimm *nvdimm)
0051 {
0052     struct key *key = NULL;
0053     static const char NVDIMM_PREFIX[] = "nvdimm:";
0054     char desc[NVDIMM_KEY_DESC_LEN + sizeof(NVDIMM_PREFIX)];
0055     struct device *dev = &nvdimm->dev;
0056
0057     sprintf(desc, "%s%s", NVDIMM_PREFIX, nvdimm->dimm_id);
0058     key = request_key(&key_type_encrypted, desc, "");
0059     if (IS_ERR(key)) {
0060         if (PTR_ERR(key) == -ENOKEY)
0061             dev_dbg(dev, "request_key() found no key\n");
0062         else
0063             dev_dbg(dev, "request_key() upcall failed\n");
0064         key = NULL;
0065     } else {
0066         struct encrypted_key_payload *epayload;
0067
0068         down_read(&key->sem);
0069         epayload = dereference_key_locked(key);
0070         if (epayload->decrypted_datalen != NVDIMM_PASSPHRASE_LEN) {
0071             up_read(&key->sem);
0072             key_put(key);
0073             key = NULL;
0074         }
0075     }
0076
0077     return key;
0078 }
0079
0080 static const void *nvdimm_get_key_payload(struct nvdimm *nvdimm,
0081         struct key **key)
0082 {
0083     *key = nvdimm_request_key(nvdimm);
0084     if (!*key)
0085         return zero_key;
0086
0087     return key_data(*key);
0088 }
0089
0090 static struct key *nvdimm_lookup_user_key(struct nvdimm *nvdimm,
0091         key_serial_t id, int subclass)
0092 {
0093     key_ref_t keyref;
0094     struct key *key;
0095     struct encrypted_key_payload *epayload;
0096     struct device *dev = &nvdimm->dev;
0097
0098     keyref = lookup_user_key(id, 0, KEY_NEED_SEARCH);
0099     if (IS_ERR(keyref))
0100         return NULL;
0101
0102     key = key_ref_to_ptr(keyref);
0103     if (key->type != &key_type_encrypted) {
0104         key_put(key);
0105         return NULL;
0106     }
0107
0108     dev_dbg(dev, "%s: key found: %#x\n", __func__, key_serial(key));
0109
0110     down_read_nested(&key->sem, subclass);
0111     epayload = dereference_key_locked(key);
0112     if (epayload->decrypted_datalen != NVDIMM_PASSPHRASE_LEN) {
0113         up_read(&key->sem);
0114         key_put(key);
0115         key = NULL;
0116     }
0117     return key;
0118 }
0119
0120 static const void *nvdimm_get_user_key_payload(struct nvdimm *nvdimm,
0121         key_serial_t id, int subclass, struct key **key)
0122 {
0123     *key = NULL;
0124     if (id == 0) {
0125         if (subclass == NVDIMM_BASE_KEY)
0126             return zero_key;
0127         else
0128             return NULL;
0129     }
0130
0131     *key = nvdimm_lookup_user_key(nvdimm, id, subclass);
0132     if (!*key)
0133         return NULL;
0134
0135     return key_data(*key);
0136 }
0137
0138
0139 static int nvdimm_key_revalidate(struct nvdimm *nvdimm)
0140 {
0141     struct key *key;
0142     int rc;
0143     const void *data;
0144
0145     if (!nvdimm->sec.ops->change_key)
0146         return -EOPNOTSUPP;
0147
0148     data = nvdimm_get_key_payload(nvdimm, &key);
0149
0150     /*
0151      * Send the same key to the hardware as new and old key to
0152      * verify that the key is good.
0153      */
0154     rc = nvdimm->sec.ops->change_key(nvdimm, data, data, NVDIMM_USER);
0155     if (rc < 0) {
0156         nvdimm_put_key(key);
0157         return rc;
0158     }
0159
0160     nvdimm_put_key(key);
0161     nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
0162     return 0;
0163 }
0164
0165 static int __nvdimm_security_unlock(struct nvdimm *nvdimm)
0166 {
0167     struct device *dev = &nvdimm->dev;
0168     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
0169     struct key *key;
0170     const void *data;
0171     int rc;
0172
0173     /* The bus lock should be held at the top level of the call stack */
0174     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0175
0176     if (!nvdimm->sec.ops || !nvdimm->sec.ops->unlock
0177             || !nvdimm->sec.flags)
0178         return -EIO;
0179
0180     /* No need to go further if security is disabled */
0181     if (test_bit(NVDIMM_SECURITY_DISABLED, &nvdimm->sec.flags))
0182         return 0;
0183
0184     if (test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags)) {
0185         dev_dbg(dev, "Security operation in progress.\n");
0186         return -EBUSY;
0187     }
0188
0189     /*
0190      * If the pre-OS has unlocked the DIMM, attempt to send the key
0191      * from request_key() to the hardware for verification.  Failure
0192      * to revalidate the key against the hardware results in a
0193      * freeze of the security configuration. I.e. if the OS does not
0194      * have the key, security is being managed pre-OS.
0195      */
0196     if (test_bit(NVDIMM_SECURITY_UNLOCKED, &nvdimm->sec.flags)) {
0197         if (!key_revalidate)
0198             return 0;
0199
0200         return nvdimm_key_revalidate(nvdimm);
0201     } else
0202         data = nvdimm_get_key_payload(nvdimm, &key);
0203
0204     rc = nvdimm->sec.ops->unlock(nvdimm, data);
0205     dev_dbg(dev, "key: %d unlock: %s\n", key_serial(key),
0206             rc == 0 ? "success" : "fail");
0207
0208     nvdimm_put_key(key);
0209     nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
0210     return rc;
0211 }
0212
0213 int nvdimm_security_unlock(struct device *dev)
0214 {
0215     struct nvdimm *nvdimm = to_nvdimm(dev);
0216     int rc;
0217
0218     nvdimm_bus_lock(dev);
0219     rc = __nvdimm_security_unlock(nvdimm);
0220     nvdimm_bus_unlock(dev);
0221     return rc;
0222 }
0223
0224 static int check_security_state(struct nvdimm *nvdimm)
0225 {
0226     struct device *dev = &nvdimm->dev;
0227
0228     if (test_bit(NVDIMM_SECURITY_FROZEN, &nvdimm->sec.flags)) {
0229         dev_dbg(dev, "Incorrect security state: %#lx\n",
0230                 nvdimm->sec.flags);
0231         return -EIO;
0232     }
0233
0234     if (test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags)) {
0235         dev_dbg(dev, "Security operation in progress.\n");
0236         return -EBUSY;
0237     }
0238
0239     return 0;
0240 }
0241
0242 static int security_disable(struct nvdimm *nvdimm, unsigned int keyid)
0243 {
0244     struct device *dev = &nvdimm->dev;
0245     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
0246     struct key *key;
0247     int rc;
0248     const void *data;
0249
0250     /* The bus lock should be held at the top level of the call stack */
0251     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0252
0253     if (!nvdimm->sec.ops || !nvdimm->sec.ops->disable
0254             || !nvdimm->sec.flags)
0255         return -EOPNOTSUPP;
0256
0257     rc = check_security_state(nvdimm);
0258     if (rc)
0259         return rc;
0260
0261     data = nvdimm_get_user_key_payload(nvdimm, keyid,
0262             NVDIMM_BASE_KEY, &key);
0263     if (!data)
0264         return -ENOKEY;
0265
0266     rc = nvdimm->sec.ops->disable(nvdimm, data);
0267     dev_dbg(dev, "key: %d disable: %s\n", key_serial(key),
0268             rc == 0 ? "success" : "fail");
0269
0270     nvdimm_put_key(key);
0271     nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
0272     return rc;
0273 }
0274
0275 static int security_update(struct nvdimm *nvdimm, unsigned int keyid,
0276         unsigned int new_keyid,
0277         enum nvdimm_passphrase_type pass_type)
0278 {
0279     struct device *dev = &nvdimm->dev;
0280     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
0281     struct key *key, *newkey;
0282     int rc;
0283     const void *data, *newdata;
0284
0285     /* The bus lock should be held at the top level of the call stack */
0286     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0287
0288     if (!nvdimm->sec.ops || !nvdimm->sec.ops->change_key
0289             || !nvdimm->sec.flags)
0290         return -EOPNOTSUPP;
0291
0292     rc = check_security_state(nvdimm);
0293     if (rc)
0294         return rc;
0295
0296     data = nvdimm_get_user_key_payload(nvdimm, keyid,
0297             NVDIMM_BASE_KEY, &key);
0298     if (!data)
0299         return -ENOKEY;
0300
0301     newdata = nvdimm_get_user_key_payload(nvdimm, new_keyid,
0302             NVDIMM_NEW_KEY, &newkey);
0303     if (!newdata) {
0304         nvdimm_put_key(key);
0305         return -ENOKEY;
0306     }
0307
0308     rc = nvdimm->sec.ops->change_key(nvdimm, data, newdata, pass_type);
0309     dev_dbg(dev, "key: %d %d update%s: %s\n",
0310             key_serial(key), key_serial(newkey),
0311             pass_type == NVDIMM_MASTER ? "(master)" : "(user)",
0312             rc == 0 ? "success" : "fail");
0313
0314     nvdimm_put_key(newkey);
0315     nvdimm_put_key(key);
0316     if (pass_type == NVDIMM_MASTER)
0317         nvdimm->sec.ext_flags = nvdimm_security_flags(nvdimm,
0318                 NVDIMM_MASTER);
0319     else
0320         nvdimm->sec.flags = nvdimm_security_flags(nvdimm,
0321                 NVDIMM_USER);
0322     return rc;
0323 }
0324
0325 static int security_erase(struct nvdimm *nvdimm, unsigned int keyid,
0326         enum nvdimm_passphrase_type pass_type)
0327 {
0328     struct device *dev = &nvdimm->dev;
0329     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
0330     struct key *key = NULL;
0331     int rc;
0332     const void *data;
0333
0334     /* The bus lock should be held at the top level of the call stack */
0335     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0336
0337     if (!nvdimm->sec.ops || !nvdimm->sec.ops->erase
0338             || !nvdimm->sec.flags)
0339         return -EOPNOTSUPP;
0340
0341     rc = check_security_state(nvdimm);
0342     if (rc)
0343         return rc;
0344
0345     if (!test_bit(NVDIMM_SECURITY_UNLOCKED, &nvdimm->sec.ext_flags)
0346             && pass_type == NVDIMM_MASTER) {
0347         dev_dbg(dev,
0348             "Attempt to secure erase in wrong master state.\n");
0349         return -EOPNOTSUPP;
0350     }
0351
0352     data = nvdimm_get_user_key_payload(nvdimm, keyid,
0353             NVDIMM_BASE_KEY, &key);
0354     if (!data)
0355         return -ENOKEY;
0356
0357     rc = nvdimm->sec.ops->erase(nvdimm, data, pass_type);
0358     dev_dbg(dev, "key: %d erase%s: %s\n", key_serial(key),
0359             pass_type == NVDIMM_MASTER ? "(master)" : "(user)",
0360             rc == 0 ? "success" : "fail");
0361
0362     nvdimm_put_key(key);
0363     nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
0364     return rc;
0365 }
0366
0367 static int security_overwrite(struct nvdimm *nvdimm, unsigned int keyid)
0368 {
0369     struct device *dev = &nvdimm->dev;
0370     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
0371     struct key *key = NULL;
0372     int rc;
0373     const void *data;
0374
0375     /* The bus lock should be held at the top level of the call stack */
0376     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0377
0378     if (!nvdimm->sec.ops || !nvdimm->sec.ops->overwrite
0379             || !nvdimm->sec.flags)
0380         return -EOPNOTSUPP;
0381
0382     rc = check_security_state(nvdimm);
0383     if (rc)
0384         return rc;
0385
0386     data = nvdimm_get_user_key_payload(nvdimm, keyid,
0387             NVDIMM_BASE_KEY, &key);
0388     if (!data)
0389         return -ENOKEY;
0390
0391     rc = nvdimm->sec.ops->overwrite(nvdimm, data);
0392     dev_dbg(dev, "key: %d overwrite submission: %s\n", key_serial(key),
0393             rc == 0 ? "success" : "fail");
0394
0395     nvdimm_put_key(key);
0396     if (rc == 0) {
0397         set_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags);
0398         set_bit(NDD_WORK_PENDING, &nvdimm->flags);
0399         set_bit(NVDIMM_SECURITY_OVERWRITE, &nvdimm->sec.flags);
0400         /*
0401          * Make sure we don't lose device while doing overwrite
0402          * query.
0403          */
0404         get_device(dev);
0405         queue_delayed_work(system_wq, &nvdimm->dwork, 0);
0406     }
0407
0408     return rc;
0409 }
0410
0411 void __nvdimm_security_overwrite_query(struct nvdimm *nvdimm)
0412 {
0413     struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nvdimm->dev);
0414     int rc;
0415     unsigned int tmo;
0416
0417     /* The bus lock should be held at the top level of the call stack */
0418     lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
0419
0420     /*
0421      * Abort and release device if we no longer have the overwrite
0422      * flag set. It means the work has been canceled.
0423      */
0424     if (!test_bit(NDD_WORK_PENDING, &nvdimm->flags))
0425         return;
0426
0427     tmo = nvdimm->sec.overwrite_tmo;
0428
0429     if (!nvdimm->sec.ops || !nvdimm->sec.ops->query_overwrite
0430             || !nvdimm->sec.flags)
0431         return;
0432
0433     rc = nvdimm->sec.ops->query_overwrite(nvdimm);
0434     if (rc == -EBUSY) {
0435
0436         /* setup delayed work again */
0437         tmo += 10;
0438         queue_delayed_work(system_wq, &nvdimm->dwork, tmo * HZ);
0439         nvdimm->sec.overwrite_tmo = min(15U * 60U, tmo);
0440         return;
0441     }
0442
0443     if (rc < 0)
0444         dev_dbg(&nvdimm->dev, "overwrite failed\n");
0445     else
0446         dev_dbg(&nvdimm->dev, "overwrite completed\n");
0447
0448     /*
0449      * Mark the overwrite work done and update dimm security flags,
0450      * then send a sysfs event notification to wake up userspace
0451      * poll threads to picked up the changed state.
0452      */
0453     nvdimm->sec.overwrite_tmo = 0;
0454     clear_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags);
0455     clear_bit(NDD_WORK_PENDING, &nvdimm->flags);
0456     nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
0457     nvdimm->sec.ext_flags = nvdimm_security_flags(nvdimm, NVDIMM_MASTER);
0458     if (nvdimm->sec.overwrite_state)
0459         sysfs_notify_dirent(nvdimm->sec.overwrite_state);
0460     put_device(&nvdimm->dev);
0461 }
0462
0463 void nvdimm_security_overwrite_query(struct work_struct *work)
0464 {
0465     struct nvdimm *nvdimm =
0466         container_of(work, typeof(*nvdimm), dwork.work);
0467
0468     nvdimm_bus_lock(&nvdimm->dev);
0469     __nvdimm_security_overwrite_query(nvdimm);
0470     nvdimm_bus_unlock(&nvdimm->dev);
0471 }
0472
0473 #define OPS                         \
0474     C( OP_FREEZE,       "freeze",       1), \
0475     C( OP_DISABLE,      "disable",      2), \
0476     C( OP_UPDATE,       "update",       3), \
0477     C( OP_ERASE,        "erase",        2), \
0478     C( OP_OVERWRITE,    "overwrite",        2), \
0479     C( OP_MASTER_UPDATE,    "master_update",    3), \
0480     C( OP_MASTER_ERASE, "master_erase",     2)
0481 #undef C
0482 #define C(a, b, c) a
0483 enum nvdimmsec_op_ids { OPS };
0484 #undef C
0485 #define C(a, b, c) { b, c }
0486 static struct {
0487     const char *name;
0488     int args;
0489 } ops[] = { OPS };
0490 #undef C
0491
0492 #define SEC_CMD_SIZE 32
0493 #define KEY_ID_SIZE 10
0494
0495 ssize_t nvdimm_security_store(struct device *dev, const char *buf, size_t len)
0496 {
0497     struct nvdimm *nvdimm = to_nvdimm(dev);
0498     ssize_t rc;
0499     char cmd[SEC_CMD_SIZE+1], keystr[KEY_ID_SIZE+1],
0500         nkeystr[KEY_ID_SIZE+1];
0501     unsigned int key, newkey;
0502     int i;
0503
0504     rc = sscanf(buf, "%"__stringify(SEC_CMD_SIZE)"s"
0505             " %"__stringify(KEY_ID_SIZE)"s"
0506             " %"__stringify(KEY_ID_SIZE)"s",
0507             cmd, keystr, nkeystr);
0508     if (rc < 1)
0509         return -EINVAL;
0510     for (i = 0; i < ARRAY_SIZE(ops); i++)
0511         if (sysfs_streq(cmd, ops[i].name))
0512             break;
0513     if (i >= ARRAY_SIZE(ops))
0514         return -EINVAL;
0515     if (ops[i].args > 1)
0516         rc = kstrtouint(keystr, 0, &key);
0517     if (rc >= 0 && ops[i].args > 2)
0518         rc = kstrtouint(nkeystr, 0, &newkey);
0519     if (rc < 0)
0520         return rc;
0521
0522     if (i == OP_FREEZE) {
0523         dev_dbg(dev, "freeze\n");
0524         rc = nvdimm_security_freeze(nvdimm);
0525     } else if (i == OP_DISABLE) {
0526         dev_dbg(dev, "disable %u\n", key);
0527         rc = security_disable(nvdimm, key);
0528     } else if (i == OP_UPDATE || i == OP_MASTER_UPDATE) {
0529         dev_dbg(dev, "%s %u %u\n", ops[i].name, key, newkey);
0530         rc = security_update(nvdimm, key, newkey, i == OP_UPDATE
0531                 ? NVDIMM_USER : NVDIMM_MASTER);
0532     } else if (i == OP_ERASE || i == OP_MASTER_ERASE) {
0533         dev_dbg(dev, "%s %u\n", ops[i].name, key);
0534         if (atomic_read(&nvdimm->busy)) {
0535             dev_dbg(dev, "Unable to secure erase while DIMM active.\n");
0536             return -EBUSY;
0537         }
0538         rc = security_erase(nvdimm, key, i == OP_ERASE
0539                 ? NVDIMM_USER : NVDIMM_MASTER);
0540     } else if (i == OP_OVERWRITE) {
0541         dev_dbg(dev, "overwrite %u\n", key);
0542         if (atomic_read(&nvdimm->busy)) {
0543             dev_dbg(dev, "Unable to overwrite while DIMM active.\n");
0544             return -EBUSY;
0545         }
0546         rc = security_overwrite(nvdimm, key);
0547     } else
0548         return -EINVAL;
0549
0550     if (rc == 0)
0551         rc = len;
0552     return rc;
0553 }