Commit 77470e98 authored by Dr. Stephen Henson's avatar Dr. Stephen Henson
Browse files

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: default avatarRich Salz <rsalz@openssl.org>
parent 7d054e5a

crypto/ec/ec_asn1.c

+2 −6
Original line number Diff line number Diff line
@@ -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;

    }

crypto/ec/ec_key.c

+65 −25
Original line number Diff line number Diff line
@@ -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)

    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)

    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;

crypto/ec/ec_lcl.h

+12 −0
Original line number Diff line number Diff line
@@ -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;

crypto/ec/ec_lib.c

+12 −5
Original line number Diff line number Diff line
@@ -373,12 +373,12 @@ 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);

    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,

                          BN_CTX *ctx)
@@ -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);

}

crypto/ec/ecdh_ossl.c

+30 −19
Original line number Diff line number Diff line
@@ -77,13 +77,28 @@ 
#include <openssl/ec.h>

#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,

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))
@@ -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;