* [PATCH v6 01/11] nfit: add support for Intel DSM 1.7 commands
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
@ 2018-07-25 20:58 ` Dave Jiang
2018-07-25 20:58 ` [PATCH v6 02/11] libnvdimm: create keyring to store security keys Dave Jiang
` (11 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:58 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add command definition for security commands defined in Intel DSM
specification v1.7. This includes "get security state", "set passphrase",
"unlock unit", "freeze lock", "secure erase", "ovewrite", and
"overwrite query". Since we are adding a lot of Intel definitions, moving
the relevant bits to its own header. Also, we don't want those commands
to be issued from user space through ioctls. Reason being some of the
security commands require kernel involvement to flush all CPU caches that
can't be done in userspace and the result can cause system crash. So
blocking security commands in the ioctl path.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/core.c | 28 ++++++++++++++++++-
drivers/acpi/nfit/intel.h | 67 +++++++++++++++++++++++++++++++++++++++++++++
drivers/acpi/nfit/nfit.h | 17 +++++++++++
drivers/nvdimm/bus.c | 2 +
include/linux/libnvdimm.h | 2 +
5 files changed, 112 insertions(+), 4 deletions(-)
create mode 100644 drivers/acpi/nfit/intel.h
diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
index 0f47917b8ef1..a3a944751e6a 100644
--- a/drivers/acpi/nfit/core.c
+++ b/drivers/acpi/nfit/core.c
@@ -24,6 +24,7 @@
#include <linux/nd.h>
#include <asm/cacheflush.h>
#include <acpi/nfit.h>
+#include "intel.h"
#include "nfit.h"
/*
@@ -377,6 +378,14 @@ static u8 nfit_dsm_revid(unsigned family, unsigned func)
[NVDIMM_INTEL_QUERY_FWUPDATE] = 2,
[NVDIMM_INTEL_SET_THRESHOLD] = 2,
[NVDIMM_INTEL_INJECT_ERROR] = 2,
+ [NVDIMM_INTEL_GET_SECURITY_STATE] = 2,
+ [NVDIMM_INTEL_SET_PASSPHRASE] = 2,
+ [NVDIMM_INTEL_DISABLE_PASSPHRASE] = 2,
+ [NVDIMM_INTEL_UNLOCK_UNIT] = 2,
+ [NVDIMM_INTEL_FREEZE_LOCK] = 2,
+ [NVDIMM_INTEL_SECURE_ERASE] = 2,
+ [NVDIMM_INTEL_OVERWRITE] = 2,
+ [NVDIMM_INTEL_QUERY_OVERWRITE] = 2,
},
};
u8 id;
@@ -3202,7 +3211,7 @@ static int acpi_nfit_flush_probe(struct nvdimm_bus_descriptor *nd_desc)
return 0;
}
-static int acpi_nfit_clear_to_send(struct nvdimm_bus_descriptor *nd_desc,
+static int __acpi_nfit_clear_to_send(struct nvdimm_bus_descriptor *nd_desc,
struct nvdimm *nvdimm, unsigned int cmd)
{
struct acpi_nfit_desc *acpi_desc = to_acpi_nfit_desc(nd_desc);
@@ -3224,6 +3233,23 @@ static int acpi_nfit_clear_to_send(struct nvdimm_bus_descriptor *nd_desc,
return 0;
}
+/* prevent security commands from being issued via ioctl */
+static int acpi_nfit_clear_to_send(struct nvdimm_bus_descriptor *nd_desc,
+ struct nvdimm *nvdimm, unsigned int cmd, void *buf)
+{
+ struct nd_cmd_pkg *call_pkg = buf;
+ unsigned int func;
+
+ if (nvdimm && cmd == ND_CMD_CALL &&
+ call_pkg->nd_family == NVDIMM_FAMILY_INTEL) {
+ func = call_pkg->nd_command;
+ if ((1 << func) & NVDIMM_INTEL_SECURITY_CMDMASK)
+ return -EOPNOTSUPP;
+ }
+
+ return __acpi_nfit_clear_to_send(nd_desc, nvdimm, cmd);
+}
+
int acpi_nfit_ars_rescan(struct acpi_nfit_desc *acpi_desc, unsigned long flags)
{
struct device *dev = acpi_desc->dev;
diff --git a/drivers/acpi/nfit/intel.h b/drivers/acpi/nfit/intel.h
new file mode 100644
index 000000000000..a6f8f4bc8ebb
--- /dev/null
+++ b/drivers/acpi/nfit/intel.h
@@ -0,0 +1,67 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright(c) 2018 Intel Corporation. All rights reserved. */
+/*
+ * Intel specific definitions for NVDIMM Firmware Interface Table - NFIT
+ */
+#ifndef _NFIT_INTEL_H_
+#define _NFIT_INTEL_H_
+
+#ifdef CONFIG_X86
+
+#define ND_INTEL_STATUS_SIZE 4
+#define ND_INTEL_PASSPHRASE_SIZE 32
+
+#define ND_INTEL_STATUS_RETRY 5
+#define ND_INTEL_STATUS_NOT_READY 9
+#define ND_INTEL_STATUS_INVALID_STATE 10
+#define ND_INTEL_STATUS_INVALID_PASS 11
+
+#define ND_INTEL_SEC_STATE_ENABLED 0x02
+#define ND_INTEL_SEC_STATE_LOCKED 0x04
+#define ND_INTEL_SEC_STATE_FROZEN 0x08
+#define ND_INTEL_SEC_STATE_PLIMIT 0x10
+#define ND_INTEL_SEC_STATE_UNSUPPORTED 0x20
+
+struct nd_intel_get_security_state {
+ u32 status;
+ u32 reserved;
+ u8 state;
+ u8 reserved1[3];
+} __packed;
+
+struct nd_intel_set_passphrase {
+ u8 old_pass[ND_INTEL_PASSPHRASE_SIZE];
+ u8 new_pass[ND_INTEL_PASSPHRASE_SIZE];
+ u32 status;
+} __packed;
+
+struct nd_intel_unlock_unit {
+ u8 passphrase[ND_INTEL_PASSPHRASE_SIZE];
+ u32 status;
+} __packed;
+
+struct nd_intel_disable_passphrase {
+ u8 passphrase[ND_INTEL_PASSPHRASE_SIZE];
+ u32 status;
+} __packed;
+
+struct nd_intel_freeze_lock {
+ u32 status;
+} __packed;
+
+struct nd_intel_secure_erase {
+ u8 passphrase[ND_INTEL_PASSPHRASE_SIZE];
+ u32 status;
+} __packed;
+
+struct nd_intel_overwrite {
+ u8 passphrase[ND_INTEL_PASSPHRASE_SIZE];
+ u32 status;
+} __packed;
+
+struct nd_intel_query_overwrite {
+ u32 status;
+} __packed;
+#endif /* CONFIG_X86 */
+
+#endif
diff --git a/drivers/acpi/nfit/nfit.h b/drivers/acpi/nfit/nfit.h
index 7d15856a739f..40b0003b1805 100644
--- a/drivers/acpi/nfit/nfit.h
+++ b/drivers/acpi/nfit/nfit.h
@@ -60,14 +60,29 @@ enum nvdimm_family_cmds {
NVDIMM_INTEL_QUERY_FWUPDATE = 16,
NVDIMM_INTEL_SET_THRESHOLD = 17,
NVDIMM_INTEL_INJECT_ERROR = 18,
+ NVDIMM_INTEL_GET_SECURITY_STATE = 19,
+ NVDIMM_INTEL_SET_PASSPHRASE = 20,
+ NVDIMM_INTEL_DISABLE_PASSPHRASE = 21,
+ NVDIMM_INTEL_UNLOCK_UNIT = 22,
+ NVDIMM_INTEL_FREEZE_LOCK = 23,
+ NVDIMM_INTEL_SECURE_ERASE = 24,
+ NVDIMM_INTEL_OVERWRITE = 25,
+ NVDIMM_INTEL_QUERY_OVERWRITE = 26,
};
+#define NVDIMM_INTEL_SECURITY_CMDMASK \
+(1 << NVDIMM_INTEL_GET_SECURITY_STATE | 1 << NVDIMM_INTEL_SET_PASSPHRASE \
+| 1 << NVDIMM_INTEL_DISABLE_PASSPHRASE | 1 << NVDIMM_INTEL_UNLOCK_UNIT \
+| 1 << NVDIMM_INTEL_FREEZE_LOCK | 1 << NVDIMM_INTEL_SECURE_ERASE \
+| 1 << NVDIMM_INTEL_OVERWRITE | 1 << NVDIMM_INTEL_QUERY_OVERWRITE)
+
#define NVDIMM_INTEL_CMDMASK \
(NVDIMM_STANDARD_CMDMASK | 1 << NVDIMM_INTEL_GET_MODES \
| 1 << NVDIMM_INTEL_GET_FWINFO | 1 << NVDIMM_INTEL_START_FWUPDATE \
| 1 << NVDIMM_INTEL_SEND_FWUPDATE | 1 << NVDIMM_INTEL_FINISH_FWUPDATE \
| 1 << NVDIMM_INTEL_QUERY_FWUPDATE | 1 << NVDIMM_INTEL_SET_THRESHOLD \
- | 1 << NVDIMM_INTEL_INJECT_ERROR | 1 << NVDIMM_INTEL_LATCH_SHUTDOWN)
+ | 1 << NVDIMM_INTEL_INJECT_ERROR | 1 << NVDIMM_INTEL_LATCH_SHUTDOWN \
+ | NVDIMM_INTEL_SECURITY_CMDMASK)
enum nfit_uuids {
/* for simplicity alias the uuid index with the family id */
diff --git a/drivers/nvdimm/bus.c b/drivers/nvdimm/bus.c
index 27902a8799b1..de2af49bbf08 100644
--- a/drivers/nvdimm/bus.c
+++ b/drivers/nvdimm/bus.c
@@ -894,7 +894,7 @@ static int nd_cmd_clear_to_send(struct nvdimm_bus *nvdimm_bus,
/* ask the bus provider if it would like to block this request */
if (nd_desc->clear_to_send) {
- int rc = nd_desc->clear_to_send(nd_desc, nvdimm, cmd);
+ int rc = nd_desc->clear_to_send(nd_desc, nvdimm, cmd, data);
if (rc)
return rc;
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 097072c5a852..472171af7f60 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -87,7 +87,7 @@ struct nvdimm_bus_descriptor {
ndctl_fn ndctl;
int (*flush_probe)(struct nvdimm_bus_descriptor *nd_desc);
int (*clear_to_send)(struct nvdimm_bus_descriptor *nd_desc,
- struct nvdimm *nvdimm, unsigned int cmd);
+ struct nvdimm *nvdimm, unsigned int cmd, void *data);
};
struct nd_cmd_desc {
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 02/11] libnvdimm: create keyring to store security keys
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
2018-07-25 20:58 ` [PATCH v6 01/11] nfit: add support for Intel DSM 1.7 commands Dave Jiang
@ 2018-07-25 20:58 ` Dave Jiang
2018-07-25 20:58 ` [PATCH v6 03/11] nfit/libnvdimm: store dimm id as a member to struct nvdimm Dave Jiang
` (10 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:58 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Prepping the libnvdimm to support security management by adding a keyring
in order to provide passphrase management through the kernel key management
APIs.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/core.c | 7 ++++++-
drivers/nvdimm/dimm_devs.c | 29 ++++++++++++++++++++++++++++-
drivers/nvdimm/nd-core.h | 1 +
include/linux/libnvdimm.h | 3 +++
kernel/cred.c | 1 +
5 files changed, 39 insertions(+), 2 deletions(-)
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index acce050856a8..3cd33d5c7cf0 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -437,9 +437,12 @@ static __init int libnvdimm_init(void)
{
int rc;
- rc = nvdimm_bus_init();
+ rc = nvdimm_devs_init();
if (rc)
return rc;
+ rc = nvdimm_bus_init();
+ if (rc)
+ goto err_bus;
rc = nvdimm_init();
if (rc)
goto err_dimm;
@@ -454,6 +457,8 @@ static __init int libnvdimm_init(void)
nvdimm_exit();
err_dimm:
nvdimm_bus_exit();
+ err_bus:
+ nvdimm_devs_exit();
return rc;
}
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 8d348b22ba45..586432450c82 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -18,12 +18,15 @@
#include <linux/io.h>
#include <linux/fs.h>
#include <linux/mm.h>
+#include <linux/key.h>
+#include <linux/init_task.h>
#include "nd-core.h"
#include "label.h"
#include "pmem.h"
#include "nd.h"
static DEFINE_IDA(dimm_ida);
+static struct key *nvdimm_keyring;
/*
* Retrieve bus and dimm handle and return if this bus supports
@@ -668,7 +671,31 @@ int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count)
}
EXPORT_SYMBOL_GPL(nvdimm_bus_check_dimm_count);
-void __exit nvdimm_devs_exit(void)
+static int nvdimm_register_keyring(void)
{
+ nvdimm_keyring = keyring_alloc(".nvdimm",
+ GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, &init_cred,
+ (KEY_POS_ALL & ~KEY_POS_SETATTR) |
+ (KEY_USR_ALL & ~KEY_USR_SETATTR),
+ KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
+ if (IS_ERR(nvdimm_keyring))
+ return PTR_ERR(nvdimm_keyring);
+
+ return 0;
+}
+
+static void nvdimm_unregister_keyring(void)
+{
+ key_revoke(nvdimm_keyring);
+}
+
+int __init nvdimm_devs_init(void)
+{
+ return nvdimm_register_keyring();
+}
+
+void nvdimm_devs_exit(void)
+{
+ nvdimm_unregister_keyring();
ida_destroy(&dimm_ida);
}
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index 79274ead54fb..2af0f89c4010 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -76,6 +76,7 @@ static inline bool is_memory(struct device *dev)
struct nvdimm_bus *walk_to_nvdimm_bus(struct device *nd_dev);
int __init nvdimm_bus_init(void);
void nvdimm_bus_exit(void);
+int nvdimm_devs_init(void);
void nvdimm_devs_exit(void);
void nd_region_devs_exit(void);
void nd_region_probe_success(struct nvdimm_bus *nvdimm_bus, struct device *dev);
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 472171af7f60..51084043915c 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -155,6 +155,9 @@ static inline struct nd_blk_region_desc *to_blk_region_desc(
}
+#define NVDIMM_PASSPHRASE_LEN 32
+#define NVDIMM_KEY_DESC_LEN 22
+
void badrange_init(struct badrange *badrange);
int badrange_add(struct badrange *badrange, u64 addr, u64 length);
void badrange_forget(struct badrange *badrange, phys_addr_t start,
diff --git a/kernel/cred.c b/kernel/cred.c
index ecf03657e71c..3a161b78a0a4 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -64,6 +64,7 @@ struct cred init_cred = {
.user_ns = &init_user_ns,
.group_info = &init_groups,
};
+EXPORT_SYMBOL(init_cred);
static inline void set_cred_subscribers(struct cred *cred, int n)
{
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 03/11] nfit/libnvdimm: store dimm id as a member to struct nvdimm
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
2018-07-25 20:58 ` [PATCH v6 01/11] nfit: add support for Intel DSM 1.7 commands Dave Jiang
2018-07-25 20:58 ` [PATCH v6 02/11] libnvdimm: create keyring to store security keys Dave Jiang
@ 2018-07-25 20:58 ` Dave Jiang
2018-07-25 20:58 ` [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs Dave Jiang
` (9 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:58 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
The generated dimm id is needed for the sysfs attribute as well as being
used as the identifier/description for the security key. Since it's
constant and should never change, store it as a member of struct nvdimm.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/core.c | 29 +++++++++++++++++------------
drivers/acpi/nfit/nfit.h | 3 +++
drivers/nvdimm/dimm_devs.c | 4 +++-
drivers/nvdimm/nd-core.h | 1 +
include/linux/libnvdimm.h | 2 +-
5 files changed, 25 insertions(+), 14 deletions(-)
diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
index a3a944751e6a..21235d555b5f 100644
--- a/drivers/acpi/nfit/core.c
+++ b/drivers/acpi/nfit/core.c
@@ -1572,18 +1572,10 @@ static DEVICE_ATTR_RO(flags);
static ssize_t id_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
- struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
- if (dcr->valid_fields & ACPI_NFIT_CONTROL_MFG_INFO_VALID)
- return sprintf(buf, "%04x-%02x-%04x-%08x\n",
- be16_to_cpu(dcr->vendor_id),
- dcr->manufacturing_location,
- be16_to_cpu(dcr->manufacturing_date),
- be32_to_cpu(dcr->serial_number));
- else
- return sprintf(buf, "%04x-%08x\n",
- be16_to_cpu(dcr->vendor_id),
- be32_to_cpu(dcr->serial_number));
+ return sprintf(buf, "%s\n", nfit_mem->id);
}
static DEVICE_ATTR_RO(id);
@@ -1712,10 +1704,23 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc,
const guid_t *guid;
int i;
int family = -1;
+ struct acpi_nfit_control_region *dcr = nfit_mem->dcr;
/* nfit test assumes 1:1 relationship between commands and dsms */
nfit_mem->dsm_mask = acpi_desc->dimm_cmd_force_en;
nfit_mem->family = NVDIMM_FAMILY_INTEL;
+
+ if (dcr->valid_fields & ACPI_NFIT_CONTROL_MFG_INFO_VALID)
+ sprintf(nfit_mem->id, "%04x-%02x-%04x-%08x",
+ be16_to_cpu(dcr->vendor_id),
+ dcr->manufacturing_location,
+ be16_to_cpu(dcr->manufacturing_date),
+ be32_to_cpu(dcr->serial_number));
+ else
+ sprintf(nfit_mem->id, "%04x-%08x",
+ be16_to_cpu(dcr->vendor_id),
+ be32_to_cpu(dcr->serial_number));
+
adev = to_acpi_dev(acpi_desc);
if (!adev)
return 0;
@@ -1899,7 +1904,7 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
nvdimm = nvdimm_create(acpi_desc->nvdimm_bus, nfit_mem,
acpi_nfit_dimm_attribute_groups,
flags, cmd_mask, flush ? flush->hint_count : 0,
- nfit_mem->flush_wpq);
+ nfit_mem->flush_wpq, &nfit_mem->id[0]);
if (!nvdimm)
return -ENOMEM;
diff --git a/drivers/acpi/nfit/nfit.h b/drivers/acpi/nfit/nfit.h
index 40b0003b1805..4048036d6ec2 100644
--- a/drivers/acpi/nfit/nfit.h
+++ b/drivers/acpi/nfit/nfit.h
@@ -173,6 +173,8 @@ struct nfit_memdev {
struct acpi_nfit_memory_map memdev[0];
};
+#define NFIT_DIMM_ID_LEN 22
+
/* assembled tables for a given dimm/memory-device */
struct nfit_mem {
struct nvdimm *nvdimm;
@@ -195,6 +197,7 @@ struct nfit_mem {
int family;
bool has_lsr;
bool has_lsw;
+ char id[NFIT_DIMM_ID_LEN+1];
};
struct acpi_nfit_desc {
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 586432450c82..e753b2095402 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -401,7 +401,7 @@ EXPORT_SYMBOL_GPL(nvdimm_attribute_group);
struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
const struct attribute_group **groups, unsigned long flags,
unsigned long cmd_mask, int num_flush,
- struct resource *flush_wpq)
+ struct resource *flush_wpq, const char *dimm_id)
{
struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
struct device *dev;
@@ -414,6 +414,8 @@ struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
kfree(nvdimm);
return NULL;
}
+
+ nvdimm->dimm_id = dimm_id;
nvdimm->provider_data = provider_data;
nvdimm->flags = flags;
nvdimm->cmd_mask = cmd_mask;
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index 2af0f89c4010..ed650f1607d8 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -42,6 +42,7 @@ struct nvdimm {
atomic_t busy;
int id, num_flush;
struct resource *flush_wpq;
+ const char *dimm_id;
};
/**
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 51084043915c..3c1f18fdf76f 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -181,7 +181,7 @@ void *nvdimm_provider_data(struct nvdimm *nvdimm);
struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
const struct attribute_group **groups, unsigned long flags,
unsigned long cmd_mask, int num_flush,
- struct resource *flush_wpq);
+ struct resource *flush_wpq, const char *dimm_id);
const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (2 preceding siblings ...)
2018-07-25 20:58 ` [PATCH v6 03/11] nfit/libnvdimm: store dimm id as a member to struct nvdimm Dave Jiang
@ 2018-07-25 20:58 ` Dave Jiang
2018-07-31 22:04 ` Alison Schofield
2018-07-25 20:58 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms Dave Jiang
` (8 subsequent siblings)
12 siblings, 1 reply; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:58 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add support to allow query the security status of the Intel nvdimms and
also unlock the dimm via the kernel key management APIs. The passphrase is
expected to be pulled from userspace through keyutils. Moving the Intel
related bits to its own source file as well.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/Makefile | 1
drivers/acpi/nfit/core.c | 3 +
drivers/acpi/nfit/intel.c | 152 ++++++++++++++++++++++++++++++++++++++++++++
drivers/acpi/nfit/intel.h | 15 ++++
drivers/nvdimm/dimm.c | 7 ++
drivers/nvdimm/dimm_devs.c | 132 ++++++++++++++++++++++++++++++++++++++
drivers/nvdimm/nd-core.h | 4 +
drivers/nvdimm/nd.h | 2 +
include/linux/libnvdimm.h | 24 +++++++
security/keys/key.c | 1
10 files changed, 338 insertions(+), 3 deletions(-)
create mode 100644 drivers/acpi/nfit/intel.c
diff --git a/drivers/acpi/nfit/Makefile b/drivers/acpi/nfit/Makefile
index a407e769f103..443c7ef4e6a6 100644
--- a/drivers/acpi/nfit/Makefile
+++ b/drivers/acpi/nfit/Makefile
@@ -1,3 +1,4 @@
obj-$(CONFIG_ACPI_NFIT) := nfit.o
nfit-y := core.o
+nfit-$(CONFIG_X86) += intel.o
nfit-$(CONFIG_X86_MCE) += mce.o
diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
index 21235d555b5f..9cb6a108ecba 100644
--- a/drivers/acpi/nfit/core.c
+++ b/drivers/acpi/nfit/core.c
@@ -1904,7 +1904,8 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
nvdimm = nvdimm_create(acpi_desc->nvdimm_bus, nfit_mem,
acpi_nfit_dimm_attribute_groups,
flags, cmd_mask, flush ? flush->hint_count : 0,
- nfit_mem->flush_wpq, &nfit_mem->id[0]);
+ nfit_mem->flush_wpq, &nfit_mem->id[0],
+ acpi_nfit_get_security_ops(nfit_mem->family));
if (!nvdimm)
return -ENOMEM;
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
new file mode 100644
index 000000000000..4bfc1c1da339
--- /dev/null
+++ b/drivers/acpi/nfit/intel.c
@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright(c) 2018 Intel Corporation. All rights reserved. */
+/*
+ * Intel specific NFIT ops
+ */
+#include <linux/libnvdimm.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/ndctl.h>
+#include <linux/sysfs.h>
+#include <linux/delay.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/nd.h>
+#include <asm/cacheflush.h>
+#include <asm/smp.h>
+#include <acpi/nfit.h>
+#include "intel.h"
+#include "nfit.h"
+
+static int intel_dimm_security_unlock(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_unlock_unit cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_UNLOCK_UNIT,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = ND_INTEL_PASSPHRASE_SIZE,
+ .nd_size_out = ND_INTEL_STATUS_SIZE,
+ .nd_fw_size = ND_INTEL_STATUS_SIZE,
+ },
+ .cmd = {
+ .status = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_UNLOCK_UNIT, &nfit_mem->dsm_mask))
+ return -ENOTTY;
+
+ memcpy(nd_cmd.cmd.passphrase, nkey->data,
+ sizeof(nd_cmd.cmd.passphrase));
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_INVALID_PASS:
+ rc = -EINVAL;
+ goto out;
+ case ND_INTEL_STATUS_INVALID_STATE:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ /*
+ * TODO: define a cross arch wbinvd when/if NVDIMM_FAMILY_INTEL
+ * support arrives on another arch.
+ */
+ /* DIMM unlocked, invalidate all CPU caches before we read it */
+ wbinvd_on_all_cpus();
+
+ out:
+ return rc;
+}
+
+static int intel_dimm_security_state(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm, enum nvdimm_security_state *state)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_get_security_state cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_GET_SECURITY_STATE,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = 0,
+ .nd_size_out =
+ sizeof(struct nd_intel_get_security_state),
+ .nd_fw_size =
+ sizeof(struct nd_intel_get_security_state),
+ },
+ .cmd = {
+ .status = 0,
+ .state = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_GET_SECURITY_STATE, &nfit_mem->dsm_mask)) {
+ *state = NVDIMM_SECURITY_UNSUPPORTED;
+ return 0;
+ }
+
+ *state = NVDIMM_SECURITY_DISABLED;
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_RETRY:
+ rc = -EAGAIN;
+ goto out;
+ case ND_INTEL_STATUS_NOT_READY:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ /* check and see if security is enabled and locked */
+ if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_UNSUPPORTED)
+ *state = NVDIMM_SECURITY_UNSUPPORTED;
+ else if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_ENABLED) {
+ if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_LOCKED)
+ *state = NVDIMM_SECURITY_LOCKED;
+ else
+ *state = NVDIMM_SECURITY_UNLOCKED;
+ } else
+ *state = NVDIMM_SECURITY_DISABLED;
+
+ out:
+ if (rc < 0)
+ *state = NVDIMM_SECURITY_INVALID;
+ return rc;
+}
+
+const struct nvdimm_security_ops intel_security_ops = {
+ .state = intel_dimm_security_state,
+ .unlock = intel_dimm_security_unlock,
+};
diff --git a/drivers/acpi/nfit/intel.h b/drivers/acpi/nfit/intel.h
index a6f8f4bc8ebb..f9ac718776ca 100644
--- a/drivers/acpi/nfit/intel.h
+++ b/drivers/acpi/nfit/intel.h
@@ -8,6 +8,8 @@
#ifdef CONFIG_X86
+extern const struct nvdimm_security_ops intel_security_ops;
+
#define ND_INTEL_STATUS_SIZE 4
#define ND_INTEL_PASSPHRASE_SIZE 32
@@ -64,4 +66,17 @@ struct nd_intel_query_overwrite {
} __packed;
#endif /* CONFIG_X86 */
+static inline const struct nvdimm_security_ops *
+acpi_nfit_get_security_ops(int family)
+{
+ switch (family) {
+#ifdef CONFIG_X86
+ case NVDIMM_FAMILY_INTEL:
+ return &intel_security_ops;
+#endif
+ default:
+ return NULL;
+ }
+}
+
#endif
diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c
index 6c8fb7590838..b6381ddbd6c1 100644
--- a/drivers/nvdimm/dimm.c
+++ b/drivers/nvdimm/dimm.c
@@ -51,6 +51,13 @@ static int nvdimm_probe(struct device *dev)
get_device(dev);
kref_init(&ndd->kref);
+ nvdimm_security_get_state(dev);
+
+ /* unlock DIMM here before touch label */
+ rc = nvdimm_security_unlock_dimm(dev);
+ if (rc < 0)
+ dev_warn(dev, "failed to unlock dimm %s\n", dev_name(dev));
+
/*
* EACCES failures reading the namespace label-area-properties
* are interpreted as the DIMM capacity being locked but the
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index e753b2095402..5b247f94807a 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -20,6 +20,7 @@
#include <linux/mm.h>
#include <linux/key.h>
#include <linux/init_task.h>
+#include <keys/user-type.h>
#include "nd-core.h"
#include "label.h"
#include "pmem.h"
@@ -28,6 +29,133 @@
static DEFINE_IDA(dimm_ida);
static struct key *nvdimm_keyring;
+/*
+ * Find key in kernel keyring
+ */
+static struct key *nvdimm_search_key(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct key *key;
+
+ if (!nvdimm->security_ops)
+ return NULL;
+
+ key = key_lookup(nvdimm->key_id);
+ if (IS_ERR(key))
+ key = NULL;
+ else
+ key_get(key);
+
+ dev_dbg(dev, "%s: key found: %d\n", __func__, key_serial(key));
+ return key;
+}
+
+#define NVDIMM_UPDATE_PREFIX "nvdimm.update:"
+#define NVDIMM_PREFIX "nvdimm:"
+
+/*
+ * Retrieve kernel key for DIMM and request from user space if necessary.
+ */
+static struct key *nvdimm_request_key(struct device *dev, bool update)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct key *key = NULL;
+ char desc[NVDIMM_KEY_DESC_LEN + strlen(NVDIMM_UPDATE_PREFIX)];
+
+ if (!nvdimm->security_ops)
+ return NULL;
+
+ sprintf(desc, "%s%s", update ? NVDIMM_UPDATE_PREFIX : NVDIMM_PREFIX,
+ nvdimm->dimm_id);
+ key = request_key(&key_type_logon, desc, desc);
+ if (IS_ERR(key))
+ key = NULL;
+
+ return key;
+}
+
+static int nvdimm_check_key_len(unsigned short len, bool update)
+{
+ if (len == (NVDIMM_PASSPHRASE_LEN * 2) && update)
+ return 0;
+
+ if (len == NVDIMM_PASSPHRASE_LEN)
+ return 0;
+
+ return -EINVAL;
+}
+
+int nvdimm_security_get_state(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ return nvdimm->security_ops->state(nvdimm_bus, nvdimm,
+ &nvdimm->state);
+}
+
+int nvdimm_security_unlock_dimm(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ struct key *key;
+ struct user_key_payload *payload;
+ int rc;
+ bool cached_key = false;
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ if (nvdimm->state == NVDIMM_SECURITY_UNLOCKED ||
+ nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED ||
+ nvdimm->state == NVDIMM_SECURITY_DISABLED)
+ return 0;
+
+ key = nvdimm_search_key(dev);
+ if (!key)
+ key = nvdimm_request_key(dev, false);
+ else
+ cached_key = true;
+ if (!key)
+ return -ENXIO;
+
+ if (!cached_key) {
+ rc = nvdimm_check_key_len(key->datalen, false);
+ if (rc < 0) {
+ key_invalidate(key);
+ key_put(key);
+ return rc;
+ }
+ }
+
+ dev_dbg(dev, "%s: key: %#x\n", __func__, key_serial(key));
+ down_read(&key->sem);
+ payload = key->payload.data[0];
+ rc = nvdimm->security_ops->unlock(nvdimm_bus, nvdimm,
+ (void *)payload->data);
+ up_read(&key->sem);
+
+ if (rc == 0) {
+ if (!cached_key) {
+ key_link(nvdimm_keyring, key);
+ nvdimm->key_id = key_serial(key);
+ }
+ nvdimm->state = NVDIMM_SECURITY_UNLOCKED;
+ dev_info(dev, "DIMM %s unlocked\n", dev_name(dev));
+ } else {
+ key_unlink(nvdimm_keyring, key);
+ key_invalidate(key);
+ dev_warn(dev, "Failed to unlock dimm: %s\n", dev_name(dev));
+ }
+
+ key_put(key);
+ nvdimm_security_get_state(dev);
+ return rc;
+}
+
/*
* Retrieve bus and dimm handle and return if this bus supports
* get_config_data commands
@@ -401,7 +529,8 @@ EXPORT_SYMBOL_GPL(nvdimm_attribute_group);
struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
const struct attribute_group **groups, unsigned long flags,
unsigned long cmd_mask, int num_flush,
- struct resource *flush_wpq, const char *dimm_id)
+ struct resource *flush_wpq, const char *dimm_id,
+ const struct nvdimm_security_ops *sec_ops)
{
struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
struct device *dev;
@@ -416,6 +545,7 @@ struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
}
nvdimm->dimm_id = dimm_id;
+ nvdimm->security_ops = sec_ops;
nvdimm->provider_data = provider_data;
nvdimm->flags = flags;
nvdimm->cmd_mask = cmd_mask;
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index ed650f1607d8..ff8919f9b67a 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -18,6 +18,7 @@
#include <linux/sizes.h>
#include <linux/mutex.h>
#include <linux/nd.h>
+#include <linux/key.h>
extern struct list_head nvdimm_bus_list;
extern struct mutex nvdimm_bus_list_mutex;
@@ -43,6 +44,9 @@ struct nvdimm {
int id, num_flush;
struct resource *flush_wpq;
const char *dimm_id;
+ const struct nvdimm_security_ops *security_ops;
+ enum nvdimm_security_state state;
+ key_serial_t key_id;
};
/**
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 9d17abd9f8d0..9c80e0f8c327 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -424,4 +424,6 @@ static inline bool is_bad_pmem(struct badblocks *bb, sector_t sector,
resource_size_t nd_namespace_blk_validate(struct nd_namespace_blk *nsblk);
const u8 *nd_dev_to_uuid(struct device *dev);
bool pmem_should_map_pages(struct device *dev);
+int nvdimm_security_unlock_dimm(struct device *dev);
+int nvdimm_security_get_state(struct device *dev);
#endif /* __ND_H__ */
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 3c1f18fdf76f..257ff2637ce1 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -155,9 +155,30 @@ static inline struct nd_blk_region_desc *to_blk_region_desc(
}
+enum nvdimm_security_state {
+ NVDIMM_SECURITY_INVALID = 0,
+ NVDIMM_SECURITY_DISABLED,
+ NVDIMM_SECURITY_UNLOCKED,
+ NVDIMM_SECURITY_LOCKED,
+ NVDIMM_SECURITY_UNSUPPORTED,
+};
+
#define NVDIMM_PASSPHRASE_LEN 32
#define NVDIMM_KEY_DESC_LEN 22
+struct nvdimm_key_data {
+ u8 data[NVDIMM_PASSPHRASE_LEN];
+};
+
+struct nvdimm_security_ops {
+ int (*state)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm,
+ enum nvdimm_security_state *state);
+ int (*unlock)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm,
+ const struct nvdimm_key_data *nkey);
+};
+
void badrange_init(struct badrange *badrange);
int badrange_add(struct badrange *badrange, u64 addr, u64 length);
void badrange_forget(struct badrange *badrange, phys_addr_t start,
@@ -181,7 +202,8 @@ void *nvdimm_provider_data(struct nvdimm *nvdimm);
struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
const struct attribute_group **groups, unsigned long flags,
unsigned long cmd_mask, int num_flush,
- struct resource *flush_wpq, const char *dimm_id);
+ struct resource *flush_wpq, const char *dimm_id,
+ const struct nvdimm_security_ops *sec_ops);
const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
diff --git a/security/keys/key.c b/security/keys/key.c
index d97c9394b5dd..5aa367b2fd24 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -679,6 +679,7 @@ struct key *key_lookup(key_serial_t id)
spin_unlock(&key_serial_lock);
return key;
}
+EXPORT_SYMBOL(key_lookup);
/*
* Find and lock the specified key type against removal.
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs
2018-07-25 20:58 ` [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs Dave Jiang
@ 2018-07-31 22:04 ` Alison Schofield
2018-07-31 22:48 ` Jiang, Dave
0 siblings, 1 reply; 21+ messages in thread
From: Alison Schofield @ 2018-07-31 22:04 UTC (permalink / raw)
To: Dave Jiang; +Cc: keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
On Wed, Jul 25, 2018 at 01:58:53PM -0700, Dave Jiang wrote:
> Add support to allow query the security status of the Intel nvdimms and
> also unlock the dimm via the kernel key management APIs. The passphrase is
> expected to be pulled from userspace through keyutils. Moving the Intel
> related bits to its own source file as well.
>
> Signed-off-by: Dave Jiang <dave.jiang@intel.com>
> Reviewed-by: Dan Williams <dan.j.williams@intel.com>
> ---
> drivers/acpi/nfit/Makefile | 1
> drivers/acpi/nfit/core.c | 3 +
> drivers/acpi/nfit/intel.c | 152 ++++++++++++++++++++++++++++++++++++++++++++
> drivers/acpi/nfit/intel.h | 15 ++++
> drivers/nvdimm/dimm.c | 7 ++
> drivers/nvdimm/dimm_devs.c | 132 ++++++++++++++++++++++++++++++++++++++
> drivers/nvdimm/nd-core.h | 4 +
> drivers/nvdimm/nd.h | 2 +
> include/linux/libnvdimm.h | 24 +++++++
> security/keys/key.c | 1
Dave - Why don't I see a config change "depends on KEYS" to make
LIBNVDIMM build?
> 10 files changed, 338 insertions(+), 3 deletions(-)
> create mode 100644 drivers/acpi/nfit/intel.c
>
> diff --git a/drivers/acpi/nfit/Makefile b/drivers/acpi/nfit/Makefile
> index a407e769f103..443c7ef4e6a6 100644
> --- a/drivers/acpi/nfit/Makefile
> +++ b/drivers/acpi/nfit/Makefile
> @@ -1,3 +1,4 @@
> obj-$(CONFIG_ACPI_NFIT) := nfit.o
> nfit-y := core.o
> +nfit-$(CONFIG_X86) += intel.o
> nfit-$(CONFIG_X86_MCE) += mce.o
> diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
> index 21235d555b5f..9cb6a108ecba 100644
> --- a/drivers/acpi/nfit/core.c
> +++ b/drivers/acpi/nfit/core.c
> @@ -1904,7 +1904,8 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
> nvdimm = nvdimm_create(acpi_desc->nvdimm_bus, nfit_mem,
> acpi_nfit_dimm_attribute_groups,
> flags, cmd_mask, flush ? flush->hint_count : 0,
> - nfit_mem->flush_wpq, &nfit_mem->id[0]);
> + nfit_mem->flush_wpq, &nfit_mem->id[0],
> + acpi_nfit_get_security_ops(nfit_mem->family));
> if (!nvdimm)
> return -ENOMEM;
>
> diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
> new file mode 100644
> index 000000000000..4bfc1c1da339
> --- /dev/null
> +++ b/drivers/acpi/nfit/intel.c
> @@ -0,0 +1,152 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright(c) 2018 Intel Corporation. All rights reserved. */
> +/*
> + * Intel specific NFIT ops
> + */
> +#include <linux/libnvdimm.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/ndctl.h>
> +#include <linux/sysfs.h>
> +#include <linux/delay.h>
> +#include <linux/acpi.h>
> +#include <linux/io.h>
> +#include <linux/nd.h>
> +#include <asm/cacheflush.h>
> +#include <asm/smp.h>
> +#include <acpi/nfit.h>
> +#include "intel.h"
> +#include "nfit.h"
> +
> +static int intel_dimm_security_unlock(struct nvdimm_bus *nvdimm_bus,
> + struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
> +{
> + struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
> + int cmd_rc, rc = 0;
> + struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
> + struct {
> + struct nd_cmd_pkg pkg;
> + struct nd_intel_unlock_unit cmd;
> + } nd_cmd = {
> + .pkg = {
> + .nd_command = NVDIMM_INTEL_UNLOCK_UNIT,
> + .nd_family = NVDIMM_FAMILY_INTEL,
> + .nd_size_in = ND_INTEL_PASSPHRASE_SIZE,
> + .nd_size_out = ND_INTEL_STATUS_SIZE,
> + .nd_fw_size = ND_INTEL_STATUS_SIZE,
> + },
> + .cmd = {
> + .status = 0,
> + },
> + };
> +
> + if (!test_bit(NVDIMM_INTEL_UNLOCK_UNIT, &nfit_mem->dsm_mask))
> + return -ENOTTY;
> +
> + memcpy(nd_cmd.cmd.passphrase, nkey->data,
> + sizeof(nd_cmd.cmd.passphrase));
> + rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
> + sizeof(nd_cmd), &cmd_rc);
> + if (rc < 0)
> + goto out;
> + if (cmd_rc < 0) {
> + rc = cmd_rc;
> + goto out;
> + }
> +
> + switch (nd_cmd.cmd.status) {
> + case 0:
> + break;
> + case ND_INTEL_STATUS_INVALID_PASS:
> + rc = -EINVAL;
> + goto out;
> + case ND_INTEL_STATUS_INVALID_STATE:
> + default:
> + rc = -ENXIO;
> + goto out;
> + }
> +
> + /*
> + * TODO: define a cross arch wbinvd when/if NVDIMM_FAMILY_INTEL
> + * support arrives on another arch.
> + */
> + /* DIMM unlocked, invalidate all CPU caches before we read it */
> + wbinvd_on_all_cpus();
> +
> + out:
> + return rc;
> +}
> +
> +static int intel_dimm_security_state(struct nvdimm_bus *nvdimm_bus,
> + struct nvdimm *nvdimm, enum nvdimm_security_state *state)
> +{
> + struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
> + int cmd_rc, rc = 0;
> + struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
> + struct {
> + struct nd_cmd_pkg pkg;
> + struct nd_intel_get_security_state cmd;
> + } nd_cmd = {
> + .pkg = {
> + .nd_command = NVDIMM_INTEL_GET_SECURITY_STATE,
> + .nd_family = NVDIMM_FAMILY_INTEL,
> + .nd_size_in = 0,
> + .nd_size_out =
> + sizeof(struct nd_intel_get_security_state),
> + .nd_fw_size =
> + sizeof(struct nd_intel_get_security_state),
> + },
> + .cmd = {
> + .status = 0,
> + .state = 0,
> + },
> + };
> +
> + if (!test_bit(NVDIMM_INTEL_GET_SECURITY_STATE, &nfit_mem->dsm_mask)) {
> + *state = NVDIMM_SECURITY_UNSUPPORTED;
> + return 0;
> + }
> +
> + *state = NVDIMM_SECURITY_DISABLED;
> + rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
> + sizeof(nd_cmd), &cmd_rc);
> + if (rc < 0)
> + goto out;
> + if (cmd_rc < 0) {
> + rc = cmd_rc;
> + goto out;
> + }
> +
> + switch (nd_cmd.cmd.status) {
> + case 0:
> + break;
> + case ND_INTEL_STATUS_RETRY:
> + rc = -EAGAIN;
> + goto out;
> + case ND_INTEL_STATUS_NOT_READY:
> + default:
> + rc = -ENXIO;
> + goto out;
> + }
> +
> + /* check and see if security is enabled and locked */
> + if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_UNSUPPORTED)
> + *state = NVDIMM_SECURITY_UNSUPPORTED;
> + else if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_ENABLED) {
> + if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_LOCKED)
> + *state = NVDIMM_SECURITY_LOCKED;
> + else
> + *state = NVDIMM_SECURITY_UNLOCKED;
> + } else
> + *state = NVDIMM_SECURITY_DISABLED;
> +
> + out:
> + if (rc < 0)
> + *state = NVDIMM_SECURITY_INVALID;
> + return rc;
> +}
> +
> +const struct nvdimm_security_ops intel_security_ops = {
> + .state = intel_dimm_security_state,
> + .unlock = intel_dimm_security_unlock,
> +};
> diff --git a/drivers/acpi/nfit/intel.h b/drivers/acpi/nfit/intel.h
> index a6f8f4bc8ebb..f9ac718776ca 100644
> --- a/drivers/acpi/nfit/intel.h
> +++ b/drivers/acpi/nfit/intel.h
> @@ -8,6 +8,8 @@
>
> #ifdef CONFIG_X86
>
> +extern const struct nvdimm_security_ops intel_security_ops;
> +
> #define ND_INTEL_STATUS_SIZE 4
> #define ND_INTEL_PASSPHRASE_SIZE 32
>
> @@ -64,4 +66,17 @@ struct nd_intel_query_overwrite {
> } __packed;
> #endif /* CONFIG_X86 */
>
> +static inline const struct nvdimm_security_ops *
> +acpi_nfit_get_security_ops(int family)
> +{
> + switch (family) {
> +#ifdef CONFIG_X86
> + case NVDIMM_FAMILY_INTEL:
> + return &intel_security_ops;
> +#endif
> + default:
> + return NULL;
> + }
> +}
> +
> #endif
> diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c
> index 6c8fb7590838..b6381ddbd6c1 100644
> --- a/drivers/nvdimm/dimm.c
> +++ b/drivers/nvdimm/dimm.c
> @@ -51,6 +51,13 @@ static int nvdimm_probe(struct device *dev)
> get_device(dev);
> kref_init(&ndd->kref);
>
> + nvdimm_security_get_state(dev);
> +
> + /* unlock DIMM here before touch label */
> + rc = nvdimm_security_unlock_dimm(dev);
> + if (rc < 0)
> + dev_warn(dev, "failed to unlock dimm %s\n", dev_name(dev));
> +
> /*
> * EACCES failures reading the namespace label-area-properties
> * are interpreted as the DIMM capacity being locked but the
> diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
> index e753b2095402..5b247f94807a 100644
> --- a/drivers/nvdimm/dimm_devs.c
> +++ b/drivers/nvdimm/dimm_devs.c
> @@ -20,6 +20,7 @@
> #include <linux/mm.h>
> #include <linux/key.h>
> #include <linux/init_task.h>
> +#include <keys/user-type.h>
> #include "nd-core.h"
> #include "label.h"
> #include "pmem.h"
> @@ -28,6 +29,133 @@
> static DEFINE_IDA(dimm_ida);
> static struct key *nvdimm_keyring;
>
> +/*
> + * Find key in kernel keyring
> + */
> +static struct key *nvdimm_search_key(struct device *dev)
> +{
> + struct nvdimm *nvdimm = to_nvdimm(dev);
> + struct key *key;
> +
> + if (!nvdimm->security_ops)
> + return NULL;
> +
> + key = key_lookup(nvdimm->key_id);
> + if (IS_ERR(key))
> + key = NULL;
> + else
> + key_get(key);
> +
> + dev_dbg(dev, "%s: key found: %d\n", __func__, key_serial(key));
> + return key;
> +}
> +
> +#define NVDIMM_UPDATE_PREFIX "nvdimm.update:"
> +#define NVDIMM_PREFIX "nvdimm:"
> +
> +/*
> + * Retrieve kernel key for DIMM and request from user space if necessary.
> + */
> +static struct key *nvdimm_request_key(struct device *dev, bool update)
> +{
> + struct nvdimm *nvdimm = to_nvdimm(dev);
> + struct key *key = NULL;
> + char desc[NVDIMM_KEY_DESC_LEN + strlen(NVDIMM_UPDATE_PREFIX)];
> +
> + if (!nvdimm->security_ops)
> + return NULL;
> +
> + sprintf(desc, "%s%s", update ? NVDIMM_UPDATE_PREFIX : NVDIMM_PREFIX,
> + nvdimm->dimm_id);
> + key = request_key(&key_type_logon, desc, desc);
> + if (IS_ERR(key))
> + key = NULL;
> +
> + return key;
> +}
> +
> +static int nvdimm_check_key_len(unsigned short len, bool update)
> +{
> + if (len == (NVDIMM_PASSPHRASE_LEN * 2) && update)
> + return 0;
> +
> + if (len == NVDIMM_PASSPHRASE_LEN)
> + return 0;
> +
> + return -EINVAL;
> +}
> +
> +int nvdimm_security_get_state(struct device *dev)
> +{
> + struct nvdimm *nvdimm = to_nvdimm(dev);
> + struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
> +
> + if (!nvdimm->security_ops)
> + return 0;
> +
> + return nvdimm->security_ops->state(nvdimm_bus, nvdimm,
> + &nvdimm->state);
> +}
> +
> +int nvdimm_security_unlock_dimm(struct device *dev)
> +{
> + struct nvdimm *nvdimm = to_nvdimm(dev);
> + struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
> + struct key *key;
> + struct user_key_payload *payload;
> + int rc;
> + bool cached_key = false;
> +
> + if (!nvdimm->security_ops)
> + return 0;
> +
> + if (nvdimm->state == NVDIMM_SECURITY_UNLOCKED ||
> + nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED ||
> + nvdimm->state == NVDIMM_SECURITY_DISABLED)
> + return 0;
> +
> + key = nvdimm_search_key(dev);
> + if (!key)
> + key = nvdimm_request_key(dev, false);
> + else
> + cached_key = true;
> + if (!key)
> + return -ENXIO;
> +
> + if (!cached_key) {
> + rc = nvdimm_check_key_len(key->datalen, false);
> + if (rc < 0) {
> + key_invalidate(key);
> + key_put(key);
> + return rc;
> + }
> + }
> +
> + dev_dbg(dev, "%s: key: %#x\n", __func__, key_serial(key));
> + down_read(&key->sem);
> + payload = key->payload.data[0];
> + rc = nvdimm->security_ops->unlock(nvdimm_bus, nvdimm,
> + (void *)payload->data);
> + up_read(&key->sem);
> +
> + if (rc == 0) {
> + if (!cached_key) {
> + key_link(nvdimm_keyring, key);
> + nvdimm->key_id = key_serial(key);
> + }
> + nvdimm->state = NVDIMM_SECURITY_UNLOCKED;
> + dev_info(dev, "DIMM %s unlocked\n", dev_name(dev));
> + } else {
> + key_unlink(nvdimm_keyring, key);
> + key_invalidate(key);
> + dev_warn(dev, "Failed to unlock dimm: %s\n", dev_name(dev));
> + }
> +
> + key_put(key);
> + nvdimm_security_get_state(dev);
> + return rc;
> +}
> +
> /*
> * Retrieve bus and dimm handle and return if this bus supports
> * get_config_data commands
> @@ -401,7 +529,8 @@ EXPORT_SYMBOL_GPL(nvdimm_attribute_group);
> struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> const struct attribute_group **groups, unsigned long flags,
> unsigned long cmd_mask, int num_flush,
> - struct resource *flush_wpq, const char *dimm_id)
> + struct resource *flush_wpq, const char *dimm_id,
> + const struct nvdimm_security_ops *sec_ops)
> {
> struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
> struct device *dev;
> @@ -416,6 +545,7 @@ struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> }
>
> nvdimm->dimm_id = dimm_id;
> + nvdimm->security_ops = sec_ops;
> nvdimm->provider_data = provider_data;
> nvdimm->flags = flags;
> nvdimm->cmd_mask = cmd_mask;
> diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
> index ed650f1607d8..ff8919f9b67a 100644
> --- a/drivers/nvdimm/nd-core.h
> +++ b/drivers/nvdimm/nd-core.h
> @@ -18,6 +18,7 @@
> #include <linux/sizes.h>
> #include <linux/mutex.h>
> #include <linux/nd.h>
> +#include <linux/key.h>
>
> extern struct list_head nvdimm_bus_list;
> extern struct mutex nvdimm_bus_list_mutex;
> @@ -43,6 +44,9 @@ struct nvdimm {
> int id, num_flush;
> struct resource *flush_wpq;
> const char *dimm_id;
> + const struct nvdimm_security_ops *security_ops;
> + enum nvdimm_security_state state;
> + key_serial_t key_id;
> };
>
> /**
> diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
> index 9d17abd9f8d0..9c80e0f8c327 100644
> --- a/drivers/nvdimm/nd.h
> +++ b/drivers/nvdimm/nd.h
> @@ -424,4 +424,6 @@ static inline bool is_bad_pmem(struct badblocks *bb, sector_t sector,
> resource_size_t nd_namespace_blk_validate(struct nd_namespace_blk *nsblk);
> const u8 *nd_dev_to_uuid(struct device *dev);
> bool pmem_should_map_pages(struct device *dev);
> +int nvdimm_security_unlock_dimm(struct device *dev);
> +int nvdimm_security_get_state(struct device *dev);
> #endif /* __ND_H__ */
> diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
> index 3c1f18fdf76f..257ff2637ce1 100644
> --- a/include/linux/libnvdimm.h
> +++ b/include/linux/libnvdimm.h
> @@ -155,9 +155,30 @@ static inline struct nd_blk_region_desc *to_blk_region_desc(
>
> }
>
> +enum nvdimm_security_state {
> + NVDIMM_SECURITY_INVALID = 0,
> + NVDIMM_SECURITY_DISABLED,
> + NVDIMM_SECURITY_UNLOCKED,
> + NVDIMM_SECURITY_LOCKED,
> + NVDIMM_SECURITY_UNSUPPORTED,
> +};
> +
> #define NVDIMM_PASSPHRASE_LEN 32
> #define NVDIMM_KEY_DESC_LEN 22
>
> +struct nvdimm_key_data {
> + u8 data[NVDIMM_PASSPHRASE_LEN];
> +};
> +
> +struct nvdimm_security_ops {
> + int (*state)(struct nvdimm_bus *nvdimm_bus,
> + struct nvdimm *nvdimm,
> + enum nvdimm_security_state *state);
> + int (*unlock)(struct nvdimm_bus *nvdimm_bus,
> + struct nvdimm *nvdimm,
> + const struct nvdimm_key_data *nkey);
> +};
> +
> void badrange_init(struct badrange *badrange);
> int badrange_add(struct badrange *badrange, u64 addr, u64 length);
> void badrange_forget(struct badrange *badrange, phys_addr_t start,
> @@ -181,7 +202,8 @@ void *nvdimm_provider_data(struct nvdimm *nvdimm);
> struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> const struct attribute_group **groups, unsigned long flags,
> unsigned long cmd_mask, int num_flush,
> - struct resource *flush_wpq, const char *dimm_id);
> + struct resource *flush_wpq, const char *dimm_id,
> + const struct nvdimm_security_ops *sec_ops);
> const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
> const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
> u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
> diff --git a/security/keys/key.c b/security/keys/key.c
> index d97c9394b5dd..5aa367b2fd24 100644
> --- a/security/keys/key.c
> +++ b/security/keys/key.c
> @@ -679,6 +679,7 @@ struct key *key_lookup(key_serial_t id)
> spin_unlock(&key_serial_lock);
> return key;
> }
> +EXPORT_SYMBOL(key_lookup);
>
> /*
> * Find and lock the specified key type against removal.
>
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread* RE: [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs
2018-07-31 22:04 ` Alison Schofield
@ 2018-07-31 22:48 ` Jiang, Dave
0 siblings, 0 replies; 21+ messages in thread
From: Jiang, Dave @ 2018-07-31 22:48 UTC (permalink / raw)
To: Schofield, Alison; +Cc: keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
> -----Original Message-----
> From: Schofield, Alison
> Sent: Tuesday, July 31, 2018 3:05 PM
> To: Jiang, Dave <dave.jiang@intel.com>
> Cc: linux-nvdimm@lists.01.org; Williams, Dan J <dan.j.williams@intel.com>; keyrings@vger.kernel.org; dhowells@redhat.com;
> keescook@chromium.org; elliott@hpe.com; ebiggers3@gmail.com
> Subject: Re: [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs
>
> On Wed, Jul 25, 2018 at 01:58:53PM -0700, Dave Jiang wrote:
> > Add support to allow query the security status of the Intel nvdimms and
> > also unlock the dimm via the kernel key management APIs. The passphrase is
> > expected to be pulled from userspace through keyutils. Moving the Intel
> > related bits to its own source file as well.
> >
> > Signed-off-by: Dave Jiang <dave.jiang@intel.com>
> > Reviewed-by: Dan Williams <dan.j.williams@intel.com>
> > ---
> > drivers/acpi/nfit/Makefile | 1
> > drivers/acpi/nfit/core.c | 3 +
> > drivers/acpi/nfit/intel.c | 152 ++++++++++++++++++++++++++++++++++++++++++++
> > drivers/acpi/nfit/intel.h | 15 ++++
> > drivers/nvdimm/dimm.c | 7 ++
> > drivers/nvdimm/dimm_devs.c | 132 ++++++++++++++++++++++++++++++++++++++
> > drivers/nvdimm/nd-core.h | 4 +
> > drivers/nvdimm/nd.h | 2 +
> > include/linux/libnvdimm.h | 24 +++++++
> > security/keys/key.c | 1
>
> Dave - Why don't I see a config change "depends on KEYS" to make
> LIBNVDIMM build?
Good catch Alison. I'll add.
>
>
> > 10 files changed, 338 insertions(+), 3 deletions(-)
> > create mode 100644 drivers/acpi/nfit/intel.c
> >
> > diff --git a/drivers/acpi/nfit/Makefile b/drivers/acpi/nfit/Makefile
> > index a407e769f103..443c7ef4e6a6 100644
> > --- a/drivers/acpi/nfit/Makefile
> > +++ b/drivers/acpi/nfit/Makefile
> > @@ -1,3 +1,4 @@
> > obj-$(CONFIG_ACPI_NFIT) := nfit.o
> > nfit-y := core.o
> > +nfit-$(CONFIG_X86) += intel.o
> > nfit-$(CONFIG_X86_MCE) += mce.o
> > diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
> > index 21235d555b5f..9cb6a108ecba 100644
> > --- a/drivers/acpi/nfit/core.c
> > +++ b/drivers/acpi/nfit/core.c
> > @@ -1904,7 +1904,8 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
> > nvdimm = nvdimm_create(acpi_desc->nvdimm_bus, nfit_mem,
> > acpi_nfit_dimm_attribute_groups,
> > flags, cmd_mask, flush ? flush->hint_count : 0,
> > - nfit_mem->flush_wpq, &nfit_mem->id[0]);
> > + nfit_mem->flush_wpq, &nfit_mem->id[0],
> > + acpi_nfit_get_security_ops(nfit_mem->family));
> > if (!nvdimm)
> > return -ENOMEM;
> >
> > diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
> > new file mode 100644
> > index 000000000000..4bfc1c1da339
> > --- /dev/null
> > +++ b/drivers/acpi/nfit/intel.c
> > @@ -0,0 +1,152 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/* Copyright(c) 2018 Intel Corporation. All rights reserved. */
> > +/*
> > + * Intel specific NFIT ops
> > + */
> > +#include <linux/libnvdimm.h>
> > +#include <linux/module.h>
> > +#include <linux/mutex.h>
> > +#include <linux/ndctl.h>
> > +#include <linux/sysfs.h>
> > +#include <linux/delay.h>
> > +#include <linux/acpi.h>
> > +#include <linux/io.h>
> > +#include <linux/nd.h>
> > +#include <asm/cacheflush.h>
> > +#include <asm/smp.h>
> > +#include <acpi/nfit.h>
> > +#include "intel.h"
> > +#include "nfit.h"
> > +
> > +static int intel_dimm_security_unlock(struct nvdimm_bus *nvdimm_bus,
> > + struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
> > +{
> > + struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
> > + int cmd_rc, rc = 0;
> > + struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
> > + struct {
> > + struct nd_cmd_pkg pkg;
> > + struct nd_intel_unlock_unit cmd;
> > + } nd_cmd = {
> > + .pkg = {
> > + .nd_command = NVDIMM_INTEL_UNLOCK_UNIT,
> > + .nd_family = NVDIMM_FAMILY_INTEL,
> > + .nd_size_in = ND_INTEL_PASSPHRASE_SIZE,
> > + .nd_size_out = ND_INTEL_STATUS_SIZE,
> > + .nd_fw_size = ND_INTEL_STATUS_SIZE,
> > + },
> > + .cmd = {
> > + .status = 0,
> > + },
> > + };
> > +
> > + if (!test_bit(NVDIMM_INTEL_UNLOCK_UNIT, &nfit_mem->dsm_mask))
> > + return -ENOTTY;
> > +
> > + memcpy(nd_cmd.cmd.passphrase, nkey->data,
> > + sizeof(nd_cmd.cmd.passphrase));
> > + rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
> > + sizeof(nd_cmd), &cmd_rc);
> > + if (rc < 0)
> > + goto out;
> > + if (cmd_rc < 0) {
> > + rc = cmd_rc;
> > + goto out;
> > + }
> > +
> > + switch (nd_cmd.cmd.status) {
> > + case 0:
> > + break;
> > + case ND_INTEL_STATUS_INVALID_PASS:
> > + rc = -EINVAL;
> > + goto out;
> > + case ND_INTEL_STATUS_INVALID_STATE:
> > + default:
> > + rc = -ENXIO;
> > + goto out;
> > + }
> > +
> > + /*
> > + * TODO: define a cross arch wbinvd when/if NVDIMM_FAMILY_INTEL
> > + * support arrives on another arch.
> > + */
> > + /* DIMM unlocked, invalidate all CPU caches before we read it */
> > + wbinvd_on_all_cpus();
> > +
> > + out:
> > + return rc;
> > +}
> > +
> > +static int intel_dimm_security_state(struct nvdimm_bus *nvdimm_bus,
> > + struct nvdimm *nvdimm, enum nvdimm_security_state *state)
> > +{
> > + struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
> > + int cmd_rc, rc = 0;
> > + struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
> > + struct {
> > + struct nd_cmd_pkg pkg;
> > + struct nd_intel_get_security_state cmd;
> > + } nd_cmd = {
> > + .pkg = {
> > + .nd_command = NVDIMM_INTEL_GET_SECURITY_STATE,
> > + .nd_family = NVDIMM_FAMILY_INTEL,
> > + .nd_size_in = 0,
> > + .nd_size_out =
> > + sizeof(struct nd_intel_get_security_state),
> > + .nd_fw_size =
> > + sizeof(struct nd_intel_get_security_state),
> > + },
> > + .cmd = {
> > + .status = 0,
> > + .state = 0,
> > + },
> > + };
> > +
> > + if (!test_bit(NVDIMM_INTEL_GET_SECURITY_STATE, &nfit_mem->dsm_mask)) {
> > + *state = NVDIMM_SECURITY_UNSUPPORTED;
> > + return 0;
> > + }
> > +
> > + *state = NVDIMM_SECURITY_DISABLED;
> > + rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
> > + sizeof(nd_cmd), &cmd_rc);
> > + if (rc < 0)
> > + goto out;
> > + if (cmd_rc < 0) {
> > + rc = cmd_rc;
> > + goto out;
> > + }
> > +
> > + switch (nd_cmd.cmd.status) {
> > + case 0:
> > + break;
> > + case ND_INTEL_STATUS_RETRY:
> > + rc = -EAGAIN;
> > + goto out;
> > + case ND_INTEL_STATUS_NOT_READY:
> > + default:
> > + rc = -ENXIO;
> > + goto out;
> > + }
> > +
> > + /* check and see if security is enabled and locked */
> > + if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_UNSUPPORTED)
> > + *state = NVDIMM_SECURITY_UNSUPPORTED;
> > + else if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_ENABLED) {
> > + if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_LOCKED)
> > + *state = NVDIMM_SECURITY_LOCKED;
> > + else
> > + *state = NVDIMM_SECURITY_UNLOCKED;
> > + } else
> > + *state = NVDIMM_SECURITY_DISABLED;
> > +
> > + out:
> > + if (rc < 0)
> > + *state = NVDIMM_SECURITY_INVALID;
> > + return rc;
> > +}
> > +
> > +const struct nvdimm_security_ops intel_security_ops = {
> > + .state = intel_dimm_security_state,
> > + .unlock = intel_dimm_security_unlock,
> > +};
> > diff --git a/drivers/acpi/nfit/intel.h b/drivers/acpi/nfit/intel.h
> > index a6f8f4bc8ebb..f9ac718776ca 100644
> > --- a/drivers/acpi/nfit/intel.h
> > +++ b/drivers/acpi/nfit/intel.h
> > @@ -8,6 +8,8 @@
> >
> > #ifdef CONFIG_X86
> >
> > +extern const struct nvdimm_security_ops intel_security_ops;
> > +
> > #define ND_INTEL_STATUS_SIZE 4
> > #define ND_INTEL_PASSPHRASE_SIZE 32
> >
> > @@ -64,4 +66,17 @@ struct nd_intel_query_overwrite {
> > } __packed;
> > #endif /* CONFIG_X86 */
> >
> > +static inline const struct nvdimm_security_ops *
> > +acpi_nfit_get_security_ops(int family)
> > +{
> > + switch (family) {
> > +#ifdef CONFIG_X86
> > + case NVDIMM_FAMILY_INTEL:
> > + return &intel_security_ops;
> > +#endif
> > + default:
> > + return NULL;
> > + }
> > +}
> > +
> > #endif
> > diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c
> > index 6c8fb7590838..b6381ddbd6c1 100644
> > --- a/drivers/nvdimm/dimm.c
> > +++ b/drivers/nvdimm/dimm.c
> > @@ -51,6 +51,13 @@ static int nvdimm_probe(struct device *dev)
> > get_device(dev);
> > kref_init(&ndd->kref);
> >
> > + nvdimm_security_get_state(dev);
> > +
> > + /* unlock DIMM here before touch label */
> > + rc = nvdimm_security_unlock_dimm(dev);
> > + if (rc < 0)
> > + dev_warn(dev, "failed to unlock dimm %s\n", dev_name(dev));
> > +
> > /*
> > * EACCES failures reading the namespace label-area-properties
> > * are interpreted as the DIMM capacity being locked but the
> > diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
> > index e753b2095402..5b247f94807a 100644
> > --- a/drivers/nvdimm/dimm_devs.c
> > +++ b/drivers/nvdimm/dimm_devs.c
> > @@ -20,6 +20,7 @@
> > #include <linux/mm.h>
> > #include <linux/key.h>
> > #include <linux/init_task.h>
> > +#include <keys/user-type.h>
> > #include "nd-core.h"
> > #include "label.h"
> > #include "pmem.h"
> > @@ -28,6 +29,133 @@
> > static DEFINE_IDA(dimm_ida);
> > static struct key *nvdimm_keyring;
> >
> > +/*
> > + * Find key in kernel keyring
> > + */
> > +static struct key *nvdimm_search_key(struct device *dev)
> > +{
> > + struct nvdimm *nvdimm = to_nvdimm(dev);
> > + struct key *key;
> > +
> > + if (!nvdimm->security_ops)
> > + return NULL;
> > +
> > + key = key_lookup(nvdimm->key_id);
> > + if (IS_ERR(key))
> > + key = NULL;
> > + else
> > + key_get(key);
> > +
> > + dev_dbg(dev, "%s: key found: %d\n", __func__, key_serial(key));
> > + return key;
> > +}
> > +
> > +#define NVDIMM_UPDATE_PREFIX "nvdimm.update:"
> > +#define NVDIMM_PREFIX "nvdimm:"
> > +
> > +/*
> > + * Retrieve kernel key for DIMM and request from user space if necessary.
> > + */
> > +static struct key *nvdimm_request_key(struct device *dev, bool update)
> > +{
> > + struct nvdimm *nvdimm = to_nvdimm(dev);
> > + struct key *key = NULL;
> > + char desc[NVDIMM_KEY_DESC_LEN + strlen(NVDIMM_UPDATE_PREFIX)];
> > +
> > + if (!nvdimm->security_ops)
> > + return NULL;
> > +
> > + sprintf(desc, "%s%s", update ? NVDIMM_UPDATE_PREFIX : NVDIMM_PREFIX,
> > + nvdimm->dimm_id);
> > + key = request_key(&key_type_logon, desc, desc);
> > + if (IS_ERR(key))
> > + key = NULL;
> > +
> > + return key;
> > +}
> > +
> > +static int nvdimm_check_key_len(unsigned short len, bool update)
> > +{
> > + if (len == (NVDIMM_PASSPHRASE_LEN * 2) && update)
> > + return 0;
> > +
> > + if (len == NVDIMM_PASSPHRASE_LEN)
> > + return 0;
> > +
> > + return -EINVAL;
> > +}
> > +
> > +int nvdimm_security_get_state(struct device *dev)
> > +{
> > + struct nvdimm *nvdimm = to_nvdimm(dev);
> > + struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
> > +
> > + if (!nvdimm->security_ops)
> > + return 0;
> > +
> > + return nvdimm->security_ops->state(nvdimm_bus, nvdimm,
> > + &nvdimm->state);
> > +}
> > +
> > +int nvdimm_security_unlock_dimm(struct device *dev)
> > +{
> > + struct nvdimm *nvdimm = to_nvdimm(dev);
> > + struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
> > + struct key *key;
> > + struct user_key_payload *payload;
> > + int rc;
> > + bool cached_key = false;
> > +
> > + if (!nvdimm->security_ops)
> > + return 0;
> > +
> > + if (nvdimm->state == NVDIMM_SECURITY_UNLOCKED ||
> > + nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED ||
> > + nvdimm->state == NVDIMM_SECURITY_DISABLED)
> > + return 0;
> > +
> > + key = nvdimm_search_key(dev);
> > + if (!key)
> > + key = nvdimm_request_key(dev, false);
> > + else
> > + cached_key = true;
> > + if (!key)
> > + return -ENXIO;
> > +
> > + if (!cached_key) {
> > + rc = nvdimm_check_key_len(key->datalen, false);
> > + if (rc < 0) {
> > + key_invalidate(key);
> > + key_put(key);
> > + return rc;
> > + }
> > + }
> > +
> > + dev_dbg(dev, "%s: key: %#x\n", __func__, key_serial(key));
> > + down_read(&key->sem);
> > + payload = key->payload.data[0];
> > + rc = nvdimm->security_ops->unlock(nvdimm_bus, nvdimm,
> > + (void *)payload->data);
> > + up_read(&key->sem);
> > +
> > + if (rc == 0) {
> > + if (!cached_key) {
> > + key_link(nvdimm_keyring, key);
> > + nvdimm->key_id = key_serial(key);
> > + }
> > + nvdimm->state = NVDIMM_SECURITY_UNLOCKED;
> > + dev_info(dev, "DIMM %s unlocked\n", dev_name(dev));
> > + } else {
> > + key_unlink(nvdimm_keyring, key);
> > + key_invalidate(key);
> > + dev_warn(dev, "Failed to unlock dimm: %s\n", dev_name(dev));
> > + }
> > +
> > + key_put(key);
> > + nvdimm_security_get_state(dev);
> > + return rc;
> > +}
> > +
> > /*
> > * Retrieve bus and dimm handle and return if this bus supports
> > * get_config_data commands
> > @@ -401,7 +529,8 @@ EXPORT_SYMBOL_GPL(nvdimm_attribute_group);
> > struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> > const struct attribute_group **groups, unsigned long flags,
> > unsigned long cmd_mask, int num_flush,
> > - struct resource *flush_wpq, const char *dimm_id)
> > + struct resource *flush_wpq, const char *dimm_id,
> > + const struct nvdimm_security_ops *sec_ops)
> > {
> > struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
> > struct device *dev;
> > @@ -416,6 +545,7 @@ struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> > }
> >
> > nvdimm->dimm_id = dimm_id;
> > + nvdimm->security_ops = sec_ops;
> > nvdimm->provider_data = provider_data;
> > nvdimm->flags = flags;
> > nvdimm->cmd_mask = cmd_mask;
> > diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
> > index ed650f1607d8..ff8919f9b67a 100644
> > --- a/drivers/nvdimm/nd-core.h
> > +++ b/drivers/nvdimm/nd-core.h
> > @@ -18,6 +18,7 @@
> > #include <linux/sizes.h>
> > #include <linux/mutex.h>
> > #include <linux/nd.h>
> > +#include <linux/key.h>
> >
> > extern struct list_head nvdimm_bus_list;
> > extern struct mutex nvdimm_bus_list_mutex;
> > @@ -43,6 +44,9 @@ struct nvdimm {
> > int id, num_flush;
> > struct resource *flush_wpq;
> > const char *dimm_id;
> > + const struct nvdimm_security_ops *security_ops;
> > + enum nvdimm_security_state state;
> > + key_serial_t key_id;
> > };
> >
> > /**
> > diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
> > index 9d17abd9f8d0..9c80e0f8c327 100644
> > --- a/drivers/nvdimm/nd.h
> > +++ b/drivers/nvdimm/nd.h
> > @@ -424,4 +424,6 @@ static inline bool is_bad_pmem(struct badblocks *bb, sector_t sector,
> > resource_size_t nd_namespace_blk_validate(struct nd_namespace_blk *nsblk);
> > const u8 *nd_dev_to_uuid(struct device *dev);
> > bool pmem_should_map_pages(struct device *dev);
> > +int nvdimm_security_unlock_dimm(struct device *dev);
> > +int nvdimm_security_get_state(struct device *dev);
> > #endif /* __ND_H__ */
> > diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
> > index 3c1f18fdf76f..257ff2637ce1 100644
> > --- a/include/linux/libnvdimm.h
> > +++ b/include/linux/libnvdimm.h
> > @@ -155,9 +155,30 @@ static inline struct nd_blk_region_desc *to_blk_region_desc(
> >
> > }
> >
> > +enum nvdimm_security_state {
> > + NVDIMM_SECURITY_INVALID = 0,
> > + NVDIMM_SECURITY_DISABLED,
> > + NVDIMM_SECURITY_UNLOCKED,
> > + NVDIMM_SECURITY_LOCKED,
> > + NVDIMM_SECURITY_UNSUPPORTED,
> > +};
> > +
> > #define NVDIMM_PASSPHRASE_LEN 32
> > #define NVDIMM_KEY_DESC_LEN 22
> >
> > +struct nvdimm_key_data {
> > + u8 data[NVDIMM_PASSPHRASE_LEN];
> > +};
> > +
> > +struct nvdimm_security_ops {
> > + int (*state)(struct nvdimm_bus *nvdimm_bus,
> > + struct nvdimm *nvdimm,
> > + enum nvdimm_security_state *state);
> > + int (*unlock)(struct nvdimm_bus *nvdimm_bus,
> > + struct nvdimm *nvdimm,
> > + const struct nvdimm_key_data *nkey);
> > +};
> > +
> > void badrange_init(struct badrange *badrange);
> > int badrange_add(struct badrange *badrange, u64 addr, u64 length);
> > void badrange_forget(struct badrange *badrange, phys_addr_t start,
> > @@ -181,7 +202,8 @@ void *nvdimm_provider_data(struct nvdimm *nvdimm);
> > struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
> > const struct attribute_group **groups, unsigned long flags,
> > unsigned long cmd_mask, int num_flush,
> > - struct resource *flush_wpq, const char *dimm_id);
> > + struct resource *flush_wpq, const char *dimm_id,
> > + const struct nvdimm_security_ops *sec_ops);
> > const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
> > const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
> > u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
> > diff --git a/security/keys/key.c b/security/keys/key.c
> > index d97c9394b5dd..5aa367b2fd24 100644
> > --- a/security/keys/key.c
> > +++ b/security/keys/key.c
> > @@ -679,6 +679,7 @@ struct key *key_lookup(key_serial_t id)
> > spin_unlock(&key_serial_lock);
> > return key;
> > }
> > +EXPORT_SYMBOL(key_lookup);
> >
> > /*
> > * Find and lock the specified key type against removal.
> >
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (3 preceding siblings ...)
2018-07-25 20:58 ` [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs Dave Jiang
@ 2018-07-25 20:58 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 06/11] nfit/libnvdimm: add disable passphrase support to Intel nvdimm Dave Jiang
` (7 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:58 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add support for setting and/or updating passphrase on the Intel nvdimms.
The passphrase is pulled from userspace through the kernel key management.
We trigger the update via writing "update" to the sysfs attribute
"security". The state of the security can also be read via the "security"
attribute. libnvdimm will generically support the key_change API call.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
---
drivers/acpi/nfit/intel.c | 68 +++++++++++++++++++++++++
drivers/nvdimm/dimm_devs.c | 120 ++++++++++++++++++++++++++++++++++++++++++++
include/linux/libnvdimm.h | 5 ++
3 files changed, 193 insertions(+)
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
index 4bfc1c1da339..314eae7e02d7 100644
--- a/drivers/acpi/nfit/intel.c
+++ b/drivers/acpi/nfit/intel.c
@@ -18,6 +18,73 @@
#include "intel.h"
#include "nfit.h"
+/*
+ * The update passphrase takes the old passphrase and the new passphrase
+ * and send those to the nvdimm. The nvdimm will verify the old
+ * passphrase and then update it with the new passphrase if pending
+ * verification. The function will pass in a zeroed passphrase field
+ * if the old passphrase is NULL. This typically happens when we are
+ * enabling security from the disabled state.
+ */
+static int intel_dimm_security_update_passphrase(
+ struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,
+ const struct nvdimm_key_data *old_data,
+ const struct nvdimm_key_data *new_data)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_set_passphrase cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_SET_PASSPHRASE,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = ND_INTEL_PASSPHRASE_SIZE * 2,
+ .nd_size_out = ND_INTEL_STATUS_SIZE,
+ .nd_fw_size = ND_INTEL_STATUS_SIZE,
+ },
+ .cmd = {
+ .status = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_SET_PASSPHRASE, &nfit_mem->dsm_mask))
+ return -ENOTTY;
+
+ if (old_data)
+ memcpy(nd_cmd.cmd.old_pass, old_data->data,
+ sizeof(nd_cmd.cmd.old_pass));
+ else
+ memset(nd_cmd.cmd.old_pass, 0, sizeof(nd_cmd.cmd.old_pass));
+ memcpy(nd_cmd.cmd.new_pass, new_data->data,
+ sizeof(nd_cmd.cmd.new_pass));
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_INVALID_PASS:
+ rc = -EINVAL;
+ goto out;
+ case ND_INTEL_STATUS_INVALID_STATE:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ out:
+ return rc;
+}
+
static int intel_dimm_security_unlock(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
{
@@ -149,4 +216,5 @@ static int intel_dimm_security_state(struct nvdimm_bus *nvdimm_bus,
const struct nvdimm_security_ops intel_security_ops = {
.state = intel_dimm_security_state,
.unlock = intel_dimm_security_unlock,
+ .change_key = intel_dimm_security_update_passphrase,
};
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 5b247f94807a..c6029e3f329e 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -156,6 +156,79 @@ int nvdimm_security_unlock_dimm(struct device *dev)
return rc;
}
+static int nvdimm_security_change_key(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ struct key *key = NULL, *old_key = NULL;
+ int rc;
+ void *old_data, *new_data;
+ bool update = false;
+ struct user_key_payload *payload;
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ if (nvdimm->state == NVDIMM_SECURITY_FROZEN)
+ return -EBUSY;
+
+ /* look for a key from keyring if exists and remove */
+ old_key = nvdimm_search_key(dev);
+ if (old_key) {
+ dev_dbg(dev, "%s: old key: %#x\n",
+ __func__, key_serial(old_key));
+ update = true;
+ }
+
+ /* request new key from userspace */
+ key = nvdimm_request_key(dev, update);
+ if (!key) {
+ dev_dbg(dev, "%s: failed to acquire new key\n", __func__);
+ rc = -ENXIO;
+ goto out;
+ }
+
+ dev_dbg(dev, "%s: new key: %#x\n", __func__, key_serial(key));
+
+ rc = nvdimm_check_key_len(key->datalen, update);
+ if (rc < 0)
+ goto out;
+
+ payload = key->payload.data[0];
+ if (!update) {
+ old_data = NULL;
+ new_data = payload->data;
+ } else {
+ new_data = payload->data;
+ old_data = new_data + NVDIMM_PASSPHRASE_LEN;
+ }
+
+ down_read(&key->sem);
+ rc = nvdimm->security_ops->change_key(nvdimm_bus, nvdimm, old_data,
+ new_data);
+ /* copy new payload to old payload */
+ if (rc == 0) {
+ if (update)
+ key_update(make_key_ref(old_key, 1), new_data,
+ old_key->datalen);
+ else
+ nvdimm->key_id = key_serial(key);
+ } else
+ dev_warn(dev, "key update failed\n");
+ up_read(&key->sem);
+
+ if (update)
+ key_invalidate(key);
+ nvdimm_security_get_state(dev);
+
+ out:
+ if (old_key)
+ key_put(old_key);
+ if (key)
+ key_put(key);
+ return rc;
+}
+
/*
* Retrieve bus and dimm handle and return if this bus supports
* get_config_data commands
@@ -513,11 +586,58 @@ static ssize_t available_slots_show(struct device *dev,
}
static DEVICE_ATTR_RO(available_slots);
+static ssize_t security_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+
+ switch (nvdimm->state) {
+ case NVDIMM_SECURITY_DISABLED:
+ return sprintf(buf, "disabled\n");
+ case NVDIMM_SECURITY_UNLOCKED:
+ return sprintf(buf, "unlocked\n");
+ case NVDIMM_SECURITY_LOCKED:
+ return sprintf(buf, "locked\n");
+ case NVDIMM_SECURITY_FROZEN:
+ return sprintf(buf, "frozen\n");
+ case NVDIMM_SECURITY_UNSUPPORTED:
+ default:
+ return sprintf(buf, "unsupported\n");
+ }
+
+ return -ENOTTY;
+}
+
+static ssize_t security_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ ssize_t rc = -EINVAL;
+
+ wait_nvdimm_bus_probe_idle(&nvdimm_bus->dev);
+ if (atomic_read(&nvdimm->busy))
+ return -EBUSY;
+
+ if (sysfs_streq(buf, "update"))
+ rc = nvdimm_security_change_key(dev);
+ else
+ return -EINVAL;
+
+ if (rc == 0)
+ rc = len;
+
+ return rc;
+}
+static DEVICE_ATTR_RW(security);
+
static struct attribute *nvdimm_attributes[] = {
&dev_attr_state.attr,
&dev_attr_flags.attr,
&dev_attr_commands.attr,
&dev_attr_available_slots.attr,
+ &dev_attr_security.attr,
NULL,
};
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 257ff2637ce1..bd6a413164ee 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -160,6 +160,7 @@ enum nvdimm_security_state {
NVDIMM_SECURITY_DISABLED,
NVDIMM_SECURITY_UNLOCKED,
NVDIMM_SECURITY_LOCKED,
+ NVDIMM_SECURITY_FROZEN,
NVDIMM_SECURITY_UNSUPPORTED,
};
@@ -177,6 +178,10 @@ struct nvdimm_security_ops {
int (*unlock)(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm,
const struct nvdimm_key_data *nkey);
+ int (*change_key)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm,
+ const struct nvdimm_key_data *old_data,
+ const struct nvdimm_key_data *new_data);
};
void badrange_init(struct badrange *badrange);
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 06/11] nfit/libnvdimm: add disable passphrase support to Intel nvdimm.
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (4 preceding siblings ...)
2018-07-25 20:58 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 07/11] nfit/libnvdimm: add freeze security " Dave Jiang
` (6 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add support to disable passphrase (security) for the Intel nvdimm. The
passphrase used for disabling is pulled from userspace via the kernel
key management. The action is triggered by writing "disable" to the sysfs
attribute "security". libnvdimm will support the generic disable API call.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/intel.c | 53 ++++++++++++++++++++++++++++++++++++++++++++
drivers/nvdimm/dimm_devs.c | 43 ++++++++++++++++++++++++++++++++++++
include/linux/libnvdimm.h | 3 ++
3 files changed, 99 insertions(+)
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
index 314eae7e02d7..21d30222371f 100644
--- a/drivers/acpi/nfit/intel.c
+++ b/drivers/acpi/nfit/intel.c
@@ -18,6 +18,58 @@
#include "intel.h"
#include "nfit.h"
+static int intel_dimm_security_disable(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_disable_passphrase cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_DISABLE_PASSPHRASE,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = ND_INTEL_PASSPHRASE_SIZE,
+ .nd_size_out = ND_INTEL_STATUS_SIZE,
+ .nd_fw_size = ND_INTEL_STATUS_SIZE,
+ },
+ .cmd = {
+ .status = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_DISABLE_PASSPHRASE, &nfit_mem->dsm_mask))
+ return -ENOTTY;
+
+ memcpy(nd_cmd.cmd.passphrase, nkey->data,
+ sizeof(nd_cmd.cmd.passphrase));
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_INVALID_PASS:
+ rc = -EINVAL;
+ goto out;
+ case ND_INTEL_STATUS_INVALID_STATE:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ out:
+ return rc;
+}
+
/*
* The update passphrase takes the old passphrase and the new passphrase
* and send those to the nvdimm. The nvdimm will verify the old
@@ -217,4 +269,5 @@ const struct nvdimm_security_ops intel_security_ops = {
.state = intel_dimm_security_state,
.unlock = intel_dimm_security_unlock,
.change_key = intel_dimm_security_update_passphrase,
+ .disable = intel_dimm_security_disable,
};
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index c6029e3f329e..1d85a4cb9402 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -97,6 +97,47 @@ int nvdimm_security_get_state(struct device *dev)
&nvdimm->state);
}
+static int nvdimm_security_disable(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ struct key *key;
+ int rc;
+ struct user_key_payload *payload;
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ if (nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED)
+ return 0;
+
+ key = nvdimm_search_key(dev);
+ if (!key) {
+ dev_warn(dev, "no key found\n");
+ return -ENOKEY;
+ }
+
+ down_read(&key->sem);
+ payload = key->payload.data[0];
+ rc = nvdimm->security_ops->disable(nvdimm_bus, nvdimm,
+ (void *)payload->data);
+ up_read(&key->sem);
+ if (rc < 0) {
+ dev_warn(dev, "unlock failed\n");
+ goto out;
+ }
+
+ /* If we succeed then remove the key */
+ key_unlink(nvdimm_keyring, key);
+ key_invalidate(key);
+ nvdimm->key_id = 0;
+
+ out:
+ key_put(key);
+ nvdimm_security_get_state(dev);
+ return rc;
+}
+
int nvdimm_security_unlock_dimm(struct device *dev)
{
struct nvdimm *nvdimm = to_nvdimm(dev);
@@ -622,6 +663,8 @@ static ssize_t security_store(struct device *dev,
if (sysfs_streq(buf, "update"))
rc = nvdimm_security_change_key(dev);
+ else if (sysfs_streq(buf, "disable"))
+ rc = nvdimm_security_disable(dev);
else
return -EINVAL;
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index bd6a413164ee..c60ab4b238f3 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -182,6 +182,9 @@ struct nvdimm_security_ops {
struct nvdimm *nvdimm,
const struct nvdimm_key_data *old_data,
const struct nvdimm_key_data *new_data);
+ int (*disable)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm,
+ const struct nvdimm_key_data *nkey);
};
void badrange_init(struct badrange *badrange);
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 07/11] nfit/libnvdimm: add freeze security support to Intel nvdimm
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (5 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 06/11] nfit/libnvdimm: add disable passphrase support to Intel nvdimm Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 08/11] nfit/libnvdimm: add support for issue secure erase DSM " Dave Jiang
` (5 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add support for freeze security on Intel nvdimm. This locks out any
changes to security for the DIMM unless a reboot is done. This is triggered
by writing "freeze" to the "security" sysfs attribute. libnvdimm will
support the generic freeze_lock API call.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/intel.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
drivers/nvdimm/dimm_devs.c | 22 +++++++++++++++++++
include/linux/libnvdimm.h | 2 ++
3 files changed, 75 insertions(+)
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
index 21d30222371f..ba886f1f5399 100644
--- a/drivers/acpi/nfit/intel.c
+++ b/drivers/acpi/nfit/intel.c
@@ -18,6 +18,53 @@
#include "intel.h"
#include "nfit.h"
+static int intel_dimm_security_freeze_lock(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_freeze_lock cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_FREEZE_LOCK,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = 0,
+ .nd_size_out = ND_INTEL_STATUS_SIZE,
+ .nd_fw_size = ND_INTEL_STATUS_SIZE,
+ },
+ .cmd = {
+ .status = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_FREEZE_LOCK, &nfit_mem->dsm_mask))
+ return -ENOTTY;
+
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_INVALID_STATE:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ out:
+ return rc;
+}
+
static int intel_dimm_security_disable(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
{
@@ -254,6 +301,9 @@ static int intel_dimm_security_state(struct nvdimm_bus *nvdimm_bus,
else if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_ENABLED) {
if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_LOCKED)
*state = NVDIMM_SECURITY_LOCKED;
+ else if (nd_cmd.cmd.state & ND_INTEL_SEC_STATE_FROZEN ||
+ nd_cmd.cmd.state & ND_INTEL_SEC_STATE_PLIMIT)
+ *state = NVDIMM_SECURITY_FROZEN;
else
*state = NVDIMM_SECURITY_UNLOCKED;
} else
@@ -270,4 +320,5 @@ const struct nvdimm_security_ops intel_security_ops = {
.unlock = intel_dimm_security_unlock,
.change_key = intel_dimm_security_update_passphrase,
.disable = intel_dimm_security_disable,
+ .freeze_lock = intel_dimm_security_freeze_lock,
};
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 1d85a4cb9402..8f4ea4e2c2ab 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -97,6 +97,26 @@ int nvdimm_security_get_state(struct device *dev)
&nvdimm->state);
}
+static int nvdimm_security_freeze_lock(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ int rc;
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ if (nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED)
+ return 0;
+
+ rc = nvdimm->security_ops->freeze_lock(nvdimm_bus, nvdimm);
+ if (rc < 0)
+ return rc;
+
+ nvdimm_security_get_state(dev);
+ return 0;
+}
+
static int nvdimm_security_disable(struct device *dev)
{
struct nvdimm *nvdimm = to_nvdimm(dev);
@@ -665,6 +685,8 @@ static ssize_t security_store(struct device *dev,
rc = nvdimm_security_change_key(dev);
else if (sysfs_streq(buf, "disable"))
rc = nvdimm_security_disable(dev);
+ else if (sysfs_streq(buf, "freeze"))
+ rc = nvdimm_security_freeze_lock(dev);
else
return -EINVAL;
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index c60ab4b238f3..bcab42caa948 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -185,6 +185,8 @@ struct nvdimm_security_ops {
int (*disable)(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm,
const struct nvdimm_key_data *nkey);
+ int (*freeze_lock)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm);
};
void badrange_init(struct badrange *badrange);
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 08/11] nfit/libnvdimm: add support for issue secure erase DSM to Intel nvdimm
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (6 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 07/11] nfit/libnvdimm: add freeze security " Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 09/11] nfit_test: add context to dimm_dev for nfit_test Dave Jiang
` (4 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add support to issue a secure erase DSM to the Intel nvdimm. The
required passphrase is acquired from userspace through the kernel key
management. To trigger the action, "erase" is written to the "security"
sysfs attribute. libnvdimm will support the erase generic API call.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit/intel.c | 58 ++++++++++++++++++++++++++++++++++++++++++++
drivers/nvdimm/dimm_devs.c | 49 +++++++++++++++++++++++++++++++++++++
include/linux/libnvdimm.h | 3 ++
3 files changed, 110 insertions(+)
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
index ba886f1f5399..419a7d54d4e8 100644
--- a/drivers/acpi/nfit/intel.c
+++ b/drivers/acpi/nfit/intel.c
@@ -18,6 +18,63 @@
#include "intel.h"
#include "nfit.h"
+static int intel_dimm_security_erase(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm, const struct nvdimm_key_data *nkey)
+{
+ struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
+ int cmd_rc, rc = 0;
+ struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+ struct {
+ struct nd_cmd_pkg pkg;
+ struct nd_intel_secure_erase cmd;
+ } nd_cmd = {
+ .pkg = {
+ .nd_command = NVDIMM_INTEL_SECURE_ERASE,
+ .nd_family = NVDIMM_FAMILY_INTEL,
+ .nd_size_in = ND_INTEL_PASSPHRASE_SIZE,
+ .nd_size_out = ND_INTEL_STATUS_SIZE,
+ .nd_fw_size = ND_INTEL_STATUS_SIZE,
+ },
+ .cmd = {
+ .status = 0,
+ },
+ };
+
+ if (!test_bit(NVDIMM_INTEL_SECURE_ERASE, &nfit_mem->dsm_mask))
+ return -ENOTTY;
+
+ /* flush all cache before we erase DIMM */
+ wbinvd_on_all_cpus();
+ memcpy(nd_cmd.cmd.passphrase, nkey->data,
+ sizeof(nd_cmd.cmd.passphrase));
+ rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_CALL, &nd_cmd,
+ sizeof(nd_cmd), &cmd_rc);
+ if (rc < 0)
+ goto out;
+ if (cmd_rc < 0) {
+ rc = cmd_rc;
+ goto out;
+ }
+
+ switch (nd_cmd.cmd.status) {
+ case 0:
+ break;
+ case ND_INTEL_STATUS_INVALID_PASS:
+ rc = -EINVAL;
+ goto out;
+ case ND_INTEL_STATUS_INVALID_STATE:
+ default:
+ rc = -ENXIO;
+ goto out;
+ }
+
+ /* DIMM erased, invalidate all CPU caches before we read it */
+ wbinvd_on_all_cpus();
+
+ out:
+ return rc;
+}
+
static int intel_dimm_security_freeze_lock(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm)
{
@@ -321,4 +378,5 @@ const struct nvdimm_security_ops intel_security_ops = {
.change_key = intel_dimm_security_update_passphrase,
.disable = intel_dimm_security_disable,
.freeze_lock = intel_dimm_security_freeze_lock,
+ .erase = intel_dimm_security_erase,
};
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 8f4ea4e2c2ab..e6d04ca44008 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -97,6 +97,53 @@ int nvdimm_security_get_state(struct device *dev)
&nvdimm->state);
}
+static int nvdimm_security_erase(struct device *dev)
+{
+ struct nvdimm *nvdimm = to_nvdimm(dev);
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ struct key *key;
+ struct user_key_payload *payload;
+ int rc = 0;
+
+ if (!nvdimm->security_ops)
+ return 0;
+
+ /* lock the device and disallow driver bind */
+ device_lock(dev);
+ /* No driver data means dimm is disabled. Proceed if so. */
+ if (dev_get_drvdata(dev)) {
+ dev_warn(dev, "Unable to secure erase while DIMM active.\n");
+ rc = -EINVAL;
+ goto out;
+ }
+
+ if (nvdimm->state == NVDIMM_SECURITY_UNSUPPORTED)
+ goto out;
+
+ key = nvdimm_search_key(dev);
+ if (!key) {
+ dev_warn(dev, "no key found\n");
+ rc = -ENOKEY;
+ goto out;
+ }
+
+ down_read(&key->sem);
+ payload = key->payload.data[0];
+ rc = nvdimm->security_ops->erase(nvdimm_bus, nvdimm,
+ (void *)payload->data);
+ up_read(&key->sem);
+ /* remove key since secure erase kills the passphrase */
+ key_unlink(nvdimm_keyring, key);
+ key_invalidate(key);
+ nvdimm->key_id = 0;
+ key_put(key);
+
+ out:
+ device_unlock(dev);
+ nvdimm_security_get_state(dev);
+ return rc;
+}
+
static int nvdimm_security_freeze_lock(struct device *dev)
{
struct nvdimm *nvdimm = to_nvdimm(dev);
@@ -687,6 +734,8 @@ static ssize_t security_store(struct device *dev,
rc = nvdimm_security_disable(dev);
else if (sysfs_streq(buf, "freeze"))
rc = nvdimm_security_freeze_lock(dev);
+ else if (sysfs_streq(buf, "erase"))
+ rc = nvdimm_security_erase(dev);
else
return -EINVAL;
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index bcab42caa948..0d85e092a6dd 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -187,6 +187,9 @@ struct nvdimm_security_ops {
const struct nvdimm_key_data *nkey);
int (*freeze_lock)(struct nvdimm_bus *nvdimm_bus,
struct nvdimm *nvdimm);
+ int (*erase)(struct nvdimm_bus *nvdimm_bus,
+ struct nvdimm *nvdimm,
+ const struct nvdimm_key_data *nkey);
};
void badrange_init(struct badrange *badrange);
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 09/11] nfit_test: add context to dimm_dev for nfit_test
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (7 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 08/11] nfit/libnvdimm: add support for issue secure erase DSM " Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 10/11] nfit_test: add test support for Intel nvdimm security DSMs Dave Jiang
` (3 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
In order to access the nfit_test context via sideband sysfs knobs, the
dimm_dev needs to be more than struct device in order to point back to
struct nfit_test. Wrapping the original struct device with a struct
nfit_dimm_dev and saving the nfit_test as private driver data. Also
changing the nfit_mem to be a member of struct nfit_dimm_dev instead of
saving as private driver data of that device. This is in preparation for
adding security DSM support and allowing the locking of DIMMs for testing
via sideband.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
tools/testing/nvdimm/test/nfit.c | 41 +++++++++++++++++++++++++-------------
1 file changed, 27 insertions(+), 14 deletions(-)
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 18157b0c0d0d..7b3ce2194889 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -150,6 +150,11 @@ struct nfit_test_fw {
u64 end_time;
};
+struct nfit_dimm_dev {
+ struct device dev;
+ struct nfit_mem *nfit_mem;
+};
+
struct nfit_test {
struct acpi_nfit_desc acpi_desc;
struct platform_device pdev;
@@ -181,7 +186,7 @@ struct nfit_test {
unsigned long deadline;
spinlock_t lock;
} ars_state;
- struct device *dimm_dev[NUM_DCR];
+ struct nfit_dimm_dev dimm_dev[NUM_DCR];
struct nd_intel_smart *smart;
struct nd_intel_smart_threshold *smart_threshold;
struct badrange badrange;
@@ -981,7 +986,8 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
&t->smart_threshold[i -
t->dcr_idx],
&t->smart[i - t->dcr_idx],
- &t->pdev.dev, t->dimm_dev[i]);
+ &t->pdev.dev,
+ &t->dimm_dev[i].dev);
break;
case ND_INTEL_SMART_INJECT:
rc = nfit_test_cmd_smart_inject(buf,
@@ -989,7 +995,8 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
&t->smart_threshold[i -
t->dcr_idx],
&t->smart[i - t->dcr_idx],
- &t->pdev.dev, t->dimm_dev[i]);
+ &t->pdev.dev,
+ &t->dimm_dev[i].dev);
break;
default:
return -ENOTTY;
@@ -1187,8 +1194,7 @@ static void put_dimms(void *data)
int i;
for (i = 0; i < t->num_dcr; i++)
- if (t->dimm_dev[i])
- device_unregister(t->dimm_dev[i]);
+ device_unregister(&t->dimm_dev[i].dev);
}
static struct class *nfit_test_dimm;
@@ -1290,19 +1296,27 @@ static const struct attribute_group *nfit_test_dimm_attribute_groups[] = {
NULL,
};
+static void dimm_dev_release(struct device *dev)
+{
+}
+
static int nfit_test_dimm_init(struct nfit_test *t)
{
- int i;
+ int i, rc;
if (devm_add_action_or_reset(&t->pdev.dev, put_dimms, t))
return -ENOMEM;
for (i = 0; i < t->num_dcr; i++) {
- t->dimm_dev[i] = device_create_with_groups(nfit_test_dimm,
- &t->pdev.dev, 0, NULL,
- nfit_test_dimm_attribute_groups,
- "test_dimm%d", i + t->dcr_idx);
- if (!t->dimm_dev[i])
- return -ENOMEM;
+ t->dimm_dev[i].dev.parent = &t->pdev.dev;
+ dev_set_name(&t->dimm_dev[i].dev, "test_dimm%d",
+ i + t->dcr_idx);
+ t->dimm_dev[i].dev.class = nfit_test_dimm;
+ t->dimm_dev[i].dev.groups = nfit_test_dimm_attribute_groups;
+ t->dimm_dev[i].dev.release = dimm_dev_release;
+ rc = device_register(&t->dimm_dev[i].dev);
+ if (rc < 0)
+ return rc;
+ dev_set_drvdata(&t->dimm_dev[i].dev, t);
}
return 0;
}
@@ -2665,8 +2679,7 @@ static int nfit_test_probe(struct platform_device *pdev)
for (i = 0; i < NUM_DCR; i++)
if (nfit_handle == handle[i])
- dev_set_drvdata(nfit_test->dimm_dev[i],
- nfit_mem);
+ nfit_test->dimm_dev[i].nfit_mem = nfit_mem;
}
mutex_unlock(&acpi_desc->init_mutex);
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 10/11] nfit_test: add test support for Intel nvdimm security DSMs
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (8 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 09/11] nfit_test: add context to dimm_dev for nfit_test Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-07-25 20:59 ` [PATCH v6 11/11] libnvdimm: add documentation for nvdimm security support Dave Jiang
` (2 subsequent siblings)
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add nfit_test support for DSM functions "Get Security State",
"Set Passphrase", "Disable Passphrase", "Unlock Unit", "Freeze Lock",
and "Secure Erase" for the fake DIMMs.
Also adding a sysfs knob in order to put the DIMMs in "locked" state. The
order of testing DIMM unlocking would be.
1a. Disable DIMM X.
1b. Set Passphrase to DIMM X.
2. Write to
/sys/devices/platform/nfit_test.0/nfit_test_dimm/test_dimmX/lock_dimm
3. Renable DIMM X
4. Check DIMM X state via sysfs "security" attribute for nmemX.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Dan Williams <dan.j.williams@intel.com>
---
tools/testing/nvdimm/Kbuild | 1
tools/testing/nvdimm/test/nfit.c | 186 ++++++++++++++++++++++++++++++++++++++
2 files changed, 187 insertions(+)
diff --git a/tools/testing/nvdimm/Kbuild b/tools/testing/nvdimm/Kbuild
index 0392153a0009..a13670d3b389 100644
--- a/tools/testing/nvdimm/Kbuild
+++ b/tools/testing/nvdimm/Kbuild
@@ -36,6 +36,7 @@ obj-$(CONFIG_DEV_DAX) += device_dax.o
obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o
nfit-y := $(ACPI_SRC)/core.o
+nfit-$(CONFIG_X86) += $(ACPI_SRC)/intel.o
nfit-$(CONFIG_X86_MCE) += $(ACPI_SRC)/mce.o
nfit-y += acpi_nfit_test.o
nfit-y += config_check.o
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 7b3ce2194889..e5b62396c41f 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -24,6 +24,7 @@
#include <linux/list.h>
#include <linux/slab.h>
#include <nd-core.h>
+#include <intel.h>
#include <nfit.h>
#include <nd.h>
#include "nfit_test.h"
@@ -155,6 +156,11 @@ struct nfit_dimm_dev {
struct nfit_mem *nfit_mem;
};
+struct nfit_test_sec {
+ u8 state;
+ u8 passphrase[32];
+};
+
struct nfit_test {
struct acpi_nfit_desc acpi_desc;
struct platform_device pdev;
@@ -192,6 +198,7 @@ struct nfit_test {
struct badrange badrange;
struct work_struct work;
struct nfit_test_fw *fw;
+ struct nfit_test_sec *sec;
};
static struct workqueue_struct *nfit_wq;
@@ -899,6 +906,138 @@ static int override_return_code(int dimm, unsigned int func, int rc)
return rc;
}
+static int nd_intel_test_cmd_security_status(struct nfit_test *t,
+ struct nd_intel_get_security_state *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ nd_cmd->status = 0;
+ nd_cmd->state = sec->state;
+ dev_dbg(dev, "security state (%#x) returned\n", nd_cmd->state);
+
+ return 0;
+}
+
+static int nd_intel_test_cmd_unlock_unit(struct nfit_test *t,
+ struct nd_intel_unlock_unit *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ if (!(sec->state & ND_INTEL_SEC_STATE_LOCKED) ||
+ (sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
+ dev_dbg(dev, "unlock unit: invalid state: %#x\n",
+ sec->state);
+ } else if (memcmp(nd_cmd->passphrase, sec->passphrase,
+ ND_INTEL_PASSPHRASE_SIZE) != 0) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
+ dev_dbg(dev, "unlock unit: invalid passphrase\n");
+ } else {
+ nd_cmd->status = 0;
+ sec->state = ND_INTEL_SEC_STATE_ENABLED;
+ dev_dbg(dev, "Unit unlocked\n");
+ }
+
+ dev_dbg(dev, "unlocking status returned: %#x\n", nd_cmd->status);
+ return 0;
+}
+
+static int nd_intel_test_cmd_set_pass(struct nfit_test *t,
+ struct nd_intel_set_passphrase *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ if (sec->state & ND_INTEL_SEC_STATE_FROZEN) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
+ dev_dbg(dev, "set passphrase: wrong security state\n");
+ } else if (memcmp(nd_cmd->old_pass, sec->passphrase,
+ ND_INTEL_PASSPHRASE_SIZE) != 0) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
+ dev_dbg(dev, "set passphrase: wrong passphrase\n");
+ } else {
+ memcpy(sec->passphrase, nd_cmd->new_pass,
+ ND_INTEL_PASSPHRASE_SIZE);
+ sec->state |= ND_INTEL_SEC_STATE_ENABLED;
+ nd_cmd->status = 0;
+ dev_dbg(dev, "passphrase updated\n");
+ }
+
+ return 0;
+}
+
+static int nd_intel_test_cmd_freeze_lock(struct nfit_test *t,
+ struct nd_intel_freeze_lock *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED)) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
+ dev_dbg(dev, "freeze lock: wrong security state\n");
+ } else {
+ sec->state |= ND_INTEL_SEC_STATE_FROZEN;
+ nd_cmd->status = 0;
+ dev_dbg(dev, "security frozen\n");
+ }
+
+ return 0;
+}
+
+static int nd_intel_test_cmd_disable_pass(struct nfit_test *t,
+ struct nd_intel_disable_passphrase *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) ||
+ (sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
+ dev_dbg(dev, "disable passphrase: wrong security state\n");
+ } else if (memcmp(nd_cmd->passphrase, sec->passphrase,
+ ND_INTEL_PASSPHRASE_SIZE) != 0) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
+ dev_dbg(dev, "disable passphrase: wrong passphrase\n");
+ } else {
+ memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
+ sec->state = 0;
+ dev_dbg(dev, "disable passphrase: done\n");
+ }
+
+ return 0;
+}
+
+static int nd_intel_test_cmd_secure_erase(struct nfit_test *t,
+ struct nd_intel_secure_erase *nd_cmd,
+ unsigned int buf_len, int idx)
+{
+ struct device *dev = &t->pdev.dev;
+ struct nfit_test_sec *sec = &t->sec[idx];
+
+ if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) ||
+ (sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
+ dev_dbg(dev, "secure erase: wrong security state\n");
+ } else if (memcmp(nd_cmd->passphrase, sec->passphrase,
+ ND_INTEL_PASSPHRASE_SIZE) != 0) {
+ nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
+ dev_dbg(dev, "secure erase: wrong passphrase\n");
+ } else {
+ memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
+ sec->state = 0;
+ dev_dbg(dev, "secure erase: done\n");
+ }
+
+ return 0;
+}
+
static int get_dimm(struct nfit_mem *nfit_mem, unsigned int func)
{
int i;
@@ -946,6 +1085,30 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
return i;
switch (func) {
+ case NVDIMM_INTEL_GET_SECURITY_STATE:
+ rc = nd_intel_test_cmd_security_status(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
+ case NVDIMM_INTEL_UNLOCK_UNIT:
+ rc = nd_intel_test_cmd_unlock_unit(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
+ case NVDIMM_INTEL_SET_PASSPHRASE:
+ rc = nd_intel_test_cmd_set_pass(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
+ case NVDIMM_INTEL_DISABLE_PASSPHRASE:
+ rc = nd_intel_test_cmd_disable_pass(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
+ case NVDIMM_INTEL_FREEZE_LOCK:
+ rc = nd_intel_test_cmd_freeze_lock(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
+ case NVDIMM_INTEL_SECURE_ERASE:
+ rc = nd_intel_test_cmd_secure_erase(t,
+ buf, buf_len, i - t->dcr_idx);
+ break;
case ND_INTEL_ENABLE_LSS_STATUS:
rc = nd_intel_test_cmd_set_lss_status(t,
buf, buf_len);
@@ -1280,10 +1443,23 @@ static ssize_t fail_cmd_code_store(struct device *dev, struct device_attribute *
}
static DEVICE_ATTR_RW(fail_cmd_code);
+static ssize_t lock_dimm_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ int dimm = dimm_name_to_id(dev);
+ struct nfit_test *t = dev_get_drvdata(dev);
+ struct nfit_test_sec *sec = &t->sec[dimm];
+
+ sec->state = ND_INTEL_SEC_STATE_ENABLED | ND_INTEL_SEC_STATE_LOCKED;
+ return size;
+}
+static DEVICE_ATTR_WO(lock_dimm);
+
static struct attribute *nfit_test_dimm_attributes[] = {
&dev_attr_fail_cmd.attr,
&dev_attr_fail_cmd_code.attr,
&dev_attr_handle.attr,
+ &dev_attr_lock_dimm.attr,
NULL,
};
@@ -2192,6 +2368,14 @@ static void nfit_test0_setup(struct nfit_test *t)
set_bit(ND_INTEL_FW_FINISH_UPDATE, &acpi_desc->dimm_cmd_force_en);
set_bit(ND_INTEL_FW_FINISH_QUERY, &acpi_desc->dimm_cmd_force_en);
set_bit(ND_INTEL_ENABLE_LSS_STATUS, &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_GET_SECURITY_STATE,
+ &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_SET_PASSPHRASE, &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_DISABLE_PASSPHRASE,
+ &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_UNLOCK_UNIT, &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_FREEZE_LOCK, &acpi_desc->dimm_cmd_force_en);
+ set_bit(NVDIMM_INTEL_SECURE_ERASE, &acpi_desc->dimm_cmd_force_en);
}
static void nfit_test1_setup(struct nfit_test *t)
@@ -2611,6 +2795,8 @@ static int nfit_test_probe(struct platform_device *pdev)
GFP_KERNEL);
nfit_test->fw = devm_kcalloc(dev, num,
sizeof(struct nfit_test_fw), GFP_KERNEL);
+ nfit_test->sec = devm_kcalloc(dev, num,
+ sizeof(struct nfit_test_sec), GFP_KERNEL);
if (nfit_test->dimm && nfit_test->dimm_dma && nfit_test->label
&& nfit_test->label_dma && nfit_test->dcr
&& nfit_test->dcr_dma && nfit_test->flush
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v6 11/11] libnvdimm: add documentation for nvdimm security support
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (9 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 10/11] nfit_test: add test support for Intel nvdimm security DSMs Dave Jiang
@ 2018-07-25 20:59 ` Dave Jiang
2018-08-02 11:58 ` [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs David Howells
2018-08-02 12:00 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms David Howells
12 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-07-25 20:59 UTC (permalink / raw)
To: linux-nvdimm; +Cc: alison.schofield, keescook, ebiggers3, dhowells, keyrings
Add theory of operation for the security support that's going into
libnvdimm.
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
---
Documentation/nvdimm/security | 70 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 70 insertions(+)
create mode 100644 Documentation/nvdimm/security
diff --git a/Documentation/nvdimm/security b/Documentation/nvdimm/security
new file mode 100644
index 000000000000..b776ef1f5e41
--- /dev/null
+++ b/Documentation/nvdimm/security
@@ -0,0 +1,70 @@
+NVDIMM SECURITY
+===============
+
+1. Introduction
+---------------
+
+With the introduction of Intel DSM v1.7 specification [1], security DSMs are
+introduced. The spec added the following security DSMs: "get security state",
+"set passphrase", "disable passphrase", "unlock unit", "freeze lock",
+"secure erase", and "overwrite". A security_ops data structure has been
+added to struct dimm in order to support the security operations and generic
+APIs are exposed to allow vendor neutral operations.
+
+2. Sysfs Interface
+------------------
+The "security" sysfs attribute is provided in the nvdimm sysfs directory. For
+example:
+/sys/devices/LNXSYSTM:00/LNXSYBUS:00/ACPI0012:00/ndbus0/nmem0/security
+
+The "show" function of that attribute will display the security state for
+that DIMM. The following states are available: disabled, unlocked, locked,
+frozen, and unsupported.
+
+The "store" function takes several commands when the attribute is written to
+in order to support some of the security functionalities:
+update - enable security. Add or update current key.
+disable - disable enabled security and remove key.
+freeze - freeze changing of security states.
+erase - generate new ecryption key for DIMM and crypto-scrambles all existing
+ user data.
+
+3. Key Management
+-----------------
+
+The key is associted to the payload by the DIMM id. For example:
+# cat /sys/devices/LNXSYSTM:00/LNXSYBUS:00/ACPI0012:00/ndbus0/nmem0/nfit/id
+8089-a2-1740-00000133
+The DIMM id would be provided along with the key payload (passphrase) to
+the kernel.
+
+The security keys are managed on the basis of a single key per DIMM. The
+key "passphrase" is expected to be 32bytes long or padded to 32bytes. This is
+similar to the ATA security specification [2]. A key is initially acquired
+via the request_key() kernel API call and retrieved from userspace. It is up to
+the user to provide an upcall application to retrieve the key in whatever
+fashion meets their security requirements.
+
+The payload provided to the key can be a 32bytes payload or 64bytes payload
+when doing an "update". The payload is viewed as 64 bytes in the following
+format:
+[32 bytes new key data zero padded][32 bytes current key data zero padded]
+However, a 32bytes payload can be provided and will be assumed as the old
+key to be 32 bytes of 0s and the provided 32bytes payload is the new key.
+It is up to the user upcall function how that's presented as the key payload
+to the kernel.
+
+All the other security functions that require a provided key can accept a
+32bytes payload or 64bytes. If the payload is 64bytes, then second 32bytes
+will be ignored and the first 32bytes contains the expected "passphrase".
+
+4. Unlocking
+------------
+When the DIMMs are being enumerated by the kernel, the kernel will attempt to
+retrieve the key from its keyring. If that fails, it will attempt to
+acquire the key from the userspace upcall function. This is the only time
+a locked DIMM can be unlocked. Once unlocked, the DIMM will remain unlocked
+until reboot.
+
+[1]: http://pmem.io/documents/NVDIMM_DSM_Interface-V1.7.pdf
+[2]: http://www.t13.org/documents/UploadedDocuments/docs2006/e05179r4-ACS-SecurityClarifications.pdf
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (10 preceding siblings ...)
2018-07-25 20:59 ` [PATCH v6 11/11] libnvdimm: add documentation for nvdimm security support Dave Jiang
@ 2018-08-02 11:58 ` David Howells
2018-08-02 12:00 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms David Howells
12 siblings, 0 replies; 21+ messages in thread
From: David Howells @ 2018-08-02 11:58 UTC (permalink / raw)
To: Dave Jiang
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
Dave Jiang <dave.jiang@intel.com> wrote:
> + key = key_lookup(nvdimm->key_id);
You should not be using key_lookup() as the key ID doesn't pin a reference to
the key you're using. If you're going to cache a key, either cache the key
pointer directly and check it with key_validate() before you use it or keep
the cache in a private kernel keyring and use key_search() each time you want
to use it. The latter method allows for the key to be garbage collected
automatically if it expires or gets invalidated.
You can still follow a negative call for a cached key with a call to
nvdimm_request_key(). In the private keyring-using case, you can link the key
to the private keyring after you got it.
> + payload = key->payload.data[0];
> + rc = nvdimm->security_ops->unlock(nvdimm_bus, nvdimm,
> + (void *)payload->data);
I would recommend casting to const void * if you can as you're not allowed to
change the payload data.
David
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-07-25 20:58 [PATCH v6 00/11] Adding security support for nvdimm Dave Jiang
` (11 preceding siblings ...)
2018-08-02 11:58 ` [PATCH v6 04/11] nfit/libnvdimm: add unlock of nvdimm support for Intel DIMMs David Howells
@ 2018-08-02 12:00 ` David Howells
2018-08-02 22:29 ` Dave Jiang
2018-08-03 8:28 ` David Howells
12 siblings, 2 replies; 21+ messages in thread
From: David Howells @ 2018-08-02 12:00 UTC (permalink / raw)
To: Dave Jiang
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
Dave Jiang <dave.jiang@intel.com> wrote:
> + /* request new key from userspace */
> + key = nvdimm_request_key(dev, update);
> + if (!key) {
> + dev_dbg(dev, "%s: failed to acquire new key\n", __func__);
> + rc = -ENXIO;
> + goto out;
> + }
I still think you're better taking two explicit key IDs as part of the command
rather than using request_key() to *hopefully* pick the right target.
David
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-08-02 12:00 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms David Howells
@ 2018-08-02 22:29 ` Dave Jiang
2018-08-03 0:28 ` Dave Jiang
2018-08-03 8:32 ` David Howells
2018-08-03 8:28 ` David Howells
1 sibling, 2 replies; 21+ messages in thread
From: Dave Jiang @ 2018-08-02 22:29 UTC (permalink / raw)
To: David Howells
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, keyrings
On 08/02/2018 05:00 AM, David Howells wrote:
> Dave Jiang <dave.jiang@intel.com> wrote:
>
>> + /* request new key from userspace */
>> + key = nvdimm_request_key(dev, update);
>> + if (!key) {
>> + dev_dbg(dev, "%s: failed to acquire new key\n", __func__);
>> + rc = -ENXIO;
>> + goto out;
>> + }
>
> I still think you're better taking two explicit key IDs as part of the command
> rather than using request_key() to *hopefully* pick the right target.
In order to do this, I would need to do a key_add() in userspace to add
a new key with the new payload before I can initiate update correct? So
for an update it would look something like:
1. (user) add key with new payload
2. (user) lookup old key
3. (user) write to sysfs update attrib: "update:<old id>:<new id>"
4. (kernel) check old_id against cached key and make sure they match
5. (kernel) check new key desc against old key and make sure they match
6. (kernel) update to hardware
6. (kernel) when success, link the new key to the kernel keyring and
it'll replace the old key?
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-08-02 22:29 ` Dave Jiang
@ 2018-08-03 0:28 ` Dave Jiang
2018-08-03 8:32 ` David Howells
1 sibling, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-08-03 0:28 UTC (permalink / raw)
To: David Howells
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, keyrings
On 08/02/2018 03:29 PM, Dave Jiang wrote:
>
>
> On 08/02/2018 05:00 AM, David Howells wrote:
>> Dave Jiang <dave.jiang@intel.com> wrote:
>>
>>> + /* request new key from userspace */
>>> + key = nvdimm_request_key(dev, update);
>>> + if (!key) {
>>> + dev_dbg(dev, "%s: failed to acquire new key\n", __func__);
>>> + rc = -ENXIO;
>>> + goto out;
>>> + }
>>
>> I still think you're better taking two explicit key IDs as part of the command
>> rather than using request_key() to *hopefully* pick the right target.
>
> In order to do this, I would need to do a key_add() in userspace to add
> a new key with the new payload before I can initiate update correct? So
> for an update it would look something like:
> 1. (user) add key with new payload
> 2. (user) lookup old key
> 3. (user) write to sysfs update attrib: "update:<old id>:<new id>"
> 4. (kernel) check old_id against cached key and make sure they match
> 5. (kernel) check new key desc against old key and make sure they match
> 6. (kernel) update to hardware
> 6. (kernel) when success, link the new key to the kernel keyring and
> it'll replace the old key?
I think I'm a little confused on what to do once I pass in the new key
id through update. How do I retrieve the new key in kernel that I added
from userspace and not use key_lookup()? request_key() or something
else? Wouldn't request_key come up with the old key since it has the
same description?
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-08-02 22:29 ` Dave Jiang
2018-08-03 0:28 ` Dave Jiang
@ 2018-08-03 8:32 ` David Howells
2018-08-03 16:07 ` Dave Jiang
1 sibling, 1 reply; 21+ messages in thread
From: David Howells @ 2018-08-03 8:32 UTC (permalink / raw)
To: Dave Jiang
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
Dave Jiang <dave.jiang@intel.com> wrote:
> I think I'm a little confused on what to do once I pass in the new key
> id through update. How do I retrieve the new key in kernel that I added
> from userspace and not use key_lookup()? request_key() or something
> else? Wouldn't request_key come up with the old key since it has the
> same description?
As I keep saying, you need to use lookup_user_key():
key = lookup_user_key(keyid, 0, KEY_NEED_SEARCH);
You need to add it to linux/key.h and export it.
David
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-08-03 8:32 ` David Howells
@ 2018-08-03 16:07 ` Dave Jiang
0 siblings, 0 replies; 21+ messages in thread
From: Dave Jiang @ 2018-08-03 16:07 UTC (permalink / raw)
To: David Howells
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, keyrings
On 08/03/2018 01:32 AM, David Howells wrote:
> Dave Jiang <dave.jiang@intel.com> wrote:
>
>> I think I'm a little confused on what to do once I pass in the new key
>> id through update. How do I retrieve the new key in kernel that I added
>> from userspace and not use key_lookup()? request_key() or something
>> else? Wouldn't request_key come up with the old key since it has the
>> same description?
>
> As I keep saying, you need to use lookup_user_key():
>
> key = lookup_user_key(keyid, 0, KEY_NEED_SEARCH);
>
> You need to add it to linux/key.h and export it.
Thanks! I got confused with key_user_lookup() and got stuck there.
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms
2018-08-02 12:00 ` [PATCH v6 05/11] nfit/libnvdimm: add set passphrase support for Intel nvdimms David Howells
2018-08-02 22:29 ` Dave Jiang
@ 2018-08-03 8:28 ` David Howells
1 sibling, 0 replies; 21+ messages in thread
From: David Howells @ 2018-08-03 8:28 UTC (permalink / raw)
To: Dave Jiang
Cc: alison.schofield, keescook, linux-nvdimm, ebiggers3, dhowells, keyrings
Dave Jiang <dave.jiang@intel.com> wrote:
> In order to do this, I would need to do a key_add() in userspace to add
Well, add_key().
> a new key with the new payload before I can initiate update correct? So
> for an update it would look something like:
> 1. (user) add key with new payload
> 2. (user) lookup old key
You don't technically need the old key - just a key with the old password in
it. It doesn't need to have any useful description since you're providing it
directly.
> 3. (user) write to sysfs update attrib: "update:<old id>:<new id>"
> 4. (kernel) check old_id against cached key and make sure they match
> 5. (kernel) check new key desc against old key and make sure they match
> 6. (kernel) update to hardware
> 6. (kernel) when success, link the new key to the kernel keyring and
> it'll replace the old key?
Yep - provided it has the same description. A keyring can only keep one key
of any {type, description} at any one time. Adding a second will displace the
first.
David
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 21+ messages in thread