From 77470e989cf3c502ee00eb060b197d0241f33a22 Mon Sep 17 00:00:00 2001 From: "Dr. Stephen Henson" Date: Sun, 28 Feb 2016 17:47:06 +0000 Subject: [PATCH] Replace overrides. Instead of overriding a default operation move default operation to a separate function which is then explicitly included in any EC_METHOD that uses it. Reviewed-by: Rich Salz --- crypto/ec/ec_asn1.c | 8 +--- crypto/ec/ec_key.c | 90 +++++++++++++++++++++++++++++++------------ crypto/ec/ec_lcl.h | 12 ++++++ crypto/ec/ec_lib.c | 17 +++++--- crypto/ec/ecdh_ossl.c | 49 ++++++++++++++--------- 5 files changed, 121 insertions(+), 55 deletions(-) diff --git a/crypto/ec/ec_asn1.c b/crypto/ec/ec_asn1.c index 4e02e5a7a1..b2ae8927a3 100644 --- a/crypto/ec/ec_asn1.c +++ b/crypto/ec/ec_asn1.c @@ -1044,13 +1044,9 @@ EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len) goto err; } } else { - if (ret->group->meth->keygenpub != NULL) { - if (ret->group->meth->keygenpub(ret) == 0) + if (ret->group->meth->keygenpub == NULL + || ret->group->meth->keygenpub(ret) == 0) goto err; - } else if (!EC_POINT_mul(ret->group, ret->pub_key, ret->priv_key, NULL, - NULL, NULL)) { - goto err; - } /* Remember the original private-key-only encoding. */ ret->enc_flag |= EC_PKEY_NO_PUBKEY; } diff --git a/crypto/ec/ec_key.c b/crypto/ec/ec_key.c index e59d2c6d6a..2ff4449de3 100644 --- a/crypto/ec/ec_key.c +++ b/crypto/ec/ec_key.c @@ -233,6 +233,16 @@ int EC_KEY_generate_key(EC_KEY *eckey) } int ossl_ec_key_gen(EC_KEY *eckey) +{ + if (eckey->group->meth->keygen == NULL) { + ECerr(EC_F_OSSL_EC_KEY_GEN, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + + return eckey->group->meth->keygen(eckey); +} + +int ec_key_simple_generate_key(EC_KEY *eckey) { int ok = 0; BN_CTX *ctx = NULL; @@ -240,9 +250,6 @@ int ossl_ec_key_gen(EC_KEY *eckey) const BIGNUM *order = NULL; EC_POINT *pub_key = NULL; - if (eckey->group->meth->keygen != NULL) - return eckey->group->meth->keygen(eckey); - if ((ctx = BN_CTX_new()) == NULL) goto err; @@ -283,10 +290,31 @@ int ossl_ec_key_gen(EC_KEY *eckey) if (eckey->priv_key != priv_key) BN_free(priv_key); BN_CTX_free(ctx); - return (ok); + return ok; +} + +int ec_key_simple_generate_public_key(EC_KEY *eckey) +{ + return EC_POINT_mul(eckey->group, eckey->pub_key, eckey->priv_key, NULL, + NULL, NULL); } int EC_KEY_check_key(const EC_KEY *eckey) +{ + if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) { + ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + + if (eckey->group->meth->keycheck == NULL) { + ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + + return eckey->group->meth->keycheck(eckey); +} + +int ec_key_simple_check_key(const EC_KEY *eckey) { int ok = 0; BN_CTX *ctx = NULL; @@ -294,15 +322,12 @@ int EC_KEY_check_key(const EC_KEY *eckey) EC_POINT *point = NULL; if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) { - ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER); return 0; } - if (eckey->group->meth->keycheck) - return eckey->group->meth->keycheck(eckey); - if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key)) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_AT_INFINITY); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_POINT_AT_INFINITY); goto err; } @@ -313,21 +338,21 @@ int EC_KEY_check_key(const EC_KEY *eckey) /* testing whether the pub_key is on the elliptic curve */ if (EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx) <= 0) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE); goto err; } /* testing whether pub_key * order is the point at infinity */ order = eckey->group->order; if (BN_is_zero(order)) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_INVALID_GROUP_ORDER); goto err; } if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx)) { - ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, ERR_R_EC_LIB); goto err; } if (!EC_POINT_is_at_infinity(eckey->group, point)) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_WRONG_ORDER); goto err; } /* @@ -336,16 +361,16 @@ int EC_KEY_check_key(const EC_KEY *eckey) */ if (eckey->priv_key != NULL) { if (BN_cmp(eckey->priv_key, order) >= 0) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_WRONG_ORDER); goto err; } if (!EC_POINT_mul(eckey->group, point, eckey->priv_key, NULL, NULL, ctx)) { - ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, ERR_R_EC_LIB); goto err; } if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, ctx) != 0) { - ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY); + ECerr(EC_F_EC_KEY_SIMPLE_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY); goto err; } } @@ -353,7 +378,7 @@ int EC_KEY_check_key(const EC_KEY *eckey) err: BN_CTX_free(ctx); EC_POINT_free(point); - return (ok); + return ok; } int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, @@ -568,11 +593,20 @@ int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len, size_t EC_KEY_priv2oct(const EC_KEY *eckey, unsigned char *buf, size_t len) { - size_t buf_len; if (eckey->group == NULL || eckey->group->meth == NULL) return 0; - if (eckey->group->meth->priv2oct) - return eckey->group->meth->priv2oct(eckey, buf, len); + if (eckey->group->meth->priv2oct == NULL) { + ECerr(EC_F_EC_KEY_PRIV2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + + return eckey->group->meth->priv2oct(eckey, buf, len); +} + +size_t ec_key_simple_priv2oct(const EC_KEY *eckey, + unsigned char *buf, size_t len) +{ + size_t buf_len; buf_len = (EC_GROUP_get_degree(eckey->group) + 7) / 8; if (eckey->priv_key == NULL) @@ -585,7 +619,7 @@ size_t EC_KEY_priv2oct(const EC_KEY *eckey, unsigned char *buf, size_t len) /* Octetstring may need leading zeros if BN is to short */ if (BN_bn2binpad(eckey->priv_key, buf, buf_len) == -1) { - ECerr(EC_F_EC_KEY_PRIV2OCT, EC_R_BUFFER_TOO_SMALL); + ECerr(EC_F_EC_KEY_SIMPLE_PRIV2OCT, EC_R_BUFFER_TOO_SMALL); return 0; } @@ -596,18 +630,24 @@ int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len) { if (eckey->group == NULL || eckey->group->meth == NULL) return 0; - if (eckey->group->meth->oct2priv) - return eckey->group->meth->oct2priv(eckey, buf, len); + if (eckey->group->meth->oct2priv == NULL) { + ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + return eckey->group->meth->oct2priv(eckey, buf, len); +} +int ec_key_simple_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len) +{ if (eckey->priv_key == NULL) eckey->priv_key = BN_secure_new(); if (eckey->priv_key == NULL) { - ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_MALLOC_FAILURE); + ECerr(EC_F_EC_KEY_SIMPLE_OCT2PRIV, ERR_R_MALLOC_FAILURE); return 0; } eckey->priv_key = BN_bin2bn(buf, len, eckey->priv_key); if (eckey->priv_key == NULL) { - ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_BN_LIB); + ECerr(EC_F_EC_KEY_SIMPLE_OCT2PRIV, ERR_R_BN_LIB); return 0; } return 1; diff --git a/crypto/ec/ec_lcl.h b/crypto/ec/ec_lcl.h index 42cf07961e..d5d2bfd4bb 100644 --- a/crypto/ec/ec_lcl.h +++ b/crypto/ec/ec_lcl.h @@ -587,6 +587,7 @@ void ec_GFp_nistp_recode_scalar_bits(unsigned char *sign, unsigned char *digit, unsigned char in); #endif int ec_precompute_mont_data(EC_GROUP *); +int ec_group_simple_order_bits(const EC_GROUP *group); #ifdef ECP_NISTZ256_ASM /** Returns GFp methods using montgomery multiplication, with x86-64 optimized @@ -596,6 +597,13 @@ int ec_precompute_mont_data(EC_GROUP *); const EC_METHOD *EC_GFp_nistz256_method(void); #endif +size_t ec_key_simple_priv2oct(const EC_KEY *eckey, + unsigned char *buf, size_t len); +int ec_key_simple_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len); +int ec_key_simple_generate_key(EC_KEY *eckey); +int ec_key_simple_generate_public_key(EC_KEY *eckey); +int ec_key_simple_check_key(const EC_KEY *eckey); + /* EC_METHOD definitions */ struct ec_key_method_st { @@ -635,6 +643,10 @@ int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, const EC_KEY *ecdh, void *(*KDF) (const void *in, size_t inlen, void *out, size_t *outlen)); +int ecdh_simple_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, + const EC_KEY *ecdh, + void *(*KDF) (const void *in, size_t inlen, + void *out, size_t *outlen)); struct ECDSA_SIG_st { BIGNUM *r; diff --git a/crypto/ec/ec_lib.c b/crypto/ec/ec_lib.c index e45cbe3607..1f487b48a0 100644 --- a/crypto/ec/ec_lib.c +++ b/crypto/ec/ec_lib.c @@ -373,11 +373,11 @@ const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group) int EC_GROUP_order_bits(const EC_GROUP *group) { - if (group->meth->group_order_bits) - return group->meth->group_order_bits(group); - if (group->order) - return BN_num_bits(group->order); - return 0; + if (group->meth->group_order_bits == NULL) { + ECerr(EC_F_EC_GROUP_ORDER_BITS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + return group->meth->group_order_bits(group); } int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, @@ -1030,3 +1030,10 @@ void *EC_KEY_get_ex_data(const EC_KEY *key, int idx) { return CRYPTO_get_ex_data(&key->ex_data, idx); } + +int ec_group_simple_order_bits(const EC_GROUP *group) +{ + if (group->order == NULL) + return 0; + return BN_num_bits(group->order); +} diff --git a/crypto/ec/ecdh_ossl.c b/crypto/ec/ecdh_ossl.c index fadc007e14..018e2294b9 100644 --- a/crypto/ec/ecdh_ossl.c +++ b/crypto/ec/ecdh_ossl.c @@ -77,16 +77,31 @@ #include #include "ec_lcl.h" +int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, + const EC_KEY *ecdh, + void *(*KDF) (const void *in, size_t inlen, + void *out, size_t *outlen)) +{ + if (ecdh->group->meth->ecdh_compute_key == 0) { + ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, + ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return -1; + } + + return ecdh->group->meth->ecdh_compute_key(out, outlen, pub_key, ecdh, + KDF); +} + /*- * This implementation is based on the following primitives in the IEEE 1363 standard: * - ECKAS-DH1 * - ECSVDP-DH * Finally an optional KDF is applied. */ -int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, - const EC_KEY *ecdh, - void *(*KDF) (const void *in, size_t inlen, - void *out, size_t *outlen)) +int ecdh_simple_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, + const EC_KEY *ecdh, + void *(*KDF) (const void *in, size_t inlen, + void *out, size_t *outlen)) { BN_CTX *ctx; EC_POINT *tmp = NULL; @@ -98,15 +113,11 @@ int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, unsigned char *buf = NULL; if (outlen > INT_MAX) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); /* sort of, + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); /* sort of, * anyway */ return -1; } - if (ecdh->group->meth->ecdh_compute_key != 0) - return ecdh->group->meth->ecdh_compute_key(out, outlen, pub_key, ecdh, - KDF); - if ((ctx = BN_CTX_new()) == NULL) goto err; BN_CTX_start(ctx); @@ -115,7 +126,7 @@ int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, priv_key = EC_KEY_get0_private_key(ecdh); if (priv_key == NULL) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, EC_R_NO_PRIVATE_VALUE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_NO_PRIVATE_VALUE); goto err; } @@ -124,33 +135,33 @@ int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, if (EC_KEY_get_flags(ecdh) & EC_FLAG_COFACTOR_ECDH) { if (!EC_GROUP_get_cofactor(group, x, NULL) || !BN_mul(x, x, priv_key, ctx)) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); goto err; } priv_key = x; } if ((tmp = EC_POINT_new(group)) == NULL) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); goto err; } if (!EC_POINT_mul(group, tmp, NULL, pub_key, priv_key, ctx)) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); goto err; } if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field) { if (!EC_POINT_get_affine_coordinates_GFp(group, tmp, x, y, ctx)) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); goto err; } } #ifndef OPENSSL_NO_EC2M else { if (!EC_POINT_get_affine_coordinates_GF2m(group, tmp, x, y, ctx)) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE); goto err; } } @@ -159,23 +170,23 @@ int ossl_ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, buflen = (EC_GROUP_get_degree(group) + 7) / 8; len = BN_num_bytes(x); if (len > buflen) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_INTERNAL_ERROR); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_INTERNAL_ERROR); goto err; } if ((buf = OPENSSL_malloc(buflen)) == NULL) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE); goto err; } memset(buf, 0, buflen - len); if (len != (size_t)BN_bn2bin(x, buf + buflen - len)) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, ERR_R_BN_LIB); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_BN_LIB); goto err; } if (KDF != 0) { if (KDF(buf, buflen, out, &outlen) == NULL) { - ECerr(EC_F_OSSL_ECDH_COMPUTE_KEY, EC_R_KDF_FAILED); + ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_KDF_FAILED); goto err; } ret = outlen; -- 2.34.1