Skip to contentSkip to conversation

crypto user configuration api

PATCH Superseded Steffen Klassert 2 participants 25 messages Aug 11, 2011 – Sep 21, 2011

Subsystems (2)

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

cover crypto user configuration api

This patchset adds a netlink based user configuration API for the crypto layer, similar to the configuration API of xfrm.

The patchset is based on the current cryptodev-2.6 tree and also available at branch 'crypto-user-config-api' of

git://git.kernel.org/pub/scm/linux/kernel/git/klassert/linux-stk.git

A userspace tool that makes use of the configuration API is temporarily available at

http://www.kernel.org/pub/linux/kernel/people/klassert/crconf/

With this it is possible to instantiate certain algorithms by doing

crconf add driver "cbc(aes-generic)" type 4

or

crconf add driver "cbc(aes-generic)" type 4 priority 100

To remove a (form templates build and unused) algorithm with all subsequent algorithms do

crconf del driver "cbc(aes-generic)" type 4

It is possible to update the priority of an algorithm by doing

crconf update driver "cbc(aes-generic)" type 4 priority 200

this updates the priority of this and all subsequent algorithms.

Finally it is possible to print the instantiated crypto algorithms similar to /proc/crypto by doing

crconf show all

This prints the algorithm informations of all instantiated algorithms as long as the information fits into a netlink message.

Steffen

#1 lore raw

PATCH 1/16 crypto: authenc - Don't multiply priorities

Most crypto algorithms simply take the priority value of the underlying algorithm and add some value to calculate the algorithms priority. The only exeptions are the authenc algorithms. We change the authenc algorithms to calculate their priority to the sum of the underlying algorithms plus 100. With this we can keep the priority consistent if one of the underlying algorithms changes the priority.

---
 crypto/authenc.c    |    4 ++--
 crypto/authencesn.c |    4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)
crypto/authenc.c +2 -2
index 5ef7ba6..59349e4 100644
@@ -644,8 +644,8 @@ static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb)
 
 	inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD;
 	inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC;
-	inst->alg.cra_priority = enc->cra_priority *
-				 10 + auth_base->cra_priority;
+	inst->alg.cra_priority = enc->cra_priority +
+				 auth_base->cra_priority + 100;
 	inst->alg.cra_blocksize = enc->cra_blocksize;
 	inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask;
 	inst->alg.cra_type = &crypto_aead_type;
crypto/authencesn.c +2 -2
index 136b68b..de82829 100644
@@ -767,8 +767,8 @@ static struct crypto_instance *crypto_authenc_esn_alloc(struct rtattr **tb)
 
 	inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD;
 	inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC;
-	inst->alg.cra_priority = enc->cra_priority *
-				 10 + auth_base->cra_priority;
+	inst->alg.cra_priority = enc->cra_priority +
+				 auth_base->cra_priority + 100;
 	inst->alg.cra_blocksize = enc->cra_blocksize;
 	inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask;
 	inst->alg.cra_type = &crypto_aead_type;
Signature · 1 line
1.7.0.4
#10 lore raw

PATCH 2/16 crypto: Add a flag to identify crypto instances

In reply to Steffen Klassert

The upcomming crypto user configuration api needs to identify crypto instances. This patch adds a flag that is set if the algorithm is an instance that is build from templates.

---
 crypto/algapi.c        |    1 +
 include/linux/crypto.h |    5 +++++
 2 files changed, 6 insertions(+), 0 deletions(-)
