#include "apps.h"
#include <openssl/bio.h>
#include <openssl/err.h>
-#include <openssl/ecdsa.h>
#include <openssl/evp.h>
+#include <openssl/ecdsa.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
{
ENGINE *e = NULL;
int ret = 1;
- ECDSA *ecdsa = NULL;
+ EC_KEY *eckey = NULL;
int i, badops = 0;
const EVP_CIPHER *enc = NULL;
BIO *in = NULL, *out = NULL;
if (informat == FORMAT_ASN1)
{
if (pubin)
- ecdsa = d2i_ECDSA_PUBKEY_bio(in, NULL);
+ eckey = d2i_EC_PUBKEY_bio(in, NULL);
else
- ecdsa = d2i_ECDSAPrivateKey_bio(in, NULL);
+ eckey = d2i_ECPrivateKey_bio(in, NULL);
}
else if (informat == FORMAT_PEM)
{
if (pubin)
- ecdsa = PEM_read_bio_ECDSA_PUBKEY(in, NULL, NULL,
+ eckey = PEM_read_bio_EC_PUBKEY(in, NULL, NULL,
NULL);
else
- ecdsa = PEM_read_bio_ECDSAPrivateKey(in, NULL, NULL,
+ eckey = PEM_read_bio_ECPrivateKey(in, NULL, NULL,
passin);
}
else
BIO_printf(bio_err, "bad input format specified for key\n");
goto end;
}
- if (ecdsa == NULL)
+ if (eckey == NULL)
{
BIO_printf(bio_err,"unable to load Key\n");
ERR_print_errors(bio_err);
if (new_form)
{
- EC_GROUP_set_point_conversion_form(ecdsa->group, form);
- ECDSA_set_conversion_form(ecdsa, form);
+ EC_GROUP_set_point_conversion_form(eckey->group, form);
+ eckey->conv_form = form;
}
if (new_asn1_flag)
- EC_GROUP_set_asn1_flag(ecdsa->group, asn1_flag);
+ EC_GROUP_set_asn1_flag(eckey->group, asn1_flag);
if (text)
- if (!ECDSA_print(out, ecdsa, 0))
+ if (!EC_KEY_print(out, eckey, 0))
{
perror(outfile);
ERR_print_errors(bio_err);
if (noout)
goto end;
- BIO_printf(bio_err, "writing ECDSA key\n");
+ BIO_printf(bio_err, "writing EC key\n");
if (outformat == FORMAT_ASN1)
{
if (param_out)
- i = i2d_ECPKParameters_bio(out, ecdsa->group);
+ i = i2d_ECPKParameters_bio(out, eckey->group);
else if (pubin || pubout)
- i = i2d_ECDSA_PUBKEY_bio(out, ecdsa);
+ i = i2d_EC_PUBKEY_bio(out, eckey);
else
- i = i2d_ECDSAPrivateKey_bio(out, ecdsa);
+ i = i2d_ECPrivateKey_bio(out, eckey);
}
else if (outformat == FORMAT_PEM)
{
if (param_out)
- i = PEM_write_bio_ECPKParameters(out, ecdsa->group);
+ i = PEM_write_bio_ECPKParameters(out, eckey->group);
else if (pubin || pubout)
- i = PEM_write_bio_ECDSA_PUBKEY(out, ecdsa);
+ i = PEM_write_bio_EC_PUBKEY(out, eckey);
else
- i = PEM_write_bio_ECDSAPrivateKey(out, ecdsa, enc,
+ i = PEM_write_bio_ECPrivateKey(out, eckey, enc,
NULL, 0, NULL, passout);
}
else
BIO_free(in);
if (out)
BIO_free_all(out);
- if (ecdsa)
- ECDSA_free(ecdsa);
+ if (eckey)
+ EC_KEY_free(eckey);
if (passin)
OPENSSL_free(passin);
if (passout)
/* apps/ecparam.c */
+/*
+ * Originally written by Nils Larsch for the OpenSSL project.
+ */
/* ====================================================================
* Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
*
* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
*
*/
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/err.h>
#include <openssl/bn.h>
#include <openssl/ec.h>
+#ifndef OPENSSL_NO_ECDSA
#include <openssl/ecdsa.h>
+#endif
#include <openssl/x509.h>
#include <openssl/pem.h>
if (genkey)
{
- ECDSA *ecdsa = ECDSA_new();
+ EC_KEY *eckey = EC_KEY_new();
- if (ecdsa == NULL)
+ if (eckey == NULL)
goto end;
assert(need_rand);
- ecdsa->group = group;
+ eckey->group = group;
- if (!ECDSA_generate_key(ecdsa))
+ if (!EC_KEY_generate_key(eckey))
{
- ecdsa->group = NULL;
- ECDSA_free(ecdsa);
+ eckey->group = NULL;
+ EC_KEY_free(eckey);
goto end;
}
if (outformat == FORMAT_ASN1)
- i = i2d_ECDSAPrivateKey_bio(out, ecdsa);
+ i = i2d_ECPrivateKey_bio(out, eckey);
else if (outformat == FORMAT_PEM)
- i = PEM_write_bio_ECDSAPrivateKey(out, ecdsa, NULL,
+ i = PEM_write_bio_ECPrivateKey(out, eckey, NULL,
NULL, 0, NULL, NULL);
else
{
BIO_printf(bio_err, "bad output format specified "
"for outfile\n");
- ecdsa->group = NULL;
- ECDSA_free(ecdsa);
+ eckey->group = NULL;
+ EC_KEY_free(eckey);
goto end;
}
- ecdsa->group = NULL;
- ECDSA_free(ecdsa);
+ eckey->group = NULL;
+ EC_KEY_free(eckey);
}
if (need_rand)
#define TYPE_RSA 1
#define TYPE_DSA 2
#define TYPE_DH 3
-#define TYPE_ECDSA 4
+#define TYPE_EC 4
int MAIN(int, char **);
#ifndef OPENSSL_NO_DSA
DSA *dsa_params=NULL;
#endif
-#ifndef OPENSSL_NO_ECDSA
- ECDSA *ecdsa_params = NULL;
+#ifndef OPENSSL_NO_EC
+ EC_KEY *ec_params = NULL;
#endif
unsigned long nmflag = 0;
int ex=1,x509=0,days=30;
}
else
#endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
if (strncmp("ecdsa:",p,4) == 0)
{
X509 *xtmp=NULL;
EVP_PKEY *dtmp;
- pkey_type=TYPE_ECDSA;
+ pkey_type=TYPE_EC;
p+=6;
if ((in=BIO_new_file(p,"r")) == NULL)
{
perror(p);
goto end;
}
- if ((ecdsa_params = ECDSA_new()) == NULL)
+ if ((ec_params = EC_KEY_new()) == NULL)
goto end;
- if ((ecdsa_params->group = PEM_read_bio_ECPKParameters(in, NULL, NULL, NULL)) == NULL)
+ if ((ec_params->group = PEM_read_bio_ECPKParameters(in, NULL, NULL, NULL)) == NULL)
{
- if (ecdsa_params)
- ECDSA_free(ecdsa_params);
+ if (ec_params)
+ EC_KEY_free(ec_params);
ERR_clear_error();
(void)BIO_reset(in);
if ((xtmp=PEM_read_bio_X509(in,NULL,NULL,NULL)) == NULL)
{
- BIO_printf(bio_err,"unable to load ECDSA parameters from file\n");
+ BIO_printf(bio_err,"unable to load EC parameters from file\n");
goto end;
}
if ((dtmp=X509_get_pubkey(xtmp)) == NULL) goto end;
- if (dtmp->type == EVP_PKEY_ECDSA)
- ecdsa_params = ECDSAParameters_dup(dtmp->pkey.ecdsa);
+ if (dtmp->type == EVP_PKEY_EC)
+ ec_params = ECParameters_dup(dtmp->pkey.eckey);
EVP_PKEY_free(dtmp);
X509_free(xtmp);
- if (ecdsa_params == NULL)
+ if (ec_params == NULL)
{
- BIO_printf(bio_err,"Certificate does not contain ECDSA parameters\n");
+ BIO_printf(bio_err,"Certificate does not contain EC parameters\n");
goto end;
}
}
if (!order)
goto end;
- if (!EC_GROUP_get_order(ecdsa_params->group, order, NULL))
+ if (!EC_GROUP_get_order(ec_params->group, order, NULL))
goto end;
newkey = BN_num_bits(order);
BN_free(order);
dsa_params=NULL;
}
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey_type == TYPE_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (pkey_type == TYPE_EC)
{
- if (!ECDSA_generate_key(ecdsa_params)) goto end;
- if (!EVP_PKEY_assign_ECDSA(pkey, ecdsa_params)) goto end;
- ecdsa_params = NULL;
+ if (!EC_KEY_generate_key(ec_params)) goto end;
+ if (!EVP_PKEY_assign_EC_KEY(pkey, ec_params))
+ goto end;
+ ec_params = NULL;
}
#endif
#ifndef OPENSSL_NO_DSA
if (dsa_params != NULL) DSA_free(dsa_params);
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (ecdsa_params != NULL) ECDSA_free(ecdsa_params);
+#ifndef OPENSSL_NO_EC
+ if (ec_params != NULL) EC_KEY_free(ec_params);
#endif
apps_shutdown();
EXIT(ex);
d2i_pr.o: ../../include/openssl/des.h ../../include/openssl/des_old.h
d2i_pr.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
d2i_pr.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
-d2i_pr.o: ../../include/openssl/ecdsa.h ../../include/openssl/err.h
-d2i_pr.o: ../../include/openssl/evp.h ../../include/openssl/idea.h
-d2i_pr.o: ../../include/openssl/lhash.h ../../include/openssl/md2.h
-d2i_pr.o: ../../include/openssl/md4.h ../../include/openssl/md5.h
-d2i_pr.o: ../../include/openssl/mdc2.h ../../include/openssl/obj_mac.h
-d2i_pr.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
-d2i_pr.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
-d2i_pr.o: ../../include/openssl/rc2.h ../../include/openssl/rc4.h
-d2i_pr.o: ../../include/openssl/rc5.h ../../include/openssl/ripemd.h
-d2i_pr.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
-d2i_pr.o: ../../include/openssl/sha.h ../../include/openssl/stack.h
-d2i_pr.o: ../../include/openssl/symhacks.h ../../include/openssl/ui.h
-d2i_pr.o: ../../include/openssl/ui_compat.h ../cryptlib.h d2i_pr.c
+d2i_pr.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+d2i_pr.o: ../../include/openssl/idea.h ../../include/openssl/lhash.h
+d2i_pr.o: ../../include/openssl/md2.h ../../include/openssl/md4.h
+d2i_pr.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+d2i_pr.o: ../../include/openssl/obj_mac.h ../../include/openssl/objects.h
+d2i_pr.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+d2i_pr.o: ../../include/openssl/ossl_typ.h ../../include/openssl/rc2.h
+d2i_pr.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+d2i_pr.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+d2i_pr.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+d2i_pr.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
+d2i_pr.o: ../../include/openssl/ui.h ../../include/openssl/ui_compat.h
+d2i_pr.o: ../cryptlib.h d2i_pr.c
d2i_pu.o: ../../e_os.h ../../include/openssl/aes.h ../../include/openssl/asn1.h
d2i_pu.o: ../../include/openssl/bio.h ../../include/openssl/blowfish.h
d2i_pu.o: ../../include/openssl/bn.h ../../include/openssl/buffer.h
d2i_pu.o: ../../include/openssl/des.h ../../include/openssl/des_old.h
d2i_pu.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
d2i_pu.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
-d2i_pu.o: ../../include/openssl/ecdsa.h ../../include/openssl/err.h
-d2i_pu.o: ../../include/openssl/evp.h ../../include/openssl/idea.h
-d2i_pu.o: ../../include/openssl/lhash.h ../../include/openssl/md2.h
-d2i_pu.o: ../../include/openssl/md4.h ../../include/openssl/md5.h
-d2i_pu.o: ../../include/openssl/mdc2.h ../../include/openssl/obj_mac.h
-d2i_pu.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
-d2i_pu.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
-d2i_pu.o: ../../include/openssl/rc2.h ../../include/openssl/rc4.h
-d2i_pu.o: ../../include/openssl/rc5.h ../../include/openssl/ripemd.h
-d2i_pu.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
-d2i_pu.o: ../../include/openssl/sha.h ../../include/openssl/stack.h
-d2i_pu.o: ../../include/openssl/symhacks.h ../../include/openssl/ui.h
-d2i_pu.o: ../../include/openssl/ui_compat.h ../cryptlib.h d2i_pu.c
+d2i_pu.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+d2i_pu.o: ../../include/openssl/idea.h ../../include/openssl/lhash.h
+d2i_pu.o: ../../include/openssl/md2.h ../../include/openssl/md4.h
+d2i_pu.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+d2i_pu.o: ../../include/openssl/obj_mac.h ../../include/openssl/objects.h
+d2i_pu.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+d2i_pu.o: ../../include/openssl/ossl_typ.h ../../include/openssl/rc2.h
+d2i_pu.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+d2i_pu.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+d2i_pu.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+d2i_pu.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
+d2i_pu.o: ../../include/openssl/ui.h ../../include/openssl/ui_compat.h
+d2i_pu.o: ../cryptlib.h d2i_pu.c
evp_asn1.o: ../../e_os.h ../../include/openssl/asn1.h
evp_asn1.o: ../../include/openssl/asn1_mac.h ../../include/openssl/bio.h
evp_asn1.o: ../../include/openssl/bn.h ../../include/openssl/buffer.h
i2d_pr.o: ../../include/openssl/des.h ../../include/openssl/des_old.h
i2d_pr.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
i2d_pr.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
-i2d_pr.o: ../../include/openssl/ecdsa.h ../../include/openssl/err.h
-i2d_pr.o: ../../include/openssl/evp.h ../../include/openssl/idea.h
-i2d_pr.o: ../../include/openssl/lhash.h ../../include/openssl/md2.h
-i2d_pr.o: ../../include/openssl/md4.h ../../include/openssl/md5.h
-i2d_pr.o: ../../include/openssl/mdc2.h ../../include/openssl/obj_mac.h
-i2d_pr.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
-i2d_pr.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
-i2d_pr.o: ../../include/openssl/rc2.h ../../include/openssl/rc4.h
-i2d_pr.o: ../../include/openssl/rc5.h ../../include/openssl/ripemd.h
-i2d_pr.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
-i2d_pr.o: ../../include/openssl/sha.h ../../include/openssl/stack.h
-i2d_pr.o: ../../include/openssl/symhacks.h ../../include/openssl/ui.h
-i2d_pr.o: ../../include/openssl/ui_compat.h ../cryptlib.h i2d_pr.c
+i2d_pr.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+i2d_pr.o: ../../include/openssl/idea.h ../../include/openssl/lhash.h
+i2d_pr.o: ../../include/openssl/md2.h ../../include/openssl/md4.h
+i2d_pr.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+i2d_pr.o: ../../include/openssl/obj_mac.h ../../include/openssl/objects.h
+i2d_pr.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+i2d_pr.o: ../../include/openssl/ossl_typ.h ../../include/openssl/rc2.h
+i2d_pr.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+i2d_pr.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+i2d_pr.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+i2d_pr.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
+i2d_pr.o: ../../include/openssl/ui.h ../../include/openssl/ui_compat.h
+i2d_pr.o: ../cryptlib.h i2d_pr.c
i2d_pu.o: ../../e_os.h ../../include/openssl/aes.h ../../include/openssl/asn1.h
i2d_pu.o: ../../include/openssl/bio.h ../../include/openssl/blowfish.h
i2d_pu.o: ../../include/openssl/bn.h ../../include/openssl/buffer.h
i2d_pu.o: ../../include/openssl/des.h ../../include/openssl/des_old.h
i2d_pu.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
i2d_pu.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
-i2d_pu.o: ../../include/openssl/ecdsa.h ../../include/openssl/err.h
-i2d_pu.o: ../../include/openssl/evp.h ../../include/openssl/idea.h
-i2d_pu.o: ../../include/openssl/lhash.h ../../include/openssl/md2.h
-i2d_pu.o: ../../include/openssl/md4.h ../../include/openssl/md5.h
-i2d_pu.o: ../../include/openssl/mdc2.h ../../include/openssl/obj_mac.h
-i2d_pu.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
-i2d_pu.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
-i2d_pu.o: ../../include/openssl/rc2.h ../../include/openssl/rc4.h
-i2d_pu.o: ../../include/openssl/rc5.h ../../include/openssl/ripemd.h
-i2d_pu.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
-i2d_pu.o: ../../include/openssl/sha.h ../../include/openssl/stack.h
-i2d_pu.o: ../../include/openssl/symhacks.h ../../include/openssl/ui.h
-i2d_pu.o: ../../include/openssl/ui_compat.h ../cryptlib.h i2d_pu.c
+i2d_pu.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+i2d_pu.o: ../../include/openssl/idea.h ../../include/openssl/lhash.h
+i2d_pu.o: ../../include/openssl/md2.h ../../include/openssl/md4.h
+i2d_pu.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+i2d_pu.o: ../../include/openssl/obj_mac.h ../../include/openssl/objects.h
+i2d_pu.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+i2d_pu.o: ../../include/openssl/ossl_typ.h ../../include/openssl/rc2.h
+i2d_pu.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+i2d_pu.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+i2d_pu.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+i2d_pu.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
+i2d_pu.o: ../../include/openssl/ui.h ../../include/openssl/ui_compat.h
+i2d_pu.o: ../cryptlib.h i2d_pu.c
n_pkey.o: ../../e_os.h ../../include/openssl/aes.h ../../include/openssl/asn1.h
n_pkey.o: ../../include/openssl/asn1_mac.h ../../include/openssl/asn1t.h
n_pkey.o: ../../include/openssl/bio.h ../../include/openssl/blowfish.h
t_pkey.o: ../../include/openssl/bn.h ../../include/openssl/buffer.h
t_pkey.o: ../../include/openssl/crypto.h ../../include/openssl/dh.h
t_pkey.o: ../../include/openssl/dsa.h ../../include/openssl/e_os2.h
-t_pkey.o: ../../include/openssl/ec.h ../../include/openssl/ecdsa.h
-t_pkey.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
-t_pkey.o: ../../include/openssl/obj_mac.h ../../include/openssl/objects.h
-t_pkey.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
-t_pkey.o: ../../include/openssl/ossl_typ.h ../../include/openssl/rsa.h
-t_pkey.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
-t_pkey.o: ../../include/openssl/symhacks.h ../cryptlib.h t_pkey.c
+t_pkey.o: ../../include/openssl/ec.h ../../include/openssl/err.h
+t_pkey.o: ../../include/openssl/lhash.h ../../include/openssl/obj_mac.h
+t_pkey.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
+t_pkey.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
+t_pkey.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
+t_pkey.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
+t_pkey.o: ../cryptlib.h t_pkey.c
t_req.o: ../../e_os.h ../../include/openssl/aes.h ../../include/openssl/asn1.h
t_req.o: ../../include/openssl/bio.h ../../include/openssl/blowfish.h
t_req.o: ../../include/openssl/bn.h ../../include/openssl/buffer.h
#define ASN1_F_I2D_ASN1_TIME 160
#define ASN1_F_I2D_DSA_PUBKEY 161
#define ASN1_F_I2D_ECDSA_PUBKEY 174
+#define ASN1_F_I2D_EC_PUBKEY 176
#define ASN1_F_I2D_NETSCAPE_RSA 162
#define ASN1_F_I2D_PRIVATEKEY 163
#define ASN1_F_I2D_PUBLICKEY 164
{ERR_PACK(0,ASN1_F_D2I_X509_PKEY,0), "d2i_X509_PKEY"},
{ERR_PACK(0,ASN1_F_I2D_ASN1_TIME,0), "I2D_ASN1_TIME"},
{ERR_PACK(0,ASN1_F_I2D_DSA_PUBKEY,0), "i2d_DSA_PUBKEY"},
-{ERR_PACK(0,ASN1_F_I2D_ECDSA_PUBKEY,0), "i2d_ECDSA_PUBKEY"},
+{ERR_PACK(0,ASN1_F_I2D_ECDSA_PUBKEY,0), "I2D_ECDSA_PUBKEY"},
+{ERR_PACK(0,ASN1_F_I2D_EC_PUBKEY,0), "i2d_EC_PUBKEY"},
{ERR_PACK(0,ASN1_F_I2D_NETSCAPE_RSA,0), "i2d_Netscape_RSA"},
{ERR_PACK(0,ASN1_F_I2D_PRIVATEKEY,0), "i2d_PrivateKey"},
{ERR_PACK(0,ASN1_F_I2D_PUBLICKEY,0), "i2d_PublicKey"},
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, unsigned char **pp,
}
break;
#endif
-#ifndef OPENSSL_NO_ECDSA
- case EVP_PKEY_ECDSA:
- if ((ret->pkey.ecdsa = d2i_ECDSAPrivateKey(NULL,
+#ifndef OPENSSL_NO_EC
+ case EVP_PKEY_EC:
+ if ((ret->pkey.eckey = d2i_ECPrivateKey(NULL,
(const unsigned char **)pp, length)) == NULL)
{
ASN1err(ASN1_F_D2I_PRIVATEKEY, ERR_R_ASN1_LIB);
if(sk_ASN1_TYPE_num(inkey) == 6)
keytype = EVP_PKEY_DSA;
else if (sk_ASN1_TYPE_num(inkey) == 4)
- keytype = EVP_PKEY_ECDSA;
+ keytype = EVP_PKEY_EC;
else keytype = EVP_PKEY_RSA;
sk_ASN1_TYPE_pop_free(inkey, ASN1_TYPE_free);
return d2i_PrivateKey(keytype, a, pp, length);
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, unsigned char **pp,
}
break;
#endif
-#ifndef OPENSSL_NO_ECDSA
- case EVP_PKEY_ECDSA:
- if ((ret->pkey.ecdsa = ECDSAPublicKey_set_octet_string(&(ret->pkey.ecdsa),
- (const unsigned char **)pp, length)) == NULL)
+#ifndef OPENSSL_NO_EC
+ case EVP_PKEY_EC:
+ if ((ret->pkey.eckey = ECPublicKey_set_octet_string(
+ &(ret->pkey.eckey), (const unsigned char **)pp,
+ length)) == NULL)
{
ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_ASN1_LIB);
goto err;
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp)
return(i2d_DSAPrivateKey(a->pkey.dsa,pp));
}
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (a->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (a->type == EVP_PKEY_EC)
{
- return(i2d_ECDSAPrivateKey(a->pkey.ecdsa, pp));
+ return(i2d_ECPrivateKey(a->pkey.eckey, pp));
}
#endif
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp)
case EVP_PKEY_DSA:
return(i2d_DSAPublicKey(a->pkey.dsa,pp));
#endif
-#ifndef OPENSSL_NO_ECDSA
- case EVP_PKEY_ECDSA:
- return(ECDSAPublicKey_get_octet_string(a->pkey.ecdsa, pp));
+#ifndef OPENSSL_NO_EC
+ case EVP_PKEY_EC:
+ return(ECPublicKey_get_octet_string(a->pkey.eckey, pp));
#endif
default:
ASN1err(ASN1_F_I2D_PUBLICKEY,ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
static int print(BIO *fp,const char *str,BIGNUM *num,
BIO_free(b);
return(ret);
}
+
+int EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
+ {
+ BIO *b;
+ int ret;
+
+ if ((b=BIO_new(BIO_s_file())) == NULL)
+ {
+ ECerr(EC_F_EC_KEY_PRINT_FP, ERR_R_BIO_LIB);
+ return(0);
+ }
+ BIO_set_fp(b, fp, BIO_NOCLOSE);
+ ret = EC_KEY_print(b, x, off);
+ BIO_free(b);
+ return(ret);
+ }
#endif
int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off)
OPENSSL_free(buffer);
return(ret);
}
-#endif /* OPENSSL_NO_EC */
-
-
-#ifndef OPENSSL_NO_ECDSA
-#ifndef OPENSSL_NO_FP_API
-int ECDSA_print_fp(FILE *fp, const ECDSA *x, int off)
-{
- BIO *b;
- int ret;
-
- if ((b=BIO_new(BIO_s_file())) == NULL)
- {
- ECDSAerr(ECDSA_F_ECDSA_PRINT_FP, ERR_R_BIO_LIB);
- return(0);
- }
- BIO_set_fp(b, fp, BIO_NOCLOSE);
- ret = ECDSA_print(b, x, off);
- BIO_free(b);
- return(ret);
-}
-#endif
-int ECDSA_print(BIO *bp, const ECDSA *x, int off)
+int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
{
char str[128];
unsigned char *buffer=NULL;
}
if ((pub_key = EC_POINT_point2bn(x->group, x->pub_key,
- ECDSA_get_conversion_form(x), NULL, ctx)) == NULL)
+ x->conv_form, NULL, ctx)) == NULL)
{
reason = ERR_R_EC_LIB;
goto err;
ret=1;
err:
if (!ret)
- ECDSAerr(ECDSA_F_ECDSA_PRINT, reason);
+ ECerr(EC_F_EC_KEY_PRINT, reason);
if (pub_key)
BN_free(pub_key);
if (ctx)
OPENSSL_free(buffer);
return(ret);
}
-#endif
+#endif /* OPENSSL_NO_EC */
static int print(BIO *bp, const char *number, BIGNUM *num, unsigned char *buf,
int off)
#endif /* !OPENSSL_NO_DSA */
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
#ifndef OPENSSL_NO_FP_API
-int ECDSAParameters_print_fp(FILE *fp, const ECDSA *x)
+int ECParameters_print_fp(FILE *fp, const EC_KEY *x)
{
BIO *b;
int ret;
if ((b=BIO_new(BIO_s_file())) == NULL)
- {
- ECDSAerr(ECDSA_F_ECDSAPARAMETERS_PRINT_FP, ERR_R_BIO_LIB);
+ {
+ ECerr(EC_F_ECPARAMETERS_PRINT_FP, ERR_R_BIO_LIB);
return(0);
- }
+ }
BIO_set_fp(b, fp, BIO_NOCLOSE);
- ret = ECDSAParameters_print(b, x);
+ ret = ECParameters_print(b, x);
BIO_free(b);
return(ret);
}
#endif
-int ECDSAParameters_print(BIO *bp, const ECDSA *x)
+int ECParameters_print(BIO *bp, const EC_KEY *x)
{
int reason=ERR_R_EC_LIB, ret=0;
BIGNUM *order=NULL;
err:
if (order)
BN_free(order);
- ECDSAerr(ECDSA_F_ECDSAPARAMETERS_PRINT, reason);
+ ECerr(EC_F_ECPARAMETERS_PRINT, reason);
return(ret);
}
}
else
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey != NULL && pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (pkey != NULL && pkey->type == EVP_PKEY_EC)
{
- BIO_printf(bp, "%12sECDSA Public Key: \n","");
- ECDSA_print(bp, pkey->pkey.ecdsa, 16);
+ BIO_printf(bp, "%12sEC Public Key: \n","");
+ EC_KEY_print(bp, pkey->pkey.eckey, 16);
}
else
#endif
}
else
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (pkey->type == EVP_PKEY_EC)
{
- BIO_printf(out, " ECDSA Public Key:\n");
- ECDSA_print(out, pkey->pkey.ecdsa,2);
+ BIO_printf(out, " EC Public Key:\n");
+ EC_KEY_print(out, pkey->pkey.eckey,2);
}
else
#endif
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
-#ifndef OPENSSL_NO_ECDSA
-#include <openssl/ecdsa.h>
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
#endif
#include <openssl/objects.h>
#include <openssl/x509.h>
}
else
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (pkey->type == EVP_PKEY_EC)
{
- BIO_printf(bp, "%12sECDSA Public Key:\n","");
- ECDSA_print(bp, pkey->pkey.ecdsa, 16);
+ BIO_printf(bp, "%12sEC Public Key:\n","");
+ EC_KEY_print(bp, pkey->pkey.eckey, 16);
}
else
#endif
OPENSSL_free(p);
}
#endif
-#ifndef OPENSSL_NO_ECDSA
- else if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ else if (pkey->type == EVP_PKEY_EC)
{
int nid=0;
unsigned char *pp;
- ECDSA *ecdsa;
+ EC_KEY *eckey;
- ecdsa = pkey->pkey.ecdsa;
+ eckey = pkey->pkey.eckey;
ASN1_TYPE_free(a->parameter);
if ((a->parameter = ASN1_TYPE_new()) == NULL)
goto err;
}
- if (EC_GROUP_get_asn1_flag(ecdsa->group)
- && (nid = EC_GROUP_get_nid(ecdsa->group)))
+ if (EC_GROUP_get_asn1_flag(eckey->group)
+ && (nid = EC_GROUP_get_nid(eckey->group)))
{
/* just set the OID */
a->parameter->type = V_ASN1_OBJECT;
}
else /* explicit parameters */
{
- if ((i = i2d_ECDSAParameters(ecdsa, NULL)) == 0)
+ if ((i = i2d_ECParameters(eckey, NULL)) == 0)
{
- X509err(X509_F_X509_PUBKEY_SET, ERR_R_ECDSA_LIB);
+ X509err(X509_F_X509_PUBKEY_SET, ERR_R_EC_LIB);
goto err;
}
if ((p = (unsigned char *) OPENSSL_malloc(i)) == NULL)
goto err;
}
pp = p;
- if (!i2d_ECDSAParameters(ecdsa, &pp))
+ if (!i2d_ECParameters(eckey, &pp))
{
- X509err(X509_F_X509_PUBKEY_SET, ERR_R_ECDSA_LIB);
+ X509err(X509_F_X509_PUBKEY_SET, ERR_R_EC_LIB);
OPENSSL_free(p);
goto err;
}
ret->save_parameters=1;
}
#endif
-#ifndef OPENSSL_NO_ECDSA
- else if (ret->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ else if (ret->type == EVP_PKEY_EC)
{
if (a->parameter && (a->parameter->type == V_ASN1_SEQUENCE))
{
/* type == V_ASN1_SEQUENCE => we have explicit parameters
* (e.g. parameters in the X9_62_EC_PARAMETERS-structure )
*/
- if ((ret->pkey.ecdsa= ECDSA_new()) == NULL)
+ if ((ret->pkey.eckey= EC_KEY_new()) == NULL)
{
- X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE);
+ X509err(X509_F_X509_PUBKEY_GET,
+ ERR_R_MALLOC_FAILURE);
goto err;
}
cp = p = a->parameter->value.sequence->data;
j = a->parameter->value.sequence->length;
- if (!d2i_ECDSAParameters(&ret->pkey.ecdsa, &cp, (long)j))
+ if (!d2i_ECParameters(&ret->pkey.eckey, &cp, (long)j))
{
- X509err(X509_F_X509_PUBKEY_GET, ERR_R_ECDSA_LIB);
+ X509err(X509_F_X509_PUBKEY_GET, ERR_R_EC_LIB);
goto err;
}
}
/* type == V_ASN1_OBJECT => the parameters are given
* by an asn1 OID
*/
- ECDSA *ecdsa;
- if (ret->pkey.ecdsa == NULL)
- ret->pkey.ecdsa = ECDSA_new();
- ecdsa = ret->pkey.ecdsa;
- if (ecdsa->group)
- EC_GROUP_free(ecdsa->group);
- if ((ecdsa->group = EC_GROUP_new_by_name(
+ EC_KEY *eckey;
+ if (ret->pkey.eckey == NULL)
+ ret->pkey.eckey = EC_KEY_new();
+ eckey = ret->pkey.eckey;
+ if (eckey->group)
+ EC_GROUP_free(eckey->group);
+ if ((eckey->group = EC_GROUP_new_by_nid(
OBJ_obj2nid(a->parameter->value.object))) == NULL)
goto err;
- EC_GROUP_set_asn1_flag(ecdsa->group,
+ EC_GROUP_set_asn1_flag(eckey->group,
OPENSSL_EC_NAMED_CURVE);
}
/* the case implicitlyCA is currently not implemented */
}
#endif
-#ifndef OPENSSL_NO_ECDSA
-ECDSA *d2i_ECDSA_PUBKEY(ECDSA **a, unsigned char **pp, long length)
+#ifndef OPENSSL_NO_EC
+EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, unsigned char **pp, long length)
{
EVP_PKEY *pkey;
- ECDSA *key;
+ EC_KEY *key;
unsigned char *q;
q = *pp;
pkey = d2i_PUBKEY(NULL, &q, length);
if (!pkey) return(NULL);
- key = EVP_PKEY_get1_ECDSA(pkey);
+ key = EVP_PKEY_get1_EC_KEY(pkey);
EVP_PKEY_free(pkey);
if (!key) return(NULL);
*pp = q;
if (a)
{
- ECDSA_free(*a);
+ EC_KEY_free(*a);
*a = key;
}
return(key);
}
-int i2d_ECDSA_PUBKEY(ECDSA *a, unsigned char **pp)
+int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp)
{
EVP_PKEY *pktmp;
int ret;
if (!a) return(0);
if ((pktmp = EVP_PKEY_new()) == NULL)
{
- ASN1err(ASN1_F_I2D_ECDSA_PUBKEY, ERR_R_MALLOC_FAILURE);
+ ASN1err(ASN1_F_I2D_EC_PUBKEY, ERR_R_MALLOC_FAILURE);
return(0);
}
- EVP_PKEY_set1_ECDSA(pktmp, a);
+ EVP_PKEY_set1_EC_KEY(pktmp, a);
ret = i2d_PUBKEY(pktmp, pp);
EVP_PKEY_free(pktmp);
return(ret);
APPS=
LIB=$(TOP)/libcrypto.a
-LIBSRC= ec_lib.c ecp_smpl.c ecp_mont.c ecp_recp.c ecp_nist.c ec_cvt.c ec_mult.c \
- ec_err.c ec_curve.c ec_check.c ec_print.c ec_asn1.c \
+LIBSRC= ec_lib.c ecp_smpl.c ecp_mont.c ecp_recp.c ecp_nist.c ec_cvt.c ec_mult.c\
+ ec_err.c ec_curve.c ec_check.c ec_print.c ec_asn1.c ec_key.c\
ec2_smpl.c ec2_smpt.c ec2_mult.c
-LIBOBJ= ec_lib.o ecp_smpl.o ecp_mont.o ecp_recp.o ecp_nist.o ec_cvt.o ec_mult.o \
- ec_err.o ec_curve.o ec_check.o ec_print.o ec_asn1.o \
+LIBOBJ= ec_lib.o ecp_smpl.o ecp_mont.o ecp_recp.o ecp_nist.o ec_cvt.o ec_mult.o\
+ ec_err.o ec_curve.o ec_check.o ec_print.o ec_asn1.o ec_key.o\
ec2_smpl.o ec2_mult.o
SRC= $(LIBSRC)
ec_err.o: ../../include/openssl/ossl_typ.h ../../include/openssl/safestack.h
ec_err.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
ec_err.o: ec_err.c
+ec_key.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
+ec_key.o: ../../include/openssl/bn.h ../../include/openssl/crypto.h
+ec_key.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
+ec_key.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
+ec_key.o: ../../include/openssl/obj_mac.h ../../include/openssl/opensslconf.h
+ec_key.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
+ec_key.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
+ec_key.o: ../../include/openssl/symhacks.h ec_key.c ec_lcl.h
ec_lib.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
ec_lib.o: ../../include/openssl/bn.h ../../include/openssl/crypto.h
ec_lib.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
/* ASN1 stuff */
#define OPENSSL_EC_NAMED_CURVE 0x001
-typedef struct ec_parameters_st ECPARAMETERS;
typedef struct ecpk_parameters_st ECPKPARAMETERS;
-DECLARE_ASN1_ITEM(ECPARAMETERS)
-DECLARE_ASN1_ITEM(ECPKPARAMETERS)
-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPARAMETERS, ECPARAMETERS)
-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPKPARAMETERS, ECPKPARAMETERS)
-
-EC_GROUP *EC_ASN1_pkparameters2group(const ECPKPARAMETERS *);
-ECPKPARAMETERS *EC_ASN1_group2pkparameters(const EC_GROUP *, ECPKPARAMETERS *);
-
-
-EC_GROUP *d2i_ECParameters(EC_GROUP **, const unsigned char **in, long len);
-int i2d_ECParameters(const EC_GROUP *, unsigned char **out);
-
EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off);
#endif
-/* SEC1 ECPrivateKey */
-typedef struct ec_privatekey_st {
- int version;
- ASN1_OCTET_STRING *privateKey;
- ECPKPARAMETERS *parameters;
- ASN1_BIT_STRING *publicKey;
- } EC_PRIVATEKEY;
+/* the EC_KEY stuff */
+typedef struct ec_key_st EC_KEY;
+
+typedef struct ec_key_meth_data_st {
+ int (*init)(EC_KEY *);
+ void (*finish)(EC_KEY *);
+ } EC_KEY_METH_DATA;
+
+struct ec_key_st {
+ int version;
+
+ EC_GROUP *group;
+
+ EC_POINT *pub_key;
+ BIGNUM *priv_key;
+
+ unsigned int enc_flag;
+ point_conversion_form_t conv_form;
+
+ int references;
-DECLARE_ASN1_ITEM(EC_PRIVATEKEY)
-DECLARE_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
-DECLARE_ASN1_ENCODE_FUNCTIONS_const(EC_PRIVATEKEY, EC_PRIVATEKEY)
+ EC_KEY_METH_DATA *meth_data;
+ }/* EC_KEY */;
+/* some values for the encoding_flag */
+#define EC_PKEY_NO_PARAMETERS 0x001
+#define EC_PKEY_NO_PUBKEY 0x002
+
+EC_KEY *EC_KEY_new(void);
+void EC_KEY_free(EC_KEY *);
+EC_KEY *EC_KEY_copy(EC_KEY *, const EC_KEY *);
+EC_KEY *EC_KEY_dup(const EC_KEY *);
+
+/* EC_KEY_generate_key() creates a ec private (public) key */
+int EC_KEY_generate_key(EC_KEY *);
+/* EC_KEY_check_key() */
+int EC_KEY_check_key(const EC_KEY *);
+
+/* de- and encode functions for the SEC1 ECPrivateKey */
+EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len);
+int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out);
+/* de- and encode functions for the elliptic curve parameters */
+EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len);
+int i2d_ECParameters(EC_KEY *a, unsigned char **out);
+
+EC_KEY *ECPublicKey_set_octet_string(EC_KEY **a, const unsigned char **in,
+ long len);
+int ECPublicKey_get_octet_string(EC_KEY *a, unsigned char **out);
+
+#ifndef OPENSSL_NO_BIO
+int ECParameters_print(BIO *bp, const EC_KEY *x);
+int EC_KEY_print(BIO *bp, const EC_KEY *x, int off);
+#endif
+#ifndef OPENSSL_NO_FP_API
+int ECParameters_print_fp(FILE *fp, const EC_KEY *x);
+int EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off);
+#endif
+#define ECParameters_dup(x) (EC_KEY *)ASN1_dup((int (*)())i2d_ECParameters,\
+ (char *(*)())d2i_ECParameters,(char *)(x))
/* BEGIN ERROR CODES */
/* The following lines are auto generated by the script mkerr.pl. Any changes
/* Function codes. */
#define EC_F_COMPUTE_WNAF 143
-#define EC_F_D2I_ECDSAPARAMETERS 154
#define EC_F_D2I_ECPARAMETERS 155
#define EC_F_D2I_ECPKPARAMETERS 161
+#define EC_F_D2I_ECPRIVATEKEY 168
+#define EC_F_ECPARAMETERS_PRINT 173
+#define EC_F_ECPARAMETERS_PRINT_FP 174
#define EC_F_ECPKPARAMETERS_PRINT 166
#define EC_F_ECPKPARAMETERS_PRINT_FP 167
+#define EC_F_ECPUBLICKEY_GET_OCTET 170
+#define EC_F_ECPUBLICKEY_SET_OCTET 171
#define EC_F_EC_ASN1_GROUP2CURVE 159
#define EC_F_EC_ASN1_GROUP2FIELDID 156
#define EC_F_EC_ASN1_GROUP2PARAMETERS 160
#define EC_F_EC_GFP_SIMPLE_OCT2POINT 103
#define EC_F_EC_GFP_SIMPLE_POINT2OCT 104
#define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137
-#define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 105
-#define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 128
-#define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 129
+#define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 105
+#define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 128
+#define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 129
#define EC_F_EC_GROUP_CHECK 150
#define EC_F_EC_GROUP_CHECK_DISCRIMINANT 153
#define EC_F_EC_GROUP_COPY 106
#define EC_F_EC_GROUP_SET_CURVE_GFP 109
#define EC_F_EC_GROUP_SET_EXTRA_DATA 110
#define EC_F_EC_GROUP_SET_GENERATOR 111
+#define EC_F_EC_KEY_CHECK_KEY 184
+#define EC_F_EC_KEY_COPY 186
+#define EC_F_EC_KEY_GENERATE_KEY 185
+#define EC_F_EC_KEY_PRINT 175
+#define EC_F_EC_KEY_PRINT_FP 176
+#define EC_F_EC_NEW 172
#define EC_F_EC_POINTS_MAKE_AFFINE 136
#define EC_F_EC_POINTS_MUL 138
#define EC_F_EC_POINT_ADD 112
#define EC_F_I2D_ECDSAPARAMETERS 158
#define EC_F_I2D_ECPARAMETERS 164
#define EC_F_I2D_ECPKPARAMETERS 165
+#define EC_F_I2D_ECPRIVATEKEY 169
/* Reason codes. */
#define EC_R_ASN1_ERROR 130
#define EC_R_INVALID_FIELD 103
#define EC_R_INVALID_FORM 104
#define EC_R_INVALID_GROUP_ORDER 119
+#define EC_R_INVALID_PRIVATE_KEY 139
#define EC_R_MISSING_PARAMETERS 127
+#define EC_R_MISSING_PRIVATE_KEY 138
#define EC_R_NOT_IMPLEMENTED 136
#define EC_R_NOT_INITIALIZED 111
#define EC_R_NO_SUCH_EXTRA_DATA 105
#define EC_R_UNKNOWN_NID 117
#define EC_R_UNKNOWN_ORDER 114
#define EC_R_UNKNOWN_PARAMETERS_TYPE 129
+#define EC_R_WRONG_ORDER 140
#ifdef __cplusplus
}
ASN1_BIT_STRING *seed;
} X9_62_CURVE;
-struct ec_parameters_st {
+typedef struct ec_parameters_st {
ASN1_INTEGER *version;
X9_62_FIELDID *fieldID;
X9_62_CURVE *curve;
ASN1_OCTET_STRING *base;
ASN1_INTEGER *order;
ASN1_INTEGER *cofactor;
- }/* ECPARAMETERS */;
+ } ECPARAMETERS;
struct ecpk_parameters_st {
int type;
} value;
}/* ECPKPARAMETERS */;
+/* SEC1 ECPrivateKey */
+typedef struct ec_privatekey_st {
+ int version;
+ ASN1_OCTET_STRING *privateKey;
+ ECPKPARAMETERS *parameters;
+ ASN1_BIT_STRING *publicKey;
+ } EC_PRIVATEKEY;
+
/* the OpenSSL asn1 definitions */
ASN1_SEQUENCE(X9_62_FIELDID) = {
} ASN1_SEQUENCE_END(ECPARAMETERS)
DECLARE_ASN1_FUNCTIONS_const(ECPARAMETERS)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPARAMETERS, ECPARAMETERS)
IMPLEMENT_ASN1_FUNCTIONS_const(ECPARAMETERS)
ASN1_CHOICE(ECPKPARAMETERS) = {
} ASN1_CHOICE_END(ECPKPARAMETERS)
DECLARE_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPKPARAMETERS, ECPKPARAMETERS)
IMPLEMENT_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
ASN1_SEQUENCE(EC_PRIVATEKEY) = {
ASN1_SIMPLE(EC_PRIVATEKEY, version, LONG),
ASN1_SIMPLE(EC_PRIVATEKEY, privateKey, ASN1_OCTET_STRING),
- ASN1_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS),
- ASN1_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING)
+ ASN1_EXP_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS, 0),
+ ASN1_EXP_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING, 1)
} ASN1_SEQUENCE_END(EC_PRIVATEKEY)
+DECLARE_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(EC_PRIVATEKEY, EC_PRIVATEKEY)
IMPLEMENT_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
/* some internal functions */
static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *);
static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *,
ECPARAMETERS *);
+EC_GROUP *EC_ASN1_pkparameters2group(const ECPKPARAMETERS *);
+ECPKPARAMETERS *EC_ASN1_group2pkparameters(const EC_GROUP *, ECPKPARAMETERS *);
static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group,
X9_62_FIELDID *field)
return ret;
}
-/* EC_GROUP <-> DER encoding of EC[PK]PARAMETERS */
-
-EC_GROUP *d2i_ECParameters(EC_GROUP **a, const unsigned char **in, long len)
- {
- EC_GROUP *group = NULL;
- ECPARAMETERS *params = NULL;
-
- if ((params = d2i_ECPARAMETERS(NULL, in, len)) == NULL)
- {
- ECerr(EC_F_D2I_ECPARAMETERS, EC_R_D2I_ECPARAMETERS_FAILURE);
- ECPARAMETERS_free(params);
- return NULL;
- }
-
- if ((group = ec_asn1_parameters2group(params)) == NULL)
- {
- ECerr(EC_F_D2I_ECPARAMETERS, EC_R_PARAMETERS2GROUP_FAILURE);
- return NULL;
- }
-
- if (a && *a)
- EC_GROUP_clear_free(*a);
- if (a)
- *a = group;
-
- ECPARAMETERS_free(params);
- return(group);
- }
+/* EC_GROUP <-> DER encoding of ECPKPARAMETERS */
EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
{
return(group);
}
-int i2d_ECParameters(const EC_GROUP *a, unsigned char **out)
+int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
{
int ret=0;
- ECPARAMETERS *tmp = ec_asn1_group2parameters(a, NULL);
+ ECPKPARAMETERS *tmp = EC_ASN1_group2pkparameters(a, NULL);
if (tmp == NULL)
{
- ECerr(EC_F_I2D_ECPARAMETERS, EC_R_GROUP2PARAMETERS_FAILURE);
+ ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
return 0;
}
- if ((ret = i2d_ECPARAMETERS(tmp, out)) == 0)
+ if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0)
{
- ECerr(EC_F_I2D_ECPARAMETERS, EC_R_I2D_EC_PARAMETERS_FAILURE);
- ECPARAMETERS_free(tmp);
+ ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
+ ECPKPARAMETERS_free(tmp);
return 0;
}
- ECPARAMETERS_free(tmp);
+ ECPKPARAMETERS_free(tmp);
return(ret);
}
-int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
+/* some EC_KEY functions */
+
+EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
{
- int ret=0;
- ECPKPARAMETERS *tmp = EC_ASN1_group2pkparameters(a, NULL);
- if (tmp == NULL)
+ int ok=0;
+ EC_KEY *ret=NULL;
+ EC_PRIVATEKEY *priv_key=NULL;
+
+ if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
{
- ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
+ ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
+ return NULL;
+ }
+
+ if ((priv_key = d2i_EC_PRIVATEKEY(&priv_key, in, len)) == NULL)
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+ EC_PRIVATEKEY_free(priv_key);
+ return NULL;
+ }
+
+ if (a == NULL || *a == NULL)
+ {
+ if ((ret = EC_KEY_new()) == NULL)
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY,
+ ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ if (a)
+ *a = ret;
+ }
+ else
+ ret = *a;
+
+ if (priv_key->parameters)
+ {
+ if (ret->group)
+ EC_GROUP_clear_free(ret->group);
+ ret->group = EC_ASN1_pkparameters2group(priv_key->parameters);
+ }
+
+ if (ret->group == NULL)
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+
+ ret->version = priv_key->version;
+
+ if (priv_key->privateKey)
+ {
+ ret->priv_key = BN_bin2bn(
+ M_ASN1_STRING_data(priv_key->privateKey),
+ M_ASN1_STRING_length(priv_key->privateKey),
+ ret->priv_key);
+ if (ret->priv_key == NULL)
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY,
+ ERR_R_BN_LIB);
+ goto err;
+ }
+ }
+ else
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY,
+ EC_R_MISSING_PRIVATE_KEY);
+ goto err;
+ }
+
+ if (priv_key->publicKey)
+ {
+ if (ret->pub_key)
+ EC_POINT_clear_free(ret->pub_key);
+ ret->pub_key = EC_POINT_new(ret->group);
+ if (ret->pub_key == NULL)
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+ if (!EC_POINT_oct2point(ret->group, ret->pub_key,
+ M_ASN1_STRING_data(priv_key->publicKey),
+ M_ASN1_STRING_length(priv_key->publicKey), NULL))
+ {
+ ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+
+ ok = 1;
+err:
+ if (!ok)
+ {
+ if (ret)
+ EC_KEY_free(ret);
+ ret = NULL;
+ }
+
+ if (priv_key)
+ EC_PRIVATEKEY_free(priv_key);
+
+ return(ret);
+ }
+
+int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
+ {
+ int ret=0, ok=0;
+ unsigned char *buffer=NULL;
+ size_t buf_len=0, tmp_len;
+ EC_PRIVATEKEY *priv_key=NULL;
+
+ if (a == NULL || a->group == NULL || a->priv_key == NULL)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY,
+ ERR_R_PASSED_NULL_PARAMETER);
+ goto err;
+ }
+
+ if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY,
+ ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+
+ priv_key->version = a->version;
+
+ buf_len = (size_t)BN_num_bytes(a->priv_key);
+ buffer = OPENSSL_malloc(buf_len);
+ if (buffer == NULL)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY,
+ ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+
+ if (!BN_bn2bin(a->priv_key, buffer))
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_BN_LIB);
+ goto err;
+ }
+
+ if (!M_ASN1_OCTET_STRING_set(priv_key->privateKey, buffer, buf_len))
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
+ goto err;
+ }
+
+ if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS))
+ {
+ if ((priv_key->parameters = EC_ASN1_group2pkparameters(
+ a->group, priv_key->parameters)) == NULL)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+
+ if (!(a->enc_flag & EC_PKEY_NO_PUBKEY))
+ {
+ priv_key->publicKey = M_ASN1_BIT_STRING_new();
+ if (priv_key->publicKey == NULL)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY,
+ ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+
+ tmp_len = EC_POINT_point2oct(a->group, a->pub_key,
+ 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;
+ }
+
+ buf_len = tmp_len;
+
+ if (!EC_POINT_point2oct(a->group, a->pub_key,
+ a->conv_form, buffer, buf_len, NULL))
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+
+ if (!M_ASN1_BIT_STRING_set(priv_key->publicKey, buffer,
+ buf_len))
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ }
+
+ if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0)
+ {
+ ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+ goto err;
+ }
+ ok=1;
+err:
+ if (buffer)
+ OPENSSL_free(buffer);
+ if (priv_key)
+ EC_PRIVATEKEY_free(priv_key);
+ return(ok?ret:0);
+ }
+
+int i2d_ECParameters(EC_KEY *a, unsigned char **out)
+ {
+ if (a == NULL)
+ {
+ ECerr(EC_F_I2D_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0)
+ return i2d_ECPKParameters(a->group, 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)
{
- ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
- ECPKPARAMETERS_free(tmp);
+ ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
+ 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)
+ {
+ ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_MALLOC_FAILURE);
+ return NULL;
+ }
+ if (a)
+ *a = ret;
+ }
+ else
+ ret = *a;
+
+ if (ret->group)
+ EC_GROUP_clear_free(ret->group);
+
+ ret->group = group;
+
+ return ret;
+ }
+
+EC_KEY *ECPublicKey_set_octet_string(EC_KEY **a, const unsigned char **in,
+ long len)
+ {
+ EC_KEY *ret=NULL;
+
+ if (a == NULL || (*a) == NULL || (*a)->group == NULL)
+ {
+ /* sorry, but a EC_GROUP-structur is necessary
+ * to set the public key */
+ ECerr(EC_F_ECPUBLICKEY_SET_OCTET, ERR_R_PASSED_NULL_PARAMETER);
return 0;
- }
- ECPKPARAMETERS_free(tmp);
- return(ret);
+ }
+ 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);
+ return 0;
+ }
+ if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL))
+ {
+ ECerr(EC_F_ECPUBLICKEY_SET_OCTET, ERR_R_EC_LIB);
+ return 0;
+ }
+ /* save the point conversion form */
+ ret->conv_form = (point_conversion_form_t)(*in[0] & ~0x01);
+ return ret;
+ }
+
+int ECPublicKey_get_octet_string(EC_KEY *a, unsigned char **out)
+ {
+ size_t buf_len=0;
+
+ if (a == NULL)
+ {
+ ECerr(EC_F_ECPUBLICKEY_GET_OCTET, ERR_R_PASSED_NULL_PARAMETER);
+ return 0;
+ }
+
+ buf_len = EC_POINT_point2oct(a->group, a->pub_key,
+ a->conv_form, NULL, 0, NULL);
+
+ if (out == NULL || buf_len == 0)
+ /* out == NULL => just return the length of the octet string */
+ return buf_len;
+
+ if (*out == NULL)
+ if ((*out = OPENSSL_malloc(buf_len)) == NULL)
+ {
+ ECerr(EC_F_ECPUBLICKEY_GET_OCTET,
+ ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+ 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);
+ OPENSSL_free(*out);
+ *out = NULL;
+ return 0;
+ }
+ return buf_len;
}
static ERR_STRING_DATA EC_str_functs[]=
{
{ERR_PACK(0,EC_F_COMPUTE_WNAF,0), "COMPUTE_WNAF"},
-{ERR_PACK(0,EC_F_D2I_ECDSAPARAMETERS,0), "d2i_ECDSAParameters"},
{ERR_PACK(0,EC_F_D2I_ECPARAMETERS,0), "d2i_ECParameters"},
{ERR_PACK(0,EC_F_D2I_ECPKPARAMETERS,0), "d2i_ECPKParameters"},
+{ERR_PACK(0,EC_F_D2I_ECPRIVATEKEY,0), "d2i_ECPrivateKey"},
+{ERR_PACK(0,EC_F_ECPARAMETERS_PRINT,0), "ECParameters_print"},
+{ERR_PACK(0,EC_F_ECPARAMETERS_PRINT_FP,0), "ECParameters_print_fp"},
{ERR_PACK(0,EC_F_ECPKPARAMETERS_PRINT,0), "ECPKParameters_print"},
{ERR_PACK(0,EC_F_ECPKPARAMETERS_PRINT_FP,0), "ECPKParameters_print_fp"},
+{ERR_PACK(0,EC_F_ECPUBLICKEY_GET_OCTET,0), "ECPUBLICKEY_GET_OCTET"},
+{ERR_PACK(0,EC_F_ECPUBLICKEY_SET_OCTET,0), "ECPUBLICKEY_SET_OCTET"},
{ERR_PACK(0,EC_F_EC_ASN1_GROUP2CURVE,0), "EC_ASN1_GROUP2CURVE"},
{ERR_PACK(0,EC_F_EC_ASN1_GROUP2FIELDID,0), "EC_ASN1_GROUP2FIELDID"},
{ERR_PACK(0,EC_F_EC_ASN1_GROUP2PARAMETERS,0), "EC_ASN1_GROUP2PARAMETERS"},
-{ERR_PACK(0,EC_F_EC_ASN1_GROUP2PKPARAMETERS,0), "EC_ASN1_group2pkparameters"},
+{ERR_PACK(0,EC_F_EC_ASN1_GROUP2PKPARAMETERS,0), "EC_ASN1_GROUP2PKPARAMETERS"},
{ERR_PACK(0,EC_F_EC_ASN1_PARAMETERS2GROUP,0), "EC_ASN1_PARAMETERS2GROUP"},
-{ERR_PACK(0,EC_F_EC_ASN1_PKPARAMETERS2GROUP,0), "EC_ASN1_pkparameters2group"},
+{ERR_PACK(0,EC_F_EC_ASN1_PKPARAMETERS2GROUP,0), "EC_ASN1_PKPARAMETERS2GROUP"},
{ERR_PACK(0,EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT,0), "ec_GF2m_simple_group_check_discriminant"},
{ERR_PACK(0,EC_F_EC_GF2M_SIMPLE_OCT2POINT,0), "ec_GF2m_simple_oct2point"},
{ERR_PACK(0,EC_F_EC_GF2M_SIMPLE_POINT2OCT,0), "ec_GF2m_simple_point2oct"},
{ERR_PACK(0,EC_F_EC_GROUP_SET_CURVE_GFP,0), "EC_GROUP_set_curve_GFp"},
{ERR_PACK(0,EC_F_EC_GROUP_SET_EXTRA_DATA,0), "EC_GROUP_set_extra_data"},
{ERR_PACK(0,EC_F_EC_GROUP_SET_GENERATOR,0), "EC_GROUP_set_generator"},
+{ERR_PACK(0,EC_F_EC_KEY_CHECK_KEY,0), "EC_KEY_check_key"},
+{ERR_PACK(0,EC_F_EC_KEY_COPY,0), "EC_KEY_copy"},
+{ERR_PACK(0,EC_F_EC_KEY_GENERATE_KEY,0), "EC_KEY_generate_key"},
+{ERR_PACK(0,EC_F_EC_KEY_PRINT,0), "EC_KEY_print"},
+{ERR_PACK(0,EC_F_EC_KEY_PRINT_FP,0), "EC_KEY_print_fp"},
+{ERR_PACK(0,EC_F_EC_NEW,0), "EC_NEW"},
{ERR_PACK(0,EC_F_EC_POINTS_MAKE_AFFINE,0), "EC_POINTs_make_affine"},
{ERR_PACK(0,EC_F_EC_POINTS_MUL,0), "EC_POINTs_mul"},
{ERR_PACK(0,EC_F_EC_POINT_ADD,0), "EC_POINT_add"},
{ERR_PACK(0,EC_F_EC_POINT_CMP,0), "EC_POINT_cmp"},
{ERR_PACK(0,EC_F_EC_POINT_COPY,0), "EC_POINT_copy"},
{ERR_PACK(0,EC_F_EC_POINT_DBL,0), "EC_POINT_dbl"},
+{ERR_PACK(0,EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,0), "EC_POINT_get_affine_coordinates_GF2m"},
{ERR_PACK(0,EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,0), "EC_POINT_get_affine_coordinates_GFp"},
{ERR_PACK(0,EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,0), "EC_POINT_get_Jprojective_coordinates_GFp"},
{ERR_PACK(0,EC_F_EC_POINT_IS_AT_INFINITY,0), "EC_POINT_is_at_infinity"},
{ERR_PACK(0,EC_F_EC_WNAF_MUL,0), "ec_wNAF_mul"},
{ERR_PACK(0,EC_F_EC_WNAF_PRECOMPUTE_MULT,0), "ec_wNAF_precompute_mult"},
{ERR_PACK(0,EC_F_GFP_MONT_GROUP_SET_CURVE,0), "GFP_MONT_GROUP_SET_CURVE"},
-{ERR_PACK(0,EC_F_I2D_ECDSAPARAMETERS,0), "i2d_ECDSAParameters"},
+{ERR_PACK(0,EC_F_I2D_ECDSAPARAMETERS,0), "I2D_ECDSAPARAMETERS"},
{ERR_PACK(0,EC_F_I2D_ECPARAMETERS,0), "i2d_ECParameters"},
{ERR_PACK(0,EC_F_I2D_ECPKPARAMETERS,0), "i2d_ECPKParameters"},
+{ERR_PACK(0,EC_F_I2D_ECPRIVATEKEY,0), "i2d_ECPrivateKey"},
{0,NULL}
};
{EC_R_INVALID_FIELD ,"invalid field"},
{EC_R_INVALID_FORM ,"invalid form"},
{EC_R_INVALID_GROUP_ORDER ,"invalid group order"},
+{EC_R_INVALID_PRIVATE_KEY ,"invalid private key"},
{EC_R_MISSING_PARAMETERS ,"missing parameters"},
+{EC_R_MISSING_PRIVATE_KEY ,"missing private key"},
{EC_R_NOT_IMPLEMENTED ,"not implemented"},
{EC_R_NOT_INITIALIZED ,"not initialized"},
{EC_R_NO_SUCH_EXTRA_DATA ,"no such extra data"},
{EC_R_UNKNOWN_NID ,"unknown nid"},
{EC_R_UNKNOWN_ORDER ,"unknown order"},
{EC_R_UNKNOWN_PARAMETERS_TYPE ,"unknown parameters type"},
+{EC_R_WRONG_ORDER ,"wrong order"},
{0,NULL}
};
--- /dev/null
+/* crypto/ec/ec_key.c */
+/*
+ * Written by Nils Larsch for the OpenSSL project.
+ */
+/* ====================================================================
+ * Copyright (c) 1998-2002 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
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#include "ec_lcl.h"
+#include <openssl/err.h>
+
+EC_KEY *EC_KEY_new(void)
+ {
+ EC_KEY *ret;
+
+ ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY));
+ if (ret == NULL)
+ {
+ ECerr(EC_F_EC_NEW, ERR_R_MALLOC_FAILURE);
+ return(NULL);
+ }
+
+ ret->version = 1;
+ ret->group = NULL;
+ ret->pub_key = NULL;
+ ret->priv_key= NULL;
+ ret->enc_flag= 0;
+ ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
+ ret->references= 1;
+ ret->meth_data = NULL;
+ return(ret);
+ }
+
+
+void EC_KEY_free(EC_KEY *r)
+ {
+ int i;
+
+ if (r == NULL) return;
+
+ i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_EC);
+#ifdef REF_PRINT
+ REF_PRINT("EC_KEY",r);
+#endif
+ if (i > 0) return;
+#ifdef REF_CHECK
+ if (i < 0)
+ {
+ fprintf(stderr,"EC_KEY_free, bad reference count\n");
+ abort();
+ }
+#endif
+
+ if (r->group != NULL)
+ EC_GROUP_free(r->group);
+ if (r->pub_key != NULL)
+ EC_POINT_free(r->pub_key);
+ if (r->priv_key != NULL)
+ BN_clear_free(r->priv_key);
+
+ if (r->meth_data && r->meth_data->finish)
+ r->meth_data->finish(r);
+
+ memset((void *)r, 0x0, sizeof(EC_KEY));
+
+ OPENSSL_free(r);
+ }
+
+EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
+ {
+ if (dest == NULL || src == NULL)
+ {
+ ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
+ return NULL;
+ }
+ /* copy the parameters */
+ if (src->group)
+ {
+ const EC_METHOD *meth = EC_GROUP_method_of(src->group);
+ /* clear the old group */
+ if (dest->group)
+ EC_GROUP_free(dest->group);
+ dest->group = EC_GROUP_new(meth);
+ if (dest->group == NULL)
+ return NULL;
+ if (!EC_GROUP_copy(dest->group, src->group))
+ return NULL;
+ }
+ /* copy the public key */
+ if (src->pub_key && src->group)
+ {
+ if (dest->pub_key)
+ EC_POINT_free(dest->pub_key);
+ dest->pub_key = EC_POINT_new(src->group);
+ if (dest->pub_key == NULL)
+ return NULL;
+ if (!EC_POINT_copy(dest->pub_key, src->pub_key))
+ return NULL;
+ }
+ /* copy the private key */
+ if (src->priv_key)
+ {
+ if (dest->priv_key == NULL)
+ {
+ dest->priv_key = BN_new();
+ if (dest->priv_key == NULL)
+ return NULL;
+ }
+ if (!BN_copy(dest->priv_key, src->priv_key))
+ return NULL;
+ }
+ /* copy the rest */
+ dest->enc_flag = src->enc_flag;
+ dest->conv_form = src->conv_form;
+ dest->version = src->version;
+
+ return dest;
+ }
+
+EC_KEY *EC_KEY_dup(const EC_KEY *eckey)
+ {
+ EC_KEY *ret = NULL;
+ int ok = 1;
+
+ ret = EC_KEY_new();
+ if (ret == NULL)
+ return NULL;
+ /* copy the parameters */
+ if (eckey->group)
+ {
+ ret->group = EC_GROUP_dup(eckey->group);
+ if (ret->group == NULL)
+ ok = 0;
+ }
+ /* copy the public key */
+ if (eckey->pub_key && eckey->group)
+ {
+ ret->pub_key = EC_POINT_dup(eckey->pub_key, eckey->group);
+ if (ret->pub_key == NULL)
+ ok = 0;
+ }
+ /* copy the private key */
+ if (eckey->priv_key)
+ {
+ ret->priv_key = BN_dup(ret->priv_key);
+ if (ret->priv_key == NULL)
+ ok = 0;
+ }
+ /* copy the rest */
+ ret->enc_flag = eckey->enc_flag;
+ ret->conv_form = eckey->conv_form;
+ ret->version = eckey->version;
+
+ if (!ok)
+ {
+ EC_KEY_free(ret);
+ ret = NULL;
+ }
+
+ return ret;
+ }
+
+int EC_KEY_generate_key(EC_KEY *eckey)
+ {
+ int ok = 0;
+ BN_CTX *ctx = NULL;
+ BIGNUM *priv_key = NULL, *order = NULL;
+ EC_POINT *pub_key = NULL;
+
+ if (!eckey || !eckey->group)
+ {
+ ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
+ return 0;
+ }
+
+ if ((order = BN_new()) == NULL) goto err;
+ if ((ctx = BN_CTX_new()) == NULL) goto err;
+
+ if (eckey->priv_key == NULL)
+ {
+ priv_key = BN_new();
+ if (priv_key == NULL)
+ goto err;
+ }
+ else
+ priv_key = eckey->priv_key;
+
+ if (!EC_GROUP_get_order(eckey->group, order, ctx))
+ goto err;
+
+ do
+ if (!BN_rand_range(priv_key, order))
+ goto err;
+ while (BN_is_zero(priv_key));
+
+ if (eckey->pub_key == NULL)
+ {
+ pub_key = EC_POINT_new(eckey->group);
+ if (pub_key == NULL)
+ goto err;
+ }
+ else
+ pub_key = eckey->pub_key;
+
+ if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))
+ goto err;
+
+ eckey->priv_key = priv_key;
+ eckey->pub_key = pub_key;
+
+ ok=1;
+
+err:
+ if (order)
+ BN_free(order);
+ if (pub_key != NULL && eckey->pub_key == NULL)
+ EC_POINT_free(pub_key);
+ if (priv_key != NULL && eckey->priv_key == NULL)
+ BN_free(priv_key);
+ if (ctx != NULL)
+ BN_CTX_free(ctx);
+ return(ok);
+ }
+
+int EC_KEY_check_key(const EC_KEY *eckey)
+ {
+ int ok = 0;
+ BN_CTX *ctx = NULL;
+ BIGNUM *order = NULL;
+ EC_POINT *point = NULL;
+
+ if (!eckey || !eckey->group || !eckey->pub_key)
+ {
+ ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
+ return 0;
+ }
+
+ if ((ctx = BN_CTX_new()) == NULL)
+ goto err;
+ if ((order = BN_new()) == NULL)
+ goto err;
+ if ((point = EC_POINT_new(eckey->group)) == NULL)
+ goto err;
+
+ /* testing whether the pub_key is on the elliptic curve */
+ if (!EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx))
+ {
+ ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
+ goto err;
+ }
+ /* testing whether pub_key * order is the point at infinity */
+ if (!EC_GROUP_get_order(eckey->group, order, ctx))
+ {
+ ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
+ goto err;
+ }
+ if (!EC_POINT_copy(point, eckey->pub_key))
+ {
+ ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
+ goto err;
+ }
+ if (!EC_POINT_mul(eckey->group, point, order, NULL, NULL, ctx))
+ {
+ ECerr(EC_F_EC_KEY_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);
+ goto err;
+ }
+ /* in case the priv_key is present :
+ * check if generator * priv_key == pub_key
+ */
+ if (eckey->priv_key)
+ {
+ if (BN_cmp(eckey->priv_key, order) >= 0)
+ {
+ ECerr(EC_F_EC_KEY_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);
+ 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);
+ goto err;
+ }
+ }
+ ok = 1;
+err:
+ if (ctx != NULL)
+ BN_CTX_free(ctx);
+ if (order != NULL)
+ BN_free(order);
+ if (point != NULL)
+ EC_POINT_free(point);
+ return(ok);
+ }
APPS=
LIB=$(TOP)/libcrypto.a
-LIBSRC= ecs_lib.c ecs_gen.c ecs_asn1.c ecs_ossl.c ecs_sign.c ecs_vrf.c \
- ecs_key.c ecs_err.c
+LIBSRC= ecs_lib.c ecs_asn1.c ecs_ossl.c ecs_sign.c ecs_vrf.c ecs_err.c
-LIBOBJ= ecs_lib.o ecs_gen.o ecs_asn1.o ecs_ossl.o ecs_sign.o ecs_vrf.o \
- ecs_key.o ecs_err.o
+LIBOBJ= ecs_lib.o ecs_asn1.o ecs_ossl.o ecs_sign.o ecs_vrf.o ecs_err.o
SRC= $(LIBSRC)
ecs_err.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
ecs_err.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
ecs_err.o: ../../include/openssl/symhacks.h ecs_err.c
-ecs_gen.o: ecs_gen.c
-ecs_key.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
-ecs_key.o: ../../include/openssl/bn.h ../../include/openssl/crypto.h
-ecs_key.o: ../../include/openssl/e_os2.h ../../include/openssl/ec.h
-ecs_key.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
-ecs_key.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
-ecs_key.o: ../../include/openssl/ossl_typ.h ../../include/openssl/safestack.h
-ecs_key.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
-ecs_key.o: ecdsa.h ecs_key.c
ecs_lib.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
ecs_lib.o: ../../include/openssl/bn.h ../../include/openssl/crypto.h
ecs_lib.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
#error ECDSA is disabled.
#endif
-#ifndef OPENSSL_NO_BIO
-#include <openssl/bio.h>
-#endif
#include <openssl/bn.h>
#include <openssl/ec.h>
#include <openssl/ossl_typ.h>
extern "C" {
#endif
-typedef struct ecdsa_st ECDSA;
-
typedef struct ECDSA_SIG_st
{
BIGNUM *r;
typedef struct ecdsa_method
{
const char *name;
- ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len, ECDSA *ecdsa);
- int (*ecdsa_sign_setup)(ECDSA *ecdsa, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **r);
- int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len, ECDSA_SIG *sig, ECDSA *ecdsa);
- int (*init)(ECDSA *ecdsa);
- int (*finish)(ECDSA *ecdsa);
+ ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len,
+ EC_KEY *eckey);
+ int (*ecdsa_sign_setup)(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
+ BIGNUM **r);
+ int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len,
+ ECDSA_SIG *sig, EC_KEY *eckey);
+#if 0
+ int (*init)(EC_KEY *eckey);
+ int (*finish)(EC_KEY *eckey);
+#endif
int flags;
char *app_data;
} ECDSA_METHOD;
-struct ecdsa_st
-{
- int version;
- point_conversion_form_t conversion_form;
-
- EC_GROUP *group;
-
- EC_POINT *pub_key;
- BIGNUM *priv_key;
-
- BIGNUM *kinv; /* signing pre-calc */
- BIGNUM *r; /* signing pre-calc */
-
- unsigned int enc_flag;
-
- int references;
+typedef struct ecdsa_data_st {
+ /* EC_KEY_METH_DATA part */
+ int (*init)(EC_KEY *);
+ void (*finish)(EC_KEY *);
+ /* method specific part */
+ BIGNUM *kinv; /* signing pre-calc */
+ BIGNUM *r; /* signing pre-calc */
+ ENGINE *engine;
int flags;
- CRYPTO_EX_DATA ex_data;
const ECDSA_METHOD *meth;
- struct engine_st *engine;
-};
-
-/* some values for the encoding_flag */
-#define ECDSA_PKEY_NO_PARAMETERS 0x001
-#define ECDSA_PKEY_NO_PUBKEY 0x002
+ CRYPTO_EX_DATA ex_data;
+} ECDSA_DATA;
+/* signature functions */
ECDSA_SIG *ECDSA_SIG_new(void);
void ECDSA_SIG_free(ECDSA_SIG *a);
int i2d_ECDSA_SIG(const ECDSA_SIG *a, unsigned char **pp);
ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **v, const unsigned char **pp, long length);
-ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len, ECDSA *ecdsa);
-int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, ECDSA_SIG *sig, ECDSA* ecdsa);
-int ECDSA_generate_key(ECDSA *ecdsa);
-int ECDSA_check_key(ECDSA *ecdsa);
+/* ECDSA_DATA functions */
+ECDSA_DATA *ECDSA_DATA_new(void);
+ECDSA_DATA *ECDSA_DATA_new_method(ENGINE *);
+void ECDSA_DATA_free(ECDSA_DATA *);
+
+ECDSA_DATA *ecdsa_check(EC_KEY *);
+
+ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len, EC_KEY *);
+int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, ECDSA_SIG
+ *sig, EC_KEY* eckey);
const ECDSA_METHOD *ECDSA_OpenSSL(void);
void ECDSA_set_default_method(const ECDSA_METHOD *);
const ECDSA_METHOD *ECDSA_get_default_method(void);
-int ECDSA_set_method(ECDSA *, const ECDSA_METHOD *);
-
-ECDSA *ECDSA_new(void);
-ECDSA *ECDSA_new_method(ENGINE *engine);
-int ECDSA_size(const ECDSA *);
-int ECDSA_sign_setup(ECDSA *ecdsa, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp);
-int ECDSA_sign(int type, const unsigned char *dgst, int dgst_len, unsigned char *sig,
- unsigned int *siglen, ECDSA *ecdsa);
-int ECDSA_verify(int type, const unsigned char *dgst, int dgst_len, const unsigned char *sig,
- int sig_len, ECDSA *ecdsa);
-int ECDSA_up_ref(ECDSA *ecdsa);
-void ECDSA_free(ECDSA *a);
-int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
- CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
-int ECDSA_set_ex_data(ECDSA *d, int idx, void *arg);
-void *ECDSA_get_ex_data(ECDSA *d, int idx);
-
-#ifndef OPENSSL_NO_BIO
-int ECDSAParameters_print(BIO *bp, const ECDSA *x);
-int ECDSA_print(BIO *bp, const ECDSA *x, int off);
-#endif
-#ifndef OPENSSL_NO_FP_API
-int ECDSAParameters_print_fp(FILE *fp, const ECDSA *x);
-int ECDSA_print_fp(FILE *fp, const ECDSA *x, int off);
-#endif
-
-/* the ECDSA_{set|get}_enc_flag() specify the encoding
- * of the elliptic curve private key */
-unsigned int ECDSA_get_enc_flag(const ECDSA *);
-void ECDSA_set_enc_flag(ECDSA *, unsigned int);
-
-/* The ECDSA_{set|get}_conversion_type() functions set/get the
- * conversion form for ec-points (see ec.h) in a ECDSA-structure */
-void ECDSA_set_conversion_form(ECDSA *, const point_conversion_form_t);
-point_conversion_form_t ECDSA_get_conversion_form(const ECDSA *);
-/* The ECDSA_{set|get}_default_conversion_form() functions set/get the
- * default conversion form */
-void ECDSA_set_default_conversion_form(const point_conversion_form_t);
-point_conversion_form_t ECDSA_get_default_conversion_form(void);
-
-/* the basic de- and encode functions ( see ecs_asn1.c ) */
-ECDSA *d2i_ECDSAParameters(ECDSA **a, const unsigned char **in, long len);
-int i2d_ECDSAParameters(ECDSA *a, unsigned char **out);
+int ECDSA_set_method(EC_KEY *, const ECDSA_METHOD *);
-ECDSA *d2i_ECDSAPrivateKey(ECDSA **a, const unsigned char **in, long len);
-int i2d_ECDSAPrivateKey(ECDSA *a, unsigned char **out);
+int ECDSA_size(const EC_KEY *);
+int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
+ BIGNUM **rp);
+int ECDSA_sign(int type, const unsigned char *dgst, int dgst_len,
+ unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
+int ECDSA_verify(int type, const unsigned char *dgst, int dgst_len,
+ const unsigned char *sig, int sig_len, EC_KEY *eckey);
-/* ECDSAPublicKey_set_octet_string() sets the public key in the ECDSA-structure.
- * (*a) must be a pointer to a ECDSA-structure with (*a)->group not zero
- * (e.g. a ECDSA-structure with a valid EC_GROUP-structure) */
-ECDSA *ECDSAPublicKey_set_octet_string(ECDSA **a, const unsigned char **in, long len);
-/* ECDSAPublicKey_get_octet_string() returns the length of the octet string encoding
- * of the public key. If out != NULL then the function returns in *out
- * a pointer to the octet string */
-int ECDSAPublicKey_get_octet_string(ECDSA *a, unsigned char **out);
+int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new
+ *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
+void *ECDSA_get_ex_data(EC_KEY *d, int idx);
-#define ECDSAParameters_dup(x) (ECDSA *)ASN1_dup((int (*)())i2d_ECDSAParameters, \
- (char *(*)())d2i_ECDSAParameters,(char *)(x))
-#define d2i_ECDSAParameters_fp(fp,x) (ECDSA *)ASN1_d2i_fp((char *(*)())ECDSA_new, \
- (char *(*)())d2i_ECDSAParameters,(fp),(unsigned char **)(x))
-#define i2d_ECDSAParameters_fp(fp,x) ASN1_i2d_fp(i2d_ECDSAParameters,(fp), \
- (unsigned char *)(x))
-#define d2i_ECDSAParameters_bio(bp,x) (ECDSA *)ASN1_d2i_bio((char *(*)())ECDSA_new, \
- (char *(*)())d2i_ECDSAParameters,(bp),(unsigned char **)(x))
-#define i2d_ECDSAParameters_bio(bp,x) ASN1_i2d_bio(i2d_ECDSAParameters,(bp), \
- (unsigned char *)(x))
/* BEGIN ERROR CODES */
/* The following lines are auto generated by the script mkerr.pl. Any changes
/* Error codes for the ECDSA functions. */
/* Function codes. */
-#define ECDSA_F_D2I_ECDSAPARAMETERS 100
-#define ECDSA_F_D2I_ECDSAPRIVATEKEY 101
-#define ECDSA_F_ECDSAPARAMETERS_PRINT 102
-#define ECDSA_F_ECDSAPARAMETERS_PRINT_FP 103
-#define ECDSA_F_ECDSA_DO_SIGN 104
-#define ECDSA_F_ECDSA_DO_VERIFY 105
-#define ECDSA_F_ECDSA_GENERATE_KEY 106
-#define ECDSA_F_ECDSA_GET 107
-#define ECDSA_F_ECDSA_GET_CURVE_NID 120
-#define ECDSA_F_ECDSA_GET_ECDSA 121
-#define ECDSA_F_ECDSA_GET_EC_PARAMETERS 122
-#define ECDSA_F_ECDSA_GET_X9_62_CURVE 108
-#define ECDSA_F_ECDSA_GET_X9_62_EC_PARAMETERS 109
-#define ECDSA_F_ECDSA_GET_X9_62_FIELDID 110
-#define ECDSA_F_ECDSA_NEW 111
-#define ECDSA_F_ECDSA_PRINT 112
-#define ECDSA_F_ECDSA_PRINT_FP 113
-#define ECDSA_F_ECDSA_SET_GROUP_P 114
-#define ECDSA_F_ECDSA_SET_PRIME_GROUP 123
-#define ECDSA_F_ECDSA_SIGN_SETUP 115
-#define ECDSA_F_I2D_ECDSAPARAMETERS 116
-#define ECDSA_F_I2D_ECDSAPRIVATEKEY 117
-#define ECDSA_F_I2D_ECDSAPUBLICKEY 118
-#define ECDSA_F_SIG_CB 119
+#define ECDSA_F_ECDSA_DATA_NEW 100
+#define ECDSA_F_ECDSA_DO_SIGN 101
+#define ECDSA_F_ECDSA_DO_VERIFY 102
+#define ECDSA_F_ECDSA_SIGN_SETUP 103
/* Reason codes. */
#define ECDSA_R_BAD_SIGNATURE 100
-#define ECDSA_R_CAN_NOT_GET_GENERATOR 101
-#define ECDSA_R_D2I_ECDSAPRIVATEKEY_MISSING_PRIVATE_KEY 102
-#define ECDSA_R_D2I_ECDSA_PRIVATEKEY_FAILURE 103
-#define ECDSA_R_D2I_EC_PARAMETERS_FAILURE 133
-#define ECDSA_R_D2I_X9_62_EC_PARAMETERS_FAILURE 104
-#define ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 105
-#define ECDSA_R_ECDSAPRIVATEKEY_NEW_FAILURE 106
-#define ECDSA_R_ECDSA_F_ECDSA_NEW 107
-#define ECDSA_R_ECDSA_GET_EC_PARAMETERS_FAILURE 134
-#define ECDSA_R_ECDSA_GET_FAILURE 108
-#define ECDSA_R_ECDSA_GET_X9_62_CURVE_FAILURE 109
-#define ECDSA_R_ECDSA_GET_X9_62_EC_PARAMETERS_FAILURE 110
-#define ECDSA_R_ECDSA_GET_X9_62_FIELDID_FAILURE 111
-#define ECDSA_R_ECDSA_NEW_FAILURE 112
-#define ECDSA_R_ECDSA_R_D2I_EC_PARAMETERS_FAILURE 135
-#define ECDSA_R_ECDSA_R_D2I_X9_62_EC_PARAMETERS_FAILURE 113
-#define ECDSA_R_ECPARAMETERS2ECDSA_FAILURE 138
-#define ECDSA_R_EC_GROUP_NID2CURVE_FAILURE 136
-#define ECDSA_R_ERR_EC_LIB 114
-#define ECDSA_R_I2D_ECDSA_PRIVATEKEY 115
-#define ECDSA_R_I2D_ECDSA_PUBLICKEY 116
-#define ECDSA_R_MISSING_PARAMETERS 117
-#define ECDSA_R_MISSING_PRIVATE_KEY 139
-#define ECDSA_R_NOT_SUPPORTED 118
-#define ECDSA_R_NO_CURVE_PARAMETER_A_SPECIFIED 119
-#define ECDSA_R_NO_CURVE_PARAMETER_B_SPECIFIED 120
-#define ECDSA_R_NO_CURVE_SPECIFIED 121
-#define ECDSA_R_NO_FIELD_SPECIFIED 122
-#define ECDSA_R_PRIME_MISSING 123
-#define ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 124
-#define ECDSA_R_SIGNATURE_MALLOC_FAILED 125
-#define ECDSA_R_UNEXPECTED_ASN1_TYPE 126
-#define ECDSA_R_UNEXPECTED_PARAMETER 127
-#define ECDSA_R_UNEXPECTED_PARAMETER_LENGTH 128
-#define ECDSA_R_UNEXPECTED_VERSION_NUMER 129
-#define ECDSA_R_UNKNOWN_PARAMETERS_TYPE 137
-#define ECDSA_R_WRONG_FIELD_IDENTIFIER 130
-#define ECDSA_R_X9_62_CURVE_NEW_FAILURE 131
-#define ECDSA_R_X9_62_EC_PARAMETERS_NEW_FAILURE 132
+#define ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 101
+#define ECDSA_R_ERR_EC_LIB 102
+#define ECDSA_R_MISSING_PARAMETERS 103
+#define ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 104
+#define ECDSA_R_SIGNATURE_MALLOC_FAILED 105
#ifdef __cplusplus
}
ECDSA_SIG* signatures[ECDSA_NIST_TESTS];
unsigned char digest[ECDSA_NIST_TESTS][20];
-void clear_ecdsa(ECDSA *ecdsa)
+void clear_ecdsa(EC_KEY *ecdsa)
{
if (!ecdsa)
return;
}
}
-int set_p192_param(ECDSA *ecdsa)
+int set_p192_param(EC_KEY *ecdsa)
{
BN_CTX *ctx=NULL;
int ret=0;
return ret;
}
-int set_p239_param(ECDSA *ecdsa)
+int set_p239_param(EC_KEY *ecdsa)
{
BN_CTX *ctx=NULL;
int ret=0;
return ret;
}
-int test_sig_vrf(ECDSA *ecdsa, const unsigned char* dgst)
+int test_sig_vrf(EC_KEY *ecdsa, const unsigned char* dgst)
{
int ret=0,type=0;
unsigned char *buffer=NULL;
return(ret == 1);
}
-int test_x962_sig_vrf(ECDSA *ecdsa, const unsigned char *dgst,
+int test_x962_sig_vrf(EC_KEY *eckey, const unsigned char *dgst,
const char *k_in, const char *r_in, const char *s_in)
{
int ret=0;
BIGNUM *r=NULL,*s=NULL,*k=NULL,*x=NULL,*y=NULL,*m=NULL,*ord=NULL;
BN_CTX *ctx=NULL;
char *tmp_char=NULL;
-
- if (!ecdsa || !ecdsa->group || !ecdsa->pub_key || !ecdsa->priv_key)
+ ECDSA_DATA *ecdsa = ecdsa_check(eckey);;
+
+ if (!eckey || !eckey->group || !eckey->pub_key || !eckey->priv_key
+ || !ecdsa)
return 0;
- if ((point = EC_POINT_new(ecdsa->group)) == NULL) goto err;
- if ((r = BN_new()) == NULL || (s = BN_new()) == NULL || (k = BN_new()) == NULL ||
- (x = BN_new()) == NULL || (y = BN_new()) == NULL || (m = BN_new()) == NULL ||
- (ord = BN_new()) == NULL) goto err;
+ if ((point = EC_POINT_new(eckey->group)) == NULL) goto err;
+ if ((r = BN_new()) == NULL || (s = BN_new()) == NULL
+ || (k = BN_new()) == NULL || (x = BN_new()) == NULL ||
+ (y = BN_new()) == NULL || (m = BN_new()) == NULL ||
+ (ord = BN_new()) == NULL) goto err;
if ((ctx = BN_CTX_new()) == NULL) goto err;
if (!BN_bin2bn(dgst, 20, m)) goto err;
if (!BN_dec2bn(&k, k_in)) goto err;
- if (!EC_POINT_mul(ecdsa->group, point, k, NULL, NULL, ctx)) goto err;
- if (!EC_POINT_get_affine_coordinates_GFp(ecdsa->group, point, x, y, ctx)) goto err;
- if (!EC_GROUP_get_order(ecdsa->group, ord, ctx)) goto err;
+ if (!EC_POINT_mul(eckey->group, point, k, NULL, NULL, ctx)) goto err;
+ if (!EC_POINT_get_affine_coordinates_GFp(eckey->group, point, x, y,
+ ctx)) goto err;
+ if (!EC_GROUP_get_order(eckey->group, ord, ctx)) goto err;
if ((ecdsa->r = BN_dup(x)) == NULL) goto err;
- if ((ecdsa->kinv = BN_mod_inverse(NULL, k, ord, ctx)) == NULL) goto err;
+ if ((ecdsa->kinv = BN_mod_inverse(NULL, k, ord, ctx)) == NULL)
+ goto err;
- if ((sig = ECDSA_do_sign(dgst, 20, ecdsa)) == NULL)
+ if ((sig = ECDSA_do_sign(dgst, 20, eckey)) == NULL)
{
BIO_printf(bio_err,"ECDSA_do_sign() failed \n");
goto err;
BIO_printf(bio_err,"sig->s = %s\n",tmp_char);
goto err;
}
- ret = ECDSA_do_verify(dgst, 20, sig, ecdsa);
+ ret = ECDSA_do_verify(dgst, 20, sig, eckey);
if (ret != 1)
{
BIO_printf(bio_err,"ECDSA_do_verify : signature verification failed \n");
return(ret == 1);
}
-int ecdsa_cmp(const ECDSA *a, const ECDSA *b)
+int ecdsa_cmp(const EC_KEY *a, const EC_KEY *b)
{
int ret=1;
BN_CTX *ctx=NULL;
int main(void)
{
- ECDSA *ecdsa=NULL, *ret_ecdsa=NULL;
+ EC_KEY *ecdsa=NULL, *ret_ecdsa=NULL;
BIGNUM *d=NULL;
X509_PUBKEY *x509_pubkey=NULL;
PKCS8_PRIV_KEY_INFO *pkcs8=NULL;
RAND_seed(rnd_seed, sizeof(rnd_seed));
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
set_p192_param(ecdsa);
- ECDSA_print(bio_err, ecdsa, 0);
+ EC_KEY_print(bio_err, ecdsa, 0);
/* en- decode tests */
- /* i2d_ - d2i_ECDSAParameters() */
+ /* i2d_ - d2i_ECParameters() */
BIO_printf(bio_err, "\nTesting i2d_ - d2i_ECDSAParameters \n");
- buf_len = i2d_ECDSAParameters(ecdsa, NULL);
+ buf_len = i2d_ECParameters(ecdsa, NULL);
if (!buf_len || (buffer = OPENSSL_malloc(buf_len)) == NULL) goto err;
pp = buffer;
- if (!i2d_ECDSAParameters(ecdsa, &pp)) goto err;
+ if (!i2d_ECParameters(ecdsa, &pp)) goto err;
pp = buffer;
- if ((ret_ecdsa = d2i_ECDSAParameters(&ret_ecdsa, (const unsigned char **)&pp,
+ if ((ret_ecdsa = d2i_ECParameters(&ret_ecdsa, (const unsigned char **)&pp,
buf_len)) == NULL) goto err;
- ECDSAParameters_print(bio_err, ret_ecdsa);
+ ECParameters_print(bio_err, ret_ecdsa);
if (ecdsa_cmp(ecdsa, ret_ecdsa)) goto err;
OPENSSL_free(buffer);
buffer = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
- /* i2d_ - d2i_ECDSAPrivateKey() */
+ /* i2d_ - d2i_ECPrivateKey() */
BIO_printf(bio_err, "\nTesting i2d_ - d2i_ECDSAPrivateKey \n");
- buf_len = i2d_ECDSAPrivateKey(ecdsa, NULL);
+ buf_len = i2d_ECPrivateKey(ecdsa, NULL);
if (!buf_len || (buffer = OPENSSL_malloc(buf_len)) == NULL) goto err;
pp = buffer;
- if (!i2d_ECDSAPrivateKey(ecdsa, &pp)) goto err;
+ if (!i2d_ECPrivateKey(ecdsa, &pp)) goto err;
pp = buffer;
- if ((ret_ecdsa = d2i_ECDSAPrivateKey(&ret_ecdsa, (const unsigned char**)&pp,
+ if ((ret_ecdsa = d2i_ECPrivateKey(&ret_ecdsa, (const unsigned char**)&pp,
buf_len)) == NULL) goto err;
- ECDSA_print(bio_err, ret_ecdsa, 0);
+ EC_KEY_print(bio_err, ret_ecdsa, 0);
if (ecdsa_cmp(ecdsa, ret_ecdsa)) goto err;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
OPENSSL_free(buffer);
buffer = NULL;
BIO_printf(bio_err, "\nTesting X509_PUBKEY_{get,set} : ");
if ((pkey = EVP_PKEY_new()) == NULL) goto err;
- EVP_PKEY_assign_ECDSA(pkey, ecdsa);
+ EVP_PKEY_assign_EC_KEY(pkey, ecdsa);
if ((x509_pubkey = X509_PUBKEY_new()) == NULL) goto err;
if (!X509_PUBKEY_set(&x509_pubkey, pkey)) goto err;
if ((ret_pkey = X509_PUBKEY_get(x509_pubkey)) == NULL) goto err;
- ret_ecdsa = EVP_PKEY_get1_ECDSA(ret_pkey);
+ ret_ecdsa = EVP_PKEY_get1_EC_KEY(ret_pkey);
EVP_PKEY_free(ret_pkey);
ret_pkey = NULL;
else BIO_printf(bio_err, "TEST OK \n");
X509_PUBKEY_free(x509_pubkey);
x509_pubkey = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
/* Testing PKCS8_PRIV_KEY_INFO <-> EVP_PKEY */
BIO_printf(bio_err, "PKCS8_OK : ");
if ((pkcs8 = EVP_PKEY2PKCS8_broken(pkey, PKCS8_OK)) == NULL) goto err;
if ((ret_pkey = EVP_PKCS82PKEY(pkcs8)) == NULL) goto err;
- ret_ecdsa = EVP_PKEY_get1_ECDSA(ret_pkey);
+ ret_ecdsa = EVP_PKEY_get1_EC_KEY(ret_pkey);
if (ecdsa_cmp(ecdsa, ret_ecdsa))
{
BIO_printf(bio_err, "TEST FAILED \n");
else BIO_printf(bio_err, "TEST OK \n");
EVP_PKEY_free(ret_pkey);
ret_pkey = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
PKCS8_PRIV_KEY_INFO_free(pkcs8);
BIO_printf(bio_err, "PKCS8_NO_OCTET : ");
if ((pkcs8 = EVP_PKEY2PKCS8_broken(pkey, PKCS8_NO_OCTET)) == NULL) goto err;
if ((ret_pkey = EVP_PKCS82PKEY(pkcs8)) == NULL) goto err;
- ret_ecdsa = EVP_PKEY_get1_ECDSA(ret_pkey);
+ ret_ecdsa = EVP_PKEY_get1_EC_KEY(ret_pkey);
if (ecdsa_cmp(ecdsa, ret_ecdsa))
{
BIO_printf(bio_err, "TEST FAILED \n");
else BIO_printf(bio_err, "TEST OK \n");
EVP_PKEY_free(ret_pkey);
ret_pkey = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
PKCS8_PRIV_KEY_INFO_free(pkcs8);
BIO_printf(bio_err, "PKCS8_EMBEDDED_PARAM : ");
if ((pkcs8 = EVP_PKEY2PKCS8_broken(pkey, PKCS8_EMBEDDED_PARAM)) == NULL) goto err;
if ((ret_pkey = EVP_PKCS82PKEY(pkcs8)) == NULL) goto err;
- ret_ecdsa = EVP_PKEY_get1_ECDSA(ret_pkey);
+ ret_ecdsa = EVP_PKEY_get1_EC_KEY(ret_pkey);
if (ecdsa_cmp(ecdsa, ret_ecdsa))
{
BIO_printf(bio_err, "TEST FAILED \n");
else BIO_printf(bio_err, "TEST OK \n");
EVP_PKEY_free(ret_pkey);
ret_pkey = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
PKCS8_PRIV_KEY_INFO_free(pkcs8);
BIO_printf(bio_err, "PKCS8_NS_DB : ");
if ((pkcs8 = EVP_PKEY2PKCS8_broken(pkey, PKCS8_NS_DB)) == NULL) goto err;
if ((ret_pkey = EVP_PKCS82PKEY(pkcs8)) == NULL) goto err;
- ret_ecdsa = EVP_PKEY_get1_ECDSA(ret_pkey);
+ ret_ecdsa = EVP_PKEY_get1_EC_KEY(ret_pkey);
if (ecdsa_cmp(ecdsa, ret_ecdsa))
{
BIO_printf(bio_err, "TEST FAILED \n");
else BIO_printf(bio_err, "TEST OK \n");
EVP_PKEY_free(ret_pkey);
ret_pkey = NULL;
- ECDSA_free(ret_ecdsa);
+ EC_KEY_free(ret_ecdsa);
ret_ecdsa = NULL;
EVP_PKEY_free(pkey);
pkey = NULL;
BIO_printf(bio_err, "Performing tests based on examples H.3.1 and H.3.2 of X9.62 \n");
BIO_printf(bio_err, "PRIME_192_V1 : ");
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
if (!set_p192_param(ecdsa)) goto err;
if (!test_x962_sig_vrf(ecdsa, dgst, "6140507067065001063065065565667405560006161556565665656654",
"3342403536405981729393488334694600415596881826869351677613",
else
BIO_printf(bio_err, "OK\n");
- ECDSA_free(ecdsa);
+ EC_KEY_free(ecdsa);
ecdsa = NULL;
OPENSSL_free(dgst);
dgst = NULL;
if (!RAND_bytes(digest[i], 20)) goto err;
BIO_printf(bio_err, "\nTesting sign & verify with NIST Prime-Curve P-192 : \n");
- ECDSA_free(ecdsa);
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
- if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_192)) == NULL) goto err;
- if (!ECDSA_generate_key(ecdsa)) goto err;
+ EC_KEY_free(ecdsa);
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
+ if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_192))
+ == NULL) goto err;
+ if (!EC_KEY_generate_key(ecdsa)) goto err;
tim = clock();
for (i=0; i<ECDSA_NIST_TESTS; i++)
if ((signatures[i] = ECDSA_do_sign(digest[i], 20, ecdsa)) == NULL) goto err;
/* EC_GROUP_NIST_PRIME_224 */
BIO_printf(bio_err, "Testing sign & verify with NIST Prime-Curve P-224 : \n");
- ECDSA_free(ecdsa);
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ EC_KEY_free(ecdsa);
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_224)) == NULL) goto err;
- if (!ECDSA_generate_key(ecdsa)) goto err;
+ if (!EC_KEY_generate_key(ecdsa)) goto err;
tim = clock();
for (i=0; i<ECDSA_NIST_TESTS; i++)
if ((signatures[i] = ECDSA_do_sign(digest[i], 20, ecdsa)) == NULL) goto err;
/* EC_GROUP_NIST_PRIME_256 */
BIO_printf(bio_err, "Testing sign & verify with NIST Prime-Curve P-256 : \n");
- ECDSA_free(ecdsa);
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ EC_KEY_free(ecdsa);
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_256)) == NULL) goto err;
- if (!ECDSA_generate_key(ecdsa)) goto err;
+ if (!EC_KEY_generate_key(ecdsa)) goto err;
tim = clock();
for (i=0; i<ECDSA_NIST_TESTS; i++)
if ((signatures[i] = ECDSA_do_sign(digest[i], 20, ecdsa)) == NULL) goto err;
/* EC_GROUP_NIST_PRIME_384 */
BIO_printf(bio_err, "Testing sign & verify with NIST Prime-Curve P-384 : \n");
- ECDSA_free(ecdsa);
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ EC_KEY_free(ecdsa);
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_384)) == NULL) goto err;
- if (!ECDSA_generate_key(ecdsa)) goto err;
+ if (!EC_KEY_generate_key(ecdsa)) goto err;
tim = clock();
for (i=0; i<ECDSA_NIST_TESTS; i++)
if ((signatures[i] = ECDSA_do_sign(digest[i], 20, ecdsa)) == NULL) goto err;
/* EC_GROUP_NIST_PRIME_521 */
BIO_printf(bio_err, "Testing sign & verify with NIST Prime-Curve P-521 : \n");
- ECDSA_free(ecdsa);
- if ((ecdsa = ECDSA_new()) == NULL) goto err;
+ EC_KEY_free(ecdsa);
+ if ((ecdsa = EC_KEY_new()) == NULL) goto err;
if ((ecdsa->group = EC_GROUP_new_by_name(EC_GROUP_NIST_PRIME_521)) == NULL) goto err;
- if (!ECDSA_generate_key(ecdsa)) goto err;
+ if (!EC_KEY_generate_key(ecdsa)) goto err;
tim = clock();
for (i=0; i<ECDSA_NIST_TESTS; i++)
if ((signatures[i] = ECDSA_do_sign(digest[i], 20, ecdsa)) == NULL) goto err;
tim_d = (double)tim / CLOCKS_PER_SEC;
BIO_printf(bio_err, "%d x ECDSA_do_verify() in %.2f"UNIT" => average time for ECDSA_do_verify() %.4f"UNIT"\n"
, ECDSA_NIST_TESTS, tim_d, tim_d/ECDSA_NIST_TESTS);
- ECDSA_free(ecdsa);
+ EC_KEY_free(ecdsa);
ecdsa = NULL;
for (i=0; i<ECDSA_NIST_TESTS; i++)
{
BIO_printf(bio_err, "TEST PASSED \n");
if (!ret)
ERR_print_errors(bio_err);
- if (ecdsa) ECDSA_free(ecdsa);
+ if (ecdsa) EC_KEY_free(ecdsa);
if (d) BN_free(d);
if (dgst) OPENSSL_free(dgst);
if (md_ctx) EVP_MD_CTX_destroy(md_ctx);
DECLARE_ASN1_FUNCTIONS_const(ECDSA_SIG)
DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECDSA_SIG, ECDSA_SIG)
IMPLEMENT_ASN1_FUNCTIONS_const(ECDSA_SIG)
-
-int i2d_ECDSAParameters(ECDSA *a, unsigned char **out)
- {
- if (a == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPARAMETERS,
- ERR_R_PASSED_NULL_PARAMETER);
- return 0;
- }
- return i2d_ECPKParameters(a->group, out);
- }
-
-ECDSA *d2i_ECDSAParameters(ECDSA **a, const unsigned char **in, long len)
- {
- EC_GROUP *group;
- ECDSA *ret;
-
- if (in == NULL || *in == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPARAMETERS,
- ERR_R_PASSED_NULL_PARAMETER);
- return NULL;
- }
-
- group = d2i_ECPKParameters(NULL, in, len);
-
- if (group == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPARAMETERS,
- ERR_R_EC_LIB);
- return NULL;
- }
-
- if (a == NULL || *a == NULL)
- {
- if ((ret = ECDSA_new()) == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPARAMETERS,
- ERR_R_MALLOC_FAILURE);
- return NULL;
- }
- if (a)
- *a = ret;
- }
- else
- ret = *a;
-
- if (ret->group)
- EC_GROUP_clear_free(ret->group);
-
- ret->group = group;
-
- return ret;
- }
-
-ECDSA *d2i_ECDSAPrivateKey(ECDSA **a, const unsigned char **in, long len)
- {
- int ok=0;
- ECDSA *ret=NULL;
- EC_PRIVATEKEY *priv_key=NULL;
-
- if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_MALLOC_FAILURE);
- return NULL;
- }
-
- if ((priv_key = d2i_EC_PRIVATEKEY(&priv_key, in, len)) == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- EC_PRIVATEKEY_free(priv_key);
- return NULL;
- }
-
- if (a == NULL || *a == NULL)
- {
- if ((ret = ECDSA_new()) == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
- if (a)
- *a = ret;
- }
- else
- ret = *a;
-
- if (priv_key->parameters)
- {
- if (ret->group)
- EC_GROUP_clear_free(ret->group);
- ret->group = EC_ASN1_pkparameters2group(priv_key->parameters);
- }
-
- if (ret->group == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
-
- ret->version = priv_key->version;
-
- if (priv_key->privateKey)
- {
- ret->priv_key = BN_bin2bn(
- M_ASN1_STRING_data(priv_key->privateKey),
- M_ASN1_STRING_length(priv_key->privateKey),
- ret->priv_key);
- if (ret->priv_key == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY,
- ERR_R_BN_LIB);
- goto err;
- }
- }
- else
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY,
- ECDSA_R_MISSING_PRIVATE_KEY);
- goto err;
- }
-
- if (priv_key->publicKey)
- {
- if (ret->pub_key)
- EC_POINT_clear_free(ret->pub_key);
- ret->pub_key = EC_POINT_new(ret->group);
- if (ret->pub_key == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
- if (!EC_POINT_oct2point(ret->group, ret->pub_key,
- M_ASN1_STRING_data(priv_key->publicKey),
- M_ASN1_STRING_length(priv_key->publicKey), NULL))
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
- }
-
- ok = 1;
-err:
- if (!ok)
- {
- if (ret)
- ECDSA_free(ret);
- ret = NULL;
- }
-
- if (priv_key)
- EC_PRIVATEKEY_free(priv_key);
-
- return(ret);
- }
-
-int i2d_ECDSAPrivateKey(ECDSA *a, unsigned char **out)
- {
- int ret=0, ok=0;
- unsigned char *buffer=NULL;
- size_t buf_len=0, tmp_len;
- EC_PRIVATEKEY *priv_key=NULL;
-
- if (a == NULL || a->group == NULL || a->priv_key == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY,
- ERR_R_PASSED_NULL_PARAMETER);
- goto err;
- }
-
- if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
-
- priv_key->version = a->version;
-
- buf_len = (size_t)BN_num_bytes(a->priv_key);
- buffer = OPENSSL_malloc(buf_len);
- if (buffer == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
-
- if (!BN_bn2bin(a->priv_key, buffer))
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_BN_LIB);
- goto err;
- }
-
- if (!M_ASN1_OCTET_STRING_set(priv_key->privateKey, buffer, buf_len))
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_ASN1_LIB);
- goto err;
- }
-
- if (!(ECDSA_get_enc_flag(a) & ECDSA_PKEY_NO_PARAMETERS))
- {
- if ((priv_key->parameters = EC_ASN1_group2pkparameters(
- a->group, priv_key->parameters)) == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
- }
-
- if (!(ECDSA_get_enc_flag(a) & ECDSA_PKEY_NO_PUBKEY))
- {
- priv_key->publicKey = M_ASN1_BIT_STRING_new();
- if (priv_key->publicKey == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
-
- tmp_len = EC_POINT_point2oct(a->group, a->pub_key,
- ECDSA_get_conversion_form(a), NULL, 0, NULL);
-
- if (tmp_len > buf_len)
- buffer = OPENSSL_realloc(buffer, tmp_len);
- if (buffer == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
-
- buf_len = tmp_len;
-
- if (!EC_POINT_point2oct(a->group, a->pub_key,
- ECDSA_get_conversion_form(a), buffer, buf_len, NULL))
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
-
- if (!M_ASN1_BIT_STRING_set(priv_key->publicKey, buffer,
- buf_len))
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_ASN1_LIB);
- goto err;
- }
- }
-
- if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- goto err;
- }
- ok=1;
-err:
- if (buffer)
- OPENSSL_free(buffer);
- if (priv_key)
- EC_PRIVATEKEY_free(priv_key);
- return(ok?ret:0);
- }
-
-
-ECDSA *ECDSAPublicKey_set_octet_string(ECDSA **a, const unsigned char **in, long len)
-{
- ECDSA *ret=NULL;
-
- if (a == NULL || (*a) == NULL || (*a)->group == NULL)
- {
- /* sorry, but a EC_GROUP-structur is necessary
- * to set the public key */
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ECDSA_R_MISSING_PARAMETERS);
- return 0;
- }
- ret = *a;
- if (ret->pub_key == NULL && (ret->pub_key = EC_POINT_new(ret->group)) == NULL)
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_MALLOC_FAILURE);
- return 0;
- }
- if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL))
- {
- ECDSAerr(ECDSA_F_D2I_ECDSAPRIVATEKEY, ERR_R_EC_LIB);
- return 0;
- }
- ECDSA_set_conversion_form(ret, (point_conversion_form_t)(*in[0] & ~0x01));
- return ret;
-}
-
-int ECDSAPublicKey_get_octet_string(ECDSA *a, unsigned char **out)
-{
- size_t buf_len=0;
-
- if (a == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPUBLICKEY, ECDSA_R_MISSING_PARAMETERS);
- return 0;
- }
- buf_len = EC_POINT_point2oct(a->group, a->pub_key,
- ECDSA_get_conversion_form(a), NULL, 0, NULL);
- if (out == NULL || buf_len == 0)
- /* out == NULL => just return the length of the octet string */
- return buf_len;
- if (*out == NULL)
- if ((*out = OPENSSL_malloc(buf_len)) == NULL)
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPUBLICKEY, ERR_R_MALLOC_FAILURE);
- return 0;
- }
- if (!EC_POINT_point2oct(a->group, a->pub_key, ECDSA_get_conversion_form(a),
- *out, buf_len, NULL))
- {
- ECDSAerr(ECDSA_F_I2D_ECDSAPUBLICKEY, ERR_R_EC_LIB);
- OPENSSL_free(*out);
- *out = NULL;
- return 0;
- }
- return buf_len;
-}
#ifndef OPENSSL_NO_ERR
static ERR_STRING_DATA ECDSA_str_functs[]=
{
-{ERR_PACK(0,ECDSA_F_D2I_ECDSAPARAMETERS,0), "d2i_ECDSAParameters"},
-{ERR_PACK(0,ECDSA_F_D2I_ECDSAPRIVATEKEY,0), "d2i_ECDSAPrivateKey"},
-{ERR_PACK(0,ECDSA_F_ECDSAPARAMETERS_PRINT,0), "ECDSAParameters_print"},
-{ERR_PACK(0,ECDSA_F_ECDSAPARAMETERS_PRINT_FP,0), "ECDSAParameters_print_fp"},
+{ERR_PACK(0,ECDSA_F_ECDSA_DATA_NEW,0), "ECDSA_DATA_new"},
{ERR_PACK(0,ECDSA_F_ECDSA_DO_SIGN,0), "ECDSA_do_sign"},
{ERR_PACK(0,ECDSA_F_ECDSA_DO_VERIFY,0), "ECDSA_do_verify"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GENERATE_KEY,0), "ECDSA_generate_key"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET,0), "ECDSA_GET"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_CURVE_NID,0), "ECDSA_GET_CURVE_NID"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_ECDSA,0), "ECDSA_GET_ECDSA"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_EC_PARAMETERS,0), "ECDSA_GET_EC_PARAMETERS"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_X9_62_CURVE,0), "ECDSA_GET_X9_62_CURVE"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_X9_62_EC_PARAMETERS,0), "ECDSA_GET_X9_62_EC_PARAMETERS"},
-{ERR_PACK(0,ECDSA_F_ECDSA_GET_X9_62_FIELDID,0), "ECDSA_GET_X9_62_FIELDID"},
-{ERR_PACK(0,ECDSA_F_ECDSA_NEW,0), "ECDSA_new"},
-{ERR_PACK(0,ECDSA_F_ECDSA_PRINT,0), "ECDSA_print"},
-{ERR_PACK(0,ECDSA_F_ECDSA_PRINT_FP,0), "ECDSA_print_fp"},
-{ERR_PACK(0,ECDSA_F_ECDSA_SET_GROUP_P,0), "ECDSA_SET_GROUP_P"},
-{ERR_PACK(0,ECDSA_F_ECDSA_SET_PRIME_GROUP,0), "ECDSA_SET_PRIME_GROUP"},
{ERR_PACK(0,ECDSA_F_ECDSA_SIGN_SETUP,0), "ECDSA_sign_setup"},
-{ERR_PACK(0,ECDSA_F_I2D_ECDSAPARAMETERS,0), "i2d_ECDSAParameters"},
-{ERR_PACK(0,ECDSA_F_I2D_ECDSAPRIVATEKEY,0), "i2d_ECDSAPrivateKey"},
-{ERR_PACK(0,ECDSA_F_I2D_ECDSAPUBLICKEY,0), "I2D_ECDSAPUBLICKEY"},
-{ERR_PACK(0,ECDSA_F_SIG_CB,0), "SIG_CB"},
{0,NULL}
};
static ERR_STRING_DATA ECDSA_str_reasons[]=
{
{ECDSA_R_BAD_SIGNATURE ,"bad signature"},
-{ECDSA_R_CAN_NOT_GET_GENERATOR ,"can not get generator"},
-{ECDSA_R_D2I_ECDSAPRIVATEKEY_MISSING_PRIVATE_KEY,"d2i ecdsaprivatekey missing private key"},
-{ECDSA_R_D2I_ECDSA_PRIVATEKEY_FAILURE ,"d2i ecdsa privatekey failure"},
-{ECDSA_R_D2I_EC_PARAMETERS_FAILURE ,"d2i ec parameters failure"},
-{ECDSA_R_D2I_X9_62_EC_PARAMETERS_FAILURE ,"d2i x9 62 ec parameters failure"},
{ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE ,"data too large for key size"},
-{ECDSA_R_ECDSAPRIVATEKEY_NEW_FAILURE ,"ecdsaprivatekey new failure"},
-{ECDSA_R_ECDSA_F_ECDSA_NEW ,"ecdsa f ecdsa new"},
-{ECDSA_R_ECDSA_GET_EC_PARAMETERS_FAILURE ,"ecdsa get ec parameters failure"},
-{ECDSA_R_ECDSA_GET_FAILURE ,"ecdsa get failure"},
-{ECDSA_R_ECDSA_GET_X9_62_CURVE_FAILURE ,"ecdsa get x9 62 curve failure"},
-{ECDSA_R_ECDSA_GET_X9_62_EC_PARAMETERS_FAILURE,"ecdsa get x9 62 ec parameters failure"},
-{ECDSA_R_ECDSA_GET_X9_62_FIELDID_FAILURE ,"ecdsa get x9 62 fieldid failure"},
-{ECDSA_R_ECDSA_NEW_FAILURE ,"ecdsa new failure"},
-{ECDSA_R_ECDSA_R_D2I_EC_PARAMETERS_FAILURE,"ecdsa r d2i ec parameters failure"},
-{ECDSA_R_ECDSA_R_D2I_X9_62_EC_PARAMETERS_FAILURE,"ecdsa r d2i x9 62 ec parameters failure"},
-{ECDSA_R_ECPARAMETERS2ECDSA_FAILURE ,"ecparameters2ecdsa failure"},
-{ECDSA_R_EC_GROUP_NID2CURVE_FAILURE ,"ec group nid2curve failure"},
{ECDSA_R_ERR_EC_LIB ,"err ec lib"},
-{ECDSA_R_I2D_ECDSA_PRIVATEKEY ,"i2d ecdsa privatekey"},
-{ECDSA_R_I2D_ECDSA_PUBLICKEY ,"i2d ecdsa publickey"},
{ECDSA_R_MISSING_PARAMETERS ,"missing parameters"},
-{ECDSA_R_MISSING_PRIVATE_KEY ,"missing private key"},
-{ECDSA_R_NOT_SUPPORTED ,"not supported"},
-{ECDSA_R_NO_CURVE_PARAMETER_A_SPECIFIED ,"no curve parameter a specified"},
-{ECDSA_R_NO_CURVE_PARAMETER_B_SPECIFIED ,"no curve parameter b specified"},
-{ECDSA_R_NO_CURVE_SPECIFIED ,"no curve specified"},
-{ECDSA_R_NO_FIELD_SPECIFIED ,"no field specified"},
-{ECDSA_R_PRIME_MISSING ,"prime missing"},
{ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED ,"random number generation failed"},
{ECDSA_R_SIGNATURE_MALLOC_FAILED ,"signature malloc failed"},
-{ECDSA_R_UNEXPECTED_ASN1_TYPE ,"unexpected asn1 type"},
-{ECDSA_R_UNEXPECTED_PARAMETER ,"unexpected parameter"},
-{ECDSA_R_UNEXPECTED_PARAMETER_LENGTH ,"unexpected parameter length"},
-{ECDSA_R_UNEXPECTED_VERSION_NUMER ,"unexpected version numer"},
-{ECDSA_R_UNKNOWN_PARAMETERS_TYPE ,"unknown parameters type"},
-{ECDSA_R_WRONG_FIELD_IDENTIFIER ,"wrong field identifier"},
-{ECDSA_R_X9_62_CURVE_NEW_FAILURE ,"x9 62 curve new failure"},
-{ECDSA_R_X9_62_EC_PARAMETERS_NEW_FAILURE ,"x9 62 ec parameters new failure"},
{0,NULL}
};
+++ /dev/null
-/* crypto/ecdsa/ecs_gen.c */
-/* ====================================================================
- * Copyright (c) 1998-2002 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
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- * software must display the following acknowledgment:
- * "This product includes software developed by the OpenSSL Project
- * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- * endorse or promote products derived from this software without
- * prior written permission. For written permission, please contact
- * openssl-core@OpenSSL.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- * nor may "OpenSSL" appear in their names without prior written
- * permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- * acknowledgment:
- * "This product includes software developed by the OpenSSL Project
- * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com). This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com).
- *
- */
-/* TODO: implementation of ecdsa parameter generation
- */
-#if 0
-#include <stdio.h>
-#include <time.h>
-#include "cryptlib.h"
-#include <openssl/evp.h>
-#include <openssl/bn.h>
-#include <openssl/ecdsa.h>
-#include <openssl/rand.h>
-#include <openssl/sha.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-ECDSA *ECDSA_generate_parameters(int bits,
- unsigned char *seed_in, int seed_len,
- int *counter_ret, unsigned long *h_ret,
- void (*callback)(int, int, void *),
- void *cb_arg)
- {
- return NULL;
- }
-#ifdef __cplusplus
-}
-#endif
-#else
-static void *dummy=&dummy;
-#endif
+++ /dev/null
-/* crypto/ecdsa/ecs_key.c */
-/* ====================================================================
- * Copyright (c) 1998-2002 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
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- * software must display the following acknowledgment:
- * "This product includes software developed by the OpenSSL Project
- * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- * endorse or promote products derived from this software without
- * prior written permission. For written permission, please contact
- * openssl-core@OpenSSL.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- * nor may "OpenSSL" appear in their names without prior written
- * permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- * acknowledgment:
- * "This product includes software developed by the OpenSSL Project
- * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com). This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com).
- *
- */
-
-#include "ecdsa.h"
-#include <openssl/err.h>
-
-int ECDSA_generate_key(ECDSA *ecdsa)
-{
- int ok=0;
- BN_CTX *ctx=NULL;
- BIGNUM *priv_key=NULL,*order=NULL;
- EC_POINT *pub_key=NULL;
-
- if (!ecdsa || !ecdsa->group)
- {
- ECDSAerr(ECDSA_F_ECDSA_GENERATE_KEY,ECDSA_R_MISSING_PARAMETERS);
- return 0;
- }
-
- if ((order = BN_new()) == NULL) goto err;
- if ((ctx = BN_CTX_new()) == NULL) goto err;
-
- if (ecdsa->priv_key == NULL)
- {
- if ((priv_key = BN_new()) == NULL) goto err;
- }
- else
- priv_key = ecdsa->priv_key;
-
- if (!EC_GROUP_get_order(ecdsa->group, order, ctx)) goto err;
- do
- if (!BN_rand_range(priv_key, order)) goto err;
- while (BN_is_zero(priv_key));
-
- if (ecdsa->pub_key == NULL)
- {
- if ((pub_key = EC_POINT_new(ecdsa->group)) == NULL) goto err;
- }
- else
- pub_key = ecdsa->pub_key;
-
- if (!EC_POINT_mul(ecdsa->group, pub_key, priv_key, NULL, NULL, ctx)) goto err;
-
- ecdsa->priv_key = priv_key;
- ecdsa->pub_key = pub_key;
- ok=1;
-err: if (order) BN_free(order);
- if ((pub_key != NULL) && (ecdsa->pub_key == NULL)) EC_POINT_free(pub_key);
- if ((priv_key != NULL) && (ecdsa->priv_key == NULL)) BN_free(priv_key);
- if (ctx != NULL) BN_CTX_free(ctx);
- return(ok);
-}
-
-int ECDSA_check_key(ECDSA *ecdsa)
-{
- int ok=0;
- BN_CTX *ctx=NULL;
- BIGNUM *order=NULL;
- EC_POINT *point=NULL;
-
- if (!ecdsa || !ecdsa->group || !ecdsa->pub_key)
- return 0;
-
- if ((ctx = BN_CTX_new()) == NULL) goto err;
- if ((order = BN_new()) == NULL) goto err;
- if ((point = EC_POINT_new(ecdsa->group)) == NULL) goto err;
-
- /* testing whether pub_key is a valid point on the elliptic curve */
- if (!EC_POINT_is_on_curve(ecdsa->group,ecdsa->pub_key,ctx)) goto err;
- /* testing whether pub_key * order is the point at infinity */
- if (!EC_GROUP_get_order(ecdsa->group,order,ctx)) goto err;
- if (!EC_POINT_copy(point,ecdsa->pub_key)) goto err;
- if (!EC_POINT_mul(ecdsa->group,point,order,NULL,NULL,ctx)) goto err;
- if (!EC_POINT_is_at_infinity(ecdsa->group,point)) goto err;
- /* in case the priv_key is present : check if generator * priv_key == pub_key */
- if (ecdsa->priv_key)
- {
- if (BN_cmp(ecdsa->priv_key,order) >= 0) goto err;
- if (!EC_POINT_mul(ecdsa->group,point,ecdsa->priv_key,NULL,NULL,ctx)) goto err;
- if (EC_POINT_cmp(ecdsa->group,point,ecdsa->pub_key,ctx) != 0) goto err;
- }
- ok = 1;
-err:
- if (ctx != NULL) BN_CTX_free(ctx);
- if (order != NULL) BN_free(order);
- if (point != NULL) EC_POINT_free(point);
- return(ok);
-}
const char *ECDSA_version="ECDSA" OPENSSL_VERSION_PTEXT;
+static void ecdsa_finish(EC_KEY *);
+
static const ECDSA_METHOD *default_ECDSA_method = NULL;
void ECDSA_set_default_method(const ECDSA_METHOD *meth)
return default_ECDSA_method;
}
-ECDSA *ECDSA_new(void)
-{
- return ECDSA_new_method(NULL);
-}
-
-int ECDSA_set_method(ECDSA *ecdsa, const ECDSA_METHOD *meth)
+int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth)
{
const ECDSA_METHOD *mtmp;
+ ECDSA_DATA *ecdsa;
+
+ ecdsa = ecdsa_check(eckey);
+
+ if (ecdsa == NULL)
+ return 0;
+
mtmp = ecdsa->meth;
- if (mtmp->finish) mtmp->finish(ecdsa);
+#if 0
+ if (mtmp->finish)
+ mtmp->finish(eckey);
+#endif
if (ecdsa->engine)
{
ENGINE_finish(ecdsa->engine);
ecdsa->engine = NULL;
}
ecdsa->meth = meth;
- if (meth->init) meth->init(ecdsa);
+#if 0
+ if (meth->init)
+ meth->init(eckey);
+#endif
return 1;
}
-ECDSA *ECDSA_new_method(ENGINE *engine)
+ECDSA_DATA *ECDSA_DATA_new(void)
+{
+ return ECDSA_DATA_new_method(NULL);
+}
+
+ECDSA_DATA *ECDSA_DATA_new_method(ENGINE *engine)
{
- ECDSA *ret;
+ ECDSA_DATA *ret;
- ret=(ECDSA *)OPENSSL_malloc(sizeof(ECDSA));
+ ret=(ECDSA_DATA *)OPENSSL_malloc(sizeof(ECDSA_DATA));
if (ret == NULL)
{
- ECDSAerr(ECDSA_F_ECDSA_NEW,ERR_R_MALLOC_FAILURE);
+ ECDSAerr(ECDSA_F_ECDSA_DATA_NEW, ERR_R_MALLOC_FAILURE);
return(NULL);
}
+ ret->init = NULL;
+ ret->finish = ecdsa_finish;
+
+ ret->kinv = NULL;
+ ret->r = NULL;
+
ret->meth = ECDSA_get_default_method();
ret->engine = engine;
if (!ret->engine)
ret->meth = ENGINE_get_ECDSA(ret->engine);
if (!ret->meth)
{
- ECDSAerr(ECDSA_R_ECDSA_F_ECDSA_NEW, ERR_R_ENGINE_LIB);
+ ECDSAerr(ECDSA_F_ECDSA_DATA_NEW, ERR_R_ENGINE_LIB);
ENGINE_finish(ret->engine);
OPENSSL_free(ret);
return NULL;
}
}
- ret->version = 1;
- ret->conversion_form = ECDSA_get_default_conversion_form();
- ret->group = NULL;
-
- ret->pub_key = NULL;
- ret->priv_key = NULL;
-
- ret->kinv = NULL;
- ret->r = NULL;
-
- ret->enc_flag = 0;
-
- ret->references = 1;
ret->flags = ret->meth->flags;
CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ECDSA, ret, &ret->ex_data);
+#if 0
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_ECDSA, ret, &ret->ex_data);
OPENSSL_free(ret);
ret=NULL;
}
-
+#endif
return(ret);
}
-void ECDSA_free(ECDSA *r)
+void ECDSA_DATA_free(ECDSA_DATA *r)
{
- int i;
-
- if (r == NULL) return;
-
- i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_ECDSA);
-#ifdef REF_PRINT
- REF_PRINT("ECDSA",r);
-#endif
- if (i > 0) return;
-#ifdef REF_CHECK
- if (i < 0)
- {
- fprintf(stderr,"ECDSA_free, bad reference count\n");
- abort();
- }
-#endif
+ if (r->kinv)
+ BN_clear_free(r->kinv);
+ if (r->r)
+ BN_clear_free(r->r);
+#if 0
if (r->meth->finish)
r->meth->finish(r);
+#endif
if (r->engine)
ENGINE_finish(r->engine);
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_ECDSA, r, &r->ex_data);
- if (r->group != NULL) EC_GROUP_free(r->group);
- if (r->pub_key != NULL) EC_POINT_free(r->pub_key);
- if (r->priv_key != NULL) BN_clear_free(r->priv_key);
- if (r->kinv != NULL) BN_clear_free(r->kinv);
- if (r->r != NULL) BN_clear_free(r->r);
+ memset((void *)r, 0x0, sizeof(ECDSA_DATA));
+
OPENSSL_free(r);
}
-int ECDSA_size(const ECDSA *r)
+ECDSA_DATA *ecdsa_check(EC_KEY *key)
+{
+ if (key->meth_data)
+ {
+ if (key->meth_data->finish != ecdsa_finish)
+ {
+ key->meth_data->finish(key);
+ key->meth_data = (EC_KEY_METH_DATA *)ECDSA_DATA_new();
+ }
+ }
+ else
+ key->meth_data = (EC_KEY_METH_DATA *)ECDSA_DATA_new();
+ return (ECDSA_DATA *)key->meth_data;
+}
+
+static void ecdsa_finish(EC_KEY *key)
+{
+ if (key->meth_data && key->meth_data->finish == ecdsa_finish)
+ ECDSA_DATA_free((ECDSA_DATA *)key->meth_data);
+}
+
+int ECDSA_size(const EC_KEY *r)
{
int ret,i;
ASN1_INTEGER bs;
return(ret);
}
+
int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
{
new_func, dup_func, free_func);
}
-int ECDSA_set_ex_data(ECDSA *d, int idx, void *arg)
+int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg)
{
- return(CRYPTO_set_ex_data(&d->ex_data,idx,arg));
-}
-
-void *ECDSA_get_ex_data(ECDSA *d, int idx)
-{
- return(CRYPTO_get_ex_data(&d->ex_data,idx));
-}
-
-int ECDSA_up_ref(ECDSA *ecdsa)
-{
- int i = CRYPTO_add(&ecdsa->references, 1, CRYPTO_LOCK_ECDSA);
-#ifdef REF_PRINT
- REF_PRINT("ECDSA",r);
-#endif
-#ifdef REF_CHECK
- if (i < 2)
- {
- fprintf(stderr, "ECDSA_up_ref, bad reference count\n");
- abort();
- }
-#endif
- return ((i > 1) ? 1 : 0);
-}
-
-void ECDSA_set_conversion_form(ECDSA *ecdsa, const point_conversion_form_t form)
-{
- if (ecdsa) ecdsa->conversion_form = form;
-}
-
-point_conversion_form_t ECDSA_get_conversion_form(const ECDSA *ecdsa)
-{
- return ecdsa ? ecdsa->conversion_form : 0;
-}
-
-static point_conversion_form_t default_conversion_form = POINT_CONVERSION_UNCOMPRESSED;
-
-void ECDSA_set_default_conversion_form(const point_conversion_form_t form)
-{
- default_conversion_form = form;
-}
-
-point_conversion_form_t ECDSA_get_default_conversion_form(void)
-{
- return default_conversion_form;
-}
-
-unsigned int ECDSA_get_enc_flag(const ECDSA *ecdsa)
-{
- return ecdsa->enc_flag;
+ ECDSA_DATA *ecdsa;
+ ecdsa = ecdsa_check(d);
+ if (ecdsa == NULL)
+ return 0;
+ return(CRYPTO_set_ex_data(&ecdsa->ex_data,idx,arg));
}
-void ECDSA_set_enc_flag(ECDSA *ecdsa, unsigned int flag)
+void *ECDSA_get_ex_data(EC_KEY *d, int idx)
{
- ecdsa->enc_flag = flag;
+ ECDSA_DATA *ecdsa;
+ ecdsa = ecdsa_check(d);
+ if (ecdsa == NULL)
+ return NULL;
+ return(CRYPTO_get_ex_data(&ecdsa->ex_data,idx));
}
#include "ecdsa.h"
#include <openssl/err.h>
+#include <openssl/obj_mac.h>
-/* TODO : general case */
-#define EC_POINT_get_affine_coordinates EC_POINT_get_affine_coordinates_GFp
-
-static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen, ECDSA *ecdsa);
-static int ecdsa_sign_setup(ECDSA *ecdsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp);
-static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len, ECDSA_SIG *sig,
- ECDSA *ecdsa);
+static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen,
+ EC_KEY *eckey);
+static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
+ BIGNUM **rp);
+static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
+ ECDSA_SIG *sig, EC_KEY *eckey);
static ECDSA_METHOD openssl_ecdsa_meth = {
-"OpenSSL ECDSA method",
-ecdsa_do_sign,
-ecdsa_sign_setup,
-ecdsa_do_verify,
-0,
-NULL
+ "OpenSSL ECDSA method",
+ ecdsa_do_sign,
+ ecdsa_sign_setup,
+ ecdsa_do_verify,
+#if 0
+ NULL, /* init */
+ NULL, /* finish */
+#endif
+ 0, /* flags */
+ NULL /* app_data */
};
const ECDSA_METHOD *ECDSA_OpenSSL(void)
return &openssl_ecdsa_meth;
}
-static int ecdsa_sign_setup(ECDSA *ecdsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
+static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
+ BIGNUM **rp)
{
BN_CTX *ctx = NULL;
BIGNUM k,*kinv=NULL,*r=NULL,*order=NULL,*X=NULL;
EC_POINT *tmp_point=NULL;
- int ret = 0,reason = ERR_R_BN_LIB;
- if (!ecdsa || !ecdsa->group || !ecdsa->pub_key || !ecdsa->priv_key)
+ int ret = 0;
+ if (!eckey || !eckey->group || !eckey->pub_key || !eckey->priv_key)
{
- reason = ECDSA_R_MISSING_PARAMETERS;
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (ctx_in == NULL)
{
- if ((ctx=BN_CTX_new()) == NULL) goto err;
+ if ((ctx=BN_CTX_new()) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
}
else
ctx=ctx_in;
- if ((r = BN_new()) == NULL) goto err;
- if ((order = BN_new()) == NULL) goto err;
- if ((X = BN_new()) == NULL) goto err;
- if ((tmp_point = EC_POINT_new(ecdsa->group)) == NULL)
+ if ((r = BN_new()) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
+ goto err;
+ }
+ if ((order = BN_new()) == NULL)
{
- reason = ERR_R_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
+ goto err;
+ }
+ if ((X = BN_new()) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
+ goto err;
+ }
+ if ((tmp_point = EC_POINT_new(eckey->group)) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
goto err;
}
- if (!EC_GROUP_get_order(ecdsa->group,order,ctx))
+ if (!EC_GROUP_get_order(eckey->group,order,ctx))
{
- reason = ERR_R_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
goto err;
}
do
if (!BN_rand_range(&k,order))
{
- reason = ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED;
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+ ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);
goto err;
}
while (BN_is_zero(&k));
/* compute r the x-coordinate of generator * k */
- if (!EC_POINT_mul(ecdsa->group,tmp_point,&k,NULL,NULL,ctx)
- || !EC_POINT_get_affine_coordinates(ecdsa->group,tmp_point,X,NULL,ctx))
+ if (!EC_POINT_mul(eckey->group, tmp_point, &k, NULL, NULL, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
+ goto err;
+ }
+ if (EC_METHOD_get_field_type(EC_GROUP_method_of(eckey->group))
+ == NID_X9_62_prime_field)
+ {
+ if (!EC_POINT_get_affine_coordinates_GFp(eckey->group,
+ tmp_point, X, NULL, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+ ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+ else /* NID_X9_62_characteristic_two_field */
+ {
+ if (!EC_POINT_get_affine_coordinates_GF2m(eckey->group,
+ tmp_point, X, NULL, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+ ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+ if (!BN_nnmod(r,X,order,ctx))
{
- reason = ERR_R_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
goto err;
}
- if (!BN_nnmod(r,X,order,ctx)) goto err;
}
while (BN_is_zero(r));
/* compute the inverse of k */
- if ((kinv = BN_mod_inverse(NULL,&k,order,ctx)) == NULL) goto err;
+ if ((kinv = BN_mod_inverse(NULL,&k,order,ctx)) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
+ goto err;
+ }
if (*rp == NULL)
BN_clear_free(*rp);
err:
if (!ret)
{
- ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,reason);
if (kinv != NULL) BN_clear_free(kinv);
if (r != NULL) BN_clear_free(r);
}
}
-static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dgst_len, ECDSA *ecdsa)
+static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dgst_len,
+ EC_KEY *eckey)
{
BIGNUM *kinv=NULL,*r=NULL,*s=NULL,*m=NULL,*tmp=NULL,*order=NULL;
BIGNUM xr;
BN_CTX *ctx=NULL;
- int reason=ERR_R_BN_LIB;
ECDSA_SIG *ret=NULL;
+ ECDSA_DATA *ecdsa;
+
+ ecdsa = ecdsa_check(eckey);
- if (!ecdsa || !ecdsa->group || !ecdsa->pub_key || !ecdsa->priv_key)
+ if (!eckey || !eckey->group || !eckey->pub_key || !eckey->priv_key
+ || !ecdsa)
{
- reason = ECDSA_R_MISSING_PARAMETERS;
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_PASSED_NULL_PARAMETER);
goto err;
}
BN_init(&xr);
- if ((ctx = BN_CTX_new()) == NULL) goto err;
- if ((order = BN_new()) == NULL) goto err;
- if ((tmp = BN_new()) == NULL) goto err;
- if ((m = BN_new()) == NULL) goto err;
- if ((s = BN_new()) == NULL) goto err;
+ if ((ctx = BN_CTX_new()) == NULL || (order = BN_new()) == NULL ||
+ (tmp = BN_new()) == NULL || (m = BN_new()) == NULL ||
+ (s = BN_new()) == NULL )
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
- if (!EC_GROUP_get_order(ecdsa->group,order,ctx))
+ if (!EC_GROUP_get_order(eckey->group,order,ctx))
{
- reason = ECDSA_R_ERR_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_EC_LIB);
goto err;
}
if (dgst_len > BN_num_bytes(order))
{
- reason = ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE;
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,
+ ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
goto err;
}
- if (BN_bin2bn(dgst,dgst_len,m) == NULL) goto err;
+ if (BN_bin2bn(dgst,dgst_len,m) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
+ goto err;
+ }
do
{
- if ((ecdsa->kinv == NULL) || (ecdsa->r == NULL))
+ if (ecdsa->kinv == NULL || ecdsa->r == NULL)
{
- if (!ECDSA_sign_setup(ecdsa,ctx,&kinv,&r)) goto err;
+ if (!ECDSA_sign_setup(eckey,ctx,&kinv,&r))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,
+ ERR_R_ECDSA_LIB);
+ goto err;
+ }
}
else
{
ecdsa->r = NULL;
}
- if (!BN_mod_mul(tmp,ecdsa->priv_key,r,order,ctx)) goto err;
- if (!BN_add(s,tmp,m)) goto err;
+ if (!BN_mod_mul(tmp,eckey->priv_key,r,order,ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
+ goto err;
+ }
+ if (!BN_add(s,tmp,m))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
+ goto err;
+ }
if (BN_cmp(s,order) > 0)
BN_sub(s,s,order);
- if (!BN_mod_mul(s,s,kinv,order,ctx)) goto err;
+ if (!BN_mod_mul(s,s,kinv,order,ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
+ goto err;
+ }
}
while (BN_is_zero(s));
if ((ret = ECDSA_SIG_new()) == NULL)
{
- reason = ECDSA_R_SIGNATURE_MALLOC_FAILED;
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_MALLOC_FAILURE);
goto err;
}
if (BN_copy(ret->r, r) == NULL || BN_copy(ret->s, s) == NULL)
{
ECDSA_SIG_free(ret);
ret = NULL;
- reason = ERR_R_BN_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
}
err:
- if (!ret)
- {
- ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,reason);
- }
- if (r != NULL) BN_clear_free(r);
- if (s != NULL) BN_clear_free(s);
- if (ctx != NULL) BN_CTX_free(ctx);
- if (m != NULL) BN_clear_free(m);
- if (tmp != NULL) BN_clear_free(tmp);
- if (order != NULL) BN_clear_free(order);
- if (kinv != NULL) BN_clear_free(kinv);
+ if (r)
+ BN_clear_free(r);
+ if (s)
+ BN_clear_free(s);
+ if (ctx)
+ BN_CTX_free(ctx);
+ if (m)
+ BN_clear_free(m);
+ if (tmp)
+ BN_clear_free(tmp);
+ if (order)
+ BN_clear_free(order);
+ if (kinv)
+ BN_clear_free(kinv);
return(ret);
}
-static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len, ECDSA_SIG *sig,
- ECDSA *ecdsa)
+static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
+ ECDSA_SIG *sig, EC_KEY *eckey)
{
BN_CTX *ctx;
BIGNUM *order=NULL,*u1=NULL,*u2=NULL,*m=NULL,*X=NULL;
EC_POINT *point=NULL;
- int ret = -1,reason = ERR_R_BN_LIB;
- if (!ecdsa || !ecdsa->group || !ecdsa->pub_key || !sig)
+ int ret = -1;
+ if (!eckey || !eckey->group || !eckey->pub_key || !sig)
{
- reason = ECDSA_R_MISSING_PARAMETERS;
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_MISSING_PARAMETERS);
return -1;
}
- if ((ctx = BN_CTX_new()) == NULL) goto err;
- if ((order = BN_new()) == NULL) goto err;
- if ((u1 = BN_new()) == NULL) goto err;
- if ((u2 = BN_new()) == NULL) goto err;
- if ((m = BN_new()) == NULL) goto err;
- if ((X = BN_new()) == NULL) goto err;
- if (!EC_GROUP_get_order(ecdsa->group,order,ctx)) goto err;
+ if ((ctx = BN_CTX_new()) == NULL || (order = BN_new()) == NULL ||
+ (u1 = BN_new()) == NULL || (u2 = BN_new()) == NULL ||
+ (m = BN_new()) == NULL || (X = BN_new()) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ if (!EC_GROUP_get_order(eckey->group, order, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
+ goto err;
+ }
if (BN_is_zero(sig->r) || sig->r->neg || BN_ucmp(sig->r, order) >= 0)
{
- reason = ECDSA_R_BAD_SIGNATURE;
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);
ret = 0;
goto err;
}
if (BN_is_zero(sig->s) || sig->s->neg || BN_ucmp(sig->s, order) >= 0)
{
- reason = ECDSA_R_BAD_SIGNATURE;
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);
ret = 0;
goto err;
}
/* calculate tmp1 = inv(S) mod order */
- if ((BN_mod_inverse(u2,sig->s,order,ctx)) == NULL) goto err;
+ if ((BN_mod_inverse(u2,sig->s,order,ctx)) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
+ goto err;
+ }
/* digest -> m */
- if (BN_bin2bn(dgst,dgst_len,m) == NULL) goto err;
+ if (BN_bin2bn(dgst,dgst_len,m) == NULL)
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
+ goto err;
+ }
/* u1 = m * tmp mod order */
- if (!BN_mod_mul(u1,m,u2,order,ctx)) goto err;
+ if (!BN_mod_mul(u1,m,u2,order,ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
+ goto err;
+ }
/* u2 = r * w mod q */
- if (!BN_mod_mul(u2,sig->r,u2,order,ctx)) goto err;
+ if (!BN_mod_mul(u2,sig->r,u2,order,ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
+ goto err;
+ }
- if ((point = EC_POINT_new(ecdsa->group)) == NULL)
+ if ((point = EC_POINT_new(eckey->group)) == NULL)
{
- reason = ERR_R_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);
goto err;
}
- if (!EC_POINT_mul(ecdsa->group,point,u1,ecdsa->pub_key,u2,ctx)
- || !EC_POINT_get_affine_coordinates(ecdsa->group,point,X,NULL,ctx))
+ if (!EC_POINT_mul(eckey->group, point, u1, eckey->pub_key, u2, ctx))
{
- reason = ERR_R_EC_LIB;
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);
+ goto err;
+ }
+ if (EC_METHOD_get_field_type(EC_GROUP_method_of(eckey->group))
+ == NID_X9_62_prime_field)
+ {
+ if (!EC_POINT_get_affine_coordinates_GFp(eckey->group,
+ point, X, NULL, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+ else /* NID_X9_62_characteristic_two_field */
+ {
+ if (!EC_POINT_get_affine_coordinates_GF2m(eckey->group,
+ point, X, NULL, ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
+ goto err;
+ }
+ }
+
+ if (!BN_nnmod(u1,X,order,ctx))
+ {
+ ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
goto err;
}
- if (!BN_nnmod(u1,X,order,ctx)) goto err;
/* is now in u1. If the signature is correct, it will be
* equal to R. */
ret = (BN_ucmp(u1,sig->r) == 0);
err:
- if (ret != 1) ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY,reason);
- if (ctx != NULL) BN_CTX_free(ctx);
- if (u1 != NULL) BN_clear_free(u1);
- if (u2 != NULL) BN_clear_free(u2);
- if (m != NULL) BN_clear_free(m);
- if (X != NULL) BN_clear_free(X);
- if (order != NULL) BN_clear_free(order);
- if (point != NULL) EC_POINT_free(point);
+ if (ctx)
+ BN_CTX_free(ctx);
+ if (u1)
+ BN_clear_free(u1);
+ if (u2)
+ BN_clear_free(u2);
+ if (m)
+ BN_clear_free(m);
+ if (X)
+ BN_clear_free(X);
+ if (order)
+ BN_clear_free(order);
+ if (point)
+ EC_POINT_free(point);
return(ret);
}
#include "ecdsa.h"
#include <openssl/engine.h>
-ECDSA_SIG * ECDSA_do_sign(const unsigned char *dgst, int dlen, ECDSA *ecdsa)
+ECDSA_SIG * ECDSA_do_sign(const unsigned char *dgst, int dlen, EC_KEY *eckey)
{
- return ecdsa->meth->ecdsa_do_sign(dgst, dlen, ecdsa);
+ ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+ if (ecdsa == NULL)
+ return NULL;
+ return ecdsa->meth->ecdsa_do_sign(dgst, dlen, eckey);
}
-int ECDSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
- unsigned int *siglen, ECDSA *ecdsa)
+int ECDSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char
+ *sig, unsigned int *siglen, EC_KEY *eckey)
{
ECDSA_SIG *s;
- s=ECDSA_do_sign(dgst,dlen,ecdsa);
+ s=ECDSA_do_sign(dgst,dlen,eckey);
if (s == NULL)
{
*siglen=0;
return(1);
}
-int ECDSA_sign_setup(ECDSA *ecdsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
+int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
+ BIGNUM **rp)
{
- return ecdsa->meth->ecdsa_sign_setup(ecdsa, ctx_in, kinvp, rp);
+ ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+ if (ecdsa == NULL)
+ return 0;
+ return ecdsa->meth->ecdsa_sign_setup(eckey, ctx_in, kinvp, rp);
}
* 0: incorrect signature
* -1: error
*/
-int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, ECDSA_SIG *sig, ECDSA *ecdsa)
+int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
+ ECDSA_SIG *sig, EC_KEY *eckey)
{
- return ecdsa->meth->ecdsa_do_verify(dgst, dgst_len, sig, ecdsa);
+ ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+ if (ecdsa == NULL)
+ return 0;
+ return ecdsa->meth->ecdsa_do_verify(dgst, dgst_len, sig, eckey);
}
/* returns
* 0: incorrect signature
* -1: error
*/
-int ECDSA_verify(int type, const unsigned char *dgst, int dgst_len, const unsigned char *sigbuf, int sig_len, ECDSA *ecdsa)
+int ECDSA_verify(int type, const unsigned char *dgst, int dgst_len,
+ const unsigned char *sigbuf, int sig_len, EC_KEY *eckey)
{
ECDSA_SIG *s;
int ret=-1;
s = ECDSA_SIG_new();
if (s == NULL) return(ret);
- if (d2i_ECDSA_SIG(&s,&sigbuf,sig_len) == NULL) goto err;
- ret=ECDSA_do_verify(dgst,dgst_len,s,ecdsa);
+ if (d2i_ECDSA_SIG(&s, &sigbuf, sig_len) == NULL) goto err;
+ ret=ECDSA_do_verify(dgst, dgst_len, s, eckey);
err:
ECDSA_SIG_free(s);
return(ret);
#define EVP_PKEY_DSA3 NID_dsaWithSHA1
#define EVP_PKEY_DSA4 NID_dsaWithSHA1_2
#define EVP_PKEY_DH NID_dhKeyAgreement
-#define EVP_PKEY_ECDSA NID_X9_62_id_ecPublicKey
+#define EVP_PKEY_EC NID_X9_62_id_ecPublicKey
+#define EVP_PKEY_ECDSA EVP_PKEY_EC
#ifdef __cplusplus
extern "C" {
#ifndef OPENSSL_NO_DH
struct dh_st *dh; /* DH */
#endif
-#ifndef OPENSSL_NO_ECDSA
- struct ecdsa_st *ecdsa; /* ECDSA */
+#ifndef OPENSSL_NO_EC
+ struct ec_key_st *eckey;/* ECC */
#endif
} pkey;
int save_parameters;
(char *)(dh))
#endif
-#ifndef OPENSSL_NO_ECDSA
-#define EVP_PKEY_assign_ECDSA(pkey,ecdsa) EVP_PKEY_assign((pkey),EVP_PKEY_ECDSA,\
- (char *)(ecdsa))
+#ifndef OPENSSL_NO_EC
+#define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\
+ (char *)(eckey))
#endif
/* Add some extra combinations */
int EVP_PKEY_set1_DH(EVP_PKEY *pkey,struct dh_st *key);
struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
#endif
-#ifndef OPENSSL_NO_ECDSA
-struct ecdsa_st;
-int EVP_PKEY_set1_ECDSA(EVP_PKEY *pkey,struct ecdsa_st *key);
-struct ecdsa_st *EVP_PKEY_get1_ECDSA(EVP_PKEY *pkey);
+#ifndef OPENSSL_NO_EC
+struct ec_key_st;
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey,struct ec_key_st *key);
+struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
#endif
EVP_PKEY * EVP_PKEY_new(void);
/* Function codes. */
#define EVP_F_D2I_PKEY 100
#define EVP_F_ECDSA_PKEY2PKCS8 129
+#define EVP_F_EC_KEY_PKEY2PKCS8 132
#define EVP_F_EVP_CIPHERINIT 123
#define EVP_F_EVP_CIPHER_CTX_CTRL 124
#define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122
#define EVP_F_EVP_PKEY_GET1_DH 119
#define EVP_F_EVP_PKEY_GET1_DSA 120
#define EVP_F_EVP_PKEY_GET1_ECDSA 130
+#define EVP_F_EVP_PKEY_GET1_EC_KEY 131
#define EVP_F_EVP_PKEY_GET1_RSA 121
#define EVP_F_EVP_PKEY_NEW 106
#define EVP_F_EVP_RIJNDAEL 126
#define EVP_R_EXPECTING_A_DH_KEY 128
#define EVP_R_EXPECTING_A_DSA_KEY 129
#define EVP_R_EXPECTING_A_ECDSA_KEY 141
+#define EVP_R_EXPECTING_A_EC_KEY 142
#define EVP_R_INITIALIZATION_ERROR 134
#define EVP_R_INPUT_NOT_INITIALIZED 111
#define EVP_R_INVALID_KEY_LENGTH 130
/* crypto/evp/evp_err.c */
/* ====================================================================
- * Copyright (c) 1999 The OpenSSL Project. All rights reserved.
+ * Copyright (c) 1999-2002 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
{
{ERR_PACK(0,EVP_F_D2I_PKEY,0), "D2I_PKEY"},
{ERR_PACK(0,EVP_F_ECDSA_PKEY2PKCS8,0), "ECDSA_PKEY2PKCS8"},
+{ERR_PACK(0,EVP_F_EC_KEY_PKEY2PKCS8,0), "EC_KEY_PKEY2PKCS8"},
{ERR_PACK(0,EVP_F_EVP_CIPHERINIT,0), "EVP_CipherInit"},
{ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_CTRL,0), "EVP_CIPHER_CTX_ctrl"},
{ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,0), "EVP_CIPHER_CTX_set_key_length"},
{ERR_PACK(0,EVP_F_EVP_PKEY_ENCRYPT,0), "EVP_PKEY_encrypt"},
{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_DH,0), "EVP_PKEY_get1_DH"},
{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_DSA,0), "EVP_PKEY_get1_DSA"},
-{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_ECDSA,0), "EVP_PKEY_get1_ECDSA"},
+{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_ECDSA,0), "EVP_PKEY_GET1_ECDSA"},
+{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_EC_KEY,0), "EVP_PKEY_get1_EC_KEY"},
{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_RSA,0), "EVP_PKEY_get1_RSA"},
{ERR_PACK(0,EVP_F_EVP_PKEY_NEW,0), "EVP_PKEY_new"},
{ERR_PACK(0,EVP_F_EVP_RIJNDAEL,0), "EVP_RIJNDAEL"},
{EVP_R_EXPECTING_A_DH_KEY ,"expecting a dh key"},
{EVP_R_EXPECTING_A_DSA_KEY ,"expecting a dsa key"},
{EVP_R_EXPECTING_A_ECDSA_KEY ,"expecting a ecdsa key"},
+{EVP_R_EXPECTING_A_EC_KEY ,"expecting a ec key"},
{EVP_R_INITIALIZATION_ERROR ,"initialization error"},
{EVP_R_INPUT_NOT_INITIALIZED ,"input not initialized"},
{EVP_R_INVALID_KEY_LENGTH ,"invalid key length"},
#ifndef OPENSSL_NO_DSA
static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
#endif
-#ifndef OPENSSL_NO_ECDSA
-static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
+#ifndef OPENSSL_NO_EC
+static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
#endif
/* Extract a private key from a PKCS8 structure */
#ifndef OPENSSL_NO_DSA
DSA *dsa = NULL;
#endif
-#ifndef OPENSSL_NO_ECDSA
- ECDSA *ecdsa = NULL;
+#ifndef OPENSSL_NO_EC
+ EC_KEY *eckey = NULL;
#endif
#if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
ASN1_INTEGER *privkey;
else /* nid == NID_ecdsa_with_SHA1 */
{
#ifndef OPENSSL_NO_ECDSA
- if ((ecdsa = d2i_ECDSAParameters(NULL, &cp, plen)) == NULL)
+ if ((eckey = d2i_ECParameters(NULL, &cp,
+ plen)) == NULL)
{
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
goto err;
}
- if ((ecdsa->priv_key = ASN1_INTEGER_to_BN(privkey, NULL)) == NULL)
+ if ((eckey->priv_key = ASN1_INTEGER_to_BN(privkey,
+ NULL)) == NULL)
{
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
goto err;
}
- if ((ecdsa->pub_key = EC_POINT_new(ecdsa->group)) == NULL)
+ if ((eckey->pub_key = EC_POINT_new(eckey->group)) == NULL)
{
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
goto err;
}
- if (!EC_POINT_copy(ecdsa->pub_key, EC_GROUP_get0_generator(ecdsa->group)))
+ if (!EC_POINT_copy(eckey->pub_key,
+ EC_GROUP_get0_generator(eckey->group)))
{
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
goto err;
}
- if (!EC_POINT_mul(ecdsa->group, ecdsa->pub_key, ecdsa->priv_key,
- NULL, NULL, ctx))
+ if (!EC_POINT_mul(eckey->group, eckey->pub_key,
+ eckey->priv_key, NULL, NULL, ctx))
{
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
goto err;
}
- EVP_PKEY_assign_ECDSA(pkey, ecdsa);
+ EVP_PKEY_assign_EC_KEY(pkey, eckey);
BN_CTX_free(ctx);
if (n_stack) sk_ASN1_TYPE_pop_free(n_stack, ASN1_TYPE_free);
else
#ifndef OPENSSL_NO_DSA
if (dsa) DSA_free(dsa);
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (ecdsa) ECDSA_free(ecdsa);
+#ifndef OPENSSL_NO_EC
+ if (eckey)
+ EC_KEY_free(eckey);
#endif
if (pkey) EVP_PKEY_free(pkey);
return NULL;
#endif
#ifndef OPENSSL_NO_ECDSA
case EVP_PKEY_ECDSA:
- if (!ecdsa_pkey2pkcs8(p8, pkey))
+ if (!eckey_pkey2pkcs8(p8, pkey))
{
PKCS8_PRIV_KEY_INFO_free(p8);
return(NULL);
}
#endif
-#ifndef OPENSSL_NO_ECDSA
-static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
+#ifndef OPENSSL_NO_EC
+static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
{
ASN1_STRING *params=NULL;
ASN1_INTEGER *prkey=NULL;
ASN1_TYPE *ttmp=NULL;
- STACK_OF(ASN1_TYPE) *necdsa=NULL;
+ STACK_OF(ASN1_TYPE) *neckey=NULL;
unsigned char *p=NULL, *q=NULL;
int len=0;
EC_POINT *point=NULL;
- if (pkey->pkey.ecdsa == NULL || pkey->pkey.ecdsa->group == NULL)
+ if (pkey->pkey.eckey == NULL || pkey->pkey.eckey->group == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);
return 0;
}
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_ecdsa_with_SHA1);
- len = i2d_ECDSAParameters(pkey->pkey.ecdsa, NULL);
+ len = i2d_ECParameters(pkey->pkey.eckey, NULL);
if ((p = OPENSSL_malloc(len)) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
return 0;
}
q = p;
- if (!i2d_ECDSAParameters(pkey->pkey.ecdsa, &q))
+ if (!i2d_ECParameters(pkey->pkey.eckey, &q))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ECDSA_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ECDSA_LIB);
OPENSSL_free(p);
return 0;
}
if ((params = ASN1_STRING_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
OPENSSL_free(p);
return 0;
}
if (!ASN1_STRING_set(params, p, len))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ASN1_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ASN1_LIB);
OPENSSL_free(p);
return 0;
}
OPENSSL_free(p);
- if ((prkey = BN_to_ASN1_INTEGER(pkey->pkey.ecdsa->priv_key, NULL)) == NULL)
+ if ((prkey = BN_to_ASN1_INTEGER(pkey->pkey.eckey->priv_key, NULL))
+ == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ASN1_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ASN1_LIB);
return 0;
}
if (!ASN1_pack_string((char *)prkey, i2d_ASN1_INTEGER,
&p8->pkey->value.octet_string))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
M_ASN1_INTEGER_free(prkey);
return 0;
}
p8->pkeyalg->parameter->value.sequence = params;
p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;
- necdsa = sk_ASN1_TYPE_new_null();
- if (necdsa == NULL || (ttmp = ASN1_TYPE_new()) == NULL)
+ neckey = sk_ASN1_TYPE_new_null();
+ if (neckey == NULL || (ttmp = ASN1_TYPE_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
return 0;
}
- if ((point = EC_GROUP_get0_generator(pkey->pkey.ecdsa->group)) == NULL)
+ if ((point = EC_GROUP_get0_generator(pkey->pkey.eckey->group))
+ == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_EC_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_EC_LIB);
return 0;
}
- len = EC_POINT_point2oct(pkey->pkey.ecdsa->group, point, ECDSA_get_conversion_form(pkey->pkey.ecdsa),
- NULL, 0, NULL);
+ len = EC_POINT_point2oct(pkey->pkey.eckey->group, point,
+ pkey->pkey.eckey->conv_form, NULL, 0, NULL);
p = OPENSSL_malloc(len);
- if (!len || !p || !EC_POINT_point2oct(pkey->pkey.ecdsa->group, point,
- ECDSA_get_conversion_form(pkey->pkey.ecdsa), p, len, NULL))
+ if (!len || !p || !EC_POINT_point2oct(pkey->pkey.eckey->group,
+ point, pkey->pkey.eckey->conv_form, p, len, NULL))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_EC_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_EC_LIB);
OPENSSL_free(p);
return 0;
}
- if ((ttmp->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+ if ((ttmp->value.octet_string =ASN1_OCTET_STRING_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!ASN1_OCTET_STRING_set(ttmp->value.octet_string, p, len))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, EVP_R_ASN1_LIB);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, EVP_R_ASN1_LIB);
return 0;
}
OPENSSL_free(p);
ttmp->type = V_ASN1_OCTET_STRING;
- if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+ if (!sk_ASN1_TYPE_push(neckey, ttmp))
{
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
if ((ttmp = ASN1_TYPE_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
return 0;
}
ttmp->value.integer = prkey;
ttmp->type = V_ASN1_INTEGER;
- if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+ if (!sk_ASN1_TYPE_push(neckey, ttmp))
{
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
- if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+ if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())
+ == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
return 0;
}
- if (!ASN1_seq_pack_ASN1_TYPE(necdsa, i2d_ASN1_TYPE,
+ if (!ASN1_seq_pack_ASN1_TYPE(neckey, i2d_ASN1_TYPE,
&p8->pkey->value.octet_string->data,
&p8->pkey->value.octet_string->length))
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
return 0;
}
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
break;
case PKCS8_EMBEDDED_PARAM:
p8->pkeyalg->parameter->type = V_ASN1_NULL;
- necdsa = sk_ASN1_TYPE_new_null();
+ neckey = sk_ASN1_TYPE_new_null();
if ((ttmp = ASN1_TYPE_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
ttmp->value.sequence = params;
ttmp->type = V_ASN1_SEQUENCE;
- if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+ if (!sk_ASN1_TYPE_push(neckey, ttmp))
{
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
if ((ttmp = ASN1_TYPE_new()) == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
ttmp->value.integer = prkey;
ttmp->type = V_ASN1_INTEGER;
- if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+ if (!sk_ASN1_TYPE_push(neckey, ttmp))
{
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
ASN1_INTEGER_free(prkey);
return 0;
}
- if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+ if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())
+ == NULL)
{
- EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
return 0;
}
- if (!ASN1_seq_pack_ASN1_TYPE(necdsa, i2d_ASN1_TYPE,
+ if (!ASN1_seq_pack_ASN1_TYPE(neckey, i2d_ASN1_TYPE,
&p8->pkey->value.octet_string->data,
&p8->pkey->value.octet_string->length))
{
EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
return 0;
}
- sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+ sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
break;
}
return 1;
else if (pkey->type == EVP_PKEY_DSA)
return(BN_num_bits(pkey->pkey.dsa->p));
#endif
-#ifndef OPENSSL_NO_ECDSA
- else if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ else if (pkey->type == EVP_PKEY_EC)
{
BIGNUM *order = BN_new();
int ret;
ERR_clear_error();
return 0;
}
- if (!EC_GROUP_get_order(pkey->pkey.ecdsa->group, order, NULL))
+ if (!EC_GROUP_get_order(pkey->pkey.eckey->group, order, NULL))
{
ERR_clear_error();
return 0;
if (pkey->type == EVP_PKEY_DSA)
return(DSA_size(pkey->pkey.dsa));
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey->type == EVP_PKEY_ECDSA)
- return(ECDSA_size(pkey->pkey.ecdsa));
+#ifndef OPENSSL_NO_EC
+ if (pkey->type == EVP_PKEY_EC)
+ return(ECDSA_size(pkey->pkey.eckey));
#endif
return(0);
to->pkey.dsa->g=a;
}
#endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
if (to->type == EVP_PKEY_ECDSA)
{
- if (to->pkey.ecdsa->group != NULL)
- EC_GROUP_free(to->pkey.ecdsa->group);
- if ((to->pkey.ecdsa->group = EC_GROUP_new(EC_GROUP_method_of(from->pkey.ecdsa->group))) == NULL) goto err;
- if (!EC_GROUP_copy(to->pkey.ecdsa->group,from->pkey.ecdsa->group)) goto err;
+ if (to->pkey.eckey->group != NULL)
+ EC_GROUP_free(to->pkey.eckey->group);
+ if ((to->pkey.eckey->group = EC_GROUP_new(
+ EC_GROUP_method_of(from->pkey.eckey->group))) == NULL)
+ goto err;
+ if (!EC_GROUP_copy(to->pkey.eckey->group,
+ from->pkey.eckey->group)) goto err;
}
#endif
return(1);
return(1);
}
#endif
-#ifndef OPENSSL_NO_ECDSA
- if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+ if (pkey->type == EVP_PKEY_EC)
{
- if (pkey->pkey.ecdsa->group == NULL)
+ if (pkey->pkey.eckey->group == NULL)
return(1);
}
#endif
}
#endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
-int EVP_PKEY_set1_ECDSA(EVP_PKEY *pkey, ECDSA *key)
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
{
- int ret = EVP_PKEY_assign_ECDSA(pkey,key);
- if (ret) CRYPTO_add(&key->references, 1,CRYPTO_LOCK_ECDSA);
+ int ret = EVP_PKEY_assign_EC_KEY(pkey,key);
+ if (ret) CRYPTO_add(&key->references, 1, CRYPTO_LOCK_EC);
return ret;
}
-ECDSA *EVP_PKEY_get1_ECDSA(EVP_PKEY *pkey)
+EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
{
- if (pkey->type != EVP_PKEY_ECDSA)
+ if (pkey->type != EVP_PKEY_EC)
{
- EVPerr(EVP_F_EVP_PKEY_GET1_ECDSA, EVP_R_EXPECTING_A_ECDSA_KEY);
+ EVPerr(EVP_F_EVP_PKEY_GET1_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
return NULL;
}
- CRYPTO_add(&pkey->pkey.ecdsa->references, 1, CRYPTO_LOCK_ECDSA);
- return pkey->pkey.ecdsa;
+ CRYPTO_add(&pkey->pkey.eckey->references, 1, CRYPTO_LOCK_EC);
+ return pkey->pkey.eckey;
}
#endif
return(EVP_PKEY_DSA);
case EVP_PKEY_DH:
return(EVP_PKEY_DH);
- case EVP_PKEY_ECDSA:
- return(EVP_PKEY_ECDSA);
+ case EVP_PKEY_EC:
+ return(EVP_PKEY_EC);
default:
return(NID_undef);
}
DSA_free(x->pkey.dsa);
break;
#endif
-#ifndef OPENSSL_NO_ECDSA
- case EVP_PKEY_ECDSA:
- ECDSA_free(x->pkey.ecdsa);
+#ifndef OPENSSL_NO_EC
+ case EVP_PKEY_EC:
+ EC_KEY_free(x->pkey.eckey);
break;
#endif
#ifndef OPENSSL_NO_DH
#endif
-#ifndef OPENSSL_NO_ECDSA
-DECLARE_PEM_rw_cb(ECDSAPrivateKey, ECDSA)
-DECLARE_PEM_rw(ECDSA_PUBKEY, ECDSA)
-#endif
-
#ifndef OPENSSL_NO_EC
DECLARE_PEM_rw(ECPKParameters, EC_GROUP)
+DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY)
+DECLARE_PEM_rw(EC_PUBKEY, EC_KEY)
#endif
#ifndef OPENSSL_NO_DH
static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa);
#endif
-#ifndef OPENSSL_NO_ECDSA
-static ECDSA *pkey_get_ecdsa(EVP_PKEY *key, ECDSA **ecdsa);
+#ifndef OPENSSL_NO_EC
+static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey);
#endif
IMPLEMENT_PEM_rw(X509_REQ, X509_REQ, PEM_STRING_X509_REQ, X509_REQ)
#endif
-#ifndef OPENSSL_NO_ECDSA
-static ECDSA *pkey_get_ecdsa(EVP_PKEY *key, ECDSA **ecdsa)
+#ifndef OPENSSL_NO_EC
+static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey)
{
- ECDSA *dtmp;
+ EC_KEY *dtmp;
if(!key) return NULL;
- dtmp = EVP_PKEY_get1_ECDSA(key);
+ dtmp = EVP_PKEY_get1_EC_KEY(key);
EVP_PKEY_free(key);
if(!dtmp) return NULL;
- if(ecdsa)
+ if(eckey)
{
- ECDSA_free(*ecdsa);
- *ecdsa = dtmp;
+ EC_KEY_free(*eckey);
+ *eckey = dtmp;
}
return dtmp;
}
-ECDSA *PEM_read_bio_ECDSAPrivateKey(BIO *bp, ECDSA **ecdsa, pem_password_cb *cb,
+EC_KEY *PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb,
void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
- return pkey_get_ecdsa(pktmp, ecdsa);
+ return pkey_get_eckey(pktmp, key);
}
-IMPLEMENT_PEM_write_cb(ECDSAPrivateKey, ECDSA, PEM_STRING_ECPRIVATEKEY, ECDSAPrivateKey)
-IMPLEMENT_PEM_rw(ECDSA_PUBKEY, ECDSA, PEM_STRING_PUBLIC, ECDSA_PUBKEY)
+IMPLEMENT_PEM_rw(ECPKParameters, EC_GROUP, PEM_STRING_ECPARAMETERS, ECPKParameters)
+
+IMPLEMENT_PEM_write_cb(ECPrivateKey, EC_KEY, PEM_STRING_ECPRIVATEKEY, ECPrivateKey)
+
+IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
#ifndef OPENSSL_NO_FP_API
-ECDSA *PEM_read_ECDSAPrivateKey(FILE *fp, ECDSA **ecdsa, pem_password_cb *cb,
+EC_KEY *PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb,
void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
- return pkey_get_ecdsa(pktmp, ecdsa);
+ return pkey_get_eckey(pktmp, eckey);
}
#endif
#endif
-#ifndef OPENSSL_NO_EC
-IMPLEMENT_PEM_rw(ECPKParameters, EC_GROUP, PEM_STRING_ECPARAMETERS, ECPKParameters)
-#endif
-
#ifndef OPENSSL_NO_DH
IMPLEMENT_PEM_rw(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
}
else
#endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
if (strcmp(name,PEM_STRING_ECPRIVATEKEY) == 0)
{
- d2i=(char *(*)())d2i_ECDSAPrivateKey;
+ d2i=(char *(*)())d2i_ECPrivateKey;
if (xi->x_pkey != NULL)
{
if (!sk_X509_INFO_push(ret,xi)) goto err;
xi->x_pkey=X509_PKEY_new();
if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
goto err;
- xi->x_pkey->dec_pkey->type=EVP_PKEY_ECDSA;
- pp=(char **)&(xi->x_pkey->dec_pkey->pkey.ecdsa);
+ xi->x_pkey->dec_pkey->type=EVP_PKEY_EC;
+ pp=(char **)&(xi->x_pkey->dec_pkey->pkey.eckey);
if ((int)strlen(header) > 10) /* assume encrypted */
raw=1;
}
#include <openssl/dsa.h>
#endif
+#ifndef OPENSSL_NO_EC
+#include <openssl/ec.h>
+#endif
+
#ifndef OPENSSL_NO_ECDSA
#include <openssl/ecdsa.h>
#endif
#define i2d_DSAPrivateKey_bio(bp,dsa) ASN1_i2d_bio(i2d_DSAPrivateKey,bp, \
(unsigned char *)dsa)
-#define d2i_ECDSAPrivateKey_fp(fp,ecdsa) (ECDSA *)ASN1_d2i_fp((char *(*)())\
- ECDSA_new,(char *(*)())d2i_ECDSAPrivateKey, (fp), \
+#define d2i_ECPrivateKey_fp(fp,ecdsa) (EC_KEY *)ASN1_d2i_fp((char *(*)())\
+ EC_KEY_new,(char *(*)())d2i_ECPrivateKey, (fp), \
(unsigned char **)(ecdsa))
-#define i2d_ECDSAPrivateKey_fp(fp,ecdsa) ASN1_i2d_fp(i2d_ECDSAPrivateKey,fp, \
+#define i2d_ECPrivateKey_fp(fp,ecdsa) ASN1_i2d_fp(i2d_ECPrivateKey,fp, \
(unsigned char *)ecdsa)
-#define d2i_ECDSAPrivateKey_bio(bp,ecdsa) (ECDSA *)ASN1_d2i_bio((char *(*)())\
- ECDSA_new,(char *(*)())d2i_ECDSAPrivateKey, (bp), \
+#define d2i_ECPrivateKey_bio(bp,ecdsa) (EC_KEY *)ASN1_d2i_bio((char *(*)())\
+ EC_KEY_new,(char *(*)())d2i_ECPrivateKey, (bp), \
(unsigned char **)(ecdsa))
-#define i2d_ECDSAPrivateKey_bio(bp,ecdsa) ASN1_i2d_bio(i2d_ECDSAPrivateKey,bp, \
+#define i2d_ECPrivateKey_bio(bp,ecdsa) ASN1_i2d_bio(i2d_ECPrivateKey,bp, \
(unsigned char *)ecdsa)
#define X509_ALGOR_dup(xn) (X509_ALGOR *)ASN1_dup((int (*)())i2d_X509_ALGOR,\
DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
#endif
-#ifndef OPENSSL_NO_ECDSA
-ECDSA *d2i_ECDSA_PUBKEY_fp(FILE *fp, ECDSA **ecdsa);
-int i2d_ECDSA_PUBKEY_fp(FILE *fp, ECDSA *ecdsa);
-ECDSA *d2i_ECDSAPrivateKey_fp(FILE *fp, ECDSA **ecdsa);
-int i2d_ECDSAPrivateKey_fp(FILE *fp, ECDSA *ecdsa);
+#ifndef OPENSSL_NO_EC
+EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
+int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);
+EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
+int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);
#endif
X509_SIG *d2i_PKCS8_fp(FILE *fp,X509_SIG **p8);
int i2d_PKCS8_fp(FILE *fp,X509_SIG *p8);
DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
#endif
-#ifndef OPENSSL_NO_ECDSA
-ECDSA *d2i_ECDSA_PUBKEY_bio(BIO *bp, ECDSA **ecdsa);
-int i2d_ECDSA_PUBKEY_bio(BIO *bp, ECDSA *ecdsa);
-ECDSA *d2i_ECDSAPrivateKey_bio(BIO *bp, ECDSA **ecdsa);
-int i2d_ECDSAPrivateKey_bio(BIO *bp, ECDSA *ecdsa);
+#ifndef OPENSSL_NO_EC
+EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
+int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);
+EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
+int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);
#endif
X509_SIG *d2i_PKCS8_bio(BIO *bp,X509_SIG **p8);
int i2d_PKCS8_bio(BIO *bp,X509_SIG *p8);
DSA * d2i_DSA_PUBKEY(DSA **a,unsigned char **pp,
long length);
#endif
-#ifndef OPENSSL_NO_ECDSA
-int i2d_ECDSA_PUBKEY(ECDSA *a, unsigned char **pp);
-ECDSA *d2i_ECDSA_PUBKEY(ECDSA **a, unsigned char **pp,
+#ifndef OPENSSL_NO_EC
+int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp);
+EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, unsigned char **pp,
long length);
#endif
}
break;
#endif
-#ifndef OPENSSL_NO_ECDSA
- case EVP_PKEY_ECDSA:
+#ifndef OPENSSL_NO_EC
+ case EVP_PKEY_EC:
{
- int r = EC_POINT_cmp(xk->pkey.ecdsa->group,xk->pkey.ecdsa->pub_key,k->pkey.ecdsa->pub_key,NULL);
+ int r = EC_POINT_cmp(xk->pkey.eckey->group,
+ xk->pkey.eckey->pub_key,k->pkey.eckey->pub_key,NULL);
if (r != 0)
{
if (r == 1)
#endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
#ifndef OPENSSL_NO_FP_API
-ECDSA *d2i_ECDSAPrivateKey_fp(FILE *fp, ECDSA **ecdsa)
+EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
{
- return((ECDSA *)ASN1_d2i_fp((char *(*)())
- ECDSA_new,(char *(*)())d2i_ECDSAPrivateKey, (fp),
- (unsigned char **)(ecdsa)));
+ return((EC_KEY *)ASN1_d2i_fp((char *(*)())
+ EC_KEY_new,(char *(*)())d2i_EC_PUBKEY, (fp),
+ (unsigned char **)(eckey)));
}
-int i2d_ECDSAPrivateKey_fp(FILE *fp, ECDSA *ecdsa)
+int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey)
{
- return(ASN1_i2d_fp(i2d_ECDSAPrivateKey,fp,(unsigned char *)ecdsa));
+ return(ASN1_i2d_fp(i2d_EC_PUBKEY,fp,(unsigned char *)eckey));
}
-
-ECDSA *d2i_ECDSA_PUBKEY_fp(FILE *fp, ECDSA **ecdsa)
+
+EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
{
- return((ECDSA *)ASN1_d2i_fp((char *(*)())
- ECDSA_new,(char *(*)())d2i_ECDSA_PUBKEY, (fp),
- (unsigned char **)(ecdsa)));
+ return((EC_KEY *)ASN1_d2i_fp((char *(*)())
+ EC_KEY_new,(char *(*)())d2i_ECPrivateKey, (fp),
+ (unsigned char **)(eckey)));
}
-int i2d_ECDSA_PUBKEY_fp(FILE *fp, ECDSA *ecdsa)
+int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
{
- return(ASN1_i2d_fp(i2d_ECDSA_PUBKEY,fp,(unsigned char *)ecdsa));
+ return(ASN1_i2d_fp(i2d_ECPrivateKey,fp,(unsigned char *)eckey));
}
#endif
-
-ECDSA *d2i_ECDSAPrivateKey_bio(BIO *bp, ECDSA **ecdsa)
+EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
{
- return((ECDSA *)ASN1_d2i_bio((char *(*)())
- ECDSA_new,(char *(*)())d2i_ECDSAPrivateKey, (bp),
- (unsigned char **)(ecdsa)));
+ return((EC_KEY *)ASN1_d2i_bio((char *(*)())
+ EC_KEY_new,(char *(*)())d2i_EC_PUBKEY, (bp),
+ (unsigned char **)(eckey)));
}
-int i2d_ECDSAPrivateKey_bio(BIO *bp, ECDSA *ecdsa)
+int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ecdsa)
{
- return(ASN1_i2d_bio(i2d_ECDSAPrivateKey,bp,(unsigned char *)ecdsa));
+ return(ASN1_i2d_bio(i2d_EC_PUBKEY,bp,(unsigned char *)ecdsa));
}
-
-ECDSA *d2i_ECDSA_PUBKEY_bio(BIO *bp, ECDSA **ecdsa)
+
+EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
{
- return((ECDSA *)ASN1_d2i_bio((char *(*)())
- ECDSA_new,(char *(*)())d2i_ECDSA_PUBKEY, (bp),
- (unsigned char **)(ecdsa)));
+ return((EC_KEY *)ASN1_d2i_bio((char *(*)())
+ EC_KEY_new,(char *(*)())d2i_ECPrivateKey, (bp),
+ (unsigned char **)(eckey)));
}
-int i2d_ECDSA_PUBKEY_bio(BIO *bp, ECDSA *ecdsa)
+int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
{
- return(ASN1_i2d_bio(i2d_ECDSA_PUBKEY,bp,(unsigned char *)ecdsa));
+ return(ASN1_i2d_bio(i2d_ECPrivateKey,bp,(unsigned char *)eckey));
}
-
#endif
+
int X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
unsigned int *len)
{
NCONF_default 3227 EXIST::FUNCTION:
OPENSSL_no_config 3228 EXIST::FUNCTION:
NCONF_WIN32 3229 EXIST::FUNCTION:
-ECDSA_set_conversion_form 3230 EXIST::FUNCTION:ECDSA
+ECDSA_set_conversion_form 3230 NOEXIST::FUNCTION:
EC_GROUP_new_by_name 3231 EXIST::FUNCTION:EC
-d2i_ECDSA_PUBKEY 3232 EXIST::FUNCTION:ECDSA
-PEM_read_bio_ECDSAPrivateKey 3233 EXIST::FUNCTION:ECDSA
+d2i_ECDSA_PUBKEY 3232 NOEXIST::FUNCTION:
+PEM_read_bio_ECDSAPrivateKey 3233 NOEXIST::FUNCTION:
EC_GROUP_get_asn1_flag 3234 EXIST::FUNCTION:EC
ECDSA_SIG_new 3235 EXIST::FUNCTION:ECDSA
ECDSA_verify 3236 EXIST::FUNCTION:ECDSA
EC_POINT_point2hex 3237 EXIST::FUNCTION:EC
-i2d_ECDSAParameters 3238 EXIST::FUNCTION:ECDSA
-i2d_ECDSAPrivateKey_bio 3239 EXIST::FUNCTION:BIO,ECDSA
-EC_ASN1_group2pkparameters 3240 EXIST::FUNCTION:EC
+i2d_ECDSAParameters 3238 NOEXIST::FUNCTION:
+i2d_ECDSAPrivateKey_bio 3239 NOEXIST::FUNCTION:
+EC_ASN1_group2pkparameters 3240 NOEXIST::FUNCTION:
PEM_write_bio_ECDSAParameters 3241 NOEXIST::FUNCTION:
-ECDSAParameters_print_fp 3242 EXIST::FUNCTION:ECDSA,FP_API
+ECDSAParameters_print_fp 3242 NOEXIST::FUNCTION:
EC_GROUP_check 3243 EXIST::FUNCTION:EC
ENGINE_set_default_ECDSA 3244 EXIST::FUNCTION:
-PEM_read_bio_ECDSA_PUBKEY 3245 EXIST::FUNCTION:ECDSA
-ECDSA_check_key 3246 EXIST::FUNCTION:ECDSA
-ECDSA_new_method 3247 EXIST::FUNCTION:ECDSA
-d2i_ECPARAMETERS 3248 EXIST::FUNCTION:EC
-d2i_ECDSAPrivateKey_bio 3249 EXIST::FUNCTION:BIO,ECDSA
-i2d_ECDSA_PUBKEY 3250 EXIST::FUNCTION:ECDSA
+PEM_read_bio_ECDSA_PUBKEY 3245 NOEXIST::FUNCTION:
+ECDSA_check_key 3246 NOEXIST::FUNCTION:
+ECDSA_new_method 3247 NOEXIST::FUNCTION:
+d2i_ECPARAMETERS 3248 NOEXIST::FUNCTION:
+d2i_ECDSAPrivateKey_bio 3249 NOEXIST::FUNCTION:
+i2d_ECDSA_PUBKEY 3250 NOEXIST::FUNCTION:
EC_POINT_hex2point 3251 EXIST::FUNCTION:EC
-i2d_ECDSA_PUBKEY_fp 3252 EXIST::FUNCTION:ECDSA,FP_API
+i2d_ECDSA_PUBKEY_fp 3252 NOEXIST::FUNCTION:
ENGINE_unregister_ECDSA 3253 EXIST::FUNCTION:
-ECDSA_free 3254 EXIST::FUNCTION:ECDSA
-ECDSAParameters_print 3255 EXIST::FUNCTION:BIO,ECDSA
+ECDSA_free 3254 NOEXIST::FUNCTION:
+ECDSAParameters_print 3255 NOEXIST::FUNCTION:
EC_POINT_bn2point 3256 EXIST::FUNCTION:EC
-PEM_write_bio_ECDSA_PUBKEY 3257 EXIST::FUNCTION:ECDSA
+PEM_write_bio_ECDSA_PUBKEY 3257 NOEXIST::FUNCTION:
ECDSA_set_method 3258 EXIST::FUNCTION:ECDSA
-ECDSA_print 3259 EXIST::FUNCTION:BIO,ECDSA
-i2d_ECPARAMETERS 3260 EXIST::FUNCTION:EC
-d2i_ECPKPARAMETERS 3261 EXIST::FUNCTION:EC
-EVP_PKEY_get1_ECDSA 3262 EXIST::FUNCTION:ECDSA
+ECDSA_print 3259 NOEXIST::FUNCTION:
+i2d_ECPARAMETERS 3260 NOEXIST::FUNCTION:
+d2i_ECPKPARAMETERS 3261 NOEXIST::FUNCTION:
+EVP_PKEY_get1_ECDSA 3262 NOEXIST::FUNCTION:
ECDSA_SIG_free 3263 EXIST::FUNCTION:ECDSA
ENGINE_get_default_ECDSA 3264 EXIST::FUNCTION:
-PEM_write_ECDSAPrivateKey 3265 EXIST:!WIN16:FUNCTION:ECDSA
+PEM_write_ECDSAPrivateKey 3265 NOEXIST::FUNCTION:
ECDSA_sign_setup 3266 EXIST::FUNCTION:ECDSA
ENGINE_get_ECDSA 3267 EXIST::FUNCTION:
ECDSA_get_default_method 3268 EXIST::FUNCTION:ECDSA
-d2i_ECDSA_PUBKEY_bio 3269 EXIST::FUNCTION:BIO,ECDSA
+d2i_ECDSA_PUBKEY_bio 3269 NOEXIST::FUNCTION:
ECDSA_sign 3270 EXIST::FUNCTION:ECDSA
ENGINE_register_ECDSA 3271 EXIST::FUNCTION:
-d2i_ECDSAPrivateKey_fp 3272 EXIST::FUNCTION:ECDSA,FP_API
+d2i_ECDSAPrivateKey_fp 3272 NOEXIST::FUNCTION:
EC_GROUP_set_asn1_flag 3273 EXIST::FUNCTION:EC
-ECPKPARAMETERS_it 3274 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:EC
-ECPKPARAMETERS_it 3274 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:EC
-ECDSA_print_fp 3275 EXIST::FUNCTION:ECDSA,FP_API
-i2d_ECDSAPrivateKey 3276 EXIST::FUNCTION:ECDSA
-d2i_ECDSAParameters 3277 EXIST::FUNCTION:ECDSA
-PEM_write_bio_ECDSAPrivateKey 3278 EXIST::FUNCTION:ECDSA
+ECPKPARAMETERS_it 3274 NOEXIST::FUNCTION:
+ECPKPARAMETERS_it 3274 NOEXIST::FUNCTION:
+ECDSA_print_fp 3275 NOEXIST::FUNCTION:
+i2d_ECDSAPrivateKey 3276 NOEXIST::FUNCTION:
+d2i_ECDSAParameters 3277 NOEXIST::FUNCTION:
+PEM_write_bio_ECDSAPrivateKey 3278 NOEXIST::FUNCTION:
ERR_load_ECDSA_strings 3279 EXIST::FUNCTION:ECDSA
d2i_ECParameters 3280 EXIST::FUNCTION:EC
d2i_ECDSA_SIG 3281 EXIST::FUNCTION:ECDSA
ECDSA_size 3282 EXIST::FUNCTION:ECDSA
EC_GROUP_set_nid 3283 EXIST::FUNCTION:EC
-EVP_PKEY_set1_ECDSA 3284 EXIST::FUNCTION:ECDSA
+EVP_PKEY_set1_ECDSA 3284 NOEXIST::FUNCTION:
EC_GROUP_get_nid 3285 EXIST::FUNCTION:EC
-d2i_ECDSA_PUBKEY_fp 3286 EXIST::FUNCTION:ECDSA,FP_API
+d2i_ECDSA_PUBKEY_fp 3286 NOEXIST::FUNCTION:
EC_METHOD_get_field_type 3287 EXIST::FUNCTION:EC
EC_GROUP_get_point_conversion_form 3288 EXIST:!VMS:FUNCTION:EC
EC_GROUP_get_point_conv_form 3288 EXIST:VMS:FUNCTION:EC
ECDSA_OpenSSL 3289 EXIST::FUNCTION:ECDSA
-i2d_ECPKPARAMETERS 3290 EXIST::FUNCTION:EC
+i2d_ECPKPARAMETERS 3290 NOEXIST::FUNCTION:
PEM_read_ECDSAParameters 3291 NOEXIST::FUNCTION:
ECDSA_get_ex_data 3292 EXIST::FUNCTION:ECDSA
ECDSA_do_verify 3293 EXIST::FUNCTION:ECDSA
d2i_ECPKParameters 3297 EXIST::FUNCTION:EC
i2d_ECDSA_SIG 3298 EXIST::FUNCTION:ECDSA
PEM_read_bio_ECDSAParameters 3299 NOEXIST::FUNCTION:
-ECDSAPublicKey_get_octet_string 3300 EXIST::FUNCTION:ECDSA
-ECDSA_new 3301 EXIST::FUNCTION:ECDSA
+ECDSAPublicKey_get_octet_string 3300 NOEXIST::FUNCTION:
+ECDSA_new 3301 NOEXIST::FUNCTION:
EVP_ecdsa 3302 EXIST::FUNCTION:SHA
-ECPARAMETERS_it 3303 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:EC
-ECPARAMETERS_it 3303 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:EC
+ECPARAMETERS_it 3303 NOEXIST::FUNCTION:
+ECPARAMETERS_it 3303 NOEXIST::FUNCTION:
ECDSA_set_default_method 3304 EXIST::FUNCTION:ECDSA
ENGINE_set_ECDSA 3305 EXIST::FUNCTION:
ECDSA_get_ex_new_index 3306 EXIST::FUNCTION:ECDSA
EC_GROUP_set_point_conversion_form 3307 EXIST:!VMS:FUNCTION:EC
EC_GROUP_set_point_conv_form 3307 EXIST:VMS:FUNCTION:EC
-PEM_write_ECDSA_PUBKEY 3308 EXIST:!WIN16:FUNCTION:ECDSA
+PEM_write_ECDSA_PUBKEY 3308 NOEXIST::FUNCTION:
EC_GROUP_check_discriminant 3309 EXIST::FUNCTION:EC
-ECDSA_set_default_conversion_form 3310 EXIST::FUNCTION:ECDSA
+ECDSA_set_default_conversion_form 3310 NOEXIST::FUNCTION:
ECDSA_set_ex_data 3311 EXIST::FUNCTION:ECDSA
-ECDSA_get_default_conversion_form 3312 EXIST::FUNCTION:ECDSA
-i2d_ECDSA_PUBKEY_bio 3313 EXIST::FUNCTION:BIO,ECDSA
-EC_ASN1_pkparameters2group 3314 EXIST::FUNCTION:EC
-d2i_ECDSAPrivateKey 3315 EXIST::FUNCTION:ECDSA
+ECDSA_get_default_conversion_form 3312 NOEXIST::FUNCTION:
+i2d_ECDSA_PUBKEY_bio 3313 NOEXIST::FUNCTION:
+EC_ASN1_pkparameters2group 3314 NOEXIST::FUNCTION:
+d2i_ECDSAPrivateKey 3315 NOEXIST::FUNCTION:
EC_GROUP_new_by_nid 3316 EXIST::FUNCTION:EC
-PEM_read_ECDSA_PUBKEY 3317 EXIST:!WIN16:FUNCTION:ECDSA
-ECDSA_up_ref 3318 EXIST::FUNCTION:ECDSA
+PEM_read_ECDSA_PUBKEY 3317 NOEXIST::FUNCTION:
+ECDSA_up_ref 3318 NOEXIST::FUNCTION:
ENGINE_register_all_ECDSA 3319 EXIST::FUNCTION:
-ECDSA_get_conversion_form 3320 EXIST::FUNCTION:ECDSA
+ECDSA_get_conversion_form 3320 NOEXIST::FUNCTION:
i2d_ECPKParameters 3321 EXIST::FUNCTION:EC
-ECDSA_generate_key 3322 EXIST::FUNCTION:ECDSA
+ECDSA_generate_key 3322 NOEXIST::FUNCTION:
PEM_write_ECDSAParameters 3323 NOEXIST::FUNCTION:
-i2d_ECDSAPrivateKey_fp 3324 EXIST::FUNCTION:ECDSA,FP_API
-PEM_read_ECDSAPrivateKey 3325 EXIST:!WIN16:FUNCTION:ECDSA
-ECDSAPublicKey_set_octet_string 3326 EXIST::FUNCTION:ECDSA
+i2d_ECDSAPrivateKey_fp 3324 NOEXIST::FUNCTION:
+PEM_read_ECDSAPrivateKey 3325 NOEXIST::FUNCTION:
+ECDSAPublicKey_set_octet_string 3326 NOEXIST::FUNCTION:
ECPKParameters_print_fp 3327 EXIST::FUNCTION:EC,FP_API
EVP_des_ede3_ecb 3328 EXIST::FUNCTION:DES
EC_GROUP_set_seed 3329 EXIST::FUNCTION:EC
d2i_ASN1_UNIVERSALSTRING 3340 EXIST::FUNCTION:
PEM_read_bio_ECPKParameters 3341 EXIST::FUNCTION:EC
ASN1_UNIVERSALSTRING_new 3342 EXIST::FUNCTION:
-EC_PRIVATEKEY_new 3343 EXIST::FUNCTION:EC
-EC_PRIVATEKEY_it 3344 EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:EC
-EC_PRIVATEKEY_it 3344 EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:EC
+EC_PRIVATEKEY_new 3343 NOEXIST::FUNCTION:
+EC_PRIVATEKEY_it 3344 NOEXIST::FUNCTION:
+EC_PRIVATEKEY_it 3344 NOEXIST::FUNCTION:
DSO_merge 3345 EXIST::FUNCTION:
-d2i_EC_PRIVATEKEY 3346 EXIST::FUNCTION:EC
-ECDSA_get_enc_flag 3347 EXIST::FUNCTION:ECDSA
-ECDSA_set_enc_flag 3348 EXIST::FUNCTION:ECDSA
-i2d_EC_PRIVATEKEY 3349 EXIST::FUNCTION:EC
-EC_PRIVATEKEY_free 3350 EXIST::FUNCTION:EC
+d2i_EC_PRIVATEKEY 3346 NOEXIST::FUNCTION:
+ECDSA_get_enc_flag 3347 NOEXIST::FUNCTION:
+ECDSA_set_enc_flag 3348 NOEXIST::FUNCTION:
+i2d_EC_PRIVATEKEY 3349 NOEXIST::FUNCTION:
+EC_PRIVATEKEY_free 3350 NOEXIST::FUNCTION:
EC_POINT_get_affine_coordinates_GF2m 3351 EXIST::FUNCTION:EC
BN_GF2m_mod_sqr_arr 3352 EXIST::FUNCTION:
EC_GROUP_new_curve_GF2m 3353 EXIST::FUNCTION:EC
BN_GF2m_poly2arr 3377 EXIST::FUNCTION:
EC_POINT_dup 3378 EXIST::FUNCTION:EC
EC_POINT_set_affine_coordinates_GF2m 3379 EXIST::FUNCTION:EC
+i2d_EC_PUBKEY 3380 EXIST::FUNCTION:EC
+i2d_ECPrivateKey 3381 EXIST::FUNCTION:EC
+EC_KEY_free 3382 EXIST::FUNCTION:EC
+PEM_write_bio_ECPrivateKey 3383 EXIST::FUNCTION:EC
+ECDSA_DATA_new_method 3384 EXIST::FUNCTION:ECDSA
+i2d_ECPrivateKey_bio 3385 EXIST::FUNCTION:BIO,EC
+d2i_ECPrivateKey_fp 3386 EXIST::FUNCTION:EC,FP_API
+EVP_PKEY_get1_EC_KEY 3387 EXIST::FUNCTION:EC
+ECPublicKey_set_octet_string 3388 EXIST::FUNCTION:EC
+PEM_write_EC_PUBKEY 3389 EXIST:!WIN16:FUNCTION:EC
+EC_KEY_print_fp 3390 EXIST::FUNCTION:EC,FP_API
+EC_KEY_new 3391 EXIST::FUNCTION:EC
+i2d_EC_PUBKEY_bio 3392 EXIST::FUNCTION:BIO,EC
+ECDSA_DATA_new 3393 EXIST::FUNCTION:ECDSA
+EVP_PKEY_set1_EC_KEY 3394 EXIST::FUNCTION:EC
+ECDSA_DATA_free 3395 EXIST::FUNCTION:ECDSA
+EC_KEY_print 3396 EXIST::FUNCTION:BIO,EC
+PEM_write_bio_EC_PUBKEY 3397 EXIST::FUNCTION:EC
+ECParameters_print 3398 EXIST::FUNCTION:BIO,EC
+d2i_EC_PUBKEY_fp 3399 EXIST::FUNCTION:EC,FP_API
+PEM_write_ECPrivateKey 3400 EXIST:!WIN16:FUNCTION:EC
+ecdsa_check 3401 EXIST::FUNCTION:ECDSA
+PEM_read_ECPrivateKey 3402 EXIST:!WIN16:FUNCTION:EC
+d2i_ECPrivateKey_bio 3403 EXIST::FUNCTION:BIO,EC
+ECParameters_print_fp 3404 EXIST::FUNCTION:EC,FP_API
+i2d_EC_PUBKEY_fp 3405 EXIST::FUNCTION:EC,FP_API
+i2d_ECPrivateKey_fp 3406 EXIST::FUNCTION:EC,FP_API
+d2i_EC_PUBKEY 3407 EXIST::FUNCTION:EC
+d2i_ECPrivateKey 3408 EXIST::FUNCTION:EC
+d2i_EC_PUBKEY_bio 3409 EXIST::FUNCTION:BIO,EC
+ECPublicKey_get_octet_string 3410 EXIST::FUNCTION:EC
+PEM_read_EC_PUBKEY 3411 EXIST:!WIN16:FUNCTION:EC
+PEM_read_bio_EC_PUBKEY 3412 EXIST::FUNCTION:EC
+PEM_read_bio_ECPrivateKey 3413 EXIST::FUNCTION:EC
+EC_KEY_dup 3414 EXIST::FUNCTION:EC
+EC_KEY_check_key 3415 EXIST::FUNCTION:EC
+EC_KEY_generate_key 3416 EXIST::FUNCTION:EC
+EC_KEY_copy 3417 EXIST::FUNCTION:EC
projects / openssl.git / commitdiff