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