crypto/algapi.c +1 -0
index c3cf1a6..6fd9bcf 100644
@@ -493,6 +493,7 @@ int crypto_register_instance(struct crypto_template *tmpl,
 		goto err;
 
 	inst->alg.cra_module = tmpl->module;
+	inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;
 
 	down_write(&crypto_alg_sem);
 
include/linux/crypto.h +5 -0
index e5e468e..cba4d63 100644
@@ -72,6 +72,11 @@
 #define CRYPTO_ALG_TESTED		0x00000400
 
 /*
+ * Set if the algorithm is an instance that is build from telplates.
+ */
+#define CRYPTO_ALG_INSTANCE		0x00000800
+
+/*
  * Transform masks and values (for crt_flags).
  */
 #define CRYPTO_TFM_REQ_MASK		0x000fff00
Signature · 1 line
1.7.0.4
#11 lore raw

PATCH 3/16 crypto: Add userspace configuration API

In reply to Steffen Klassert

This patch adds a basic userspace configuration API for the crypto layer. With this it is possible to instantiate, update, remove and to show crypto algorithms from userspace.

---
 crypto/Kconfig             |    7 +
 crypto/Makefile            |    1 +
 crypto/crypto_user.c       |  497 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/cryptouser.h |   58 +++++
 include/linux/netlink.h    |    1 +
 5 files changed, 564 insertions(+), 0 deletions(-)
 create mode 100644 crypto/crypto_user.c
 create mode 100644 include/linux/cryptouser.h
crypto/Kconfig +7 -0
index 55c50cd..c05d0df 100644
@@ -100,6 +100,13 @@ config CRYPTO_MANAGER2
 	select CRYPTO_BLKCIPHER2
 	select CRYPTO_PCOMP2
 
+config CRYPTO_USER
+	tristate "Userspace cryptographic algorithm configuration"
+	select CRYPTO_MANAGER
+	help
+	  Userapace configuration for cryptographic instantiations such as
+	  cbc(aes).
+
 config CRYPTO_MANAGER_DISABLE_TESTS
 	bool "Disable run-time self tests"
 	default y
crypto/Makefile +1 -0
index ce5a813..4c4171b 100644
@@ -31,6 +31,7 @@ obj-$(CONFIG_CRYPTO_PCOMP2) += pcompress.o
 cryptomgr-y := algboss.o testmgr.o
 
 obj-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o
+obj-$(CONFIG_CRYPTO_USER) += crypto_user.o
 obj-$(CONFIG_CRYPTO_HMAC) += hmac.o
 obj-$(CONFIG_CRYPTO_VMAC) += vmac.o
 obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o
crypto/crypto_user.c new file +497 -0

497 lines not on this page · raw message

include/linux/cryptouser.h new file +58 -0

58 lines not on this page · raw message

include/linux/netlink.h +1 -0
index 2e17c5d..464ace0 100644
@@ -25,6 +25,7 @@
 #define NETLINK_SCSITRANSPORT	18	/* SCSI Transports */
 #define NETLINK_ECRYPTFS	19
 #define NETLINK_RDMA		20
+#define NETLINK_CRYPTO		21	/* Crypto layer */
 
 #define MAX_LINKS 32		
 
Signature · 1 line
1.7.0.4
#12 lore raw

PATCH 4/16 crypto: Add a report function pointer to crypto_type

In reply to Steffen Klassert

We add a report function pointer to struct crypto_type. This function pointer is used from the crypto userspace configuration API to report crypto algorithms to userspace.

---
 crypto/crypto_user.c    |    8 ++++++++
 include/crypto/algapi.h |    2 ++
 2 files changed, 10 insertions(+), 0 deletions(-)
crypto/crypto_user.c +8 -0
index c288ada..49f302a 100644
@@ -88,7 +88,15 @@ static int crypto_report_one(struct crypto_alg *alg,
 	rb->priority = alg->cra_priority;
 	rb->refcnt = atomic_read(&alg->cra_refcnt);
 
+	if (alg->cra_type && alg->cra_type->report) {
+		if (alg->cra_type->report(skb, alg))
+			goto nla_put_failure;
+	}
+
 	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
 }
 
 static int crypto_report_alg(struct crypto_alg *alg,
include/crypto/algapi.h +2 -0
index 59c3e5b..ecc721d 100644
@@ -15,6 +15,7 @@
 #include <linux/crypto.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
+#include <linux/skbuff.h>
 
 struct module;
 struct rtattr;
@@ -26,6 +27,7 @@ struct crypto_type {
 	int (*init)(struct crypto_tfm *tfm, u32 type, u32 mask);
 	int (*init_tfm)(struct crypto_tfm *tfm);
 	void (*show)(struct seq_file *m, struct crypto_alg *alg);
+	int (*report)(struct sk_buff *skb, struct crypto_alg *alg);
 	struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask);
 
 	unsigned int type;
Signature · 1 line
1.7.0.4
#13 lore raw

PATCH 5/16 crypto: Add userspace report for larval type algorithms

In reply to Steffen Klassert
---
 crypto/crypto_user.c       |   13 +++++++++++++
 include/linux/cryptouser.h |    6 ++++++
 2 files changed, 19 insertions(+), 0 deletions(-)
crypto/crypto_user.c +13 -0
index 49f302a..fa68965 100644
@@ -88,11 +88,24 @@ static int crypto_report_one(struct crypto_alg *alg,
 	rb->priority = alg->cra_priority;
 	rb->refcnt = atomic_read(&alg->cra_refcnt);
 
+	if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
+		struct crypto_report_larval rl;
+
+		snprintf(rl.type, CRYPTO_MAX_ALG_NAME, "%s", "larval");
+		rl.flags = alg->cra_flags;
+
+		NLA_PUT(skb, CRYPTOCFGA_REPORT_LARVAL,
+			sizeof(struct crypto_report_larval), &rl);
+
+		goto out;
+	}
+
 	if (alg->cra_type && alg->cra_type->report) {
 		if (alg->cra_type->report(skb, alg))
 			goto nla_put_failure;
 	}
 
+out:
 	return 0;
 
 nla_put_failure:
include/linux/cryptouser.h +6 -0
index 056c451..d0766e3 100644
@@ -34,6 +34,7 @@ enum {
 enum crypto_attr_type_t {
 	CRYPTOCFGA_UNSPEC,
 	CRYPTOCFGA_PRIORITY_VAL,	/* __u32 */
+	CRYPTOCFGA_REPORT_LARVAL,	/* struct crypto_report_larval */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -56,3 +57,8 @@ struct crypto_report_base {
 	int priority;
 	int refcnt;
 };
+
+struct crypto_report_larval {
+	char type[CRYPTO_MAX_NAME];
+	__u32 flags;
+};
Signature · 1 line
1.7.0.4
#14 lore raw

PATCH 6/16 crypto: Add userspace report for shash type algorithms

In reply to Steffen Klassert
---
 crypto/shash.c             |   25 +++++++++++++++++++++++++
 include/linux/cryptouser.h |    7 +++++++
 2 files changed, 32 insertions(+), 0 deletions(-)
crypto/shash.c +25 -0
index 76f74b9..d27a134 100644
@@ -17,6 +17,8 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include "internal.h"
 
@@ -522,6 +524,26 @@ static unsigned int crypto_shash_extsize(struct crypto_alg *alg)
 	return alg->cra_ctxsize;
 }
 
+static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_shash rshash;
+	struct shash_alg *salg = __crypto_shash_alg(alg);
+
+	snprintf(rshash.type, CRYPTO_MAX_ALG_NAME, "%s", "shash");
+	rshash.blocksize = alg->cra_blocksize;
+	rshash.digestsize = salg->digestsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_SHASH,
+		sizeof(struct crypto_report_shash), &rshash);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
@@ -541,6 +563,9 @@ static const struct crypto_type crypto_shash_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_shash_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_shash_report,
+#endif
 	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
 	.maskset = CRYPTO_ALG_TYPE_MASK,
 	.type = CRYPTO_ALG_TYPE_SHASH,
include/linux/cryptouser.h +7 -0
index d0766e3..8f2b4a1 100644
@@ -35,6 +35,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_UNSPEC,
 	CRYPTOCFGA_PRIORITY_VAL,	/* __u32 */
 	CRYPTOCFGA_REPORT_LARVAL,	/* struct crypto_report_larval */
+	CRYPTOCFGA_REPORT_SHASH,	/* struct crypto_report_shash */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -62,3 +63,9 @@ struct crypto_report_larval {
 	char type[CRYPTO_MAX_NAME];
 	__u32 flags;
 };
+
+struct crypto_report_shash {
+	char type[CRYPTO_MAX_NAME];
+	unsigned int blocksize;
+	unsigned int digestsize;
+};
Signature · 1 line
1.7.0.4
#15 lore raw

PATCH 7/16 crypto: Add userspace report for ahash type algorithms

In reply to Steffen Klassert
---
 crypto/ahash.c             |   27 +++++++++++++++++++++++++++
 include/linux/cryptouser.h |    8 ++++++++
 2 files changed, 35 insertions(+), 0 deletions(-)
crypto/ahash.c +27 -0
index f669822..5dce6a0 100644
@@ -21,6 +21,8 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include "internal.h"
 
@@ -397,6 +399,28 @@ static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
 	return sizeof(struct crypto_shash *);
 }
 
+static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_ahash rahash;
+
+	snprintf(rahash.type, CRYPTO_MAX_ALG_NAME, "%s", "ahash");
+	snprintf(rahash.async, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
+
+	rahash.blocksize = alg->cra_blocksize;
+	rahash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_AHASH,
+		sizeof(struct crypto_report_ahash), &rahash);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
@@ -415,6 +439,9 @@ const struct crypto_type crypto_ahash_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_ahash_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_ahash_report,
+#endif
 	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
 	.maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
 	.type = CRYPTO_ALG_TYPE_AHASH,
include/linux/cryptouser.h +8 -0
index 8f2b4a1..94ffb7b 100644
@@ -36,6 +36,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_PRIORITY_VAL,	/* __u32 */
 	CRYPTOCFGA_REPORT_LARVAL,	/* struct crypto_report_larval */
 	CRYPTOCFGA_REPORT_SHASH,	/* struct crypto_report_shash */
+	CRYPTOCFGA_REPORT_AHASH,	/* struct crypto_report_ahash */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -69,3 +70,10 @@ struct crypto_report_shash {
 	unsigned int blocksize;
 	unsigned int digestsize;
 };
+
+struct crypto_report_ahash {
+	char type[CRYPTO_MAX_NAME];
+	char async[CRYPTO_MAX_NAME];
+	unsigned int blocksize;
+	unsigned int digestsize;
+};
Signature · 1 line
1.7.0.4
#16 lore raw

PATCH 8/16 crypto: Add userspace report for blkcipher type algorithms

In reply to Steffen Klassert
---
 crypto/blkcipher.c         |   29 +++++++++++++++++++++++++++++
 include/linux/cryptouser.h |   10 ++++++++++
 2 files changed, 39 insertions(+), 0 deletions(-)
crypto/blkcipher.c +29 -0
index 7a72192..b85a67d 100644
@@ -24,6 +24,8 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/string.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include "internal.h"
 
@@ -492,6 +494,30 @@ static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
 		return crypto_init_blkcipher_ops_async(tfm);
 }
 
