1 | /*
|
---|
2 | * Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
|
---|
3 | *
|
---|
4 | * Licensed under the OpenSSL license (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 | #include "apps.h"
|
---|
11 | #include "progs.h"
|
---|
12 | #include <string.h>
|
---|
13 | #include <openssl/err.h>
|
---|
14 | #include <openssl/pem.h>
|
---|
15 | #include <openssl/evp.h>
|
---|
16 |
|
---|
17 | #define KEY_NONE 0
|
---|
18 | #define KEY_PRIVKEY 1
|
---|
19 | #define KEY_PUBKEY 2
|
---|
20 | #define KEY_CERT 3
|
---|
21 |
|
---|
22 | static EVP_PKEY_CTX *init_ctx(const char *kdfalg, int *pkeysize,
|
---|
23 | const char *keyfile, int keyform, int key_type,
|
---|
24 | char *passinarg, int pkey_op, ENGINE *e,
|
---|
25 | const int impl);
|
---|
26 |
|
---|
27 | static int setup_peer(EVP_PKEY_CTX *ctx, int peerform, const char *file,
|
---|
28 | ENGINE *e);
|
---|
29 |
|
---|
30 | static int do_keyop(EVP_PKEY_CTX *ctx, int pkey_op,
|
---|
31 | unsigned char *out, size_t *poutlen,
|
---|
32 | const unsigned char *in, size_t inlen);
|
---|
33 |
|
---|
34 | typedef enum OPTION_choice {
|
---|
35 | OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
|
---|
36 | OPT_ENGINE, OPT_ENGINE_IMPL, OPT_IN, OPT_OUT,
|
---|
37 | OPT_PUBIN, OPT_CERTIN, OPT_ASN1PARSE, OPT_HEXDUMP, OPT_SIGN,
|
---|
38 | OPT_VERIFY, OPT_VERIFYRECOVER, OPT_REV, OPT_ENCRYPT, OPT_DECRYPT,
|
---|
39 | OPT_DERIVE, OPT_SIGFILE, OPT_INKEY, OPT_PEERKEY, OPT_PASSIN,
|
---|
40 | OPT_PEERFORM, OPT_KEYFORM, OPT_PKEYOPT, OPT_KDF, OPT_KDFLEN,
|
---|
41 | OPT_R_ENUM
|
---|
42 | } OPTION_CHOICE;
|
---|
43 |
|
---|
44 | const OPTIONS pkeyutl_options[] = {
|
---|
45 | {"help", OPT_HELP, '-', "Display this summary"},
|
---|
46 | {"in", OPT_IN, '<', "Input file - default stdin"},
|
---|
47 | {"out", OPT_OUT, '>', "Output file - default stdout"},
|
---|
48 | {"pubin", OPT_PUBIN, '-', "Input is a public key"},
|
---|
49 | {"certin", OPT_CERTIN, '-', "Input is a cert with a public key"},
|
---|
50 | {"asn1parse", OPT_ASN1PARSE, '-', "asn1parse the output data"},
|
---|
51 | {"hexdump", OPT_HEXDUMP, '-', "Hex dump output"},
|
---|
52 | {"sign", OPT_SIGN, '-', "Sign input data with private key"},
|
---|
53 | {"verify", OPT_VERIFY, '-', "Verify with public key"},
|
---|
54 | {"verifyrecover", OPT_VERIFYRECOVER, '-',
|
---|
55 | "Verify with public key, recover original data"},
|
---|
56 | {"rev", OPT_REV, '-', "Reverse the order of the input buffer"},
|
---|
57 | {"encrypt", OPT_ENCRYPT, '-', "Encrypt input data with public key"},
|
---|
58 | {"decrypt", OPT_DECRYPT, '-', "Decrypt input data with private key"},
|
---|
59 | {"derive", OPT_DERIVE, '-', "Derive shared secret"},
|
---|
60 | {"kdf", OPT_KDF, 's', "Use KDF algorithm"},
|
---|
61 | {"kdflen", OPT_KDFLEN, 'p', "KDF algorithm output length"},
|
---|
62 | {"sigfile", OPT_SIGFILE, '<', "Signature file (verify operation only)"},
|
---|
63 | {"inkey", OPT_INKEY, 's', "Input private key file"},
|
---|
64 | {"peerkey", OPT_PEERKEY, 's', "Peer key file used in key derivation"},
|
---|
65 | {"passin", OPT_PASSIN, 's', "Input file pass phrase source"},
|
---|
66 | {"peerform", OPT_PEERFORM, 'E', "Peer key format - default PEM"},
|
---|
67 | {"keyform", OPT_KEYFORM, 'E', "Private key format - default PEM"},
|
---|
68 | {"pkeyopt", OPT_PKEYOPT, 's', "Public key options as opt:value"},
|
---|
69 | OPT_R_OPTIONS,
|
---|
70 | #ifndef OPENSSL_NO_ENGINE
|
---|
71 | {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
|
---|
72 | {"engine_impl", OPT_ENGINE_IMPL, '-',
|
---|
73 | "Also use engine given by -engine for crypto operations"},
|
---|
74 | #endif
|
---|
75 | {NULL}
|
---|
76 | };
|
---|
77 |
|
---|
78 | int pkeyutl_main(int argc, char **argv)
|
---|
79 | {
|
---|
80 | BIO *in = NULL, *out = NULL;
|
---|
81 | ENGINE *e = NULL;
|
---|
82 | EVP_PKEY_CTX *ctx = NULL;
|
---|
83 | char *infile = NULL, *outfile = NULL, *sigfile = NULL, *passinarg = NULL;
|
---|
84 | char hexdump = 0, asn1parse = 0, rev = 0, *prog;
|
---|
85 | unsigned char *buf_in = NULL, *buf_out = NULL, *sig = NULL;
|
---|
86 | OPTION_CHOICE o;
|
---|
87 | int buf_inlen = 0, siglen = -1, keyform = FORMAT_PEM, peerform = FORMAT_PEM;
|
---|
88 | int keysize = -1, pkey_op = EVP_PKEY_OP_SIGN, key_type = KEY_PRIVKEY;
|
---|
89 | int engine_impl = 0;
|
---|
90 | int ret = 1, rv = -1;
|
---|
91 | size_t buf_outlen;
|
---|
92 | const char *inkey = NULL;
|
---|
93 | const char *peerkey = NULL;
|
---|
94 | const char *kdfalg = NULL;
|
---|
95 | int kdflen = 0;
|
---|
96 | STACK_OF(OPENSSL_STRING) *pkeyopts = NULL;
|
---|
97 |
|
---|
98 | prog = opt_init(argc, argv, pkeyutl_options);
|
---|
99 | while ((o = opt_next()) != OPT_EOF) {
|
---|
100 | switch (o) {
|
---|
101 | case OPT_EOF:
|
---|
102 | case OPT_ERR:
|
---|
103 | opthelp:
|
---|
104 | BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
|
---|
105 | goto end;
|
---|
106 | case OPT_HELP:
|
---|
107 | opt_help(pkeyutl_options);
|
---|
108 | ret = 0;
|
---|
109 | goto end;
|
---|
110 | case OPT_IN:
|
---|
111 | infile = opt_arg();
|
---|
112 | break;
|
---|
113 | case OPT_OUT:
|
---|
114 | outfile = opt_arg();
|
---|
115 | break;
|
---|
116 | case OPT_SIGFILE:
|
---|
117 | sigfile = opt_arg();
|
---|
118 | break;
|
---|
119 | case OPT_ENGINE_IMPL:
|
---|
120 | engine_impl = 1;
|
---|
121 | break;
|
---|
122 | case OPT_INKEY:
|
---|
123 | inkey = opt_arg();
|
---|
124 | break;
|
---|
125 | case OPT_PEERKEY:
|
---|
126 | peerkey = opt_arg();
|
---|
127 | break;
|
---|
128 | case OPT_PASSIN:
|
---|
129 | passinarg = opt_arg();
|
---|
130 | break;
|
---|
131 | case OPT_PEERFORM:
|
---|
132 | if (!opt_format(opt_arg(), OPT_FMT_PDE, &peerform))
|
---|
133 | goto opthelp;
|
---|
134 | break;
|
---|
135 | case OPT_KEYFORM:
|
---|
136 | if (!opt_format(opt_arg(), OPT_FMT_PDE, &keyform))
|
---|
137 | goto opthelp;
|
---|
138 | break;
|
---|
139 | case OPT_R_CASES:
|
---|
140 | if (!opt_rand(o))
|
---|
141 | goto end;
|
---|
142 | break;
|
---|
143 | case OPT_ENGINE:
|
---|
144 | e = setup_engine(opt_arg(), 0);
|
---|
145 | break;
|
---|
146 | case OPT_PUBIN:
|
---|
147 | key_type = KEY_PUBKEY;
|
---|
148 | break;
|
---|
149 | case OPT_CERTIN:
|
---|
150 | key_type = KEY_CERT;
|
---|
151 | break;
|
---|
152 | case OPT_ASN1PARSE:
|
---|
153 | asn1parse = 1;
|
---|
154 | break;
|
---|
155 | case OPT_HEXDUMP:
|
---|
156 | hexdump = 1;
|
---|
157 | break;
|
---|
158 | case OPT_SIGN:
|
---|
159 | pkey_op = EVP_PKEY_OP_SIGN;
|
---|
160 | break;
|
---|
161 | case OPT_VERIFY:
|
---|
162 | pkey_op = EVP_PKEY_OP_VERIFY;
|
---|
163 | break;
|
---|
164 | case OPT_VERIFYRECOVER:
|
---|
165 | pkey_op = EVP_PKEY_OP_VERIFYRECOVER;
|
---|
166 | break;
|
---|
167 | case OPT_ENCRYPT:
|
---|
168 | pkey_op = EVP_PKEY_OP_ENCRYPT;
|
---|
169 | break;
|
---|
170 | case OPT_DECRYPT:
|
---|
171 | pkey_op = EVP_PKEY_OP_DECRYPT;
|
---|
172 | break;
|
---|
173 | case OPT_DERIVE:
|
---|
174 | pkey_op = EVP_PKEY_OP_DERIVE;
|
---|
175 | break;
|
---|
176 | case OPT_KDF:
|
---|
177 | pkey_op = EVP_PKEY_OP_DERIVE;
|
---|
178 | key_type = KEY_NONE;
|
---|
179 | kdfalg = opt_arg();
|
---|
180 | break;
|
---|
181 | case OPT_KDFLEN:
|
---|
182 | kdflen = atoi(opt_arg());
|
---|
183 | break;
|
---|
184 | case OPT_REV:
|
---|
185 | rev = 1;
|
---|
186 | break;
|
---|
187 | case OPT_PKEYOPT:
|
---|
188 | if ((pkeyopts == NULL &&
|
---|
189 | (pkeyopts = sk_OPENSSL_STRING_new_null()) == NULL) ||
|
---|
190 | sk_OPENSSL_STRING_push(pkeyopts, opt_arg()) == 0) {
|
---|
191 | BIO_puts(bio_err, "out of memory\n");
|
---|
192 | goto end;
|
---|
193 | }
|
---|
194 | break;
|
---|
195 | }
|
---|
196 | }
|
---|
197 | argc = opt_num_rest();
|
---|
198 | if (argc != 0)
|
---|
199 | goto opthelp;
|
---|
200 |
|
---|
201 | if (kdfalg != NULL) {
|
---|
202 | if (kdflen == 0) {
|
---|
203 | BIO_printf(bio_err,
|
---|
204 | "%s: no KDF length given (-kdflen parameter).\n", prog);
|
---|
205 | goto opthelp;
|
---|
206 | }
|
---|
207 | } else if (inkey == NULL) {
|
---|
208 | BIO_printf(bio_err,
|
---|
209 | "%s: no private key given (-inkey parameter).\n", prog);
|
---|
210 | goto opthelp;
|
---|
211 | } else if (peerkey != NULL && pkey_op != EVP_PKEY_OP_DERIVE) {
|
---|
212 | BIO_printf(bio_err,
|
---|
213 | "%s: no peer key given (-peerkey parameter).\n", prog);
|
---|
214 | goto opthelp;
|
---|
215 | }
|
---|
216 | ctx = init_ctx(kdfalg, &keysize, inkey, keyform, key_type,
|
---|
217 | passinarg, pkey_op, e, engine_impl);
|
---|
218 | if (ctx == NULL) {
|
---|
219 | BIO_printf(bio_err, "%s: Error initializing context\n", prog);
|
---|
220 | ERR_print_errors(bio_err);
|
---|
221 | goto end;
|
---|
222 | }
|
---|
223 | if (peerkey != NULL && !setup_peer(ctx, peerform, peerkey, e)) {
|
---|
224 | BIO_printf(bio_err, "%s: Error setting up peer key\n", prog);
|
---|
225 | ERR_print_errors(bio_err);
|
---|
226 | goto end;
|
---|
227 | }
|
---|
228 | if (pkeyopts != NULL) {
|
---|
229 | int num = sk_OPENSSL_STRING_num(pkeyopts);
|
---|
230 | int i;
|
---|
231 |
|
---|
232 | for (i = 0; i < num; ++i) {
|
---|
233 | const char *opt = sk_OPENSSL_STRING_value(pkeyopts, i);
|
---|
234 |
|
---|
235 | if (pkey_ctrl_string(ctx, opt) <= 0) {
|
---|
236 | BIO_printf(bio_err, "%s: Can't set parameter \"%s\":\n",
|
---|
237 | prog, opt);
|
---|
238 | ERR_print_errors(bio_err);
|
---|
239 | goto end;
|
---|
240 | }
|
---|
241 | }
|
---|
242 | }
|
---|
243 |
|
---|
244 | if (sigfile != NULL && (pkey_op != EVP_PKEY_OP_VERIFY)) {
|
---|
245 | BIO_printf(bio_err,
|
---|
246 | "%s: Signature file specified for non verify\n", prog);
|
---|
247 | goto end;
|
---|
248 | }
|
---|
249 |
|
---|
250 | if (sigfile == NULL && (pkey_op == EVP_PKEY_OP_VERIFY)) {
|
---|
251 | BIO_printf(bio_err,
|
---|
252 | "%s: No signature file specified for verify\n", prog);
|
---|
253 | goto end;
|
---|
254 | }
|
---|
255 |
|
---|
256 | if (pkey_op != EVP_PKEY_OP_DERIVE) {
|
---|
257 | in = bio_open_default(infile, 'r', FORMAT_BINARY);
|
---|
258 | if (in == NULL)
|
---|
259 | goto end;
|
---|
260 | }
|
---|
261 | out = bio_open_default(outfile, 'w', FORMAT_BINARY);
|
---|
262 | if (out == NULL)
|
---|
263 | goto end;
|
---|
264 |
|
---|
265 | if (sigfile != NULL) {
|
---|
266 | BIO *sigbio = BIO_new_file(sigfile, "rb");
|
---|
267 |
|
---|
268 | if (sigbio == NULL) {
|
---|
269 | BIO_printf(bio_err, "Can't open signature file %s\n", sigfile);
|
---|
270 | goto end;
|
---|
271 | }
|
---|
272 | siglen = bio_to_mem(&sig, keysize * 10, sigbio);
|
---|
273 | BIO_free(sigbio);
|
---|
274 | if (siglen < 0) {
|
---|
275 | BIO_printf(bio_err, "Error reading signature data\n");
|
---|
276 | goto end;
|
---|
277 | }
|
---|
278 | }
|
---|
279 |
|
---|
280 | if (in != NULL) {
|
---|
281 | /* Read the input data */
|
---|
282 | buf_inlen = bio_to_mem(&buf_in, keysize * 10, in);
|
---|
283 | if (buf_inlen < 0) {
|
---|
284 | BIO_printf(bio_err, "Error reading input Data\n");
|
---|
285 | goto end;
|
---|
286 | }
|
---|
287 | if (rev) {
|
---|
288 | size_t i;
|
---|
289 | unsigned char ctmp;
|
---|
290 | size_t l = (size_t)buf_inlen;
|
---|
291 | for (i = 0; i < l / 2; i++) {
|
---|
292 | ctmp = buf_in[i];
|
---|
293 | buf_in[i] = buf_in[l - 1 - i];
|
---|
294 | buf_in[l - 1 - i] = ctmp;
|
---|
295 | }
|
---|
296 | }
|
---|
297 | }
|
---|
298 |
|
---|
299 | /* Sanity check the input */
|
---|
300 | if (buf_inlen > EVP_MAX_MD_SIZE
|
---|
301 | && (pkey_op == EVP_PKEY_OP_SIGN
|
---|
302 | || pkey_op == EVP_PKEY_OP_VERIFY)) {
|
---|
303 | BIO_printf(bio_err,
|
---|
304 | "Error: The input data looks too long to be a hash\n");
|
---|
305 | goto end;
|
---|
306 | }
|
---|
307 |
|
---|
308 | if (pkey_op == EVP_PKEY_OP_VERIFY) {
|
---|
309 | rv = EVP_PKEY_verify(ctx, sig, (size_t)siglen,
|
---|
310 | buf_in, (size_t)buf_inlen);
|
---|
311 | if (rv == 1) {
|
---|
312 | BIO_puts(out, "Signature Verified Successfully\n");
|
---|
313 | ret = 0;
|
---|
314 | } else {
|
---|
315 | BIO_puts(out, "Signature Verification Failure\n");
|
---|
316 | }
|
---|
317 | goto end;
|
---|
318 | }
|
---|
319 | if (kdflen != 0) {
|
---|
320 | buf_outlen = kdflen;
|
---|
321 | rv = 1;
|
---|
322 | } else {
|
---|
323 | rv = do_keyop(ctx, pkey_op, NULL, (size_t *)&buf_outlen,
|
---|
324 | buf_in, (size_t)buf_inlen);
|
---|
325 | }
|
---|
326 | if (rv > 0 && buf_outlen != 0) {
|
---|
327 | buf_out = app_malloc(buf_outlen, "buffer output");
|
---|
328 | rv = do_keyop(ctx, pkey_op,
|
---|
329 | buf_out, (size_t *)&buf_outlen,
|
---|
330 | buf_in, (size_t)buf_inlen);
|
---|
331 | }
|
---|
332 | if (rv <= 0) {
|
---|
333 | if (pkey_op != EVP_PKEY_OP_DERIVE) {
|
---|
334 | BIO_puts(bio_err, "Public Key operation error\n");
|
---|
335 | } else {
|
---|
336 | BIO_puts(bio_err, "Key derivation failed\n");
|
---|
337 | }
|
---|
338 | ERR_print_errors(bio_err);
|
---|
339 | goto end;
|
---|
340 | }
|
---|
341 | ret = 0;
|
---|
342 |
|
---|
343 | if (asn1parse) {
|
---|
344 | if (!ASN1_parse_dump(out, buf_out, buf_outlen, 1, -1))
|
---|
345 | ERR_print_errors(bio_err);
|
---|
346 | } else if (hexdump) {
|
---|
347 | BIO_dump(out, (char *)buf_out, buf_outlen);
|
---|
348 | } else {
|
---|
349 | BIO_write(out, buf_out, buf_outlen);
|
---|
350 | }
|
---|
351 |
|
---|
352 | end:
|
---|
353 | EVP_PKEY_CTX_free(ctx);
|
---|
354 | release_engine(e);
|
---|
355 | BIO_free(in);
|
---|
356 | BIO_free_all(out);
|
---|
357 | OPENSSL_free(buf_in);
|
---|
358 | OPENSSL_free(buf_out);
|
---|
359 | OPENSSL_free(sig);
|
---|
360 | sk_OPENSSL_STRING_free(pkeyopts);
|
---|
361 | return ret;
|
---|
362 | }
|
---|
363 |
|
---|
364 | static EVP_PKEY_CTX *init_ctx(const char *kdfalg, int *pkeysize,
|
---|
365 | const char *keyfile, int keyform, int key_type,
|
---|
366 | char *passinarg, int pkey_op, ENGINE *e,
|
---|
367 | const int engine_impl)
|
---|
368 | {
|
---|
369 | EVP_PKEY *pkey = NULL;
|
---|
370 | EVP_PKEY_CTX *ctx = NULL;
|
---|
371 | ENGINE *impl = NULL;
|
---|
372 | char *passin = NULL;
|
---|
373 | int rv = -1;
|
---|
374 | X509 *x;
|
---|
375 | if (((pkey_op == EVP_PKEY_OP_SIGN) || (pkey_op == EVP_PKEY_OP_DECRYPT)
|
---|
376 | || (pkey_op == EVP_PKEY_OP_DERIVE))
|
---|
377 | && (key_type != KEY_PRIVKEY && kdfalg == NULL)) {
|
---|
378 | BIO_printf(bio_err, "A private key is needed for this operation\n");
|
---|
379 | goto end;
|
---|
380 | }
|
---|
381 | if (!app_passwd(passinarg, NULL, &passin, NULL)) {
|
---|
382 | BIO_printf(bio_err, "Error getting password\n");
|
---|
383 | goto end;
|
---|
384 | }
|
---|
385 | switch (key_type) {
|
---|
386 | case KEY_PRIVKEY:
|
---|
387 | pkey = load_key(keyfile, keyform, 0, passin, e, "Private Key");
|
---|
388 | break;
|
---|
389 |
|
---|
390 | case KEY_PUBKEY:
|
---|
391 | pkey = load_pubkey(keyfile, keyform, 0, NULL, e, "Public Key");
|
---|
392 | break;
|
---|
393 |
|
---|
394 | case KEY_CERT:
|
---|
395 | x = load_cert(keyfile, keyform, "Certificate");
|
---|
396 | if (x) {
|
---|
397 | pkey = X509_get_pubkey(x);
|
---|
398 | X509_free(x);
|
---|
399 | }
|
---|
400 | break;
|
---|
401 |
|
---|
402 | case KEY_NONE:
|
---|
403 | break;
|
---|
404 |
|
---|
405 | }
|
---|
406 |
|
---|
407 | #ifndef OPENSSL_NO_ENGINE
|
---|
408 | if (engine_impl)
|
---|
409 | impl = e;
|
---|
410 | #endif
|
---|
411 |
|
---|
412 | if (kdfalg != NULL) {
|
---|
413 | int kdfnid = OBJ_sn2nid(kdfalg);
|
---|
414 |
|
---|
415 | if (kdfnid == NID_undef) {
|
---|
416 | kdfnid = OBJ_ln2nid(kdfalg);
|
---|
417 | if (kdfnid == NID_undef) {
|
---|
418 | BIO_printf(bio_err, "The given KDF \"%s\" is unknown.\n",
|
---|
419 | kdfalg);
|
---|
420 | goto end;
|
---|
421 | }
|
---|
422 | }
|
---|
423 | ctx = EVP_PKEY_CTX_new_id(kdfnid, impl);
|
---|
424 | } else {
|
---|
425 | if (pkey == NULL)
|
---|
426 | goto end;
|
---|
427 | *pkeysize = EVP_PKEY_size(pkey);
|
---|
428 | ctx = EVP_PKEY_CTX_new(pkey, impl);
|
---|
429 | EVP_PKEY_free(pkey);
|
---|
430 | }
|
---|
431 |
|
---|
432 | if (ctx == NULL)
|
---|
433 | goto end;
|
---|
434 |
|
---|
435 | switch (pkey_op) {
|
---|
436 | case EVP_PKEY_OP_SIGN:
|
---|
437 | rv = EVP_PKEY_sign_init(ctx);
|
---|
438 | break;
|
---|
439 |
|
---|
440 | case EVP_PKEY_OP_VERIFY:
|
---|
441 | rv = EVP_PKEY_verify_init(ctx);
|
---|
442 | break;
|
---|
443 |
|
---|
444 | case EVP_PKEY_OP_VERIFYRECOVER:
|
---|
445 | rv = EVP_PKEY_verify_recover_init(ctx);
|
---|
446 | break;
|
---|
447 |
|
---|
448 | case EVP_PKEY_OP_ENCRYPT:
|
---|
449 | rv = EVP_PKEY_encrypt_init(ctx);
|
---|
450 | break;
|
---|
451 |
|
---|
452 | case EVP_PKEY_OP_DECRYPT:
|
---|
453 | rv = EVP_PKEY_decrypt_init(ctx);
|
---|
454 | break;
|
---|
455 |
|
---|
456 | case EVP_PKEY_OP_DERIVE:
|
---|
457 | rv = EVP_PKEY_derive_init(ctx);
|
---|
458 | break;
|
---|
459 | }
|
---|
460 |
|
---|
461 | if (rv <= 0) {
|
---|
462 | EVP_PKEY_CTX_free(ctx);
|
---|
463 | ctx = NULL;
|
---|
464 | }
|
---|
465 |
|
---|
466 | end:
|
---|
467 | OPENSSL_free(passin);
|
---|
468 | return ctx;
|
---|
469 |
|
---|
470 | }
|
---|
471 |
|
---|
472 | static int setup_peer(EVP_PKEY_CTX *ctx, int peerform, const char *file,
|
---|
473 | ENGINE *e)
|
---|
474 | {
|
---|
475 | EVP_PKEY *peer = NULL;
|
---|
476 | ENGINE *engine = NULL;
|
---|
477 | int ret;
|
---|
478 |
|
---|
479 | if (peerform == FORMAT_ENGINE)
|
---|
480 | engine = e;
|
---|
481 | peer = load_pubkey(file, peerform, 0, NULL, engine, "Peer Key");
|
---|
482 | if (peer == NULL) {
|
---|
483 | BIO_printf(bio_err, "Error reading peer key %s\n", file);
|
---|
484 | ERR_print_errors(bio_err);
|
---|
485 | return 0;
|
---|
486 | }
|
---|
487 |
|
---|
488 | ret = EVP_PKEY_derive_set_peer(ctx, peer);
|
---|
489 |
|
---|
490 | EVP_PKEY_free(peer);
|
---|
491 | if (ret <= 0)
|
---|
492 | ERR_print_errors(bio_err);
|
---|
493 | return ret;
|
---|
494 | }
|
---|
495 |
|
---|
496 | static int do_keyop(EVP_PKEY_CTX *ctx, int pkey_op,
|
---|
497 | unsigned char *out, size_t *poutlen,
|
---|
498 | const unsigned char *in, size_t inlen)
|
---|
499 | {
|
---|
500 | int rv = 0;
|
---|
501 | switch (pkey_op) {
|
---|
502 | case EVP_PKEY_OP_VERIFYRECOVER:
|
---|
503 | rv = EVP_PKEY_verify_recover(ctx, out, poutlen, in, inlen);
|
---|
504 | break;
|
---|
505 |
|
---|
506 | case EVP_PKEY_OP_SIGN:
|
---|
507 | rv = EVP_PKEY_sign(ctx, out, poutlen, in, inlen);
|
---|
508 | break;
|
---|
509 |
|
---|
510 | case EVP_PKEY_OP_ENCRYPT:
|
---|
511 | rv = EVP_PKEY_encrypt(ctx, out, poutlen, in, inlen);
|
---|
512 | break;
|
---|
513 |
|
---|
514 | case EVP_PKEY_OP_DECRYPT:
|
---|
515 | rv = EVP_PKEY_decrypt(ctx, out, poutlen, in, inlen);
|
---|
516 | break;
|
---|
517 |
|
---|
518 | case EVP_PKEY_OP_DERIVE:
|
---|
519 | rv = EVP_PKEY_derive(ctx, out, poutlen);
|
---|
520 | break;
|
---|
521 |
|
---|
522 | }
|
---|
523 | return rv;
|
---|
524 | }
|
---|