1 files changed, 76 insertions, 76 deletions

diff --git a/src/usr.bin/openssl/pkeyutl.c b/src/usr.bin/openssl/pkeyutl.c
index 8c0fd28b29..efd0896c02 100644
--- a/src/usr.bin/openssl/pkeyutl.c
+++ b/src/usr.bin/openssl/pkeyutl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pkeyutl.c,v 1.18 2023/03/05 13:12:53 tb Exp $ */
+/* $OpenBSD: pkeyutl.c,v 1.19 2023/03/06 14:32:06 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -82,7 +82,7 @@ static struct {
         int pkey_op;
         int rev;
         char *sigfile;
-} pkeyutl_config;
+} cfg;
 
 static void pkeyutl_usage(void);
 
@@ -101,48 +101,48 @@ static const struct option pkeyutl_options[] = {
                 .name = "asn1parse",
                 .desc = "ASN.1 parse the output data",
                 .type = OPTION_FLAG,
-                .opt.flag = &pkeyutl_config.asn1parse,
+                .opt.flag = &cfg.asn1parse,
         },
         {
                 .name = "certin",
                 .desc = "Input is a certificate containing a public key",
                 .type = OPTION_VALUE,
                 .value = KEY_CERT,
-                .opt.value = &pkeyutl_config.key_type,
+                .opt.value = &cfg.key_type,
         },
         {
                 .name = "decrypt",
                 .desc = "Decrypt the input data using a private key",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_DECRYPT,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
         {
                 .name = "derive",
                 .desc = "Derive a shared secret using the peer key",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_DERIVE,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
         {
                 .name = "encrypt",
                 .desc = "Encrypt the input data using a public key",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_ENCRYPT,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
         {
                 .name = "hexdump",
                 .desc = "Hex dump the output data",
                 .type = OPTION_FLAG,
-                .opt.flag = &pkeyutl_config.hexdump,
+                .opt.flag = &cfg.hexdump,
         },
         {
                 .name = "in",
                 .argname = "file",
                 .desc = "Input file (default stdin)",
                 .type = OPTION_ARG,
-                .opt.arg = &pkeyutl_config.infile,
+                .opt.arg = &cfg.infile,
         },
         {
                 .name = "inkey",
@@ -156,28 +156,28 @@ static const struct option pkeyutl_options[] = {
                 .argname = "fmt",
                 .desc = "Input key format (DER or PEM (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &pkeyutl_config.keyform,
+                .opt.value = &cfg.keyform,
         },
         {
                 .name = "out",
                 .argname = "file",
                 .desc = "Output file (default stdout)",
                 .type = OPTION_ARG,
-                .opt.arg = &pkeyutl_config.outfile,
+                .opt.arg = &cfg.outfile,
         },
         {
                 .name = "passin",
                 .argname = "arg",
                 .desc = "Key password source",
                 .type = OPTION_ARG,
-                .opt.arg = &pkeyutl_config.passargin,
+                .opt.arg = &cfg.passargin,
         },
         {
                 .name = "peerform",
                 .argname = "fmt",
                 .desc = "Input key format (DER or PEM (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &pkeyutl_config.peerform,
+                .opt.value = &cfg.peerform,
         },
         {
                 .name = "peerkey",
@@ -198,41 +198,41 @@ static const struct option pkeyutl_options[] = {
                 .desc = "Input is a public key",
                 .type = OPTION_VALUE,
                 .value = KEY_PUBKEY,
-                .opt.value = &pkeyutl_config.key_type,
+                .opt.value = &cfg.key_type,
         },
         {
                 .name = "rev",
                 .desc = "Reverse the input data",
                 .type = OPTION_FLAG,
-                .opt.flag = &pkeyutl_config.rev,
+                .opt.flag = &cfg.rev,
         },
         {
                 .name = "sigfile",
                 .argname = "file",
                 .desc = "Signature file (verify operation only)",
                 .type = OPTION_ARG,
-                .opt.arg = &pkeyutl_config.sigfile,
+                .opt.arg = &cfg.sigfile,
         },
         {
                 .name = "sign",
                 .desc = "Sign the input data using private key",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_SIGN,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
         {
                 .name = "verify",
                 .desc = "Verify the input data using public key",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_VERIFY,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
         {
                 .name = "verifyrecover",
                 .desc = "Verify with public key, recover original data",
                 .type = OPTION_VALUE,
                 .value = EVP_PKEY_OP_VERIFYRECOVER,
-                .opt.value = &pkeyutl_config.pkey_op,
+                .opt.value = &cfg.pkey_op,
         },
 
         {NULL},
@@ -268,36 +268,36 @@ pkeyutl_main(int argc, char **argv)
                 exit(1);
         }
 
-        memset(&pkeyutl_config, 0, sizeof(pkeyutl_config));
-        pkeyutl_config.pkey_op = EVP_PKEY_OP_SIGN;
-        pkeyutl_config.key_type = KEY_PRIVKEY;
-        pkeyutl_config.keyform = FORMAT_PEM;
-        pkeyutl_config.peerform = FORMAT_PEM;
-        pkeyutl_config.keysize = -1;
+        memset(&cfg, 0, sizeof(cfg));
+        cfg.pkey_op = EVP_PKEY_OP_SIGN;
+        cfg.key_type = KEY_PRIVKEY;
+        cfg.keyform = FORMAT_PEM;
+        cfg.peerform = FORMAT_PEM;
+        cfg.keysize = -1;
 
         if (options_parse(argc, argv, pkeyutl_options, NULL, NULL) != 0) {
                 pkeyutl_usage();
                 goto end;
         }
 
-        if (!pkeyutl_config.ctx) {
+        if (!cfg.ctx) {
                 pkeyutl_usage();
                 goto end;
         }
-        if (pkeyutl_config.sigfile &&
-            (pkeyutl_config.pkey_op != EVP_PKEY_OP_VERIFY)) {
+        if (cfg.sigfile &&
+            (cfg.pkey_op != EVP_PKEY_OP_VERIFY)) {
                 BIO_puts(bio_err, "Signature file specified for non verify\n");
                 goto end;
         }
-        if (!pkeyutl_config.sigfile &&
-            (pkeyutl_config.pkey_op == EVP_PKEY_OP_VERIFY)) {
+        if (!cfg.sigfile &&
+            (cfg.pkey_op == EVP_PKEY_OP_VERIFY)) {
                 BIO_puts(bio_err, "No signature file specified for verify\n");
                 goto end;
         }
 
-        if (pkeyutl_config.pkey_op != EVP_PKEY_OP_DERIVE) {
-                if (pkeyutl_config.infile) {
-                        if (!(in = BIO_new_file(pkeyutl_config.infile, "rb"))) {
+        if (cfg.pkey_op != EVP_PKEY_OP_DERIVE) {
+                if (cfg.infile) {
+                        if (!(in = BIO_new_file(cfg.infile, "rb"))) {
                                 BIO_puts(bio_err,
                                     "Error Opening Input File\n");
                                 ERR_print_errors(bio_err);
@@ -306,8 +306,8 @@ pkeyutl_main(int argc, char **argv)
                 } else
                         in = BIO_new_fp(stdin, BIO_NOCLOSE);
         }
-        if (pkeyutl_config.outfile) {
-                if (!(out = BIO_new_file(pkeyutl_config.outfile, "wb"))) {
+        if (cfg.outfile) {
+                if (!(out = BIO_new_file(cfg.outfile, "wb"))) {
                         BIO_printf(bio_err, "Error Creating Output File\n");
                         ERR_print_errors(bio_err);
                         goto end;
@@ -316,14 +316,14 @@ pkeyutl_main(int argc, char **argv)
                 out = BIO_new_fp(stdout, BIO_NOCLOSE);
         }
 
-        if (pkeyutl_config.sigfile) {
-                BIO *sigbio = BIO_new_file(pkeyutl_config.sigfile, "rb");
+        if (cfg.sigfile) {
+                BIO *sigbio = BIO_new_file(cfg.sigfile, "rb");
                 if (!sigbio) {
                         BIO_printf(bio_err, "Can't open signature file %s\n",
-                            pkeyutl_config.sigfile);
+                            cfg.sigfile);
                         goto end;
                 }
-                siglen = bio_to_mem(&sig, pkeyutl_config.keysize * 10, sigbio);
+                siglen = bio_to_mem(&sig, cfg.keysize * 10, sigbio);
                 BIO_free(sigbio);
                 if (siglen <= 0) {
                         BIO_printf(bio_err, "Error reading signature data\n");
@@ -332,12 +332,12 @@ pkeyutl_main(int argc, char **argv)
         }
         if (in) {
                 /* Read the input data */