+static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_blkcipher rblkcipher;
+
+	snprintf(rblkcipher.type, CRYPTO_MAX_ALG_NAME, "%s", "blkcipher");
+	snprintf(rblkcipher.geniv, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_blkcipher.geniv ?: "<default>");
+
+	rblkcipher.blocksize = alg->cra_blocksize;
+	rblkcipher.min_keysize = alg->cra_blkcipher.min_keysize;
+	rblkcipher.max_keysize = alg->cra_blkcipher.max_keysize;
+	rblkcipher.ivsize = alg->cra_blkcipher.ivsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
+		sizeof(struct crypto_report_blkcipher), &rblkcipher);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)
@@ -511,6 +537,9 @@ const struct crypto_type crypto_blkcipher_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_blkcipher_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_blkcipher_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_blkcipher_type);
 
include/linux/cryptouser.h +10 -0
index 94ffb7b..e2e6c4c 100644
@@ -37,6 +37,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_LARVAL,	/* struct crypto_report_larval */
 	CRYPTOCFGA_REPORT_SHASH,	/* struct crypto_report_shash */
 	CRYPTOCFGA_REPORT_AHASH,	/* struct crypto_report_ahash */
+	CRYPTOCFGA_REPORT_BLKCIPHER,	/* struct crypto_report_blkcipher */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -77,3 +78,12 @@ struct crypto_report_ahash {
 	unsigned int blocksize;
 	unsigned int digestsize;
 };
