While keys of differing type have a common struct key definition, there is
no common scheme to the payload and key material extraction differs.
For kernel functionality that supports different key types,
this means duplicated code for key material extraction and because key type
is discriminated by a pointer to a global, users need to replicate
reachability checks as well, so builtin code doesn't depend on a key
type symbol offered by a module.
Make this easier by adding a common helper with initial support for
user, logon, encrypted and trusted keys. The code is taken from
dm-crypt, which is migrated to use the helper in a later commit.
The implementation must be partially in a header to support configurations
where the key type symbol is defined in a module, but key support in general
is built-in.
Signed-off-by: Ahmad Fatoum <a.fatoum@xxxxxxxxxxxxxx>
---
I am not sure whether the chosen header and source file are the best
places for this. This could be made header-only too if that's preferred.
To: David Howells <dhowells@xxxxxxxxxx>
To: Jarkko Sakkinen <jarkko@xxxxxxxxxx>
To: James Morris <jmorris@xxxxxxxxx>
To: "Serge E. Hallyn" <serge@xxxxxxxxxx>
To: Alasdair Kergon <agk@xxxxxxxxxx>
To: Mike Snitzer <snitzer@xxxxxxxxxx>
To: dm-devel@xxxxxxxxxx
To: Song Liu <song@xxxxxxxxxx>
To: Richard Weinberger <richard@xxxxxx>
Cc: linux-kernel@xxxxxxxxxxxxxxx
Cc: linux-raid@xxxxxxxxxxxxxxx
Cc: keyrings@xxxxxxxxxxxxxxx
Cc: linux-mtd@xxxxxxxxxxxxxxxxxxx
Cc: linux-security-module@xxxxxxxxxxxxxxx
Cc: linux-integrity@xxxxxxxxxxxxxxx
---
include/linux/key.h | 45 +++++++++++++++++++++++++++++++++++++++++++++
security/keys/key.c | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 85 insertions(+)
diff --git a/include/linux/key.h b/include/linux/key.h
index 7febc4881363..916612f5b313 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -20,6 +20,8 @@
#include <linux/assoc_array.h>
#include <linux/refcount.h>
#include <linux/time64.h>
+#include <linux/err.h>
+#include <linux/kconfig.h>
#ifdef __KERNEL__
#include <linux/uidgid.h>
@@ -487,6 +489,48 @@ extern void key_fsuid_changed(struct cred *new_cred);
extern void key_fsgid_changed(struct cred *new_cred);
extern void key_init(void);
+/*
+ * internal use, so key core code need not link against
+ * all supported key types
+ * */
+enum __key_type {
+ KEY_TYPE_UNKNOWN, KEY_TYPE_USER, KEY_TYPE_ENCRYPTED, KEY_TYPE_TRUSTED
+};
+
+const void *__key_extract_material(const struct key *key, enum __key_type type,
+ unsigned int *len);
+
+/**
+ * key_extract_material - Extract decrypted data out of a key
+ * @key: a logon, user, encrypted or trusted key
+ * @len: pointer to variable to store key size into
+ *
+ * Extract decrypted data out of supported key types
+ *
+ * Returns a pointer to the key material if successfull or an error
+ * pointer if key type is not compiled in, the buffer is too
+ * small or the key was revoked.
+ */
+static inline const void *key_extract_material(const struct key *key,
+ unsigned int *len)
+{
+ extern struct key_type key_type_user;
+ extern struct key_type key_type_logon;
+ extern struct key_type key_type_encrypted;
+ extern struct key_type key_type_trusted;
+ enum __key_type type = KEY_TYPE_UNKNOWN;
+ const struct key_type *t = key->type;
+
+ if (t == &key_type_logon || t == &key_type_user)
+ type = KEY_TYPE_USER;
+ else if (IS_REACHABLE(CONFIG_ENCRYPTED_KEYS) && t == &key_type_encrypted)
+ type = KEY_TYPE_ENCRYPTED;
+ else if (IS_REACHABLE(CONFIG_TRUSTED_KEYS) && t == &key_type_trusted)
+ type = KEY_TYPE_TRUSTED;
+
+ return __key_extract_material(key, type, len);
+}
+
#else /* CONFIG_KEYS */
#define key_validate(k) 0
@@ -504,6 +548,7 @@ extern void key_init(void);
#define key_init() do { } while(0)
#define key_free_user_ns(ns) do { } while(0)
#define key_remove_domain(d) do { } while(0)
+#define key_extract_material(k, l) ERR_PTR(-EINVAL)
#endif /* CONFIG_KEYS */
#endif /* __KERNEL__ */
diff --git a/security/keys/key.c b/security/keys/key.c
index c45afdd1dfbb..69cd1cb8c413 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -15,6 +15,9 @@
#include <linux/random.h>
#include <linux/ima.h>
#include <linux/err.h>
+#include <keys/user-type.h>
+#include <keys/encrypted-type.h>
+#include <keys/trusted-type.h>
#include "internal.h"
struct kmem_cache *key_jar;
@@ -1140,6 +1143,43 @@ int generic_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
}
EXPORT_SYMBOL(generic_key_instantiate);
+const void *__key_extract_material(const struct key *key,
+ enum __key_type type, unsigned int *len)
+{
+ const struct encrypted_key_payload *ekp;
+ const struct trusted_key_payload *tkp;
+ const struct user_key_payload *ukp;
+
+ switch (type) {
+ case KEY_TYPE_USER:
+ ukp = user_key_payload_locked(key);
+ if (!ukp)
+ break;
+
+ *len = ukp->datalen;
+ return ukp->data;
+ case KEY_TYPE_ENCRYPTED:
+ ekp = key->payload.data[0];
+ if (!ekp)
+ break;
+
+ *len = ekp->decrypted_datalen;
+ return ekp->decrypted_data;
+ case KEY_TYPE_TRUSTED:
+ tkp = key->payload.data[0];
+ if (!tkp)
+ break;
+
+ *len = tkp->key_len;
+ return tkp->key;
+ default:
+ return ERR_PTR(-EINVAL);
+ }
+
+ return ERR_PTR(-EKEYREVOKED);
+}
+EXPORT_SYMBOL(__key_extract_material);
+
/**
* register_key_type - Register a type of key.
* @ktype: The new key type.
--
git-series 0.9.1
