xref: /freebsd/crypto/openssl/doc/man3/EVP_PKEY_CTX_ctrl.pod (revision cab6a39d7b343596a5823e65c0f7b426551ec22d) 
1=pod
2
3=head1 NAME
4
5EVP_PKEY_CTX_ctrl,
6EVP_PKEY_CTX_ctrl_str,
7EVP_PKEY_CTX_ctrl_uint64,
8EVP_PKEY_CTX_md,
9EVP_PKEY_CTX_set_signature_md,
10EVP_PKEY_CTX_get_signature_md,
11EVP_PKEY_CTX_set_mac_key,
12EVP_PKEY_CTX_set_rsa_padding,
13EVP_PKEY_CTX_get_rsa_padding,
14EVP_PKEY_CTX_set_rsa_pss_saltlen,
15EVP_PKEY_CTX_get_rsa_pss_saltlen,
16EVP_PKEY_CTX_set_rsa_keygen_bits,
17EVP_PKEY_CTX_set_rsa_keygen_pubexp,
18EVP_PKEY_CTX_set_rsa_keygen_primes,
19EVP_PKEY_CTX_set_rsa_mgf1_md,
20EVP_PKEY_CTX_get_rsa_mgf1_md,
21EVP_PKEY_CTX_set_rsa_oaep_md,
22EVP_PKEY_CTX_get_rsa_oaep_md,
23EVP_PKEY_CTX_set0_rsa_oaep_label,
24EVP_PKEY_CTX_get0_rsa_oaep_label,
25EVP_PKEY_CTX_set_dsa_paramgen_bits,
26EVP_PKEY_CTX_set_dsa_paramgen_q_bits,
27EVP_PKEY_CTX_set_dsa_paramgen_md,
28EVP_PKEY_CTX_set_dh_paramgen_prime_len,
29EVP_PKEY_CTX_set_dh_paramgen_subprime_len,
30EVP_PKEY_CTX_set_dh_paramgen_generator,
31EVP_PKEY_CTX_set_dh_paramgen_type,
32EVP_PKEY_CTX_set_dh_rfc5114,
33EVP_PKEY_CTX_set_dhx_rfc5114,
34EVP_PKEY_CTX_set_dh_pad,
35EVP_PKEY_CTX_set_dh_nid,
36EVP_PKEY_CTX_set_dh_kdf_type,
37EVP_PKEY_CTX_get_dh_kdf_type,
38EVP_PKEY_CTX_set0_dh_kdf_oid,
39EVP_PKEY_CTX_get0_dh_kdf_oid,
40EVP_PKEY_CTX_set_dh_kdf_md,
41EVP_PKEY_CTX_get_dh_kdf_md,
42EVP_PKEY_CTX_set_dh_kdf_outlen,
43EVP_PKEY_CTX_get_dh_kdf_outlen,
44EVP_PKEY_CTX_set0_dh_kdf_ukm,
45EVP_PKEY_CTX_get0_dh_kdf_ukm,
46EVP_PKEY_CTX_set_ec_paramgen_curve_nid,
47EVP_PKEY_CTX_set_ec_param_enc,
48EVP_PKEY_CTX_set_ecdh_cofactor_mode,
49EVP_PKEY_CTX_get_ecdh_cofactor_mode,
50EVP_PKEY_CTX_set_ecdh_kdf_type,
51EVP_PKEY_CTX_get_ecdh_kdf_type,
52EVP_PKEY_CTX_set_ecdh_kdf_md,
53EVP_PKEY_CTX_get_ecdh_kdf_md,
54EVP_PKEY_CTX_set_ecdh_kdf_outlen,
55EVP_PKEY_CTX_get_ecdh_kdf_outlen,
56EVP_PKEY_CTX_set0_ecdh_kdf_ukm,
57EVP_PKEY_CTX_get0_ecdh_kdf_ukm,
58EVP_PKEY_CTX_set1_id, EVP_PKEY_CTX_get1_id, EVP_PKEY_CTX_get1_id_len
59- algorithm specific control operations
60
61=head1 SYNOPSIS
62
63 #include <openssl/evp.h>
64
65 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
66                       int cmd, int p1, void *p2);
67 int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
68                              int cmd, uint64_t value);
69 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
70                           const char *value);
71
72 int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);
73
74 int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
75 int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD **pmd);
76
77 int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX *ctx, unsigned char *key, int len);
78
79 #include <openssl/rsa.h>
80
81 int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad);
82 int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad);
83 int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int len);
84 int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *len);
85 int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int mbits);
86 int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
87 int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes);
88 int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
89 int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
90 int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
91 int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
92 int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char *label, int len);
93 int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label);
94
95 #include <openssl/dsa.h>
96
97 int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
98 int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits);
99 int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
100
101 #include <openssl/dh.h>
102
103 int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int len);
104 int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int len);
105 int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
106 int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int type);
107 int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad);
108 int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid);
109 int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int rfc5114);
110 int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int rfc5114);
111 int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
112 int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx);
113 int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid);
114 int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid);
115 int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
116 int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
117 int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
118 int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
119 int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);
120 int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
121
122 #include <openssl/ec.h>
123
124 int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
125 int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX *ctx, int param_enc);
126 int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx, int cofactor_mode);
127 int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx);
128 int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
129 int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX *ctx);
130 int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
131 int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
132 int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
133 int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
134 int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);
135 int EVP_PKEY_CTX_get0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
136
137 int EVP_PKEY_CTX_set1_id(EVP_PKEY_CTX *ctx, void *id, size_t id_len);
138 int EVP_PKEY_CTX_get1_id(EVP_PKEY_CTX *ctx, void *id);
139 int EVP_PKEY_CTX_get1_id_len(EVP_PKEY_CTX *ctx, size_t *id_len);
140
141=head1 DESCRIPTION
142
143The function EVP_PKEY_CTX_ctrl() sends a control operation to the context
144B<ctx>. The key type used must match B<keytype> if it is not -1. The parameter
145B<optype> is a mask indicating which operations the control can be applied to.
146The control command is indicated in B<cmd> and any additional arguments in
147B<p1> and B<p2>.
148
149For B<cmd> = B<EVP_PKEY_CTRL_SET_MAC_KEY>, B<p1> is the length of the MAC key,
150and B<p2> is MAC key. This is used by Poly1305, SipHash, HMAC and CMAC.
151
152Applications will not normally call EVP_PKEY_CTX_ctrl() directly but will
153instead call one of the algorithm specific macros below.
154
155The function EVP_PKEY_CTX_ctrl_uint64() is a wrapper that directly passes a
156uint64 value as B<p2> to EVP_PKEY_CTX_ctrl().
157
158The function EVP_PKEY_CTX_ctrl_str() allows an application to send an algorithm
159specific control operation to a context B<ctx> in string form. This is
160intended to be used for options specified on the command line or in text
161files. The commands supported are documented in the openssl utility
162command line pages for the option B<-pkeyopt> which is supported by the
163B<pkeyutl>, B<genpkey> and B<req> commands.
164
165The function EVP_PKEY_CTX_md() sends a message digest control operation
166to the context B<ctx>. The message digest is specified by its name B<md>.
167
168All the remaining "functions" are implemented as macros.
169
170The EVP_PKEY_CTX_set_signature_md() macro sets the message digest type used
171in a signature. It can be used in the RSA, DSA and ECDSA algorithms.
172
173The EVP_PKEY_CTX_get_signature_md() macro gets the message digest type used in a
174signature. It can be used in the RSA, DSA and ECDSA algorithms.
175
176Key generation typically involves setting up parameters to be used and
177generating the private and public key data. Some algorithm implementations
178allow private key data to be set explicitly using the EVP_PKEY_CTX_set_mac_key()
179macro. In this case key generation is simply the process of setting up the
180parameters for the key and then setting the raw key data to the value explicitly
181provided by that macro. Normally applications would call
182L<EVP_PKEY_new_raw_private_key(3)> or similar functions instead of this macro.
183
184The EVP_PKEY_CTX_set_mac_key() macro can be used with any of the algorithms
185supported by the L<EVP_PKEY_new_raw_private_key(3)> function.
186
187=head2 RSA parameters
188
189The EVP_PKEY_CTX_set_rsa_padding() macro sets the RSA padding mode for B<ctx>.
190The B<pad> parameter can take the value B<RSA_PKCS1_PADDING> for PKCS#1
191padding, B<RSA_SSLV23_PADDING> for SSLv23 padding, B<RSA_NO_PADDING> for
192no padding, B<RSA_PKCS1_OAEP_PADDING> for OAEP padding (encrypt and
193decrypt only), B<RSA_X931_PADDING> for X9.31 padding (signature operations
194only) and B<RSA_PKCS1_PSS_PADDING> (sign and verify only).
195
196Two RSA padding modes behave differently if EVP_PKEY_CTX_set_signature_md()
197is used. If this macro is called for PKCS#1 padding the plaintext buffer is
198an actual digest value and is encapsulated in a DigestInfo structure according
199to PKCS#1 when signing and this structure is expected (and stripped off) when
200verifying. If this control is not used with RSA and PKCS#1 padding then the
201supplied data is used directly and not encapsulated. In the case of X9.31
202padding for RSA the algorithm identifier byte is added or checked and removed
203if this control is called. If it is not called then the first byte of the plaintext
204buffer is expected to be the algorithm identifier byte.
205
206The EVP_PKEY_CTX_get_rsa_padding() macro gets the RSA padding mode for B<ctx>.
207
208The EVP_PKEY_CTX_set_rsa_pss_saltlen() macro sets the RSA PSS salt length to
209B<len>. As its name implies it is only supported for PSS padding. Three special
210values are supported: B<RSA_PSS_SALTLEN_DIGEST> sets the salt length to the
211digest length, B<RSA_PSS_SALTLEN_MAX> sets the salt length to the maximum
212permissible value. When verifying B<RSA_PSS_SALTLEN_AUTO> causes the salt length
213to be automatically determined based on the B<PSS> block structure. If this
214macro is not called maximum salt length is used when signing and auto detection
215when verifying is used by default.
216
217The EVP_PKEY_CTX_get_rsa_pss_saltlen() macro gets the RSA PSS salt length
218for B<ctx>. The padding mode must have been set to B<RSA_PKCS1_PSS_PADDING>.
219
220The EVP_PKEY_CTX_set_rsa_keygen_bits() macro sets the RSA key length for
221RSA key generation to B<bits>. If not specified 1024 bits is used.
222
223The EVP_PKEY_CTX_set_rsa_keygen_pubexp() macro sets the public exponent value
224for RSA key generation to B<pubexp>. Currently it should be an odd integer. The
225B<pubexp> pointer is used internally by this function so it should not be
226modified or freed after the call. If not specified 65537 is used.
227
228The EVP_PKEY_CTX_set_rsa_keygen_primes() macro sets the number of primes for
229RSA key generation to B<primes>. If not specified 2 is used.
230
231The EVP_PKEY_CTX_set_rsa_mgf1_md() macro sets the MGF1 digest for RSA padding
232schemes to B<md>. If not explicitly set the signing digest is used. The
233padding mode must have been set to B<RSA_PKCS1_OAEP_PADDING>
234or B<RSA_PKCS1_PSS_PADDING>.
235
236The EVP_PKEY_CTX_get_rsa_mgf1_md() macro gets the MGF1 digest for B<ctx>.
237If not explicitly set the signing digest is used. The padding mode must have
238been set to B<RSA_PKCS1_OAEP_PADDING> or B<RSA_PKCS1_PSS_PADDING>.
239
240The EVP_PKEY_CTX_set_rsa_oaep_md() macro sets the message digest type used
241in RSA OAEP to B<md>. The padding mode must have been set to
242B<RSA_PKCS1_OAEP_PADDING>.
243
244The EVP_PKEY_CTX_get_rsa_oaep_md() macro gets the message digest type used
245in RSA OAEP to B<md>. The padding mode must have been set to
246B<RSA_PKCS1_OAEP_PADDING>.
247
248The EVP_PKEY_CTX_set0_rsa_oaep_label() macro sets the RSA OAEP label to
249B<label> and its length to B<len>. If B<label> is NULL or B<len> is 0,
250the label is cleared. The library takes ownership of the label so the
251caller should not free the original memory pointed to by B<label>.
252The padding mode must have been set to B<RSA_PKCS1_OAEP_PADDING>.
253
254The EVP_PKEY_CTX_get0_rsa_oaep_label() macro gets the RSA OAEP label to
255B<label>. The return value is the label length. The padding mode
256must have been set to B<RSA_PKCS1_OAEP_PADDING>. The resulting pointer is owned
257by the library and should not be freed by the caller.
258
259=head2 DSA parameters
260
261The EVP_PKEY_CTX_set_dsa_paramgen_bits() macro sets the number of bits used
262for DSA parameter generation to B<nbits>. If not specified, 1024 is used.
263
264The EVP_PKEY_CTX_set_dsa_paramgen_q_bits() macro sets the number of bits in the
265subprime parameter B<q> for DSA parameter generation to B<qbits>. If not
266specified, 160 is used. If a digest function is specified below, this parameter
267is ignored and instead, the number of bits in B<q> matches the size of the
268digest.
269
270The EVP_PKEY_CTX_set_dsa_paramgen_md() macro sets the digest function used for
271DSA parameter generation to B<md>. If not specified, one of SHA-1, SHA-224, or
272SHA-256 is selected to match the bit length of B<q> above.
273
274=head2 DH parameters
275
276The EVP_PKEY_CTX_set_dh_paramgen_prime_len() macro sets the length of the DH
277prime parameter B<p> for DH parameter generation. If this macro is not called
278then 1024 is used. Only accepts lengths greater than or equal to 256.
279
280The EVP_PKEY_CTX_set_dh_paramgen_subprime_len() macro sets the length of the DH
281optional subprime parameter B<q> for DH parameter generation. The default is
282256 if the prime is at least 2048 bits long or 160 otherwise. The DH
283paramgen type must have been set to x9.42.
284
285The EVP_PKEY_CTX_set_dh_paramgen_generator() macro sets DH generator to B<gen>
286for DH parameter generation. If not specified 2 is used.
287
288The EVP_PKEY_CTX_set_dh_paramgen_type() macro sets the key type for DH
289parameter generation. Use 0 for PKCS#3 DH and 1 for X9.42 DH.
290The default is 0.
291
292The EVP_PKEY_CTX_set_dh_pad() macro sets the DH padding mode. If B<pad> is
2931 the shared secret is padded with zeros up to the size of the DH prime B<p>.
294If B<pad> is zero (the default) then no padding is performed.
295
296EVP_PKEY_CTX_set_dh_nid() sets the DH parameters to values corresponding to
297B<nid> as defined in RFC7919. The B<nid> parameter must be B<NID_ffdhe2048>,
298B<NID_ffdhe3072>, B<NID_ffdhe4096>, B<NID_ffdhe6144>, B<NID_ffdhe8192>
299or B<NID_undef> to clear the stored value. This macro can be called during
300parameter or key generation.
301The nid parameter and the rfc5114 parameter are mutually exclusive.
302
303The EVP_PKEY_CTX_set_dh_rfc5114() and EVP_PKEY_CTX_set_dhx_rfc5114() macros are
304synonymous. They set the DH parameters to the values defined in RFC5114. The
305B<rfc5114> parameter must be 1, 2 or 3 corresponding to RFC5114 sections
3062.1, 2.2 and 2.3. or 0 to clear the stored value. This macro can be called
307during parameter generation. The B<ctx> must have a key type of
308B<EVP_PKEY_DHX>.
309The rfc5114 parameter and the nid parameter are mutually exclusive.
310
311=head2 DH key derivation function parameters
312
313Note that all of the following functions require that the B<ctx> parameter has
314a private key type of B<EVP_PKEY_DHX>. When using key derivation, the output of
315EVP_PKEY_derive() is the output of the KDF instead of the DH shared secret.
316The KDF output is typically used as a Key Encryption Key (KEK) that in turn
317encrypts a Content Encryption Key (CEK).
318
319The EVP_PKEY_CTX_set_dh_kdf_type() macro sets the key derivation function type
320to B<kdf> for DH key derivation. Possible values are B<EVP_PKEY_DH_KDF_NONE>
321and B<EVP_PKEY_DH_KDF_X9_42> which uses the key derivation specified in RFC2631
322(based on the keying algorithm described in X9.42). When using key derivation,
323the B<kdf_oid>, B<kdf_md> and B<kdf_outlen> parameters must also be specified.
324
325The EVP_PKEY_CTX_get_dh_kdf_type() macro gets the key derivation function type
326for B<ctx> used for DH key derivation. Possible values are B<EVP_PKEY_DH_KDF_NONE>
327and B<EVP_PKEY_DH_KDF_X9_42>.
328
329The EVP_PKEY_CTX_set0_dh_kdf_oid() macro sets the key derivation function
330object identifier to B<oid> for DH key derivation. This OID should identify
331the algorithm to be used with the Content Encryption Key.
332The library takes ownership of the object identifier so the caller should not
333free the original memory pointed to by B<oid>.
334
335The EVP_PKEY_CTX_get0_dh_kdf_oid() macro gets the key derivation function oid
336for B<ctx> used for DH key derivation. The resulting pointer is owned by the
337library and should not be freed by the caller.
338
339The EVP_PKEY_CTX_set_dh_kdf_md() macro sets the key derivation function
340message digest to B<md> for DH key derivation. Note that RFC2631 specifies
341that this digest should be SHA1 but OpenSSL tolerates other digests.
342
343The EVP_PKEY_CTX_get_dh_kdf_md() macro gets the key derivation function
344message digest for B<ctx> used for DH key derivation.
345
346The EVP_PKEY_CTX_set_dh_kdf_outlen() macro sets the key derivation function
347output length to B<len> for DH key derivation.
348
349The EVP_PKEY_CTX_get_dh_kdf_outlen() macro gets the key derivation function
350output length for B<ctx> used for DH key derivation.
351
352The EVP_PKEY_CTX_set0_dh_kdf_ukm() macro sets the user key material to
353B<ukm> and its length to B<len> for DH key derivation. This parameter is optional
354and corresponds to the partyAInfo field in RFC2631 terms. The specification
355requires that it is 512 bits long but this is not enforced by OpenSSL.
356The library takes ownership of the user key material so the caller should not
357free the original memory pointed to by B<ukm>.
358
359The EVP_PKEY_CTX_get0_dh_kdf_ukm() macro gets the user key material for B<ctx>.
360The return value is the user key material length. The resulting pointer is owned
361by the library and should not be freed by the caller.
362
363=head2 EC parameters
364
365The EVP_PKEY_CTX_set_ec_paramgen_curve_nid() sets the EC curve for EC parameter
366generation to B<nid>. For EC parameter generation this macro must be called
367or an error occurs because there is no default curve.
368This function can also be called to set the curve explicitly when
369generating an EC key.
370
371The EVP_PKEY_CTX_set_ec_param_enc() macro sets the EC parameter encoding to
372B<param_enc> when generating EC parameters or an EC key. The encoding can be
373B<OPENSSL_EC_EXPLICIT_CURVE> for explicit parameters (the default in versions
374of OpenSSL before 1.1.0) or B<OPENSSL_EC_NAMED_CURVE> to use named curve form.
375For maximum compatibility the named curve form should be used. Note: the
376B<OPENSSL_EC_NAMED_CURVE> value was added in OpenSSL 1.1.0; previous
377versions should use 0 instead.
378
379=head2 ECDH parameters
380
381The EVP_PKEY_CTX_set_ecdh_cofactor_mode() macro sets the cofactor mode to
382B<cofactor_mode> for ECDH key derivation. Possible values are 1 to enable
383cofactor key derivation, 0 to disable it and -1 to clear the stored cofactor
384mode and fallback to the private key cofactor mode.
385
386The EVP_PKEY_CTX_get_ecdh_cofactor_mode() macro returns the cofactor mode for
387B<ctx> used for ECDH key derivation. Possible values are 1 when cofactor key
388derivation is enabled and 0 otherwise.
389
390=head2 ECDH key derivation function parameters
391
392The EVP_PKEY_CTX_set_ecdh_kdf_type() macro sets the key derivation function type
393to B<kdf> for ECDH key derivation. Possible values are B<EVP_PKEY_ECDH_KDF_NONE>
394and B<EVP_PKEY_ECDH_KDF_X9_63> which uses the key derivation specified in X9.63.
395When using key derivation, the B<kdf_md> and B<kdf_outlen> parameters must
396also be specified.
397
398The EVP_PKEY_CTX_get_ecdh_kdf_type() macro returns the key derivation function
399type for B<ctx> used for ECDH key derivation. Possible values are
400B<EVP_PKEY_ECDH_KDF_NONE> and B<EVP_PKEY_ECDH_KDF_X9_63>.
401
402The EVP_PKEY_CTX_set_ecdh_kdf_md() macro sets the key derivation function
403message digest to B<md> for ECDH key derivation. Note that X9.63 specifies
404that this digest should be SHA1 but OpenSSL tolerates other digests.
405
406The EVP_PKEY_CTX_get_ecdh_kdf_md() macro gets the key derivation function
407message digest for B<ctx> used for ECDH key derivation.
408
409The EVP_PKEY_CTX_set_ecdh_kdf_outlen() macro sets the key derivation function
410output length to B<len> for ECDH key derivation.
411
412The EVP_PKEY_CTX_get_ecdh_kdf_outlen() macro gets the key derivation function
413output length for B<ctx> used for ECDH key derivation.
414
415The EVP_PKEY_CTX_set0_ecdh_kdf_ukm() macro sets the user key material to B<ukm>
416for ECDH key derivation. This parameter is optional and corresponds to the
417shared info in X9.63 terms. The library takes ownership of the user key material
418so the caller should not free the original memory pointed to by B<ukm>.
419
420The EVP_PKEY_CTX_get0_ecdh_kdf_ukm() macro gets the user key material for B<ctx>.
421The return value is the user key material length. The resulting pointer is owned
422by the library and should not be freed by the caller.
423
424=head2 Other parameters
425
426The EVP_PKEY_CTX_set1_id(), EVP_PKEY_CTX_get1_id() and EVP_PKEY_CTX_get1_id_len()
427macros are used to manipulate the special identifier field for specific signature
428algorithms such as SM2. The EVP_PKEY_CTX_set1_id() sets an ID pointed by B<id> with
429the length B<id_len> to the library. The library takes a copy of the id so that
430the caller can safely free the original memory pointed to by B<id>. The
431EVP_PKEY_CTX_get1_id_len() macro returns the length of the ID set via a previous
432call to EVP_PKEY_CTX_set1_id(). The length is usually used to allocate adequate
433memory for further calls to EVP_PKEY_CTX_get1_id(). The EVP_PKEY_CTX_get1_id()
434macro returns the previously set ID value to caller in B<id>. The caller should
435allocate adequate memory space for the B<id> before calling EVP_PKEY_CTX_get1_id().
436
437=head1 RETURN VALUES
438
439EVP_PKEY_CTX_ctrl() and its macros return a positive value for success and 0
440or a negative value for failure. In particular a return value of -2
441indicates the operation is not supported by the public key algorithm.
442
443=head1 SEE ALSO
444
445L<EVP_PKEY_CTX_new(3)>,
446L<EVP_PKEY_encrypt(3)>,
447L<EVP_PKEY_decrypt(3)>,
448L<EVP_PKEY_sign(3)>,
449L<EVP_PKEY_verify(3)>,
450L<EVP_PKEY_verify_recover(3)>,
451L<EVP_PKEY_derive(3)>,
452L<EVP_PKEY_keygen(3)>
453
454=head1 HISTORY
455
456The
457EVP_PKEY_CTX_set1_id(), EVP_PKEY_CTX_get1_id() and EVP_PKEY_CTX_get1_id_len()
458macros were added in 1.1.1, other functions were added in OpenSSL 1.0.0.
459
460=head1 COPYRIGHT
461
462Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
463
464Licensed under the OpenSSL license (the "License").  You may not use
465this file except in compliance with the License.  You can obtain a copy
466in the file LICENSE in the source distribution or at
467L<https://www.openssl.org/source/license.html>.
468
469=cut
470