+
+struct crypto_report_blkcipher {
+	char type[CRYPTO_MAX_NAME];
+	char geniv[CRYPTO_MAX_NAME];
+	unsigned int blocksize;
+	unsigned int min_keysize;
+	unsigned int max_keysize;
+	unsigned int ivsize;
+};
Signature · 1 line
1.7.0.4
#17 lore raw

PATCH 9/16 crypto: Add userspace report for ablkcipher type algorithms

In reply to Steffen Klassert
---
 crypto/ablkcipher.c        |   31 +++++++++++++++++++++++++++++++
 include/linux/cryptouser.h |   11 +++++++++++
 2 files changed, 42 insertions(+), 0 deletions(-)
crypto/ablkcipher.c +31 -0
index fdc67d3..d9b6717 100644
@@ -23,6 +23,8 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include <crypto/scatterwalk.h>
 
@@ -381,6 +383,32 @@ static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,
 	return 0;
 }
 
+static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_ablkcipher rablkcipher;
+
+	snprintf(rablkcipher.type, CRYPTO_MAX_ALG_NAME, "%s", "ablkcipher");
+	snprintf(rablkcipher.geniv, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_ablkcipher.geniv ?: "<default>");
+	snprintf(rablkcipher.async, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
+
+	rablkcipher.blocksize = alg->cra_blocksize;
+	rablkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
+	rablkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;
+	rablkcipher.ivsize = alg->cra_ablkcipher.ivsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_ABLKCIPHER,
+		sizeof(struct crypto_report_ablkcipher), &rablkcipher);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
@@ -403,6 +431,9 @@ const struct crypto_type crypto_ablkcipher_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_ablkcipher_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_ablkcipher_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);
 
include/linux/cryptouser.h +11 -0
index e2e6c4c..8440966 100644
@@ -38,6 +38,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_SHASH,	/* struct crypto_report_shash */
 	CRYPTOCFGA_REPORT_AHASH,	/* struct crypto_report_ahash */
 	CRYPTOCFGA_REPORT_BLKCIPHER,	/* struct crypto_report_blkcipher */
+	CRYPTOCFGA_REPORT_ABLKCIPHER,	/* struct crypto_report_ablkcipher */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -87,3 +88,13 @@ struct crypto_report_blkcipher {
 	unsigned int max_keysize;
 	unsigned int ivsize;
 };
+
+struct crypto_report_ablkcipher {
+	char type[CRYPTO_MAX_NAME];
+	char async[CRYPTO_MAX_NAME];
+	char geniv[CRYPTO_MAX_NAME];
+	unsigned int blocksize;
+	unsigned int min_keysize;
+	unsigned int max_keysize;
+	unsigned int ivsize;
+};
Signature · 1 line
1.7.0.4
#18 lore raw

PATCH 10/16 crypto: Add userspace report for givcipher type algorithms

In reply to Steffen Klassert
---
 crypto/ablkcipher.c        |   29 +++++++++++++++++++++++++++++
 include/linux/cryptouser.h |    1 +
 2 files changed, 30 insertions(+), 0 deletions(-)
crypto/ablkcipher.c +29 -0
index d9b6717..c19d14b 100644
@@ -463,6 +463,32 @@ static int crypto_init_givcipher_ops(struct crypto_tfm *tfm, u32 type,
 	return 0;
 }
 
