Add support for NIST P521 to ecdsa
Subsystems (6)
Stefan Berger
reviewerv8 cover Add support for NIST P521 to ecdsa
This series adds support for the NIST P521 curve to the ecdsa module to enable signature verification with it.
An issue with the current code in ecdsa is that it assumes that input arrays providing key coordinates for example, are arrays of digits (a 'digit' is a 'u64'). This works well for all currently supported curves, such as NIST P192/256/384, but does not work for NIST P521 where coordinates are 8 digits + 2 bytes long. So some of the changes deal with converting byte arrays to digits and adjusting tests on input byte array lengths to tolerate arrays not providing multiples of 8 bytes.
Regards,
Stefan
v8:
- Changed nbits from unsigned int to u32 (5/13)
- Added MODULE_ALIAS_CRYPTO("ecdsa-nist-p521") (11/13)
- Applied R-b & T-b tags from Jarkko
- Rebased on master branch at
https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git
v7:
- Applied T-b tag from Christian to all patches
- Applied R-b tag from Jarkko to some patches
- Rephrased some patch descriptions per Jarkko's request
v6:
- Use existing #defines for number of digits rather than plain numbers (1/13, 6/13) following Bharat's suggestion
- Initialize result from lowest 521 bits of product rather than going through tmp variable (6/13)
v5:
- Simplified ecc_digits_from_bytes as suggested by Lukas (1/12)
- Using nbits == 521 to detect NIST P521 curve rather than strcmp() (5,6/12)
- Nits in patch description and comments (11/12)
v4:
- Followed suggestions by Lukas Wummer (1,5,8/12)
- Use nbits rather than ndigits where needed (8/12)
- Renaming 'keylen' variablest to bufsize where necessary (9/12)
- Adjust signature size calculation for NIST P521 (11/12)
v3:
- Dropped ecdh support
- Use ecc_get_curve_nbits for getting number of bits in NIST P521 curve in ecc_point_mult (7/10)
v2:
- Reformulated some patch descriptions
- Fixed issue detected by krobot
- Some other small changes to the code
Stefan Berger (13):
crypto: ecc - Use ECC_CURVE_NIST_P192/256/384_DIGITS where possible
crypto: ecdsa - Convert byte arrays with key coordinates to digits
crypto: ecdsa - Adjust tests on length of key parameters
crypto: ecdsa - Extend res.x mod n calculation for NIST P521
crypto: ecc - Add nbits field to ecc_curve structure
crypto: ecc - Implement vli_mmod_fast_521 for NIST p521
crypto: ecc - Add special case for NIST P521 in ecc_point_mult
crypto: ecc - Add NIST P521 curve parameters
crypto: ecdsa - Replace ndigits with nbits where precision is needed
crypto: ecdsa - Rename keylen to bufsize where necessary
crypto: ecdsa - Register NIST P521 and extend test suite
crypto: asymmetric_keys - Adjust signature size calculation for NIST
P521
crypto: x509 - Add OID for NIST P521 and extend parser for it
crypto/asymmetric_keys/public_key.c | 14 ++- crypto/asymmetric_keys/x509_cert_parser.c | 3 + crypto/ecc.c | 44 +++++-- crypto/ecc_curve_defs.h | 49 ++++++++ crypto/ecdsa.c | 63 +++++++--- crypto/ecrdsa_defs.h | 5 + crypto/testmgr.c | 7 ++ crypto/testmgr.h | 146 ++++++++++++++++++++++ include/crypto/ecc_curve.h | 2 + include/crypto/ecdh.h | 1 + include/crypto/internal/ecc.h | 24 +++- include/linux/oid_registry.h | 1 + 12 files changed, 336 insertions(+), 23 deletions(-)
base-commit: a9a72140536fe02d98bce72a608ccf3ba9008a71
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 1/13 crypto: ecc - Use ECC_CURVE_NIST_P192/256/384_DIGITS where possible
Replace hard-coded numbers with ECC_CURVE_NIST_P192/256/384_DIGITS where possible.
--- crypto/ecc.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
crypto/ecc.c +6 -6
@@ -689,7 +689,7 @@ static void vli_mmod_barrett(u64 *result, u64 *product, const u64 *mod,static void vli_mmod_fast_192 (u64 *result,const u64 *product,const u64 *curve_prime,u64 *tmp) { -const unsigned int ndigits =3 ; +const unsigned int ndigits =ECC_CURVE_NIST_P192_DIGITS ;int carry;vli_set (result, product, ndigits);
@@ -717,7 +717,7 @@ static void vli_mmod_fast_256(u64 *result, const u64 *product, const u64 *curve_prime, u64 *tmp) { int carry; -const unsigned int ndigits =4 ; +const unsigned int ndigits =ECC_CURVE_NIST_P256_DIGITS ;/* t */ vli_set (result, product, ndigits);
@@ -800,7 +800,7 @@ static void vli_mmod_fast_384(u64 *result, const u64 *product, const u64 *curve_prime, u64 *tmp) { int carry; -const unsigned int ndigits =6 ; +const unsigned int ndigits =ECC_CURVE_NIST_P384_DIGITS ;/* t */ vli_set (result, product, ndigits);
@@ -932,13 +932,13 @@ static bool vli_mmod_fast(u64 *result, u64 *product, }switch (ndigits) { -case 3 : +case ECC_CURVE_NIST_P192_DIGITS :vli_mmod_fast_192 (result, product, curve_prime, tmp);break ; -case 4 : +case ECC_CURVE_NIST_P256_DIGITS :vli_mmod_fast_256 (result, product, curve_prime, tmp);break ; -case 6 : +case ECC_CURVE_NIST_P384_DIGITS :vli_mmod_fast_384 (result, product, curve_prime, tmp);break ;default :
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 2/13 crypto: ecdsa - Convert byte arrays with key coordinates to digits
In reply to Stefan BergerFor NIST P192/256/384 the public key's x and y parameters could be copied directly from a given array since both parameters filled 'ndigits' of digits (a 'digit' is a u64). For support of NIST P521 the key parameters need to have leading zeros prepended to the most significant digit since only 2 bytes of the most significant digit are provided.
Therefore, implement ecc_digits_from_bytes to convert a byte array into an array of digits and use this function in ecdsa_set_pub_key where an input byte array needs to be converted into digits.
--- crypto/ecdsa.c | 14 +++++++++----- include/crypto/internal/ecc.h | 21 +++++++++++++++++++++ 2 files changed, 30 insertions(+), 5 deletions(-)
crypto/ecdsa.c +9 -5
@@ -222,9 +222,8 @@ static int ecdsa_ecc_ctx_reset(struct ecc_ctx *ctx)static int ecdsa_set_pub_key (struct crypto_akcipher *tfm,const void *key,unsigned int keylen) {struct ecc_ctx *ctx =akcipher_tfm_ctx (tfm); +unsigned int digitlen, ndigits;const unsigned char *d = key; -const u64 *digits = (const u64 *)&d[1 ]; -unsigned int ndigits;int ret; ret =ecdsa_ecc_ctx_reset (ctx);
@@ -238,12 +237,17 @@ static int ecdsa_set_pub_key(struct crypto_akcipher *tfm, const void *key, unsigreturn -EINVAL ; keylen--; - ndigits = (keylen >>1 ) /sizeof (u64); + digitlen = keylen >>1 ; + + ndigits =DIV_ROUND_UP (digitlen,sizeof (u64));if (ndigits != ctx->curve->g.ndigits)return -EINVAL ; -ecc_swap_digits (digits, ctx->pub_key.x, ndigits); -ecc_swap_digits (&digits[ndigits], ctx->pub_key.y, ndigits); + d++; + +ecc_digits_from_bytes (d, digitlen, ctx->pub_key.x, ndigits); +ecc_digits_from_bytes (&d[digitlen], digitlen, ctx->pub_key.y, ndigits); + ret =ecc_is_pubkey_valid_full (ctx->curve, &ctx->pub_key); ctx->pub_key_set = ret ==0 ;
include/crypto/internal/ecc.h +21 -0
@@ -56,6 +56,27 @@ static inline void ecc_swap_digits(const void *in, u64 *out, unsigned int ndigit out[i] =get_unaligned_be64 (&src[ndigits -1 - i]); } +/** +* ecc_digits_from_bytes() - Create ndigits-sized digits array from byte array +* @in: Input byte array +* @nbytes Size of input byte array +* @out Output digits array +* @ndigits: Number of digits to create from byte array +*/ +static inline void ecc_digits_from_bytes (const u8 *in,unsigned int nbytes, +u64 *out,unsigned int ndigits) +{ +unsigned int o = nbytes &7 ; +__be64 msd =0 ; + +if (o) { +memcpy ((u8 *)&msd +sizeof (msd) - o, in, o); + out[--ndigits] =be64_to_cpu (msd); + in += o; + } +ecc_swap_digits (in, out, ndigits); +} +/** * ecc_is_key_valid() - Validate a given ECDH private key *
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 3/13 crypto: ecdsa - Adjust tests on length of key parameters
In reply to Stefan BergerIn preparation for support of NIST P521, adjust the basic tests on the length of the provided key parameters to only ensure that the length of the x plus y coordinates parameter array is not an odd number and that each coordinate fits into an array of 'ndigits' digits. Mathematical tests on the key's parameters are then done in ecc_is_pubkey_valid_full rejecting invalid keys.
The change is necessary since NIST P521 keys do not have keys with coordinates that each require 'full' digits (= all bits in u64 used). NIST P521 only requires 2 bytes (9 bits) in the most significant digit unlike NIST P192/256/384 that each require multiple 'full' digits.
--- crypto/ecdsa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
crypto/ecdsa.c +1 -1
@@ -230,7 +230,7 @@ static int ecdsa_set_pub_key(struct crypto_akcipher *tfm, const void *key, unsigif (ret <0 )return ret; -if (keylen <1 || (((keylen -1 ) >>1 ) %sizeof (u64)) !=0 ) +if (keylen <1 || ((keylen -1 ) &1 ) !=0 )return -EINVAL ;/* we only accept uncompressed format indicated by '4' */ if (d[0 ] !=4 )
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 4/13 crypto: ecdsa - Extend res.x mod n calculation for NIST P521
In reply to Stefan Bergerres.x has been calculated by ecc_point_mult_shamir, which uses 'mod curve_prime' on res.x and therefore p > res.x with 'p' being the curve_prime. Further, it is true that for the NIST curves p > n with 'n' being the 'curve_order' and therefore the following may be true as well:
p > res.x >= n.
If res.x >= n then res.x mod n can be calculated by iteratively sub- tracting n from res.x until res.x < n. For NIST P192/256/384 this can be done in a single subtraction. This can also be done in a single subtraction for NIST P521.
The mathematical reason why a single subtraction is sufficient is due to the values of 'p' and 'n' of the NIST curves where the following holds true:
note: max(res.x) = p - 1
max(res.x) - n < n
p - 1 - n < n
p - 1 < 2n => holds true for the NIST curves
--- crypto/ecdsa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
crypto/ecdsa.c +1 -1
@@ -122,7 +122,7 @@ static int _ecdsa_verify(struct ecc_ctx *ctx, const u64 *hash, const u64 *r, con/* res.x = res.x mod n (if res.x > order) */ if (unlikely (vli_cmp (res.x, curve->n, ndigits) ==1 )) -/* faster alternative for NIST p384, p256 & p192 */ +/* faster alternative for NIST p521, p384, p256 & p192 */ vli_sub (res.x, res.x, curve->n, ndigits);if (!vli_cmp (res.x, r, ndigits))
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 5/13 crypto: ecc - Add nbits field to ecc_curve structure
In reply to Stefan BergerAdd the number of bits a curve has to the ecc_curve definition to be able to derive the number of bytes a curve requires for its coordinates from it. It also allows one to identify a curve by its particular size. Set the number of bits on all curve definitions.
--- crypto/ecc_curve_defs.h | 4 ++++ crypto/ecrdsa_defs.h | 5 +++++ include/crypto/ecc_curve.h | 2 ++ 3 files changed, 11 insertions(+)
crypto/ecc_curve_defs.h +4 -0
@@ -17,6 +17,7 @@ static u64 nist_p192_b[] = { 0xFEB8DEECC146B9B1ull, 0x0FA7E9AB72243049ull, 0x64210519E59C80E7ull };static struct ecc_curve nist_p192 = { .name ="nist_192" , + .nbits =192 , .g = { .x = nist_p192_g_x, .y = nist_p192_g_y,
@@ -43,6 +44,7 @@ static u64 nist_p256_b[] = { 0x3BCE3C3E27D2604Bull, 0x651D06B0CC53B0F6ull, 0xB3EBBD55769886BCull, 0x5AC635D8AA3A93E7ull };static struct ecc_curve nist_p256 = { .name ="nist_256" , + .nbits =256 , .g = { .x = nist_p256_g_x, .y = nist_p256_g_y,
@@ -75,6 +77,7 @@ static u64 nist_p384_b[] = { 0x2a85c8edd3ec2aefull, 0xc656398d8a2ed19dull, 0x988e056be3f82d19ull, 0xb3312fa7e23ee7e4ull };static struct ecc_curve nist_p384 = { .name ="nist_384" , + .nbits =384 , .g = { .x = nist_p384_g_x, .y = nist_p384_g_y,
@@ -95,6 +98,7 @@ static u64 curve25519_a[] = { 0x000000000001DB41, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 };static const struct ecc_curve ecc_25519 = { .name ="curve25519" , + .nbits =255 , .g = { .x = curve25519_g_x, .ndigits =4 ,
crypto/ecrdsa_defs.h +5 -0
@@ -47,6 +47,7 @@ static u64 cp256a_b[] = {static struct ecc_curve gost_cp256a = { .name ="cp256a" , + .nbits =256 , .g = { .x = cp256a_g_x, .y = cp256a_g_y,
@@ -80,6 +81,7 @@ static u64 cp256b_b[] = {static struct ecc_curve gost_cp256b = { .name ="cp256b" , + .nbits =256 , .g = { .x = cp256b_g_x, .y = cp256b_g_y,
@@ -117,6 +119,7 @@ static u64 cp256c_b[] = {static struct ecc_curve gost_cp256c = { .name ="cp256c" , + .nbits =256 , .g = { .x = cp256c_g_x, .y = cp256c_g_y,
@@ -166,6 +169,7 @@ static u64 tc512a_b[] = {static struct ecc_curve gost_tc512a = { .name ="tc512a" , + .nbits =512 , .g = { .x = tc512a_g_x, .y = tc512a_g_y,
@@ -211,6 +215,7 @@ static u64 tc512b_b[] = {static struct ecc_curve gost_tc512b = { .name ="tc512b" , + .nbits =512 , .g = { .x = tc512b_g_x, .y = tc512b_g_y,
include/crypto/ecc_curve.h +2 -0
@@ -23,6 +23,7 @@ struct ecc_point {* struct ecc_curve - definition of elliptic curve * * @name: Short name of the curve. +* @nbits: The number of bits of a curve. * @g: Generator point of the curve. * @p: Prime number, if Barrett's reduction is used for this curve * pre-calculated value 'mu' is appended to the @p after ndigits.
@@ -34,6 +35,7 @@ struct ecc_point {*/ struct ecc_curve {char *name; +u32 nbits;struct ecc_point g;u64 *p;u64 *n;
Signature · 1 line
2.43.0
Re: [PATCH v8 05/13] crypto: ecc - Add nbits field to ecc_curve structure
Quoted 8 lines · Stefan Berger
Add the number of bits a curve has to the
ecc_curvedefinition to be able to derive the number of bytes a curve requires for its coordinates from it. It also allows one to identify a curve by its particular size. Set the number of bits on all curve definitions.Tested-by Lukas Wunner <[email protected]>Reviewed-by Jarkko Sakkinen <[email protected]>Signed-off-by Stefan Berger <[email protected]>
Quoted 109 lines
--- crypto/ecc_curve_defs.h | 4 ++++ crypto/ecrdsa_defs.h | 5 +++++ include/crypto/ecc_curve.h | 2 ++ 3 files changed, 11 insertions(+)crypto/ecc_curve_defs.h +4
-0@@ -17,6 +17,7 @@ static u64 nist_p192_b[] = { 0xFEB8DEECC146B9B1ull, 0x0FA7E9AB72243049ull, 0x64210519E59C80E7ull };static struct ecc_curve nist_p192 = { .name ="nist_192" , + .nbits =192 , .g = { .x = nist_p192_g_x, .y = nist_p192_g_y,@@ -43,6 +44,7 @@ static u64 nist_p256_b[] = { 0x3BCE3C3E27D2604Bull, 0x651D06B0CC53B0F6ull, 0xB3EBBD55769886BCull, 0x5AC635D8AA3A93E7ull };static struct ecc_curve nist_p256 = { .name ="nist_256" , + .nbits =256 , .g = { .x = nist_p256_g_x, .y = nist_p256_g_y,@@ -75,6 +77,7 @@ static u64 nist_p384_b[] = { 0x2a85c8edd3ec2aefull, 0xc656398d8a2ed19dull, 0x988e056be3f82d19ull, 0xb3312fa7e23ee7e4ull };static struct ecc_curve nist_p384 = { .name ="nist_384" , + .nbits =384 , .g = { .x = nist_p384_g_x, .y = nist_p384_g_y,@@ -95,6 +98,7 @@ static u64 curve25519_a[] = { 0x000000000001DB41, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 };static const struct ecc_curve ecc_25519 = { .name ="curve25519" , + .nbits =255 , .g = { .x = curve25519_g_x, .ndigits =4 ,crypto/ecrdsa_defs.h +5
-0@@ -47,6 +47,7 @@ static u64 cp256a_b[] = {static struct ecc_curve gost_cp256a = { .name ="cp256a" , + .nbits =256 , .g = { .x = cp256a_g_x, .y = cp256a_g_y,@@ -80,6 +81,7 @@ static u64 cp256b_b[] = {static struct ecc_curve gost_cp256b = { .name ="cp256b" , + .nbits =256 , .g = { .x = cp256b_g_x, .y = cp256b_g_y,@@ -117,6 +119,7 @@ static u64 cp256c_b[] = {static struct ecc_curve gost_cp256c = { .name ="cp256c" , + .nbits =256 , .g = { .x = cp256c_g_x, .y = cp256c_g_y,@@ -166,6 +169,7 @@ static u64 tc512a_b[] = {static struct ecc_curve gost_tc512a = { .name ="tc512a" , + .nbits =512 , .g = { .x = tc512a_g_x, .y = tc512a_g_y,@@ -211,6 +215,7 @@ static u64 tc512b_b[] = {static struct ecc_curve gost_tc512b = { .name ="tc512b" , + .nbits =512 , .g = { .x = tc512b_g_x, .y = tc512b_g_y,include/crypto/ecc_curve.h +2
-0@@ -23,6 +23,7 @@ struct ecc_point {* struct ecc_curve - definition of elliptic curve * * @name: Short name of the curve. +* @nbits: The number of bits of a curve. * @g: Generator point of the curve. * @p: Prime number, if Barrett's reduction is used for this curve * pre-calculated value 'mu' is appended to the @p after ndigits. @@ -34,6 +35,7 @@ struct ecc_point {*/ struct ecc_curve {char *name; +u32 nbits;struct ecc_point g;u64 *p;u64 *n;Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 6/13 crypto: ecc - Implement vli_mmod_fast_521 for NIST p521
In reply to Stefan BergerImplement vli_mmod_fast_521 following the description for how to calculate the modulus for NIST P521 in the NIST publication "Recommendations for Discrete Logarithm-Based Cryptography: Elliptic Curve Domain Parameters" section G.1.4.
NIST p521 requires 9 64bit digits, so increase the ECC_MAX_DIGITS so that the vli digit array provides enough elements to fit the larger integers required by this curve.
--- crypto/ecc.c | 25 +++++++++++++++++++++++++ include/crypto/internal/ecc.h | 3 ++- 2 files changed, 27 insertions(+), 1 deletion(-)
crypto/ecc.c +25 -0
@@ -902,6 +902,28 @@ static void vli_mmod_fast_384(u64 *result, const u64 *product,#undef AND64H#undef AND64L +/* +* Computes result = product % curve_prime +* from "Recommendations for Discrete Logarithm-Based Cryptography: +* Elliptic Curve Domain Parameters" section G.1.4 +*/ +static void vli_mmod_fast_521 (u64 *result,const u64 *product, +const u64 *curve_prime,u64 *tmp) +{ +const unsigned int ndigits =ECC_CURVE_NIST_P521_DIGITS ; +size_t i; + +/* Initialize result with lowest 521 bits from product */ +vli_set (result, product, ndigits); + result[8 ] &=0x1ff ; + +for (i =0 ; i < ndigits; i++) + tmp[i] = (product[8 + i] >>9 ) | (product[9 + i] <<55 ); + tmp[8 ] &=0x1ff ; + +vli_mod_add (result, result, tmp, curve_prime, ndigits); +} +/* Computes result = product % curve_prime for different curve_primes. * * Note that curve_primes are distinguished just by heuristic check and
@@ -941,6 +963,9 @@ static bool vli_mmod_fast(u64 *result, u64 *product,case ECC_CURVE_NIST_P384_DIGITS :vli_mmod_fast_384 (result, product, curve_prime, tmp);break ; +case ECC_CURVE_NIST_P521_DIGITS : +vli_mmod_fast_521 (result, product, curve_prime, tmp); +break ;default :pr_err_ratelimited ("ecc: unsupported digits size!\n" );return false;
include/crypto/internal/ecc.h +2 -1
@@ -33,7 +33,8 @@#define ECC_CURVE_NIST_P192_DIGITS 3#define ECC_CURVE_NIST_P256_DIGITS 4#define ECC_CURVE_NIST_P384_DIGITS 6 -#define ECC_MAX_DIGITS (512 / 64)/* due to ecrdsa */ +#define ECC_CURVE_NIST_P521_DIGITS 9 +#define ECC_MAX_DIGITS DIV_ROUND_UP(521, 64)/* NIST P521 */ #define ECC_DIGITS_TO_BYTES_SHIFT 3
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 7/13 crypto: ecc - Add special case for NIST P521 in ecc_point_mult
In reply to Stefan BergerIn ecc_point_mult use the number of bits of the NIST P521 curve + 2. The change is required specifically for NIST P521 to pass mathematical tests on the public key.
--- crypto/ecc.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
crypto/ecc.c +4 -1
@@ -1320,7 +1320,10 @@ static void ecc_point_mult(struct ecc_point *result, carry =vli_add (sk[0 ], scalar, curve->n, ndigits);vli_add (sk[1 ], sk[0 ], curve->n, ndigits); scalar = sk[!carry]; - num_bits =sizeof (u64) * ndigits *8 +1 ; +if (curve->nbits ==521 )/* NIST P521 */ + num_bits = curve->nbits +2 ; +else + num_bits =sizeof (u64) * ndigits *8 +1 ;vli_set (rx[1 ], point->x, ndigits);vli_set (ry[1 ], point->y, ndigits);
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 8/13 crypto: ecc - Add NIST P521 curve parameters
In reply to Stefan BergerAdd the parameters for the NIST P521 curve and define a new curve ID for it. Make the curve available in ecc_get_curve.
--- crypto/ecc.c | 2 ++ crypto/ecc_curve_defs.h | 45 +++++++++++++++++++++++++++++++++++++++++ include/crypto/ecdh.h | 1 + 3 files changed, 48 insertions(+)
crypto/ecc.c +2 -0
@@ -60,6 +60,8 @@ const struct ecc_curve *ecc_get_curve(unsigned int curve_id)return &nist_p256;case ECC_CURVE_NIST_P384 :return &nist_p384; +case ECC_CURVE_NIST_P521 : +return &nist_p521;default :return NULL ; }
crypto/ecc_curve_defs.h +45 -0
51 lines not on this page · raw message
include/crypto/ecdh.h +1 -0
@@ -26,6 +26,7 @@#define ECC_CURVE_NIST_P192 0x0001#define ECC_CURVE_NIST_P256 0x0002#define ECC_CURVE_NIST_P384 0x0003 +#define ECC_CURVE_NIST_P521 0x0004/** * struct ecdh - define an ECDH private key
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 9/13 crypto: ecdsa - Replace ndigits with nbits where precision is needed
In reply to Stefan BergerReplace the usage of ndigits with nbits where precise space calculations are needed, such as in ecdsa_max_size where the length of a coordinate is determined.
--- crypto/ecdsa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
crypto/ecdsa.c +1 -1
@@ -266,7 +266,7 @@ static unsigned int ecdsa_max_size(struct crypto_akcipher *tfm) {struct ecc_ctx *ctx =akcipher_tfm_ctx (tfm); -return ctx->pub_key.ndigits <<ECC_DIGITS_TO_BYTES_SHIFT ; +return DIV_ROUND_UP (ctx->curve->nbits,8 ); }static int ecdsa_nist_p384_init_tfm (struct crypto_akcipher *tfm)
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 10/13 crypto: ecdsa - Rename keylen to bufsize where necessary
In reply to Stefan BergerIn cases where 'keylen' was referring to the size of the buffer used by a curve's digits, it does not reflect the purpose of the variable anymore once NIST P521 is used. What it refers to then is the size of the buffer, which may be a few bytes larger than the size a coordinate of a key. Therefore, rename keylen to bufsize where appropriate.
--- crypto/ecdsa.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
crypto/ecdsa.c +6 -6
@@ -35,8 +35,8 @@ struct ecdsa_signature_ctx {static int ecdsa_get_signature_rs (u64 *dest,size_t hdrlen,unsigned char tag,const void *value,size_t vlen,unsigned int ndigits) { -size_t keylen = ndigits *sizeof (u64); -ssize_t diff = vlen - keylen; +size_t bufsize = ndigits *sizeof (u64); +ssize_t diff = vlen - bufsize;const char *d = value;u8 rs[ECC_MAX_BYTES ];
@@ -58,7 +58,7 @@ static int ecdsa_get_signature_rs(u64 *dest, size_t hdrlen, unsigned char tag,if (diff)return -EINVAL ; } -if (-diff >= keylen) +if (-diff >= bufsize)return -EINVAL ;if (diff) {
@@ -138,7 +138,7 @@ static int ecdsa_verify(struct akcipher_request *req) {struct crypto_akcipher *tfm =crypto_akcipher_reqtfm (req);struct ecc_ctx *ctx =akcipher_tfm_ctx (tfm); -size_t keylen = ctx->curve->g.ndigits *sizeof (u64); +size_t bufsize = ctx->curve->g.ndigits *sizeof (u64);struct ecdsa_signature_ctx sig_ctx = { .curve = ctx->curve, };
@@ -165,14 +165,14 @@ static int ecdsa_verify(struct akcipher_request *req) goto error;/* if the hash is shorter then we will add leading zeros to fit to ndigits */ - diff = keylen - req->dst_len; + diff = bufsize - req->dst_len;if (diff >=0 ) {if (diff)memset (rawhash,0 , diff);memcpy (&rawhash[diff], buffer + req->src_len, req->dst_len); }else if (diff <0 ) {/* given hash is longer, we take the left-most bytes */ -memcpy (&rawhash, buffer + req->src_len, keylen); +memcpy (&rawhash, buffer + req->src_len, bufsize); }ecc_swap_digits ((u64 *)rawhash, hash, ctx->curve->g.ndigits);
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 11/13 crypto: ecdsa - Register NIST P521 and extend test suite
In reply to Stefan BergerRegister NIST P521 as an akcipher and extend the testmgr with NIST P521-specific test vectors.
Add a module alias so the module gets automatically loaded by the crypto subsystem when the curve is needed.
--- crypto/ecdsa.c | 31 ++++++++++ crypto/testmgr.c | 7 +++ crypto/testmgr.h | 146 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 184 insertions(+)
crypto/ecdsa.c +31 -0
@@ -269,6 +269,28 @@ static unsigned int ecdsa_max_size(struct crypto_akcipher *tfm)return DIV_ROUND_UP (ctx->curve->nbits,8 ); } +static int ecdsa_nist_p521_init_tfm (struct crypto_akcipher *tfm) +{ +struct ecc_ctx *ctx =akcipher_tfm_ctx (tfm); + +return ecdsa_ecc_ctx_init (ctx,ECC_CURVE_NIST_P521 ); +} + +static struct akcipher_alg ecdsa_nist_p521 = { + .verify = ecdsa_verify, + .set_pub_key = ecdsa_set_pub_key, + .max_size = ecdsa_max_size, + .init = ecdsa_nist_p521_init_tfm, + .exit = ecdsa_exit_tfm, + .base = { + .cra_name ="ecdsa-nist-p521" , + .cra_driver_name ="ecdsa-nist-p521-generic" , + .cra_priority =100 , + .cra_module =THIS_MODULE , + .cra_ctxsize =sizeof (struct ecc_ctx ), + }, +}; +static int ecdsa_nist_p384_init_tfm (struct crypto_akcipher *tfm) {struct ecc_ctx *ctx =akcipher_tfm_ctx (tfm);
@@ -352,8 +374,15 @@ static int __init ecdsa_init(void)if (ret) goto nist_p384_error; + ret =crypto_register_akcipher (&ecdsa_nist_p521); +if (ret) + goto nist_p521_error; +return 0 ; +nist_p521_error: +crypto_unregister_akcipher (&ecdsa_nist_p384); + nist_p384_error:crypto_unregister_akcipher (&ecdsa_nist_p256);
@@ -369,6 +398,7 @@ static void __exit ecdsa_exit(void)crypto_unregister_akcipher (&ecdsa_nist_p192);crypto_unregister_akcipher (&ecdsa_nist_p256);crypto_unregister_akcipher (&ecdsa_nist_p384); +crypto_unregister_akcipher (&ecdsa_nist_p521); }subsys_initcall (ecdsa_init);
@@ -380,4 +410,5 @@ MODULE_DESCRIPTION("ECDSA generic algorithm");MODULE_ALIAS_CRYPTO ("ecdsa-nist-p192" );MODULE_ALIAS_CRYPTO ("ecdsa-nist-p256" );MODULE_ALIAS_CRYPTO ("ecdsa-nist-p384" ); +MODULE_ALIAS_CRYPTO ("ecdsa-nist-p521" );MODULE_ALIAS_CRYPTO ("ecdsa-generic" );
crypto/testmgr.c +7 -0
@@ -5097,6 +5097,13 @@ static const struct alg_test_desc alg_test_descs[] = { .suite = { .akcipher = __VECS(ecdsa_nist_p384_tv_template) } + }, { + .alg = "ecdsa-nist-p521", + .test = alg_test_akcipher, + .fips_allowed = 1, + .suite = { + .akcipher = __VECS(ecdsa_nist_p521_tv_template) + } }, { .alg = "ecrdsa", .test = alg_test_akcipher,
crypto/testmgr.h +146 -0
152 lines not on this page · raw message
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 12/13 crypto: asymmetric_keys - Adjust signature size calculation for NIST P521
In reply to Stefan BergerAdjust the calculation of the maximum signature size for support of NIST P521. While existing curves may prepend a 0 byte to their coordinates (to make the number positive), NIST P521 will not do this since only the first bit in the most significant byte is used.
If the encoding of the x & y coordinates requires at least 128 bytes then an additional byte is needed for the encoding of the length. Take this into account when calculating the maximum signature size.
--- crypto/asymmetric_keys/public_key.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
crypto/asymmetric_keys/public_key.c +13 -1
@@ -234,6 +234,7 @@ static int software_key_query(const struct kernel_pkey_params *params, info->key_size = len *8 ;if (strncmp (pkey->pkey_algo,"ecdsa" ,5 ) ==0 ) { +int slen = len;/* * ECDSA key sizes are much smaller than RSA, and thus could * operate on (hashed) inputs that are larger than key size.
@@ -247,8 +248,19 @@ static int software_key_query(const struct kernel_pkey_params *params,* Verify takes ECDSA-Sig (described in RFC 5480) as input, * which is actually 2 'key_size'-bit integers encoded in * ASN.1. Account for the ASN.1 encoding overhead here. +* +* NIST P192/256/384 may prepend a '0' to a coordinate to +* indicate a positive integer. NIST P521 never needs it. */ - info->max_sig_size =2 * (len +3 ) +2 ; +if (strcmp (pkey->pkey_algo,"ecdsa-nist-p521" ) !=0 ) + slen +=1 ; +/* Length of encoding the x & y coordinates */ + slen =2 * (slen +2 ); +/* +* If coordinate encoding takes at least 128 bytes then an +* additional byte for length encoding is needed. +*/ + info->max_sig_size =1 + (slen >=128 ) +1 + slen; }else { info->max_data_size = len; info->max_sig_size = len;
Signature · 1 line
2.43.0
Stefan Berger
reviewerPATCH v8 13/13 crypto: x509 - Add OID for NIST P521 and extend parser for it
In reply to Stefan BergerEnable the x509 parser to accept NIST P521 certificates and add the OID for ansip521r1, which is the identifier for NIST P521.
--- crypto/asymmetric_keys/x509_cert_parser.c | 3 +++ include/linux/oid_registry.h | 1 + 2 files changed, 4 insertions(+)
crypto/asymmetric_keys/x509_cert_parser.c +3 -0
@@ -546,6 +546,9 @@ int x509_extract_key_data(void *context, size_t hdrlen,case OID_id_ansip384r1: ctx->cert->pub->pkey_algo ="ecdsa-nist-p384" ;break ; +case OID_id_ansip521r1: + ctx->cert->pub->pkey_algo ="ecdsa-nist-p521" ; +break ;default :return -ENOPKG ; }
include/linux/oid_registry.h +1 -0
@@ -69,6 +69,7 @@ enum OID { OID_certAuthInfoAccess,/* 1.3.6.1.5.5.7.1.1 */ OID_sha1,/* 1.3.14.3.2.26 */ OID_id_ansip384r1,/* 1.3.132.0.34 */ + OID_id_ansip521r1,/* 1.3.132.0.35 */ OID_sha256,/* 2.16.840.1.101.3.4.2.1 */ OID_sha384,/* 2.16.840.1.101.3.4.2.2 */ OID_sha512, /* 2.16.840.1.101.3.4.2.3 */
Signature · 1 line
2.43.0
Quoted 2 lines · Stefan Berger
This series adds support for the NIST P521 curve to the ecdsa module to enable signature verification with it.
PCI device authentication with P521 is still working fine with v8.
Herbert Xu
maintainerQuoted 86 lines · Stefan Berger
This series adds support for the NIST P521 curve to the ecdsa module to enable signature verification with it.
An issue with the current code in ecdsa is that it assumes that input arrays providing key coordinates for example, are arrays of digits (a 'digit' is a 'u64'). This works well for all currently supported curves, such as NIST P192/256/384, but does not work for NIST P521 where coordinates are 8 digits + 2 bytes long. So some of the changes deal with converting byte arrays to digits and adjusting tests on input byte array lengths to tolerate arrays not providing multiples of 8 bytes.
Regards,
Stefanv8:
- Changed nbits from unsigned int to u32 (5/13)
- AddedMODULE_ALIAS_CRYPTO("ecdsa-nist-p521")(11/13)
- Applied R-b & T-b tags from Jarkko
- Rebased on master branch at
https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.gitv7:
- Applied T-b tag from Christian to all patches
- Applied R-b tag from Jarkko to some patches
- Rephrased some patch descriptions per Jarkko's requestv6:
- Use existing #defines for number of digits rather than plain numbers (1/13, 6/13) following Bharat's suggestion
- Initialize result from lowest 521 bits of product rather than going through tmp variable (6/13)v5:
- Simplifiedecc_digits_from_bytesas suggested by Lukas (1/12)
- Using nbits == 521 to detect NIST P521 curve rather thanstrcmp()(5,6/12)
- Nits in patch description and comments (11/12)v4:
- Followed suggestions by Lukas Wummer (1,5,8/12)
- Use nbits rather than ndigits where needed (8/12)
- Renaming 'keylen' variablest to bufsize where necessary (9/12)
- Adjust signature size calculation for NIST P521 (11/12)v3:
- Dropped ecdh support
- Useecc_get_curve_nbitsfor getting number of bits in NIST P521 curve inecc_point_mult(7/10)v2:
- Reformulated some patch descriptions
- Fixed issue detected by krobot
- Some other small changes to the codeStefan Berger (13):
crypto: ecc - Use ECC_CURVE_NIST_P192/256/384_DIGITS where possible
crypto: ecdsa - Convert byte arrays with key coordinates to digits
crypto: ecdsa - Adjust tests on length of key parameters
crypto: ecdsa - Extend res.x mod n calculation for NIST P521
crypto: ecc - Add nbits field toecc_curvestructure
crypto: ecc - Implementvli_mmod_fast_521for NIST p521
crypto: ecc - Add special case for NIST P521 inecc_point_mult
crypto: ecc - Add NIST P521 curve parameters
crypto: ecdsa - Replace ndigits with nbits where precision is needed
crypto: ecdsa - Rename keylen to bufsize where necessary
crypto: ecdsa - Register NIST P521 and extend test suite
crypto:asymmetric_keys- Adjust signature size calculation for NISTP521crypto: x509 - Add OID for NIST P521 and extend parser for it
crypto/asymmetric_keys/public_key.c | 14 ++- crypto/asymmetric_keys/x509_cert_parser.c | 3 + crypto/ecc.c | 44 +++++-- crypto/ecc_curve_defs.h | 49 ++++++++ crypto/ecdsa.c | 63 +++++++--- crypto/ecrdsa_defs.h | 5 + crypto/testmgr.c | 7 ++ crypto/testmgr.h | 146 ++++++++++++++++++++++ include/crypto/ecc_curve.h | 2 + include/crypto/ecdh.h | 1 + include/crypto/internal/ecc.h | 24 +++- include/linux/oid_registry.h | 1 + 12 files changed, 336 insertions(+), 23 deletions(-)
Quoted 3 lines
base-commit:
a9a72140536fe02d98bce72a608ccf3ba9008a71Signature · 1 line
2.43.0
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