X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=crypto%2Fec%2Fec_asn1.c;h=145807b611a5aa9efa6b782b2c543d95b8fe3387;hp=26f3916d014d84c6317ba366b94b15f997660664;hb=94782e0e9c28bd872107b8f814f4db68c9fbf5ab;hpb=7e31164ae08fdc00fb62f749f7b6d18aaa75523e diff --git a/crypto/ec/ec_asn1.c b/crypto/ec/ec_asn1.c index 26f3916d01..145807b611 100644 --- a/crypto/ec/ec_asn1.c +++ b/crypto/ec/ec_asn1.c @@ -3,7 +3,7 @@ * Written by Nils Larsch for the OpenSSL project. */ /* ==================================================================== - * Copyright (c) 2000-2002 The OpenSSL Project. All rights reserved. + * Copyright (c) 2000-2003 The OpenSSL Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,24 +62,108 @@ #include #include -/* some structures needed for the asn1 encoding */ -typedef struct x9_62_fieldid_st { - ASN1_OBJECT *fieldType; - ASN1_TYPE *parameters; - } X9_62_FIELDID; -typedef struct x9_62_characteristic_two_st { - long m; - ASN1_OBJECT *basis; - ASN1_TYPE *parameters; - } X9_62_CHARACTERISTIC_TWO; +int EC_GROUP_get_basis_type(const EC_GROUP *group) + { + int i=0; + + if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != + NID_X9_62_characteristic_two_field) + /* everything else is currently not supported */ + return 0; + + while (group->poly[i] != 0) + i++; + + if (i == 4) + return NID_X9_62_ppBasis; + else if (i == 2) + return NID_X9_62_tpBasis; + else + /* everything else is currently not supported */ + return 0; + } +#ifndef OPENSSL_NO_EC2M +int EC_GROUP_get_trinomial_basis(const EC_GROUP *group, unsigned int *k) + { + if (group == NULL) + return 0; + + if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != + NID_X9_62_characteristic_two_field + || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] == 0))) + { + ECerr(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + + if (k) + *k = group->poly[1]; + + return 1; + } +int EC_GROUP_get_pentanomial_basis(const EC_GROUP *group, unsigned int *k1, + unsigned int *k2, unsigned int *k3) + { + if (group == NULL) + return 0; + + if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != + NID_X9_62_characteristic_two_field + || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] != 0) && (group->poly[3] != 0) && (group->poly[4] == 0))) + { + ECerr(EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + return 0; + } + + if (k1) + *k1 = group->poly[3]; + if (k2) + *k2 = group->poly[2]; + if (k3) + *k3 = group->poly[1]; + return 1; + } +#endif + + +/* some structures needed for the asn1 encoding */ typedef struct x9_62_pentanomial_st { long k1; long k2; long k3; } X9_62_PENTANOMIAL; +typedef struct x9_62_characteristic_two_st { + long m; + ASN1_OBJECT *type; + union { + char *ptr; + /* NID_X9_62_onBasis */ + ASN1_NULL *onBasis; + /* NID_X9_62_tpBasis */ + ASN1_INTEGER *tpBasis; + /* NID_X9_62_ppBasis */ + X9_62_PENTANOMIAL *ppBasis; + /* anything else */ + ASN1_TYPE *other; + } p; + } X9_62_CHARACTERISTIC_TWO; + +typedef struct x9_62_fieldid_st { + ASN1_OBJECT *fieldType; + union { + char *ptr; + /* NID_X9_62_prime_field */ + ASN1_INTEGER *prime; + /* NID_X9_62_characteristic_two_field */ + X9_62_CHARACTERISTIC_TWO *char_two; + /* anything else */ + ASN1_TYPE *other; + } p; + } X9_62_FIELDID; + typedef struct x9_62_curve_st { ASN1_OCTET_STRING *a; ASN1_OCTET_STRING *b; @@ -112,36 +196,44 @@ typedef struct ec_privatekey_st { ASN1_BIT_STRING *publicKey; } EC_PRIVATEKEY; -/* the OpenSSL asn1 definitions */ +/* the OpenSSL ASN.1 definitions */ +ASN1_SEQUENCE(X9_62_PENTANOMIAL) = { + ASN1_SIMPLE(X9_62_PENTANOMIAL, k1, LONG), + ASN1_SIMPLE(X9_62_PENTANOMIAL, k2, LONG), + ASN1_SIMPLE(X9_62_PENTANOMIAL, k3, LONG) +} ASN1_SEQUENCE_END(X9_62_PENTANOMIAL) -ASN1_SEQUENCE(X9_62_FIELDID) = { - ASN1_SIMPLE(X9_62_FIELDID, fieldType, ASN1_OBJECT), - ASN1_SIMPLE(X9_62_FIELDID, parameters, ASN1_ANY) -} ASN1_SEQUENCE_END(X9_62_FIELDID) +DECLARE_ASN1_ALLOC_FUNCTIONS(X9_62_PENTANOMIAL) +IMPLEMENT_ASN1_ALLOC_FUNCTIONS(X9_62_PENTANOMIAL) + +ASN1_ADB_TEMPLATE(char_two_def) = ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.other, ASN1_ANY); -DECLARE_ASN1_FUNCTIONS_const(X9_62_FIELDID) -DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_FIELDID, X9_62_FIELDID) -IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_FIELDID) +ASN1_ADB(X9_62_CHARACTERISTIC_TWO) = { + ADB_ENTRY(NID_X9_62_onBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.onBasis, ASN1_NULL)), + ADB_ENTRY(NID_X9_62_tpBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.tpBasis, ASN1_INTEGER)), + ADB_ENTRY(NID_X9_62_ppBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.ppBasis, X9_62_PENTANOMIAL)) +} ASN1_ADB_END(X9_62_CHARACTERISTIC_TWO, 0, type, 0, &char_two_def_tt, NULL); ASN1_SEQUENCE(X9_62_CHARACTERISTIC_TWO) = { ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, m, LONG), - ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, basis, ASN1_OBJECT), - ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, parameters, ASN1_ANY) + ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, type, ASN1_OBJECT), + ASN1_ADB_OBJECT(X9_62_CHARACTERISTIC_TWO) } ASN1_SEQUENCE_END(X9_62_CHARACTERISTIC_TWO) -DECLARE_ASN1_FUNCTIONS_const(X9_62_CHARACTERISTIC_TWO) -DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_CHARACTERISTIC_TWO, X9_62_CHARACTERISTIC_TWO) -IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_CHARACTERISTIC_TWO) +DECLARE_ASN1_ALLOC_FUNCTIONS(X9_62_CHARACTERISTIC_TWO) +IMPLEMENT_ASN1_ALLOC_FUNCTIONS(X9_62_CHARACTERISTIC_TWO) -ASN1_SEQUENCE(X9_62_PENTANOMIAL) = { - ASN1_SIMPLE(X9_62_PENTANOMIAL, k1, LONG), - ASN1_SIMPLE(X9_62_PENTANOMIAL, k2, LONG), - ASN1_SIMPLE(X9_62_PENTANOMIAL, k3, LONG) -} ASN1_SEQUENCE_END(X9_62_PENTANOMIAL) +ASN1_ADB_TEMPLATE(fieldID_def) = ASN1_SIMPLE(X9_62_FIELDID, p.other, ASN1_ANY); -DECLARE_ASN1_FUNCTIONS_const(X9_62_PENTANOMIAL) -DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_PENTANOMIAL, X9_62_PENTANOMIAL) -IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_PENTANOMIAL) +ASN1_ADB(X9_62_FIELDID) = { + ADB_ENTRY(NID_X9_62_prime_field, ASN1_SIMPLE(X9_62_FIELDID, p.prime, ASN1_INTEGER)), + ADB_ENTRY(NID_X9_62_characteristic_two_field, ASN1_SIMPLE(X9_62_FIELDID, p.char_two, X9_62_CHARACTERISTIC_TWO)) +} ASN1_ADB_END(X9_62_FIELDID, 0, fieldType, 0, &fieldID_def_tt, NULL); + +ASN1_SEQUENCE(X9_62_FIELDID) = { + ASN1_SIMPLE(X9_62_FIELDID, fieldType, ASN1_OBJECT), + ASN1_ADB_OBJECT(X9_62_FIELDID) +} ASN1_SEQUENCE_END(X9_62_FIELDID) ASN1_SEQUENCE(X9_62_CURVE) = { ASN1_SIMPLE(X9_62_CURVE, a, ASN1_OCTET_STRING), @@ -149,22 +241,17 @@ ASN1_SEQUENCE(X9_62_CURVE) = { ASN1_OPT(X9_62_CURVE, seed, ASN1_BIT_STRING) } ASN1_SEQUENCE_END(X9_62_CURVE) -DECLARE_ASN1_FUNCTIONS_const(X9_62_CURVE) -DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_CURVE, X9_62_CURVE) -IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_CURVE) - ASN1_SEQUENCE(ECPARAMETERS) = { ASN1_SIMPLE(ECPARAMETERS, version, LONG), ASN1_SIMPLE(ECPARAMETERS, fieldID, X9_62_FIELDID), ASN1_SIMPLE(ECPARAMETERS, curve, X9_62_CURVE), ASN1_SIMPLE(ECPARAMETERS, base, ASN1_OCTET_STRING), ASN1_SIMPLE(ECPARAMETERS, order, ASN1_INTEGER), - ASN1_SIMPLE(ECPARAMETERS, cofactor, ASN1_INTEGER) + ASN1_OPT(ECPARAMETERS, cofactor, ASN1_INTEGER) } ASN1_SEQUENCE_END(ECPARAMETERS) -DECLARE_ASN1_FUNCTIONS_const(ECPARAMETERS) -DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPARAMETERS, ECPARAMETERS) -IMPLEMENT_ASN1_FUNCTIONS_const(ECPARAMETERS) +DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS) +IMPLEMENT_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS) ASN1_CHOICE(ECPKPARAMETERS) = { ASN1_SIMPLE(ECPKPARAMETERS, value.named_curve, ASN1_OBJECT), @@ -189,12 +276,10 @@ IMPLEMENT_ASN1_FUNCTIONS_const(EC_PRIVATEKEY) /* some declarations of internal function */ -/* ec_asn1_group2field() creates a X9_62_FIELDID object from a - * EC_GROUP object */ -static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *, X9_62_FIELDID *); -/* ec_asn1_group2curve() creates a X9_62_CURVE object from a - * EC_GROUP object */ -static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *, X9_62_CURVE *); +/* ec_asn1_group2field() sets the values in a X9_62_FIELDID object */ +static int ec_asn1_group2fieldid(const EC_GROUP *, X9_62_FIELDID *); +/* ec_asn1_group2curve() sets the values in a X9_62_CURVE object */ +static int ec_asn1_group2curve(const EC_GROUP *, X9_62_CURVE *); /* ec_asn1_parameters2group() creates a EC_GROUP object from a * ECPARAMETERS object */ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *); @@ -212,50 +297,28 @@ static ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *, /* the function definitions */ -static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, - X9_62_FIELDID *field) +static int ec_asn1_group2fieldid(const EC_GROUP *group, X9_62_FIELDID *field) { int ok=0, nid; - X9_62_FIELDID *ret = NULL; - X9_62_CHARACTERISTIC_TWO *char_two = NULL; - X9_62_PENTANOMIAL *penta = NULL; BIGNUM *tmp = NULL; - unsigned char *buffer = NULL; - unsigned char *pp; - size_t buf_len = 0; - if (field == NULL) - { - if ((ret = X9_62_FIELDID_new()) == NULL) - { - ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); - return NULL; - } - } - else - { - ret = field; - /* clear the old values */ - if (ret->fieldType != NULL) - ASN1_OBJECT_free(ret->fieldType); - if (ret->parameters != NULL) - ASN1_TYPE_free(ret->parameters); - } + if (group == NULL || field == NULL) + return 0; + + /* clear the old values (if necessary) */ + if (field->fieldType != NULL) + ASN1_OBJECT_free(field->fieldType); + if (field->p.other != NULL) + ASN1_TYPE_free(field->p.other); nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group)); /* set OID for the field */ - if ((ret->fieldType = OBJ_nid2obj(nid)) == NULL) + if ((field->fieldType = OBJ_nid2obj(nid)) == NULL) { ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB); goto err; } - if ((ret->parameters = ASN1_TYPE_new()) == NULL) - { - ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); - goto err; - } - if (nid == NID_X9_62_prime_field) { if ((tmp = BN_new()) == NULL) @@ -264,26 +327,33 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, goto err; } /* the parameters are specified by the prime number p */ - ret->parameters->type = V_ASN1_INTEGER; if (!EC_GROUP_get_curve_GFp(group, tmp, NULL, NULL, NULL)) { ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB); goto err; } /* set the prime number */ - ret->parameters->value.integer = BN_to_ASN1_INTEGER(tmp, NULL); - if (ret->parameters->value.integer == NULL) + field->p.prime = BN_to_ASN1_INTEGER(tmp,NULL); + if (field->p.prime == NULL) { ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_ASN1_LIB); goto err; } } else /* nid == NID_X9_62_characteristic_two_field */ +#ifdef OPENSSL_NO_EC2M + { + ECerr(EC_F_EC_ASN1_GROUP2FIELDID, EC_R_GF2M_NOT_SUPPORTED); + goto err; + } +#else { int field_type; - unsigned int k1, k2, k3; + X9_62_CHARACTERISTIC_TWO *char_two; + + field->p.char_two = X9_62_CHARACTERISTIC_TWO_new(); + char_two = field->p.char_two; - char_two = X9_62_CHARACTERISTIC_TWO_new(); if (char_two == NULL) { ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); @@ -292,7 +362,7 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, char_two->m = (long)EC_GROUP_get_degree(group); - field_type = EC_GROUP_get_basis_type(group, &k1, &k2, &k3); + field_type = EC_GROUP_get_basis_type(group); if (field_type == 0) { @@ -300,7 +370,7 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, goto err; } /* set base type OID */ - if ((char_two->basis = OBJ_nid2obj(field_type)) == NULL) + if ((char_two->type = OBJ_nid2obj(field_type)) == NULL) { ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB); goto err; @@ -308,128 +378,81 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, if (field_type == NID_X9_62_tpBasis) { - char_two->parameters->type = V_ASN1_INTEGER; - char_two->parameters->value.integer = - ASN1_INTEGER_new(); - if (char_two->parameters->value.integer == NULL) + unsigned int k; + + if (!EC_GROUP_get_trinomial_basis(group, &k)) + goto err; + + char_two->p.tpBasis = ASN1_INTEGER_new(); + if (!char_two->p.tpBasis) { - ECerr(EC_F_EC_ASN1_GROUP2FIELDID, - ERR_R_ASN1_LIB); + ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); goto err; } - if (!ASN1_INTEGER_set(char_two->parameters->value.integer, (long)k1)) + if (!ASN1_INTEGER_set(char_two->p.tpBasis, (long)k)) { - ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, + ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_ASN1_LIB); goto err; } } else if (field_type == NID_X9_62_ppBasis) { - penta = X9_62_PENTANOMIAL_new(); - /* set k? values */ - penta->k1 = (long)k1; - penta->k2 = (long)k2; - penta->k3 = (long)k3; - /* get the length of the encoded structure */ - buf_len = i2d_X9_62_PENTANOMIAL(penta, NULL); - if ((buffer = OPENSSL_malloc(buf_len)) == NULL) + unsigned int k1, k2, k3; + + if (!EC_GROUP_get_pentanomial_basis(group, &k1, &k2, &k3)) + goto err; + + char_two->p.ppBasis = X9_62_PENTANOMIAL_new(); + if (!char_two->p.ppBasis) { - ECerr(EC_F_EC_ASN1_GROUP2FIELDID, - ERR_R_MALLOC_FAILURE); + ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); goto err; } - pp = buffer; - i2d_X9_62_PENTANOMIAL(penta, &pp); - /* set the encoded pentanomial */ - char_two->parameters->type=V_ASN1_SEQUENCE; - char_two->parameters->value.sequence=ASN1_STRING_new(); - ASN1_STRING_set(char_two->parameters->value.sequence, - buffer, buf_len); - - OPENSSL_free(buffer); - buffer = NULL; + + /* set k? values */ + char_two->p.ppBasis->k1 = (long)k1; + char_two->p.ppBasis->k2 = (long)k2; + char_two->p.ppBasis->k3 = (long)k3; } else /* field_type == NID_X9_62_onBasis */ { /* for ONB the parameters are (asn1) NULL */ - char_two->parameters->type = V_ASN1_NULL; - } - /* encoded the X9_62_CHARACTERISTIC_TWO structure */ - buf_len = i2d_X9_62_CHARACTERISTIC_TWO(char_two, NULL); - - if ((buffer = OPENSSL_malloc(buf_len)) == NULL) - { - ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); - goto err; + char_two->p.onBasis = ASN1_NULL_new(); + if (!char_two->p.onBasis) + { + ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE); + goto err; + } } - pp = buffer; - i2d_X9_62_CHARACTERISTIC_TWO(char_two, &pp); - /* set the encoded parameters */ - ret->parameters->type = V_ASN1_SEQUENCE; - ret->parameters->value.sequence = ASN1_STRING_new(); - ASN1_STRING_set(ret->parameters->value.sequence, - buffer, buf_len); } +#endif ok = 1; -err : if (!ok) - { - if (ret && !field) - X9_62_FIELDID_free(ret); - ret = NULL; - } - if (tmp) +err : if (tmp) BN_free(tmp); - if (char_two) - X9_62_CHARACTERISTIC_TWO_free(char_two); - if (penta) - X9_62_PENTANOMIAL_free(penta); - if (buffer) - OPENSSL_free(buffer); - return(ret); + return(ok); } -static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, - X9_62_CURVE *curve) +static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve) { int ok=0, nid; - X9_62_CURVE *ret=NULL; - BIGNUM *tmp_1=NULL, - *tmp_2=NULL; - unsigned char *buffer_1=NULL, - *buffer_2=NULL, - *a_buf=NULL, - *b_buf=NULL; + BIGNUM *tmp_1=NULL, *tmp_2=NULL; + unsigned char *buffer_1=NULL, *buffer_2=NULL, + *a_buf=NULL, *b_buf=NULL; size_t len_1, len_2; unsigned char char_zero = 0; + if (!group || !curve || !curve->a || !curve->b) + return 0; + if ((tmp_1 = BN_new()) == NULL || (tmp_2 = BN_new()) == NULL) { ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE); goto err; } - if (curve == NULL) - { - if ((ret = X9_62_CURVE_new()) == NULL) - { - ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE); - goto err; - } - } - else - { - ret = curve; - if (ret->a) - ASN1_OCTET_STRING_free(ret->a); - if (ret->b) - ASN1_OCTET_STRING_free(ret->b); - if (ret->seed) - ASN1_BIT_STRING_free(ret->seed); - } - nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group)); /* get a and b */ @@ -441,6 +464,7 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, goto err; } } +#ifndef OPENSSL_NO_EC2M else /* nid == NID_X9_62_characteristic_two_field */ { if (!EC_GROUP_get_curve_GF2m(group, NULL, tmp_1, tmp_2, NULL)) @@ -449,7 +473,7 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, goto err; } } - +#endif len_1 = (size_t)BN_num_bytes(tmp_1); len_2 = (size_t)BN_num_bytes(tmp_2); @@ -498,14 +522,8 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, } /* set a and b */ - if ((ret->a = M_ASN1_OCTET_STRING_new()) == NULL || - (ret->b = M_ASN1_OCTET_STRING_new()) == NULL ) - { - ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE); - goto err; - } - if (!M_ASN1_OCTET_STRING_set(ret->a, a_buf, len_1) || - !M_ASN1_OCTET_STRING_set(ret->b, b_buf, len_2)) + if (!M_ASN1_OCTET_STRING_set(curve->a, a_buf, len_1) || + !M_ASN1_OCTET_STRING_set(curve->b, b_buf, len_2)) { ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB); goto err; @@ -514,8 +532,15 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, /* set the seed (optional) */ if (group->seed) { - if ((ret->seed = ASN1_BIT_STRING_new()) == NULL) goto err; - if (!ASN1_BIT_STRING_set(ret->seed, group->seed, + if (!curve->seed) + if ((curve->seed = ASN1_BIT_STRING_new()) == NULL) + { + ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE); + goto err; + } + curve->seed->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); + curve->seed->flags |= ASN1_STRING_FLAG_BITS_LEFT; + if (!ASN1_BIT_STRING_set(curve->seed, group->seed, (int)group->seed_len)) { ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB); @@ -523,17 +548,17 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group, } } else - ret->seed = NULL; + { + if (curve->seed) + { + ASN1_BIT_STRING_free(curve->seed); + curve->seed = NULL; + } + } ok = 1; -err : if (!ok) - { - if (ret && !curve) - X9_62_CURVE_free(ret); - ret = NULL; - } - if (buffer_1) +err: if (buffer_1) OPENSSL_free(buffer_1); if (buffer_2) OPENSSL_free(buffer_2); @@ -541,7 +566,7 @@ err : if (!ok) BN_free(tmp_1); if (tmp_2) BN_free(tmp_2); - return(ret); + return(ok); } static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group, @@ -577,16 +602,14 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group, ret->version = (long)0x1; /* set the fieldID */ - ret->fieldID = ec_asn1_group2field(group, ret->fieldID); - if (ret->fieldID == NULL) + if (!ec_asn1_group2fieldid(group, ret->fieldID)) { ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB); goto err; } /* set the curve */ - ret->curve = ec_asn1_group2curve(group, ret->curve); - if (ret->curve == NULL) + if (!ec_asn1_group2curve(group, ret->curve)) { ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB); goto err; @@ -641,17 +664,15 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group, goto err; } - /* set the cofactor */ - if (!EC_GROUP_get_cofactor(group, tmp, NULL)) - { - ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB); - goto err; - } - ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor); - if (ret->cofactor == NULL) + /* set the cofactor (optional) */ + if (EC_GROUP_get_cofactor(group, tmp, NULL)) { - ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB); - goto err; + ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor); + if (ret->cofactor == NULL) + { + ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB); + goto err; + } } ok = 1; @@ -697,7 +718,7 @@ ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *group, /* use the asn1 OID to describe the * the elliptic curve parameters */ - tmp = EC_GROUP_get_nid(group); + tmp = EC_GROUP_get_curve_name(group); if (tmp) { ret->type = 0; @@ -731,12 +752,10 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) EC_GROUP *ret = NULL; BIGNUM *p = NULL, *a = NULL, *b = NULL; EC_POINT *point=NULL; - X9_62_CHARACTERISTIC_TWO *char_two = NULL; - X9_62_PENTANOMIAL *penta = NULL; - unsigned char *pp; + long field_bits; if (!params->fieldID || !params->fieldID->fieldType || - !params->fieldID->parameters) + !params->fieldID->p.ptr) { ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); goto err; @@ -765,77 +784,77 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) /* get the field parameters */ tmp = OBJ_obj2nid(params->fieldID->fieldType); - if (tmp == NID_X9_62_characteristic_two_field) +#ifdef OPENSSL_NO_EC2M + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_GF2M_NOT_SUPPORTED); + goto err; + } +#else { - ASN1_TYPE *parameters = params->fieldID->parameters; + X9_62_CHARACTERISTIC_TWO *char_two; - if (parameters->type != V_ASN1_SEQUENCE) + char_two = params->fieldID->p.char_two; + + field_bits = char_two->m; + if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE); goto err; } if ((p = BN_new()) == NULL) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, - ERR_R_MALLOC_FAILURE); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE); goto err; } - /* extract the X9_62_CHARACTERISTIC_TWO object */ - pp = M_ASN1_STRING_data(parameters->value.sequence); - char_two = d2i_X9_62_CHARACTERISTIC_TWO(NULL, - (const unsigned char **) &pp, - M_ASN1_STRING_length(parameters->value.sequence)); - if (char_two == NULL) - { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB); - goto err; - } /* get the base type */ - tmp = OBJ_obj2nid(char_two->basis); + tmp = OBJ_obj2nid(char_two->type); if (tmp == NID_X9_62_tpBasis) { long tmp_long; - if (char_two->parameters->type != V_ASN1_INTEGER || - char_two->parameters->value.integer == NULL) + if (!char_two->p.tpBasis) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, - EC_R_ASN1_ERROR); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); goto err; } - tmp_long = ASN1_INTEGER_get(char_two->parameters->value.integer); + tmp_long = ASN1_INTEGER_get(char_two->p.tpBasis); + + if (!(char_two->m > tmp_long && tmp_long > 0)) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_TRINOMIAL_BASIS); + goto err; + } + /* create the polynomial */ - if (!BN_set_bit(p, (int)char_two->m)) goto err; - if (!BN_set_bit(p, (int)tmp_long)) goto err; - if (!BN_set_bit(p, 0)) goto err; + if (!BN_set_bit(p, (int)char_two->m)) + goto err; + if (!BN_set_bit(p, (int)tmp_long)) + goto err; + if (!BN_set_bit(p, 0)) + goto err; } else if (tmp == NID_X9_62_ppBasis) { - if (char_two->parameters->type != V_ASN1_SEQUENCE || - char_two->parameters->value.sequence == NULL) + X9_62_PENTANOMIAL *penta; + + penta = char_two->p.ppBasis; + if (!penta) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, - EC_R_ASN1_ERROR); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); goto err; } - /* extract the pentanomial data */ - pp = M_ASN1_STRING_data( - char_two->parameters->value.sequence); - penta = d2i_X9_62_PENTANOMIAL(NULL, - (const unsigned char **) &pp, - M_ASN1_STRING_length( - char_two->parameters->value.sequence)); - if (penta == NULL) + + if (!(char_two->m > penta->k3 && penta->k3 > penta->k2 && penta->k2 > penta->k1 && penta->k1 > 0)) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, - ERR_R_ASN1_LIB); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_PENTANOMIAL_BASIS); goto err; } + /* create the polynomial */ if (!BN_set_bit(p, (int)char_two->m)) goto err; if (!BN_set_bit(p, (int)penta->k1)) goto err; @@ -845,8 +864,7 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) } else if (tmp == NID_X9_62_onBasis) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, - EC_R_NOT_IMPLEMENTED); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_NOT_IMPLEMENTED); goto err; } else /* error */ @@ -857,35 +875,50 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) /* create the EC_GROUP structure */ ret = EC_GROUP_new_curve_GF2m(p, a, b, NULL); - if (ret == NULL) - { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB); - goto err; - } } +#endif else if (tmp == NID_X9_62_prime_field) { /* we have a curve over a prime field */ /* extract the prime number */ - if (params->fieldID->parameters->type != V_ASN1_INTEGER || - !params->fieldID->parameters->value.integer) + if (!params->fieldID->p.prime) { ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); goto err; } - p = ASN1_INTEGER_to_BN(params->fieldID->parameters->value.integer, NULL); + p = ASN1_INTEGER_to_BN(params->fieldID->p.prime, NULL); if (p == NULL) { ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB); goto err; } - /* create the EC_GROUP structure */ - ret = EC_GROUP_new_curve_GFp(p, a, b, NULL); - if (ret == NULL) + + if (BN_is_negative(p) || BN_is_zero(p)) { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB); + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD); goto err; } + + field_bits = BN_num_bits(p); + if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE); + goto err; + } + + /* create the EC_GROUP structure */ + ret = EC_GROUP_new_curve_GFp(p, a, b, NULL); + } + else + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD); + goto err; + } + + if (ret == NULL) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB); + goto err; } /* extract seed (optional) */ @@ -904,9 +937,7 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) ret->seed_len = params->curve->seed->length; } - /* extract the order, cofactor and generator */ - if (!params->order || !params->cofactor || !params->base || - !params->base->data) + if (!params->order || !params->base || !params->base->data) { ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); goto err; @@ -914,14 +945,11 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) if ((point = EC_POINT_new(ret)) == NULL) goto err; - a = ASN1_INTEGER_to_BN(params->order, a); - b = ASN1_INTEGER_to_BN(params->cofactor, b); - if (!a || !b) - { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB); - goto err; - } + /* set the point conversion form */ + EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t) + (params->base->data[0] & ~0x01)); + /* extract the ec point */ if (!EC_POINT_oct2point(ret, point, params->base->data, params->base->length, NULL)) { @@ -929,10 +957,39 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params) goto err; } - /* set the point conversion form */ - EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t) - (params->base->data[0] & ~0x01)); - + /* extract the order */ + if ((a = ASN1_INTEGER_to_BN(params->order, a)) == NULL) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB); + goto err; + } + if (BN_is_negative(a) || BN_is_zero(a)) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER); + goto err; + } + if (BN_num_bits(a) > (int)field_bits + 1) /* Hasse bound */ + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER); + goto err; + } + + /* extract the cofactor (optional) */ + if (params->cofactor == NULL) + { + if (b) + { + BN_free(b); + b = NULL; + } + } + else + if ((b = ASN1_INTEGER_to_BN(params->cofactor, b)) == NULL) + { + ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB); + goto err; + } + /* set the generator, order and cofactor (if present) */ if (!EC_GROUP_set_generator(ret, point, a, b)) { ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB); @@ -956,10 +1013,6 @@ err: if (!ok) BN_free(b); if (point) EC_POINT_free(point); - if (char_two) - X9_62_CHARACTERISTIC_TWO_free(char_two); - if (penta) - X9_62_PENTANOMIAL_free(penta); return(ret); } @@ -978,7 +1031,7 @@ EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params) if (params->type == 0) { /* the curve is given by an OID */ tmp = OBJ_obj2nid(params->value.named_curve); - if ((ret = EC_GROUP_new_by_nid(tmp)) == NULL) + if ((ret = EC_GROUP_new_by_curve_name(tmp)) == NULL) { ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_EC_GROUP_NEW_BY_NAME_FAILURE); @@ -1003,7 +1056,7 @@ EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params) } else { - ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR); + ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_ASN1_ERROR); return NULL; } @@ -1027,6 +1080,7 @@ EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len) if ((group = ec_asn1_pkparameters2group(params)) == NULL) { ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_PKPARAMETERS2GROUP_FAILURE); + ECPKPARAMETERS_free(params); return NULL; } @@ -1131,6 +1185,9 @@ EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len) if (priv_key->publicKey) { + const unsigned char *pub_oct; + size_t pub_oct_len; + if (ret->pub_key) EC_POINT_clear_free(ret->pub_key); ret->pub_key = EC_POINT_new(ret->group); @@ -1139,9 +1196,12 @@ EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len) ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB); goto err; } + pub_oct = M_ASN1_STRING_data(priv_key->publicKey); + pub_oct_len = M_ASN1_STRING_length(priv_key->publicKey); + /* save the point conversion form */ + ret->conv_form = (point_conversion_form_t)(pub_oct[0] & ~0x01); if (!EC_POINT_oct2point(ret->group, ret->pub_key, - M_ASN1_STRING_data(priv_key->publicKey), - M_ASN1_STRING_length(priv_key->publicKey), NULL)) + pub_oct, pub_oct_len, NULL)) { ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB); goto err; @@ -1231,16 +1291,17 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out) a->conv_form, NULL, 0, NULL); if (tmp_len > buf_len) - buffer = OPENSSL_realloc(buffer, tmp_len); - if (buffer == NULL) { - ECerr(EC_F_I2D_ECPRIVATEKEY, - ERR_R_MALLOC_FAILURE); - goto err; + unsigned char *tmp_buffer = OPENSSL_realloc(buffer, tmp_len); + if (!tmp_buffer) + { + ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE); + goto err; + } + buffer = tmp_buffer; + buf_len = tmp_len; } - buf_len = tmp_len; - if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form, buffer, buf_len, NULL)) { @@ -1248,6 +1309,8 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out) goto err; } + priv_key->publicKey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); + priv_key->publicKey->flags |= ASN1_STRING_FLAG_BITS_LEFT; if (!M_ASN1_BIT_STRING_set(priv_key->publicKey, buffer, buf_len)) { @@ -1282,7 +1345,6 @@ int i2d_ECParameters(EC_KEY *a, unsigned char **out) EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len) { - EC_GROUP *group; EC_KEY *ret; if (in == NULL || *in == NULL) @@ -1291,14 +1353,6 @@ EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len) return NULL; } - group = d2i_ECPKParameters(NULL, in, len); - - if (group == NULL) - { - ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB); - return NULL; - } - if (a == NULL || *a == NULL) { if ((ret = EC_KEY_new()) == NULL) @@ -1312,16 +1366,16 @@ EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len) else ret = *a; - if (ret->group) - EC_GROUP_clear_free(ret->group); + if (!d2i_ECPKParameters(&ret->group, in, len)) + { + ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB); + return NULL; + } - ret->group = group; - return ret; } -EC_KEY *ECPublicKey_set_octet_string(EC_KEY **a, const unsigned char **in, - long len) +EC_KEY *o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len) { EC_KEY *ret=NULL; @@ -1329,33 +1383,35 @@ EC_KEY *ECPublicKey_set_octet_string(EC_KEY **a, const unsigned char **in, { /* sorry, but a EC_GROUP-structur is necessary * to set the public key */ - ECerr(EC_F_ECPUBLICKEY_SET_OCTET, ERR_R_PASSED_NULL_PARAMETER); + ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER); return 0; } ret = *a; if (ret->pub_key == NULL && (ret->pub_key = EC_POINT_new(ret->group)) == NULL) { - ECerr(EC_F_ECPUBLICKEY_SET_OCTET, ERR_R_MALLOC_FAILURE); + ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_MALLOC_FAILURE); return 0; } if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL)) { - ECerr(EC_F_ECPUBLICKEY_SET_OCTET, ERR_R_EC_LIB); + ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_EC_LIB); return 0; } /* save the point conversion form */ ret->conv_form = (point_conversion_form_t)(*in[0] & ~0x01); + *in += len; return ret; } -int ECPublicKey_get_octet_string(EC_KEY *a, unsigned char **out) +int i2o_ECPublicKey(EC_KEY *a, unsigned char **out) { - size_t buf_len=0; + size_t buf_len=0; + int new_buffer = 0; if (a == NULL) { - ECerr(EC_F_ECPUBLICKEY_GET_OCTET, ERR_R_PASSED_NULL_PARAMETER); + ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER); return 0; } @@ -1367,19 +1423,23 @@ int ECPublicKey_get_octet_string(EC_KEY *a, unsigned char **out) return buf_len; if (*out == NULL) + { if ((*out = OPENSSL_malloc(buf_len)) == NULL) { - ECerr(EC_F_ECPUBLICKEY_GET_OCTET, - ERR_R_MALLOC_FAILURE); + ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE); return 0; } + new_buffer = 1; + } if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form, *out, buf_len, NULL)) { - ECerr(EC_F_ECPUBLICKEY_GET_OCTET, ERR_R_EC_LIB); + ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB); OPENSSL_free(*out); *out = NULL; return 0; } + if (!new_buffer) + *out += buf_len; return buf_len; }