1156 lines
44 KiB
D
1156 lines
44 KiB
D
/* crypto/ec/ec.h */
|
|
/*
|
|
* Originally written by Bodo Moeller for the OpenSSL project.
|
|
*/
|
|
/**
|
|
* \file crypto/ec/ec.h Include file for the OpenSSL EC functions
|
|
* \author Originally written by Bodo Moeller for the OpenSSL project
|
|
*/
|
|
/* ====================================================================
|
|
* Copyright (c) 1998-2005 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).
|
|
*
|
|
*/
|
|
/* ====================================================================
|
|
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
|
|
*
|
|
* Portions of the attached software ("Contribution") are developed by
|
|
* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
|
|
*
|
|
* The Contribution is licensed pursuant to the OpenSSL open source
|
|
* license provided above.
|
|
*
|
|
* The elliptic curve binary polynomial software is originally written by
|
|
* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
|
|
*
|
|
*/
|
|
|
|
module deimos.openssl.ec;
|
|
|
|
import deimos.openssl._d_util;
|
|
|
|
public import deimos.openssl.opensslconf;
|
|
import deimos.openssl.evp; // Needed for EVP_PKEY_ALG_CTRL and ec_key_st.
|
|
|
|
version (OPENSSL_NO_EC) {
|
|
static assert(false, "EC is disabled.");
|
|
}
|
|
|
|
public import deimos.openssl.asn1;
|
|
public import deimos.openssl.symhacks;
|
|
version(OPENSSL_NO_DEPRECATED) {} else {
|
|
public import deimos.openssl.bn;
|
|
}
|
|
|
|
extern (C):
|
|
nothrow:
|
|
|
|
static if (!is(typeof(OPENSSL_ECC_MAX_FIELD_BITS))) {
|
|
enum OPENSSL_ECC_MAX_FIELD_BITS = 661;
|
|
}
|
|
|
|
/** Enum for the point conversion form as defined in X9.62 (ECDSA)
|
|
* for the encoding of a elliptic curve point (x,y) */
|
|
enum point_conversion_form_t {
|
|
/** the point is encoded as z||x, where the octet z specifies
|
|
* which solution of the quadratic equation y is */
|
|
POINT_CONVERSION_COMPRESSED = 2,
|
|
/** the point is encoded as z||x||y, where z is the octet 0x02 */
|
|
POINT_CONVERSION_UNCOMPRESSED = 4,
|
|
/** the point is encoded as z||x||y, where the octet z specifies
|
|
* which solution of the quadratic equation y is */
|
|
POINT_CONVERSION_HYBRID = 6
|
|
}
|
|
|
|
|
|
struct ec_method_st;
|
|
alias ec_method_st EC_METHOD;
|
|
|
|
struct ec_group_st;
|
|
/*
|
|
EC_METHOD* meth;
|
|
-- field definition
|
|
-- curve coefficients
|
|
-- optional generator with associated information (order, cofactor)
|
|
-- optional extra data (precomputed table for fast computation of multiples of generator)
|
|
-- ASN1 stuff
|
|
*/
|
|
alias ec_group_st EC_GROUP;
|
|
|
|
struct ec_point_st;
|
|
alias ec_point_st EC_POINT;
|
|
|
|
|
|
/********************************************************************/
|
|
/* EC_METHODs for curves over GF(p) */
|
|
/********************************************************************/
|
|
|
|
/** Returns the basic GFp ec methods which provides the basis for the
|
|
* optimized methods.
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_simple_method();
|
|
|
|
/** Returns GFp methods using montgomery multiplication.
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_mont_method();
|
|
|
|
/** Returns GFp methods using optimized methods for NIST recommended curves
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_nist_method();
|
|
|
|
version(OPENSSL_NO_EC_NISTP_64_GCC_128) {} else {
|
|
/** Returns 64-bit optimized methods for nistp224
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_nistp224_method();
|
|
|
|
/** Returns 64-bit optimized methods for nistp256
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_nistp256_method();
|
|
|
|
/** Returns 64-bit optimized methods for nistp521
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GFp_nistp521_method();
|
|
}
|
|
|
|
version(OPENSSL_NO_EC2M) {} else {
|
|
/********************************************************************/
|
|
/* EC_METHOD for curves over GF(2^m) */
|
|
/********************************************************************/
|
|
|
|
/** Returns the basic GF2m ec method
|
|
* \return EC_METHOD object
|
|
*/
|
|
const(EC_METHOD)* EC_GF2m_simple_method();
|
|
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
/* EC_GROUP functions */
|
|
/********************************************************************/
|
|
|
|
/** Creates a new EC_GROUP object
|
|
* \param meth EC_METHOD to use
|
|
* \return newly created EC_GROUP object or NULL in case of an error.
|
|
*/
|
|
EC_GROUP* EC_GROUP_new(const(EC_METHOD)* meth);
|
|
|
|
/** Frees a EC_GROUP object
|
|
* \param group EC_GROUP object to be freed.
|
|
*/
|
|
void EC_GROUP_free(EC_GROUP* group);
|
|
|
|
/** Clears and frees a EC_GROUP object
|
|
* \param group EC_GROUP object to be cleared and freed.
|
|
*/
|
|
void EC_GROUP_clear_free(EC_GROUP* group);
|
|
|
|
/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
|
|
* \param dst destination EC_GROUP object
|
|
* \param src source EC_GROUP object
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_GROUP_copy(EC_GROUP* dst, const(EC_GROUP)* src);
|
|
|
|
/** Creates a new EC_GROUP object and copies the copies the content
|
|
* form src to the newly created EC_KEY object
|
|
* \param src source EC_GROUP object
|
|
* \return newly created EC_GROUP object or NULL in case of an error.
|
|
*/
|
|
EC_GROUP* EC_GROUP_dup(const(EC_GROUP)* src);
|
|
|
|
/** Returns the EC_METHOD of the EC_GROUP object.
|
|
* \param group EC_GROUP object
|
|
* \return EC_METHOD used in this EC_GROUP object.
|
|
*/
|
|
const(EC_METHOD)* EC_GROUP_method_of(const(EC_GROUP)* group);
|
|
|
|
/** Returns the field type of the EC_METHOD.
|
|
* \param meth EC_METHOD object
|
|
* \return NID of the underlying field type OID.
|
|
*/
|
|
int EC_METHOD_get_field_type(const(EC_METHOD)* meth);
|
|
|
|
/** Sets the generator and it's order/cofactor of a EC_GROUP object.
|
|
* \param group EC_GROUP object
|
|
* \param generator EC_POINT object with the generator.
|
|
* \param order the order of the group generated by the generator.
|
|
* \param cofactor the index of the sub-group generated by the generator
|
|
* in the group of all points on the elliptic curve.
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_set_generator(EC_GROUP* group, const(EC_POINT)* generator, const(BIGNUM)* order, const(BIGNUM)* cofactor);
|
|
|
|
/** Returns the generator of a EC_GROUP object.
|
|
* \param group EC_GROUP object
|
|
* \return the currently used generator (possibly NULL).
|
|
*/
|
|
const(EC_POINT)* EC_GROUP_get0_generator(const(EC_GROUP)* group);
|
|
|
|
/** Gets the order of a EC_GROUP
|
|
* \param group EC_GROUP object
|
|
* \param order BIGNUM to which the order is copied
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_get_order(const(EC_GROUP)* group, BIGNUM* order, BN_CTX* ctx);
|
|
|
|
/** Gets the cofactor of a EC_GROUP
|
|
* \param group EC_GROUP object
|
|
* \param cofactor BIGNUM to which the cofactor is copied
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_get_cofactor(const(EC_GROUP)* group, BIGNUM* cofactor, BN_CTX* ctx);
|
|
|
|
/** Sets the name of a EC_GROUP object
|
|
* \param group EC_GROUP object
|
|
* \param nid NID of the curve name OID
|
|
*/
|
|
void EC_GROUP_set_curve_name(EC_GROUP* group, int nid);
|
|
|
|
/** Returns the curve name of a EC_GROUP object
|
|
* \param group EC_GROUP object
|
|
* \return NID of the curve name OID or 0 if not set.
|
|
*/
|
|
int EC_GROUP_get_curve_name(const(EC_GROUP)* group);
|
|
|
|
void EC_GROUP_set_asn1_flag(EC_GROUP* group, int flag);
|
|
int EC_GROUP_get_asn1_flag(const(EC_GROUP)* group);
|
|
|
|
void EC_GROUP_set_point_conversion_form(EC_GROUP* group, point_conversion_form_t);
|
|
point_conversion_form_t EC_GROUP_get_point_conversion_form(const(EC_GROUP)*);
|
|
|
|
ubyte* EC_GROUP_get0_seed(const(EC_GROUP)* x);
|
|
size_t EC_GROUP_get_seed_len(const(EC_GROUP)*);
|
|
size_t EC_GROUP_set_seed(EC_GROUP*, const(ubyte)*, size_t len);
|
|
|
|
/** Sets the parameter of a ec over GFp defined by y^2 = x^3 + a*x + b
|
|
* \param group EC_GROUP object
|
|
* \param p BIGNUM with the prime number
|
|
* \param a BIGNUM with parameter a of the equation
|
|
* \param b BIGNUM with parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_set_curve_GFp(EC_GROUP* group, const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
|
|
|
|
/** Gets the parameter of the ec over GFp defined by y^2 = x^3 + a*x + b
|
|
* \param group EC_GROUP object
|
|
* \param p BIGNUM for the prime number
|
|
* \param a BIGNUM for parameter a of the equation
|
|
* \param b BIGNUM for parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_get_curve_GFp(const(EC_GROUP)* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
|
|
|
|
version(OPENSSL_NO_EC2M) {} else {
|
|
/** Sets the parameter of a ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b
|
|
* \param group EC_GROUP object
|
|
* \param p BIGNUM with the polynomial defining the underlying field
|
|
* \param a BIGNUM with parameter a of the equation
|
|
* \param b BIGNUM with parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_set_curve_GF2m(EC_GROUP* group, const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
|
|
|
|
/** Gets the parameter of the ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b
|
|
* \param group EC_GROUP object
|
|
* \param p BIGNUM for the polynomial defining the underlying field
|
|
* \param a BIGNUM for parameter a of the equation
|
|
* \param b BIGNUM for parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_get_curve_GF2m(const(EC_GROUP)* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
|
|
}
|
|
/** Returns the number of bits needed to represent a field element
|
|
* \param group EC_GROUP object
|
|
* \return number of bits needed to represent a field element
|
|
*/
|
|
int EC_GROUP_get_degree(const(EC_GROUP)* group);
|
|
|
|
/** Checks whether the parameter in the EC_GROUP define a valid ec group
|
|
* \param group EC_GROUP object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 if group is a valid ec group and 0 otherwise
|
|
*/
|
|
int EC_GROUP_check(const(EC_GROUP)* group, BN_CTX* ctx);
|
|
|
|
/** Checks whether the discriminant of the elliptic curve is zero or not
|
|
* \param group EC_GROUP object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 if the discriminant is not zero and 0 otherwise
|
|
*/
|
|
int EC_GROUP_check_discriminant(const(EC_GROUP)* group, BN_CTX* ctx);
|
|
|
|
/** Compares two EC_GROUP objects
|
|
* \param a first EC_GROUP object
|
|
* \param b second EC_GROUP object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 0 if both groups are equal and 1 otherwise
|
|
*/
|
|
int EC_GROUP_cmp(const(EC_GROUP)* a, const(EC_GROUP)* b, BN_CTX* ctx);
|
|
|
|
/* EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*()
|
|
* after choosing an appropriate EC_METHOD */
|
|
|
|
/** Creates a new EC_GROUP object with the specified parameters defined
|
|
* over GFp (defined by the equation y^2 = x^3 + a*x + b)
|
|
* \param p BIGNUM with the prime number
|
|
* \param a BIGNUM with the parameter a of the equation
|
|
* \param b BIGNUM with the parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return newly created EC_GROUP object with the specified parameters
|
|
*/
|
|
EC_GROUP* EC_GROUP_new_curve_GFp(const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
|
|
version(OPENSSL_NO_EC2M) {} else {
|
|
/** Creates a new EC_GROUP object with the specified parameters defined
|
|
* over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
|
|
* \param p BIGNUM with the polynomial defining the underlying field
|
|
* \param a BIGNUM with the parameter a of the equation
|
|
* \param b BIGNUM with the parameter b of the equation
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return newly created EC_GROUP object with the specified parameters
|
|
*/
|
|
EC_GROUP* EC_GROUP_new_curve_GF2m(const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
|
|
}
|
|
/** Creates a EC_GROUP object with a curve specified by a NID
|
|
* \param nid NID of the OID of the curve name
|
|
* \return newly created EC_GROUP object with specified curve or NULL
|
|
* if an error occurred
|
|
*/
|
|
EC_GROUP* EC_GROUP_new_by_curve_name(int nid);
|
|
|
|
|
|
/********************************************************************/
|
|
/* handling of internal curves */
|
|
/********************************************************************/
|
|
|
|
struct EC_builtin_curve {
|
|
int nid;
|
|
const(char)* comment;
|
|
}
|
|
|
|
/* EC_builtin_curves(EC_builtin_curve* r, size_t size) returns number
|
|
* of all available curves or zero if a error occurred.
|
|
* In case r ist not zero nitems EC_builtin_curve structures
|
|
* are filled with the data of the first nitems internal groups */
|
|
size_t EC_get_builtin_curves(EC_builtin_curve* r, size_t nitems);
|
|
|
|
|
|
/********************************************************************/
|
|
/* EC_POINT functions */
|
|
/********************************************************************/
|
|
|
|
/** Creates a new EC_POINT object for the specified EC_GROUP
|
|
* \param group EC_GROUP the underlying EC_GROUP object
|
|
* \return newly created EC_POINT object or NULL if an error occurred
|
|
*/
|
|
EC_POINT* EC_POINT_new(const(EC_GROUP)* group);
|
|
|
|
/** Frees a EC_POINT object
|
|
* \param point EC_POINT object to be freed
|
|
*/
|
|
void EC_POINT_free(EC_POINT* point);
|
|
|
|
/** Clears and frees a EC_POINT object
|
|
* \param point EC_POINT object to be cleared and freed
|
|
*/
|
|
void EC_POINT_clear_free(EC_POINT* point);
|
|
|
|
/** Copies EC_POINT object
|
|
* \param dst destination EC_POINT object
|
|
* \param src source EC_POINT object
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_copy(EC_POINT* dst, const(EC_POINT)* src);
|
|
|
|
/** Creates a new EC_POINT object and copies the content of the supplied
|
|
* EC_POINT
|
|
* \param src source EC_POINT object
|
|
* \param group underlying the EC_GROUP object
|
|
* \return newly created EC_POINT object or NULL if an error occurred
|
|
*/
|
|
EC_POINT* EC_POINT_dup(const(EC_POINT)* src, const(EC_GROUP)* group);
|
|
|
|
/** Returns the EC_METHOD used in EC_POINT object
|
|
* \param point EC_POINT object
|
|
* \return the EC_METHOD used
|
|
*/
|
|
const(EC_METHOD)* EC_POINT_method_of(const(EC_POINT)* point);
|
|
|
|
/** Sets a point to infinity (neutral element)
|
|
* \param group underlying EC_GROUP object
|
|
* \param point EC_POINT to set to infinity
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_to_infinity(const(EC_GROUP)* group, EC_POINT* point);
|
|
|
|
/** Sets the jacobian projective coordinates of a EC_POINT over GFp
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM with the x-coordinate
|
|
* \param y BIGNUM with the y-coordinate
|
|
* \param z BIGNUM with the z-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_Jprojective_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(BIGNUM)* x, const(BIGNUM)* y, const(BIGNUM)* z, BN_CTX* ctx);
|
|
|
|
/** Gets the jacobian projective coordinates of a EC_POINT over GFp
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM for the x-coordinate
|
|
* \param y BIGNUM for the y-coordinate
|
|
* \param z BIGNUM for the z-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_get_Jprojective_coordinates_GFp(const(EC_GROUP)* group,
|
|
const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BIGNUM* z, BN_CTX* ctx);
|
|
|
|
/** Sets the affine coordinates of a EC_POINT over GFp
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM with the x-coordinate
|
|
* \param y BIGNUM with the y-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_affine_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(BIGNUM)* x, const(BIGNUM)* y, BN_CTX* ctx);
|
|
|
|
/** Gets the affine coordinates of a EC_POINT over GFp
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM for the x-coordinate
|
|
* \param y BIGNUM for the y-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_get_affine_coordinates_GFp(const(EC_GROUP)* group,
|
|
const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);
|
|
|
|
/** Sets the x9.62 compressed coordinates of a EC_POINT over GFp
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM with x-coordinate
|
|
* \param y_bit integer with the y-Bit (either 0 or 1)
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_compressed_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(BIGNUM)* x, int y_bit, BN_CTX* ctx);
|
|
version(OPENSSL_NO_EC2M) {} else {
|
|
/** Sets the affine coordinates of a EC_POINT over GF2m
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM with the x-coordinate
|
|
* \param y BIGNUM with the y-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_affine_coordinates_GF2m(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(BIGNUM)* x, const(BIGNUM)* y, BN_CTX* ctx);
|
|
|
|
/** Gets the affine coordinates of a EC_POINT over GF2m
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM for the x-coordinate
|
|
* \param y BIGNUM for the y-coordinate
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_get_affine_coordinates_GF2m(const(EC_GROUP)* group,
|
|
const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);
|
|
|
|
/** Sets the x9.62 compressed coordinates of a EC_POINT over GF2m
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param x BIGNUM with x-coordinate
|
|
* \param y_bit integer with the y-Bit (either 0 or 1)
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_set_compressed_coordinates_GF2m(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(BIGNUM)* x, int y_bit, BN_CTX* ctx);
|
|
}
|
|
/** Encodes a EC_POINT object to a octet string
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param form point conversion form
|
|
* \param buf memory buffer for the result. If NULL the function returns
|
|
* required buffer size.
|
|
* \param len length of the memory buffer
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return the length of the encoded octet string or 0 if an error occurred
|
|
*/
|
|
size_t EC_POINT_point2oct(const(EC_GROUP)* group, const(EC_POINT)* p,
|
|
point_conversion_form_t form,
|
|
ubyte* buf, size_t len, BN_CTX* ctx);
|
|
|
|
/** Decodes a EC_POINT from a octet string
|
|
* \param group underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \param buf memory buffer with the encoded ec point
|
|
* \param len length of the encoded ec point
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_oct2point(const(EC_GROUP)* group, EC_POINT* p,
|
|
const(ubyte)* buf, size_t len, BN_CTX* ctx);
|
|
|
|
/* other interfaces to point2oct/oct2point: */
|
|
BIGNUM* EC_POINT_point2bn(const(EC_GROUP)*, const(EC_POINT)*,
|
|
point_conversion_form_t form, BIGNUM*, BN_CTX*);
|
|
EC_POINT* EC_POINT_bn2point(const(EC_GROUP)*, const(BIGNUM)*,
|
|
EC_POINT*, BN_CTX*);
|
|
char* EC_POINT_point2hex(const(EC_GROUP)*, const(EC_POINT)*,
|
|
point_conversion_form_t form, BN_CTX*);
|
|
EC_POINT* EC_POINT_hex2point(const(EC_GROUP)*, const(char)*,
|
|
EC_POINT*, BN_CTX*);
|
|
|
|
|
|
/********************************************************************/
|
|
/* functions for doing EC_POINT arithmetic */
|
|
/********************************************************************/
|
|
|
|
/** Computes the sum of two EC_POINT
|
|
* \param group underlying EC_GROUP object
|
|
* \param r EC_POINT object for the result (r = a + b)
|
|
* \param a EC_POINT object with the first summand
|
|
* \param b EC_POINT object with the second summand
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_add(const(EC_GROUP)* group, EC_POINT* r, const(EC_POINT)* a, const(EC_POINT)* b, BN_CTX* ctx);
|
|
|
|
/** Computes the double of a EC_POINT
|
|
* \param group underlying EC_GROUP object
|
|
* \param r EC_POINT object for the result (r = 2* a)
|
|
* \param a EC_POINT object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_dbl(const(EC_GROUP)* group, EC_POINT* r, const(EC_POINT)* a, BN_CTX* ctx);
|
|
|
|
/** Computes the inverse of a EC_POINT
|
|
* \param group underlying EC_GROUP object
|
|
* \param a EC_POINT object to be inverted (it's used for the result as well)
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_invert(const(EC_GROUP)* group, EC_POINT* a, BN_CTX* ctx);
|
|
|
|
/** Checks whether the point is the neutral element of the group
|
|
* \param group the underlying EC_GROUP object
|
|
* \param p EC_POINT object
|
|
* \return 1 if the point is the neutral element and 0 otherwise
|
|
*/
|
|
int EC_POINT_is_at_infinity(const(EC_GROUP)* group, const(EC_POINT)* p);
|
|
|
|
/** Checks whether the point is on the curve
|
|
* \param group underlying EC_GROUP object
|
|
* \param point EC_POINT object to check
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 if point if on the curve and 0 otherwise
|
|
*/
|
|
int EC_POINT_is_on_curve(const(EC_GROUP)* group, const(EC_POINT)* point, BN_CTX* ctx);
|
|
|
|
/** Compares two EC_POINTs
|
|
* \param group underlying EC_GROUP object
|
|
* \param a first EC_POINT object
|
|
* \param b second EC_POINT object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 0 if both points are equal and a value != 0 otherwise
|
|
*/
|
|
int EC_POINT_cmp(const(EC_GROUP)* group, const(EC_POINT)* a, const(EC_POINT)* b, BN_CTX* ctx);
|
|
|
|
int EC_POINT_make_affine(const(EC_GROUP)* group, EC_POINT* point, BN_CTX* ctx);
|
|
int EC_POINTs_make_affine(const(EC_GROUP)* group, size_t num, EC_POINT*[] points, BN_CTX* ctx);
|
|
|
|
/** Computes r = generator* n sum_{i=0}^num p[i] * m[i]
|
|
* \param group underlying EC_GROUP object
|
|
* \param r EC_POINT object for the result
|
|
* \param n BIGNUM with the multiplier for the group generator (optional)
|
|
* \param num number futher summands
|
|
* \param p array of size num of EC_POINT objects
|
|
* \param m array of size num of BIGNUM objects
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINTs_mul(const(EC_GROUP)* group, EC_POINT* r, const(BIGNUM)* n, size_t num, const(EC_POINT)*[] p, const(BIGNUM)*[] m, BN_CTX* ctx);
|
|
|
|
/** Computes r = generator* n + q* m
|
|
* \param group underlying EC_GROUP object
|
|
* \param r EC_POINT object for the result
|
|
* \param n BIGNUM with the multiplier for the group generator (optional)
|
|
* \param q EC_POINT object with the first factor of the second summand
|
|
* \param m BIGNUM with the second factor of the second summand
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_POINT_mul(const(EC_GROUP)* group, EC_POINT* r, const(BIGNUM)* n, const(EC_POINT)* q, const(BIGNUM)* m, BN_CTX* ctx);
|
|
|
|
/** Stores multiples of generator for faster point multiplication
|
|
* \param group EC_GROUP object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occured
|
|
*/
|
|
int EC_GROUP_precompute_mult(EC_GROUP* group, BN_CTX* ctx);
|
|
|
|
/** Reports whether a precomputation has been done
|
|
* \param group EC_GROUP object
|
|
* \return 1 if a pre-computation has been done and 0 otherwise
|
|
*/
|
|
int EC_GROUP_have_precompute_mult(const(EC_GROUP)* group);
|
|
|
|
|
|
/********************************************************************/
|
|
/* ASN1 stuff */
|
|
/********************************************************************/
|
|
|
|
/* EC_GROUP_get_basis_type() returns the NID of the basis type
|
|
* used to represent the field elements */
|
|
int EC_GROUP_get_basis_type(const(EC_GROUP)*);
|
|
version(OPENSSL_NO_EC2M) {} else {
|
|
int EC_GROUP_get_trinomial_basis(const(EC_GROUP)*, uint* k);
|
|
int EC_GROUP_get_pentanomial_basis(const(EC_GROUP)*, uint* k1,
|
|
uint* k2, uint* k3);
|
|
}
|
|
|
|
enum OPENSSL_EC_NAMED_CURVE = 0x001;
|
|
|
|
struct ecpk_parameters_st;
|
|
alias ecpk_parameters_st ECPKPARAMETERS;
|
|
|
|
EC_GROUP* d2i_ECPKParameters(EC_GROUP**, const(ubyte)** in_, c_long len);
|
|
int i2d_ECPKParameters(const(EC_GROUP)*, ubyte** out_);
|
|
|
|
/+XXX
|
|
#define d2i_ECPKParameters_bio(bp,x) ASN1_d2i_bio_of(EC_GROUP,NULL,d2i_ECPKParameters,bp,x)
|
|
#define i2d_ECPKParameters_bio(bp,x) ASN1_i2d_bio_of_const(EC_GROUP,i2d_ECPKParameters,bp,x)
|
|
#define d2i_ECPKParameters_fp(fp,x) (EC_GROUP*)ASN1_d2i_fp(NULL, \
|
|
(ExternC!(char* function()) )d2i_ECPKParameters,(fp),(ubyte**)(x))
|
|
#define i2d_ECPKParameters_fp(fp,x) ASN1_i2d_fp(i2d_ECPKParameters,(fp), \
|
|
(ubyte*)(x))
|
|
+/
|
|
|
|
version(OPENSSL_NO_BIO) {} else {
|
|
int ECPKParameters_print(BIO* bp, const(EC_GROUP)* x, int off);
|
|
}
|
|
version(OPENSSL_NO_FP_API) {} else {
|
|
int ECPKParameters_print_fp(FILE* fp, const(EC_GROUP)* x, int off);
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
/* EC_KEY functions */
|
|
/********************************************************************/
|
|
|
|
/*struct ec_key_st;*/
|
|
alias ec_key_st EC_KEY;
|
|
|
|
/* some values for the encoding_flag */
|
|
enum EC_PKEY_NO_PARAMETERS = 0x001;
|
|
enum EC_PKEY_NO_PUBKEY = 0x002;
|
|
|
|
/* some values for the flags field */
|
|
enum EC_FLAG_NON_FIPS_ALLOW = 0x1;
|
|
enum EC_FLAG_FIPS_CHECKED = 0x2;
|
|
|
|
/** Creates a new EC_KEY object.
|
|
* \return EC_KEY object or NULL if an error occurred.
|
|
*/
|
|
EC_KEY* EC_KEY_new();
|
|
|
|
int EC_KEY_get_flags(const(EC_KEY)* key);
|
|
|
|
void EC_KEY_set_flags(EC_KEY* key, int flags);
|
|
|
|
void EC_KEY_clear_flags(EC_KEY* key, int flags);
|
|
|
|
/** Creates a new EC_KEY object using a named curve as underlying
|
|
* EC_GROUP object.
|
|
* \param nid NID of the named curve.
|
|
* \return EC_KEY object or NULL if an error occurred.
|
|
*/
|
|
EC_KEY* EC_KEY_new_by_curve_name(int nid);
|
|
|
|
/** Frees a EC_KEY object.
|
|
* \param key EC_KEY object to be freed.
|
|
*/
|
|
void EC_KEY_free(EC_KEY* key);
|
|
|
|
/** Copies a EC_KEY object.
|
|
* \param dst destination EC_KEY object
|
|
* \param src src EC_KEY object
|
|
* \return dst or NULL if an error occurred.
|
|
*/
|
|
EC_KEY* EC_KEY_copy(EC_KEY* dst, const(EC_KEY)* src);
|
|
|
|
/** Creates a new EC_KEY object and copies the content from src to it.
|
|
* \param src the source EC_KEY object
|
|
* \return newly created EC_KEY object or NULL if an error occurred.
|
|
*/
|
|
EC_KEY* EC_KEY_dup(const(EC_KEY)* src);
|
|
|
|
/** Increases the internal reference count of a EC_KEY object.
|
|
* \param key EC_KEY object
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_up_ref(EC_KEY* key);
|
|
|
|
/** Returns the EC_GROUP object of a EC_KEY object
|
|
* \param key EC_KEY object
|
|
* \return the EC_GROUP object (possibly NULL).
|
|
*/
|
|
const(EC_GROUP)* EC_KEY_get0_group(const(EC_KEY)* key);
|
|
|
|
/** Sets the EC_GROUP of a EC_KEY object.
|
|
* \param key EC_KEY object
|
|
* \param group EC_GROUP to use in the EC_KEY object (note: the EC_KEY
|
|
* object will use an own copy of the EC_GROUP).
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_set_group(EC_KEY* key, const(EC_GROUP)* group);
|
|
|
|
/** Returns the private key of a EC_KEY object.
|
|
* \param key EC_KEY object
|
|
* \return a BIGNUM with the private key (possibly NULL).
|
|
*/
|
|
const(BIGNUM)* EC_KEY_get0_private_key(const(EC_KEY)* key);
|
|
|
|
/** Sets the private key of a EC_KEY object.
|
|
* \param key EC_KEY object
|
|
* \param prv BIGNUM with the private key (note: the EC_KEY object
|
|
* will use an own copy of the BIGNUM).
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_set_private_key(EC_KEY* key, const(BIGNUM)* prv);
|
|
|
|
/** Returns the public key of a EC_KEY object.
|
|
* \param key the EC_KEY object
|
|
* \return a EC_POINT object with the public key (possibly NULL)
|
|
*/
|
|
const(EC_POINT)* EC_KEY_get0_public_key(const(EC_KEY)* key);
|
|
|
|
/** Sets the public key of a EC_KEY object.
|
|
* \param key EC_KEY object
|
|
* \param pub EC_POINT object with the public key (note: the EC_KEY object
|
|
* will use an own copy of the EC_POINT object).
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_set_public_key(EC_KEY* key, const(EC_POINT)* pub);
|
|
|
|
uint EC_KEY_get_enc_flags(const(EC_KEY)* key);
|
|
void EC_KEY_set_enc_flags(EC_KEY* eckey, uint);
|
|
point_conversion_form_t EC_KEY_get_conv_form(const(EC_KEY)* key);
|
|
void EC_KEY_set_conv_form(EC_KEY* eckey, point_conversion_form_t);
|
|
/* functions to set/get method specific data */
|
|
void* EC_KEY_get_key_method_data(EC_KEY* eckey,
|
|
ExternC!(void* function(void*)) dup_func, ExternC!(void function(void*)) free_func, ExternC!(void function(void*)) clear_free_func);
|
|
/** Sets the key method data of an EC_KEY object, if none has yet been set.
|
|
* \param key EC_KEY object
|
|
* \param data opaque data to install.
|
|
* \param dup_func a function that duplicates |data|.
|
|
* \param free_func a function that frees |data|.
|
|
* \param clear_free_func a function that wipes and frees |data|.
|
|
* \return the previously set data pointer, or NULL if |data| was inserted.
|
|
*/
|
|
void *EC_KEY_insert_key_method_data(EC_KEY* key, void* data,
|
|
ExternC!(void* function(void*)) dup_func, ExternC!(void function(void*)) free_func, ExternC!(void function(void*)) clear_free_func);
|
|
/* wrapper functions for the underlying EC_GROUP object */
|
|
void EC_KEY_set_asn1_flag(EC_KEY* eckey, int);
|
|
|
|
/** Creates a table of pre-computed multiples of the generator to
|
|
* accelerate further EC_KEY operations.
|
|
* \param key EC_KEY object
|
|
* \param ctx BN_CTX object (optional)
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_precompute_mult(EC_KEY* key, BN_CTX* ctx);
|
|
|
|
/** Creates a new ec private (and optional a new public) key.
|
|
* \param key EC_KEY object
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int EC_KEY_generate_key(EC_KEY* key);
|
|
|
|
/** Verifies that a private and/or public key is valid.
|
|
* \param key the EC_KEY object
|
|
* \return 1 on success and 0 otherwise.
|
|
*/
|
|
int EC_KEY_check_key(const(EC_KEY)* key);
|
|
|
|
|
|
/********************************************************************/
|
|
/* de- and encoding functions for SEC1 ECPrivateKey */
|
|
/********************************************************************/
|
|
|
|
/** Decodes a private key from a memory buffer.
|
|
* \param key a pointer to a EC_KEY object which should be used (or NULL)
|
|
* \param in pointer to memory with the DER encoded private key
|
|
* \param len length of the DER encoded private key
|
|
* \return the decoded private key or NULL if an error occurred.
|
|
*/
|
|
EC_KEY* d2i_ECPrivateKey(EC_KEY** key, const(ubyte)** in_, c_long len);
|
|
|
|
/** Encodes a private key object and stores the result in a buffer.
|
|
* \param key the EC_KEY object to encode
|
|
* \param out the buffer for the result (if NULL the function returns number
|
|
* of bytes needed).
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int i2d_ECPrivateKey(EC_KEY* key, ubyte** out_);
|
|
|
|
|
|
/********************************************************************/
|
|
/* de- and encoding functions for EC parameters */
|
|
/********************************************************************/
|
|
|
|
/** Decodes ec parameter from a memory buffer.
|
|
* \param key a pointer to a EC_KEY object which should be used (or NULL)
|
|
* \param in pointer to memory with the DER encoded ec parameters
|
|
* \param len length of the DER encoded ec parameters
|
|
* \return a EC_KEY object with the decoded parameters or NULL if an error
|
|
* occurred.
|
|
*/
|
|
EC_KEY* d2i_ECParameters(EC_KEY** key, const(ubyte)** in_, c_long len);
|
|
|
|
/** Encodes ec parameter and stores the result in a buffer.
|
|
* \param key the EC_KEY object with ec paramters to encode
|
|
* \param out the buffer for the result (if NULL the function returns number
|
|
* of bytes needed).
|
|
* \return 1 on success and 0 if an error occurred.
|
|
*/
|
|
int i2d_ECParameters(EC_KEY* key, ubyte** out_);
|
|
|
|
|
|
/********************************************************************/
|
|
/* de- and encoding functions for EC public key */
|
|
/* (octet string, not DER -- hence 'o2i' and 'i2o') */
|
|
/********************************************************************/
|
|
|
|
/** Decodes a ec public key from a octet string.
|
|
* \param key a pointer to a EC_KEY object which should be used
|
|
* \param in memory buffer with the encoded public key
|
|
* \param len length of the encoded public key
|
|
* \return EC_KEY object with decoded public key or NULL if an error
|
|
* occurred.
|
|
*/
|
|
EC_KEY* o2i_ECPublicKey(EC_KEY** key, const(ubyte)** in_, c_long len);
|
|
|
|
/** Encodes a ec public key in an octet string.
|
|
* \param key the EC_KEY object with the public key
|
|
* \param out the buffer for the result (if NULL the function returns number
|
|
* of bytes needed).
|
|
* \return 1 on success and 0 if an error occurred
|
|
*/
|
|
int i2o_ECPublicKey(EC_KEY* key, ubyte** out_);
|
|
|
|
version(OPENSSL_NO_BIO) {} else {
|
|
/** Prints out the ec parameters on human readable form.
|
|
* \param bp BIO object to which the information is printed
|
|
* \param key EC_KEY object
|
|
* \return 1 on success and 0 if an error occurred
|
|
*/
|
|
int ECParameters_print(BIO* bp, const(EC_KEY)* key);
|
|
|
|
/** Prints out the contents of a EC_KEY object
|
|
* \param bp BIO object to which the information is printed
|
|
* \param key EC_KEY object
|
|
* \param off line offset
|
|
* \return 1 on success and 0 if an error occurred
|
|
*/
|
|
int EC_KEY_print(BIO* bp, const(EC_KEY)* key, int off);
|
|
|
|
}
|
|
version(OPENSSL_NO_FP_API) {} else {
|
|
/** Prints out the ec parameters on human readable form.
|
|
* \param fp file descriptor to which the information is printed
|
|
* \param key EC_KEY object
|
|
* \return 1 on success and 0 if an error occurred
|
|
*/
|
|
int ECParameters_print_fp(FILE* fp, const(EC_KEY)* key);
|
|
|
|
/** Prints out the contents of a EC_KEY object
|
|
* \param fp file descriptor to which the information is printed
|
|
* \param key EC_KEY object
|
|
* \param off line offset
|
|
* \return 1 on success and 0 if an error occurred
|
|
*/
|
|
int EC_KEY_print_fp(FILE* fp, const(EC_KEY)* key, int off);
|
|
|
|
}
|
|
|
|
auto ECParameters_dup()(EC_KEY* x) {return ASN1_dup_of!EC_KEY(&i2d_ECParameters,&d2i_ECParameters,x); }
|
|
|
|
//#ifndef __cplusplus
|
|
//#if defined(__SUNPRO_C)
|
|
//# if __SUNPRO_C >= 0x520
|
|
//# pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE)
|
|
//# endif
|
|
//# endif
|
|
//#endif
|
|
|
|
auto EVP_PKEY_CTX_set_ec_paramgen_curve_nid()(EVP_PKEY_CTX* ctx, int nid) {
|
|
return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, EVP_PKEY_OP_PARAMGEN,
|
|
EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, null);
|
|
}
|
|
|
|
enum EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID = (EVP_PKEY_ALG_CTRL + 1);
|
|
|
|
/* BEGIN ERROR CODES */
|
|
/* The following lines are auto generated by the script mkerr.pl. Any changes
|
|
* made after this point may be overwritten when the script is next run.
|
|
*/
|
|
void ERR_load_EC_strings();
|
|
|
|
/* Error codes for the EC functions. */
|
|
|
|
/* Function codes. */
|
|
enum EC_F_BN_TO_FELEM = 224;
|
|
enum EC_F_COMPUTE_WNAF = 143;
|
|
enum EC_F_D2I_ECPARAMETERS = 144;
|
|
enum EC_F_D2I_ECPKPARAMETERS = 145;
|
|
enum EC_F_D2I_ECPRIVATEKEY = 146;
|
|
enum EC_F_DO_EC_KEY_PRINT = 221;
|
|
enum EC_F_ECKEY_PARAM2TYPE = 223;
|
|
enum EC_F_ECKEY_PARAM_DECODE = 212;
|
|
enum EC_F_ECKEY_PRIV_DECODE = 213;
|
|
enum EC_F_ECKEY_PRIV_ENCODE = 214;
|
|
enum EC_F_ECKEY_PUB_DECODE = 215;
|
|
enum EC_F_ECKEY_PUB_ENCODE = 216;
|
|
enum EC_F_ECKEY_TYPE2PARAM = 220;
|
|
enum EC_F_ECPARAMETERS_PRINT = 147;
|
|
enum EC_F_ECPARAMETERS_PRINT_FP = 148;
|
|
enum EC_F_ECPKPARAMETERS_PRINT = 149;
|
|
enum EC_F_ECPKPARAMETERS_PRINT_FP = 150;
|
|
enum EC_F_ECP_NIST_MOD_192 = 203;
|
|
enum EC_F_ECP_NIST_MOD_224 = 204;
|
|
enum EC_F_ECP_NIST_MOD_256 = 205;
|
|
enum EC_F_ECP_NIST_MOD_521 = 206;
|
|
enum EC_F_EC_ASN1_GROUP2CURVE = 153;
|
|
enum EC_F_EC_ASN1_GROUP2FIELDID = 154;
|
|
enum EC_F_EC_ASN1_GROUP2PARAMETERS = 155;
|
|
enum EC_F_EC_ASN1_GROUP2PKPARAMETERS = 156;
|
|
enum EC_F_EC_ASN1_PARAMETERS2GROUP = 157;
|
|
enum EC_F_EC_ASN1_PKPARAMETERS2GROUP = 158;
|
|
enum EC_F_EC_EX_DATA_SET_DATA = 211;
|
|
enum EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY = 208;
|
|
enum EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT = 159;
|
|
enum EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE = 195;
|
|
enum EC_F_EC_GF2M_SIMPLE_OCT2POINT = 160;
|
|
enum EC_F_EC_GF2M_SIMPLE_POINT2OCT = 161;
|
|
enum EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES = 162;
|
|
enum EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES = 163;
|
|
enum EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES = 164;
|
|
enum EC_F_EC_GFP_MONT_FIELD_DECODE = 133;
|
|
enum EC_F_EC_GFP_MONT_FIELD_ENCODE = 134;
|
|
enum EC_F_EC_GFP_MONT_FIELD_MUL = 131;
|
|
enum EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE = 209;
|
|
enum EC_F_EC_GFP_MONT_FIELD_SQR = 132;
|
|
enum EC_F_EC_GFP_MONT_GROUP_SET_CURVE = 189;
|
|
enum EC_F_EC_GFP_MONT_GROUP_SET_CURVE_GFP = 135;
|
|
enum EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE = 225;
|
|
enum EC_F_EC_GFP_NISTP224_POINTS_MUL = 228;
|
|
enum EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES = 226;
|
|
enum EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE = 230;
|
|
enum EC_F_EC_GFP_NISTP256_POINTS_MUL = 231;
|
|
enum EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES = 232;
|
|
enum EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE = 233;
|
|
enum EC_F_EC_GFP_NISTP521_POINTS_MUL = 234;
|
|
enum EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES = 235;
|
|
enum EC_F_EC_GFP_NIST_FIELD_MUL = 200;
|
|
enum EC_F_EC_GFP_NIST_FIELD_SQR = 201;
|
|
enum EC_F_EC_GFP_NIST_GROUP_SET_CURVE = 202;
|
|
enum EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT = 165;
|
|
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE = 166;
|
|
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE_GFP = 100;
|
|
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_GENERATOR = 101;
|
|
enum EC_F_EC_GFP_SIMPLE_MAKE_AFFINE = 102;
|
|
enum EC_F_EC_GFP_SIMPLE_OCT2POINT = 103;
|
|
enum EC_F_EC_GFP_SIMPLE_POINT2OCT = 104;
|
|
enum EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE = 137;
|
|
enum EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES = 167;
|
|
enum EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES_GFP = 105;
|
|
enum EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES = 168;
|
|
enum EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES_GFP = 128;
|
|
enum EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES = 169;
|
|
enum EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES_GFP = 129;
|
|
enum EC_F_EC_GROUP_CHECK = 170;
|
|
enum EC_F_EC_GROUP_CHECK_DISCRIMINANT = 171;
|
|
enum EC_F_EC_GROUP_COPY = 106;
|
|
enum EC_F_EC_GROUP_GET0_GENERATOR = 139;
|
|
enum EC_F_EC_GROUP_GET_COFACTOR = 140;
|
|
enum EC_F_EC_GROUP_GET_CURVE_GF2M = 172;
|
|
enum EC_F_EC_GROUP_GET_CURVE_GFP = 130;
|
|
enum EC_F_EC_GROUP_GET_DEGREE = 173;
|
|
enum EC_F_EC_GROUP_GET_ORDER = 141;
|
|
enum EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS = 193;
|
|
enum EC_F_EC_GROUP_GET_TRINOMIAL_BASIS = 194;
|
|
enum EC_F_EC_GROUP_NEW = 108;
|
|
enum EC_F_EC_GROUP_NEW_BY_CURVE_NAME = 174;
|
|
enum EC_F_EC_GROUP_NEW_FROM_DATA = 175;
|
|
enum EC_F_EC_GROUP_PRECOMPUTE_MULT = 142;
|
|
enum EC_F_EC_GROUP_SET_CURVE_GF2M = 176;
|
|
enum EC_F_EC_GROUP_SET_CURVE_GFP = 109;
|
|
enum EC_F_EC_GROUP_SET_EXTRA_DATA = 110;
|
|
enum EC_F_EC_GROUP_SET_GENERATOR = 111;
|
|
enum EC_F_EC_KEY_CHECK_KEY = 177;
|
|
enum EC_F_EC_KEY_COPY = 178;
|
|
enum EC_F_EC_KEY_GENERATE_KEY = 179;
|
|
enum EC_F_EC_KEY_NEW = 182;
|
|
enum EC_F_EC_KEY_PRINT = 180;
|
|
enum EC_F_EC_KEY_PRINT_FP = 181;
|
|
enum EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES = 229;
|
|
enum EC_F_EC_POINTS_MAKE_AFFINE = 136;
|
|
enum EC_F_EC_POINT_ADD = 112;
|
|
enum EC_F_EC_POINT_CMP = 113;
|
|
enum EC_F_EC_POINT_COPY = 114;
|
|
enum EC_F_EC_POINT_DBL = 115;
|
|
enum EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M = 183;
|
|
enum EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP = 116;
|
|
enum EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP = 117;
|
|
enum EC_F_EC_POINT_INVERT = 210;
|
|
enum EC_F_EC_POINT_IS_AT_INFINITY = 118;
|
|
enum EC_F_EC_POINT_IS_ON_CURVE = 119;
|
|
enum EC_F_EC_POINT_MAKE_AFFINE = 120;
|
|
enum EC_F_EC_POINT_MUL = 184;
|
|
enum EC_F_EC_POINT_NEW = 121;
|
|
enum EC_F_EC_POINT_OCT2POINT = 122;
|
|
enum EC_F_EC_POINT_POINT2OCT = 123;
|
|
enum EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M = 185;
|
|
enum EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP = 124;
|
|
enum EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M = 186;
|
|
enum EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP = 125;
|
|
enum EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP = 126;
|
|
enum EC_F_EC_POINT_SET_TO_INFINITY = 127;
|
|
enum EC_F_EC_PRE_COMP_DUP = 207;
|
|
enum EC_F_EC_PRE_COMP_NEW = 196;
|
|
enum EC_F_EC_WNAF_MUL = 187;
|
|
enum EC_F_EC_WNAF_PRECOMPUTE_MULT = 188;
|
|
enum EC_F_I2D_ECPARAMETERS = 190;
|
|
enum EC_F_I2D_ECPKPARAMETERS = 191;
|
|
enum EC_F_I2D_ECPRIVATEKEY = 192;
|
|
enum EC_F_I2O_ECPUBLICKEY = 151;
|
|
enum EC_F_NISTP224_PRE_COMP_NEW = 227;
|
|
enum EC_F_NISTP256_PRE_COMP_NEW = 236;
|
|
enum EC_F_NISTP521_PRE_COMP_NEW = 237;
|
|
enum EC_F_O2I_ECPUBLICKEY = 152;
|
|
enum EC_F_OLD_EC_PRIV_DECODE = 222;
|
|
enum EC_F_PKEY_EC_CTRL = 197;
|
|
enum EC_F_PKEY_EC_CTRL_STR = 198;
|
|
enum EC_F_PKEY_EC_DERIVE = 217;
|
|
enum EC_F_PKEY_EC_KEYGEN = 199;
|
|
enum EC_F_PKEY_EC_PARAMGEN = 219;
|
|
enum EC_F_PKEY_EC_SIGN = 218;
|
|
|
|
/* Reason codes. */
|
|
enum EC_R_ASN1_ERROR = 115;
|
|
enum EC_R_ASN1_UNKNOWN_FIELD = 116;
|
|
enum EC_R_BIGNUM_OUT_OF_RANGE = 144;
|
|
enum EC_R_BUFFER_TOO_SMALL = 100;
|
|
enum EC_R_COORDINATES_OUT_OF_RANGE = 146;
|
|
enum EC_R_D2I_ECPKPARAMETERS_FAILURE = 117;
|
|
enum EC_R_DECODE_ERROR = 142;
|
|
enum EC_R_DISCRIMINANT_IS_ZERO = 118;
|
|
enum EC_R_EC_GROUP_NEW_BY_NAME_FAILURE = 119;
|
|
enum EC_R_FIELD_TOO_LARGE = 143;
|
|
enum EC_R_GF2M_NOT_SUPPORTED = 147;
|
|
enum EC_R_GROUP2PKPARAMETERS_FAILURE = 120;
|
|
enum EC_R_I2D_ECPKPARAMETERS_FAILURE = 121;
|
|
enum EC_R_INCOMPATIBLE_OBJECTS = 101;
|
|
enum EC_R_INVALID_ARGUMENT = 112;
|
|
enum EC_R_INVALID_COMPRESSED_POINT = 110;
|
|
enum EC_R_INVALID_COMPRESSION_BIT = 109;
|
|
enum EC_R_INVALID_CURVE = 141;
|
|
enum EC_R_INVALID_DIGEST_TYPE = 138;
|
|
enum EC_R_INVALID_ENCODING = 102;
|
|
enum EC_R_INVALID_FIELD = 103;
|
|
enum EC_R_INVALID_FORM = 104;
|
|
enum EC_R_INVALID_GROUP_ORDER = 122;
|
|
enum EC_R_INVALID_PENTANOMIAL_BASIS = 132;
|
|
enum EC_R_INVALID_PRIVATE_KEY = 123;
|
|
enum EC_R_INVALID_TRINOMIAL_BASIS = 137;
|
|
enum EC_R_KEYS_NOT_SET = 140;
|
|
enum EC_R_MISSING_PARAMETERS = 124;
|
|
enum EC_R_MISSING_PRIVATE_KEY = 125;
|
|
enum EC_R_NOT_A_NIST_PRIME = 135;
|
|
enum EC_R_NOT_A_SUPPORTED_NIST_PRIME = 136;
|
|
enum EC_R_NOT_IMPLEMENTED = 126;
|
|
enum EC_R_NOT_INITIALIZED = 111;
|
|
enum EC_R_NO_FIELD_MOD = 133;
|
|
enum EC_R_NO_PARAMETERS_SET = 139;
|
|
enum EC_R_PASSED_NULL_PARAMETER = 134;
|
|
enum EC_R_PKPARAMETERS2GROUP_FAILURE = 127;
|
|
enum EC_R_POINT_AT_INFINITY = 106;
|
|
enum EC_R_POINT_IS_NOT_ON_CURVE = 107;
|
|
enum EC_R_SLOT_FULL = 108;
|
|
enum EC_R_UNDEFINED_GENERATOR = 113;
|
|
enum EC_R_UNDEFINED_ORDER = 128;
|
|
enum EC_R_UNKNOWN_GROUP = 129;
|
|
enum EC_R_UNKNOWN_ORDER = 114;
|
|
enum EC_R_UNSUPPORTED_FIELD = 131;
|
|
enum EC_R_WRONG_CURVE_PARAMETERS = 145;
|
|
enum EC_R_WRONG_ORDER = 130;
|