| Message ID | 20210305005203.3547587-1-stefanb@linux.vnet.ibm.com |
|---|---|
| Headers | show |
| Series | Add support for x509 certs with NIST P384/256/192 keys | expand |
Herbert, you can take patches 1-8. 9 will not apply without Nayna's series as mentioned in the patch. Regards, Stefan On 3/4/21 7:51 PM, Stefan Berger wrote: > From: Stefan Berger <stefanb@linux.ibm.com> > > This series of patches adds support for x509 certificates signed by a CA > that uses NIST P384, P256 or P192 keys for signing. It also adds support for > certificates where the public key is one of this type of a key. The math > for ECDSA signature verification is also added as well as the math for fast > mmod operation for NIST P384. > > Since self-signed certificates are verified upon loading, the following > script can be used for testing of NIST P256 keys: > > k=$(keyctl newring test @u) > > while :; do > for hash in sha1 sha224 sha256 sha384 sha512; do > openssl req \ > -x509 \ > -${hash} \ > -newkey ec \ > -pkeyopt ec_paramgen_curve:prime256v1 \ > -keyout key.pem \ > -days 365 \ > -subj '/CN=test' \ > -nodes \ > -outform der \ > -out cert.der > keyctl padd asymmetric testkey $k < cert.der > if [ $? -ne 0 ]; then > echo "ERROR" > exit 1 > fi > done > done > > Ecdsa support also works with restricted keyrings where an RSA key is used > to sign a NIST P384/256/192 key. Scripts for testing are here: > > https://github.com/stefanberger/eckey-testing > > The ECDSA signature verification will be used by IMA Appraisal where ECDSA > file signatures stored in RPM packages will use substantially less space > than if RSA signatures were to be used. > > Further, a patch is added that allows kernel modules to be signed with a NIST > p384 key. > > Stefan and Saulo > > v9->v10: > - rearranged order of patches to have crypto patches first > - moved hunk from patch 3 to patch 2 to avoid compilation warning due to > unused symbol > > v8->v9: > - Appended Saulo's patches > - Appended patch to support kernel modules signed with NIST p384 key. This > patch requires Nayna's series here: https://lkml.org/lkml/2021/2/18/856 > > v7->v8: > - patch 3/4: Do not determine key algo using parse_OID in public_key.c > but do this when parsing the certificate. This addresses an issue > with certain build configurations where OID_REGISTRY is not available > as 'Reported-by: kernel test robot <lkp@intel.com>'. > > v6->v7: > - Moved some OID defintions to patch 1 for bisectability > - Applied R-b's > > v5->v6: > - moved ecdsa code into its own module ecdsa_generic built from ecdsa.c > - added script-generated test vectors for NIST P256 & P192 and all hashes > - parsing of OID that contain header with new parse_oid() > > v4->v5: > - registering crypto support under names ecdsa-nist-p256/p192 following > Hubert Xu's suggestion in other thread > - appended IMA ECDSA support patch > > v3->v4: > - split off of ecdsa crypto part; registering akcipher as "ecdsa" and > deriving used curve from digits in parsed key > > v2->v3: > - patch 2 now includes linux/scatterlist.h > > v1->v2: > - using faster vli_sub rather than newly added vli_mod_fast to 'reduce' > result > - rearranged switch statements to follow after RSA > - 3rd patch from 1st posting is now 1st patch > > > Saulo Alessandre (4): > crypto: Add NIST P384 curve parameters > crypto: Add math to support fast NIST P384 > ecdsa: Register NIST P384 and extend test suite > x509: Add OID for NIST P384 and extend parser for it > > Stefan Berger (5): > crypto: Add support for ECDSA signature verification > x509: Detect sm2 keys by their parameters OID > x509: Add support for parsing x509 certs with ECDSA keys > ima: Support EC keys for signature verification > certs: Add support for using elliptic curve keys for signing modules > > certs/Kconfig | 22 ++ > certs/Makefile | 14 + > crypto/Kconfig | 10 + > crypto/Makefile | 6 + > crypto/asymmetric_keys/pkcs7_parser.c | 4 + > crypto/asymmetric_keys/public_key.c | 4 +- > crypto/asymmetric_keys/x509_cert_parser.c | 49 ++- > crypto/asymmetric_keys/x509_public_key.c | 4 +- > crypto/ecc.c | 281 +++++++++----- > crypto/ecc.h | 31 +- > crypto/ecc_curve_defs.h | 32 ++ > crypto/ecdsa.c | 400 ++++++++++++++++++++ > crypto/ecdsasignature.asn1 | 4 + > crypto/testmgr.c | 18 + > crypto/testmgr.h | 424 ++++++++++++++++++++++ > include/crypto/ecdh.h | 1 + > include/keys/asymmetric-type.h | 6 + > include/linux/oid_registry.h | 10 +- > lib/oid_registry.c | 13 + > security/integrity/digsig_asymmetric.c | 30 +- > 20 files changed, 1256 insertions(+), 107 deletions(-) > create mode 100644 crypto/ecdsa.c > create mode 100644 crypto/ecdsasignature.asn1 >
On Thu, Mar 04, 2021 at 07:52:03PM -0500, Stefan Berger wrote: > From: Stefan Berger <stefanb@linux.ibm.com> > > This patch adds support for using elliptic curve keys for signing "Add support > modules. It uses a NIST P384 (secp384r1) key if the user chooses an > elliptic curve key and will have ECDSA support built into the kernel. > > Note: A developer choosing an ECDSA key for signing modules has to > manually delete the signing key (rm certs/signing_key.*) when falling > back to building an older version of a kernel that only supports RSA > keys since otherwise ECDSA-signed modules will not be usable when that > older kernel runs and the ECDSA key was still used for signing modules. > > Signed-off-by: Stefan Berger <stefanb@linux.ibm.com> > Reviewed-by: Mimi Zohar <zohar@linux.ibm.com> > Extra new line. > --- /Jarkko > > v8->v9: > - Automatically select CONFIG_ECDSA for built-in ECDSA support > - Added help documentation > > This patch builds on top Nayna's series for 'kernel build support for > loading the kernel module signing key'. > - https://lkml.org/lkml/2021/2/18/856 > --- > certs/Kconfig | 22 ++++++++++++++++++++++ > certs/Makefile | 14 ++++++++++++++ > crypto/asymmetric_keys/pkcs7_parser.c | 4 ++++ > 3 files changed, 40 insertions(+) > > diff --git a/certs/Kconfig b/certs/Kconfig > index 48675ad319db..919db43ce80b 100644 > --- a/certs/Kconfig > +++ b/certs/Kconfig > @@ -15,6 +15,28 @@ config MODULE_SIG_KEY > then the kernel will automatically generate the private key and > certificate as described in Documentation/admin-guide/module-signing.rst > > +choice > + prompt "Type of module signing key to be generated" > + default MODULE_SIG_KEY_TYPE_RSA > + help > + The type of module signing key type to generated. This option > + does not apply if a #PKCS11 URI is used. > + > +config MODULE_SIG_KEY_TYPE_RSA > + bool "RSA" > + depends on MODULE_SIG || IMA_APPRAISE_MODSIG > + help > + Use an RSA key for module signing. > + > +config MODULE_SIG_KEY_TYPE_ECDSA > + bool "ECDSA" > + select CRYPTO_ECDSA > + depends on MODULE_SIG || IMA_APPRAISE_MODSIG > + help > + Use an elliptic curve key (NIST P384) for module signing. > + > +endchoice > + > config SYSTEM_TRUSTED_KEYRING > bool "Provide system-wide ring of trusted keys" > depends on KEYS > diff --git a/certs/Makefile b/certs/Makefile > index 3fe6b73786fa..c487d7021c54 100644 > --- a/certs/Makefile > +++ b/certs/Makefile > @@ -69,6 +69,18 @@ else > SIGNER = -signkey $(obj)/signing_key.key > endif # CONFIG_IMA_APPRAISE_MODSIG > > +X509TEXT=$(shell openssl x509 -in $(CONFIG_MODULE_SIG_KEY) -text) > + > +# Support user changing key type > +ifdef CONFIG_MODULE_SIG_KEY_TYPE_ECDSA > +keytype_openssl = -newkey ec -pkeyopt ec_paramgen_curve:secp384r1 > +$(if $(findstring ecdsa-with-,$(X509TEXT)),,$(shell rm -f $(CONFIG_MODULE_SIG_KEY))) > +endif > + > +ifdef CONFIG_MODULE_SIG_KEY_TYPE_RSA > +$(if $(findstring rsaEncryption,$(X509TEXT)),,$(shell rm -f $(CONFIG_MODULE_SIG_KEY))) > +endif > + > $(obj)/signing_key.pem: $(obj)/x509.genkey > @$(kecho) "###" > @$(kecho) "### Now generating an X.509 key pair to be used for signing modules." > @@ -86,12 +98,14 @@ ifeq ($(CONFIG_IMA_APPRAISE_MODSIG),y) > -batch -x509 -config $(obj)/x509.genkey \ > -outform PEM -out $(CA_KEY) \ > -keyout $(CA_KEY) -extensions ca_ext \ > + $(keytype_openssl) \ > $($(quiet)redirect_openssl) > endif # CONFIG_IMA_APPRAISE_MODSIG > $(Q)openssl req -new -nodes -utf8 \ > -batch -config $(obj)/x509.genkey \ > -outform PEM -out $(obj)/signing_key.csr \ > -keyout $(obj)/signing_key.key -extensions myexts \ > + $(keytype_openssl) \ > $($(quiet)redirect_openssl) > $(Q)openssl x509 -req -days 36500 -in $(obj)/signing_key.csr \ > -outform PEM -out $(obj)/signing_key.crt $(SIGNER) \ > diff --git a/crypto/asymmetric_keys/pkcs7_parser.c b/crypto/asymmetric_keys/pkcs7_parser.c > index 967329e0a07b..2546ec6a0505 100644 > --- a/crypto/asymmetric_keys/pkcs7_parser.c > +++ b/crypto/asymmetric_keys/pkcs7_parser.c > @@ -269,6 +269,10 @@ int pkcs7_sig_note_pkey_algo(void *context, size_t hdrlen, > ctx->sinfo->sig->pkey_algo = "rsa"; > ctx->sinfo->sig->encoding = "pkcs1"; > break; > + case OID_id_ecdsa_with_sha256: > + ctx->sinfo->sig->pkey_algo = "ecdsa"; > + ctx->sinfo->sig->encoding = "x962"; > + break; > default: > printk("Unsupported pkey algo: %u\n", ctx->last_oid); > return -ENOPKG; > -- > 2.29.2 > >
On Thu, Mar 04, 2021 at 07:51:57PM -0500, Stefan Berger wrote: > From: Saulo Alessandre <saulo.alessandre@tse.jus.br> > > * crypto/ecc.c > - add vli_mmod_fast_384 > - change some routines to pass ecc_curve forward until vli_mmod_fast > > * crypto/ecc.h > - add ECC_CURVE_NIST_P384_DIGITS > - change ECC_MAX_DIGITS to P384 size > > Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> > Tested-by: Stefan Berger <stefanb@linux.ibm.com> Another "diffstat". /Jarkko > --- > crypto/ecc.c | 266 +++++++++++++++++++++++++++++++++++++-------------- > crypto/ecc.h | 3 +- > 2 files changed, 194 insertions(+), 75 deletions(-) > > diff --git a/crypto/ecc.c b/crypto/ecc.c > index f6cef5a7942d..c125576cda6b 100644 > --- a/crypto/ecc.c > +++ b/crypto/ecc.c > @@ -778,18 +778,133 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, > } > } > > +#define SL32OR32(x32, y32) (((u64)x32 << 32) | y32) > +#define AND64H(x64) (x64 & 0xffFFffFF00000000ull) > +#define AND64L(x64) (x64 & 0x00000000ffFFffFFull) > + > +/* Computes result = product % curve_prime > + * from "Mathematical routines for the NIST prime elliptic curves" > + */ > +static void vli_mmod_fast_384(u64 *result, const u64 *product, > + const u64 *curve_prime, u64 *tmp) > +{ > + int carry; > + const unsigned int ndigits = 6; > + > + /* t */ > + vli_set(result, product, ndigits); > + > + /* s1 */ > + tmp[0] = 0; // 0 || 0 > + tmp[1] = 0; // 0 || 0 > + tmp[2] = SL32OR32(product[11], (product[10]>>32)); //a22||a21 > + tmp[3] = product[11]>>32; // 0 ||a23 > + tmp[4] = 0; // 0 || 0 > + tmp[5] = 0; // 0 || 0 > + carry = vli_lshift(tmp, tmp, 1, ndigits); > + carry += vli_add(result, result, tmp, ndigits); > + > + /* s2 */ > + tmp[0] = product[6]; //a13||a12 > + tmp[1] = product[7]; //a15||a14 > + tmp[2] = product[8]; //a17||a16 > + tmp[3] = product[9]; //a19||a18 > + tmp[4] = product[10]; //a21||a20 > + tmp[5] = product[11]; //a23||a22 > + carry += vli_add(result, result, tmp, ndigits); > + > + /* s3 */ > + tmp[0] = SL32OR32(product[11], (product[10]>>32)); //a22||a21 > + tmp[1] = SL32OR32(product[6], (product[11]>>32)); //a12||a23 > + tmp[2] = SL32OR32(product[7], (product[6])>>32); //a14||a13 > + tmp[3] = SL32OR32(product[8], (product[7]>>32)); //a16||a15 > + tmp[4] = SL32OR32(product[9], (product[8]>>32)); //a18||a17 > + tmp[5] = SL32OR32(product[10], (product[9]>>32)); //a20||a19 > + carry += vli_add(result, result, tmp, ndigits); > + > + /* s4 */ > + tmp[0] = AND64H(product[11]); //a23|| 0 > + tmp[1] = (product[10]<<32); //a20|| 0 > + tmp[2] = product[6]; //a13||a12 > + tmp[3] = product[7]; //a15||a14 > + tmp[4] = product[8]; //a17||a16 > + tmp[5] = product[9]; //a19||a18 > + carry += vli_add(result, result, tmp, ndigits); > + > + /* s5 */ > + tmp[0] = 0; // 0|| 0 > + tmp[1] = 0; // 0|| 0 > + tmp[2] = product[10]; //a21||a20 > + tmp[3] = product[11]; //a23||a22 > + tmp[4] = 0; // 0|| 0 > + tmp[5] = 0; // 0|| 0 > + carry += vli_add(result, result, tmp, ndigits); > + > + /* s6 */ > + tmp[0] = AND64L(product[10]); // 0 ||a20 > + tmp[1] = AND64H(product[10]); //a21|| 0 > + tmp[2] = product[11]; //a23||a22 > + tmp[3] = 0; // 0 || 0 > + tmp[4] = 0; // 0 || 0 > + tmp[5] = 0; // 0 || 0 > + carry += vli_add(result, result, tmp, ndigits); > + > + /* d1 */ > + tmp[0] = SL32OR32(product[6], (product[11]>>32)); //a12||a23 > + tmp[1] = SL32OR32(product[7], (product[6]>>32)); //a14||a13 > + tmp[2] = SL32OR32(product[8], (product[7]>>32)); //a16||a15 > + tmp[3] = SL32OR32(product[9], (product[8]>>32)); //a18||a17 > + tmp[4] = SL32OR32(product[10], (product[9]>>32)); //a20||a19 > + tmp[5] = SL32OR32(product[11], (product[10]>>32)); //a22||a21 > + carry -= vli_sub(result, result, tmp, ndigits); > + > + /* d2 */ > + tmp[0] = (product[10]<<32); //a20|| 0 > + tmp[1] = SL32OR32(product[11], (product[10]>>32)); //a22||a21 > + tmp[2] = (product[11]>>32); // 0 ||a23 > + tmp[3] = 0; // 0 || 0 > + tmp[4] = 0; // 0 || 0 > + tmp[5] = 0; // 0 || 0 > + carry -= vli_sub(result, result, tmp, ndigits); > + > + /* d3 */ > + tmp[0] = 0; // 0 || 0 > + tmp[1] = AND64H(product[11]); //a23|| 0 > + tmp[2] = product[11]>>32; // 0 ||a23 > + tmp[3] = 0; // 0 || 0 > + tmp[4] = 0; // 0 || 0 > + tmp[5] = 0; // 0 || 0 > + carry -= vli_sub(result, result, tmp, ndigits); > + > + if (carry < 0) { > + do { > + carry += vli_add(result, result, curve_prime, ndigits); > + } while (carry < 0); > + } else { > + while (carry || vli_cmp(curve_prime, result, ndigits) != 1) > + carry -= vli_sub(result, result, curve_prime, ndigits); > + } > + > +} > + > +#undef SL32OR32 > +#undef AND64H > +#undef AND64L > + > /* Computes result = product % curve_prime for different curve_primes. > * > * Note that curve_primes are distinguished just by heuristic check and > * not by complete conformance check. > */ > static bool vli_mmod_fast(u64 *result, u64 *product, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 tmp[2 * ECC_MAX_DIGITS]; > + const u64 *curve_prime = curve->p; > + const unsigned int ndigits = curve->g.ndigits; > > - /* Currently, both NIST primes have -1 in lowest qword. */ > - if (curve_prime[0] != -1ull) { > + /* Currently, all NIST have name nist_.* */ > + if (strncmp(curve->name, "nist_", 5) != 0) { > /* Try to handle Pseudo-Marsenne primes. */ > if (curve_prime[ndigits - 1] == -1ull) { > vli_mmod_special(result, product, curve_prime, > @@ -812,6 +927,9 @@ static bool vli_mmod_fast(u64 *result, u64 *product, > case 4: > vli_mmod_fast_256(result, product, curve_prime, tmp); > break; > + case 6: > + vli_mmod_fast_384(result, product, curve_prime, tmp); > + break; > default: > pr_err_ratelimited("ecc: unsupported digits size!\n"); > return false; > @@ -835,22 +953,22 @@ EXPORT_SYMBOL(vli_mod_mult_slow); > > /* Computes result = (left * right) % curve_prime. */ > static void vli_mod_mult_fast(u64 *result, const u64 *left, const u64 *right, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 product[2 * ECC_MAX_DIGITS]; > > - vli_mult(product, left, right, ndigits); > - vli_mmod_fast(result, product, curve_prime, ndigits); > + vli_mult(product, left, right, curve->g.ndigits); > + vli_mmod_fast(result, product, curve); > } > > /* Computes result = left^2 % curve_prime. */ > static void vli_mod_square_fast(u64 *result, const u64 *left, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 product[2 * ECC_MAX_DIGITS]; > > - vli_square(product, left, ndigits); > - vli_mmod_fast(result, product, curve_prime, ndigits); > + vli_square(product, left, curve->g.ndigits); > + vli_mmod_fast(result, product, curve); > } > > #define EVEN(vli) (!(vli[0] & 1)) > @@ -948,25 +1066,27 @@ static bool ecc_point_is_zero(const struct ecc_point *point) > > /* Double in place */ > static void ecc_point_double_jacobian(u64 *x1, u64 *y1, u64 *z1, > - u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > /* t1 = x, t2 = y, t3 = z */ > u64 t4[ECC_MAX_DIGITS]; > u64 t5[ECC_MAX_DIGITS]; > + const u64 *curve_prime = curve->p; > + const unsigned int ndigits = curve->g.ndigits; > > if (vli_is_zero(z1, ndigits)) > return; > > /* t4 = y1^2 */ > - vli_mod_square_fast(t4, y1, curve_prime, ndigits); > + vli_mod_square_fast(t4, y1, curve); > /* t5 = x1*y1^2 = A */ > - vli_mod_mult_fast(t5, x1, t4, curve_prime, ndigits); > + vli_mod_mult_fast(t5, x1, t4, curve); > /* t4 = y1^4 */ > - vli_mod_square_fast(t4, t4, curve_prime, ndigits); > + vli_mod_square_fast(t4, t4, curve); > /* t2 = y1*z1 = z3 */ > - vli_mod_mult_fast(y1, y1, z1, curve_prime, ndigits); > + vli_mod_mult_fast(y1, y1, z1, curve); > /* t3 = z1^2 */ > - vli_mod_square_fast(z1, z1, curve_prime, ndigits); > + vli_mod_square_fast(z1, z1, curve); > > /* t1 = x1 + z1^2 */ > vli_mod_add(x1, x1, z1, curve_prime, ndigits); > @@ -975,7 +1095,7 @@ static void ecc_point_double_jacobian(u64 *x1, u64 *y1, u64 *z1, > /* t3 = x1 - z1^2 */ > vli_mod_sub(z1, x1, z1, curve_prime, ndigits); > /* t1 = x1^2 - z1^4 */ > - vli_mod_mult_fast(x1, x1, z1, curve_prime, ndigits); > + vli_mod_mult_fast(x1, x1, z1, curve); > > /* t3 = 2*(x1^2 - z1^4) */ > vli_mod_add(z1, x1, x1, curve_prime, ndigits); > @@ -992,7 +1112,7 @@ static void ecc_point_double_jacobian(u64 *x1, u64 *y1, u64 *z1, > /* t1 = 3/2*(x1^2 - z1^4) = B */ > > /* t3 = B^2 */ > - vli_mod_square_fast(z1, x1, curve_prime, ndigits); > + vli_mod_square_fast(z1, x1, curve); > /* t3 = B^2 - A */ > vli_mod_sub(z1, z1, t5, curve_prime, ndigits); > /* t3 = B^2 - 2A = x3 */ > @@ -1000,7 +1120,7 @@ static void ecc_point_double_jacobian(u64 *x1, u64 *y1, u64 *z1, > /* t5 = A - x3 */ > vli_mod_sub(t5, t5, z1, curve_prime, ndigits); > /* t1 = B * (A - x3) */ > - vli_mod_mult_fast(x1, x1, t5, curve_prime, ndigits); > + vli_mod_mult_fast(x1, x1, t5, curve); > /* t4 = B * (A - x3) - y1^4 = y3 */ > vli_mod_sub(t4, x1, t4, curve_prime, ndigits); > > @@ -1010,23 +1130,22 @@ static void ecc_point_double_jacobian(u64 *x1, u64 *y1, u64 *z1, > } > > /* Modify (x1, y1) => (x1 * z^2, y1 * z^3) */ > -static void apply_z(u64 *x1, u64 *y1, u64 *z, u64 *curve_prime, > - unsigned int ndigits) > +static void apply_z(u64 *x1, u64 *y1, u64 *z, const struct ecc_curve *curve) > { > u64 t1[ECC_MAX_DIGITS]; > > - vli_mod_square_fast(t1, z, curve_prime, ndigits); /* z^2 */ > - vli_mod_mult_fast(x1, x1, t1, curve_prime, ndigits); /* x1 * z^2 */ > - vli_mod_mult_fast(t1, t1, z, curve_prime, ndigits); /* z^3 */ > - vli_mod_mult_fast(y1, y1, t1, curve_prime, ndigits); /* y1 * z^3 */ > + vli_mod_square_fast(t1, z, curve); /* z^2 */ > + vli_mod_mult_fast(x1, x1, t1, curve); /* x1 * z^2 */ > + vli_mod_mult_fast(t1, t1, z, curve); /* z^3 */ > + vli_mod_mult_fast(y1, y1, t1, curve); /* y1 * z^3 */ > } > > /* P = (x1, y1) => 2P, (x2, y2) => P' */ > static void xycz_initial_double(u64 *x1, u64 *y1, u64 *x2, u64 *y2, > - u64 *p_initial_z, u64 *curve_prime, > - unsigned int ndigits) > + u64 *p_initial_z, const struct ecc_curve *curve) > { > u64 z[ECC_MAX_DIGITS]; > + const unsigned int ndigits = curve->g.ndigits; > > vli_set(x2, x1, ndigits); > vli_set(y2, y1, ndigits); > @@ -1037,35 +1156,37 @@ static void xycz_initial_double(u64 *x1, u64 *y1, u64 *x2, u64 *y2, > if (p_initial_z) > vli_set(z, p_initial_z, ndigits); > > - apply_z(x1, y1, z, curve_prime, ndigits); > + apply_z(x1, y1, z, curve); > > - ecc_point_double_jacobian(x1, y1, z, curve_prime, ndigits); > + ecc_point_double_jacobian(x1, y1, z, curve); > > - apply_z(x2, y2, z, curve_prime, ndigits); > + apply_z(x2, y2, z, curve); > } > > /* Input P = (x1, y1, Z), Q = (x2, y2, Z) > * Output P' = (x1', y1', Z3), P + Q = (x3, y3, Z3) > * or P => P', Q => P + Q > */ > -static void xycz_add(u64 *x1, u64 *y1, u64 *x2, u64 *y2, u64 *curve_prime, > - unsigned int ndigits) > +static void xycz_add(u64 *x1, u64 *y1, u64 *x2, u64 *y2, > + const struct ecc_curve *curve) > { > /* t1 = X1, t2 = Y1, t3 = X2, t4 = Y2 */ > u64 t5[ECC_MAX_DIGITS]; > + const u64 *curve_prime = curve->p; > + const unsigned int ndigits = curve->g.ndigits; > > /* t5 = x2 - x1 */ > vli_mod_sub(t5, x2, x1, curve_prime, ndigits); > /* t5 = (x2 - x1)^2 = A */ > - vli_mod_square_fast(t5, t5, curve_prime, ndigits); > + vli_mod_square_fast(t5, t5, curve); > /* t1 = x1*A = B */ > - vli_mod_mult_fast(x1, x1, t5, curve_prime, ndigits); > + vli_mod_mult_fast(x1, x1, t5, curve); > /* t3 = x2*A = C */ > - vli_mod_mult_fast(x2, x2, t5, curve_prime, ndigits); > + vli_mod_mult_fast(x2, x2, t5, curve); > /* t4 = y2 - y1 */ > vli_mod_sub(y2, y2, y1, curve_prime, ndigits); > /* t5 = (y2 - y1)^2 = D */ > - vli_mod_square_fast(t5, y2, curve_prime, ndigits); > + vli_mod_square_fast(t5, y2, curve); > > /* t5 = D - B */ > vli_mod_sub(t5, t5, x1, curve_prime, ndigits); > @@ -1074,11 +1195,11 @@ static void xycz_add(u64 *x1, u64 *y1, u64 *x2, u64 *y2, u64 *curve_prime, > /* t3 = C - B */ > vli_mod_sub(x2, x2, x1, curve_prime, ndigits); > /* t2 = y1*(C - B) */ > - vli_mod_mult_fast(y1, y1, x2, curve_prime, ndigits); > + vli_mod_mult_fast(y1, y1, x2, curve); > /* t3 = B - x3 */ > vli_mod_sub(x2, x1, t5, curve_prime, ndigits); > /* t4 = (y2 - y1)*(B - x3) */ > - vli_mod_mult_fast(y2, y2, x2, curve_prime, ndigits); > + vli_mod_mult_fast(y2, y2, x2, curve); > /* t4 = y3 */ > vli_mod_sub(y2, y2, y1, curve_prime, ndigits); > > @@ -1089,22 +1210,24 @@ static void xycz_add(u64 *x1, u64 *y1, u64 *x2, u64 *y2, u64 *curve_prime, > * Output P + Q = (x3, y3, Z3), P - Q = (x3', y3', Z3) > * or P => P - Q, Q => P + Q > */ > -static void xycz_add_c(u64 *x1, u64 *y1, u64 *x2, u64 *y2, u64 *curve_prime, > - unsigned int ndigits) > +static void xycz_add_c(u64 *x1, u64 *y1, u64 *x2, u64 *y2, > + const struct ecc_curve *curve) > { > /* t1 = X1, t2 = Y1, t3 = X2, t4 = Y2 */ > u64 t5[ECC_MAX_DIGITS]; > u64 t6[ECC_MAX_DIGITS]; > u64 t7[ECC_MAX_DIGITS]; > + const u64 *curve_prime = curve->p; > + const unsigned int ndigits = curve->g.ndigits; > > /* t5 = x2 - x1 */ > vli_mod_sub(t5, x2, x1, curve_prime, ndigits); > /* t5 = (x2 - x1)^2 = A */ > - vli_mod_square_fast(t5, t5, curve_prime, ndigits); > + vli_mod_square_fast(t5, t5, curve); > /* t1 = x1*A = B */ > - vli_mod_mult_fast(x1, x1, t5, curve_prime, ndigits); > + vli_mod_mult_fast(x1, x1, t5, curve); > /* t3 = x2*A = C */ > - vli_mod_mult_fast(x2, x2, t5, curve_prime, ndigits); > + vli_mod_mult_fast(x2, x2, t5, curve); > /* t4 = y2 + y1 */ > vli_mod_add(t5, y2, y1, curve_prime, ndigits); > /* t4 = y2 - y1 */ > @@ -1113,29 +1236,29 @@ static void xycz_add_c(u64 *x1, u64 *y1, u64 *x2, u64 *y2, u64 *curve_prime, > /* t6 = C - B */ > vli_mod_sub(t6, x2, x1, curve_prime, ndigits); > /* t2 = y1 * (C - B) */ > - vli_mod_mult_fast(y1, y1, t6, curve_prime, ndigits); > + vli_mod_mult_fast(y1, y1, t6, curve); > /* t6 = B + C */ > vli_mod_add(t6, x1, x2, curve_prime, ndigits); > /* t3 = (y2 - y1)^2 */ > - vli_mod_square_fast(x2, y2, curve_prime, ndigits); > + vli_mod_square_fast(x2, y2, curve); > /* t3 = x3 */ > vli_mod_sub(x2, x2, t6, curve_prime, ndigits); > > /* t7 = B - x3 */ > vli_mod_sub(t7, x1, x2, curve_prime, ndigits); > /* t4 = (y2 - y1)*(B - x3) */ > - vli_mod_mult_fast(y2, y2, t7, curve_prime, ndigits); > + vli_mod_mult_fast(y2, y2, t7, curve); > /* t4 = y3 */ > vli_mod_sub(y2, y2, y1, curve_prime, ndigits); > > /* t7 = (y2 + y1)^2 = F */ > - vli_mod_square_fast(t7, t5, curve_prime, ndigits); > + vli_mod_square_fast(t7, t5, curve); > /* t7 = x3' */ > vli_mod_sub(t7, t7, t6, curve_prime, ndigits); > /* t6 = x3' - B */ > vli_mod_sub(t6, t7, x1, curve_prime, ndigits); > /* t6 = (y2 + y1)*(x3' - B) */ > - vli_mod_mult_fast(t6, t6, t5, curve_prime, ndigits); > + vli_mod_mult_fast(t6, t6, t5, curve); > /* t2 = y3' */ > vli_mod_sub(y1, t6, y1, curve_prime, ndigits); > > @@ -1165,41 +1288,37 @@ static void ecc_point_mult(struct ecc_point *result, > vli_set(rx[1], point->x, ndigits); > vli_set(ry[1], point->y, ndigits); > > - xycz_initial_double(rx[1], ry[1], rx[0], ry[0], initial_z, curve_prime, > - ndigits); > + xycz_initial_double(rx[1], ry[1], rx[0], ry[0], initial_z, curve); > > for (i = num_bits - 2; i > 0; i--) { > nb = !vli_test_bit(scalar, i); > - xycz_add_c(rx[1 - nb], ry[1 - nb], rx[nb], ry[nb], curve_prime, > - ndigits); > - xycz_add(rx[nb], ry[nb], rx[1 - nb], ry[1 - nb], curve_prime, > - ndigits); > + xycz_add_c(rx[1 - nb], ry[1 - nb], rx[nb], ry[nb], curve); > + xycz_add(rx[nb], ry[nb], rx[1 - nb], ry[1 - nb], curve); > } > > nb = !vli_test_bit(scalar, 0); > - xycz_add_c(rx[1 - nb], ry[1 - nb], rx[nb], ry[nb], curve_prime, > - ndigits); > + xycz_add_c(rx[1 - nb], ry[1 - nb], rx[nb], ry[nb], curve); > > /* Find final 1/Z value. */ > /* X1 - X0 */ > vli_mod_sub(z, rx[1], rx[0], curve_prime, ndigits); > /* Yb * (X1 - X0) */ > - vli_mod_mult_fast(z, z, ry[1 - nb], curve_prime, ndigits); > + vli_mod_mult_fast(z, z, ry[1 - nb], curve); > /* xP * Yb * (X1 - X0) */ > - vli_mod_mult_fast(z, z, point->x, curve_prime, ndigits); > + vli_mod_mult_fast(z, z, point->x, curve); > > /* 1 / (xP * Yb * (X1 - X0)) */ > vli_mod_inv(z, z, curve_prime, point->ndigits); > > /* yP / (xP * Yb * (X1 - X0)) */ > - vli_mod_mult_fast(z, z, point->y, curve_prime, ndigits); > + vli_mod_mult_fast(z, z, point->y, curve); > /* Xb * yP / (xP * Yb * (X1 - X0)) */ > - vli_mod_mult_fast(z, z, rx[1 - nb], curve_prime, ndigits); > + vli_mod_mult_fast(z, z, rx[1 - nb], curve); > /* End 1/Z calculation */ > > - xycz_add(rx[nb], ry[nb], rx[1 - nb], ry[1 - nb], curve_prime, ndigits); > + xycz_add(rx[nb], ry[nb], rx[1 - nb], ry[1 - nb], curve); > > - apply_z(rx[0], ry[0], z, curve_prime, ndigits); > + apply_z(rx[0], ry[0], z, curve); > > vli_set(result->x, rx[0], ndigits); > vli_set(result->y, ry[0], ndigits); > @@ -1220,9 +1339,9 @@ static void ecc_point_add(const struct ecc_point *result, > vli_mod_sub(z, result->x, p->x, curve->p, ndigits); > vli_set(px, p->x, ndigits); > vli_set(py, p->y, ndigits); > - xycz_add(px, py, result->x, result->y, curve->p, ndigits); > + xycz_add(px, py, result->x, result->y, curve); > vli_mod_inv(z, z, curve->p, ndigits); > - apply_z(result->x, result->y, z, curve->p, ndigits); > + apply_z(result->x, result->y, z, curve); > } > > /* Computes R = u1P + u2Q mod p using Shamir's trick. > @@ -1251,8 +1370,7 @@ void ecc_point_mult_shamir(const struct ecc_point *result, > points[2] = q; > points[3] = ∑ > > - num_bits = max(vli_num_bits(u1, ndigits), > - vli_num_bits(u2, ndigits)); > + num_bits = max(vli_num_bits(u1, ndigits), vli_num_bits(u2, ndigits)); > i = num_bits - 1; > idx = (!!vli_test_bit(u1, i)) | ((!!vli_test_bit(u2, i)) << 1); > point = points[idx]; > @@ -1263,7 +1381,7 @@ void ecc_point_mult_shamir(const struct ecc_point *result, > z[0] = 1; > > for (--i; i >= 0; i--) { > - ecc_point_double_jacobian(rx, ry, z, curve->p, ndigits); > + ecc_point_double_jacobian(rx, ry, z, curve); > idx = (!!vli_test_bit(u1, i)) | ((!!vli_test_bit(u2, i)) << 1); > point = points[idx]; > if (point) { > @@ -1273,14 +1391,14 @@ void ecc_point_mult_shamir(const struct ecc_point *result, > > vli_set(tx, point->x, ndigits); > vli_set(ty, point->y, ndigits); > - apply_z(tx, ty, z, curve->p, ndigits); > + apply_z(tx, ty, z, curve); > vli_mod_sub(tz, rx, tx, curve->p, ndigits); > - xycz_add(tx, ty, rx, ry, curve->p, ndigits); > - vli_mod_mult_fast(z, z, tz, curve->p, ndigits); > + xycz_add(tx, ty, rx, ry, curve); > + vli_mod_mult_fast(z, z, tz, curve); > } > } > vli_mod_inv(z, z, curve->p, ndigits); > - apply_z(rx, ry, z, curve->p, ndigits); > + apply_z(rx, ry, z, curve); > } > EXPORT_SYMBOL(ecc_point_mult_shamir); > > @@ -1434,10 +1552,10 @@ int ecc_is_pubkey_valid_partial(const struct ecc_curve *curve, > return -EINVAL; > > /* Check 3: Verify that y^2 == (x^3 + a·x + b) mod p */ > - vli_mod_square_fast(yy, pk->y, curve->p, pk->ndigits); /* y^2 */ > - vli_mod_square_fast(xxx, pk->x, curve->p, pk->ndigits); /* x^2 */ > - vli_mod_mult_fast(xxx, xxx, pk->x, curve->p, pk->ndigits); /* x^3 */ > - vli_mod_mult_fast(w, curve->a, pk->x, curve->p, pk->ndigits); /* a·x */ > + vli_mod_square_fast(yy, pk->y, curve); /* y^2 */ > + vli_mod_square_fast(xxx, pk->x, curve); /* x^2 */ > + vli_mod_mult_fast(xxx, xxx, pk->x, curve); /* x^3 */ > + vli_mod_mult_fast(w, curve->a, pk->x, curve); /* a·x */ > vli_mod_add(w, w, curve->b, curve->p, pk->ndigits); /* a·x + b */ > vli_mod_add(w, w, xxx, curve->p, pk->ndigits); /* x^3 + a·x + b */ > if (vli_cmp(yy, w, pk->ndigits) != 0) /* Equation */ > diff --git a/crypto/ecc.h b/crypto/ecc.h > index 2ea86dfb5cf7..8f40ebd74565 100644 > --- a/crypto/ecc.h > +++ b/crypto/ecc.h > @@ -29,7 +29,8 @@ > /* One digit is u64 qword. */ > #define ECC_CURVE_NIST_P192_DIGITS 3 > #define ECC_CURVE_NIST_P256_DIGITS 4 > -#define ECC_MAX_DIGITS (512 / 64) > +#define ECC_CURVE_NIST_P384_DIGITS 6 > +#define ECC_MAX_DIGITS (512 / 64) /* due to ecrdsa */ > > #define ECC_DIGITS_TO_BYTES_SHIFT 3 > > -- > 2.29.2 > >
On Thu, Mar 04, 2021 at 07:51:58PM -0500, Stefan Berger wrote: > From: Saulo Alessandre <saulo.alessandre@tse.jus.br> > > * crypto/ecdsa.c > - add ecdsa_nist_p384_init_tfm > - register and unregister P384 tfm > > * crypto/testmgr.c > - add test vector for P384 on vector of tests > > * crypto/testmgr.h > - add test vector params for P384(sha1, sha224, sha256, sha384 > and sha512) > > Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> > Tested-by: Stefan Berger <stefanb@linux.ibm.com> "diffstat" /Jarkko > --- > crypto/ecdsa.c | 33 +++++++++- > crypto/testmgr.c | 6 ++ > crypto/testmgr.h | 157 +++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 195 insertions(+), 1 deletion(-) > > diff --git a/crypto/ecdsa.c b/crypto/ecdsa.c > index 04fbb3d2abc5..8cce80e4154e 100644 > --- a/crypto/ecdsa.c > +++ b/crypto/ecdsa.c > @@ -145,7 +145,7 @@ static int _ecdsa_verify(struct ecc_ctx *ctx, const u64 *hash, > > /* res.x = res.x mod n (if res.x > order) */ > if (unlikely(vli_cmp(res.x, curve->n, ndigits) == 1)) > - /* faster alternative for NIST p256 & p192 */ > + /* faster alternative for NIST p384, p256 & p192 */ > vli_sub(res.x, res.x, curve->n, ndigits); > > if (!vli_cmp(res.x, r, ndigits)) > @@ -289,6 +289,28 @@ static unsigned int ecdsa_max_size(struct crypto_akcipher *tfm) > return ctx->pub_key.ndigits << ECC_DIGITS_TO_BYTES_SHIFT; > } > > +static int ecdsa_nist_p384_init_tfm(struct crypto_akcipher *tfm) > +{ > + struct ecc_ctx *ctx = akcipher_tfm_ctx(tfm); > + > + return ecdsa_ecc_ctx_init(ctx, ECC_CURVE_NIST_P384); > +} > + > +static struct akcipher_alg ecdsa_nist_p384 = { > + .verify = ecdsa_verify, > + .set_pub_key = ecdsa_set_pub_key, > + .max_size = ecdsa_max_size, > + .init = ecdsa_nist_p384_init_tfm, > + .exit = ecdsa_exit_tfm, > + .base = { > + .cra_name = "ecdsa-nist-p384", > + .cra_driver_name = "ecdsa-nist-p384-generic", > + .cra_priority = 100, > + .cra_module = THIS_MODULE, > + .cra_ctxsize = sizeof(struct ecc_ctx), > + }, > +}; > + > static int ecdsa_nist_p256_init_tfm(struct crypto_akcipher *tfm) > { > struct ecc_ctx *ctx = akcipher_tfm_ctx(tfm); > @@ -345,8 +367,16 @@ static int ecdsa_init(void) > ret = crypto_register_akcipher(&ecdsa_nist_p256); > if (ret) > goto nist_p256_error; > + > + ret = crypto_register_akcipher(&ecdsa_nist_p384); > + if (ret) > + goto nist_p384_error; > + > return 0; > > +nist_p384_error: > + crypto_unregister_akcipher(&ecdsa_nist_p256); > + > nist_p256_error: > if (ecdsa_nist_p192_registered) > crypto_unregister_akcipher(&ecdsa_nist_p192); > @@ -358,6 +388,7 @@ static void ecdsa_exit(void) > if (ecdsa_nist_p192_registered) > crypto_unregister_akcipher(&ecdsa_nist_p192); > crypto_unregister_akcipher(&ecdsa_nist_p256); > + crypto_unregister_akcipher(&ecdsa_nist_p384); > } > > subsys_initcall(ecdsa_init); > diff --git a/crypto/testmgr.c b/crypto/testmgr.c > index 2607602f9de5..08f85719338a 100644 > --- a/crypto/testmgr.c > +++ b/crypto/testmgr.c > @@ -4925,6 +4925,12 @@ static const struct alg_test_desc alg_test_descs[] = { > .suite = { > .akcipher = __VECS(ecdsa_nist_p256_tv_template) > } > + }, { > + .alg = "ecdsa-nist-p384", > + .test = alg_test_akcipher, > + .suite = { > + .akcipher = __VECS(ecdsa_nist_p384_tv_template) > + } > }, { > .alg = "ecrdsa", > .test = alg_test_akcipher, > diff --git a/crypto/testmgr.h b/crypto/testmgr.h > index 2adcc0dc0bdd..e63a760aca2d 100644 > --- a/crypto/testmgr.h > +++ b/crypto/testmgr.h > @@ -833,6 +833,163 @@ static const struct akcipher_testvec ecdsa_nist_p256_tv_template[] = { > }, > }; > > +static const struct akcipher_testvec ecdsa_nist_p384_tv_template[] = { > + { > + .key = /* secp384r1(sha1) */ > + "\x04\x89\x25\xf3\x97\x88\xcb\xb0\x78\xc5\x72\x9a\x14\x6e\x7a\xb1" > + "\x5a\xa5\x24\xf1\x95\x06\x9e\x28\xfb\xc4\xb9\xbe\x5a\x0d\xd9\x9f" > + "\xf3\xd1\x4d\x2d\x07\x99\xbd\xda\xa7\x66\xec\xbb\xea\xba\x79\x42" > + "\xc9\x34\x89\x6a\xe7\x0b\xc3\xf2\xfe\x32\x30\xbe\xba\xf9\xdf\x7e" > + "\x4b\x6a\x07\x8e\x26\x66\x3f\x1d\xec\xa2\x57\x91\x51\xdd\x17\x0e" > + "\x0b\x25\xd6\x80\x5c\x3b\xe6\x1a\x98\x48\x91\x45\x7a\x73\xb0\xc3" > + "\xf1", > + .key_len = 97, > + .params = > + "\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04" > + "\x00\x22", > + .param_len = 18, > + .m = > + "\x12\x55\x28\xf0\x77\xd5\xb6\x21\x71\x32\x48\xcd\x28\xa8\x25\x22" > + "\x3a\x69\xc1\x93", > + .m_size = 20, > + .algo = OID_id_ecdsa_with_sha1, > + .c = > + "\x30\x66\x02\x31\x00\xf5\x0f\x24\x4c\x07\x93\x6f\x21\x57\x55\x07" > + "\x20\x43\x30\xde\xa0\x8d\x26\x8e\xae\x63\x3f\xbc\x20\x3a\xc6\xf1" > + "\x32\x3c\xce\x70\x2b\x78\xf1\x4c\x26\xe6\x5b\x86\xcf\xec\x7c\x7e" > + "\xd0\x87\xd7\xd7\x6e\x02\x31\x00\xcd\xbb\x7e\x81\x5d\x8f\x63\xc0" > + "\x5f\x63\xb1\xbe\x5e\x4c\x0e\xa1\xdf\x28\x8c\x1b\xfa\xf9\x95\x88" > + "\x74\xa0\x0f\xbf\xaf\xc3\x36\x76\x4a\xa1\x59\xf1\x1c\xa4\x58\x26" > + "\x79\x12\x2a\xb7\xc5\x15\x92\xc5", > + .c_size = 104, > + .public_key_vec = true, > + .siggen_sigver_test = true, > + }, { > + .key = /* secp384r1(sha224) */ > + "\x04\x69\x6c\xcf\x62\xee\xd0\x0d\xe5\xb5\x2f\x70\x54\xcf\x26\xa0" > + "\xd9\x98\x8d\x92\x2a\xab\x9b\x11\xcb\x48\x18\xa1\xa9\x0d\xd5\x18" > + "\x3e\xe8\x29\x6e\xf6\xe4\xb5\x8e\xc7\x4a\xc2\x5f\x37\x13\x99\x05" > + "\xb6\xa4\x9d\xf9\xfb\x79\x41\xe7\xd7\x96\x9f\x73\x3b\x39\x43\xdc" > + "\xda\xf4\x06\xb9\xa5\x29\x01\x9d\x3b\xe1\xd8\x68\x77\x2a\xf4\x50" > + "\x6b\x93\x99\x6c\x66\x4c\x42\x3f\x65\x60\x6c\x1c\x0b\x93\x9b\x9d" > + "\xe0", > + .key_len = 97, > + .params = > + "\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04" > + "\x00\x22", > + .param_len = 18, > + .m = > + "\x12\x80\xb6\xeb\x25\xe2\x3d\xf0\x21\x32\x96\x17\x3a\x38\x39\xfd" > + "\x1f\x05\x34\x7b\xb8\xf9\x71\x66\x03\x4f\xd5\xe5", > + .m_size = 28, > + .algo = OID_id_ecdsa_with_sha224, > + .c = > + "\x30\x66\x02\x31\x00\x8a\x51\x84\xce\x13\x1e\xd2\xdc\xec\xcb\xe4" > + "\x89\x47\xb2\xf7\xbc\x97\xf1\xc8\x72\x26\xcf\x5a\x5e\xc5\xda\xb4" > + "\xe3\x93\x07\xe0\x99\xc9\x9c\x11\xb8\x10\x01\xc5\x41\x3f\xdd\x15" > + "\x1b\x68\x2b\x9d\x8b\x02\x31\x00\x8b\x03\x2c\xfc\x1f\xd1\xa9\xa4" > + "\x4b\x00\x08\x31\x6c\xf5\xd5\xf6\xdf\xd8\x68\xa2\x64\x42\x65\xf3" > + "\x4d\xd0\xc6\x6e\xb0\xe9\xfc\x14\x9f\x19\xd0\x42\x8b\x93\xc2\x11" > + "\x88\x2b\x82\x26\x5e\x1c\xda\xfb", > + .c_size = 104, > + .public_key_vec = true, > + .siggen_sigver_test = true, > + }, { > + .key = /* secp384r1(sha256) */ > + "\x04\xee\xd6\xda\x3e\x94\x90\x00\x27\xed\xf8\x64\x55\xd6\x51\x9a" > + "\x1f\x52\x00\x63\x78\xf1\xa9\xfd\x75\x4c\x9e\xb2\x20\x1a\x91\x5a" > + "\xba\x7a\xa3\xe5\x6c\xb6\x25\x68\x4b\xe8\x13\xa6\x54\x87\x2c\x0e" > + "\xd0\x83\x95\xbc\xbf\xc5\x28\x4f\x77\x1c\x46\xa6\xf0\xbc\xd4\xa4" > + "\x8d\xc2\x8f\xb3\x32\x37\x40\xd6\xca\xf8\xae\x07\x34\x52\x39\x52" > + "\x17\xc3\x34\x29\xd6\x40\xea\x5c\xb9\x3f\xfb\x32\x2e\x12\x33\xbc" > + "\xab", > + .key_len = 97, > + .params = > + "\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04" > + "\x00\x22", > + .param_len = 18, > + .m = > + "\xaa\xe7\xfd\x03\x26\xcb\x94\x71\xe4\xce\x0f\xc5\xff\xa6\x29\xa3" > + "\xe1\xcc\x4c\x35\x4e\xde\xca\x80\xab\x26\x0c\x25\xe6\x68\x11\xc2", > + .m_size = 32, > + .algo = OID_id_ecdsa_with_sha256, > + .c = > + "\x30\x64\x02\x30\x08\x09\x12\x9d\x6e\x96\x64\xa6\x8e\x3f\x7e\xce" > + "\x0a\x9b\xaa\x59\xcc\x47\x53\x87\xbc\xbd\x83\x3f\xaf\x06\x3f\x84" > + "\x04\xe2\xf9\x67\xb6\xc6\xfc\x70\x2e\x66\x3c\x77\xc8\x8d\x2c\x79" > + "\x3a\x8e\x32\xc4\x02\x30\x40\x34\xb8\x90\xa9\x80\xab\x47\x26\xa2" > + "\xb0\x89\x42\x0a\xda\xd9\xdd\xce\xbc\xb2\x97\xf4\x9c\xf3\x15\x68" > + "\xc0\x75\x3e\x23\x5e\x36\x4f\x8d\xde\x1e\x93\x8d\x95\xbb\x10\x0e" > + "\xf4\x1f\x39\xca\x4d\x43", > + .c_size = 102, > + .public_key_vec = true, > + .siggen_sigver_test = true, > + }, { > + .key = /* secp384r1(sha384) */ > + "\x04\x3a\x2f\x62\xe7\x1a\xcf\x24\xd0\x0b\x7c\xe0\xed\x46\x0a\x4f" > + "\x74\x16\x43\xe9\x1a\x25\x7c\x55\xff\xf0\x29\x68\x66\x20\x91\xf9" > + "\xdb\x2b\xf6\xb3\x6c\x54\x01\xca\xc7\x6a\x5c\x0d\xeb\x68\xd9\x3c" > + "\xf1\x01\x74\x1f\xf9\x6c\xe5\x5b\x60\xe9\x7f\x5d\xb3\x12\x80\x2a" > + "\xd8\x67\x92\xc9\x0e\x4c\x4c\x6b\xa1\xb2\xa8\x1e\xac\x1c\x97\xd9" > + "\x21\x67\xe5\x1b\x5a\x52\x31\x68\xd6\xee\xf0\x19\xb0\x55\xed\x89" > + "\x9e", > + .key_len = 97, > + .params = > + "\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04" > + "\x00\x22", > + .param_len = 18, > + .m = > + "\x8d\xf2\xc0\xe9\xa8\xf3\x8e\x44\xc4\x8c\x1a\xa0\xb8\xd7\x17\xdf" > + "\xf2\x37\x1b\xc6\xe3\xf5\x62\xcc\x68\xf5\xd5\x0b\xbf\x73\x2b\xb1" > + "\xb0\x4c\x04\x00\x31\xab\xfe\xc8\xd6\x09\xc8\xf2\xea\xd3\x28\xff", > + .m_size = 48, > + .algo = OID_id_ecdsa_with_sha384, > + .c = > + "\x30\x66\x02\x31\x00\x9b\x28\x68\xc0\xa1\xea\x8c\x50\xee\x2e\x62" > + "\x35\x46\xfa\x00\xd8\x2d\x7a\x91\x5f\x49\x2d\x22\x08\x29\xe6\xfb" > + "\xca\x8c\xd6\xb6\xb4\x3b\x1f\x07\x8f\x15\x02\xfe\x1d\xa2\xa4\xc8" > + "\xf2\xea\x9d\x11\x1f\x02\x31\x00\xfc\x50\xf6\x43\xbd\x50\x82\x0e" > + "\xbf\xe3\x75\x24\x49\xac\xfb\xc8\x71\xcd\x8f\x18\x99\xf0\x0f\x13" > + "\x44\x92\x8c\x86\x99\x65\xb3\x97\x96\x17\x04\xc9\x05\x77\xf1\x8e" > + "\xab\x8d\x4e\xde\xe6\x6d\x9b\x66", > + .c_size = 104, > + .public_key_vec = true, > + .siggen_sigver_test = true, > + }, { > + .key = /* secp384r1(sha512) */ > + "\x04\xb4\xe7\xc1\xeb\x64\x25\x22\x46\xc3\x86\x61\x80\xbe\x1e\x46" > + "\xcb\xf6\x05\xc2\xee\x73\x83\xbc\xea\x30\x61\x4d\x40\x05\x41\xf4" > + "\x8c\xe3\x0e\x5c\xf0\x50\xf2\x07\x19\xe8\x4f\x25\xbe\xee\x0c\x95" > + "\x54\x36\x86\xec\xc2\x20\x75\xf3\x89\xb5\x11\xa1\xb7\xf5\xaf\xbe" > + "\x81\xe4\xc3\x39\x06\xbd\xe4\xfe\x68\x1c\x6d\x99\x2b\x1b\x63\xfa" > + "\xdf\x42\x5c\xc2\x5a\xc7\x0c\xf4\x15\xf7\x1b\xa3\x2e\xd7\x00\xac" > + "\xa3", > + .key_len = 97, > + .params = > + "\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04" > + "\x00\x22", > + .param_len = 18, > + .m = > + "\xe8\xb7\x52\x7d\x1a\x44\x20\x05\x53\x6b\x3a\x68\xf2\xe7\x6c\xa1" > + "\xae\x9d\x84\xbb\xba\x52\x43\x3e\x2c\x42\x78\x49\xbf\x78\xb2\x71" > + "\xeb\xe1\xe0\xe8\x42\x7b\x11\xad\x2b\x99\x05\x1d\x36\xe6\xac\xfc" > + "\x55\x73\xf0\x15\x63\x39\xb8\x6a\x6a\xc5\x91\x5b\xca\x6a\xa8\x0e", > + .m_size = 64, > + .algo = OID_id_ecdsa_with_sha512, > + .c = > + "\x30\x63\x02\x2f\x1d\x20\x94\x77\xfe\x31\xfa\x4d\xc6\xef\xda\x02" > + "\xe7\x0f\x52\x9a\x02\xde\x93\xe8\x83\xe4\x84\x4c\xfc\x6f\x80\xe3" > + "\xaf\xb3\xd9\xdc\x2b\x43\x0e\x6a\xb3\x53\x6f\x3e\xb3\xc7\xa8\xb3" > + "\x17\x77\xd1\x02\x30\x63\xf6\xf0\x3d\x5f\x5f\x99\x3f\xde\x3a\x3d" > + "\x16\xaf\xb4\x52\x6a\xec\x63\xe3\x0c\xec\x50\xdc\xcc\xc4\x6a\x03" > + "\x5f\x8d\x7a\xf9\xfb\x34\xe4\x8b\x80\xa5\xb6\xda\x2c\x4e\x45\xcf" > + "\x3c\x93\xff\x50\x5d", > + .c_size = 101, > + .public_key_vec = true, > + .siggen_sigver_test = true, > + }, > +}; > + > /* > * EC-RDSA test vectors are generated by gost-engine. > */ > -- > 2.29.2 > >
On Thu, Mar 04, 2021 at 07:51:59PM -0500, Stefan Berger wrote: > From: Stefan Berger <stefanb@linux.ibm.com> > > Detect whether a key is an sm2 type of key by its OID in the parameters > array rather than assuming that everything under OID_id_ecPublicKey > is sm2, which is not the case. > > Cc: David Howells <dhowells@redhat.com> > Cc: keyrings@vger.kernel.org > Signed-off-by: Stefan Berger <stefanb@linux.ibm.com> > Reviewed-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com> > --- > crypto/asymmetric_keys/x509_cert_parser.c | 12 +++++++++++- > include/linux/oid_registry.h | 1 + > lib/oid_registry.c | 13 +++++++++++++ > 3 files changed, 25 insertions(+), 1 deletion(-) > > diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_keys/x509_cert_parser.c > index 52c9b455fc7d..1621ceaf5c95 100644 > --- a/crypto/asymmetric_keys/x509_cert_parser.c > +++ b/crypto/asymmetric_keys/x509_cert_parser.c > @@ -459,6 +459,7 @@ int x509_extract_key_data(void *context, size_t hdrlen, > const void *value, size_t vlen) > { > struct x509_parse_context *ctx = context; > + enum OID oid; enum is not a real type, and it is hard to recall how much it allocates from stack. I would replace this with plain int. > > ctx->key_algo = ctx->last_oid; > switch (ctx->last_oid) { > @@ -470,7 +471,16 @@ int x509_extract_key_data(void *context, size_t hdrlen, > ctx->cert->pub->pkey_algo = "ecrdsa"; > break; > case OID_id_ecPublicKey: > - ctx->cert->pub->pkey_algo = "sm2"; > + if (parse_OID(ctx->params, ctx->params_size, &oid) != 0) > + return -EBADMSG; > + > + switch (oid) { > + case OID_sm2: > + ctx->cert->pub->pkey_algo = "sm2"; > + break; > + default: > + return -ENOPKG; > + } > break; > default: > return -ENOPKG; > diff --git a/include/linux/oid_registry.h b/include/linux/oid_registry.h > index b504e2f36b25..f32d91895e4d 100644 > --- a/include/linux/oid_registry.h > +++ b/include/linux/oid_registry.h > @@ -121,6 +121,7 @@ enum OID { > }; > > extern enum OID look_up_OID(const void *data, size_t datasize); > +extern int parse_OID(const void *data, size_t datasize, enum OID *oid); > extern int sprint_oid(const void *, size_t, char *, size_t); > extern int sprint_OID(enum OID, char *, size_t); > > diff --git a/lib/oid_registry.c b/lib/oid_registry.c > index f7ad43f28579..508e0b34b5f0 100644 > --- a/lib/oid_registry.c > +++ b/lib/oid_registry.c > @@ -11,6 +11,7 @@ > #include <linux/kernel.h> > #include <linux/errno.h> > #include <linux/bug.h> > +#include <linux/asn1.h> > #include "oid_registry_data.c" > > MODULE_DESCRIPTION("OID Registry"); > @@ -92,6 +93,18 @@ enum OID look_up_OID(const void *data, size_t datasize) > } > EXPORT_SYMBOL_GPL(look_up_OID); > > +int parse_OID(const void *data, size_t datasize, enum OID *oid) An exported function without kdoc. > +{ > + const unsigned char *v = data; > + > + if (datasize < 2 || v[0] != ASN1_OID || v[1] != datasize - 2) > + return -EBADMSG; '1' and '2' are magic numbers unless you either have constants defining them, or at least an inline comment with explanation. > + > + *oid = look_up_OID(data + 2, datasize - 2); > + return 0; > +} > +EXPORT_SYMBOL_GPL(parse_OID); > + > /* > * sprint_OID - Print an Object Identifier into a buffer > * @data: The encoded OID to print > -- > 2.29.2 > > /Jarkko
On 3/5/21 12:16 PM, Jarkko Sakkinen wrote: > On Thu, Mar 04, 2021 at 07:51:59PM -0500, Stefan Berger wrote: >> From: Stefan Berger <stefanb@linux.ibm.com> >> >> Detect whether a key is an sm2 type of key by its OID in the parameters >> array rather than assuming that everything under OID_id_ecPublicKey >> is sm2, which is not the case. >> >> Cc: David Howells <dhowells@redhat.com> >> Cc: keyrings@vger.kernel.org >> Signed-off-by: Stefan Berger <stefanb@linux.ibm.com> >> Reviewed-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com> >> --- >> crypto/asymmetric_keys/x509_cert_parser.c | 12 +++++++++++- >> include/linux/oid_registry.h | 1 + >> lib/oid_registry.c | 13 +++++++++++++ >> 3 files changed, 25 insertions(+), 1 deletion(-) >> >> diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_keys/x509_cert_parser.c >> index 52c9b455fc7d..1621ceaf5c95 100644 >> --- a/crypto/asymmetric_keys/x509_cert_parser.c >> +++ b/crypto/asymmetric_keys/x509_cert_parser.c >> @@ -459,6 +459,7 @@ int x509_extract_key_data(void *context, size_t hdrlen, >> const void *value, size_t vlen) >> { >> struct x509_parse_context *ctx = context; >> + enum OID oid; > enum is not a real type, and it is hard to recall how much it allocates > from stack. I would replace this with plain int. That would be worse considering existing code: https://elixir.bootlin.com/linux/latest/source/lib/oid_registry.c#L25 > >> >> ctx->key_algo = ctx->last_oid; >> switch (ctx->last_oid) { >> @@ -470,7 +471,16 @@ int x509_extract_key_data(void *context, size_t hdrlen, >> ctx->cert->pub->pkey_algo = "ecrdsa"; >> break; >> case OID_id_ecPublicKey: >> - ctx->cert->pub->pkey_algo = "sm2"; >> + if (parse_OID(ctx->params, ctx->params_size, &oid) != 0) >> + return -EBADMSG; >> + >> + switch (oid) { >> + case OID_sm2: >> + ctx->cert->pub->pkey_algo = "sm2"; >> + break; >> + default: >> + return -ENOPKG; >> + } >> break; >> default: >> return -ENOPKG; >> diff --git a/include/linux/oid_registry.h b/include/linux/oid_registry.h >> index b504e2f36b25..f32d91895e4d 100644 >> --- a/include/linux/oid_registry.h >> +++ b/include/linux/oid_registry.h >> @@ -121,6 +121,7 @@ enum OID { >> }; >> >> extern enum OID look_up_OID(const void *data, size_t datasize); >> +extern int parse_OID(const void *data, size_t datasize, enum OID *oid); >> extern int sprint_oid(const void *, size_t, char *, size_t); >> extern int sprint_OID(enum OID, char *, size_t); >> >> diff --git a/lib/oid_registry.c b/lib/oid_registry.c >> index f7ad43f28579..508e0b34b5f0 100644 >> --- a/lib/oid_registry.c >> +++ b/lib/oid_registry.c >> @@ -11,6 +11,7 @@ >> #include <linux/kernel.h> >> #include <linux/errno.h> >> #include <linux/bug.h> >> +#include <linux/asn1.h> >> #include "oid_registry_data.c" >> >> MODULE_DESCRIPTION("OID Registry"); >> @@ -92,6 +93,18 @@ enum OID look_up_OID(const void *data, size_t datasize) >> } >> EXPORT_SYMBOL_GPL(look_up_OID); >> >> +int parse_OID(const void *data, size_t datasize, enum OID *oid) > An exported function without kdoc. > >> +{ >> + const unsigned char *v = data; >> + >> + if (datasize < 2 || v[0] != ASN1_OID || v[1] != datasize - 2) >> + return -EBADMSG; > '1' and '2' are magic numbers unless you either have constants defining > them, or at least an inline comment with explanation. I can add those.
Stefan, On Thu, Mar 04, 2021 at 07:51:57PM -0500, Stefan Berger wrote: > From: Saulo Alessandre <saulo.alessandre@tse.jus.br> > > * crypto/ecc.c > - add vli_mmod_fast_384 > - change some routines to pass ecc_curve forward until vli_mmod_fast > > * crypto/ecc.h > - add ECC_CURVE_NIST_P384_DIGITS > - change ECC_MAX_DIGITS to P384 size > > Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> > Tested-by: Stefan Berger <stefanb@linux.ibm.com> > --- > crypto/ecc.c | 266 +++++++++++++++++++++++++++++++++++++-------------- > crypto/ecc.h | 3 +- > 2 files changed, 194 insertions(+), 75 deletions(-) > > diff --git a/crypto/ecc.c b/crypto/ecc.c > index f6cef5a7942d..c125576cda6b 100644 > --- a/crypto/ecc.c > +++ b/crypto/ecc.c > @@ -778,18 +778,133 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, > ... > /* Computes result = product % curve_prime for different curve_primes. > * > * Note that curve_primes are distinguished just by heuristic check and > * not by complete conformance check. > */ > static bool vli_mmod_fast(u64 *result, u64 *product, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 tmp[2 * ECC_MAX_DIGITS]; > + const u64 *curve_prime = curve->p; > + const unsigned int ndigits = curve->g.ndigits; > > - /* Currently, both NIST primes have -1 in lowest qword. */ > - if (curve_prime[0] != -1ull) { > + /* Currently, all NIST have name nist_.* */ > + if (strncmp(curve->name, "nist_", 5) != 0) { I am not sure, but maybe this strncmp should not be optimized somehow, since vli_mmod_fast could be called quite frequently. Perhaps by integer algo id or even callback? Thanks, > /* Try to handle Pseudo-Marsenne primes. */ > if (curve_prime[ndigits - 1] == -1ull) { > vli_mmod_special(result, product, curve_prime, > @@ -812,6 +927,9 @@ static bool vli_mmod_fast(u64 *result, u64 *product, > case 4: > vli_mmod_fast_256(result, product, curve_prime, tmp); > break; > + case 6: > + vli_mmod_fast_384(result, product, curve_prime, tmp); > + break; > default: > pr_err_ratelimited("ecc: unsupported digits size!\n"); > return false; > @@ -835,22 +953,22 @@ EXPORT_SYMBOL(vli_mod_mult_slow); > > /* Computes result = (left * right) % curve_prime. */ > static void vli_mod_mult_fast(u64 *result, const u64 *left, const u64 *right, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 product[2 * ECC_MAX_DIGITS]; > > - vli_mult(product, left, right, ndigits); > - vli_mmod_fast(result, product, curve_prime, ndigits); > + vli_mult(product, left, right, curve->g.ndigits); > + vli_mmod_fast(result, product, curve); > } > > /* Computes result = left^2 % curve_prime. */ > static void vli_mod_square_fast(u64 *result, const u64 *left, > - const u64 *curve_prime, unsigned int ndigits) > + const struct ecc_curve *curve) > { > u64 product[2 * ECC_MAX_DIGITS]; > > - vli_square(product, left, ndigits); > - vli_mmod_fast(result, product, curve_prime, ndigits); > + vli_square(product, left, curve->g.ndigits); > + vli_mmod_fast(result, product, curve); > } > > #define EVEN(vli) (!(vli[0] & 1))
On 3/6/21 2:25 PM, Vitaly Chikunov wrote: > Stefan, > > On Thu, Mar 04, 2021 at 07:51:57PM -0500, Stefan Berger wrote: >> From: Saulo Alessandre <saulo.alessandre@tse.jus.br> >> >> * crypto/ecc.c >> - add vli_mmod_fast_384 >> - change some routines to pass ecc_curve forward until vli_mmod_fast >> >> * crypto/ecc.h >> - add ECC_CURVE_NIST_P384_DIGITS >> - change ECC_MAX_DIGITS to P384 size >> >> Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> >> Tested-by: Stefan Berger <stefanb@linux.ibm.com> >> --- >> crypto/ecc.c | 266 +++++++++++++++++++++++++++++++++++++-------------- >> crypto/ecc.h | 3 +- >> 2 files changed, 194 insertions(+), 75 deletions(-) >> >> diff --git a/crypto/ecc.c b/crypto/ecc.c >> index f6cef5a7942d..c125576cda6b 100644 >> --- a/crypto/ecc.c >> +++ b/crypto/ecc.c >> @@ -778,18 +778,133 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, >> ... >> /* Computes result = product % curve_prime for different curve_primes. >> * >> * Note that curve_primes are distinguished just by heuristic check and >> * not by complete conformance check. >> */ >> static bool vli_mmod_fast(u64 *result, u64 *product, >> - const u64 *curve_prime, unsigned int ndigits) >> + const struct ecc_curve *curve) >> { >> u64 tmp[2 * ECC_MAX_DIGITS]; >> + const u64 *curve_prime = curve->p; >> + const unsigned int ndigits = curve->g.ndigits; >> >> - /* Currently, both NIST primes have -1 in lowest qword. */ >> - if (curve_prime[0] != -1ull) { >> + /* Currently, all NIST have name nist_.* */ >> + if (strncmp(curve->name, "nist_", 5) != 0) { > I am not sure, but maybe this strncmp should not be optimized somehow, > since vli_mmod_fast could be called quite frequently. Perhaps by integer > algo id or even callback? Should be optimized or should not be? You seem to say both. The code code here is shared with ecrdsa. The comparison won't go beyond a single letter considering the naming of the curves define here: "cp256a": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L49 "cp256b": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L82 "cp256c": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L119 "tc512a": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L168 and here: "nist_192": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecc_curve_defs.h#L18 "nist_256": https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecc_curve_defs.h#L45 All the ecrdsa curves were previously evaluating 'curve_prime[0] != -1ull', so it doesn't change anything. Stefan
Stefan, On Sat, Mar 06, 2021 at 06:29:18PM -0500, Stefan Berger wrote: > On 3/6/21 2:25 PM, Vitaly Chikunov wrote: > > > > On Thu, Mar 04, 2021 at 07:51:57PM -0500, Stefan Berger wrote: > > > From: Saulo Alessandre <saulo.alessandre@tse.jus.br> > > > > > > * crypto/ecc.c > > > - add vli_mmod_fast_384 > > > - change some routines to pass ecc_curve forward until vli_mmod_fast > > > > > > * crypto/ecc.h > > > - add ECC_CURVE_NIST_P384_DIGITS > > > - change ECC_MAX_DIGITS to P384 size > > > > > > Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> > > > Tested-by: Stefan Berger <stefanb@linux.ibm.com> > > > --- > > > crypto/ecc.c | 266 +++++++++++++++++++++++++++++++++++++-------------- > > > crypto/ecc.h | 3 +- > > > 2 files changed, 194 insertions(+), 75 deletions(-) > > > > > > diff --git a/crypto/ecc.c b/crypto/ecc.c > > > index f6cef5a7942d..c125576cda6b 100644 > > > --- a/crypto/ecc.c > > > +++ b/crypto/ecc.c > > > @@ -778,18 +778,133 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, > > > ... > > > /* Computes result = product % curve_prime for different curve_primes. > > > * > > > * Note that curve_primes are distinguished just by heuristic check and > > > * not by complete conformance check. > > > */ > > > static bool vli_mmod_fast(u64 *result, u64 *product, > > > - const u64 *curve_prime, unsigned int ndigits) > > > + const struct ecc_curve *curve) > > > { > > > u64 tmp[2 * ECC_MAX_DIGITS]; > > > + const u64 *curve_prime = curve->p; > > > + const unsigned int ndigits = curve->g.ndigits; > > > - /* Currently, both NIST primes have -1 in lowest qword. */ > > > - if (curve_prime[0] != -1ull) { > > > + /* Currently, all NIST have name nist_.* */ > > > + if (strncmp(curve->name, "nist_", 5) != 0) { > > I am not sure, but maybe this strncmp should not be optimized somehow, > > since vli_mmod_fast could be called quite frequently. Perhaps by integer > > algo id or even callback? > > Should be optimized or should not be? You seem to say both. Excuse me for the typo. I meant "should be optimized". I think, maybe it's time to add algo selector id (for the case statement, for example instead of `switch (ndigits)') or just callback for a low level mmod function. If you think this would not impact performance then nevermind. Thanks, > > The code code here is shared with ecrdsa. The comparison won't go beyond a > single letter considering the naming of the curves define here: > > "cp256a": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L49 > > "cp256b": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L82 > > "cp256c": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L119 > > "tc512a": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecrdsa_defs.h#L168 > > and here: > > "nist_192": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecc_curve_defs.h#L18 > > "nist_256": > https://elixir.bootlin.com/linux/v5.11.3/source/crypto/ecc_curve_defs.h#L45 > > > All the ecrdsa curves were previously evaluating 'curve_prime[0] != -1ull', > so it doesn't change anything. > > Stefan >
On 3/6/21 7:03 PM, Vitaly Chikunov wrote: > Stefan, > > On Sat, Mar 06, 2021 at 06:29:18PM -0500, Stefan Berger wrote: >> On 3/6/21 2:25 PM, Vitaly Chikunov wrote: >>> On Thu, Mar 04, 2021 at 07:51:57PM -0500, Stefan Berger wrote: >>>> From: Saulo Alessandre <saulo.alessandre@tse.jus.br> >>>> >>>> * crypto/ecc.c >>>> - add vli_mmod_fast_384 >>>> - change some routines to pass ecc_curve forward until vli_mmod_fast >>>> >>>> * crypto/ecc.h >>>> - add ECC_CURVE_NIST_P384_DIGITS >>>> - change ECC_MAX_DIGITS to P384 size >>>> >>>> Signed-off-by: Saulo Alessandre <saulo.alessandre@tse.jus.br> >>>> Tested-by: Stefan Berger <stefanb@linux.ibm.com> >>>> --- >>>> crypto/ecc.c | 266 +++++++++++++++++++++++++++++++++++++-------------- >>>> crypto/ecc.h | 3 +- >>>> 2 files changed, 194 insertions(+), 75 deletions(-) >>>> >>>> diff --git a/crypto/ecc.c b/crypto/ecc.c >>>> index f6cef5a7942d..c125576cda6b 100644 >>>> --- a/crypto/ecc.c >>>> +++ b/crypto/ecc.c >>>> @@ -778,18 +778,133 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, >>>> ... >>>> /* Computes result = product % curve_prime for different curve_primes. >>>> * >>>> * Note that curve_primes are distinguished just by heuristic check and >>>> * not by complete conformance check. >>>> */ >>>> static bool vli_mmod_fast(u64 *result, u64 *product, >>>> - const u64 *curve_prime, unsigned int ndigits) >>>> + const struct ecc_curve *curve) >>>> { >>>> u64 tmp[2 * ECC_MAX_DIGITS]; >>>> + const u64 *curve_prime = curve->p; >>>> + const unsigned int ndigits = curve->g.ndigits; >>>> - /* Currently, both NIST primes have -1 in lowest qword. */ >>>> - if (curve_prime[0] != -1ull) { >>>> + /* Currently, all NIST have name nist_.* */ >>>> + if (strncmp(curve->name, "nist_", 5) != 0) { >>> I am not sure, but maybe this strncmp should not be optimized somehow, >>> since vli_mmod_fast could be called quite frequently. Perhaps by integer >>> algo id or even callback? >> Should be optimized or should not be? You seem to say both. > Excuse me for the typo. I meant "should be optimized". I think, maybe > it's time to add algo selector id (for the case statement, for example > instead of `switch (ndigits)') or just callback for a low level mmod > function. > > If you think this would not impact performance then nevermind. I think it would only be a few cycles. Of course we could introduce a flag to indicate nist functions (rather than using strncmp on the name) or work with the callbacks (only for the nist functions?) as you mentioned, but maybe that's something we could do after? Either way we would have to pass the ecc_curve pointer all the way into vli_mmod_fast. So this change here is preparing for this as well. Stefan
From: Stefan Berger <stefanb@linux.ibm.com> This series of patches adds support for x509 certificates signed by a CA that uses NIST P384, P256 or P192 keys for signing. It also adds support for certificates where the public key is one of this type of a key. The math for ECDSA signature verification is also added as well as the math for fast mmod operation for NIST P384. Since self-signed certificates are verified upon loading, the following script can be used for testing of NIST P256 keys: k=$(keyctl newring test @u) while :; do for hash in sha1 sha224 sha256 sha384 sha512; do openssl req \ -x509 \ -${hash} \ -newkey ec \ -pkeyopt ec_paramgen_curve:prime256v1 \ -keyout key.pem \ -days 365 \ -subj '/CN=test' \ -nodes \ -outform der \ -out cert.der keyctl padd asymmetric testkey $k < cert.der if [ $? -ne 0 ]; then echo "ERROR" exit 1 fi done done Ecdsa support also works with restricted keyrings where an RSA key is used to sign a NIST P384/256/192 key. Scripts for testing are here: https://github.com/stefanberger/eckey-testing The ECDSA signature verification will be used by IMA Appraisal where ECDSA file signatures stored in RPM packages will use substantially less space than if RSA signatures were to be used. Further, a patch is added that allows kernel modules to be signed with a NIST p384 key. Stefan and Saulo v9->v10: - rearranged order of patches to have crypto patches first - moved hunk from patch 3 to patch 2 to avoid compilation warning due to unused symbol v8->v9: - Appended Saulo's patches - Appended patch to support kernel modules signed with NIST p384 key. This patch requires Nayna's series here: https://lkml.org/lkml/2021/2/18/856 v7->v8: - patch 3/4: Do not determine key algo using parse_OID in public_key.c but do this when parsing the certificate. This addresses an issue with certain build configurations where OID_REGISTRY is not available as 'Reported-by: kernel test robot <lkp@intel.com>'. v6->v7: - Moved some OID defintions to patch 1 for bisectability - Applied R-b's v5->v6: - moved ecdsa code into its own module ecdsa_generic built from ecdsa.c - added script-generated test vectors for NIST P256 & P192 and all hashes - parsing of OID that contain header with new parse_oid() v4->v5: - registering crypto support under names ecdsa-nist-p256/p192 following Hubert Xu's suggestion in other thread - appended IMA ECDSA support patch v3->v4: - split off of ecdsa crypto part; registering akcipher as "ecdsa" and deriving used curve from digits in parsed key v2->v3: - patch 2 now includes linux/scatterlist.h v1->v2: - using faster vli_sub rather than newly added vli_mod_fast to 'reduce' result - rearranged switch statements to follow after RSA - 3rd patch from 1st posting is now 1st patch Saulo Alessandre (4): crypto: Add NIST P384 curve parameters crypto: Add math to support fast NIST P384 ecdsa: Register NIST P384 and extend test suite x509: Add OID for NIST P384 and extend parser for it Stefan Berger (5): crypto: Add support for ECDSA signature verification x509: Detect sm2 keys by their parameters OID x509: Add support for parsing x509 certs with ECDSA keys ima: Support EC keys for signature verification certs: Add support for using elliptic curve keys for signing modules certs/Kconfig | 22 ++ certs/Makefile | 14 + crypto/Kconfig | 10 + crypto/Makefile | 6 + crypto/asymmetric_keys/pkcs7_parser.c | 4 + crypto/asymmetric_keys/public_key.c | 4 +- crypto/asymmetric_keys/x509_cert_parser.c | 49 ++- crypto/asymmetric_keys/x509_public_key.c | 4 +- crypto/ecc.c | 281 +++++++++----- crypto/ecc.h | 31 +- crypto/ecc_curve_defs.h | 32 ++ crypto/ecdsa.c | 400 ++++++++++++++++++++ crypto/ecdsasignature.asn1 | 4 + crypto/testmgr.c | 18 + crypto/testmgr.h | 424 ++++++++++++++++++++++ include/crypto/ecdh.h | 1 + include/keys/asymmetric-type.h | 6 + include/linux/oid_registry.h | 10 +- lib/oid_registry.c | 13 + security/integrity/digsig_asymmetric.c | 30 +- 20 files changed, 1256 insertions(+), 107 deletions(-) create mode 100644 crypto/ecdsa.c create mode 100644 crypto/ecdsasignature.asn1