+static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_ablkcipher rablkcipher;
+
+	snprintf(rablkcipher.type, CRYPTO_MAX_ALG_NAME, "%s", "givcipher");
+	snprintf(rablkcipher.geniv, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_ablkcipher.geniv ?: "<built-in>");
+	snprintf(rablkcipher.async, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
+
+	rablkcipher.blocksize = alg->cra_blocksize;
+	rablkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
+	rablkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;
+	rablkcipher.ivsize = alg->cra_ablkcipher.ivsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_GIVCIPHER,
+		sizeof(struct crypto_report_ablkcipher), &rablkcipher);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg)
@@ -485,6 +511,9 @@ const struct crypto_type crypto_givcipher_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_givcipher_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_givcipher_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_givcipher_type);
 
include/linux/cryptouser.h +1 -0
index 8440966..e2c76f7 100644
@@ -39,6 +39,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_AHASH,	/* struct crypto_report_ahash */
 	CRYPTOCFGA_REPORT_BLKCIPHER,	/* struct crypto_report_blkcipher */
 	CRYPTOCFGA_REPORT_ABLKCIPHER,	/* struct crypto_report_ablkcipher */
+	CRYPTOCFGA_REPORT_GIVCIPHER,	/* struct crypto_report_ablkcipher */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
Signature · 1 line
1.7.0.4
#19 lore raw

PATCH 11/16 crypto: Add userspace report for aead type algorithms

In reply to Steffen Klassert
---
 crypto/aead.c              |   31 +++++++++++++++++++++++++++++++
 include/linux/cryptouser.h |   10 ++++++++++
 2 files changed, 41 insertions(+), 0 deletions(-)
crypto/aead.c +31 -0
index 6729e8f..25793b7 100644
@@ -21,6 +21,8 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include "internal.h"
 
@@ -109,6 +111,32 @@ static int crypto_init_aead_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
 	return 0;
 }
 
+static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_aead raead;
+	struct aead_alg *aead = &alg->cra_aead;
+
+	snprintf(raead.type, CRYPTO_MAX_ALG_NAME, "%s", "aead");
+	snprintf(raead.geniv, CRYPTO_MAX_ALG_NAME, "%s",
+		 aead->geniv ?: "<built-in>");
+	snprintf(raead.async, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
+
+	raead.blocksize = alg->cra_blocksize;
+	raead.maxauthsize = aead->maxauthsize;
+	raead.ivsize = aead->ivsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_AEAD,
+		sizeof(struct crypto_report_aead), &raead);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
@@ -130,6 +158,9 @@ const struct crypto_type crypto_aead_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_aead_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_aead_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_aead_type);
 
include/linux/cryptouser.h +10 -0
index e2c76f7..04762d7 100644
@@ -40,6 +40,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_BLKCIPHER,	/* struct crypto_report_blkcipher */
 	CRYPTOCFGA_REPORT_ABLKCIPHER,	/* struct crypto_report_ablkcipher */
 	CRYPTOCFGA_REPORT_GIVCIPHER,	/* struct crypto_report_ablkcipher */
+	CRYPTOCFGA_REPORT_AEAD,		/* struct crypto_report_aead */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -99,3 +100,12 @@ struct crypto_report_ablkcipher {
 	unsigned int max_keysize;
 	unsigned int ivsize;
 };
+
+struct crypto_report_aead {
+	char type[CRYPTO_MAX_NAME];
+	char async[CRYPTO_MAX_NAME];
+	char geniv[CRYPTO_MAX_NAME];
+	unsigned int blocksize;
+	unsigned int maxauthsize;
+	unsigned int ivsize;
+};
Signature · 1 line
1.7.0.4
#20 lore raw

PATCH 12/16 crypto: Add userspace report for nivaead type algorithms

In reply to Steffen Klassert
---
 crypto/aead.c              |   29 +++++++++++++++++++++++++++++
 include/linux/cryptouser.h |    1 +
 2 files changed, 30 insertions(+), 0 deletions(-)
crypto/aead.c +29 -0
index 25793b7..218ecc8 100644
@@ -196,6 +196,32 @@ static int crypto_init_nivaead_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
 	return 0;
 }
 
+static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_aead raead;
+	struct aead_alg *aead = &alg->cra_aead;
+
+	snprintf(raead.type, CRYPTO_MAX_ALG_NAME, "%s", "nivaead");
+	snprintf(raead.geniv, CRYPTO_MAX_ALG_NAME, "%s", aead->geniv);
+	snprintf(raead.async, CRYPTO_MAX_ALG_NAME, "%s",
+		 alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
+
+	raead.blocksize = alg->cra_blocksize;
+	raead.maxauthsize = aead->maxauthsize;
+	raead.ivsize = aead->ivsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_NIVAEAD,
+		sizeof(struct crypto_report_aead), &raead);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
+
 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg)
@@ -217,6 +243,9 @@ const struct crypto_type crypto_nivaead_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_nivaead_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_nivaead_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_nivaead_type);
 
include/linux/cryptouser.h +1 -0
index 04762d7..fc660c7 100644
@@ -41,6 +41,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_ABLKCIPHER,	/* struct crypto_report_ablkcipher */
 	CRYPTOCFGA_REPORT_GIVCIPHER,	/* struct crypto_report_ablkcipher */
 	CRYPTOCFGA_REPORT_AEAD,		/* struct crypto_report_aead */
