crypto: add EC-RDSA (GOST 34.10) algorithm
Subsystems (13)
v9 cover crypto: add EC-RDSA (GOST 34.10) algorithm
This patchset changes akcipher API to support ECDSA style signature verification, augments x509 parser to make it work with EC-RDSA certificates, and, finally, implements EC-RDSA (GOST 34.10) signature verification and its integration with IMA.
---
Changes since v8:
- asym_tpm: move setting set_pub_key parameters into derive_pub_key, as suggested by Denis Kenzior.
Changes since v7:
- Do not check callback validity in akcipher requests, instead define default callbacks on register, suggested by Herbert Xu.
- Sanity checks in crypto_akcipher_maxsize are removed (not needed).
- Sanity checks for dst' and dst_len' are removed from verify op (not needed in akcipher API and should be checked by a driver).
- Patch "KEYS: report to keyctl only actually supported key ops" is removed, as it would affect user-space API.
Changes since (v5-v6):
- set_params API is removed in favor of appending parameters into a key stream, as requested by Herbert Xu.
- verify op signature de-kmemdup'ed (as requested by David Howells) in separate patch (as requested by Herbert Xu).
- Add forgotten ASN.1 parser files to EC-RDSA patch.
- Tested on x86_64.
Changes since v5:
- Comparison of hash algo by enum id instead of text name, as suggested by Thiago Jung Bauermann and Mimi Zohar.
Changes since RFC (v1-v4):
- akcipher set_max_size, encrypt, decrypt, sign, verify callbacks may be undefined by the drivers, so their crypto_akcipher_* frontends check for their presence before passing the call.
- supported_ops flags are set for keyctl, based on the presence of implemented akcipher callbacks.
- Transition to verify2 API is abandoned because raw RSA does not need sign/verify ops at all, and we can switch to the new verify in one step. For this RSA backends have sign/verify ops removed as they should only be used (and actually used only) via PKCS1 driver.
- Verify callback requires digest as the input parameter in src SGL, as suggested by Herbert Xu, (instead of a separate parameter, as it was in verify2).
- For verify op signature is moved into kmalloc'd memory as suggested by Herbert Xu.
- set_params API should be called before set_{pub,priv}_key, thus set_*_key knows everything it needs to set they key properly. Also, set_params made optional for back compatibility with RSA drivers.
- Public-key cryptography section is created in Kconfig.
- ecc.c is made into separate module object, to be used together by ECDH and EC-RDSA.
- EC-RDSA parameters and public key are parsed using asn1_ber_decoder as suggested by Stephan Mueller and David Howells.
- Test vectors are added and tests are passing.
- Curves/parameters definitions are split from ecrdsa.c into ecrdsa_defs.h.
- Integration with IMA in asymmetric_verify(). Userspace ima-evm-utils already have a patch in the queue to support this. Tested on x86_64.
Vitaly Chikunov (10):
crypto: akcipher - default implementations for request callbacks
crypto: rsa - unimplement sign/verify for raw RSA backends
crypto: akcipher - new verify API for public key algorithms
KEYS: do not kmemdup digest in {public,tpm}_key_verify_signature X.509: parse public key parameters from x509 for akcipher
crypto: Kconfig - create Public-key cryptography section
crypto: ecc - make ecc into separate module
crypto: ecrdsa - add EC-RDSA (GOST 34.10) algorithm
crypto: ecrdsa - add EC-RDSA test vectors to testmgr
integrity: support EC-RDSA signatures for asymmetric_verify
crypto/Kconfig | 63 ++-- crypto/Makefile | 10 +- crypto/akcipher.c | 14 + crypto/asymmetric_keys/asym_tpm.c | 43 +-- crypto/asymmetric_keys/public_key.c | 105 ++++--- crypto/asymmetric_keys/x509.asn1 | 2 +- crypto/asymmetric_keys/x509_cert_parser.c | 57 +++- crypto/ecc.c | 417 +++++++++++++++++++++++++- crypto/ecc.h | 153 +++++++++- crypto/ecc_curve_defs.h | 15 - crypto/ecrdsa.c | 296 ++++++++++++++++++ crypto/ecrdsa_defs.h | 225 ++++++++++++++ crypto/ecrdsa_params.asn1 | 4 + crypto/ecrdsa_pub_key.asn1 | 1 + crypto/rsa-pkcs1pad.c | 33 +- crypto/rsa.c | 109 ------- crypto/testmgr.c | 80 +++-- crypto/testmgr.h | 159 ++++++++++ drivers/crypto/caam/caampkc.c | 2 - drivers/crypto/ccp/ccp-crypto-rsa.c | 2 - drivers/crypto/qat/qat_common/qat_asym_algs.c | 2 - include/crypto/akcipher.h | 54 ++-- include/crypto/public_key.h | 4 + include/linux/oid_registry.h | 18 ++ security/integrity/digsig_asymmetric.c | 11 +- 25 files changed, 1574 insertions(+), 305 deletions(-) create mode 100644 crypto/ecrdsa.c create mode 100644 crypto/ecrdsa_defs.h create mode 100644 crypto/ecrdsa_params.asn1 create mode 100644 crypto/ecrdsa_pub_key.asn1
Signature · 1 line
2.11.0
PATCH v9 1/10 crypto: akcipher - default implementations for request callbacks
Because with the introduction of EC-RDSA and change in workings of RSA in regard to sign/verify, akcipher could have not all callbacks defined, check the presence of callbacks in crypto_register_akcipher() and provide default implementation if the callback is not implemented.
This is suggested by Herbert Xu instead of checking the presence of the callback on every request.
--- crypto/akcipher.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
crypto/akcipher.c +14 -0
@@ -119,10 +119,24 @@ static void akcipher_prepare_alg(struct akcipher_alg *alg) base->cra_flags |=CRYPTO_ALG_TYPE_AKCIPHER ; } +static int akcipher_default_op (struct akcipher_request *req) +{ +return -ENOSYS ; +} +int crypto_register_akcipher (struct akcipher_alg *alg) {struct crypto_alg *base = &alg->base; +if (!alg->sign) + alg->sign = akcipher_default_op; +if (!alg->verify) + alg->verify = akcipher_default_op; +if (!alg->encrypt) + alg->encrypt = akcipher_default_op; +if (!alg->decrypt) + alg->decrypt = akcipher_default_op; +akcipher_prepare_alg (alg);return crypto_register_alg (base); }
Signature · 1 line
2.11.0
PATCH v9 2/10 crypto: rsa - unimplement sign/verify for raw RSA backends
In reply to Vitaly ChikunovIn preparation for new akcipher verify call remove sign/verify callbacks from RSA backends and make PKCS1 driver call encrypt/decrypt instead.
This also complies with the well-known idea that raw RSA should never be used for sign/verify. It only should be used with proper padding scheme such as PKCS1 driver provides.
--- crypto/rsa-pkcs1pad.c | 4 +- crypto/rsa.c | 109 -------------------------- drivers/crypto/caam/caampkc.c | 2 - drivers/crypto/ccp/ccp-crypto-rsa.c | 2 - drivers/crypto/qat/qat_common/qat_asym_algs.c | 2 - 5 files changed, 2 insertions(+), 117 deletions(-)
crypto/rsa-pkcs1pad.c +2 -2
@@ -429,7 +429,7 @@ static int pkcs1pad_sign(struct akcipher_request *req)akcipher_request_set_crypt (&req_ctx->child_req, req_ctx->in_sg, req->dst, ctx->key_size -1 , req->dst_len); - err =crypto_akcipher_sign (&req_ctx->child_req); + err =crypto_akcipher_decrypt (&req_ctx->child_req);if (err != -EINPROGRESS && err != -EBUSY )return pkcs1pad_encrypt_sign_complete (req, err);
@@ -551,7 +551,7 @@ static int pkcs1pad_verify(struct akcipher_request *req) req_ctx->out_sg, req->src_len, ctx->key_size); - err =crypto_akcipher_verify (&req_ctx->child_req); + err =crypto_akcipher_encrypt (&req_ctx->child_req);if (err != -EINPROGRESS && err != -EBUSY )return pkcs1pad_verify_complete (req, err);
crypto/rsa.c +0 -109
127 lines not on this page · raw message
drivers/crypto/caam/caampkc.c +0 -2
@@ -994,8 +994,6 @@ static void caam_rsa_exit_tfm(struct crypto_akcipher *tfm)static struct akcipher_alg caam_rsa = { .encrypt = caam_rsa_enc, .decrypt = caam_rsa_dec, - .sign = caam_rsa_dec, - .verify = caam_rsa_enc, .set_pub_key = caam_rsa_set_pub_key, .set_priv_key = caam_rsa_set_priv_key, .max_size = caam_rsa_max_size,
drivers/crypto/ccp/ccp-crypto-rsa.c +0 -2
@@ -213,8 +213,6 @@ static void ccp_rsa_exit_tfm(struct crypto_akcipher *tfm)static struct akcipher_alg ccp_rsa_defaults = { .encrypt = ccp_rsa_encrypt, .decrypt = ccp_rsa_decrypt, - .sign = ccp_rsa_decrypt, - .verify = ccp_rsa_encrypt, .set_pub_key = ccp_rsa_setpubkey, .set_priv_key = ccp_rsa_setprivkey, .max_size = ccp_rsa_maxsize,
drivers/crypto/qat/qat_common/qat_asym_algs.c +0 -2
@@ -1300,8 +1300,6 @@ static void qat_rsa_exit_tfm(struct crypto_akcipher *tfm)static struct akcipher_alg rsa = { .encrypt = qat_rsa_enc, .decrypt = qat_rsa_dec, - .sign = qat_rsa_dec, - .verify = qat_rsa_enc, .set_pub_key = qat_rsa_setpubkey, .set_priv_key = qat_rsa_setprivkey, .max_size = qat_rsa_max_size,
Signature · 1 line
2.11.0
PATCH v9 3/10 crypto: akcipher - new verify API for public key algorithms
In reply to Vitaly ChikunovPrevious akcipher .verify() just `decrypts' (using RSA encrypt which is using public key) signature to uncover message hash, which was then compared in upper level public_key_verify_signature() with the expected hash value, which itself was never passed into verify().
This approach was incompatible with EC-DSA family of algorithms, because, to verify a signature EC-DSA algorithm also needs a hash value as input; then it's used (together with a signature divided into halves r||s') to produce a witness value, which is then compared with r' to determine if the signature is correct. Thus, for EC-DSA, nor requirements of .verify() itself, nor its output expectations in public_key_verify_signature() wasn't sufficient.
Make improved .verify() call which gets hash value as input and produce complete signature check without any output besides status.
Now for the top level verification only crypto_akcipher_verify() needs to be called and its return value inspected.
Make sure that digest' is in kmalloc'd memory (in place of output`) in {public,tpm}_key_verify_signature() as insisted by Herbert Xu, and will be changed in the following commit.
--- crypto/asymmetric_keys/asym_tpm.c | 34 ++++++++----------------- crypto/asymmetric_keys/public_key.c | 34 ++++++++----------------- crypto/rsa-pkcs1pad.c | 29 +++++++++++++-------- crypto/testmgr.c | 50 ++++++++++++++++++++++--------------- include/crypto/akcipher.h | 36 ++++++++++++++++---------- 5 files changed, 92 insertions(+), 91 deletions(-)
crypto/asymmetric_keys/asym_tpm.c +10 -24
@@ -744,12 +744,11 @@ static int tpm_key_verify_signature(const struct key *key,struct crypto_wait cwait;struct crypto_akcipher *tfm;struct akcipher_request *req; -struct scatterlist sig_sg, digest_sg; +struct scatterlist src_sg[2 ];char alg_name[CRYPTO_MAX_ALG_NAME ];uint8_t der_pub_key[PUB_KEY_BUF_SIZE ];uint32_t der_pub_key_len; -void *output; -unsigned int outlen; +void *digest;int ret;pr_devel ("=>%s()\n" , __func__);
@@ -782,35 +781,22 @@ static int tpm_key_verify_signature(const struct key *key, goto error_free_tfm; ret = -ENOMEM ; - outlen =crypto_akcipher_maxsize (tfm); - output =kmalloc (outlen,GFP_KERNEL ); -if (!output) + digest =kmemdup (sig->digest, sig->digest_size,GFP_KERNEL ); +if (!digest) goto error_free_req; -sg_init_one (&sig_sg, sig->s, sig->s_size); -sg_init_one (&digest_sg, output, outlen); -akcipher_request_set_crypt (req, &sig_sg, &digest_sg, sig->s_size, - outlen); +sg_init_table (src_sg,2 ); +sg_set_buf (&src_sg[0 ], sig->s, sig->s_size); +sg_set_buf (&src_sg[1 ], digest, sig->digest_size); +akcipher_request_set_crypt (req, src_sg,NULL , sig->s_size, + sig->digest_size);crypto_init_wait (&cwait);akcipher_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG |CRYPTO_TFM_REQ_MAY_SLEEP , crypto_req_done, &cwait); - -/* Perform the verification calculation. This doesn't actually do the -* verification, but rather calculates the hash expected by the -* signature and returns that to us. -*/ ret =crypto_wait_req (crypto_akcipher_verify (req), &cwait); -if (ret) - goto out_free_output; - -/* Do the actual verification step. */ -if (req->dst_len != sig->digest_size || -memcmp (sig->digest, output, sig->digest_size) !=0 ) - ret = -EKEYREJECTED ; -out_free_output: -kfree (output); +kfree (digest); error_free_req:akcipher_request_free (req); error_free_tfm:
crypto/asymmetric_keys/public_key.c +10 -24
@@ -227,10 +227,9 @@ int public_key_verify_signature(const struct public_key *pkey,struct crypto_wait cwait;struct crypto_akcipher *tfm;struct akcipher_request *req; -struct scatterlist sig_sg, digest_sg; +struct scatterlist src_sg[2 ];char alg_name[CRYPTO_MAX_ALG_NAME ]; -void *output; -unsigned int outlen; +void *digest;int ret;pr_devel ("=>%s()\n" , __func__);
@@ -264,35 +263,22 @@ int public_key_verify_signature(const struct public_key *pkey, goto error_free_req; ret = -ENOMEM ; - outlen =crypto_akcipher_maxsize (tfm); - output =kmalloc (outlen,GFP_KERNEL ); -if (!output) + digest =kmemdup (sig->digest, sig->digest_size,GFP_KERNEL ); +if (!digest) goto error_free_req; -sg_init_one (&sig_sg, sig->s, sig->s_size); -sg_init_one (&digest_sg, output, outlen); -akcipher_request_set_crypt (req, &sig_sg, &digest_sg, sig->s_size, - outlen); +sg_init_table (src_sg,2 ); +sg_set_buf (&src_sg[0 ], sig->s, sig->s_size); +sg_set_buf (&src_sg[1 ], digest, sig->digest_size); +akcipher_request_set_crypt (req, src_sg,NULL , sig->s_size, + sig->digest_size);crypto_init_wait (&cwait);akcipher_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG |CRYPTO_TFM_REQ_MAY_SLEEP , crypto_req_done, &cwait); - -/* Perform the verification calculation. This doesn't actually do the -* verification, but rather calculates the hash expected by the -* signature and returns that to us. -*/ ret =crypto_wait_req (crypto_akcipher_verify (req), &cwait); -if (ret) - goto out_free_output; - -/* Do the actual verification step. */ -if (req->dst_len != sig->digest_size || -memcmp (sig->digest, output, sig->digest_size) !=0 ) - ret = -EKEYREJECTED ; -out_free_output: -kfree (output); +kfree (digest); error_free_req:akcipher_request_free (req); error_free_tfm:
crypto/rsa-pkcs1pad.c +19 -10
@@ -488,14 +488,21 @@ static int pkcs1pad_verify_complete(struct akcipher_request *req, int err) err =0 ; -if (req->dst_len < dst_len - pos) - err = -EOVERFLOW ; - req->dst_len = dst_len - pos; - -if (!err) -sg_copy_from_buffer (req->dst, -sg_nents_for_len (req->dst, req->dst_len), - out_buf + pos, req->dst_len); +if (req->dst_len != dst_len - pos) { + err = -EKEYREJECTED ; + req->dst_len = dst_len - pos; + goto done; + } +/* Extract appended digest. */ +sg_pcopy_to_buffer (req->src, +sg_nents_for_len (req->src, + req->src_len + req->dst_len), + req_ctx->out_buf + ctx->key_size, + req->dst_len, ctx->key_size); +/* Do the actual verification step. */ +if (memcmp (req_ctx->out_buf + ctx->key_size, out_buf + pos, + req->dst_len) !=0 ) + err = -EKEYREJECTED ; done:kzfree (req_ctx->out_buf);
@@ -532,10 +539,12 @@ static int pkcs1pad_verify(struct akcipher_request *req)struct pkcs1pad_request *req_ctx =akcipher_request_ctx (req);int err; -if (!ctx->key_size || req->src_len < ctx->key_size) +if (WARN_ON (req->dst) || +WARN_ON (!req->dst_len) || + !ctx->key_size || req->src_len < ctx->key_size)return -EINVAL ; - req_ctx->out_buf =kmalloc (ctx->key_size,GFP_KERNEL ); + req_ctx->out_buf =kmalloc (ctx->key_size + req->dst_len,GFP_KERNEL );if (!req_ctx->out_buf)return -ENOMEM ;
crypto/testmgr.c +30 -20
80 lines not on this page · raw message
include/crypto/akcipher.h +23 -13
@@ -19,14 +19,20 @@* * @base: Common attributes for async crypto requests * @src: Source data -* @dst: Destination data +* For verify op this is signature + digest, in that case +* total size of @src is @src_len + @dst_len. +* @dst: Destination data (Should be NULL for verify op) * @src_len: Size of the input buffer -* @dst_len: Size of the output buffer. It needs to be at least -* as big as the expected result depending on the operation +* For verify op it's size of signature part of @src, this part +* is supposed to be operated by cipher. +* @dst_len: Size of @dst buffer (for all ops except verify). +* It needs to be at least as big as the expected result +* depending on the operation. * After operation it will be updated with the actual size of the * result. * In case of error where the dst sgl size was insufficient, * it will be updated to the size required for the operation. +* For verify op this is size of digest part in @src. * @__ctx: Start of private context data */ struct akcipher_request {
@@ -55,10 +61,9 @@ struct crypto_akcipher {* algorithm. In case of error, where the dst_len was insufficient, * the req->dst_len will be updated to the size required for the * operation -* @verify: Function performs a sign operation as defined by public key -* algorithm. In case of error, where the dst_len was insufficient, -* the req->dst_len will be updated to the size required for the -* operation +* @verify: Function performs a complete verify operation as defined by +* public key algorithm, returning verification status. Requires +* digest value as input parameter. * @encrypt: Function performs an encrypt operation as defined by public key * algorithm. In case of error, where the dst_len was insufficient, * the req->dst_len will be updated to the size required for the
@@ -238,9 +243,10 @@ static inline void akcipher_request_set_callback(struct akcipher_request *req,* * @req: public key request * @src: ptr to input scatter list -* @dst: ptr to output scatter list +* @dst: ptr to output scatter list or NULL for verify op * @src_len: size of the src input scatter list to be processed -* @dst_len: size of the dst output scatter list +* @dst_len: size of the dst output scatter list or size of signature +* portion in @src for verify op */ static inline void akcipher_request_set_crypt(struct akcipher_request *req, struct scatterlist *src,
@@ -343,14 +349,18 @@ static inline int crypto_akcipher_sign(struct akcipher_request *req) }/** -* crypto_akcipher_verify() - Invoke public key verify operation +* crypto_akcipher_verify() - Invoke public key signature verification * -* Function invokes the specific public key verify operation for a given -* public key algorithm +* Function invokes the specific public key signature verification operation +* for a given public key algorithm. * * @req: asymmetric key request * -* Return: zero on success; error code in case of error +* Note: req->dst should be NULL, req->src should point to SG of size +* (req->src_size + req->dst_size), containing signature (of req->src_size +* length) with appended digest (of req->dst_size length). +* +* Return: zero on verification success; error code in case of error. */ static inline int crypto_akcipher_verify (struct akcipher_request *req) {
Signature · 1 line
2.11.0
PATCH v9 4/10 KEYS: do not kmemdup digest in {public,tpm}_key_verify_signature
In reply to Vitaly ChikunovTreat (struct public_key_signature)'s digest same as its signature (s). Since digest should be already in the kmalloc'd memory do not kmemdup digest value before calling {public,tpm}_key_verify_signature.
Patch is split from the previous as suggested by Herbert Xu.
--- crypto/asymmetric_keys/asym_tpm.c | 10 +--------- crypto/asymmetric_keys/public_key.c | 9 +-------- 2 files changed, 2 insertions(+), 17 deletions(-)
crypto/asymmetric_keys/asym_tpm.c +1 -9
@@ -748,7 +748,6 @@ static int tpm_key_verify_signature(const struct key *key,char alg_name[CRYPTO_MAX_ALG_NAME ];uint8_t der_pub_key[PUB_KEY_BUF_SIZE ];uint32_t der_pub_key_len; -void *digest;int ret;pr_devel ("=>%s()\n" , __func__);
@@ -780,14 +779,9 @@ static int tpm_key_verify_signature(const struct key *key,if (!req) goto error_free_tfm; - ret = -ENOMEM ; - digest =kmemdup (sig->digest, sig->digest_size,GFP_KERNEL ); -if (!digest) - goto error_free_req; -sg_init_table (src_sg,2 );sg_set_buf (&src_sg[0 ], sig->s, sig->s_size); -sg_set_buf (&src_sg[1 ], digest, sig->digest_size); +sg_set_buf (&src_sg[1 ], sig->digest, sig->digest_size);akcipher_request_set_crypt (req, src_sg,NULL , sig->s_size, sig->digest_size);crypto_init_wait (&cwait);
@@ -796,8 +790,6 @@ static int tpm_key_verify_signature(const struct key *key, crypto_req_done, &cwait); ret =crypto_wait_req (crypto_akcipher_verify (req), &cwait); -kfree (digest); -error_free_req:akcipher_request_free (req); error_free_tfm:crypto_free_akcipher (tfm);
crypto/asymmetric_keys/public_key.c +1 -8
@@ -229,7 +229,6 @@ int public_key_verify_signature(const struct public_key *pkey,struct akcipher_request *req;struct scatterlist src_sg[2 ];char alg_name[CRYPTO_MAX_ALG_NAME ]; -void *digest;int ret;pr_devel ("=>%s()\n" , __func__);
@@ -262,14 +261,9 @@ int public_key_verify_signature(const struct public_key *pkey,if (ret) goto error_free_req; - ret = -ENOMEM ; - digest =kmemdup (sig->digest, sig->digest_size,GFP_KERNEL ); -if (!digest) - goto error_free_req; -sg_init_table (src_sg,2 );sg_set_buf (&src_sg[0 ], sig->s, sig->s_size); -sg_set_buf (&src_sg[1 ], digest, sig->digest_size); +sg_set_buf (&src_sg[1 ], sig->digest, sig->digest_size);akcipher_request_set_crypt (req, src_sg,NULL , sig->s_size, sig->digest_size);crypto_init_wait (&cwait);
@@ -278,7 +272,6 @@ int public_key_verify_signature(const struct public_key *pkey, crypto_req_done, &cwait); ret =crypto_wait_req (crypto_akcipher_verify (req), &cwait); -kfree (digest); error_free_req:akcipher_request_free (req); error_free_tfm:
Signature · 1 line
2.11.0
PATCH v9 5/10 X.509: parse public key parameters from x509 for akcipher
In reply to Vitaly ChikunovSome public key algorithms (like EC-DSA) keep in parameters field important data such as digest and curve OIDs (possibly more for different EC-DSA variants). Thus, just setting a public key (as for RSA) is not enough.
Append parameters into the key stream for akcipher_set_{pub,priv}_key. Appended data is: (u32) algo OID, (u32) parameters length, parameters data.
This does not affect current akcipher API nor RSA ciphers (they could ignore it). Idea of appending parameters to the key stream is by Herbert Xu.
--- crypto/asymmetric_keys/asym_tpm.c | 9 +++- crypto/asymmetric_keys/public_key.c | 72 ++++++++++++++++++++++++------- crypto/asymmetric_keys/x509.asn1 | 2 +- crypto/asymmetric_keys/x509_cert_parser.c | 31 +++++++++++++ crypto/testmgr.c | 24 +++++++++-- crypto/testmgr.h | 5 +++ include/crypto/akcipher.h | 18 ++++---- include/crypto/public_key.h | 4 ++ 8 files changed, 136 insertions(+), 29 deletions(-)
crypto/asymmetric_keys/asym_tpm.c +8 -1
@@ -276,6 +276,10 @@ static int tpm_sign(struct tpm_buf *tb,return datalen; } + +/* Room to fit two u32 zeros for algo id and parameters length. */ +#define SETKEY_PARAMS_SIZE (sizeof(u32) * 2) +/* * Maximum buffer size for the BER/DER encoded public key. The public key * is of the form SEQUENCE { INTEGER n, INTEGER e } where n is a maximum 2048
@@ -286,8 +290,9 @@ static int tpm_sign(struct tpm_buf *tb,* - 257 bytes of n * - max 2 bytes for INTEGER e type/length * - 3 bytes of e +* - 4+4 of zeros for set_pub_key parameters (SETKEY_PARAMS_SIZE) */ -#define PUB_KEY_BUF_SIZE (4 + 4 + 257 + 2 + 3) +#define PUB_KEY_BUF_SIZE (4 + 4 + 257 + 2 + 3 + SETKEY_PARAMS_SIZE)/* * Provide a part of a description of the key for /proc/keys.
@@ -364,6 +369,8 @@ static uint32_t derive_pub_key(const void *pub_key, uint32_t len, uint8_t *buf) cur =encode_tag_length (cur,0x02 ,sizeof (e));memcpy (cur, e,sizeof (e)); cur +=sizeof (e); +/* Zero parameters to satisfy set_pub_key ABI. */ +memset (cur,0 ,SETKEY_PARAMS_SIZE );return cur - buf; }
crypto/asymmetric_keys/public_key.c +57 -15
147 lines not on this page · raw message
crypto/asymmetric_keys/x509.asn1 +1 -1
@@ -22,7 +22,7 @@ CertificateSerialNumber ::= INTEGER AlgorithmIdentifier ::= SEQUENCE { algorithm OBJECT IDENTIFIER ({ x509_note_OID }), - parameters ANY OPTIONAL + parameters ANY OPTIONAL ({ x509_note_params }) } Name ::= SEQUENCE OF RelativeDistinguishedName
crypto/asymmetric_keys/x509_cert_parser.c +31 -0
@@ -26,6 +26,9 @@ struct x509_parse_context {const void *cert_start;/* Start of cert content */ const void *key;/* Key data */ size_t key_size;/* Size of key data */ +const void *params;/* Key parameters */ +size_t params_size;/* Size of key parameters */ +enum OID key_algo;/* Public key algorithm */ enum OID last_oid;/* Last OID encountered */ enum OID algo_oid;/* Algorithm OID */ unsigned char nr_mpi;/* Number of MPIs stored */
@@ -109,6 +112,13 @@ struct x509_certificate *x509_cert_parse(const void *data, size_t datalen) cert->pub->keylen = ctx->key_size; + cert->pub->params =kmemdup (ctx->params, ctx->params_size,GFP_KERNEL ); +if (!cert->pub->params) + goto error_decode; + + cert->pub->paramlen = ctx->params_size; + cert->pub->algo = ctx->key_algo; +/* Grab the signature bits */ ret =x509_get_sig_params (cert);if (ret <0 )
@@ -401,6 +411,27 @@ int x509_note_subject(void *context, size_t hdrlen, }/* +* Extract the parameters for the public key +*/ +int x509_note_params (void *context,size_t hdrlen, +unsigned char tag, +const void *value,size_t vlen) +{ +struct x509_parse_context *ctx = context; + +/* +* AlgorithmIdentifier is used three times in the x509, we should skip +* first and ignore third, using second one which is after subject and +* before subjectPublicKey. +*/ +if (!ctx->cert->raw_subject || ctx->key) +return 0 ; + ctx->params = value - hdrlen; + ctx->params_size = vlen + hdrlen; +return 0 ; +} + +/* * Extract the data for the public key algorithm */ int x509_extract_key_data(void *context, size_t hdrlen,
crypto/testmgr.c +20 -4
@@ -2585,6 +2585,12 @@ static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,return err; } +static u8 *test_pack_u32 (u8 *dst,u32 val) +{ +memcpy (dst, &val,sizeof (val)); +return dst +sizeof (val); +} +static int test_akcipher_one (struct crypto_akcipher *tfm,const struct akcipher_testvec *vecs) {
@@ -2599,6 +2605,7 @@ static int test_akcipher_one(struct crypto_akcipher *tfm,const char *m, *c;unsigned int m_size, c_size;const char *op; +u8 *key, *ptr;if (testmgr_alloc_buf (xbuf))return err;
@@ -2609,12 +2616,20 @@ static int test_akcipher_one(struct crypto_akcipher *tfm,crypto_init_wait (&wait); + key =kmalloc (vecs->key_len +sizeof (u32) *2 + vecs->param_len, +GFP_KERNEL ); +if (!key) + goto free_xbuf; +memcpy (key, vecs->key, vecs->key_len); + ptr = key + vecs->key_len; + ptr =test_pack_u32 (ptr, vecs->algo); + ptr =test_pack_u32 (ptr, vecs->param_len); +memcpy (ptr, vecs->params, vecs->param_len); +if (vecs->public_key_vec) - err =crypto_akcipher_set_pub_key (tfm, vecs->key, - vecs->key_len); + err =crypto_akcipher_set_pub_key (tfm, key, vecs->key_len);else - err =crypto_akcipher_set_priv_key (tfm, vecs->key, - vecs->key_len); + err =crypto_akcipher_set_priv_key (tfm, key, vecs->key_len);if (err) goto free_req;
@@ -2744,6 +2759,7 @@ static int test_akcipher_one(struct crypto_akcipher *tfm,kfree (outbuf_enc); free_req:akcipher_request_free (req); +kfree (key); free_xbuf:testmgr_free_buf (xbuf);return err;
crypto/testmgr.h +5 -0
@@ -25,6 +25,8 @@#ifndef _CRYPTO_TESTMGR_H#define _CRYPTO_TESTMGR_H +#include <linux/oid_registry.h> +#define MAX_IVLEN 32/*
@@ -135,13 +137,16 @@ struct drbg_testvec {struct akcipher_testvec {const unsigned char *key; +const unsigned char *params;const unsigned char *m;const unsigned char *c;unsigned int key_len; +unsigned int param_len;unsigned int m_size;unsigned int c_size;bool public_key_vec;bool siggen_sigver_test; +enum OID algo; };struct kpp_testvec {
include/crypto/akcipher.h +10 -8
@@ -74,10 +74,10 @@ struct crypto_akcipher {* operation * @set_pub_key: Function invokes the algorithm specific set public key * function, which knows how to decode and interpret -* the BER encoded public key +* the BER encoded public key and parameters * @set_priv_key: Function invokes the algorithm specific set private key * function, which knows how to decode and interpret -* the BER encoded private key +* the BER encoded private key and parameters * @max_size: Function returns dest buffer size required for a given key. * @init: Initialize the cryptographic transformation object. * This function is used to initialize the cryptographic
@@ -379,11 +379,12 @@ static inline int crypto_akcipher_verify(struct akcipher_request *req)* crypto_akcipher_set_pub_key() - Invoke set public key operation * * Function invokes the algorithm specific set key function, which knows -* how to decode and interpret the encoded key +* how to decode and interpret the encoded key and parameters * * @tfm: tfm handle -* @key: BER encoded public key -* @keylen: length of the key +* @key: BER encoded public key, algo OID, paramlen, BER encoded +* parameters +* @keylen: length of the key (not including other data) * * Return: zero on success; error code in case of error */
@@ -400,11 +401,12 @@ static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm,* crypto_akcipher_set_priv_key() - Invoke set private key operation * * Function invokes the algorithm specific set key function, which knows -* how to decode and interpret the encoded key +* how to decode and interpret the encoded keya and parameters * * @tfm: tfm handle -* @key: BER encoded private key -* @keylen: length of the key +* @key: BER encoded private key, algo OID, paramlen, BER encoded +* parameters +* @keylen: length of the key (not including other data) * * Return: zero on success; error code in case of error */
include/crypto/public_key.h +4 -0
@@ -15,6 +15,7 @@#define _LINUX_PUBLIC_KEY_H#include <linux/keyctl.h> +#include <linux/oid_registry.h> /* * Cryptographic data for the public-key subtype of the asymmetric key type.
@@ -25,6 +26,9 @@struct public_key {void *key;u32 keylen; +enum OID algo; +void *params; +u32 paramlen;bool key_is_private;const char *id_type;const char *pkey_algo;
Signature · 1 line
2.11.0
PATCH v9 6/10 crypto: Kconfig - create Public-key cryptography section
In reply to Vitaly ChikunovGroup RSA, DH, and ECDH into Public-key cryptography config section.
--- crypto/Kconfig | 48 +++++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 23 deletions(-)
crypto/Kconfig +25 -23
@@ -113,29 +113,6 @@ config CRYPTO_ACOMP select CRYPTO_ALGAPI select CRYPTO_ACOMP2 -config CRYPTO_RSA - tristate "RSA algorithm" - select CRYPTO_AKCIPHER - select CRYPTO_MANAGER - select MPILIB - select ASN1 - help - Generic implementation of the RSA public key algorithm. - -config CRYPTO_DH - tristate "Diffie-Hellman algorithm" - select CRYPTO_KPP - select MPILIB - help - Generic implementation of the Diffie-Hellman algorithm. - -config CRYPTO_ECDH - tristate "ECDH algorithm" - select CRYPTO_KPP - select CRYPTO_RNG_DEFAULT - help - Generic implementation of the ECDH algorithm - config CRYPTO_MANAGER tristate "Cryptographic algorithm manager" select CRYPTO_MANAGER2
@@ -253,6 +230,31 @@ config CRYPTO_GLUE_HELPER_X86 config CRYPTO_ENGINE tristate +comment "Public-key cryptography" + +config CRYPTO_RSA + tristate "RSA algorithm" + select CRYPTO_AKCIPHER + select CRYPTO_MANAGER + select MPILIB + select ASN1 + help + Generic implementation of the RSA public key algorithm. + +config CRYPTO_DH + tristate "Diffie-Hellman algorithm" + select CRYPTO_KPP + select MPILIB + help + Generic implementation of the Diffie-Hellman algorithm. + +config CRYPTO_ECDH + tristate "ECDH algorithm" + select CRYPTO_KPP + select CRYPTO_RNG_DEFAULT + help + Generic implementation of the ECDH algorithm + comment "Authenticated Encryption with Associated Data" config CRYPTO_CCM
Signature · 1 line
2.11.0
PATCH v9 7/10 crypto: ecc - make ecc into separate module
In reply to Vitaly Chikunovecc.c have algorithms that could be used togeter by ecdh and ecrdsa. Make it separate module. Add CRYPTO_ECC into Kconfig. EXPORT_SYMBOL and document to what seems appropriate. Move structs ecc_point and ecc_curve from ecc_curve_defs.h into ecc.h.
No code changes.
--- crypto/Kconfig | 4 ++ crypto/Makefile | 2 +- crypto/ecc.c | 25 +++++++++---- crypto/ecc.h | 99 +++++++++++++++++++++++++++++++++++++++++++++++++ crypto/ecc_curve_defs.h | 15 -------- 5 files changed, 122 insertions(+), 23 deletions(-)
crypto/Kconfig +4 -0
@@ -248,8 +248,12 @@ config CRYPTO_DH help Generic implementation of the Diffie-Hellman algorithm. +config CRYPTO_ECC + tristate + config CRYPTO_ECDH tristate "ECDH algorithm" + select CRYPTO_ECC select CRYPTO_KPP select CRYPTO_RNG_DEFAULT help
crypto/Makefile +1 -1
@@ -147,8 +147,8 @@ obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o obj-$(CONFIG_CRYPTO_OFB) += ofb.o +obj-$(CONFIG_CRYPTO_ECC) += ecc.o -ecdh_generic-y := ecc.o ecdh_generic-y += ecdh.o ecdh_generic-y += ecdh_helper.o obj-$(CONFIG_CRYPTO_ECDH) += ecdh_generic.o
crypto/ecc.c +18 -7
@@ -24,6 +24,7 @@* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include <linux/module.h> #include <linux/random.h> #include <linux/slab.h> #include <linux/swab.h>
@@ -112,7 +113,7 @@ static void vli_clear(u64 *vli, unsigned int ndigits) }/* Returns true if vli = 0, false otherwise. */ -static bool vli_is_zero (const u64 *vli,unsigned int ndigits) +bool vli_is_zero (const u64 *vli,unsigned int ndigits) {int i;
@@ -123,6 +124,7 @@ static bool vli_is_zero(const u64 *vli, unsigned int ndigits)return true; } +EXPORT_SYMBOL (vli_is_zero);/* Returns nonzero if bit bit of vli is set. */ static u64 vli_test_bit (const u64 *vli,unsigned int bit)
@@ -171,7 +173,7 @@ static void vli_set(u64 *dest, const u64 *src, unsigned int ndigits) }/* Returns sign of left - right. */ -static int vli_cmp (const u64 *left,const u64 *right,unsigned int ndigits) +int vli_cmp (const u64 *left,const u64 *right,unsigned int ndigits) {int i;
@@ -184,6 +186,7 @@ static int vli_cmp(const u64 *left, const u64 *right, unsigned int ndigits)return 0 ; } +EXPORT_SYMBOL (vli_cmp);/* Computes result = in << c, returning carry. Can modify in place * (if result = in). 0 < shift < 64.
@@ -240,7 +243,7 @@ static u64 vli_add(u64 *result, const u64 *left, const u64 *right, }/* Computes result = left - right, returning borrow. Can modify in place. */ -static u64 vli_sub (u64 *result,const u64 *left,const u64 *right, +u64 vli_sub (u64 *result,const u64 *left,const u64 *right,unsigned int ndigits) {u64 borrow =0 ;
@@ -258,6 +261,7 @@ static u64 vli_sub(u64 *result, const u64 *left, const u64 *right,return borrow; } +EXPORT_SYMBOL (vli_sub);static uint128_t mul_64_64 (u64 left,u64 right) {
@@ -557,7 +561,7 @@ static void vli_mod_square_fast(u64 *result, const u64 *left,* See "From Euclid's GCD to Montgomery Multiplication to the Great Divide" * https://labs.oracle.com/techrep/2001/smli_tr-2001-95.pdf */ -static void vli_mod_inv (u64 *result,const u64 *input,const u64 *mod, +void vli_mod_inv (u64 *result,const u64 *input,const u64 *mod,unsigned int ndigits) {u64 a[ECC_MAX_DIGITS ], b[ECC_MAX_DIGITS ];
@@ -630,6 +634,7 @@ static void vli_mod_inv(u64 *result, const u64 *input, const u64 *mod,vli_set (result, u, ndigits); } +EXPORT_SYMBOL (vli_mod_inv);/* ------ Point operations ------ */
@@ -948,6 +953,7 @@ int ecc_is_key_valid(unsigned int curve_id, unsigned int ndigits,return __ecc_is_key_valid (curve, private_key, ndigits); } +EXPORT_SYMBOL (ecc_is_key_valid);/* * ECC private keys are generated using the method of extra random bits,
@@ -1000,6 +1006,7 @@ int ecc_gen_privkey(unsigned int curve_id, unsigned int ndigits, u64 *privkey)return 0 ; } +EXPORT_SYMBOL (ecc_gen_privkey);int ecc_make_pub_key (unsigned int curve_id,unsigned int ndigits,const u64 *private_key,u64 *public_key)
@@ -1036,10 +1043,11 @@ int ecc_make_pub_key(unsigned int curve_id, unsigned int ndigits, out:return ret; } +EXPORT_SYMBOL (ecc_make_pub_key);/* SP800-56A section 5.6.2.3.4 partial verification: ephemeral keys only */ -static int ecc_is_pubkey_valid_partial (const struct ecc_curve *curve, -struct ecc_point *pk) +int ecc_is_pubkey_valid_partial (const struct ecc_curve *curve, +struct ecc_point *pk) {u64 yy[ECC_MAX_DIGITS ], xxx[ECC_MAX_DIGITS ], w[ECC_MAX_DIGITS ];
@@ -1064,8 +1072,8 @@ static int ecc_is_pubkey_valid_partial(const struct ecc_curve *curve,return -EINVAL ;return 0 ; - } +EXPORT_SYMBOL (ecc_is_pubkey_valid_partial); int crypto_ecdh_shared_secret(unsigned int curve_id, unsigned int ndigits, const u64 *private_key, const u64 *public_key,
@@ -1121,3 +1129,6 @@ int crypto_ecdh_shared_secret(unsigned int curve_id, unsigned int ndigits, out:return ret; } +EXPORT_SYMBOL (crypto_ecdh_shared_secret); + +MODULE_LICENSE ("Dual BSD/GPL" );
crypto/ecc.h +99 -0
109 lines not on this page · raw message
crypto/ecc_curve_defs.h +0 -15
@@ -2,21 +2,6 @@#ifndef _CRYTO_ECC_CURVE_DEFS_H#define _CRYTO_ECC_CURVE_DEFS_H -struct ecc_point { -u64 *x; -u64 *y; -u8 ndigits; -}; - -struct ecc_curve { -char *name; -struct ecc_point g; -u64 *p; -u64 *n; -u64 *a; -u64 *b; -}; -/* NIST P-192: a = p - 3 */ static u64 nist_p192_g_x[] = {0xF4FF0AFD82FF1012ull ,0x7CBF20EB43A18800ull ,0x188DA80EB03090F6ull };
Signature · 1 line
2.11.0
PATCH v9 8/10 crypto: ecrdsa - add EC-RDSA (GOST 34.10) algorithm
In reply to Vitaly ChikunovAdd Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012, RFC 7091, ISO/IEC 14888-3) is one of the Russian (and since 2018 the CIS countries) cryptographic standard algorithms (called GOST algorithms). Only signature verification is supported, with intent to be used in the IMA.
Summary of the changes:
* crypto/Kconfig:
- EC-RDSA is added into Public-key cryptography section.
* crypto/Makefile:
- ecrdsa objects are added.
* crypto/asymmetric_keys/x509_cert_parser.c:
- Recognize EC-RDSA and Streebog OIDs.
* include/linux/oid_registry.h:
- EC-RDSA OIDs are added to the enum. Also, a two currently not implemented curve OIDs are added for possible extension later (to not change numbering and grouping).
* crypto/ecc.c:
- Kenneth MacKay copyright date is updated to 2014, because vli_mmod_slow, ecc_point_add, ecc_point_mult_shamir are based on his code from micro-ecc.
- Functions needed for ecrdsa are EXPORT_SYMBOL'ed.
- New functions:
vli_is_negative - helper to determine sign of vli; vli_from_be64 - unpack big-endian array into vli (used for
a signature);
vli_from_le64 - unpack little-endian array into vli (used for
a public key);
vli_uadd, vli_usub - add/sub u64 value to/from vli (used for
increment/decrement);
mul_64_64 - optimized to use __int128 where appropriate, this speeds
up point multiplication (and as a consequence signature verification) by the factor of 1.5-2;
vli_umult - multiply vli by a small value (speeds up point
multiplication by another factor of 1.5-2, depending on vli sizes);
vli_mmod_special - module reduction for some form of Pseudo-Mersenne
primes (used for the curves A);
vli_mmod_special2 - module reduction for another form of
Pseudo-Mersenne primes (used for the curves B);
vli_mmod_barrett - module reduction using pre-computed value (used
for the curve C);
vli_mmod_slow - more general module reduction which is much slower
(used when the modulus is subgroup order);
vli_mod_mult_slow - modular multiplication;
ecc_point_add - add two points;
ecc_point_mult_shamir - add two points multiplied by scalars in one
combined multiplication (this gives speed up by another factor 2 in compare to two separate multiplications).
ecc_is_pubkey_valid_partial - additional samity check is added.
- Updated vli_mmod_fast with non-strict heuristic to call optimal
module reduction function depending on the prime value;
- All computations for the previously defined (two NIST) curves should not unaffected.
* crypto/ecc.h:
- Newly exported functions are documented.
* crypto/ecrdsa_defs.h
- Five curves are defined.
* crypto/ecrdsa.c:
- Signature verification is implemented.
* crypto/ecrdsa_params.asn1, crypto/ecrdsa_pub_key.asn1:
- Templates for BER decoder for EC-RDSA parameters and public key.
--- crypto/Kconfig | 11 + crypto/Makefile | 8 + crypto/asymmetric_keys/x509_cert_parser.c | 26 +- crypto/ecc.c | 392 +++++++++++++++++++++++++++++- crypto/ecc.h | 54 +++- crypto/ecrdsa.c | 296 ++++++++++++++++++++++ crypto/ecrdsa_defs.h | 225 +++++++++++++++++ crypto/ecrdsa_params.asn1 | 4 + crypto/ecrdsa_pub_key.asn1 | 1 + include/linux/oid_registry.h | 18 ++ 10 files changed, 1022 insertions(+), 13 deletions(-) create mode 100644 crypto/ecrdsa.c create mode 100644 crypto/ecrdsa_defs.h create mode 100644 crypto/ecrdsa_params.asn1 create mode 100644 crypto/ecrdsa_pub_key.asn1
crypto/Kconfig +11 -0
@@ -259,6 +259,17 @@ config CRYPTO_ECDH help Generic implementation of the ECDH algorithm +config CRYPTO_ECRDSA + tristate "EC-RDSA (GOST 34.10) algorithm" + select CRYPTO_ECC + select CRYPTO_AKCIPHER + select CRYPTO_STREEBOG + help + Elliptic Curve Russian Digital Signature Algorithm (GOST R 34.10-2012, + RFC 7091, ISO/IEC 14888-3:2018) is one of the Russian cryptographic + standard algorithms (called GOST algorithms). Only signature verification + is implemented. + comment "Authenticated Encryption with Associated Data" config CRYPTO_CCM
crypto/Makefile +8 -0
@@ -153,6 +153,14 @@ ecdh_generic-y += ecdh.o ecdh_generic-y += ecdh_helper.o obj-$(CONFIG_CRYPTO_ECDH) += ecdh_generic.o +$(obj)/ecrdsa_params.asn1.o: $(obj)/ecrdsa_params.asn1.c $(obj)/ecrdsa_params.asn1.h +$(obj)/ecrdsa_pub_key.asn1.o: $(obj)/ecrdsa_pub_key.asn1.c $(obj)/ecrdsa_pub_key.asn1.h +$(obj)/ecrdsa.o: $(obj)/ecrdsa_params.asn1.h $(obj)/ecrdsa_pub_key.asn1.h +ecrdsa_generic-y += ecrdsa.o +ecrdsa_generic-y += ecrdsa_params.asn1.o +ecrdsa_generic-y += ecrdsa_pub_key.asn1.o +obj-$(CONFIG_CRYPTO_ECRDSA) += ecrdsa_generic.o + # # generic algorithms and the async_tx api #
crypto/asymmetric_keys/x509_cert_parser.c +22 -4
@@ -230,6 +230,14 @@ int x509_note_pkey_algo(void *context, size_t hdrlen,case OID_sha224WithRSAEncryption: ctx->cert->sig->hash_algo ="sha224" ; goto rsa_pkcs1; + +case OID_gost2012Signature256: + ctx->cert->sig->hash_algo ="streebog256" ; + goto ecrdsa; + +case OID_gost2012Signature512: + ctx->cert->sig->hash_algo ="streebog512" ; + goto ecrdsa; } rsa_pkcs1:
@@ -237,6 +245,11 @@ int x509_note_pkey_algo(void *context, size_t hdrlen, ctx->cert->sig->encoding ="pkcs1" ; ctx->algo_oid = ctx->last_oid;return 0 ; +ecrdsa: + ctx->cert->sig->pkey_algo ="ecrdsa" ; + ctx->cert->sig->encoding ="raw" ; + ctx->algo_oid = ctx->last_oid; +return 0 ; }/*
@@ -256,7 +269,8 @@ int x509_note_signature(void *context, size_t hdrlen,return -EINVAL ; } -if (strcmp (ctx->cert->sig->pkey_algo,"rsa" ) =0 ) { +if (strcmp (ctx->cert->sig->pkey_algo,"rsa" ) =0 || +strcmp (ctx->cert->sig->pkey_algo,"ecrdsa" ) =0 ) {/* Discard the BIT STRING metadata */ if (vlen <1 || *(const u8 *)value !=0 )return -EBADMSG ;
@@ -440,11 +454,15 @@ int x509_extract_key_data(void *context, size_t hdrlen, {struct x509_parse_context *ctx = context; -if (ctx->last_oid != OID_rsaEncryption) + ctx->key_algo = ctx->last_oid; +if (ctx->last_oid = OID_rsaEncryption) + ctx->cert->pub->pkey_algo ="rsa" ; +else if (ctx->last_oid = OID_gost2012PKey256 || + ctx->last_oid = OID_gost2012PKey512) + ctx->cert->pub->pkey_algo ="ecrdsa" ; +else return -ENOPKG ; - ctx->cert->pub->pkey_algo ="rsa" ; -/* Discard the BIT STRING metadata */ if (vlen <1 || *(const u8 *)value !=0 )return -EBADMSG ;
crypto/ecc.c +384 -8
487 lines not on this page · raw message
crypto/ecc.h +53 -1
78 lines not on this page · raw message
crypto/ecrdsa.c new file +296 -0
296 lines not on this page · raw message
crypto/ecrdsa_defs.h new file +225 -0
225 lines not on this page · raw message
crypto/ecrdsa_params.asn1 new file +4 -0
@@ -0,0 +1,4 @@ +EcrdsaParams ::= SEQUENCE { + curve OBJECT IDENTIFIER ({ ecrdsa_param_curve }), + digest OBJECT IDENTIFIER OPTIONAL ({ ecrdsa_param_digest }) +}
crypto/ecrdsa_pub_key.asn1 new file +1 -0
@@ -0,0 +1 @@ +EcrdsaPubKey ::= OCTET STRING ({ ecrdsa_parse_pub_key })
include/linux/oid_registry.h +18 -0
@@ -93,6 +93,24 @@ enum OID { OID_authorityKeyIdentifier,/* 2.5.29.35 */ OID_extKeyUsage,/* 2.5.29.37 */ +/* EC-RDSA */ + OID_gostCPSignA,/* 1.2.643.2.2.35.1 */ + OID_gostCPSignB,/* 1.2.643.2.2.35.2 */ + OID_gostCPSignC,/* 1.2.643.2.2.35.3 */ + OID_gost2012PKey256,/* 1.2.643.7.1.1.1.1 */ + OID_gost2012PKey512,/* 1.2.643.7.1.1.1.2 */ + OID_gost2012Digest256,/* 1.2.643.7.1.1.2.2 */ + OID_gost2012Digest512,/* 1.2.643.7.1.1.2.3 */ + OID_gost2012Signature256,/* 1.2.643.7.1.1.3.2 */ + OID_gost2012Signature512,/* 1.2.643.7.1.1.3.3 */ + OID_gostTC26Sign256A,/* 1.2.643.7.1.2.1.1.1 */ + OID_gostTC26Sign256B,/* 1.2.643.7.1.2.1.1.2 */ + OID_gostTC26Sign256C,/* 1.2.643.7.1.2.1.1.3 */ + OID_gostTC26Sign256D,/* 1.2.643.7.1.2.1.1.4 */ + OID_gostTC26Sign512A,/* 1.2.643.7.1.2.1.2.1 */ + OID_gostTC26Sign512B,/* 1.2.643.7.1.2.1.2.2 */ + OID_gostTC26Sign512C,/* 1.2.643.7.1.2.1.2.3 */ +OID__NR };
Signature · 1 line
2.11.0
PATCH v9 9/10 crypto: ecrdsa - add EC-RDSA test vectors to testmgr
In reply to Vitaly ChikunovAdd testmgr test vectors for EC-RDSA algorithm for every of five supported parameters (curves). Because there are no officially published test vectors for the curves, the vectors are generated by gost-engine.
--- crypto/testmgr.c | 6 +++ crypto/testmgr.h | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 160 insertions(+)
crypto/testmgr.c +6 -0
@@ -3476,6 +3476,12 @@ static const struct alg_test_desc alg_test_descs[] = { .kpp = __VECS(ecdh_tv_template) } }, { + .alg = "ecrdsa", + .test = alg_test_akcipher, + .suite = { + .akcipher = __VECS(ecrdsa_tv_template) + } + }, { .alg = "gcm(aes)", .test = alg_test_aead, .fips_allowed = 1,
crypto/testmgr.h +139 -0
145 lines not on this page · raw message
Signature · 1 line
2.11.0
PATCH v9 10/10 integrity: support EC-RDSA signatures for asymmetric_verify
In reply to Vitaly ChikunovAllow to use EC-RDSA signatures for IMA by determining signature type by the hash algorithm name. This works good for EC-RDSA since Streebog and EC-RDSA should always be used together.
--- security/integrity/digsig_asymmetric.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
security/integrity/digsig_asymmetric.c +9 -2
@@ -104,9 +104,16 @@ int asymmetric_verify(struct key *keyring, const char *sig,memset (&pks,0 ,sizeof (pks)); - pks.pkey_algo ="rsa" ; pks.hash_algo = hash_algo_name[hdr->hash_algo]; - pks.encoding ="pkcs1" ; +if (hdr->hash_algo =HASH_ALGO_STREEBOG_256 || + hdr->hash_algo =HASH_ALGO_STREEBOG_512 ) { +/* EC-RDSA and Streebog should go together. */ + pks.pkey_algo ="ecrdsa" ; + pks.encoding ="raw" ; + }else { + pks.pkey_algo ="rsa" ; + pks.encoding ="pkcs1" ; + } pks.digest = (u8 *)data; pks.digest_size = datalen; pks.s = hdr->sig;
Signature · 1 line
2.11.0
Re: [PATCH v9 05/10] X.509: parse public key parameters from x509 for akcipher
In reply to Vitaly ChikunovHi Vitaly,
Quoted 17 lines · Vitaly Chikunov
Some public key algorithms (like EC-DSA) keep in parameters field important data such as digest and curve OIDs (possibly more for different EC-DSA variants). Thus, just setting a public key (as for RSA) is not enough.
Append parameters into the key stream for akcipher_set_{pub,priv}_key. Appended data is: (u32) algo OID, (u32) parameters length, parameters data.
This does not affect current akcipher API nor RSA ciphers (they could ignore it). Idea of appending parameters to the key stream is by Herbert Xu.
Cc David Howells <[email protected]>Cc Denis Kenzior <[email protected]>Signed-off-by Vitaly Chikunov <[email protected]>
Quoted 11 lines
--- crypto/asymmetric_keys/asym_tpm.c | 9 +++- crypto/asymmetric_keys/public_key.c | 72 ++++++++++++++++++++++++------- crypto/asymmetric_keys/x509.asn1 | 2 +- crypto/asymmetric_keys/x509_cert_parser.c | 31 +++++++++++++ crypto/testmgr.c | 24 +++++++++-- crypto/testmgr.h | 5 +++ include/crypto/akcipher.h | 18 ++++---- include/crypto/public_key.h | 4 ++ 8 files changed, 136 insertions(+), 29 deletions(-)
Looks good to me.
By the way:
include/crypto/akcipher.h static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm, · line 404
Quoted 6 lines
include/crypto/akcipher.h +1
-1@@ -400,11 +401,12 @@ static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm,* crypto_akcipher_set_priv_key() - Invoke set private key operation * * Function invokes the algorithm specific set key function, which knows -* how to decode and interpret the encoded key +* how to decode and interpret the encoded keya and parameters
Seems to be a stray 'a' after 'key'?
Regards,
-Denis
Re: [PATCH v9 05/10] X.509: parse public key parameters from x509 for akcipher
Denis, Herbert,
Quoted 32 lines · Denis Kenzior
Hi Vitaly,
Quoted 17 lines · Vitaly Chikunov
Some public key algorithms (like EC-DSA) keep in parameters field important data such as digest and curve OIDs (possibly more for different EC-DSA variants). Thus, just setting a public key (as for RSA) is not enough.
Append parameters into the key stream for akcipher_set_{pub,priv}_key. Appended data is: (u32) algo OID, (u32) parameters length, parameters data.
This does not affect current akcipher API nor RSA ciphers (they could ignore it). Idea of appending parameters to the key stream is by Herbert Xu.
Cc David Howells <[email protected]>Cc Denis Kenzior <[email protected]>Signed-off-by Vitaly Chikunov <[email protected]>Quoted 11 lines
--- crypto/asymmetric_keys/asym_tpm.c | 9 +++- crypto/asymmetric_keys/public_key.c | 72 ++++++++++++++++++++++++------- crypto/asymmetric_keys/x509.asn1 | 2 +- crypto/asymmetric_keys/x509_cert_parser.c | 31 +++++++++++++ crypto/testmgr.c | 24 +++++++++-- crypto/testmgr.h | 5 +++ include/crypto/akcipher.h | 18 ++++---- include/crypto/public_key.h | 4 ++ 8 files changed, 136 insertions(+), 29 deletions(-)
Quoted 3 lines
Looks good to me.
Reviewed-by Denis Kenzior <[email protected]>
Thanks!
Quoted 10 lines
By the way:
include/crypto/akcipher.h static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm, · line 404
Quoted 6 lines
include/crypto/akcipher.h +1
-1@@ -400,11 +401,12 @@ static inline int crypto_akcipher_set_pub_key(struct crypto_akcipher *tfm,* crypto_akcipher_set_priv_key() - Invoke set private key operation * * Function invokes the algorithm specific set key function, which knows -* how to decode and interpret the encoded key +* how to decode and interpret the encoded keya and parameters Seems to be a stray 'a' after 'key'?
Ah! Herbert, should I resend the whole patchset with this typo fix, or you could apply small change if you going to accept it?
Thanks,
Quoted 3 lines
Regards,
-Denis
Herbert Xu
maintainerRe: [PATCH v9 05/10] X.509: parse public key parameters from x509 for akcipher
Quoted 3 lines · Vitaly Chikunov
Ah! Herbert, should I resend the whole patchset with this typo fix, or you could apply small change if you going to accept it?
I'll fix it up when I apply the series.
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
Herbert Xu
maintainerQuoted 35 lines · Vitaly Chikunov
Vitaly Chikunov (10):
crypto: akcipher - default implementations for request callbacks
crypto: rsa - unimplement sign/verify for raw RSA backends
crypto: akcipher - new verify API for public key algorithms
KEYS: do not kmemdup digest in {public,tpm}_key_verify_signature X.509: parse public key parameters from x509 for akcipher
crypto:Kconfig- create Public-key cryptography section
crypto: ecc - make ecc into separate module
crypto: ecrdsa - add EC-RDSA (GOST 34.10) algorithm
crypto: ecrdsa - add EC-RDSA test vectors to testmgr
integrity: support EC-RDSA signatures forasymmetric_verifycrypto/Kconfig | 63 ++-- crypto/Makefile | 10 +- crypto/akcipher.c | 14 + crypto/asymmetric_keys/asym_tpm.c | 43 +-- crypto/asymmetric_keys/public_key.c | 105 ++++--- crypto/asymmetric_keys/x509.asn1 | 2 +- crypto/asymmetric_keys/x509_cert_parser.c | 57 +++- crypto/ecc.c | 417 +++++++++++++++++++++++++- crypto/ecc.h | 153 +++++++++- crypto/ecc_curve_defs.h | 15 - crypto/ecrdsa.c | 296 ++++++++++++++++++ crypto/ecrdsa_defs.h | 225 ++++++++++++++ crypto/ecrdsa_params.asn1 | 4 + crypto/ecrdsa_pub_key.asn1 | 1 + crypto/rsa-pkcs1pad.c | 33 +- crypto/rsa.c | 109 ------- crypto/testmgr.c | 80 +++-- crypto/testmgr.h | 159 ++++++++++ drivers/crypto/caam/caampkc.c | 2 - drivers/crypto/ccp/ccp-crypto-rsa.c | 2 - drivers/crypto/qat/qat_common/qat_asym_algs.c | 2 - include/crypto/akcipher.h | 54 ++--
Quoted 8 lines
include/crypto/public_key.h | 4 + include/linux/oid_registry.h | 18 ++ security/integrity/digsig_asymmetric.c | 11 +- 25 files changed, 1574 insertions(+), 305 deletions(-) create mode 100644 crypto/ecrdsa.c create mode 100644 crypto/ecrdsa_defs.h create mode 100644 crypto/ecrdsa_params.asn1 create mode 100644 crypto/ecrdsa_pub_key.asn1
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