-                buf_inlen = bio_to_mem(&buf_in, pkeyutl_config.keysize * 10, in);
+                buf_inlen = bio_to_mem(&buf_in, cfg.keysize * 10, in);
                 if (buf_inlen <= 0) {
                         BIO_printf(bio_err, "Error reading input Data\n");
                         exit(1);
                 }
-                if (pkeyutl_config.rev) {
+                if (cfg.rev) {
                         size_t i;
                         unsigned char ctmp;
                         size_t l = (size_t) buf_inlen;
@@ -348,8 +348,8 @@ pkeyutl_main(int argc, char **argv)
                         }
                 }
         }
-        if (pkeyutl_config.pkey_op == EVP_PKEY_OP_VERIFY) {
-                rv = EVP_PKEY_verify(pkeyutl_config.ctx, sig, (size_t) siglen,
+        if (cfg.pkey_op == EVP_PKEY_OP_VERIFY) {
+                rv = EVP_PKEY_verify(cfg.ctx, sig, (size_t) siglen,
                     buf_in, (size_t) buf_inlen);
                 if (rv == 1) {
                         BIO_puts(out, "Signature Verified Successfully\n");
@@ -359,15 +359,15 @@ pkeyutl_main(int argc, char **argv)
                 if (rv >= 0)
                         goto end;
         } else {
-                rv = do_keyop(pkeyutl_config.ctx, pkeyutl_config.pkey_op, NULL,
+                rv = do_keyop(cfg.ctx, cfg.pkey_op, NULL,
                     (size_t *)&buf_outlen, buf_in, (size_t) buf_inlen);
                 if (rv > 0) {
                         buf_out = malloc(buf_outlen);
                         if (!buf_out)
                                 rv = -1;
                         else
-                                rv = do_keyop(pkeyutl_config.ctx,
-                                    pkeyutl_config.pkey_op,
+                                rv = do_keyop(cfg.ctx,
+                                    cfg.pkey_op,
                                     buf_out, (size_t *) & buf_outlen,
                                     buf_in, (size_t) buf_inlen);
                 }
@@ -379,16 +379,16 @@ pkeyutl_main(int argc, char **argv)
                 goto end;
         }
         ret = 0;
-        if (pkeyutl_config.asn1parse) {
+        if (cfg.asn1parse) {
                 if (!ASN1_parse_dump(out, buf_out, buf_outlen, 1, -1))
                         ERR_print_errors(bio_err);
-        } else if (pkeyutl_config.hexdump)
+        } else if (cfg.hexdump)
                 BIO_dump(out, (char *) buf_out, buf_outlen);
         else
                 BIO_write(out, buf_out, buf_outlen);
 
  end:
-        EVP_PKEY_CTX_free(pkeyutl_config.ctx);
+        EVP_PKEY_CTX_free(cfg.ctx);
         BIO_free(in);
         BIO_free_all(out);
         free(buf_in);
@@ -406,32 +406,32 @@ init_ctx(char *keyfile)
         int rv = -1;
         X509 *x;
 
-        if (((pkeyutl_config.pkey_op == EVP_PKEY_OP_SIGN)
-                || (pkeyutl_config.pkey_op == EVP_PKEY_OP_DECRYPT)
-                || (pkeyutl_config.pkey_op == EVP_PKEY_OP_DERIVE))
-            && (pkeyutl_config.key_type != KEY_PRIVKEY)) {
+        if (((cfg.pkey_op == EVP_PKEY_OP_SIGN)
+                || (cfg.pkey_op == EVP_PKEY_OP_DECRYPT)
+                || (cfg.pkey_op == EVP_PKEY_OP_DERIVE))
+            && (cfg.key_type != KEY_PRIVKEY)) {
                 BIO_printf(bio_err,
                     "A private key is needed for this operation\n");
                 goto end;
         }
-        if (!app_passwd(bio_err, pkeyutl_config.passargin, NULL, &passin,
+        if (!app_passwd(bio_err, cfg.passargin, NULL, &passin,
             NULL)) {
                 BIO_printf(bio_err, "Error getting password\n");
                 goto end;
         }
-        switch (pkeyutl_config.key_type) {
+        switch (cfg.key_type) {
         case KEY_PRIVKEY:
-                pkey = load_key(bio_err, keyfile, pkeyutl_config.keyform, 0,
+                pkey = load_key(bio_err, keyfile, cfg.keyform, 0,
                     passin, "Private Key");
                 break;
 
         case KEY_PUBKEY:
-                pkey = load_pubkey(bio_err, keyfile, pkeyutl_config.keyform, 0,
+                pkey = load_pubkey(bio_err, keyfile, cfg.keyform, 0,
                     NULL, "Public Key");
                 break;
 
         case KEY_CERT:
-                x = load_cert(bio_err, keyfile, pkeyutl_config.keyform,
+                x = load_cert(bio_err, keyfile, cfg.keyform,
                     NULL, "Certificate");
                 if (x) {
                         pkey = X509_get_pubkey(x);
@@ -440,53 +440,53 @@ init_ctx(char *keyfile)
                 break;
         }
 
-        pkeyutl_config.keysize = EVP_PKEY_size(pkey);
+        cfg.keysize = EVP_PKEY_size(pkey);
 
         if (!pkey)
                 goto end;
 
-        pkeyutl_config.ctx = EVP_PKEY_CTX_new(pkey, NULL);
+        cfg.ctx = EVP_PKEY_CTX_new(pkey, NULL);
 
         EVP_PKEY_free(pkey);
 
-        if (!pkeyutl_config.ctx)
+        if (!cfg.ctx)
                 goto end;
 
-        switch (pkeyutl_config.pkey_op) {
+        switch (cfg.pkey_op) {
         case EVP_PKEY_OP_SIGN:
-                rv = EVP_PKEY_sign_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_sign_init(cfg.ctx);
                 break;
 
         case EVP_PKEY_OP_VERIFY:
-                rv = EVP_PKEY_verify_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_verify_init(cfg.ctx);
                 break;
 
         case EVP_PKEY_OP_VERIFYRECOVER:
-                rv = EVP_PKEY_verify_recover_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_verify_recover_init(cfg.ctx);
                 break;
 
         case EVP_PKEY_OP_ENCRYPT:
-                rv = EVP_PKEY_encrypt_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_encrypt_init(cfg.ctx);
                 break;
 
         case EVP_PKEY_OP_DECRYPT:
-                rv = EVP_PKEY_decrypt_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_decrypt_init(cfg.ctx);
                 break;
 
         case EVP_PKEY_OP_DERIVE:
-                rv = EVP_PKEY_derive_init(pkeyutl_config.ctx);
+                rv = EVP_PKEY_derive_init(cfg.ctx);
                 break;
         }
 
         if (rv <= 0) {
-                EVP_PKEY_CTX_free(pkeyutl_config.ctx);
-                pkeyutl_config.ctx = NULL;
+                EVP_PKEY_CTX_free(cfg.ctx);
+                cfg.ctx = NULL;
         }
 
  end:
         free(passin);
 
-        if (!pkeyutl_config.ctx) {
+        if (!cfg.ctx) {
                 BIO_puts(bio_err, "Error initializing context\n");
                 ERR_print_errors(bio_err);
                 return (1);
@@ -501,11 +501,11 @@ setup_peer(char *file)
         EVP_PKEY *peer = NULL;
         int ret;
 
-        if (!pkeyutl_config.ctx) {
+        if (!cfg.ctx) {
                 BIO_puts(bio_err, "-peerkey command before -inkey\n");
                 return (1);
         }
-        peer = load_pubkey(bio_err, file, pkeyutl_config.peerform, 0, NULL,
+        peer = load_pubkey(bio_err, file, cfg.peerform, 0, NULL,
             "Peer Key");
 
         if (!peer) {
@@ -513,7 +513,7 @@ setup_peer(char *file)
                 ERR_print_errors(bio_err);
                 return (1);
         }
-        ret = EVP_PKEY_derive_set_peer(pkeyutl_config.ctx, peer);
+        ret = EVP_PKEY_derive_set_peer(cfg.ctx, peer);
 
         EVP_PKEY_free(peer);
         if (ret <= 0) {
@@ -527,10 +527,10 @@ setup_peer(char *file)
 static int
 pkeyutl_pkeyopt(char *pkeyopt)
 {
-        if (!pkeyutl_config.ctx) {
+        if (!cfg.ctx) {
                 BIO_puts(bio_err, "-pkeyopt command before -inkey\n");
                 return (1);
-        } else if (pkey_ctrl_string(pkeyutl_config.ctx, pkeyopt) <= 0) {
+        } else if (pkey_ctrl_string(cfg.ctx, pkeyopt) <= 0) {
                 BIO_puts(bio_err, "parameter setting error\n");
                 ERR_print_errors(bio_err);
                 return (1);