+	CRYPTOCFGA_REPORT_NIVAEAD,	/* struct crypto_report_aead */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
Signature · 1 line
1.7.0.4
#21 lore raw

PATCH 13/16 crypto: Add userspace report for pcompress type algorithms

In reply to Steffen Klassert
---
 crypto/pcompress.c         |   22 ++++++++++++++++++++++
 include/linux/cryptouser.h |    5 +++++
 2 files changed, 27 insertions(+), 0 deletions(-)
crypto/pcompress.c +22 -0
index f7c4a7d..3fc8ed7 100644
@@ -24,6 +24,8 @@
 #include <linux/module.h>
 #include <linux/seq_file.h>
 #include <linux/string.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 #include <crypto/compress.h>
 #include <crypto/internal/compress.h>
@@ -46,6 +48,23 @@ static int crypto_pcomp_init_tfm(struct crypto_tfm *tfm)
 	return 0;
 }
 
+static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_comp rpcomp;
+
+	snprintf(rpcomp.type, CRYPTO_MAX_ALG_NAME, "%s", "pcomp");
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_PCOMPRESS,
+		sizeof(struct crypto_report_comp), &rpcomp);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg)
@@ -60,6 +79,9 @@ static const struct crypto_type crypto_pcomp_type = {
 #ifdef CONFIG_PROC_FS
 	.show		= crypto_pcomp_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_pcomp_report,
+#endif
 	.maskclear	= ~CRYPTO_ALG_TYPE_MASK,
 	.maskset	= CRYPTO_ALG_TYPE_MASK,
 	.type		= CRYPTO_ALG_TYPE_PCOMPRESS,
include/linux/cryptouser.h +5 -0
index fc660c7..1d24aea 100644
@@ -42,6 +42,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_GIVCIPHER,	/* struct crypto_report_ablkcipher */
 	CRYPTOCFGA_REPORT_AEAD,		/* struct crypto_report_aead */
 	CRYPTOCFGA_REPORT_NIVAEAD,	/* struct crypto_report_aead */
+	CRYPTOCFGA_REPORT_PCOMPRESS,	/* struct crypto_report_comp */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -110,3 +111,7 @@ struct crypto_report_aead {
 	unsigned int maxauthsize;
 	unsigned int ivsize;
 };
+
+struct crypto_report_comp {
+	char type[CRYPTO_MAX_NAME];
+};
Signature · 1 line
1.7.0.4
#22 lore raw

PATCH 14/16 crypto: Add userspace report for rng type algorithms

In reply to Steffen Klassert
---
 crypto/rng.c               |   24 ++++++++++++++++++++++++
 include/linux/cryptouser.h |    6 ++++++
 2 files changed, 30 insertions(+), 0 deletions(-)
crypto/rng.c +24 -0
index 45229ae..3051375 100644
@@ -21,6 +21,8 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/string.h>
+#include <linux/cryptouser.h>
+#include <net/netlink.h>
 
 static DEFINE_MUTEX(crypto_default_rng_lock);
 struct crypto_rng *crypto_default_rng;
@@ -58,6 +60,25 @@ static int crypto_init_rng_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
 	return 0;
 }
 
+static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg)
+	__attribute__ ((unused));
+static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_rng rrng;
+
+	snprintf(rrng.type, CRYPTO_MAX_ALG_NAME, "%s", "rng");
+
+	rrng.seedsize = alg->cra_rng.seedsize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_RNG,
+		sizeof(struct crypto_report_rng), &rrng);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
 	__attribute__ ((unused));
 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
@@ -78,6 +99,9 @@ const struct crypto_type crypto_rng_type = {
 #ifdef CONFIG_PROC_FS
 	.show = crypto_rng_show,
 #endif
+#ifdef CONFIG_CRYPTO_USER
+	.report = crypto_rng_report,
+#endif
 };
 EXPORT_SYMBOL_GPL(crypto_rng_type);
 
include/linux/cryptouser.h +6 -0
index 1d24aea..2219964 100644
@@ -43,6 +43,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_AEAD,		/* struct crypto_report_aead */
 	CRYPTOCFGA_REPORT_NIVAEAD,	/* struct crypto_report_aead */
 	CRYPTOCFGA_REPORT_PCOMPRESS,	/* struct crypto_report_comp */
+	CRYPTOCFGA_REPORT_RNG,		/* struct crypto_report_rng */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -115,3 +116,8 @@ struct crypto_report_aead {
 struct crypto_report_comp {
 	char type[CRYPTO_MAX_NAME];
 };
+
+struct crypto_report_rng {
+	char type[CRYPTO_MAX_NAME];
+	unsigned int seedsize;
+};
Signature · 1 line
1.7.0.4
#23 lore raw

PATCH 15/16 crypto: Add userspace report for cipher type algorithms

In reply to Steffen Klassert
---
 crypto/crypto_user.c       |   29 +++++++++++++++++++++++++++++
 include/linux/cryptouser.h |    8 ++++++++
 2 files changed, 37 insertions(+), 0 deletions(-)
crypto/crypto_user.c +29 -0
index fa68965..82f9fad 100644
@@ -76,6 +76,25 @@ static struct crypto_alg *crypto_alg_match(struct crypto_user_alg *p)
 	return alg;
 }
 
