Add EVP_KDF-X942 to the fips module
[openssl.git] / crypto / dh / dh_ctrl.c
1 /*
2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * DH low level APIs are deprecated for public use, but still ok for
12  * internal use.
13  */
14 #include "internal/deprecated.h"
15
16 #include <stdio.h>
17 #include "crypto/evp.h"
18 #include <openssl/bn.h>
19 #include <openssl/engine.h>
20 #include <openssl/obj_mac.h>
21 #include <openssl/core_names.h>
22 #include "internal/cryptlib.h"
23 #include "internal/refcount.h"
24 #include "crypto/dh.h"
25 #include "dh_local.h"
26
27 static int dh_paramgen_check(EVP_PKEY_CTX *ctx)
28 {
29     if (ctx == NULL || !EVP_PKEY_CTX_IS_GEN_OP(ctx)) {
30         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
31         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
32         return -2;
33     }
34     /* If key type not DH return error */
35     if (ctx->pmeth != NULL
36         && ctx->pmeth->pkey_id != EVP_PKEY_DH
37         && ctx->pmeth->pkey_id != EVP_PKEY_DHX)
38         return -1;
39     return 1;
40 }
41
42 static int dh_param_derive_check(EVP_PKEY_CTX *ctx)
43 {
44     if (ctx == NULL || !EVP_PKEY_CTX_IS_DERIVE_OP(ctx)) {
45         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
46         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
47         return -2;
48     }
49     /* If key type not DH return error */
50     if (ctx->pmeth != NULL
51         && ctx->pmeth->pkey_id != EVP_PKEY_DH
52         && ctx->pmeth->pkey_id != EVP_PKEY_DHX)
53         return -1;
54     return 1;
55 }
56
57 int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex)
58 {
59     int ret;
60     OSSL_PARAM params[2], *p = params;
61
62     if ((ret = dh_paramgen_check(ctx)) <= 0)
63         return ret;
64
65     *p++ = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX, &gindex);
66     *p = OSSL_PARAM_construct_end();
67
68     return EVP_PKEY_CTX_set_params(ctx, params);
69 }
70
71 int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
72                                       const unsigned char *seed,
73                                       size_t seedlen)
74 {
75     int ret;
76     OSSL_PARAM params[2], *p = params;
77
78     if ((ret = dh_paramgen_check(ctx)) <= 0)
79         return ret;
80
81     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
82                                              (void *)seed, seedlen);
83     *p = OSSL_PARAM_construct_end();
84
85     return EVP_PKEY_CTX_set_params(ctx, params);
86 }
87
88 int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int typ)
89 {
90     int ret;
91     OSSL_PARAM params[2], *p = params;
92     const char *name;
93
94     if ((ret = dh_paramgen_check(ctx)) <= 0)
95         return ret;
96
97     /* TODO(3.0): Remove this eventually when no more legacy */
98     if (ctx->op.keymgmt.genctx == NULL)
99         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
100                                  EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, typ, NULL);
101
102     name = dh_gen_type_id2name(typ);
103     if (name == NULL)
104         return 0;
105     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
106                                             (char *) name, 0);
107     *p = OSSL_PARAM_construct_end();
108
109     return EVP_PKEY_CTX_set_params(ctx, params);
110 }
111
112 int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int pbits)
113 {
114     int ret;
115     OSSL_PARAM params[2], *p = params;
116     size_t bits = pbits;
117
118     if ((ret = dh_paramgen_check(ctx)) <= 0)
119         return ret;
120
121     /* TODO(3.0): Remove this eventually when no more legacy */
122     if (ctx->op.keymgmt.genctx == NULL)
123         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
124                                  EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, pbits,
125                                  NULL);
126     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_FFC_PBITS, &bits);
127     *p = OSSL_PARAM_construct_end();
128     return EVP_PKEY_CTX_set_params(ctx, params);
129 }
130
131 int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int qbits)
132 {
133     int ret;
134     OSSL_PARAM params[2], *p = params;
135     size_t bits2 = qbits;
136
137     if ((ret = dh_paramgen_check(ctx)) <= 0)
138         return ret;
139
140     /* TODO(3.0): Remove this eventually when no more legacy */
141     if (ctx->op.keymgmt.genctx == NULL)
142         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
143                                  EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, qbits,
144                                  NULL);
145     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_FFC_QBITS, &bits2);
146     *p = OSSL_PARAM_construct_end();
147
148     return EVP_PKEY_CTX_set_params(ctx, params);
149 }
150
151 int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen)
152 {
153     int ret;
154     OSSL_PARAM params[2], *p = params;
155
156     if ((ret = dh_paramgen_check(ctx)) <= 0)
157         return ret;
158
159     /* TODO(3.0): Remove this eventually when no more legacy */
160     if (ctx->op.keymgmt.genctx == NULL)
161         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN,
162                                  EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL);
163     *p++ = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_DH_GENERATOR, &gen);
164     *p = OSSL_PARAM_construct_end();
165
166     return EVP_PKEY_CTX_set_params(ctx, params);
167 }
168
169 int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int gen)
170 {
171     int ret;
172     OSSL_PARAM params[2], *p = params;
173     const char *name;
174
175     if ((ret = dh_paramgen_check(ctx)) <= 0)
176         return ret;
177
178     /* TODO(3.0): Remove this eventually when no more legacy */
179     if (ctx->op.keymgmt.genctx == NULL)
180         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN,
181                                  EVP_PKEY_CTRL_DH_RFC5114, gen, NULL);
182     name = ossl_ffc_named_group_from_uid(gen);
183     if (name == NULL)
184         return 0;
185
186     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
187                                             (void *)name, 0);
188     *p = OSSL_PARAM_construct_end();
189     return EVP_PKEY_CTX_set_params(ctx, params);
190 }
191
192 int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int gen)
193 {
194     return EVP_PKEY_CTX_set_dh_rfc5114(ctx, gen);
195 }
196
197 int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid)
198 {
199     int ret;
200     OSSL_PARAM params[2], *p = params;
201     const char *name;
202
203     if ((ret = dh_paramgen_check(ctx)) <= 0)
204         return ret;
205
206     /* TODO(3.0): Remove this eventually when no more legacy */
207     if (ctx->op.keymgmt.genctx == NULL)
208         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH,
209                                  EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
210                                  EVP_PKEY_CTRL_DH_NID, nid, NULL);
211     name = ossl_ffc_named_group_from_uid(nid);
212     if (name == NULL)
213         return 0;
214
215     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
216                                             (void *)name, 0);
217     *p = OSSL_PARAM_construct_end();
218     return EVP_PKEY_CTX_set_params(ctx, params);
219 }
220
221 int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf)
222 {
223     int ret;
224     const char *kdf_type;
225     OSSL_PARAM params[2], *p = params;
226
227     ret = dh_param_derive_check(ctx);
228     if (ret != 1)
229         return ret;
230
231     /* TODO(3.0): Remove this eventually when no more legacy */
232     if (ctx->op.kex.exchprovctx == NULL)
233         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
234                                  EVP_PKEY_CTRL_DH_KDF_TYPE, kdf, NULL);
235     switch (kdf) {
236         case EVP_PKEY_DH_KDF_NONE:
237             kdf_type = "";
238             break;
239         case EVP_PKEY_DH_KDF_X9_42:
240             kdf_type = OSSL_KDF_NAME_X942KDF_ASN1;
241             break;
242         default:
243             return -2;
244     }
245     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
246                                             /*
247                                              * Cast away the const. This is read
248                                              * only so should be safe
249                                              */
250                                             (char *)kdf_type, 0);
251     *p = OSSL_PARAM_construct_end();
252
253     ret = evp_pkey_ctx_set_params_strict(ctx, params);
254     if (ret == -2) {
255         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
256         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
257         return -2;
258     }
259
260     return ret;
261 }
262
263 int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx)
264 {
265     int ret;
266     char kdf_type[80]; /* 80 should be big enough */
267     OSSL_PARAM params[2], *p = params;
268
269     ret = dh_param_derive_check(ctx);
270     if (ret != 1)
271         return ret;
272
273     /* TODO(3.0): Remove this eventually when no more legacy */
274     if (ctx->op.kex.exchprovctx == NULL)
275         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
276                                  EVP_PKEY_CTRL_DH_KDF_TYPE, -2, NULL);
277     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
278                                             kdf_type, sizeof(kdf_type));
279     *p = OSSL_PARAM_construct_end();
280
281     ret = evp_pkey_ctx_get_params_strict(ctx, params);
282     if (ret == -2) {
283         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
284         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
285         return -2;
286     } else if (ret != 1) {
287         return -1;
288     }
289
290     if (kdf_type[0] == '\0')
291         return EVP_PKEY_DH_KDF_NONE;
292     else if (strcmp(kdf_type, OSSL_KDF_NAME_X942KDF_ASN1) == 0)
293         return EVP_PKEY_DH_KDF_X9_42;
294
295     return -1;
296 }
297
298 int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid)
299 {
300     int ret;
301     OSSL_PARAM params[2], *p = params;
302     const char *oid_name;
303
304     ret = dh_param_derive_check(ctx);
305     if (ret != 1)
306         return ret;
307
308     /* TODO(3.0): Remove this eventually when no more legacy */
309     if (ctx->op.kex.exchprovctx == NULL)
310         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
311                                  EVP_PKEY_CTRL_DH_KDF_OID, 0, (void *)(oid));
312     oid_name = OBJ_nid2sn(OBJ_obj2nid(oid));
313
314     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
315                                             (char *)oid_name, 0);
316     *p = OSSL_PARAM_construct_end();
317     ret = evp_pkey_ctx_set_params_strict(ctx, params);
318     if (ret == -2) {
319         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
320         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
321         return -2;
322     }
323
324     return ret;
325 }
326
327 int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid)
328 {
329     int ret, nid;
330     OSSL_PARAM params[2], *p = params;
331     char oid_name[80]; /* 80 should be big enough */
332
333     ret = dh_param_derive_check(ctx);
334     if (ret != 1)
335         return ret;
336
337     /* TODO(3.0): Remove this eventually when no more legacy */
338     if (ctx->op.kex.exchprovctx == NULL)
339         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
340                                  EVP_PKEY_CTRL_GET_DH_KDF_OID, 0, (void *)(oid));
341     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
342                                             oid_name, sizeof(oid_name));
343     *p = OSSL_PARAM_construct_end();
344
345     ret = evp_pkey_ctx_get_params_strict(ctx, params);
346     if (ret == -2) {
347         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
348         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
349         return -2;
350     } else if (ret != 1) {
351         return -1;
352     }
353     nid = OBJ_sn2nid(oid_name);
354     if (nid == NID_undef)
355         nid = OBJ_ln2nid(oid_name);
356     *oid = (nid == NID_undef ? NULL : OBJ_nid2obj(nid));
357     return *oid != NULL;
358 }
359
360 int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
361 {
362     int ret;
363     OSSL_PARAM params[2], *p = params;
364     const char *md_name = NULL;
365
366     ret = dh_param_derive_check(ctx);
367     if (ret != 1)
368         return ret;
369
370     /* TODO(3.0): Remove this eventually when no more legacy */
371     if (ctx->op.kex.exchprovctx == NULL)
372         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
373                                  EVP_PKEY_CTRL_DH_KDF_MD, 0, (void *)(md));
374     md_name = (md == NULL) ? "" : EVP_MD_name(md);
375
376     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
377                                             /*
378                                              * Cast away the const. This is read
379                                              * only so should be safe
380                                              */
381                                             (char *)md_name, 0);
382     *p = OSSL_PARAM_construct_end();
383
384     ret = evp_pkey_ctx_set_params_strict(ctx, params);
385     if (ret == -2) {
386         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
387         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
388         return -2;
389     }
390     return ret;
391 }
392
393 int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **pmd)
394 {
395     int ret;
396     char name[80] = "";  /* 80 should be big enough */
397     OSSL_PARAM params[2], *p = params;
398
399     ret = dh_param_derive_check(ctx);
400     if (ret != 1)
401         return ret;
402
403     /* TODO(3.0): Remove this eventually when no more legacy */
404     if (ctx->op.kex.exchprovctx == NULL)
405         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
406                                  EVP_PKEY_CTRL_GET_DH_KDF_MD, 0, (void *)(pmd));
407     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
408                                             name, sizeof(name));
409     *p = OSSL_PARAM_construct_end();
410
411     ret = evp_pkey_ctx_get_params_strict(ctx, params);
412     if (ret == -2) {
413         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
414         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
415         return -2;
416     } else if (ret != 1) {
417         return -1;
418     }
419
420     /* May be NULL meaning "unknown" */
421     *pmd = EVP_get_digestbyname(name);
422
423     return 1;
424 }
425
426 int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int inlen)
427 {
428     int ret;
429     size_t len = inlen;
430     OSSL_PARAM params[2], *p = params;
431
432     ret = dh_param_derive_check(ctx);
433     if (ret != 1)
434         return ret;
435
436     /* TODO(3.0): Remove this eventually when no more legacy */
437     if (ctx->op.kex.exchprovctx == NULL)
438         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
439                                  EVP_PKEY_CTRL_DH_KDF_OUTLEN, inlen, NULL);
440     if (inlen <= 0) {
441         /*
442          * This would ideally be -1 or 0, but we have to retain compatibility
443          * with legacy behaviour of EVP_PKEY_CTX_ctrl() which returned -2 if
444          * in <= 0
445          */
446         return -2;
447     }
448
449     *p++ = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
450                                        &len);
451     *p = OSSL_PARAM_construct_end();
452
453     ret = evp_pkey_ctx_set_params_strict(ctx, params);
454     if (ret == -2) {
455         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
456         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
457         return -2;
458     }
459     return ret;
460 }
461
462 int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *plen)
463 {
464     int ret;
465     size_t len = UINT_MAX;
466     OSSL_PARAM params[2], *p = params;
467
468     ret = dh_param_derive_check(ctx);
469     if (ret != 1)
470         return ret;
471
472     /* TODO(3.0): Remove this eventually when no more legacy */
473     if (ctx->op.kex.exchprovctx == NULL)
474         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
475                                  EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, 0,
476                                  (void *)(plen));
477     *p++ = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
478                                        &len);
479     *p = OSSL_PARAM_construct_end();
480
481     ret = evp_pkey_ctx_get_params_strict(ctx, params);
482     if (ret == -2) {
483         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
484         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
485         return -2;
486     } else if (ret != 1) {
487         return -1;
488     }
489
490     if (len > INT_MAX)
491         return -1;
492
493     *plen = (int)len;
494
495     return 1;
496 }
497
498 int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len)
499 {
500     int ret;
501     OSSL_PARAM params[2], *p = params;
502
503     if (len <= 0)
504         return -1;
505
506     ret = dh_param_derive_check(ctx);
507     if (ret != 1)
508         return ret;
509
510     /* TODO(3.0): Remove this eventually when no more legacy */
511     if (ctx->op.kex.exchprovctx == NULL)
512         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
513                                  EVP_PKEY_CTRL_DH_KDF_UKM, len, (void *)(ukm));
514
515     *p++ = OSSL_PARAM_construct_octet_string(OSSL_EXCHANGE_PARAM_KDF_UKM,
516                                             /*
517                                              * Cast away the const. This is read
518                                              * only so should be safe
519                                              */
520                                             (void *)ukm,
521                                             (size_t)len);
522     *p = OSSL_PARAM_construct_end();
523
524     ret = evp_pkey_ctx_set_params_strict(ctx, params);
525     if (ret == -2) {
526         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
527         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
528         return -2;
529     }
530     if (ret == 1)
531         OPENSSL_free(ukm);
532     return ret;
533 }
534
535 int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **pukm)
536 {
537     int ret;
538     size_t ukmlen;
539     OSSL_PARAM params[3], *p = params;
540
541     ret = dh_param_derive_check(ctx);
542     if (ret != 1)
543         return ret;
544
545     /* TODO(3.0): Remove this eventually when no more legacy */
546     if (ctx->op.kex.exchprovctx == NULL)
547         return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_DERIVE,
548                                  EVP_PKEY_CTRL_GET_DH_KDF_UKM, 0, (void *)(pukm));
549
550     *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_EXCHANGE_PARAM_KDF_UKM,
551                                           (void **)pukm, 0);
552     *p++ = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_UKM_LEN,
553                                        &ukmlen);
554     *p = OSSL_PARAM_construct_end();
555
556     ret = evp_pkey_ctx_get_params_strict(ctx, params);
557     if (ret == -2) {
558         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
559         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
560         return -2;
561     } else if (ret != 1) {
562         return -1;
563     }
564
565     if (ukmlen > INT_MAX)
566         return -1;
567
568     return (int)ukmlen;
569 }