crypto: dh - infrastructure for NVM in-band auth and FIPS conformance
Subsystems (4)
v4 cover crypto: dh - infrastructure for NVM in-band auth and FIPS conformance
Hi all,
first of all, to the people primarily interested in security/keys/, there's a rather trivial change to security/keys/dh.c in patch 4/15. It would be great to get ACKs for that...
This patchset's main objective is to provide the DH related preprequisite bits needed by the upcoming support for NVME in-band authentication ([1]), namely
- support for the RFC 7919 ffdheXYZ group parameters (patches [1-8/15]) and
- an ephemeral key generation primitive for these (patches [9-11/15]).
With this in place, it happens to become relatively straight-forward to achieve conformance with NIST SP800-56Ar3. The remainder of this patchset, i.e. patches [12-15/15], implements the required changes.
The previous v3 of this patchset can be found at [2]. The only difference between v3 and the v4 here is the removal of a superfluous "default n" Kconfig statement in patch [7/15] ("crypto: dh - implement ffdheXYZ(dh) templates").
I would like to reiterate that [12/15] ("crypto: api - allow algs only in specific constructions in FIPS mode") is heavily based on a patch previously posted by Herbert. Please refer to the v3 cover letter at [2] for the full history.
Finally note that Stephan has granted his
to v3 already ([3]). Stephan, with the trivial diff between v3 and v4, would you be Ok with carrying it over?
Thanks,
Nicolai
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]
[3] https://lore.kernel.org/r/[email protected]
Nicolai Stange (15):
crypto: kpp - provide support for KPP template instances
crypto: kpp - provide support for KPP spawns
crypto: dh - remove struct dh's ->q member
crypto: dh - constify struct dh's pointer members
crypto: dh - split out deserialization code from crypto_dh_decode()
crypto: dh - introduce common code for built-in safe-prime group
support
crypto: dh - implement ffdheXYZ(dh) templates
crypto: testmgr - add known answer tests for ffdheXYZ(dh) templates
crypto: dh - implement private key generation primitive for
ffdheXYZ(dh)
crypto: testmgr - add keygen tests for ffdheXYZ(dh) templates
crypto: dh - allow for passing NULL to the ffdheXYZ(dh)s'
->set_secret()
crypto: api - allow algs only in specific constructions in FIPS mode
crypto: dh - disallow plain "dh" usage in FIPS mode lib/mpi: export mpi_rshift
crypto: dh - calculate Q from P for the full public key verification
crypto/Kconfig | 7 + crypto/algapi.c | 18 +- crypto/api.c | 19 +- crypto/dh.c | 687 +++++++++++++++- crypto/dh_helper.c | 42 +- crypto/kpp.c | 29 + crypto/tcrypt.c | 4 +- crypto/testmgr.c | 61 +- crypto/testmgr.h | 1445 ++++++++++++++++++++++++++++++++- include/crypto/dh.h | 26 +- include/crypto/internal/kpp.h | 158 ++++ include/linux/crypto.h | 9 + lib/mpi/mpi-bit.c | 1 + security/keys/dh.c | 2 +- 14 files changed, 2441 insertions(+), 67 deletions(-)
Signature · 1 line
2.26.2
PATCH v4 1/15 crypto: kpp - provide support for KPP template instances
The upcoming support for the RFC 7919 ffdhe group parameters will be made available in the form of templates like "ffdhe2048(dh)", "ffdhe3072(dh)" and so on. Template instantiations thereof would wrap the inner "dh" kpp_alg and also provide kpp_alg services to the outside again. Furthermore, it might be perhaps be desirable to provide KDF templates in the future, which would similarly wrap an inner kpp_alg and present themselves to the outside as another kpp_alg, transforming the shared secret on its way out.
Introduce the bits needed for supporting KPP template instances. Everything related to inner kpp_alg spawns potentially being held by such template instances will be deferred to a subsequent patch in order to facilitate review.
Define struct struct kpp_instance in close analogy to the already existing skcipher_instance, shash_instance and alike, but wrapping a struct kpp_alg. Implement the new kpp_register_instance() template instance registration primitive. Provide some helper functions for
- going back and forth between a generic struct crypto_instance and the new struct kpp_instance,
- obtaining the instantiating kpp_instance from a crypto_kpp transform and
- for accessing a given kpp_instance's implementation specific context data.
Annotate everything with proper kernel-doc comments, even though include/crypto/internal/kpp.h is not considered for the generated docs.
--- crypto/kpp.c | 20 +++++++++ include/crypto/internal/kpp.h | 83 +++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+)
crypto/kpp.c +20 -0
@@ -68,9 +68,17 @@ static int crypto_kpp_init_tfm(struct crypto_tfm *tfm)return 0 ; } +static void crypto_kpp_free_instance (struct crypto_instance *inst) +{ +struct kpp_instance *kpp =kpp_instance (inst); + + kpp->free (kpp); +} +static const struct crypto_type crypto_kpp_type = { .extsize = crypto_alg_extsize, .init_tfm = crypto_kpp_init_tfm, + .free = crypto_kpp_free_instance, #ifdef CONFIG_PROC_FS .show = crypto_kpp_show, #endif
@@ -111,5 +119,17 @@ void crypto_unregister_kpp(struct kpp_alg *alg) }EXPORT_SYMBOL_GPL (crypto_unregister_kpp); +int kpp_register_instance (struct crypto_template *tmpl, +struct kpp_instance *inst) +{ +if (WARN_ON (!inst->free)) +return -EINVAL ; + +kpp_prepare_alg (&inst->alg); + +return crypto_register_instance (tmpl,kpp_crypto_instance (inst)); +} +EXPORT_SYMBOL_GPL (kpp_register_instance); +MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Key-agreement Protocol Primitives" );
include/crypto/internal/kpp.h +83 -0
99 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 01/15] crypto: kpp - provide support for KPP template instances
Quoted 24 lines · Nicolai Stange
The upcoming support for the RFC 7919 ffdhe group parameters will be made available in the form of templates like "ffdhe2048(dh)", "ffdhe3072(dh)" and so on. Template instantiations thereof would wrap the inner "dh"
kpp_algand also providekpp_algservices to the outside again. Furthermore, it might be perhaps be desirable to provide KDF templates in the future, which would similarly wrap an innerkpp_algand present themselves to the outside as anotherkpp_alg, transforming the shared secret on its way out.Introduce the bits needed for supporting KPP template instances. Everything related to inner
kpp_algspawns potentially being held by such template instances will be deferred to a subsequent patch in order to facilitate review.Define struct struct
kpp_instancein close analogy to the already existingskcipher_instance,shash_instanceand alike, but wrapping a structkpp_alg. Implement the newkpp_register_instance()template instance registration primitive. Provide some helper functions for
- going back and forth between a generic structcrypto_instanceand the new structkpp_instance,
- obtaining the instantiatingkpp_instancefrom acrypto_kpptransform and
- for accessing a given kpp_instance's implementation specific context data.
Quoted 9 lines
Annotate everything with proper kernel-doc comments, even though
include/crypto/internal/kpp.his not considered for the generated docs.Signed-off-by Nicolai Stange <[email protected]>--- crypto/kpp.c | 20 +++++++++ include/crypto/internal/kpp.h | 83 +++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 2/15 crypto: kpp - provide support for KPP spawns
In reply to Nicolai StangeThe upcoming support for the RFC 7919 ffdhe group parameters will be made available in the form of templates like "ffdhe2048(dh)", "ffdhe3072(dh)" and so on. Template instantiations thereof would wrap the inner "dh" kpp_alg and also provide kpp_alg services to the outside again.
The primitves needed for providing kpp_alg services from template instances have been introduced with the previous patch. Continue this work now and implement everything needed for enabling template instances to make use of inner KPP algorithms like "dh".
More specifically, define a struct crypto_kpp_spawn in close analogy to crypto_skcipher_spawn, crypto_shash_spawn and alike. Implement a crypto_grab_kpp() and crypto_drop_kpp() pair for binding such a spawn to some inner kpp_alg and for releasing it respectively. Template implementations can instantiate transforms from the underlying kpp_alg by means of the new crypto_spawn_kpp(). Finally, provide the crypto_spawn_kpp_alg() helper for accessing a spawn's underlying kpp_alg during template instantiation.
Annotate everything with proper kernel-doc comments, even though include/crypto/internal/kpp.h is not considered for the generated docs.
--- crypto/kpp.c | 9 +++++ include/crypto/internal/kpp.h | 75 +++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+)
crypto/kpp.c +9 -0
@@ -95,6 +95,15 @@ struct crypto_kpp *crypto_alloc_kpp(const char *alg_name, u32 type, u32 mask) }EXPORT_SYMBOL_GPL (crypto_alloc_kpp); +int crypto_grab_kpp (struct crypto_kpp_spawn *spawn, +struct crypto_instance *inst, +const char *name,u32 type,u32 mask) +{ + spawn->base.frontend = &crypto_kpp_type; +return crypto_grab_spawn (&spawn->base, inst, name, type, mask); +} +EXPORT_SYMBOL_GPL (crypto_grab_kpp); +static void kpp_prepare_alg (struct kpp_alg *alg) {struct crypto_alg *base = &alg->base;
include/crypto/internal/kpp.h +75 -0
85 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 02/15] crypto: kpp - provide support for KPP spawns
Quoted 19 lines · Nicolai Stange
The upcoming support for the RFC 7919 ffdhe group parameters will be made available in the form of templates like "ffdhe2048(dh)", "ffdhe3072(dh)" and so on. Template instantiations thereof would wrap the inner "dh"
kpp_algand also providekpp_algservices to the outside again.The primitves needed for providing
kpp_algservices from template instances have been introduced with the previous patch. Continue this work now and implement everything needed for enabling template instances to make use of inner KPP algorithms like "dh".More specifically, define a struct
crypto_kpp_spawnin close analogy tocrypto_skcipher_spawn,crypto_shash_spawnand alike. Implement acrypto_grab_kpp()andcrypto_drop_kpp()pair for binding such a spawn to some innerkpp_algand for releasing it respectively. Template implementations can instantiate transforms from the underlyingkpp_algby means of the newcrypto_spawn_kpp(). Finally, provide thecrypto_spawn_kpp_alg()helper for accessing a spawn's underlyingkpp_algduring template instantiation.
Quoted 9 lines
Annotate everything with proper kernel-doc comments, even though
include/crypto/internal/kpp.his not considered for the generated docs.Signed-off-by Nicolai Stange <[email protected]>--- crypto/kpp.c | 9 +++++ include/crypto/internal/kpp.h | 75 +++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 3/15 crypto: dh - remove struct dh's ->q member
In reply to Nicolai StangeThe only current user of the DH KPP algorithm, the keyctl(KEYCTL_DH_COMPUTE) syscall, doesn't set the domain parameter ->q in struct dh. Remove it and any associated (de)serialization code in crypto_dh_encode_key() and crypto_dh_decode_key. Adjust the encoded ->secret values in testmgr's DH test vectors accordingly.
Note that the dh-generic implementation would have initialized its struct dh_ctx's ->q from the decoded struct dh's ->q, if present. If this struct dh_ctx's ->q would ever have been non-NULL, it would have enabled a full key validation as specified in NIST SP800-56A in dh_is_pubkey_valid(). However, as outlined above, ->q is always NULL in practice and the full key validation code is effectively dead. A later patch will make dh_is_pubkey_valid() to calculate Q from P on the fly, if possible, so don't remove struct dh_ctx's ->q now, but leave it there until that has happened.
--- crypto/dh.c | 6 ------ crypto/dh_helper.c | 17 ++++------------- crypto/testmgr.h | 16 ++++++---------- include/crypto/dh.h | 4 ---- 4 files changed, 10 insertions(+), 33 deletions(-)
crypto/dh.c +0 -6
@@ -62,12 +62,6 @@ static int dh_set_params(struct dh_ctx *ctx, struct dh *params)if (!ctx->p)return -EINVAL ; -if (params->q && params->q_size) { - ctx->q =mpi_read_raw_data (params->q, params->q_size); -if (!ctx->q) -return -EINVAL ; - } - ctx->g =mpi_read_raw_data (params->g, params->g_size);if (!ctx->g)return -EINVAL ;
crypto/dh_helper.c +4 -13
@@ -10,7 +10,7 @@#include <crypto/dh.h> #include <crypto/kpp.h> -#define DH_KPP_SECRET_MIN_SIZE (sizeof(struct kpp_secret) + 4 * sizeof(int)) +#define DH_KPP_SECRET_MIN_SIZE (sizeof(struct kpp_secret) + 3 * sizeof(int))static inline u8 *dh_pack_data (u8 *dst,u8 *end,const void *src,size_t size) {
@@ -28,7 +28,7 @@ static inline const u8 *dh_unpack_data(void *dst, const void *src, size_t size)static inline unsigned int dh_data_size (const struct dh *p) { -return p->key_size + p->p_size + p->q_size + p->g_size; +return p->key_size + p->p_size + p->g_size; }unsigned int crypto_dh_key_len (const struct dh *p)
@@ -53,11 +53,9 @@ int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params) ptr =dh_pack_data (ptr, end, ¶ms->key_size,sizeof (params->key_size)); ptr =dh_pack_data (ptr, end, ¶ms->p_size,sizeof (params->p_size)); - ptr =dh_pack_data (ptr, end, ¶ms->q_size,sizeof (params->q_size)); ptr =dh_pack_data (ptr, end, ¶ms->g_size,sizeof (params->g_size)); ptr =dh_pack_data (ptr, end, params->key, params->key_size); ptr =dh_pack_data (ptr, end, params->p, params->p_size); - ptr =dh_pack_data (ptr, end, params->q, params->q_size); ptr =dh_pack_data (ptr, end, params->g, params->g_size);if (ptr != end)return -EINVAL ;
@@ -79,7 +77,6 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params) ptr =dh_unpack_data (¶ms->key_size, ptr,sizeof (params->key_size)); ptr =dh_unpack_data (¶ms->p_size, ptr,sizeof (params->p_size)); - ptr =dh_unpack_data (¶ms->q_size, ptr,sizeof (params->q_size)); ptr =dh_unpack_data (¶ms->g_size, ptr,sizeof (params->g_size));if (secret.len !=crypto_dh_key_len (params))return -EINVAL ;
@@ -89,7 +86,7 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params)* some drivers assume otherwise. */ if (params->key_size > params->p_size || - params->g_size > params->p_size || params->q_size > params->p_size) + params->g_size > params->p_size)return -EINVAL ;/* Don't allocate memory. Set pointers to data within
@@ -97,9 +94,7 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params)*/ params->key = (void *)ptr; params->p = (void *)(ptr + params->key_size); - params->q = (void *)(ptr + params->key_size + params->p_size); - params->g = (void *)(ptr + params->key_size + params->p_size + - params->q_size); + params->g = (void *)(ptr + params->key_size + params->p_size);/* * Don't permit 'p' to be 0. It's not a prime number, and it's subject
@@ -109,10 +104,6 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params)if (memchr_inv (params->p,0 , params->p_size) ==NULL )return -EINVAL ; -/* It is permissible to not provide Q. */ -if (params->q_size ==0 ) - params->q =NULL ; -return 0 ; }EXPORT_SYMBOL_GPL (crypto_dh_decode_key);
crypto/testmgr.h +6 -10
@@ -1246,17 +1246,15 @@ static const struct kpp_testvec dh_tv_template[] = { .secret =#ifdef __LITTLE_ENDIAN"\x01\x00" /* type */ -"\x15\x02" /* len */ +"\x11\x02" /* len */ "\x00\x01\x00\x00" /* key_size */ "\x00\x01\x00\x00" /* p_size */ -"\x00\x00\x00\x00" /* q_size */ "\x01\x00\x00\x00" /* g_size */#else "\x00\x01" /* type */ -"\x02\x15" /* len */ +"\x02\x11" /* len */ "\x00\x00\x01\x00" /* key_size */ "\x00\x00\x01\x00" /* p_size */ -"\x00\x00\x00\x00" /* q_size */ "\x00\x00\x00\x01" /* g_size */#endif /* xa */
@@ -1346,7 +1344,7 @@ static const struct kpp_testvec dh_tv_template[] = {"\xd3\x34\x49\xad\x64\xa6\xb1\xc0\x59\x28\x75\x60\xa7\x8a\xb0\x11" "\x56\x89\x42\x74\x11\xf5\xf6\x5e\x6f\x16\x54\x6a\xb1\x76\x4d\x50" "\x8a\x68\xc1\x5b\x82\xb9\x0d\x00\x32\x50\xed\x88\x87\x48\x92\x17", - .secret_size = 533, + .secret_size = 529, .b_public_size = 256, .expected_a_public_size = 256, .expected_ss_size = 256,
@@ -1355,17 +1353,15 @@ static const struct kpp_testvec dh_tv_template[] = { .secret =#ifdef __LITTLE_ENDIAN"\x01\x00" /* type */ -"\x15\x02" /* len */ +"\x11\x02" /* len */ "\x00\x01\x00\x00" /* key_size */ "\x00\x01\x00\x00" /* p_size */ -"\x00\x00\x00\x00" /* q_size */ "\x01\x00\x00\x00" /* g_size */#else "\x00\x01" /* type */ -"\x02\x15" /* len */ +"\x02\x11" /* len */ "\x00\x00\x01\x00" /* key_size */ "\x00\x00\x01\x00" /* p_size */ -"\x00\x00\x00\x00" /* q_size */ "\x00\x00\x00\x01" /* g_size */#endif /* xa */
@@ -1455,7 +1451,7 @@ static const struct kpp_testvec dh_tv_template[] = {"\x5e\x5a\x64\xbd\xf6\x85\x04\xe8\x28\x6a\xac\xef\xce\x19\x8e\x9a" "\xfe\x75\xc0\x27\x69\xe3\xb3\x7b\x21\xa7\xb1\x16\xa4\x85\x23\xee" "\xb0\x1b\x04\x6e\xbd\xab\x16\xde\xfd\x86\x6b\xa9\x95\xd7\x0b\xfd", - .secret_size = 533, + .secret_size = 529, .b_public_size = 256, .expected_a_public_size = 256, .expected_ss_size = 256,
include/crypto/dh.h +0 -4
@@ -24,21 +24,17 @@* * @key: Private DH key * @p: Diffie-Hellman parameter P -* @q: Diffie-Hellman parameter Q * @g: Diffie-Hellman generator G * @key_size: Size of the private DH key * @p_size: Size of DH parameter P -* @q_size: Size of DH parameter Q * @g_size: Size of DH generator G */ struct dh {void *key;void *p; -void *q;void *g;unsigned int key_size;unsigned int p_size; -unsigned int q_size;unsigned int g_size; };
Signature · 1 line
2.26.2
PATCH v4 4/15 crypto: dh - constify struct dh's pointer members
In reply to Nicolai Stangestruct dh contains several pointer members corresponding to DH parameters:
->key, ->p and ->g. A subsequent commit will introduce "dh" wrapping templates of the form "ffdhe2048(dh)", "ffdhe3072(dh)" and so on in order to provide built-in support for the well-known safe-prime ffdhe group parameters specified in RFC 7919. These templates will need to set the group parameter related members of the (serialized) struct dh instance passed to the inner "dh" kpp_alg instance, i.e. ->p and ->g, to some constant, static storage arrays.
Turn the struct dh pointer members' types into "pointer to const" in preparation for this.
--- include/crypto/dh.h | 6 +++--- security/keys/dh.c | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-)
include/crypto/dh.h +3 -3
@@ -30,9 +30,9 @@* @g_size: Size of DH generator G */ struct dh { -void *key; -void *p; -void *g; +const void *key; +const void *p; +const void *g;unsigned int key_size;unsigned int p_size;unsigned int g_size;
security/keys/dh.c +1 -1
@@ -15,7 +15,7 @@#include <keys/user-type.h> #include "internal.h" -static ssize_t dh_data_from_key (key_serial_t keyid,void **data) +static ssize_t dh_data_from_key (key_serial_t keyid,const void **data) {struct key *key;key_ref_t key_ref;
Signature · 1 line
2.26.2
Re: [PATCH v4 04/15] crypto: dh - constify struct dh's pointer members
Quoted 9 lines · Nicolai Stange
struct dh contains several pointer members corresponding to DH parameters:
->key, ->p and ->g. A subsequent commit will introduce "dh" wrapping templates of the form "ffdhe2048(dh)", "ffdhe3072(dh)" and so on in order to provide built-in support for the well-known safe-prime ffdhe group parameters specified in RFC 7919. These templates will need to set the group parameter related members of the (serialized) struct dh instance passed to the inner "dh"kpp_alginstance, i.e. ->p and ->g, to some constant, static storage arrays.
Quoted 9 lines
Turn the struct dh pointer members' types into "pointer to const" in preparation for this.
Signed-off-by Nicolai Stange <[email protected]>--- include/crypto/dh.h | 6 +++--- security/keys/dh.c | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 5/15 crypto: dh - split out deserialization code from crypto_dh_decode()
In reply to Nicolai StangeA subsequent commit will introduce "dh" wrapping templates of the form "ffdhe2048(dh)", "ffdhe3072(dh)" and so on in order to provide built-in support for the well-known safe-prime ffdhe group parameters specified in RFC 7919.
Those templates' ->set_secret() will wrap the inner "dh" implementation's ->set_secret() and set the ->p and ->g group parameters as appropriate on the way inwards. More specifically,
- A ffdheXYZ(dh) user would call crypto_dh_encode() on a struct dh instance having ->p == ->g == NULL as well as ->p_size == ->g_size == 0 and pass the resulting buffer to the outer ->set_secret().
- This outer ->set_secret() would then decode the struct dh via crypto_dh_decode_key(), set ->p, ->g, ->p_size as well as ->g_size as appropriate for the group in question and encode the struct dh again before passing it further down to the inner "dh"'s ->set_secret().
The problem is that crypto_dh_decode_key() implements some basic checks which would reject parameter sets with ->p_size == 0 and thus, the ffdheXYZ templates' ->set_secret() cannot use it as-is for decoding the passed buffer. As the inner "dh"'s ->set_secret() will eventually conduct said checks on the final parameter set anyway, the outer ->set_secret() really only needs the decoding functionality.
Split out the pure struct dh decoding part from crypto_dh_decode_key() into the new __crypto_dh_decode_key().
__crypto_dh_decode_key() gets defined in crypto/dh_helper.c, but will have to get called from crypto/dh.c and thus, its declaration must be somehow made available to the latter. Strictly speaking, __crypto_dh_decode_key() is internal to the dh_generic module, yet it would be a bit over the top to introduce a new header like e.g. include/crypto/internal/dh.h containing just a single prototype. Add the __crypto_dh_decode_key() declaration to include/crypto/dh.h instead.
Provide a proper kernel-doc annotation, even though __crypto_dh_decode_key() is purposedly not on the function list specified in Documentation/crypto/api-kpp.rst.
--- crypto/dh_helper.c | 27 +++++++++++++++++++-------- include/crypto/dh.h | 16 ++++++++++++++++ 2 files changed, 35 insertions(+), 8 deletions(-)
crypto/dh_helper.c +19 -8
@@ -63,7 +63,7 @@ int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params) }EXPORT_SYMBOL_GPL (crypto_dh_encode_key); -int crypto_dh_decode_key (const char *buf,unsigned int len,struct dh *params) +int __crypto_dh_decode_key (const char *buf,unsigned int len,struct dh *params) {const u8 *ptr = buf;struct kpp_secret secret;
@@ -81,6 +81,24 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params)if (secret.len !=crypto_dh_key_len (params))return -EINVAL ; +/* Don't allocate memory. Set pointers to data within +* the given buffer +*/ + params->key = (void *)ptr; + params->p = (void *)(ptr + params->key_size); + params->g = (void *)(ptr + params->key_size + params->p_size); + +return 0 ; +} + +int crypto_dh_decode_key (const char *buf,unsigned int len,struct dh *params) +{ +int err; + + err =__crypto_dh_decode_key (buf, len, params); +if (err) +return err; +/* * Don't permit the buffer for 'key' or 'g' to be larger than 'p', since * some drivers assume otherwise.
@@ -89,13 +107,6 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params) params->g_size > params->p_size)return -EINVAL ; -/* Don't allocate memory. Set pointers to data within -* the given buffer -*/ - params->key = (void *)ptr; - params->p = (void *)(ptr + params->key_size); - params->g = (void *)(ptr + params->key_size + params->p_size); -/* * Don't permit 'p' to be 0. It's not a prime number, and it's subject * to corner cases such as 'mod 0' being undefined or
include/crypto/dh.h +16 -0
@@ -79,4 +79,20 @@ int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params);*/ int crypto_dh_decode_key (const char *buf,unsigned int len,struct dh *params); +/** +* __crypto_dh_decode_key() - decode a private key without parameter checks +* @buf: Buffer holding a packet key that should be decoded +* @len: Length of the packet private key buffer +* @params: Buffer allocated by the caller that is filled with the +* unpacked DH private key. +* +* Internal function providing the same services as the exported +* crypto_dh_decode_key(), but without any of those basic parameter +* checks conducted by the latter. +* +* Return: -EINVAL if buffer has insufficient size, 0 on success +*/ +int __crypto_dh_decode_key (const char *buf,unsigned int len, +struct dh *params); +#endif
Signature · 1 line
2.26.2
Re: [PATCH v4 05/15] crypto: dh - split out deserialization code from crypto_dh_decode()
Quoted 38 lines · Nicolai Stange
A subsequent commit will introduce "dh" wrapping templates of the form "ffdhe2048(dh)", "ffdhe3072(dh)" and so on in order to provide built-in support for the well-known safe-prime ffdhe group parameters specified in RFC 7919.
Those templates' ->set_secret() will wrap the inner "dh" implementation's ->set_secret() and set the ->p and ->g group parameters as appropriate on the way inwards. More specifically,
- A ffdheXYZ(dh) user would callcrypto_dh_encode()on a struct dh instance having ->p == ->g == NULL as well as ->p_size == ->g_size == 0 and pass the resulting buffer to the outer ->set_secret().
- This outer ->set_secret() would then decode the struct dh viacrypto_dh_decode_key(), set ->p, ->g, ->p_size as well as ->g_size as appropriate for the group in question and encode the struct dh again before passing it further down to the inner "dh"'s ->set_secret().The problem is that
crypto_dh_decode_key()implements some basic checks which would reject parameter sets with ->p_size == 0 and thus, the ffdheXYZ templates' ->set_secret() cannot use it as-is for decoding the passed buffer. As the inner "dh"'s ->set_secret() will eventually conduct said checks on the final parameter set anyway, the outer ->set_secret() really only needs the decoding functionality.Split out the pure struct dh decoding part from
crypto_dh_decode_key()into the new__crypto_dh_decode_key().
__crypto_dh_decode_key()gets defined incrypto/dh_helper.c, but will have to get called fromcrypto/dh.cand thus, its declaration must be somehow made available to the latter. Strictly speaking,__crypto_dh_decode_key()is internal to thedh_genericmodule, yet it would be a bit over the top to introduce a new header like e.g.include/crypto/internal/dh.hcontaining just a single prototype. Add the__crypto_dh_decode_key()declaration toinclude/crypto/dh.hinstead.Provide a proper kernel-doc annotation, even though
__crypto_dh_decode_key()is purposedly not on the function list specified inDocumentation/crypto/api-kpp.rst.
Quoted 6 lines
Signed-off-by Nicolai Stange <[email protected]>--- crypto/dh_helper.c | 27 +++++++++++++++++++-------- include/crypto/dh.h | 16 ++++++++++++++++ 2 files changed, 35 insertions(+), 8 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 6/15 crypto: dh - introduce common code for built-in safe-prime group support
In reply to Nicolai StangeRecent work on NVME in-band authentication support ([1]) needs to invoke the "dh" KPP with the FFDHE safe-prime group parameters as specified in RFC 7919 and generate ephemeral keys suitable for the respective group. By coincidence, the requirements from NIST SP800-56Arev3,
sec. 5.5.2 ("Assurance of Domain-Parameter Validity") basically boil down to disallowing any group parameters not among the approved safe-prime groups specified in either RFC 7919 or RFC 3526 in FIPS mode. Furthermore, SP800-56Arev3 specifies the respective security strength for each of the approved safe-prime groups, which has a direct impact on the minimum key lengths.
In this light, it's desirable to introduce built-in support for the RFC 7919 safe-prime groups to the kernel's DH implementation, provide a SP800-56Arev3 conforming key generation primitive for those and render non-approved group parameters unusable in FIPS mode on the way.
As suggested ([2]) in the course of discussion to previous iterations of this patchset, the built-in support for ffdhe groups would be best made available in the form of templates wrapping the existing "dh" implementation, one for each group specified by RFC 7919: ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh). As these templates differ only in the safe-prime constants they'd configure the inner "dh" transforms with, they can share almost all of their "dh"-wrapping template implementation code.
Introduce this common code to dh_generic. The actual dump of the RFC 7919 safe-prime constants will be deferred to the next patch in order to facilitate review. The ephemeral key generation primitive mentioned above likewise deserves a patch on its own, as does the mechanism by which unapproved groups are rendered unusable in FIPS mode.
Define a struct dh_safe_prime container for specifying the individual templates' associated safe-prime group constants. All ffdheXYZ(dh) template instances will store a pointer to such a dh_safe_prime in their context areas each. Implement the common __dh_safe_prime_create() template instantiation helper. The intention is that the individual ffdheXYZ(dh) crypto_templates' ->create() implementations will simply forward any calls to __dh_safe_prime_create(), passing a suitable dh_safe_prime in addition to the received ->create() arguments. __dh_safe_prime_create() would then create and register a kpp_instance as appropriate, storing the given dh_safe_prime pointer alongside a crypto_kpp_spawn for the inner "dh" kpp_alg in the context area.
As the ffdheXYZ(dh) kpp_instances are supposed to act as proxies to the inner "dh" kpp_alg, make each of their associated crypto_kpp transforms to in turn own an inner "dh" transform, a pointer to which gets stored in the context area. Setup and teardown are getting handled from the outer ->init_tfm() and ->exit_tfm() respectively.
In order to achieve the overall goal and let the ffdheXYZ(dh) kpp_instances configure the inner "dh" transforms with the respective group parameters, make their common ->set_secret(), the new dh_safe_prime_set_secret(), fill in the P and G values before forwarding the call to the inner "dh"'s ->set_secret(). Note that the outer ->set_secret() can obtain the P value associated with the given ffdheXYZ(dh) kpp_instance by means of the dh_safe_prime referenced from the latter's context. The value of G OTOH always equals constant 2 for the safe-prime groups.
Finally, make the remaining two kpp_alg primitives both operating on kpp_requests, i.e. ->generate_public_key() and ->compute_shared_secret(), to merely forward any request to the inner "dh" implementation. However, a kpp_request instance received from the outside cannot get simply passed on as-is, because its associated transform (crypto_kpp_reqtfm()) will have been set to the outer ffdheXYZ(dh) one. In order to handle this, reserve some space in the outer ffdheXYZ(dh) kpp_requests' context areas for in turn storing an inner kpp_request suitable for "dh" each. Make the outer ->generate_public_key() and ->compute_shared_secret() respectively to setup this inner kpp_request by means of the new dh_safe_prime_prepare_dh_req() helper before handing it over to the "dh" implementation for further processing. dh_safe_prime_prepare_dh_req() basically copies the outer kpp_request received from the outside over to the inner one, but installs the inner transform and its own ->complete() proxy callback therein. This completion callback, the new dh_safe_prime_complete_req(), doesn't do anything beyond completing the outer request. Note that there exist some examples in crypto/, which would simply install the completion handler from the outer request at the inner one in similar setups, e.g. seqiv. However, this would mean that the user-provided completion handler won't get called with the address of the outer kpp_request initially submitted and the handler might not be prepared for this. Users could certainly work around this by setting the callback ->data properly, but IMO it's cleaner this way. Furthermore, it might make sense to extend dh_safe_prime_complete_req() in the future and move e.g. those post-computation FIPS checks from the generic "dh" implementation to the ffdheXYZ(dh) templates.
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]
--- crypto/dh.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+)
crypto/dh.c +208 -0
@@ -257,6 +257,214 @@ static struct kpp_alg dh = { }, }; + +struct dh_safe_prime { +unsigned int max_strength; +unsigned int p_size; +const char *p; +}; + +static const char safe_prime_g[] = {2 }; + +struct dh_safe_prime_instance_ctx { +struct crypto_kpp_spawn dh_spawn; +const struct dh_safe_prime *safe_prime; +}; + +struct dh_safe_prime_tfm_ctx { +struct crypto_kpp *dh_tfm; +}; + +static void dh_safe_prime_free_instance (struct kpp_instance *inst) +{ +struct dh_safe_prime_instance_ctx *ctx =kpp_instance_ctx (inst); + +crypto_drop_kpp (&ctx->dh_spawn); +kfree (inst); +} + +static inline struct dh_safe_prime_instance_ctx *dh_safe_prime_instance_ctx ( +struct crypto_kpp *tfm) +{ +return kpp_instance_ctx (kpp_alg_instance (tfm)); +} + +static inline struct kpp_alg *dh_safe_prime_dh_alg ( +struct dh_safe_prime_tfm_ctx *ctx) +{ +return crypto_kpp_alg (ctx->dh_tfm); +} + +static int dh_safe_prime_init_tfm (struct crypto_kpp *tfm) +{ +struct dh_safe_prime_instance_ctx *inst_ctx = +dh_safe_prime_instance_ctx (tfm); +struct dh_safe_prime_tfm_ctx *tfm_ctx =kpp_tfm_ctx (tfm); + + tfm_ctx->dh_tfm =crypto_spawn_kpp (&inst_ctx->dh_spawn); +if (IS_ERR (tfm_ctx->dh_tfm)) +return PTR_ERR (tfm_ctx->dh_tfm); + +return 0 ; +} + +static void dh_safe_prime_exit_tfm (struct crypto_kpp *tfm) +{ +struct dh_safe_prime_tfm_ctx *tfm_ctx =kpp_tfm_ctx (tfm); + +crypto_free_kpp (tfm_ctx->dh_tfm); +} + +static int dh_safe_prime_set_secret (struct crypto_kpp *tfm,const void *buffer, +unsigned int len) +{ +struct dh_safe_prime_instance_ctx *inst_ctx = +dh_safe_prime_instance_ctx (tfm); +struct dh_safe_prime_tfm_ctx *tfm_ctx =kpp_tfm_ctx (tfm); +struct dh params; +void *buf; +unsigned int buf_size; +int err; + + err =__crypto_dh_decode_key (buffer, len, ¶ms); +if (err) +return err; + +if (params.p_size || params.g_size) +return -EINVAL ; + + params.p = inst_ctx->safe_prime->p; + params.p_size = inst_ctx->safe_prime->p_size; + params.g = safe_prime_g; + params.g_size =sizeof (safe_prime_g); + + buf_size =crypto_dh_key_len (¶ms); + buf =kmalloc (buf_size,GFP_KERNEL ); +if (!buf) +return -ENOMEM ; + + err =crypto_dh_encode_key (buf, buf_size, ¶ms); +if (err) + goto out; + + err =crypto_kpp_set_secret (tfm_ctx->dh_tfm, buf, buf_size); +out: +kfree_sensitive (buf); +return err; +} + +static void dh_safe_prime_complete_req (struct crypto_async_request *dh_req, +int err) +{ +struct kpp_request *req = dh_req->data; + +kpp_request_complete (req, err); +} + +static struct kpp_request *dh_safe_prime_prepare_dh_req (struct kpp_request *req) +{ +struct dh_safe_prime_tfm_ctx *tfm_ctx = +kpp_tfm_ctx (crypto_kpp_reqtfm (req)); +struct kpp_request *dh_req =kpp_request_ctx (req); + +kpp_request_set_tfm (dh_req, tfm_ctx->dh_tfm); +kpp_request_set_callback (dh_req, req->base.flags, + dh_safe_prime_complete_req, req); + +kpp_request_set_input (dh_req, req->src, req->src_len); +kpp_request_set_output (dh_req, req->dst, req->dst_len); + +return dh_req; +} + +static int dh_safe_prime_generate_public_key (struct kpp_request *req) +{ +struct kpp_request *dh_req =dh_safe_prime_prepare_dh_req (req); + +return crypto_kpp_generate_public_key (dh_req); +} + +static int dh_safe_prime_compute_shared_secret (struct kpp_request *req) +{ +struct kpp_request *dh_req =dh_safe_prime_prepare_dh_req (req); + +return crypto_kpp_compute_shared_secret (dh_req); +} + +static unsigned int dh_safe_prime_max_size (struct crypto_kpp *tfm) +{ +struct dh_safe_prime_tfm_ctx *tfm_ctx =kpp_tfm_ctx (tfm); + +return crypto_kpp_maxsize (tfm_ctx->dh_tfm); +} + +static int __maybe_unused __dh_safe_prime_create ( +struct crypto_template *tmpl,struct rtattr **tb, +const struct dh_safe_prime *safe_prime) +{ +struct kpp_instance *inst; +struct dh_safe_prime_instance_ctx *ctx; +const char *dh_name; +struct kpp_alg *dh_alg; +u32 mask; +int err; + + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_KPP , &mask); +if (err) +return err; + + dh_name =crypto_attr_alg_name (tb[1 ]); +if (IS_ERR (dh_name)) +return PTR_ERR (dh_name); + + inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL ); +if (!inst) +return -ENOMEM ; + + ctx =kpp_instance_ctx (inst); + + err =crypto_grab_kpp (&ctx->dh_spawn,kpp_crypto_instance (inst), + dh_name,0 , mask); +if (err) + goto err_free_inst; + + err = -EINVAL ; + dh_alg =crypto_spawn_kpp_alg (&ctx->dh_spawn); +if (strcmp (dh_alg->base.cra_name,"dh" )) + goto err_free_inst; + + ctx->safe_prime = safe_prime; + + err =crypto_inst_setname (kpp_crypto_instance (inst), + tmpl->name, &dh_alg->base); +if (err) + goto err_free_inst; + + inst->alg.set_secret = dh_safe_prime_set_secret; + inst->alg.generate_public_key = dh_safe_prime_generate_public_key; + inst->alg.compute_shared_secret = dh_safe_prime_compute_shared_secret; + inst->alg.max_size = dh_safe_prime_max_size; + inst->alg.init = dh_safe_prime_init_tfm; + inst->alg.exit = dh_safe_prime_exit_tfm; + inst->alg.reqsize =sizeof (struct kpp_request ) + dh_alg->reqsize; + inst->alg.base.cra_priority = dh_alg->base.cra_priority; + inst->alg.base.cra_module =THIS_MODULE ; + inst->alg.base.cra_ctxsize =sizeof (struct dh_safe_prime_tfm_ctx ); + + inst->free = dh_safe_prime_free_instance; + + err =kpp_register_instance (tmpl, inst); +if (err) + goto err_free_inst; + +return 0 ; + +err_free_inst: +dh_safe_prime_free_instance (inst); + +return err; +} +static int dh_init (void ) {return crypto_register_kpp (&dh);
Signature · 1 line
2.26.2
Re: [PATCH v4 06/15] crypto: dh - introduce common code for built-in safe-prime group support
Quoted 85 lines · Nicolai Stange
Recent work on NVME in-band authentication support ([1]) needs to invoke the "dh" KPP with the FFDHE safe-prime group parameters as specified in RFC 7919 and generate ephemeral keys suitable for the respective group. By coincidence, the requirements from NIST SP800-56Arev3,
sec. 5.5.2 ("Assurance of Domain-Parameter Validity") basically boil down to disallowing any group parameters not among the approved safe-prime groups specified in either RFC 7919 or RFC 3526 in FIPS mode. Furthermore, SP800-56Arev3 specifies the respective security strength for each of the approved safe-prime groups, which has a direct impact on the minimum key lengths.In this light, it's desirable to introduce built-in support for the RFC 7919 safe-prime groups to the kernel's DH implementation, provide a SP800-56Arev3 conforming key generation primitive for those and render non-approved group parameters unusable in FIPS mode on the way.
As suggested ([2]) in the course of discussion to previous iterations of this patchset, the built-in support for ffdhe groups would be best made available in the form of templates wrapping the existing "dh" implementation, one for each group specified by RFC 7919: ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh). As these templates differ only in the safe-prime constants they'd configure the inner "dh" transforms with, they can share almost all of their "dh"-wrapping template implementation code.
Introduce this common code to
dh_generic. The actual dump of the RFC 7919 safe-prime constants will be deferred to the next patch in order to facilitate review. The ephemeral key generation primitive mentioned above likewise deserves a patch on its own, as does the mechanism by which unapproved groups are rendered unusable in FIPS mode.Define a struct
dh_safe_primecontainer for specifying the individual templates' associated safe-prime group constants. All ffdheXYZ(dh) template instances will store a pointer to such adh_safe_primein their context areas each. Implement the common__dh_safe_prime_create()template instantiation helper. The intention is that the individual ffdheXYZ(dh)crypto_templates' ->create() implementations will simply forward any calls to__dh_safe_prime_create(), passing a suitabledh_safe_primein addition to the received ->create() arguments.__dh_safe_prime_create()would then create and register akpp_instanceas appropriate, storing the givendh_safe_primepointer alongside acrypto_kpp_spawnfor the inner "dh"kpp_algin the context area.As the ffdheXYZ(dh)
kpp_instancesare supposed to act as proxies to the inner "dh"kpp_alg, make each of their associatedcrypto_kpptransforms to in turn own an inner "dh" transform, a pointer to which gets stored in the context area. Setup and teardown are getting handled from the outer ->init_tfm() and ->exit_tfm() respectively.In order to achieve the overall goal and let the ffdheXYZ(dh)
kpp_instancesconfigure the inner "dh" transforms with the respective group parameters, make their common ->set_secret(), the newdh_safe_prime_set_secret(), fill in the P and G values before forwarding the call to the inner "dh"'s ->set_secret(). Note that the outer ->set_secret() can obtain the P value associated with the given ffdheXYZ(dh)kpp_instanceby means of thedh_safe_primereferenced from the latter's context. The value of G OTOH always equals constant 2 for the safe-prime groups.Finally, make the remaining two
kpp_algprimitives both operating onkpp_requests, i.e. ->generate_public_key() and ->compute_shared_secret(), to merely forward any request to the inner "dh" implementation. However, akpp_requestinstance received from the outside cannot get simply passed on as-is, because its associated transform (crypto_kpp_reqtfm()) will have been set to the outer ffdheXYZ(dh) one. In order to handle this, reserve some space in the outer ffdheXYZ(dh)kpp_requests' context areas for in turn storing an innerkpp_requestsuitable for "dh" each. Make the outer ->generate_public_key() and ->compute_shared_secret() respectively to setup this innerkpp_requestby means of the newdh_safe_prime_prepare_dh_req()helper before handing it over to the "dh" implementation for further processing.dh_safe_prime_prepare_dh_req()basically copies the outerkpp_requestreceived from the outside over to the inner one, but installs the inner transform and its own ->complete() proxy callback therein. This completion callback, the newdh_safe_prime_complete_req(), doesn't do anything beyond completing the outer request. Note that there exist some examples incrypto/, which would simply install the completion handler from the outer request at the inner one in similar setups, e.g. seqiv. However, this would mean that the user-provided completion handler won't get called with the address of the outerkpp_requestinitially submitted and the handler might not be prepared for this. Users could certainly work around this by setting the callback ->data properly, but IMO it's cleaner this way. Furthermore, it might make sense to extenddh_safe_prime_complete_req()in the future and move e.g. those post-computation FIPS checks from the generic "dh" implementation to the ffdheXYZ(dh) templates.
Quoted 8 lines
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]Signed-off-by Nicolai Stange <[email protected]>--- crypto/dh.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 7/15 crypto: dh - implement ffdheXYZ(dh) templates
In reply to Nicolai StangeCurrent work on NVME in-band authentication support ([1]) needs to invoke DH with the FFDHE safe-prime group parameters specified in RFC 7919.
Introduce a new CRYPTO_DH_RFC7919_GROUPS Kconfig option. If enabled, make dh_generic register a couple of ffdheXYZ(dh) templates, one for each group:
ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh). Their respective ->set_secret() expects a (serialized) struct dh, just like the underlying "dh" implementation does, but with the P and G values unset so that the safe-prime constants for the given group can be filled in by the wrapping template.
Internally, a struct dh_safe_prime instance is being defined for each of the ffdheXYZ(dh) templates as appropriate. In order to prepare for future key generation, fill in the maximum security strength values as specified by SP800-56Arev3 on the go, even though they're not needed at this point yet.
Implement the respective ffdheXYZ(dh) crypto_template's ->create() by simply forwarding any calls to the __dh_safe_prime_create() helper introduced with the previous commit, passing the associated dh_safe_prime in addition to the received ->create() arguments.
[1] https://lore.kernel.org/r/[email protected]
--- crypto/Kconfig | 6 + crypto/dh.c | 298 ++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 303 insertions(+), 1 deletion(-)
crypto/Kconfig +6 -0
@@ -231,6 +231,12 @@ config CRYPTO_DH help Generic implementation of the Diffie-Hellman algorithm. +config CRYPTO_DH_RFC7919_GROUPS + bool "Support for RFC 7919 FFDHE group parameters" + depends on CRYPTO_DH + help + Provide support for RFC 7919 FFDHE group parameters. If unsure, say N. + config CRYPTO_ECC tristate select CRYPTO_RNG_DEFAULT
crypto/dh.c +297 -1
310 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 07/15] crypto: dh - implement ffdheXYZ(dh) templates
Quoted 22 lines · Nicolai Stange
Current work on NVME in-band authentication support ([1]) needs to invoke DH with the FFDHE safe-prime group parameters specified in RFC 7919.
Introduce a new
CRYPTO_DH_RFC7919_GROUPSKconfigoption. If enabled, makedh_genericregister a couple of ffdheXYZ(dh) templates, one for each group:
ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh). Their respective ->set_secret() expects a (serialized) struct dh, just like the underlying "dh" implementation does, but with the P and G values unset so that the safe-prime constants for the given group can be filled in by the wrapping template.Internally, a struct
dh_safe_primeinstance is being defined for each of the ffdheXYZ(dh) templates as appropriate. In order to prepare for future key generation, fill in the maximum security strength values as specified by SP800-56Arev3 on the go, even though they're not needed at this point yet.Implement the respective ffdheXYZ(dh) crypto_template's ->create() by simply forwarding any calls to the
__dh_safe_prime_create()helper introduced with the previous commit, passing the associateddh_safe_primein addition to the received ->create() arguments.
Quoted 8 lines
[1] https://lore.kernel.org/r/[email protected]
Signed-off-by Nicolai Stange <[email protected]>--- crypto/Kconfig | 6 + crypto/dh.c | 298 ++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 303 insertions(+), 1 deletion(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 8/15 crypto: testmgr - add known answer tests for ffdheXYZ(dh) templates
In reply to Nicolai StangeAdd known answer tests for the ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh) templates introduced with the previous patch to the testmgr. All TVs have been generated with OpenSSL.
--- crypto/testmgr.c | 37 ++ crypto/testmgr.h | 871 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 908 insertions(+)
crypto/testmgr.c +37 -0
@@ -4973,6 +4973,43 @@ static const struct alg_test_desc alg_test_descs[] = { .cipher = __VECS(essiv_aes_cbc_tv_template) } }, { +#if IS_ENABLED(CONFIG_CRYPTO_DH_RFC7919_GROUPS) + .alg = "ffdhe2048(dh)", + .test = alg_test_kpp, + .fips_allowed = 1, + .suite = { + .kpp = __VECS(ffdhe2048_dh_tv_template) + } + }, { + .alg = "ffdhe3072(dh)", + .test = alg_test_kpp, + .fips_allowed = 1, + .suite = { + .kpp = __VECS(ffdhe3072_dh_tv_template) + } + }, { + .alg = "ffdhe4096(dh)", + .test = alg_test_kpp, + .fips_allowed = 1, + .suite = { + .kpp = __VECS(ffdhe4096_dh_tv_template) + } + }, { + .alg = "ffdhe6144(dh)", + .test = alg_test_kpp, + .fips_allowed = 1, + .suite = { + .kpp = __VECS(ffdhe6144_dh_tv_template) + } + }, { + .alg = "ffdhe8192(dh)", + .test = alg_test_kpp, + .fips_allowed = 1, + .suite = { + .kpp = __VECS(ffdhe8192_dh_tv_template) + } + }, { +#endif /* CONFIG_CRYPTO_DH_RFC7919_GROUPS */ .alg = "gcm(aes)", .generic_driver = "gcm_base(ctr(aes-generic),ghash-generic)", .test = alg_test_aead,
crypto/testmgr.h +871 -0
877 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 08/15] crypto: testmgr - add known answer tests for ffdheXYZ(dh) templates
Quoted 10 lines · Nicolai Stange
Add known answer tests for the ffdhe2048(dh), ffdhe3072(dh), ffdhe4096(dh), ffdhe6144(dh) and ffdhe8192(dh) templates introduced with the previous patch to the testmgr. All TVs have been generated with OpenSSL.
Signed-off-by Nicolai Stange <[email protected]>--- crypto/testmgr.c | 37 ++ crypto/testmgr.h | 871 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 908 insertions(+)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 9/15 crypto: dh - implement private key generation primitive for ffdheXYZ(dh)
In reply to Nicolai StangeThe support for NVME in-band authentication currently in the works ([1]) needs to generate ephemeral DH keys for use with the RFC 7919 safe-prime FFDHE groups.
In analogy to ECDH and its ecc_gen_privkey(), implement a dh_safe_prime_gen_privkey() and invoke it from the ffdheXYZ(dh) templates' common ->set_secret(), i.e. dh_safe_prime_set_secret(), in case the input ->key_size is zero.
As the RFC 7919 FFDHE groups are classified as approved safe-prime groups by SP800-56Arev3, it's worthwhile to make the new dh_safe_prime_gen_privkey() to follow the approach specified in SP800-56Arev3, sec. 5.6.1.1.3 ("Key-Pair Generation Using Extra Random Bits") in order to achieve conformance.
SP800-56Arev3 specifies a lower as well as an upper bound on the generated key's length:
- it must be >= two times the maximum supported security strength of the group in question and
- it must be <= the length of the domain parameter Q.
For any safe-prime group Q = (P - 1)/2 by definition and the individual maximum supported security strengths as specified by SP800-56Arev3 have been made available as part of the FFDHE dh_safe_prime definitions introduced with a previous patch. Make dh_safe_prime_gen_privkey() pick twice the maximum supported strength rounded up to the next power of two for the output key size. This choice respects both, the lower and upper bounds given by SP800-90Arev3 for any of the approved safe-prime groups and is also in line with the NVME base spec 2.0, which requires the key size to be >= 256bits.
[1] https://lore.kernel.org/r/[email protected]
--- crypto/Kconfig | 1 + crypto/dh.c | 140 +++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 138 insertions(+), 3 deletions(-)
crypto/Kconfig +1 -0
@@ -234,6 +234,7 @@ config CRYPTO_DH config CRYPTO_DH_RFC7919_GROUPS bool "Support for RFC 7919 FFDHE group parameters" depends on CRYPTO_DH + select CRYPTO_RNG_DEFAULT help Provide support for RFC 7919 FFDHE group parameters. If unsure, say N.
crypto/dh.c +137 -3
172 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 09/15] crypto: dh - implement private key generation primitive for ffdheXYZ(dh)
Quoted 31 lines · Nicolai Stange
The support for NVME in-band authentication currently in the works ([1]) needs to generate ephemeral DH keys for use with the RFC 7919 safe-prime FFDHE groups.
In analogy to ECDH and its
ecc_gen_privkey(), implement adh_safe_prime_gen_privkey()and invoke it from the ffdheXYZ(dh) templates' common ->set_secret(), i.e.dh_safe_prime_set_secret(), in case the input ->key_size is zero.As the RFC 7919 FFDHE groups are classified as approved safe-prime groups by SP800-56Arev3, it's worthwhile to make the new
dh_safe_prime_gen_privkey()to follow the approach specified in SP800-56Arev3, sec. 5.6.1.1.3 ("Key-Pair Generation Using Extra Random Bits") in order to achieve conformance.SP800-56Arev3 specifies a lower as well as an upper bound on the generated key's length:
- it must be >= two times the maximum supported security strength of the group in question and
- it must be <= the length of the domain parameter Q.For any safe-prime group Q = (P - 1)/2 by definition and the individual maximum supported security strengths as specified by SP800-56Arev3 have been made available as part of the FFDHE
dh_safe_primedefinitions introduced with a previous patch. Makedh_safe_prime_gen_privkey()pick twice the maximum supported strength rounded up to the next power of two for the output key size. This choice respects both, the lower and upper bounds given by SP800-90Arev3 for any of the approved safe-prime groups and is also in line with the NVME base spec 2.0, which requires the key size to be >= 256bits.
Quoted 8 lines
[1] https://lore.kernel.org/r/[email protected]
Signed-off-by Nicolai Stange <[email protected]>--- crypto/Kconfig | 1 + crypto/dh.c | 140 +++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 138 insertions(+), 3 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 10/15 crypto: testmgr - add keygen tests for ffdheXYZ(dh) templates
In reply to Nicolai StangeNow that the ffdheXYZ(dh) templates support ephemeral key generation, add ->keygen = 1 TVs for each of them to the testmgr.c.
In order to facilitate string merging by the compiler, set party B's secret and public keys to the ones specified for party A in the respective existing known answer test. With GCC 7.5 on x86_64, this leads to an increase of testmgr.o size by less than half a kB.
--- crypto/testmgr.h | 578 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 568 insertions(+), 10 deletions(-)
crypto/testmgr.h +568 -10
@@ -1547,6 +1547,76 @@ static const struct kpp_testvec ffdhe2048_dh_tv_template[] __maybe_unused = { .expected_a_public_size = 256, .expected_ss_size = 256, }, + { + .secret = +#ifdef __LITTLE_ENDIAN +"\x01\x00" /* type */ +"\x10\x00" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#else +"\x00\x01" /* type */ +"\x00\x10" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#endif + .b_secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x10\x01" /* len */ + "\x00\x01\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#else +"\x00\x01" /* type */ +"\x01\x10" /* len */ +"\x00\x00\x01\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#endif +/* xa */ +"\x23\x7d\xd0\x06\xfd\x7a\xe5\x7a\x08\xda\x98\x31\xc0\xb3\xd5\x85" +"\xe2\x0d\x2a\x91\x5f\x78\x4b\xa6\x62\xd0\xa6\x35\xd4\xef\x86\x39" +"\xf1\xdb\x71\x5e\xb0\x11\x2e\xee\x91\x3a\xaa\xf9\xe3\xdf\x8d\x8b" +"\x48\x41\xde\xe8\x78\x53\xc5\x5f\x93\xd2\x79\x0d\xbe\x8d\x83\xe8" +"\x8f\x00\xd2\xde\x13\x18\x04\x05\x20\x6d\xda\xfa\x1d\x0b\x24\x52" +"\x3a\x18\x2b\xe1\x1e\xae\x15\x3b\x0f\xaa\x09\x09\xf6\x01\x98\xe9" +"\x81\x5d\x6b\x83\x6e\x55\xf1\x5d\x6f\x6f\x0d\x9d\xa8\x72\x32\x63" +"\x60\xe6\x0b\xc5\x22\xe2\xf9\x46\x58\xa2\x1c\x2a\xb0\xd5\xaf\xe3" +"\x5b\x03\xb7\x36\xb7\xba\x55\x20\x08\x7c\x51\xd4\x89\x42\x9c\x14" +"\x23\xe2\x71\x3e\x15\x2a\x0d\x34\x8a\xde\xad\x84\x11\x15\x72\x18" +"\x42\x43\x0a\xe2\x58\x29\xb3\x90\x0f\x56\xd8\x8a\x0f\x0e\xbc\x0e" +"\x9c\xe7\xd5\xe6\x5b\xbf\x06\x64\x38\x12\xa5\x8d\x5b\x68\x34\xdd" +"\x75\x48\xc9\xa7\xa3\x58\x5a\x1c\xe1\xb2\xc5\xe3\x39\x03\xcf\xab" +"\xc2\x14\x07\xaf\x55\x80\xc7\x63\xe4\x03\xeb\xe9\x0a\x25\x61\x85" +"\x1d\x0e\x81\x52\x7b\xbc\x4a\x0c\xc8\x59\x6a\xac\x18\xfb\x8c\x0c" + "\xb4\x79\xbd\xa1\x4c\xbb\x02\xc9\xd5\x13\x88\x3d\x25\xaa\x77\x49", + .b_public = +"\x8b\xdb\xc1\xf7\xc6\xba\xa1\x38\x95\x6a\xa1\xb6\x04\x5e\xae\x52" +"\x72\xfc\xef\x2d\x9d\x71\x05\x9c\xd3\x02\xa9\xfb\x55\x0f\xfa\xc9" +"\xb4\x34\x51\xa3\x28\x89\x8d\x93\x92\xcb\xd9\xb5\xb9\x66\xfc\x67" +"\x15\x92\x6f\x73\x85\x15\xe2\xfc\x11\x6b\x97\x8c\x4b\x0f\x12\xfa" +"\x8d\x72\x76\x9b\x8f\x3b\xfe\x31\xbe\x42\x88\x4c\xd2\xb2\x70\xa6" +"\xa5\xe3\x7e\x73\x07\x12\x36\xaa\xc9\x5c\x83\xe1\xf1\x46\x41\x4f" +"\x7c\x52\xaf\xdc\xa4\xe6\x82\xa3\x86\x83\x47\x5a\x12\x3a\x0c\xe3" +"\xdd\xdb\x94\x03\x2a\x59\x91\xa0\x19\xe5\xf8\x07\xdd\x54\x6a\x22" +"\x43\xb7\xf3\x74\xd7\xb9\x30\xfe\x9c\xe8\xd1\xcf\x06\x43\x68\xb9" +"\x54\x8f\x54\xa2\xe5\x3c\xf2\xc3\x4c\xee\xd4\x7c\x5d\x0e\xb1\x7b" +"\x16\x68\xb5\xb3\x7d\xd4\x11\x83\x5c\x77\x17\xc4\xf0\x59\x76\x7a" +"\x83\x40\xe5\xd9\x4c\x76\x23\x5b\x17\x6d\xee\x4a\x92\x68\x4b\x89" +"\xa0\x6d\x23\x8c\x80\x31\x33\x3a\x12\xf4\x50\xa6\xcb\x13\x97\x01" +"\xb8\x2c\xe6\xd2\x38\xdf\xd0\x7f\xc6\x27\x19\x0e\xb2\x07\xfd\x1f" +"\x1b\x9c\x1b\x87\xf9\x73\x6a\x3f\x7f\xb0\xf9\x2f\x3c\x19\x9f\xc9" + "\x8f\x97\x21\x0e\x8e\xbb\x1a\x17\x20\x15\xdd\xc6\x42\x60\xae\x4d", + .secret_size = 16, + .b_secret_size = 272, + .b_public_size = 256, + .expected_a_public_size = 256, + .expected_ss_size = 256, + .genkey = true, + }, }; static const struct kpp_testvec ffdhe3072_dh_tv_template[] __maybe_unused = {
@@ -1670,6 +1740,92 @@ static const struct kpp_testvec ffdhe3072_dh_tv_template[] __maybe_unused = { .expected_a_public_size = 384, .expected_ss_size = 384, }, + { + .secret = +#ifdef __LITTLE_ENDIAN +"\x01\x00" /* type */ +"\x10\x00" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#else +"\x00\x01" /* type */ +"\x00\x10" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#endif + .b_secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x90\x01" /* len */ + "\x80\x01\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#else +"\x00\x01" /* type */ +"\x01\x90" /* len */ +"\x00\x00\x01\x80" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#endif +/* xa */ +"\x6b\xb4\x97\x23\xfa\xc8\x5e\xa9\x7b\x63\xe7\x3e\x0e\x99\xc3\xb9" +"\xda\xb7\x48\x0d\xc3\xb1\xbf\x4f\x17\xc7\xa9\x51\xf6\x64\xff\xc4" +"\x31\x58\x87\x25\x83\x2c\x00\xf0\x41\x29\xf7\xee\xf9\xe6\x36\x76" +"\xd6\x3a\x24\xbe\xa7\x07\x0b\x93\xc7\x9f\x6c\x75\x0a\x26\x75\x76" +"\xe3\x0c\x42\xe0\x00\x04\x69\xd9\xec\x0b\x59\x54\x28\x8f\xd7\x9a" +"\x63\xf4\x5b\xdf\x85\x65\xc4\xe1\x95\x27\x4a\x42\xad\x36\x47\xa9" +"\x0a\xf8\x14\x1c\xf3\x94\x3b\x7e\x47\x99\x35\xa8\x18\xec\x70\x10" +"\xdf\xcb\xd2\x78\x88\xc1\x2d\x59\x93\xc1\xa4\x6d\xd7\x1d\xb9\xd5" +"\xf8\x30\x06\x7f\x98\x90\x0c\x74\x5e\x89\x2f\x64\x5a\xad\x5f\x53" +"\xb2\xa3\xa8\x83\xbf\xfc\x37\xef\xb8\x36\x0a\x5c\x62\x81\x64\x74" +"\x16\x2f\x45\x39\x2a\x91\x26\x87\xc0\x12\xcc\x75\x11\xa3\xa1\xc5" +"\xae\x20\xcf\xcb\x20\x25\x6b\x7a\x31\x93\x9d\x38\xb9\x57\x72\x46" +"\xd4\x84\x65\x87\xf1\xb5\xd3\xab\xfc\xc3\x4d\x40\x92\x94\x1e\xcd" +"\x1c\x87\xec\x3f\xcd\xbe\xd0\x95\x6b\x40\x02\xdd\x62\xeb\x0a\xda" +"\x4f\xbe\x8e\x32\x48\x8b\x6d\x83\xa0\x96\x62\x23\xec\x83\x91\x44" +"\xf9\x72\x01\xac\xa0\xe4\x72\x1d\x5a\x75\x05\x57\x90\xae\x7e\xb4" +"\x71\x39\x01\x05\xdc\xe9\xee\xcb\xf0\x61\x28\x91\x69\x8c\x31\x03" +"\x7a\x92\x15\xa1\x58\x67\x3d\x70\x82\xa6\x2c\xfe\x10\x56\x58\xd3" +"\x94\x67\xe1\xbe\xee\xc1\x64\x5c\x4b\xc8\x28\x3d\xc5\x66\x3a\xab" +"\x22\xc1\x7e\xa1\xbb\xf3\x19\x3b\xda\x46\x82\x45\xd4\x3c\x7c\xc6" +"\xce\x1f\x7f\x95\xa2\x17\xff\x88\xba\xd6\x4d\xdb\xd2\xea\xde\x39" +"\xd6\xa5\x18\x73\xbb\x64\x6e\x79\xe9\xdc\x3f\x92\x7f\xda\x1f\x49" +"\x33\x70\x65\x73\xa2\xd9\x06\xb8\x1b\x29\x29\x1a\xe0\xa3\xe6\x05" + "\x9a\xa8\xc2\x4e\x7a\x78\x1d\x22\x57\x21\xc8\xa3\x8d\x66\x3e\x23", + .b_public = +"\x1b\x6a\xba\xea\xa3\xcc\x50\x69\xa9\x41\x89\xaf\x04\xe1\x44\x22" +"\x97\x20\xd1\xf6\x1e\xcb\x64\x36\x6f\xee\x0b\x16\xc1\xd9\x91\xbe" +"\x57\xc8\xd9\xf2\xa1\x96\x91\xec\x41\xc7\x79\x00\x1a\x48\x25\x55" +"\xbe\xf3\x20\x8c\x38\xc6\x7b\xf2\x8b\x5a\xc3\xb5\x87\x0a\x86\x3d" +"\xb7\xd6\xce\xb0\x96\x2e\x5d\xc4\x00\x5e\x42\xe4\xe5\x50\x4f\xb8" +"\x6f\x18\xa4\xe1\xd3\x20\xfc\x3c\xf5\x0a\xff\x23\xa6\x5b\xb4\x17" +"\x3e\x7b\xdf\xb9\xb5\x3c\x1b\x76\x29\xcd\xb4\x46\x4f\x27\x8f\xd2" +"\xe8\x27\x66\xdb\xe8\xb3\xf5\xe1\xd0\x04\xcd\x89\xff\xba\x76\x67" +"\xe8\x4d\xcf\x86\x1c\x8a\xd1\xcf\x99\x27\xfb\xa9\x78\xcc\x94\xaf" +"\x3d\x04\xfd\x25\xc0\x47\xfa\x29\x80\x05\xf4\xde\xad\xdb\xab\x12" +"\xb0\x2b\x8e\xca\x02\x06\x6d\xad\x3e\x09\xb1\x22\xa3\xf5\x4c\x6d" +"\x69\x99\x58\x8b\xd8\x45\x2e\xe0\xc9\x3c\xf7\x92\xce\x21\x90\x6b" +"\x3b\x65\x9f\x64\x79\x8d\x67\x22\x1a\x37\xd3\xee\x51\xe2\xe7\x5a" +"\x93\x51\xaa\x3c\x4b\x04\x16\x32\xef\xe3\x66\xbe\x18\x94\x88\x64" +"\x79\xce\x06\x3f\xb8\xd6\xee\xdc\x13\x79\x6f\x20\x14\xc2\x6b\xce" +"\xc8\xda\x42\xa5\x93\x5b\xe4\x7f\x1a\xe6\xda\x0f\xb3\xc1\x5f\x30" +"\x50\x76\xe8\x37\x3d\xca\x77\x2c\xa8\xe4\x3b\xf9\x6f\xe0\x17\xed" +"\x0e\xef\xb7\x31\x14\xb5\xea\xd9\x39\x22\x89\xb6\x40\x57\xcc\x84" +"\xef\x73\xa7\xe9\x27\x21\x85\x89\xfa\xaf\x03\xda\x9c\x8b\xfd\x52" +"\x7d\xb0\xa4\xe4\xf9\xd8\x90\x55\xc4\x39\xd6\x9d\xaf\x3b\xce\xac" +"\xaa\x36\x14\x7a\x9b\x8b\x12\x43\xe1\xca\x61\xae\x46\x5b\xe7\xe5" +"\x88\x32\x80\xa0\x2d\x51\xbb\x2f\xea\xeb\x3c\x71\xb2\xae\xce\xca" +"\x61\xd2\x76\xe0\x45\x46\x78\x4e\x09\x2d\xc2\x54\xc2\xa9\xc7\xa8" + "\x55\x8e\x72\xa4\x8b\x8a\xc9\x01\xdb\xe9\x58\x11\xa1\xc4\xe7\x12", + .secret_size = 16, + .b_secret_size = 400, + .b_public_size = 384, + .expected_a_public_size = 384, + .expected_ss_size = 384, + .genkey = true, + }, }; static const struct kpp_testvec ffdhe4096_dh_tv_template[] __maybe_unused = {
@@ -1825,6 +1981,108 @@ static const struct kpp_testvec ffdhe4096_dh_tv_template[] __maybe_unused = { .expected_a_public_size = 512, .expected_ss_size = 512, }, + { + .secret = +#ifdef __LITTLE_ENDIAN +"\x01\x00" /* type */ +"\x10\x00" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#else +"\x00\x01" /* type */ +"\x00\x10" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#endif + .b_secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x10\x02" /* len */ + "\x00\x02\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#else +"\x00\x01" /* type */ +"\x02\x10" /* len */ +"\x00\x00\x02\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#endif +/* xa */ +"\x1a\x48\xf3\x6c\x61\x03\x42\x43\xd7\x42\x3b\xfa\xdb\x55\x6f\xa2" +"\xe1\x79\x52\x0b\x47\xc5\x03\x60\x2f\x26\xb9\x1a\x14\x15\x1a\xd9" +"\xe0\xbb\xa7\x82\x63\x41\xec\x26\x55\x00\xab\xe5\x21\x9d\x31\x14" +"\x0e\xe2\xc2\xb2\xb8\x37\xe6\xc3\x5a\xab\xae\x25\xdb\x71\x1e\xed" +"\xe8\x75\x9a\x04\xa7\x92\x2a\x99\x7e\xc0\x5b\x64\x75\x7f\xe5\xb5" +"\xdb\x6c\x95\x4f\xe9\xdc\x39\x76\x79\xb0\xf7\x00\x30\x8e\x86\xe7" +"\x36\xd1\xd2\x0c\x68\x7b\x94\xe9\x91\x85\x08\x86\xbc\x64\x87\xd2" +"\xf5\x5b\xaf\x03\xf6\x5f\x28\x25\xf1\xa3\x20\x5c\x1b\xb5\x26\x45" +"\x9a\x47\xab\xd6\xad\x49\xab\x92\x8e\x62\x6f\x48\x31\xea\xf6\x76" +"\xff\xa2\xb6\x28\x78\xef\x59\xc3\x71\x5d\xa8\xd9\x70\x89\xcc\xe2" +"\x63\x58\x5e\x3a\xa2\xa2\x88\xbf\x77\x20\x84\x33\x65\x64\x4e\x73" +"\xe5\x08\xd5\x89\x23\xd6\x07\xac\x29\x65\x2e\x02\xa8\x35\x96\x48" +"\xe7\x5d\x43\x6a\x42\xcc\xda\x98\xc4\x75\x90\x2e\xf6\xc4\xbf\xd4" +"\xbc\x31\x14\x0d\x54\x30\x11\xb2\xc9\xcf\xbb\xba\xbc\xc6\xf2\xcf" +"\xfe\x4a\x9d\xf3\xec\x78\x5d\x5d\xb4\x99\xd0\x67\x0f\x5a\x21\x1c" +"\x7b\x95\x2b\xcf\x49\x44\x94\x05\x1a\x21\x81\x25\x7f\xe3\x8a\x2a" +"\xdd\x88\xac\x44\x94\x23\x20\x3b\x75\xf6\x2a\x8a\x45\xf8\xb5\x1f" +"\xb9\x8b\xeb\xab\x9b\x38\x23\x26\xf1\x0f\x34\x47\x4f\x7f\xe1\x9e" +"\x84\x84\x78\xe5\xe3\x49\xeb\xcc\x2f\x02\x85\xa4\x18\x91\xde\x1a" +"\x60\x54\x33\x81\xd5\xae\xdb\x23\x9c\x4d\xa4\xdb\x22\x5b\xdf\xf4" +"\x8e\x05\x2b\x60\xba\xe8\x75\xfc\x34\x99\xcf\x35\xe1\x06\xba\xdc" +"\x79\x2a\x5e\xec\x1c\xbe\x79\x33\x63\x1c\xe7\x5f\x1e\x30\xd6\x1b" +"\xdb\x11\xb8\xea\x63\xff\xfe\x1a\x3c\x24\xf4\x78\x9c\xcc\x5d\x9a" +"\xc9\x2d\xc4\x9a\xd4\xa7\x65\x84\x98\xdb\x66\x76\xf0\x34\x31\x9f" +"\xce\xb5\xfb\x28\x07\xde\x1e\x0d\x9b\x01\x64\xeb\x2a\x37\x2f\x20" +"\xa5\x95\x72\x2b\x54\x51\x59\x91\xea\x50\x54\x0f\x2e\xb0\x1d\xf6" +"\xb9\x46\x43\xf9\xd0\x13\x21\x20\x47\x61\x1a\x1c\x30\xc6\x9e\x75" +"\x22\xe4\xf2\xb1\xab\x01\xdc\x5b\x3c\x1e\xa2\x6d\xc0\xb9\x9a\x2a" +"\x84\x61\xea\x85\x63\xa0\x77\xd0\xeb\x20\x68\xd5\x95\x6a\x1b\x8f" +"\x1f\x9a\xba\x44\x49\x8c\x77\xa6\xd9\xa0\x14\xf8\x7d\x9b\x4e\xfa" +"\xdc\x4f\x1c\x4d\x60\x50\x26\x7f\xd6\xc1\x91\x2b\xa6\x37\x5d\x94" + "\x69\xb2\x47\x59\xd6\xc3\x59\xbb\xd6\x9b\x71\x52\x85\x7a\xcb\x2d", + .b_public = +"\x1f\xff\xd6\xc4\x59\xf3\x4a\x9e\x81\x74\x4d\x27\xa7\xc6\x6b\x35" +"\xd8\xf5\xb3\x24\x97\x82\xe7\x2e\xf3\x21\x91\x23\x2f\x3d\x57\x7f" +"\x15\x8c\x84\x71\xe7\x25\x35\xe8\x07\x14\x06\x4c\x83\xdc\x55\x4a" +"\xf8\x45\xc5\xe9\xfa\x6e\xae\x6e\xcf\x4d\x11\x91\x26\x16\x6f\x86" +"\x89\x78\xaa\xb4\x25\x54\xb2\x74\x07\xe5\x26\x26\x0c\xad\xa4\x57" +"\x59\x61\x66\x71\x43\x22\xff\x49\x51\xa4\x76\x0e\x55\x7b\x60\x45" +"\x4f\xaf\xbd\x9c\xec\x64\x3f\x80\x0b\x0c\x31\x41\xf0\xfe\x2c\xb7" +"\x0a\xbe\xa5\x71\x08\x0d\x8d\x1e\x8a\x77\x9a\xd2\x90\x31\x96\xd0" +"\x3b\x31\xdc\xc6\x18\x59\x43\xa1\x19\x5a\x84\x68\x29\xad\x5e\x58" +"\xa2\x50\x3e\x83\xf5\x7a\xbd\x88\x17\x60\x89\x98\x9c\x19\x89\x27" +"\x89\xfc\x33\x87\x42\xd5\xde\x19\x14\xf2\x95\x82\x10\x87\xad\x82" +"\xdd\x6b\x51\x2d\x8d\x0e\x81\x4b\xde\xb3\x35\x6c\x0f\x4b\x56\x45" +"\x48\x87\xe9\x5a\xf9\x70\x10\x30\x8e\xa1\xbb\xa4\x70\xbf\xa0\xab" +"\x10\x31\x3c\x2c\xdc\xc4\xed\xe3\x51\xdc\xee\xd2\xa5\x5c\x4e\x6e" +"\xf6\xed\x60\x5a\xeb\xf3\x02\x19\x2a\x95\xe9\x46\xff\x37\x1b\xf0" +"\x1d\x10\x4a\x8f\x4f\x3a\x6e\xf5\xfc\x02\x6d\x09\x7d\xea\x69\x7b" +"\x13\xb0\xb6\x80\x5c\x15\x20\xa8\x4d\x15\x56\x11\x72\x49\xdb\x48" +"\x54\x40\x66\xd5\xcd\x17\x3a\x26\x95\xf6\xd7\xf2\x59\xa3\xda\xbb" +"\x26\xd0\xe5\x46\xbf\xee\x0e\x7d\xf1\xe0\x11\x02\x4d\xd3\xdc\xe2" +"\x3f\xc2\x51\x7e\xc7\x90\x33\x3c\x1c\xa0\x4c\x69\xcc\x1e\xc7\xac" +"\x17\xe0\xe5\xf4\x8c\x05\x64\x34\xfe\x84\x70\xd7\x6b\xed\xab\xf5" +"\x88\x9d\x3e\x4c\x5a\x9e\xd4\x74\xfd\xdd\x91\xd5\xd4\xcb\xbf\xf8" +"\xb7\x56\xb5\xe9\x22\xa6\x6d\x7a\x44\x05\x41\xbf\xdb\x61\x28\xc6" +"\x99\x49\x87\x3d\x28\x77\xf8\x83\x23\x7e\xa9\xa7\xee\x20\xdb\x6d" +"\x21\x50\xb7\xc9\x52\x57\x53\xa3\xcf\xdf\xd0\xf9\xb9\x62\x96\x89" +"\xf5\x5c\xa9\x8a\x11\x95\x01\x25\xc9\x81\x15\x76\xae\xf0\xc7\xc5" +"\x50\xae\x6f\xb5\xd2\x8a\x8e\x9a\xd4\x30\x55\xc6\xe9\x2c\x81\x6e" +"\x95\xf6\x45\x89\x55\x28\x34\x7b\xe5\x72\x9a\x2a\xe2\x98\x09\x35" +"\xe0\xe9\x75\x94\xe9\x34\x95\xb9\x13\x6e\xd5\xa1\x62\x5a\x1c\x94" +"\x28\xed\x84\x46\x76\x6d\x10\x37\x71\xa3\x31\x46\x64\xe4\x59\x44" +"\x17\x70\x1c\x23\xc9\x7e\xf6\xab\x8a\x24\xae\x25\xe2\xb2\x5f\x33" + "\xe4\xd7\xd3\x34\x2a\x49\x22\x16\x15\x9b\x90\x40\xda\x99\xd5\xaf", + .secret_size = 16, + .b_secret_size = 528, + .b_public_size = 512, + .expected_a_public_size = 512, + .expected_ss_size = 512, + .genkey = true, + }, }; static const struct kpp_testvec ffdhe6144_dh_tv_template[] __maybe_unused = {
@@ -2044,28 +2302,162 @@ static const struct kpp_testvec ffdhe6144_dh_tv_template[] __maybe_unused = { .expected_a_public_size = 768, .expected_ss_size = 768, }, -}; - -static const struct kpp_testvec ffdhe8192_dh_tv_template[]__maybe_unused = { { .secret = #ifdef __LITTLE_ENDIAN "\x01\x00" /* type */ - "\x10\x04" /* len */ - "\x00\x04\x00\x00" /* key_size */ + "\x10\x00" /* len */ + "\x00\x00\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00", /* g_size */ +#else + "\x00\x01" /* type */ + "\x00\x10" /* len */ + "\x00\x00\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00", /* g_size */ +#endif + .b_secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x10\x03" /* len */ + "\x00\x03\x00\x00" /* key_size */ "\x00\x00\x00\x00" /* p_size */ "\x00\x00\x00\x00" /* g_size */ #else "\x00\x01" /* type */ - "\x04\x10" /* len */ - "\x00\x00\x04\x00" /* key_size */ + "\x03\x10" /* len */ + "\x00\x00\x03\x00" /* key_size */ "\x00\x00\x00\x00" /* p_size */ "\x00\x00\x00\x00" /* g_size */ #endif /* xa */ -"\x76\x6e\xeb\xf9\xeb\x76\xae\x37\xcb\x19\x49\x8b\xeb\xaf\xb0\x4b" -"\x6d\xe9\x15\xad\xda\xf2\xef\x58\xe9\xd6\xdd\x4c\xb3\x56\xd0\x3b" -"\x00\xb0\x65\xed\xae\xe0\x2e\xdf\x8f\x45\x3f\x3c\x5d\x2f\xfa\x96" + "\x63\x3e\x6f\xe0\xfe\x9f\x4a\x01\x62\x77\xce\xf1\xc7\xcc\x49\x4d" + "\x92\x53\x56\xe3\x39\x15\x81\xb2\xcd\xdc\xaf\x5e\xbf\x31\x1f\x69" + "\xce\x41\x35\x24\xaa\x46\x53\xb5\xb7\x3f\x2b\xad\x95\x14\xfb\xe4" + "\x9a\x61\xcd\x0f\x1f\x02\xee\xa4\x79\x2c\x9d\x1a\x7c\x62\x82\x39" + "\xdd\x43\xcc\x58\x9f\x62\x47\x56\x1d\x0f\xc2\x67\xbc\x24\xd0\xf9" + "\x0a\x50\x1b\x10\xe7\xbb\xd1\xc2\x01\xbb\xc4\x4c\xda\x12\x60\x0e" + "\x95\x2b\xde\x09\xd6\x67\xe1\xbc\x4c\xb9\x67\xdf\xd0\x1f\x97\xb4" + "\xde\xcb\x6b\x78\x83\x51\x74\x33\x01\x7f\xf6\x0a\x95\x69\x93\x00" + "\x2a\xc3\x75\x8e\xef\xbe\x53\x11\x6d\xc4\xd0\x9f\x6d\x63\x48\xc1" + "\x91\x1f\x7d\x88\xa7\x90\x78\xd1\x7e\x52\x42\x10\x01\xb4\x27\x95" + "\x91\x43\xcc\x82\x91\x86\x62\xa0\x9d\xef\x65\x6e\x67\xcf\x19\x11" + "\x35\x37\x5e\x94\x97\x83\xa6\x83\x1c\x7e\x8a\x3e\x32\xb0\xce\xff" + "\x20\xdc\x7b\x6e\x18\xd9\x6b\x27\x31\xfc\xc3\xef\x47\x8d\xbe\x34" + "\x2b\xc7\x60\x74\x3c\x93\xb3\x8e\x54\x77\x4e\x73\xe6\x40\x72\x35" + "\xb0\xf0\x06\x53\x43\xbe\xd0\xc3\x87\xcc\x38\x96\xa9\x10\xa0\xd6" + "\x17\xed\xa5\x6a\xf4\xf6\xaa\x77\x40\xed\x7d\x2e\x58\x0f\x5b\x04" + "\x5a\x41\x12\x95\x22\xcb\xa3\xce\x8b\x6d\x6d\x89\xec\x7c\x1d\x25" + "\x27\x52\x50\xa0\x5b\x93\x8c\x5d\x3f\x56\xb9\xa6\x5e\xe5\xf7\x9b" + "\xc7\x9a\x4a\x2e\x79\xb5\xca\x29\x58\x52\xa0\x63\xe4\x9d\xeb\x4c" + "\x4c\xa8\x37\x0b\xe9\xa0\x18\xf1\x86\xf6\x4d\x32\xfb\x9e\x4f\xb3" + "\x7b\x5d\x58\x78\x70\xbd\x56\xac\x99\x75\x25\x71\x66\x76\x4e\x5e" + "\x67\x4f\xb1\x17\xa7\x8b\x55\x12\x87\x01\x4e\xd1\x66\xef\xd0\x70" + "\xaf\x14\x34\xee\x2a\x76\x49\x25\xa6\x2e\x43\x37\x75\x7d\x1a\xad" + "\x08\xd5\x01\x85\x9c\xe1\x20\xd8\x38\x5c\x57\xa5\xed\x9d\x46\x3a" + "\xb7\x46\x60\x29\x8b\xc4\x21\x50\x0a\x30\x9c\x57\x42\xe4\x35\xf8" + "\x12\x5c\x4f\xa2\x20\xc2\xc9\x43\xe3\x6d\x20\xbc\xdf\xb8\x37\x33" + "\x45\x43\x06\x4e\x08\x6f\x8a\xcd\x61\xc3\x1b\x05\x28\x82\xbe\xf0" + "\x48\x33\xe5\x93\xc9\x1a\x61\x16\x67\x03\x9d\x47\x9d\x74\xeb\xae" + "\x13\xf2\xb4\x1b\x09\x11\xf5\x15\xcb\x28\xfd\x50\xe0\xbc\x58\x36" + "\x38\x91\x2c\x07\x27\x1f\x49\x68\xf4\xce\xad\xf7\xba\xec\x5d\x3d" + "\xfd\x27\xe2\xcf\xf4\x56\xfe\x08\xa6\x11\x61\xcb\x6c\x9f\xf9\x3c" + "\x57\x0b\x8b\xaa\x00\x16\x18\xba\x1f\xe8\x4f\x01\xe2\x79\x2a\x0b" + "\xc1\xbd\x52\xef\xe6\xf7\x5a\x66\xfe\x07\x3b\x50\x6b\xbb\xcb\x39" + "\x3c\x94\xf6\x21\x0d\x68\x69\xa4\xed\x2e\xb5\x85\x03\x11\x38\x79" + "\xec\xb5\x22\x23\xdf\x9e\xad\xb4\xbe\xd7\xc7\xdf\xea\x30\x23\x8a" + "\xb7\x21\x0a\x9d\xbd\x99\x13\x7d\x5f\x7e\xaf\x28\x54\x3f\xca\x5e" + "\xf4\xfc\x05\x0d\x65\x67\xd8\xf6\x8e\x90\x9d\x0d\xcf\x62\x82\xd6" + "\x9f\x02\xf8\xca\xfa\x42\x24\x7f\x4d\xb7\xfc\x92\xa6\x4a\x51\xc4" + "\xd8\xae\x19\x87\xc6\xa3\x83\xbe\x7b\x6d\xc3\xf5\xb8\xad\x4a\x05" + "\x78\x84\x3a\x15\x2e\x40\xbe\x79\xa9\xc0\x12\xa1\x48\x39\xc3\xdb" + "\x47\x4f\x7d\xea\x6d\xc7\xfa\x2c\x4e\xe9\xa5\x85\x81\xea\x6c\xcd" + "\x8a\xe5\x74\x17\x76\x31\x31\x75\x96\x83\xca\x81\xbb\x5c\xa9\x79" + "\x2c\xbd\x09\xfe\xe4\x86\x0d\x8c\x76\x9c\xbc\xe8\x93\xe4\xd0\xe4" + "\x0f\xf8\xff\x24\x7e\x66\x61\x69\xfb\xe4\x46\x08\x94\x99\xa5\x53" + "\xd7\xe4\x29\x72\x86\x86\xe8\x1d\x37\xfa\xcb\xd0\x8d\x51\xd0\xbf" + "\x81\xcf\x55\xb9\xc5\x78\x8c\x74\xa0\x16\x3a\xd2\x19\x94\x29\x6a" + "\x5e\xec\xd3\x20\xa0\xb2\xfd\xce\xd4\x14\xa3\x39\x10\xa9\xf4\x4e" + "\xba\x21\x09\x5c\xe6\x61\x43\x51\xae\xc4\x71\xd7\x21\xef\x98\x39", + .b_public = + "\x45\x96\x5a\xb7\x78\x5c\xa4\x4d\x39\xb2\x5f\xc8\xc2\xaa\x1a\xf4" + "\xa6\x68\xf6\x6f\x7e\xa8\x4a\x5b\x0e\xba\x0a\x99\x85\xf9\x63\xd4" + "\x58\x21\x6d\xa8\x3c\xf4\x05\x10\xb0\x0d\x6f\x1c\xa0\x17\x85\xae" + "\x68\xbf\xcc\x00\xc8\x86\x1b\x24\x31\xc9\x49\x23\x91\xe0\x71\x29" + "\x06\x39\x39\x93\x49\x9c\x75\x18\x1a\x8b\x61\x73\x1c\x7f\x37\xd5" + "\xf1\xab\x20\x5e\x62\x25\xeb\x58\xd5\xfa\xc9\x7f\xad\x57\xd5\xcc" + "\x0d\xc1\x7a\x2b\x33\x2a\x76\x84\x33\x26\x97\xcf\x47\x9d\x72\x2a" + "\xc9\x39\xde\xa8\x42\x27\x2d\xdc\xee\x00\x60\xd2\x4f\x13\xe0\xde" + "\xd5\xc7\xf6\x7d\x8b\x2a\x43\x49\x40\x99\xc2\x61\x84\x8e\x57\x09" + "\x7c\xcc\x19\x46\xbd\x4c\xd2\x7c\x7d\x02\x4d\x88\xdf\x58\x24\x80" + "\xeb\x19\x3b\x2a\x13\x2b\x19\x85\x3c\xd8\x31\x03\x00\xa4\xd4\x57" + "\x23\x2c\x24\x37\xb3\x62\xea\x35\x29\xd0\x2c\xac\xfd\xbd\xdf\x3d" + "\xa6\xce\xfa\x0d\x5b\xb6\x15\x8b\xe3\x58\xe9\xad\x99\x87\x29\x51" + "\x8d\x97\xd7\xa9\x55\xf0\x72\x6e\x4e\x58\xcb\x2b\x4d\xbd\xd0\x48" + "\x7d\x14\x86\xdb\x3f\xa2\x5f\x6e\x35\x4a\xe1\x70\xb1\x53\x72\xb7" + "\xbc\xe9\x3d\x1b\x33\xc0\x54\x6f\x43\x55\x76\x85\x7f\x9b\xa5\xb3" + "\xc1\x1d\xd3\xfe\xe2\xd5\x96\x3d\xdd\x92\x04\xb1\xad\x75\xdb\x13" + "\x4e\x49\xfc\x35\x34\xc5\xda\x13\x98\xb8\x12\xbe\xda\x90\x55\x7c" + "\x11\x6c\xbe\x2b\x8c\x51\x29\x23\xc1\x51\xbc\x0c\x1c\xe2\x20\xfc" + "\xfe\xf2\xaa\x71\x9b\x21\xdf\x25\x1f\x68\x21\x7e\xe1\xc9\x87\xa0" + "\x20\xf6\x8d\x4f\x27\x8c\x3c\x0f\x9d\xf4\x69\x25\xaa\x49\xab\x94" + "\x22\x5a\x92\x3a\xba\xb4\xc2\x8c\x5a\xaa\x04\xbf\x46\xc5\xaa\x93" + "\xab\x0d\xe9\x54\x6c\x3a\x64\xa6\xa2\x21\x66\xee\x1c\x10\x21\x84" + "\xf2\x9e\xcc\x57\xac\xc2\x25\x62\xad\xbb\x59\xef\x25\x61\x6c\x81" + "\x38\x8a\xdc\x8c\xeb\x7b\x18\x1d\xaf\xa9\xc5\x9a\xf4\x49\x26\x8a" + "\x25\xc4\x3e\x31\x95\x28\xef\xf7\x72\xe9\xc5\xaa\x59\x72\x2b\x67" + "\x47\xe8\x6b\x51\x05\x24\xb8\x18\xb3\x34\x0f\x8c\x2b\x80\xba\x61" + "\x1c\xbe\x9e\x9a\x7c\xe3\x60\x5e\x49\x02\xff\x50\x8a\x64\x28\x64" + "\x46\x7b\x83\x14\x72\x6e\x59\x9b\x56\x09\xb4\xf0\xde\x52\xc3\xf3" + "\x58\x17\x6a\xae\xb1\x0f\xf4\x39\xcc\xd8\xce\x4d\xe1\x51\x17\x88" + "\xe4\x98\xd9\xd1\xa9\x55\xbc\xbf\x7e\xc4\x51\x96\xdb\x44\x1d\xcd" + "\x8d\x74\xad\xa7\x8f\x87\x83\x75\xfc\x36\xb7\xd2\xd4\x89\x16\x97" + "\xe4\xc6\x2a\xe9\x65\xc8\xca\x1c\xbd\x86\xaf\x57\x80\xf7\xdd\x42" + "\xc0\x3b\x3f\x87\x51\x02\x2f\xf8\xd8\x68\x0f\x3d\x95\x2d\xf1\x67" + "\x09\xa6\x5d\x0b\x7e\x01\xb4\xb2\x32\x01\xa8\xd0\x58\x0d\xe6\xa2" + "\xd8\x4b\x22\x10\x7d\x11\xf3\xc2\x4e\xb8\x43\x8e\x31\x79\x59\xe2" + "\xc4\x96\x29\x17\x40\x06\x0d\xdf\xdf\xc3\x02\x30\x2a\xd1\x8e\xf2" + "\xee\x2d\xd2\x12\x63\x5a\x1d\x3c\xba\x4a\xc4\x56\x90\xc6\x12\x0b" + "\xe0\x04\x3f\x35\x59\x8e\x40\x75\xf4\x4c\x10\x61\xb9\x30\x89\x7c" + "\x8d\x0e\x25\xb7\x5a\x6b\x97\x05\xc6\x37\x80\x6e\x94\x56\xa8\x5f" + "\x03\x94\x59\xc8\xc5\x3e\xdc\x23\xe5\x68\x4f\xd7\xbb\x6d\x7e\xc1" + "\x8d\xf9\xcc\x3f\x38\xad\x77\xb3\x18\x61\xed\x04\xc0\x71\xa7\x96" + "\xb1\xaf\x1d\x69\x78\xda\x6d\x89\x8b\x50\x75\x99\x44\xb3\xb2\x75" + "\xd1\xc8\x14\x40\xa1\x0a\xbf\xc4\x45\xc4\xee\x12\x90\x76\x26\x64" + "\xb7\x73\x2e\x0b\x0c\xfa\xc3\x55\x29\x24\x1b\x7a\x00\x27\x07\x26" + "\x36\xf0\x38\x1a\xe3\xb7\xc4\x8d\x1c\x9c\xa9\xc0\xc1\x45\x91\x9e" + "\x86\xdd\x82\x94\x45\xfa\xcd\x5a\x19\x12\x7d\xef\xda\x17\xad\x21" + "\x17\x89\x8b\x45\xa7\xf5\xed\x51\x9e\x58\x13\xdc\x84\xa4\xe6\x37", + .secret_size = 16, + .b_secret_size = 784, + .b_public_size = 768, + .expected_a_public_size = 768, + .expected_ss_size = 768, + .genkey = true, + }, +}; + +static const struct kpp_testvec ffdhe8192_dh_tv_template[] __maybe_unused = { + { + .secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x10\x04" /* len */ + "\x00\x04\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#else + "\x00\x01" /* type */ + "\x04\x10" /* len */ + "\x00\x00\x04\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#endif + /* xa */ + "\x76\x6e\xeb\xf9\xeb\x76\xae\x37\xcb\x19\x49\x8b\xeb\xaf\xb0\x4b" + "\x6d\xe9\x15\xad\xda\xf2\xef\x58\xe9\xd6\xdd\x4c\xb3\x56\xd0\x3b" + "\x00\xb0\x65\xed\xae\xe0\x2e\xdf\x8f\x45\x3f\x3c\x5d\x2f\xfa\x96" "\x36\x33\xb2\x01\x8b\x0f\xe8\x46\x15\x6d\x60\x5b\xec\x32\xc3\x3b" "\x06\xf3\xb4\x1b\x9a\xef\x3c\x03\x0e\xcc\xce\x1d\x24\xa0\xc9\x08" "\x65\xf9\x45\xe5\xd2\x43\x08\x88\x58\xd6\x46\xe7\xbb\x25\xac\xed"
@@ -2327,6 +2719,172 @@ static const struct kpp_testvec ffdhe8192_dh_tv_template[] __maybe_unused = { .expected_a_public_size = 1024, .expected_ss_size = 1024, }, + { + .secret = +#ifdef __LITTLE_ENDIAN +"\x01\x00" /* type */ +"\x10\x00" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#else +"\x00\x01" /* type */ +"\x00\x10" /* len */ +"\x00\x00\x00\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ +"\x00\x00\x00\x00" ,/* g_size */ +#endif + .b_secret = +#ifdef __LITTLE_ENDIAN + "\x01\x00" /* type */ + "\x10\x04" /* len */ + "\x00\x04\x00\x00" /* key_size */ + "\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#else +"\x00\x01" /* type */ +"\x04\x10" /* len */ +"\x00\x00\x04\x00" /* key_size */ +"\x00\x00\x00\x00" /* p_size */ + "\x00\x00\x00\x00" /* g_size */ +#endif +/* xa */ +"\x76\x6e\xeb\xf9\xeb\x76\xae\x37\xcb\x19\x49\x8b\xeb\xaf\xb0\x4b" +"\x6d\xe9\x15\xad\xda\xf2\xef\x58\xe9\xd6\xdd\x4c\xb3\x56\xd0\x3b" +"\x00\xb0\x65\xed\xae\xe0\x2e\xdf\x8f\x45\x3f\x3c\x5d\x2f\xfa\x96" +"\x36\x33\xb2\x01\x8b\x0f\xe8\x46\x15\x6d\x60\x5b\xec\x32\xc3\x3b" +"\x06\xf3\xb4\x1b\x9a\xef\x3c\x03\x0e\xcc\xce\x1d\x24\xa0\xc9\x08" +"\x65\xf9\x45\xe5\xd2\x43\x08\x88\x58\xd6\x46\xe7\xbb\x25\xac\xed" +"\x3b\xac\x6f\x5e\xfb\xd6\x19\xa6\x20\x3a\x1d\x0c\xe8\x00\x72\x54" +"\xd7\xd9\xc9\x26\x49\x18\xc6\xb8\xbc\xdd\xf3\xce\xf3\x7b\x69\x04" +"\x5c\x6f\x11\xdb\x44\x42\x72\xb6\xb7\x84\x17\x86\x47\x3f\xc5\xa1" +"\xd8\x86\xef\xe2\x27\x49\x2b\x8f\x3e\x91\x12\xd9\x45\x96\xf7\xe6" +"\x77\x76\x36\x58\x71\x9a\xb1\xdb\xcf\x24\x9e\x7e\xad\xce\x45\xba" +"\xb5\xec\x8e\xb9\xd6\x7b\x3d\x76\xa4\x85\xad\xd8\x49\x9b\x80\x9d" +"\x7f\x9f\x85\x09\x9e\x86\x5b\x6b\xf3\x8d\x39\x5e\x6f\xe4\x30\xc8" +"\xa5\xf3\xdf\x68\x73\x6b\x2e\x9a\xcb\xac\x0a\x0d\x44\xc1\xaf\xb2" +"\x11\x1b\x7c\x43\x08\x44\x43\xe2\x4e\xfd\x93\x30\x99\x09\x12\xbb" +"\xf6\x31\x34\xa5\x3d\x45\x98\xee\xd7\x2a\x1a\x89\xf5\x37\x92\x33" +"\xa0\xdd\xf5\xfb\x1f\x90\x42\x55\x5a\x0b\x82\xff\xf0\x96\x92\x15" +"\x65\x5a\x55\x96\xca\x1b\xd5\xe5\xb5\x94\xde\x2e\xa6\x03\x57\x9e" +"\x15\xe4\x32\x2b\x1f\xb2\x22\x21\xe9\xa0\x05\xd3\x65\x6c\x11\x66" +"\x25\x38\xbb\xa3\x6c\xc2\x0b\x2b\xd0\x7a\x20\x26\x29\x37\x5d\x5f" +"\xd8\xff\x2a\xcd\x46\x6c\xd6\x6e\xe5\x77\x1a\xe6\x33\xf1\x8e\xc8" +"\x10\x30\x11\x00\x27\xf9\x7d\x0e\x28\x43\xa7\x67\x38\x7f\x16\xda" +"\xd0\x01\x8e\xa4\xe8\x6f\xcd\x23\xaf\x77\x52\x34\xad\x7e\xc3\xed" +"\x2d\x10\x0a\x33\xdc\xcf\x1b\x88\x0f\xcc\x48\x7f\x42\xf0\x9e\x13" +"\x1f\xf5\xd1\xe9\x90\x87\xbd\xfa\x5f\x1d\x77\x55\xcb\xc3\x05\xaf" +"\x71\xd0\xe0\xab\x46\x31\xd7\xea\x89\x54\x2d\x39\xaf\xf6\x4f\x74" +"\xaf\x46\x58\x89\x78\x95\x2e\xe6\x90\xb7\xaa\x00\x73\x9f\xed\xb9" +"\x00\xd6\xf6\x6d\x26\x59\xcd\x56\xdb\xf7\x3d\x5f\xeb\x6e\x46\x33" +"\xb1\x23\xed\x9f\x8d\x58\xdc\xb4\x28\x3b\x90\x09\xc4\x61\x02\x1f" +"\xf8\x62\xf2\x6e\xc1\x94\x71\x66\x93\x11\xdf\xaa\x3e\xd7\xb5\xe5" +"\xc1\x78\xe9\x14\xcd\x55\x16\x51\xdf\x8d\xd0\x94\x8c\x43\xe9\xb8" +"\x1d\x42\x7f\x76\xbc\x6f\x87\x42\x88\xde\xd7\x52\x78\x00\x4f\x18" +"\x02\xe7\x7b\xe2\x8a\xc3\xd1\x43\xa5\xac\xda\xb0\x8d\x19\x96\xd4" +"\x81\xe0\x75\xe9\xca\x41\x7e\x1f\x93\x0b\x26\x24\xb3\xaa\xdd\x10" +"\x20\xd3\xf2\x9f\x3f\xdf\x65\xde\x67\x79\xdc\x76\x9f\x3c\x72\x75" +"\x65\x8a\x30\xcc\xd2\xcc\x06\xb1\xab\x62\x86\x78\x5d\xb8\xce\x72" +"\xb3\x12\xc7\x9f\x07\xd0\x6b\x98\x82\x9b\x6c\xbb\x15\xe5\xcc\xf4" +"\xc8\xf4\x60\x81\xdc\xd3\x09\x1b\x5e\xd4\xf3\x55\xcf\x1c\x16\x83" +"\x61\xb4\x2e\xcc\x08\x67\x58\xfd\x46\x64\xbc\x29\x4b\xdd\xda\xec" +"\xdc\xc6\xa9\xa5\x73\xfb\xf8\xf3\xaf\x89\xa8\x9e\x25\x14\xfa\xac" +"\xeb\x1c\x7c\x80\x96\x66\x4d\x41\x67\x9b\x07\x4f\x0a\x97\x17\x1c" +"\x4d\x61\xc7\x2e\x6f\x36\x98\x29\x50\x39\x6d\xe7\x70\xda\xf0\xc8" +"\x05\x80\x7b\x32\xff\xfd\x12\xde\x61\x0d\xf9\x4c\x21\xf1\x56\x72" +"\x3d\x61\x46\xc0\x2d\x07\xd1\x6c\xd3\xbe\x9a\x21\x83\x85\xf7\xed" +"\x53\x95\x44\x40\x8f\x75\x12\x18\xc2\x9a\xfd\x5e\xce\x66\xa6\x7f" +"\x57\xc0\xd7\x73\x76\xb3\x13\xda\x2e\x58\xc6\x27\x40\xb2\x2d\xef" +"\x7d\x72\xb4\xa8\x75\x6f\xcc\x5f\x42\x3e\x2c\x90\x36\x59\xa0\x34" +"\xaa\xce\xbc\x04\x4c\xe6\x56\xc2\xcd\xa6\x1c\x59\x04\x56\x53\xcf" +"\x6d\xd7\xf0\xb1\x4f\x91\xfa\x84\xcf\x4b\x8d\x50\x4c\xf8\x2a\x31" +"\x5f\xe3\xba\x79\xb4\xcc\x59\x64\xe3\x7a\xfa\xf6\x06\x9d\x04\xbb" +"\xce\x61\xbf\x9e\x59\x0a\x09\x51\x6a\xbb\x0b\x80\xe0\x91\xc1\x51" +"\x04\x58\x67\x67\x4b\x42\x4f\x95\x68\x75\xe2\x1f\x9c\x14\x70\xfd" +"\x3a\x8a\xce\x8b\x04\xa1\x89\xe7\xb4\xbf\x70\xfe\xf3\x0c\x48\x04" +"\x3a\xd2\x85\x68\x03\xe7\xfa\xec\x5b\x55\xb7\x95\xfd\x5b\x19\x35" +"\xad\xcb\x4a\x63\x03\x44\x64\x2a\x48\x59\x9a\x26\x43\x96\x8c\xe6" +"\xbd\xb7\x90\xd4\x5f\x8d\x08\x28\xa8\xc5\x89\x70\xb9\x6e\xd3\x3b" +"\x76\x0e\x37\x98\x15\x27\xca\xc9\xb0\xe0\xfd\xf3\xc6\xdf\x69\xce" +"\xe1\x5f\x6a\x3e\x5c\x86\xe2\x58\x41\x11\xf0\x7e\x56\xec\xe4\xc9" +"\x0d\x87\x91\xfb\xb9\xc8\x0d\x34\xab\xb0\xc6\xf2\xa6\x00\x7b\x18" +"\x92\xf4\x43\x7f\x01\x85\x2e\xef\x8c\x72\x50\x10\xdb\xf1\x37\x62" +"\x16\x85\x71\x01\xa8\x2b\xf0\x13\xd3\x7c\x0b\xaf\xf1\xf3\xd1\xee" +"\x90\x41\x5f\x7d\x5b\xa9\x83\x4b\xfa\x80\x59\x50\x73\xe1\xc4\xf9" +"\x5e\x4b\xde\xd9\xf5\x22\x68\x5e\x65\xd9\x37\xe4\x1a\x08\x0e\xb1" + "\x28\x2f\x40\x9e\x37\xa8\x12\x56\xb7\xb8\x64\x94\x68\x94\xff\x9f", + .b_public = +"\xa1\x6c\x9e\xda\x45\x4d\xf6\x59\x04\x00\xc1\xc6\x8b\x12\x3b\xcd" +"\x07\xe4\x3e\xec\xac\x9b\xfc\xf7\x6d\x73\x39\x9e\x52\xf8\xbe\x33" +"\xe2\xca\xea\x99\x76\xc7\xc9\x94\x5c\xf3\x1b\xea\x6b\x66\x4b\x51" +"\x90\xf6\x4f\x75\xd5\x85\xf4\x28\xfd\x74\xa5\x57\xb1\x71\x0c\xb6" +"\xb6\x95\x70\x2d\xfa\x4b\x56\xe0\x56\x10\x21\xe5\x60\xa6\x18\xa4" +"\x78\x8c\x07\xc0\x2b\x59\x9c\x84\x5b\xe9\xb9\x74\xbf\xbc\x65\x48" +"\x27\x82\x40\x53\x46\x32\xa2\x92\x91\x9d\xf6\xd1\x07\x0e\x1d\x07" +"\x1b\x41\x04\xb1\xd4\xce\xae\x6e\x46\xf1\x72\x50\x7f\xff\xa8\xa2" +"\xbc\x3a\xc1\xbb\x28\xd7\x7d\xcd\x7a\x22\x01\xaf\x57\xb0\xa9\x02" +"\xd4\x8a\x92\xd5\xe6\x8e\x6f\x11\x39\xfe\x36\x87\x89\x42\x25\x42" +"\xd9\xbe\x67\x15\xe1\x82\x8a\x5e\x98\xc2\xd5\xde\x9e\x13\x1a\xe7" +"\xf9\x9f\x8e\x2d\x49\xdc\x4d\x98\x8c\xdd\xfd\x24\x7c\x46\xa9\x69" +"\x3b\x31\xb3\x12\xce\x54\xf6\x65\x75\x40\xc2\xf1\x04\x92\xe3\x83" +"\xeb\x02\x3d\x79\xc0\xf9\x7c\x28\xb3\x97\x03\xf7\x61\x1c\xce\x95" +"\x1a\xa0\xb3\x77\x1b\xc1\x9f\xf8\xf6\x3f\x4d\x0a\xfb\xfa\x64\x1c" +"\xcb\x37\x5b\xc3\x28\x60\x9f\xd1\xf2\xc4\xee\x77\xaa\x1f\xe9\xa2" +"\x89\x4c\xc6\xb7\xb3\xe4\xa5\xed\xa7\xe8\xac\x90\xdc\xc3\xfb\x56" +"\x9c\xda\x2c\x1d\x1a\x9a\x8c\x82\x92\xee\xdc\xa0\xa4\x01\x6e\x7f" +"\xc7\x0e\xc2\x73\x7d\xa6\xac\x12\x01\xc0\xc0\xc8\x7c\x84\x86\xc7" +"\xa5\x94\xe5\x33\x84\x71\x6e\x36\xe3\x3b\x81\x30\xe0\xc8\x51\x52" +"\x2b\x9e\x68\xa2\x6e\x09\x95\x8c\x7f\x78\x82\xbd\x53\x26\xe7\x95" +"\xe0\x03\xda\xc0\xc3\x6e\xcf\xdc\xb3\x14\xfc\xe9\x5b\x9b\x70\x6c" +"\x93\x04\xab\x13\xf7\x17\x6d\xee\xad\x32\x48\xe9\xa0\x94\x1b\x14" +"\x64\x4f\xa1\xb3\x8d\x6a\xca\x28\xfe\x4a\xf4\xf0\xc5\xb7\xf9\x8a" +"\x8e\xff\xfe\x57\x6f\x20\xdb\x04\xab\x02\x31\x22\x42\xfd\xbd\x77" +"\xea\xce\xe8\xc7\x5d\xe0\x8e\xd6\x66\xd0\xe4\x04\x2f\x5f\x71\xc7" +"\x61\x2d\xa5\x3f\x2f\x46\xf2\xd8\x5b\x25\x82\xf0\x52\x88\xc0\x59" +"\xd3\xa3\x90\x17\xc2\x04\x13\xc3\x13\x69\x4f\x17\xb1\xb3\x46\x4f" +"\xa7\xe6\x8b\x5e\x3e\x95\x0e\xf5\x42\x17\x7f\x4d\x1f\x1b\x7d\x65" +"\x86\xc5\xc8\xae\xae\xd8\x4f\xe7\x89\x41\x69\xfd\x06\xce\x5d\xed" +"\x44\x55\xad\x51\x98\x15\x78\x8d\x68\xfc\x93\x72\x9d\x22\xe5\x1d" +"\x21\xc3\xbe\x3a\x44\x34\xc0\xa3\x1f\xca\xdf\x45\xd0\x5c\xcd\xb7" +"\x72\xeb\xae\x7a\xad\x3f\x05\xa0\xe3\x6e\x5a\xd8\x52\xa7\xf1\x1e" +"\xb4\xf2\xcf\xe7\xdf\xa7\xf2\x22\x00\xb2\xc4\x17\x3d\x2c\x15\x04" +"\x71\x28\x69\x5c\x69\x21\xc8\xf1\x9b\xd8\xc7\xbc\x27\xa3\x85\xe9" +"\x53\x77\xd3\x65\xc3\x86\xdd\xb3\x76\x13\xfb\xa1\xd4\xee\x9d\xe4" +"\x51\x3f\x83\x59\xe4\x47\xa8\xa6\x0d\x68\xd5\xf6\xf4\xca\x31\xcd" +"\x30\x48\x34\x90\x11\x8e\x87\xe9\xea\xc9\xd0\xc3\xba\x28\xf9\xc0" +"\xc9\x8e\x23\xe5\xc2\xee\xf2\x47\x9c\x41\x1c\x10\x33\x27\x23\x49" +"\xe5\x0d\x18\xbe\x19\xc1\xba\x6c\xdc\xb7\xa1\xe7\xc5\x0d\x6f\xf0" +"\x8c\x62\x6e\x0d\x14\xef\xef\xf2\x8e\x01\xd2\x76\xf5\xc1\xe1\x92" +"\x3c\xb3\x76\xcd\xd8\xdd\x9b\xe0\x8e\xdc\x24\x34\x13\x65\x0f\x11" +"\xaf\x99\x7a\x2f\xe6\x1f\x7d\x17\x3e\x8a\x68\x9a\x37\xc8\x8d\x3e" +"\xa3\xfe\xfe\x57\x22\xe6\x0e\x50\xb5\x98\x0b\x71\xd8\x01\xa2\x8d" +"\x51\x96\x50\xc2\x41\x31\xd8\x23\x98\xfc\xd1\x9d\x7e\x27\xbb\x69" +"\x78\xe0\x87\xf7\xe4\xdd\x58\x13\x9d\xec\x00\xe4\xb9\x70\xa2\x94" +"\x5d\x52\x4e\xf2\x5c\xd1\xbc\xfd\xee\x9b\xb9\xe5\xc4\xc0\xa8\x77" +"\x67\xa4\xd1\x95\x34\xe4\x6d\x5f\x25\x02\x8d\x65\xdd\x11\x63\x55" +"\x04\x01\x21\x60\xc1\x5c\xef\x77\x33\x01\x1c\xa2\x11\x2b\xdd\x2b" +"\x74\x99\x23\x38\x05\x1b\x7e\x2e\x01\x52\xfe\x9c\x23\xde\x3e\x1a" +"\x72\xf4\xff\x7b\x02\xaa\x08\xcf\xe0\x5b\x83\xbe\x85\x5a\xe8\x9d" +"\x11\x3e\xff\x2f\xc6\x97\x67\x36\x6c\x0f\x81\x9c\x26\x29\xb1\x0f" +"\xbb\x53\xbd\xf4\xec\x2a\x84\x41\x28\x3b\x86\x40\x95\x69\x55\x5f" +"\x30\xee\xda\x1e\x6c\x4b\x25\xd6\x2f\x2c\x0e\x3c\x1a\x26\xa0\x3e" +"\xef\x09\xc6\x2b\xe5\xa1\x0c\x03\xa8\xf5\x39\x70\x31\xc4\x32\x79" +"\xd1\xd9\xc2\xcc\x32\x4a\xf1\x2f\x57\x5a\xcc\xe5\xc3\xc5\xd5\x4e" +"\x86\x56\xca\x64\xdb\xab\x61\x85\x8f\xf9\x20\x02\x40\x66\x76\x9e" +"\x5e\xd4\xac\xf0\x47\xa6\x50\x5f\xc2\xaf\x55\x9b\xa3\xc9\x8b\xf8" +"\x42\xd5\xcf\x1a\x95\x22\xd9\xd1\x0b\x92\x51\xca\xde\x46\x02\x0d" +"\x8b\xee\xd9\xa0\x04\x74\xf5\x0e\xb0\x3a\x62\xec\x3c\x91\x29\x33" +"\xa7\x78\x22\x92\xac\x27\xe6\x2d\x6f\x56\x8a\x5d\x72\xc2\xf1\x5c" +"\x54\x11\x97\x24\x61\xcb\x0c\x52\xd4\x57\x56\x22\x86\xf0\x19\x27" +"\x76\x30\x04\xf4\x39\x7b\x1a\x5a\x04\x0d\xec\x59\x9a\x31\x4c\x40" + "\x19\x6d\x3c\x41\x1b\x0c\xca\xeb\x25\x39\x6c\x96\xf8\x55\xd0\xec", + .secret_size = 16, + .b_secret_size = 1040, + .b_public_size = 1024, + .expected_a_public_size = 1024, + .expected_ss_size = 1024, + .genkey = true, + }, }; static const struct kpp_testvec curve25519_tv_template[] = {
Signature · 1 line
2.26.2
Re: [PATCH v4 10/15] crypto: testmgr - add keygen tests for ffdheXYZ(dh) templates
Quoted 8 lines · Nicolai Stange
Now that the ffdheXYZ(dh) templates support ephemeral key generation, add ->keygen = 1 TVs for each of them to the
testmgr.c.In order to facilitate string merging by the compiler, set party B's secret and public keys to the ones specified for party A in the respective existing known answer test. With GCC 7.5 on
x86_64, this leads to an increase of testmgr.o size by less than half a kB.
Quoted 5 lines
Signed-off-by Nicolai Stange <[email protected]>--- crypto/testmgr.h | 578 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 568 insertions(+), 10 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 11/15 crypto: dh - allow for passing NULL to the ffdheXYZ(dh)s' ->set_secret()
In reply to Nicolai StangeEphemeral key generation can be requested from any of the ffdheXYZ(dh) variants' common ->set_secret() by passing it an (encoded) struct dh with the key parameter being unset, i.e. with ->key_size == 0. As the whole purpose of the ffdheXYZ(dh) templates is to fill in the group parameters as appropriate, they expect ->p and ->g to be unset in any input struct dh as well. This means that a user would have to encode an all-zeroes struct dh instance via crypto_dh_encode_key() when requesting ephemeral key generation from a ffdheXYZ(dh) instance, which is kind of pointless.
Make dh_safe_prime_set_secret() to decode a struct dh from the supplied buffer only if the latter is non-NULL and initialize it with all zeroes otherwise.
That is, it is now possible to call
crypto_kpp_set_secret(tfm, NULL, 0);
on any ffdheXYZ(dh) tfm for requesting ephemeral key generation.
--- crypto/dh.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)
crypto/dh.c +8 -7
@@ -444,17 +444,18 @@ static int dh_safe_prime_set_secret(struct crypto_kpp *tfm, const void *buffer,struct dh_safe_prime_instance_ctx *inst_ctx =dh_safe_prime_instance_ctx (tfm);struct dh_safe_prime_tfm_ctx *tfm_ctx =kpp_tfm_ctx (tfm); -struct dh params; +struct dh params = {};void *buf =NULL , *key =NULL ;unsigned int buf_size;int err; - err =__crypto_dh_decode_key (buffer, len, ¶ms); -if (err) -return err; - -if (params.p_size || params.g_size) -return -EINVAL ; +if (buffer) { + err =__crypto_dh_decode_key (buffer, len, ¶ms); +if (err) +return err; +if (params.p_size || params.g_size) +return -EINVAL ; + } params.p = inst_ctx->safe_prime->p; params.p_size = inst_ctx->safe_prime->p_size;
Signature · 1 line
2.26.2
Re: [PATCH v4 11/15] crypto: dh - allow for passing NULL to the ffdheXYZ(dh)s' ->set_secret()
Quoted 16 lines · Nicolai Stange
Ephemeral key generation can be requested from any of the ffdheXYZ(dh) variants' common ->set_secret() by passing it an (encoded) struct dh with the key parameter being unset, i.e. with ->key_size == 0. As the whole purpose of the ffdheXYZ(dh) templates is to fill in the group parameters as appropriate, they expect ->p and ->g to be unset in any input struct dh as well. This means that a user would have to encode an all-zeroes struct dh instance via
crypto_dh_encode_key()when requesting ephemeral key generation from a ffdheXYZ(dh) instance, which is kind of pointless.Make
dh_safe_prime_set_secret()to decode a struct dh from the supplied buffer only if the latter is non-NULL and initialize it with all zeroes otherwise.That is, it is now possible to call
Quoted 9 lines
crypto_kpp_set_secret(tfm, NULL, 0);on any ffdheXYZ(dh) tfm for requesting ephemeral key generation.
Signed-off-by Nicolai Stange <[email protected]>--- crypto/dh.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 12/15 crypto: api - allow algs only in specific constructions in FIPS mode
In reply to Nicolai StangeCurrently we do not distinguish between algorithms that fail on the self-test vs. those which are disabled in FIPS mode (not allowed). Both are marked as having failed the self-test.
Recently the need arose to allow the usage of certain algorithms only as arguments to specific template instantiations in FIPS mode. For example, standalone "dh" must be blocked, but e.g. "ffdhe2048(dh)" is allowed. Other potential use cases include "cbcmac(aes)", which must only be used with ccm(), or "ghash", which must be used only for gcm().
This patch allows this scenario by adding a new flag FIPS_INTERNAL to indicate those algorithms that are not FIPS-allowed. They can then be used as template arguments only, i.e. when looked up via crypto_grab_spawn() to be more specific. The FIPS_INTERNAL bit gets propagated upwards recursively into the surrounding template instances, until the construction eventually matches an explicit testmgr entry with ->fips_allowed being set, if any.
The behaviour to skip !->fips_allowed self-test executions in FIPS mode will be retained. Note that this effectively means that FIPS_INTERNAL algorithms are handled very similarly to the INTERNAL ones in this regard. It is expected that the FIPS_INTERNAL algorithms will receive sufficient testing when the larger constructions they're a part of, if any, get exercised by testmgr.
Note that as a side-effect of this patch algorithms which are not FIPS-allowed will now return ENOENT instead of ELIBBAD. Hopefully this is not an issue as some people were relying on this already.
--- crypto/algapi.c | 18 ++++++++++++++++-- crypto/api.c | 19 +++++++++++++++++-- crypto/tcrypt.c | 4 ++-- crypto/testmgr.c | 23 +++++++++++++++++++---- include/linux/crypto.h | 9 +++++++++ 5 files changed, 63 insertions(+), 10 deletions(-)
crypto/algapi.c +16 -2
@@ -328,8 +328,16 @@ void crypto_alg_tested(const char *name, int err) found: q->cra_flags |=CRYPTO_ALG_DEAD ; alg = test->adult; -if (err ||list_empty (&alg->cra_list)) + +if (list_empty (&alg->cra_list)) + goto complete; + +if (err == -ECANCELED ) + alg->cra_flags |=CRYPTO_ALG_FIPS_INTERNAL ; +else if (err) goto complete; +else + alg->cra_flags &= ~CRYPTO_ALG_FIPS_INTERNAL ; alg->cra_flags |=CRYPTO_ALG_TESTED ;
@@ -610,6 +618,7 @@ int crypto_register_instance(struct crypto_template *tmpl, {struct crypto_larval *larval;struct crypto_spawn *spawn; +u32 fips_internal =0 ;int err; err =crypto_check_alg (&inst->alg);
@@ -632,11 +641,15 @@ int crypto_register_instance(struct crypto_template *tmpl, spawn->inst = inst; spawn->registered = true; + fips_internal |= spawn->alg->cra_flags; +crypto_mod_put (spawn->alg); spawn = next; } + inst->alg.cra_flags |= (fips_internal &CRYPTO_ALG_FIPS_INTERNAL ); + larval =__crypto_register_alg (&inst->alg);if (IS_ERR (larval)) goto unlock;
@@ -689,7 +702,8 @@ int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst,if (IS_ERR (name))return PTR_ERR (name); - alg =crypto_find_alg (name, spawn->frontend, type, mask); + alg =crypto_find_alg (name, spawn->frontend, + type |CRYPTO_ALG_FIPS_INTERNAL , mask);if (IS_ERR (alg))return PTR_ERR (alg);
crypto/api.c +17 -2
@@ -223,6 +223,8 @@ static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)else if (crypto_is_test_larval (larval) && !(alg->cra_flags &CRYPTO_ALG_TESTED )) alg =ERR_PTR (-EAGAIN ); +else if (alg->cra_flags &CRYPTO_ALG_FIPS_INTERNAL ) + alg =ERR_PTR (-EAGAIN );else if (!crypto_mod_get (alg)) alg =ERR_PTR (-EAGAIN );crypto_mod_put (&larval->alg);
@@ -233,6 +235,7 @@ static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)static struct crypto_alg *crypto_alg_lookup (const char *name,u32 type,u32 mask) { +const u32 fips =CRYPTO_ALG_FIPS_INTERNAL ;struct crypto_alg *alg;u32 test =0 ;
@@ -240,8 +243,20 @@ static struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, test |=CRYPTO_ALG_TESTED ;down_read (&crypto_alg_sem); - alg =__crypto_alg_lookup (name, type | test, mask | test); -if (!alg && test) { + alg =__crypto_alg_lookup (name, (type | test) & ~fips, + (mask | test) & ~fips); +if (alg) { +if (((type | mask) ^ fips) & fips) + mask |= fips; + mask &= fips; + +if (!crypto_is_larval (alg) && + ((type ^ alg->cra_flags) & mask)) { +/* Algorithm is disallowed in FIPS mode. */ +crypto_mod_put (alg); + alg =ERR_PTR (-ENOENT ); + } + }else if (test) { alg =__crypto_alg_lookup (name, type, mask);if (alg && !crypto_is_larval (alg)) {/* Test failed */
crypto/tcrypt.c +2 -2
@@ -1473,8 +1473,8 @@ static inline int tcrypt_test(const char *alg)pr_debug ("testing %s\n" , alg); ret =alg_test (alg, alg,0 ,0 ); -/* non-fips algs return -EINVAL in fips mode */ -if (fips_enabled && ret == -EINVAL ) +/* non-fips algs return -EINVAL or -ECANCELED in fips mode */ +if (fips_enabled && (ret == -EINVAL || ret == -ECANCELED )) ret =0 ;return ret; }
crypto/testmgr.c +19 -4
@@ -5650,6 +5650,13 @@ static int alg_find_test(const char *alg)return -1 ; } +static int alg_fips_disabled (const char *driver,const char *alg) +{ +pr_info ("alg: %s (%s) is disabled due to FIPS\n" , alg, driver); + +return -ECANCELED ; +} +int alg_test (const char *driver,const char *alg,u32 type,u32 mask) {int i;
@@ -5686,9 +5693,13 @@ int alg_test(const char *driver, const char *alg, u32 type, u32 mask)if (i <0 && j <0 ) goto notest; -if (fips_enabled && ((i >=0 && !alg_test_descs[i].fips_allowed) || - (j >=0 && !alg_test_descs[j].fips_allowed))) - goto non_fips_alg; +if (fips_enabled) { +if (j >=0 && !alg_test_descs[j].fips_allowed) +return -EINVAL ; + +if (i >=0 && !alg_test_descs[i].fips_allowed) + goto non_fips_alg; + } rc =0 ;if (i >=0 )
@@ -5718,9 +5729,13 @@ int alg_test(const char *driver, const char *alg, u32 type, u32 mask) notest:printk (KERN_INFO "alg: No test for %s (%s)\n" , alg, driver); + +if (type &CRYPTO_ALG_FIPS_INTERNAL ) +return alg_fips_disabled (driver, alg); +return 0 ; non_fips_alg: - return -EINVAL; + return alg_fips_disabled(driver, alg); }#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
include/linux/crypto.h +9 -0
@@ -132,6 +132,15 @@*/ #define CRYPTO_ALG_ALLOCATES_MEMORY 0x00010000 +/* +* Mark an algorithm as a service implementation only usable by a +* template and never by a normal user of the kernel crypto API. +* This is intended to be used by algorithms that are themselves +* not FIPS-approved but may instead be used to implement parts of +* a FIPS-approved algorithm (e.g., dh vs. ffdhe2048(dh)). +*/ +#define CRYPTO_ALG_FIPS_INTERNAL 0x00020000 +/* * Transform masks and values (for crt_flags). */
Signature · 1 line
2.26.2
Re: [PATCH v4 12/15] crypto: api - allow algs only in specific constructions in FIPS mode
Quoted 33 lines · Nicolai Stange
Currently we do not distinguish between algorithms that fail on the self-test vs. those which are disabled in FIPS mode (not allowed). Both are marked as having failed the self-test.
Recently the need arose to allow the usage of certain algorithms only as arguments to specific template instantiations in FIPS mode. For example, standalone "dh" must be blocked, but e.g. "ffdhe2048(dh)" is allowed. Other potential use cases include "cbcmac(aes)", which must only be used with
ccm(), or "ghash", which must be used only forgcm().This patch allows this scenario by adding a new flag
FIPS_INTERNALto indicate those algorithms that are not FIPS-allowed. They can then be used as template arguments only, i.e. when looked up viacrypto_grab_spawn()to be more specific. TheFIPS_INTERNALbit gets propagated upwards recursively into the surrounding template instances, until the construction eventually matches an explicit testmgr entry with ->fips_allowed being set, if any.The behaviour to skip !->fips_allowed self-test executions in FIPS mode will be retained. Note that this effectively means that
FIPS_INTERNALalgorithms are handled very similarly to the INTERNAL ones in this regard. It is expected that theFIPS_INTERNALalgorithms will receive sufficient testing when the larger constructions they're a part of, if any, get exercised by testmgr.Note that as a side-effect of this patch algorithms which are not FIPS-allowed will now return ENOENT instead of ELIBBAD. Hopefully this is not an issue as some people were relying on this already.
Originally-by Herbert Xu <[email protected]>Signed-off-by Nicolai Stange <[email protected]>
Quoted 8 lines
--- crypto/algapi.c | 18 ++++++++++++++++-- crypto/api.c | 19 +++++++++++++++++-- crypto/tcrypt.c | 4 ++-- crypto/testmgr.c | 23 +++++++++++++++++++---- include/linux/crypto.h | 9 +++++++++ 5 files changed, 63 insertions(+), 10 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 13/15 crypto: dh - disallow plain "dh" usage in FIPS mode
In reply to Nicolai StangeSP800-56Arev3, sec. 5.5.2 ("Assurance of Domain-Parameter Validity") asserts that an implementation needs to verify domain paramtere validity, which boils down to either
- the domain parameters corresponding to some known safe-prime group explicitly listed to be approved in the document or
- for parameters conforming to a "FIPS 186-type parameter-size set", that the implementation needs to perform an explicit domain parameter verification, which would require access to the "seed" and "counter" values used in their generation.
The latter is not easily feasible and moreover, SP800-56Arev3 states that safe-prime groups are preferred and that FIPS 186-type parameter sets should only be supported for backward compatibility, if it all.
Mark "dh" as not fips_allowed in testmgr. Note that the safe-prime ffdheXYZ(dh) wrappers are not affected by this change: as these enforce some approved safe-prime group each, their usage is still allowed in FIPS mode.
This change will effectively render the keyctl(KEYCTL_DH_COMPUTE) syscall unusable in FIPS mode, but it has been brought up that this might even be a good thing ([1]).
[1] https://lore.kernel.org/r/[email protected]
--- crypto/testmgr.c | 1 - 1 file changed, 1 deletion(-)
crypto/testmgr.c +0 -1
@@ -4650,7 +4650,6 @@ static const struct alg_test_desc alg_test_descs[] = { }, { .alg = "dh", .test = alg_test_kpp, - .fips_allowed = 1, .suite = { .kpp = __VECS(dh_tv_template) }
Signature · 1 line
2.26.2
Re: [PATCH v4 13/15] crypto: dh - disallow plain "dh" usage in FIPS mode
Quoted 23 lines · Nicolai Stange
SP800-56Arev3, sec. 5.5.2 ("Assurance of Domain-Parameter Validity") asserts that an implementation needs to verify domain paramtere validity, which boils down to either
- the domain parameters corresponding to some known safe-prime group explicitly listed to be approved in the document or
- for parameters conforming to a "FIPS 186-type parameter-size set", that the implementation needs to perform an explicit domain parameter verification, which would require access to the "seed" and "counter" values used in their generation.The latter is not easily feasible and moreover, SP800-56Arev3 states that safe-prime groups are preferred and that FIPS 186-type parameter sets should only be supported for backward compatibility, if it all.
Mark "dh" as not
fips_allowedin testmgr. Note that the safe-prime ffdheXYZ(dh) wrappers are not affected by this change: as these enforce some approved safe-prime group each, their usage is still allowed in FIPS mode.This change will effectively render the
keyctl(KEYCTL_DH_COMPUTE)syscall unusable in FIPS mode, but it has been brought up that this might even be a good thing ([1]).
Quoted 7 lines
[1] https://lore.kernel.org/r/[email protected]
Signed-off-by Nicolai Stange <[email protected]>--- crypto/testmgr.c | 1 - 1 file changed, 1 deletion(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
PATCH v4 14/15 lib/mpi: export mpi_rshift
In reply to Nicolai StangeA subsequent patch will make the crypto/dh's dh_is_pubkey_valid() to calculate a safe-prime groups Q parameter from P: Q = (P - 1) / 2. For implementing this, mpi_rshift() will be needed. Export it so that it's accessible from crypto/dh.
--- lib/mpi/mpi-bit.c | 1 + 1 file changed, 1 insertion(+)
lib/mpi/mpi-bit.c +1 -0
@@ -242,6 +242,7 @@ void mpi_rshift(MPI x, MPI a, unsigned int n) }MPN_NORMALIZE (x->d, x->nlimbs); } +EXPORT_SYMBOL_GPL (mpi_rshift);/**************** * Shift A by COUNT limbs to the left
Signature · 1 line
2.26.2
PATCH v4 15/15 crypto: dh - calculate Q from P for the full public key verification
In reply to Nicolai StangeAs the ->q in struct dh_ctx gets never set anywhere, the code in dh_is_pubkey_valid() for doing the full public key validation in accordance to SP800-56Arev3 is effectively dead.
However, for safe-prime groups Q = (P - 1)/2 by definition and as the safe-prime groups are the only possible groups in FIPS mode (via those ffdheXYZ() templates), this enables dh_is_pubkey_valid() to calculate Q on the fly for these.
Implement this.
With this change, the last code accessing struct dh_ctx's ->q is now gone. Remove this member from struct dh_ctx.
--- crypto/dh.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-)
crypto/dh.c +29 -11
@@ -15,7 +15,6 @@struct dh_ctx {MPI p;/* Value is guaranteed to be set. */ -MPI q;/* Value is optional. */ MPI g;/* Value is guaranteed to be set. */ MPI xa;/* Value is guaranteed to be set. */ };
@@ -23,7 +22,6 @@ struct dh_ctx {static void dh_clear_ctx (struct dh_ctx *ctx) {mpi_free (ctx->p); -mpi_free (ctx->q);mpi_free (ctx->g);mpi_free (ctx->xa);memset (ctx,0 ,sizeof (*ctx));
@@ -99,11 +97,12 @@ static int dh_set_secret(struct crypto_kpp *tfm, const void *buf,/* * SP800-56A public key verification: * -* * If Q is provided as part of the domain paramenters, a full validation -* according to SP800-56A section 5.6.2.3.1 is performed. +* * For the safe-prime groups in FIPS mode, Q can be computed +* trivially from P and a full validation according to SP800-56A +* section 5.6.2.3.1 is performed. * -* * If Q is not provided, a partial validation according to SP800-56A section -* 5.6.2.3.2 is performed. +* * For all other sets of group parameters, only a partial validation +* according to SP800-56A section 5.6.2.3.2 is performed. */ static int dh_is_pubkey_valid (struct dh_ctx *ctx,MPI y) {
@@ -114,21 +113,40 @@ static int dh_is_pubkey_valid(struct dh_ctx *ctx, MPI y)* Step 1: Verify that 2 <= y <= p - 2. * * The upper limit check is actually y < p instead of y < p - 1 -* as the mpi_sub_ui function is yet missing. +* in order to save one mpi_sub_ui() invocation here. Note that +* p - 1 is the non-trivial element of the subgroup of order 2 and +* thus, the check on y^q below would fail if y == p - 1. */ if (mpi_cmp_ui (y,1 ) <1 ||mpi_cmp (y, ctx->p) >=0 )return -EINVAL ; -/* Step 2: Verify that 1 = y^q mod p */ -if (ctx->q) { -MPI val =mpi_alloc (0 ); +/* +* Step 2: Verify that 1 = y^q mod p +* +* For the safe-prime groups q = (p - 1)/2. +*/ +if (fips_enabled) { +MPI val, q;int ret; + val =mpi_alloc (0 );if (!val)return -ENOMEM ; - ret =mpi_powm (val, y, ctx->q, ctx->p); + q =mpi_alloc (mpi_get_nlimbs (ctx->p)); +if (!q) { +mpi_free (val); +return -ENOMEM ; + } + +/* +* ->p is odd, so no need to explicitly subtract one +* from it before shifting to the right. +*/ +mpi_rshift (q, ctx->p,1 ); + ret =mpi_powm (val, y, q, ctx->p); +mpi_free (q);if (ret) {mpi_free (val);return ret;
Signature · 1 line
2.26.2
Re: [PATCH v4 15/15] crypto: dh - calculate Q from P for the full public key verification
Quoted 10 lines · Nicolai Stange
As the ->q in struct
dh_ctxgets never set anywhere, the code indh_is_pubkey_valid()for doing the full public key validation in accordance to SP800-56Arev3 is effectively dead.However, for safe-prime groups Q = (P - 1)/2 by definition and as the safe-prime groups are the only possible groups in FIPS mode (via those
ffdheXYZ()templates), this enablesdh_is_pubkey_valid()to calculate Q on the fly for these.
Implement this.
Quoted 8 lines
With this change, the last code accessing struct dh_ctx's ->q is now gone. Remove this member from struct
dh_ctx.Signed-off-by Nicolai Stange <[email protected]>--- crypto/dh.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
Herbert Xu
maintainerQuoted 59 lines · Nicolai Stange
Hi all,
first of all, to the people primarily interested in
security/keys/, there's a rather trivial change tosecurity/keys/dh.cin patch 4/15. It would be great to get ACKs for that...This patchset's main objective is to provide the DH related preprequisite bits needed by the upcoming support for NVME in-band authentication ([1]), namely
- support for the RFC 7919 ffdheXYZ group parameters (patches [1-8/15]) and
- an ephemeral key generation primitive for these (patches [9-11/15]).With this in place, it happens to become relatively straight-forward to achieve conformance with NIST SP800-56Ar3. The remainder of this patchset, i.e. patches [12-15/15], implements the required changes.
The previous v3 of this patchset can be found at [2]. The only difference between v3 and the v4 here is the removal of a superfluous "default n"
Kconfigstatement in patch [7/15] ("crypto: dh - implement ffdheXYZ(dh) templates").I would like to reiterate that [12/15] ("crypto: api - allow algs only in specific constructions in FIPS mode") is heavily based on a patch previously posted by Herbert. Please refer to the v3 cover letter at [2] for the full history.
Finally note that Stephan has granted his
Tested-by Stephan Mueller <[email protected]>to v3 already ([3]). Stephan, with the trivial diff between v3 and v4, would you be Ok with carrying it over?
Thanks,
Nicolai
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]
[3] https://lore.kernel.org/r/[email protected]Nicolai Stange (15):
crypto: kpp - provide support for KPP template instances
crypto: kpp - provide support for KPP spawns
crypto: dh - remove struct dh's ->q member
crypto: dh - constify struct dh's pointer members
crypto: dh - split out deserialization code fromcrypto_dh_decode()
crypto: dh - introduce common code for built-in safe-prime group
support
crypto: dh - implement ffdheXYZ(dh) templates
crypto: testmgr - add known answer tests for ffdheXYZ(dh) templates
crypto: dh - implement private key generation primitive for
ffdheXYZ(dh)
crypto: testmgr - add keygen tests for ffdheXYZ(dh) templates
crypto: dh - allow for passing NULL to the ffdheXYZ(dh)s'->set_secret()crypto: api - allow algs only in specific constructions in FIPS mode
crypto: dh - disallow plain "dh" usage in FIPS mode lib/mpi: exportmpi_rshift
crypto: dh - calculate Q from P for the full public key verification
Quoted 15 lines
crypto/Kconfig | 7 + crypto/algapi.c | 18 +- crypto/api.c | 19 +- crypto/dh.c | 687 +++++++++++++++- crypto/dh_helper.c | 42 +- crypto/kpp.c | 29 + crypto/tcrypt.c | 4 +- crypto/testmgr.c | 61 +- crypto/testmgr.h | 1445 ++++++++++++++++++++++++++++++++- include/crypto/dh.h | 26 +- include/crypto/internal/kpp.h | 158 ++++ include/linux/crypto.h | 9 + lib/mpi/mpi-bit.c | 1 + security/keys/dh.c | 2 +- 14 files changed, 2441 insertions(+), 67 deletions(-)
All applied. 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