+static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_cipher rcipher;
+
+	snprintf(rcipher.type, CRYPTO_MAX_ALG_NAME, "%s", "cipher");
+
+	rcipher.blocksize = alg->cra_blocksize;
+	rcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
+	rcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_CIPHER,
+		sizeof(struct crypto_report_cipher), &rcipher);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
 static int crypto_report_one(struct crypto_alg *alg,
 			     struct crypto_report_base *rb, struct sk_buff *skb)
 {
@@ -103,6 +122,16 @@ static int crypto_report_one(struct crypto_alg *alg,
 	if (alg->cra_type && alg->cra_type->report) {
 		if (alg->cra_type->report(skb, alg))
 			goto nla_put_failure;
+
+		goto out;
+	}
+
+	switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
+	case CRYPTO_ALG_TYPE_CIPHER:
+		if (crypto_report_cipher(skb, alg))
+			goto nla_put_failure;
+
+		break;
 	}
 
 out:
include/linux/cryptouser.h +8 -0
index 2219964..82ec52d 100644
@@ -44,6 +44,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_NIVAEAD,	/* struct crypto_report_aead */
 	CRYPTOCFGA_REPORT_PCOMPRESS,	/* struct crypto_report_comp */
 	CRYPTOCFGA_REPORT_RNG,		/* struct crypto_report_rng */
+	CRYPTOCFGA_REPORT_CIPHER,	/* struct crypto_report_cipher */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
@@ -85,6 +86,13 @@ struct crypto_report_ahash {
 	unsigned int digestsize;
 };
 
+struct crypto_report_cipher {
+	char type[CRYPTO_MAX_ALG_NAME];
+	unsigned int blocksize;
+	unsigned int min_keysize;
+	unsigned int max_keysize;
+};
+
 struct crypto_report_blkcipher {
 	char type[CRYPTO_MAX_NAME];
 	char geniv[CRYPTO_MAX_NAME];
Signature · 1 line
1.7.0.4
#24 lore raw

PATCH 16/16 crypto: Add userspace report for compress type algorithms

In reply to Steffen Klassert
---
 crypto/crypto_user.c       |   21 +++++++++++++++++++++
 include/linux/cryptouser.h |    1 +
 2 files changed, 22 insertions(+), 0 deletions(-)
crypto/crypto_user.c +21 -0
index 82f9fad..be6a193 100644
@@ -95,6 +95,22 @@ nla_put_failure:
 	return -EMSGSIZE;
 }
 
+static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
+{
+	struct crypto_report_comp rcomp;
+
+	snprintf(rcomp.type, CRYPTO_MAX_ALG_NAME, "%s", "compression");
+
+	NLA_PUT(skb, CRYPTOCFGA_REPORT_COMPRESS,
+		sizeof(struct crypto_report_comp), &rcomp);
+
+	return 0;
+
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
+
 static int crypto_report_one(struct crypto_alg *alg,
 			     struct crypto_report_base *rb, struct sk_buff *skb)
 {
@@ -132,6 +148,11 @@ static int crypto_report_one(struct crypto_alg *alg,
 			goto nla_put_failure;
 
 		break;
+	case CRYPTO_ALG_TYPE_COMPRESS:
+		if (crypto_report_comp(skb, alg))
+			goto nla_put_failure;
+
+		break;
 	}
 
 out:
include/linux/cryptouser.h +1 -0
index 82ec52d..2e829f1 100644
@@ -45,6 +45,7 @@ enum crypto_attr_type_t {
 	CRYPTOCFGA_REPORT_PCOMPRESS,	/* struct crypto_report_comp */
 	CRYPTOCFGA_REPORT_RNG,		/* struct crypto_report_rng */
 	CRYPTOCFGA_REPORT_CIPHER,	/* struct crypto_report_cipher */
+	CRYPTOCFGA_REPORT_COMPRESS,	/* struct crypto_report_comp */
 	__CRYPTOCFGA_MAX
 
 #define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
Signature · 1 line
1.7.0.4
maintainer
#2 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

In reply to Steffen Klassert
Quoted 8 lines · Steffen Klassert

Most crypto algorithms simply take the priority value of the underlying algorithm and add some value to calculate the algorithms priority. The only exeptions are the authenc algorithms. We change the authenc algorithms to calculate their priority to the sum of the underlying algorithms plus 100. With this we can keep the priority consistent if one of the underlying algorithms changes the priority.

Actually the reason it places a bigger weight on the cipher's priority is because typically ciphers are slower than hashes. So this is expressing the fact that we'd rather use a faster cipher with a slower hash than the other way around.

Do you have a particular scenario in mind where this is broken?

Thanks,

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#3 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 5 lines · Herbert Xu

Actually the reason it places a bigger weight on the cipher's priority is because typically ciphers are slower than hashes. So this is expressing the fact that we'd rather use a faster cipher with a slower hash than the other way around.

I thought the underlying ciphers and hashes choose their priority based on the algorithms speed. So I thought it would be ok to just add their priorities in the authenc algorithms. Do you think we shoud keep the weight on the cipher's priority?

Quoted 3 lines

Do you have a particular scenario in mind where this is broken?

I don't think it is broken. It's just easier to handle if an underlying algorithm changes it's priority. If the user changes the priority of a certain algorithm, I take the difference of the old and new priority value and add this to all subsequent algorithms. So this can not take the weight into account without some 'per algorithm' priority update functions.

maintainer
#4 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 6 lines · Steffen Klassert

I don't think it is broken. It's just easier to handle if an underlying algorithm changes it's priority. If the user changes the priority of a certain algorithm, I take the difference of the old and new priority value and add this to all subsequent algorithms. So this can not take the weight into account without some 'per algorithm' priority update functions.

Oh I see. I don't think we need to go that far.

Here are two simpler ways of handling this:

1) Liquidate all instances on top of the algorithm being changed (this is what we already do when you register a new implementation of an algorithm with a higher priority).

2) Do nothing and let the user change everything manually.

My take would be to just do 1) considering that the usage scenario is that the user is either going to change something like AES at the very bottom of the pile or something complex at the top.

Cheers,

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#5 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 8 lines · Herbert Xu
Quoted 6 lines · Steffen Klassert

I don't think it is broken. It's just easier to handle if an underlying algorithm changes it's priority. If the user changes the priority of a certain algorithm, I take the difference of the old and new priority value and add this to all subsequent algorithms. So this can not take the weight into account without some 'per algorithm' priority update functions.

Quoted 7 lines

Oh I see. I don't think we need to go that far.

Here are two simpler ways of handling this:

1) Liquidate all instances on top of the algorithm being changed (this is what we already do when you register a new implementation of an algorithm with a higher priority).

