doc/man3/EC_KEY_new.pod

   1 =pod
   2
   3 =head1 NAME
   4
   5 EVP_EC_gen,
   6 EC_KEY_get_method, EC_KEY_set_method, EC_KEY_new_ex,
   7 EC_KEY_new, EC_KEY_get_flags, EC_KEY_set_flags, EC_KEY_clear_flags,
   8 EC_KEY_new_by_curve_name_ex, EC_KEY_new_by_curve_name, EC_KEY_free,
   9 EC_KEY_copy, EC_KEY_dup, EC_KEY_up_ref, EC_KEY_get0_engine,
  10 EC_KEY_get0_group, EC_KEY_set_group, EC_KEY_get0_private_key,
  11 EC_KEY_set_private_key, EC_KEY_get0_public_key, EC_KEY_set_public_key,
  12 EC_KEY_get_conv_form,
  13 EC_KEY_set_conv_form, EC_KEY_set_asn1_flag,
  14 EC_KEY_decoded_from_explicit_params, EC_KEY_precompute_mult,
  15 EC_KEY_generate_key, EC_KEY_check_key, EC_KEY_set_public_key_affine_coordinates,
  16 EC_KEY_oct2key, EC_KEY_key2buf, EC_KEY_oct2priv, EC_KEY_priv2oct,
  17 EC_KEY_priv2buf - Functions for creating, destroying and manipulating
  18 EC_KEY objects
  19
  20 =head1 SYNOPSIS
  21
  22  #include <openssl/ec.h>
  23
  24  EVP_PKEY *EVP_EC_gen(const char *curve);
  25
  26 The following functions have been deprecated since OpenSSL 3.0, and can be
  27 hidden entirely by defining B<OPENSSL_API_COMPAT> with a suitable version value,
  28 see L<openssl_user_macros(7)>:
  29
  30  EC_KEY *EC_KEY_new_ex(OSSL_LIB_CTX *ctx, const char *propq);
  31  EC_KEY *EC_KEY_new(void);
  32  int EC_KEY_get_flags(const EC_KEY *key);
  33  void EC_KEY_set_flags(EC_KEY *key, int flags);
  34  void EC_KEY_clear_flags(EC_KEY *key, int flags);
  35  EC_KEY *EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX *ctx, const char *propq,
  36                                      int nid);
  37  EC_KEY *EC_KEY_new_by_curve_name(int nid);
  38  void EC_KEY_free(EC_KEY *key);
  39  EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
  40  EC_KEY *EC_KEY_dup(const EC_KEY *src);
  41  int EC_KEY_up_ref(EC_KEY *key);
  42  ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey);
  43  const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
  44  int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
  45  const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
  46  int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key);
  47  const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
  48  int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
  49  point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
  50  void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform);
  51  void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
  52  int EC_KEY_decoded_from_explicit_params(const EC_KEY *key);
  53  int EC_KEY_generate_key(EC_KEY *key);
  54  int EC_KEY_check_key(const EC_KEY *key);
  55  int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y);
  56  const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
  57  int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
  58
  59  int EC_KEY_oct2key(EC_KEY *eckey, const unsigned char *buf, size_t len, BN_CTX *ctx);
  60  size_t EC_KEY_key2buf(const EC_KEY *eckey, point_conversion_form_t form,
  61                        unsigned char **pbuf, BN_CTX *ctx);
  62
  63  int EC_KEY_oct2priv(EC_KEY *eckey, const unsigned char *buf, size_t len);
  64  size_t EC_KEY_priv2oct(const EC_KEY *eckey, unsigned char *buf, size_t len);
  65
  66  size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf);
  67  int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
  68
  69 =head1 DESCRIPTION
  70
  71 EVP_EC_gen() generates a new EC key pair on the given I<curve>.
  72
  73 All of the functions described below are deprecated.
  74 Applications should instead use EVP_EC_gen(), L<EVP_PKEY_Q_keygen(3)>, or
  75 L<EVP_PKEY_keygen_init(3)> and L<EVP_PKEY_keygen(3)>.
  76
  77 An EC_KEY represents a public key and, optionally, the associated private
  78 key.
  79 A new EC_KEY with no associated curve can be constructed by calling
  80 EC_KEY_new_ex() and specifying the associated library context in I<ctx>
  81 (see L<OSSL_LIB_CTX(3)>) and property query string I<propq>.
  82 The I<ctx> parameter may be NULL in which case the default library context is
  83 used.
  84 The reference count for the newly created EC_KEY is initially
  85 set to 1.
  86 A curve can be associated with the EC_KEY by calling
  87 EC_KEY_set_group().
  88
  89 EC_KEY_new() is the same as EC_KEY_new_ex() except that the default library
  90 context is always used.
  91
  92 Alternatively a new EC_KEY can be constructed by calling
  93 EC_KEY_new_by_curve_name_ex() and supplying the nid of the associated
  94 curve, the library context to be used I<ctx> (see L<OSSL_LIB_CTX(3)>) and any
  95 property query string I<propq>.
  96 The I<ctx> parameter may be NULL in which case the default library context is
  97 used. The I<propq> value may also be NULL.
  98 See L<EC_GROUP_new(3)> for a description of curve names.
  99 This function simply wraps calls to EC_KEY_new_ex() and
 100 EC_GROUP_new_by_curve_name_ex().
 101
 102 EC_KEY_new_by_curve_name() is the same as EC_KEY_new_by_curve_name_ex()
 103 except that the default library context is always used and a NULL property query
 104 string.
 105
 106 Calling EC_KEY_free() decrements the reference count for the EC_KEY object,
 107 and if it has dropped to zero then frees the memory associated with it.  If
 108 I<key> is NULL nothing is done.
 109
 110 EC_KEY_copy() copies the contents of the EC_KEY in I<src> into I<dest>.
 111
 112 EC_KEY_dup() creates a new EC_KEY object and copies I<ec_key> into it.
 113
 114 EC_KEY_up_ref() increments the reference count associated with the EC_KEY
 115 object.
 116
 117 EC_KEY_get0_engine() returns a handle to the ENGINE that has been set for
 118 this EC_KEY object.
 119
 120 EC_KEY_generate_key() generates a new public and private key for the supplied
 121 I<eckey> object. I<eckey> must have an EC_GROUP object associated with it
 122 before calling this function. The private key is a random integer (0 < priv_key
 123 < order, where I<order> is the order of the EC_GROUP object). The public key is
 124 an EC_POINT on the curve calculated by multiplying the generator for the
 125 curve by the private key.
 126
 127 EC_KEY_check_key() performs various sanity checks on the EC_KEY object to
 128 confirm that it is valid.
 129
 130 EC_KEY_set_public_key_affine_coordinates() sets the public key for I<key> based
 131 on its affine coordinates; i.e., it constructs an EC_POINT object based on
 132 the supplied I<x> and I<y> values and sets the public key to be this
 133 EC_POINT. It also performs certain sanity checks on the key to confirm
 134 that it is valid.
 135
 136 The functions EC_KEY_get0_group(), EC_KEY_set_group(),
 137 EC_KEY_get0_private_key(), EC_KEY_set_private_key(), EC_KEY_get0_public_key(),
 138 and EC_KEY_set_public_key() get and set the EC_GROUP object, the private key,
 139 and the EC_POINT public key for the B<key> respectively. The function
 140 EC_KEY_set_private_key() accepts NULL as the priv_key argument to securely clear
 141 the private key component from the EC_KEY.
 142
 143 The functions EC_KEY_get_conv_form() and EC_KEY_set_conv_form() get and set the
 144 point_conversion_form for the I<key>. For a description of
 145 point_conversion_forms please see L<EC_POINT_new(3)>.
 146
 147 EC_KEY_set_flags() sets the flags in the I<flags> parameter on the EC_KEY
 148 object. Any flags that are already set are left set. The flags currently
 149 defined are EC_FLAG_NON_FIPS_ALLOW and EC_FLAG_FIPS_CHECKED. In
 150 addition there is the flag EC_FLAG_COFACTOR_ECDH which is specific to ECDH.
 151 EC_KEY_get_flags() returns the current flags that are set for this EC_KEY.
 152 EC_KEY_clear_flags() clears the flags indicated by the I<flags> parameter; all
 153 other flags are left in their existing state.
 154
 155 EC_KEY_set_asn1_flag() sets the asn1_flag on the underlying EC_GROUP object
 156 (if set). Refer to L<EC_GROUP_copy(3)> for further information on the
 157 asn1_flag.
 158
 159 EC_KEY_decoded_from_explicit_params() returns 1 if the group of the I<key> was
 160 decoded from data with explicitly encoded group parameters, -1 if the I<key>
 161 is NULL or the group parameters are missing, and 0 otherwise.
 162
 163 EC_KEY_precompute_mult() stores multiples of the underlying EC_GROUP generator
 164 for faster point multiplication. See also L<EC_POINT_add(3)>.
 165 Modern versions should instead switch to named curves which OpenSSL has
 166 hardcoded lookup tables for.
 167
 168 EC_KEY_oct2key() and EC_KEY_key2buf() are identical to the functions
 169 EC_POINT_oct2point() and EC_POINT_point2buf() except they use the public key
 170 EC_POINT in I<eckey>.
 171
 172 EC_KEY_oct2priv() and EC_KEY_priv2oct() convert between the private key
 173 component of I<eckey> and octet form. The octet form consists of the content
 174 octets of the I<privateKey> OCTET STRING in an I<ECPrivateKey> ASN.1 structure.
 175
 176 The function EC_KEY_priv2oct() must be supplied with a buffer long enough to
 177 store the octet form. The return value provides the number of octets stored.
 178 Calling the function with a NULL buffer will not perform the conversion but
 179 will just return the required buffer length.
 180
 181 The function EC_KEY_priv2buf() allocates a buffer of suitable length and writes
 182 an EC_KEY to it in octet format. The allocated buffer is written to I<*pbuf>
 183 and its length is returned. The caller must free up the allocated buffer with a
 184 call to OPENSSL_free(). Since the allocated buffer value is written to I<*pbuf>
 185 the I<pbuf> parameter B<MUST NOT> be B<NULL>.
 186
 187 EC_KEY_priv2buf() converts an EC_KEY private key into an allocated buffer.
 188
 189 =head1 RETURN VALUES
 190
 191 EC_KEY_new_ex(), EC_KEY_new(), EC_KEY_new_by_curve_name_ex(),
 192 EC_KEY_new_by_curve_name() and EC_KEY_dup() return a pointer to the newly
 193 created EC_KEY object, or NULL on error.
 194
 195 EC_KEY_get_flags() returns the flags associated with the EC_KEY object as an
 196 integer.
 197
 198 EC_KEY_copy() returns a pointer to the destination key, or NULL on error.
 199
 200 EC_KEY_get0_engine() returns a pointer to an ENGINE, or NULL if it wasn't set.
 201
 202 EC_KEY_up_ref(), EC_KEY_set_group(), EC_KEY_set_public_key(),
 203 EC_KEY_precompute_mult(), EC_KEY_generate_key(), EC_KEY_check_key(),
 204 EC_KEY_set_public_key_affine_coordinates(), EC_KEY_oct2key() and
 205 EC_KEY_oct2priv() return 1 on success or 0 on error.
 206
 207 EC_KEY_set_private_key() returns 1 on success or 0 on error except when the
 208 priv_key argument is NULL, in that case it returns 0, for legacy compatibility,
 209 and should not be treated as an error.
 210
 211 EC_KEY_get0_group() returns the EC_GROUP associated with the EC_KEY.
 212
 213 EC_KEY_get0_private_key() returns the private key associated with the EC_KEY.
 214
 215 EC_KEY_get_conv_form() return the point_conversion_form for the EC_KEY.
 216
 217 EC_KEY_key2buf(), EC_KEY_priv2oct() and EC_KEY_priv2buf() return the length
 218 of the buffer or 0 on error.
 219
 220 =head1 SEE ALSO
 221
 222 L<EVP_PKEY_Q_keygen(3)>
 223 L<crypto(7)>, L<EC_GROUP_new(3)>,
 224 L<EC_GROUP_copy(3)>, L<EC_POINT_new(3)>,
 225 L<EC_POINT_add(3)>,
 226 L<EC_GFp_simple_method(3)>,
 227 L<d2i_ECPKParameters(3)>,
 228 L<OSSL_LIB_CTX(3)>
 229
 230 =head1 HISTORY
 231
 232 EVP_EC_gen() was added in OpenSSL 3.0.
 233 All other functions described here were deprecated in OpenSSL 3.0.
 234 For replacement see L<EVP_PKEY-EC(7)>.
 235
 236 =head1 COPYRIGHT
 237
 238 Copyright 2013-2023 The OpenSSL Project Authors. All Rights Reserved.
 239
 240 Licensed under the Apache License 2.0 (the "License").  You may not use
 241 this file except in compliance with the License.  You can obtain a copy
 242 in the file LICENSE in the source distribution or at
 243 L<https://www.openssl.org/source/license.html>.
 244
 245 =cut