Hm, I thought about that already. But in this case, we can change the priority just if all the algorithms on top are unused. My intention was to be able to change the priority without the need of removing all transforms build from these algorithms. So I had the hope to get it that all existing transforms continue to use the old algorithm of hightest priority and all newly build transforms use the new algorithm with the highest priority.

Quoted 2 lines

2) Do nothing and let the user change everything manually.

This has the same issue, with the only difference that the user has to remove the instances on top manually.

I think the only value of the priority update is, if we can do it without removing existing transforms. If this is not possible it is much easier to just delete the algorithm in question and to build a new one with the updated priority.

maintainer
#6 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 5 lines · Steffen Klassert

I think the only value of the priority update is, if we can do it without removing existing transforms. If this is not possible it is much easier to just delete the algorithm in question and to build a new one with the updated priority.

We don't want to automatically update a value that the user may have previously set. So I think updating instances on mass won't work anyway.

Besides, an instance may depend on an algorithm which should not influence its priority value at all (e.g., if it's only used during setkey).

So let's just remove that and make this simpler.

Thanks!

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#7 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 11 lines · Herbert Xu

We don't want to automatically update a value that the user may have previously set. So I think updating instances on mass won't work anyway.

Besides, an instance may depend on an algorithm which should not influence its priority value at all (e.g., if it's only used during setkey).

So let's just remove that and make this simpler.

Ok, I'll remove it and respin the patches.

#8 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

In reply to Herbert Xu
Quoted 16 lines · Herbert Xu
Quoted 6 lines · Steffen Klassert

I don't think it is broken. It's just easier to handle if an underlying algorithm changes it's priority. If the user changes the priority of a certain algorithm, I take the difference of the old and new priority value and add this to all subsequent algorithms. So this can not take the weight into account without some 'per algorithm' priority update functions.

Oh I see. I don't think we need to go that far.

Here are two simpler ways of handling this:

1) Liquidate all instances on top of the algorithm being changed (this is what we already do when you register a new implementation of an algorithm with a higher priority).

Quoted 6 lines

2) Do nothing and let the user change everything manually.

My take would be to just do 1) considering that the usage scenario is that the user is either going to change something like AES at the very bottom of the pile or something complex at the top.

I've just noticed that we need the update functionality to change the priority of algorithms that are not build from templates because we can't delete them without unloading the module. If the algorithm is not build as a module, we can't delete it at all. So there is no chance to change the priority without an update functionality.

Therefore I'll bring the update functions back. I'll use your option 1) to deal with the algorithms on top of the changed one.

maintainer
#9 lore raw

Re: [PATCH 01/16] crypto: authenc - Don't multiply priorities

Quoted 3 lines · Steffen Klassert

Therefore I'll bring the update functions back. I'll use your option 1) to deal with the algorithms on top of the changed one.

Sounds good.

Cheers,

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt