===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/openssl/ec.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- src/usr.bin/openssl/ec.c	2014/08/28 14:23:52	1.2
+++ src/usr.bin/openssl/ec.c	2015/07/12 22:16:49	1.3
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec.c,v 1.2 2014/08/28 14:23:52 jsing Exp $ */
+/* $OpenBSD: ec.c,v 1.3 2015/07/12 22:16:49 doug Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -60,6 +60,7 @@
 
 #ifndef OPENSSL_NO_EC
 
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -71,17 +72,213 @@
 #include <openssl/evp.h>
 #include <openssl/pem.h>
 
-/* -inform arg    - input format - default PEM (one of DER, NET or PEM)
- * -outform arg   - output format - default PEM
- * -in arg        - input file - default stdin
- * -out arg       - output file - default stdout
- * -des           - encrypt output if PEM format with DES in cbc mode
- * -text          - print a text version
- * -param_out     - print the elliptic curve parameters
- * -conv_form arg - specifies the point encoding form
- * -param_enc arg - specifies the parameter encoding
- */
+static struct {
+	int asn1_flag;
+	const EVP_CIPHER *enc;
+#ifndef OPENSSL_NO_ENGINE
+	char *engine;
+#endif
+	point_conversion_form_t form;
+	char *infile;
+	int informat;
+	char *outfile;
+	int outformat;
+	int new_asn1_flag;
+	int new_form;
+	int noout;
+	int param_out;
+	char *passargin;
+	char *passargout;
+	int pubin;
+	int pubout;
+	int text;
+} ec_config;
 
+static int
+ec_opt_enc(int argc, char **argv, int *argsused)
+{
+	char *name = argv[0];
+
+	if (*name++ != '-')
+		return (1);
+
+	if ((ec_config.enc = EVP_get_cipherbyname(name)) != NULL) {
+		*argsused = 1;
+		return (0);
+	}
+
+	return (1);
+}
+
+static int
+ec_opt_form(char *arg)
+{
+	if (strcmp(arg, "compressed") == 0)
+		ec_config.form = POINT_CONVERSION_COMPRESSED;
+	else if (strcmp(arg, "uncompressed") == 0)
+		ec_config.form = POINT_CONVERSION_UNCOMPRESSED;
+	else if (strcmp(arg, "hybrid") == 0)
+		ec_config.form = POINT_CONVERSION_HYBRID;
+	else {
+		fprintf(stderr, "Invalid point conversion: %s\n", arg);
+		return (1);
+	}
+
+	ec_config.new_form = 1;
+	return (0);
+}
+
+static int
+ec_opt_named(char *arg)
+{
+	if (strcmp(arg, "named_curve") == 0)
+		ec_config.asn1_flag = OPENSSL_EC_NAMED_CURVE;
+	else if (strcmp(arg, "explicit") == 0)
+		ec_config.asn1_flag = 0;
+	else {
+		fprintf(stderr, "Invalid curve type: %s\n", arg);
+		return (1);
+	}
+
+	ec_config.new_asn1_flag = 1;
+	return (0);
+}
+
+static struct option ec_options[] = {
+	{
+		.name = "conv_form",
+		.argname = "form",
+		.desc = "Specify the point conversion form (default"
+		    " \"named_curve\")",
+		.type = OPTION_ARG_FUNC,
+		.opt.argfunc = ec_opt_form,
+	},
+#ifndef OPENSSL_NO_ENGINE
+	{
+		.name = "engine",
+		.argname = "id",
+		.desc = "Use the engine specified by the given identifier",
+		.type = OPTION_ARG,
+		.opt.arg = &ec_config.engine,
+	},
+#endif
+	{
+		.name = "in",
+		.argname = "file",
+		.desc = "Input file (default stdin)",
+		.type = OPTION_ARG,
+		.opt.arg = &ec_config.infile,
+	},
+	{
+		.name = "inform",
+		.argname = "format",
+		.desc = "Input format (DER or PEM (default))",
+		.type = OPTION_ARG_FORMAT,
+		.opt.value = &ec_config.informat,
+	},
+	{
+		.name = "noout",
+		.desc = "No output",
+		.type = OPTION_FLAG,
+		.opt.flag = &ec_config.noout,
+	},
+	{
+		.name = "out",
+		.argname = "file",
+		.desc = "Output file (default stdout)",
+		.type = OPTION_ARG,
+		.opt.arg = &ec_config.outfile,
+	},
+	{
+		.name = "outform",
+		.argname = "format",
+		.desc = "Output format (DER or PEM (default))",
+		.type = OPTION_ARG_FORMAT,
+		.opt.value = &ec_config.outformat,
+	},
+	{
+		.name = "param_enc",
+		.argname = "type",
+		.desc = "Specify the way the ec parameters are encoded"
+		    " (default \"uncompressed\")",
+		.type = OPTION_ARG_FUNC,
+		.opt.argfunc = ec_opt_named,
+	},
+	{
+		.name = "param_out",
+		.desc = "Print the elliptic curve parameters",
+		.type = OPTION_FLAG,
+		.opt.flag = &ec_config.param_out,
+	},
+	{
+		.name = "passin",
+		.argname = "source",
+		.desc = "Input file passphrase source",
+		.type = OPTION_ARG,
+		.opt.arg = &ec_config.passargin,
+	},
+	{
+		.name = "passout",
+		.argname = "source",
+		.desc = "Output file passphrase source",
+		.type = OPTION_ARG,
+		.opt.arg = &ec_config.passargout,
+	},
+	{
+		.name = "pubin",
+		.desc = "Read public key instead of private key from input",
+		.type = OPTION_FLAG,
+		.opt.flag = &ec_config.pubin,
+	},
+	{
+		.name = "pubout",
+		.desc = "Output public key instead of private key in output",
+		.type = OPTION_FLAG,
+		.opt.flag = &ec_config.pubout,
+	},
+	{
+		.name = "text",
+		.desc = "Print the public/private key components and parameters",
+		.type = OPTION_FLAG,
+		.opt.flag = &ec_config.text,
+	},
+	{
+		.name = NULL,
+		.desc = "Cipher to encrypt the output if using PEM format",
+		.type = OPTION_ARGV_FUNC,
+		.opt.argvfunc = ec_opt_enc,
+	},
+	{ NULL },
+};
+
+static void
+show_ciphers(const OBJ_NAME *name, void *arg)
+{
+	static int n;
+
+	if (!islower((unsigned char)*name->name))
+		return;
+
+	fprintf(stderr, " -%-24s%s", name->name, (++n % 3 ? "" : "\n"));
+}
+
+static void
+ec_usage(void)
+{
+	fprintf(stderr,
+	    "usage: ec [-conv_form form] [-engine id] [-in file]\n"
+	    "    [-inform format] [-noout] [-out file] [-outform format]\n"
+	    "    [-param_enc type] [-param_out] [-passin file]\n"
+	    "    [-passout file] [-pubin] [-pubout] [-text] [-ciphername]\n\n");
+	options_usage(ec_options);
+
+	fprintf(stderr, "\n");
+
+	fprintf(stderr, "Valid ciphername values:\n\n");
+	OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, show_ciphers, NULL);
+	fprintf(stderr, "\n");
+}
+
 int ec_main(int, char **);
 
 int
@@ -90,174 +287,54 @@
 	int ret = 1;
 	EC_KEY *eckey = NULL;
 	const EC_GROUP *group;
-	int i, badops = 0;
-	const EVP_CIPHER *enc = NULL;
+	int i;
 	BIO *in = NULL, *out = NULL;
-	int informat, outformat, text = 0, noout = 0;
-	int pubin = 0, pubout = 0, param_out = 0;
-	char *infile, *outfile, *prog, *engine;
-	char *passargin = NULL, *passargout = NULL;
 	char *passin = NULL, *passout = NULL;
-	point_conversion_form_t form = POINT_CONVERSION_UNCOMPRESSED;
-	int new_form = 0;
-	int asn1_flag = OPENSSL_EC_NAMED_CURVE;
-	int new_asn1_flag = 0;
 
-	engine = NULL;
-	infile = NULL;
-	outfile = NULL;
-	informat = FORMAT_PEM;
-	outformat = FORMAT_PEM;
+	memset(&ec_config, 0, sizeof(ec_config));
 
-	prog = argv[0];
-	argc--;
-	argv++;
-	while (argc >= 1) {
-		if (strcmp(*argv, "-inform") == 0) {
-			if (--argc < 1)
-				goto bad;
-			informat = str2fmt(*(++argv));
-		} else if (strcmp(*argv, "-outform") == 0) {
-			if (--argc < 1)
-				goto bad;
-			outformat = str2fmt(*(++argv));
-		} else if (strcmp(*argv, "-in") == 0) {
-			if (--argc < 1)
-				goto bad;
-			infile = *(++argv);
-		} else if (strcmp(*argv, "-out") == 0) {
-			if (--argc < 1)
-				goto bad;
-			outfile = *(++argv);
-		} else if (strcmp(*argv, "-passin") == 0) {
-			if (--argc < 1)
-				goto bad;
-			passargin = *(++argv);
-		} else if (strcmp(*argv, "-passout") == 0) {
-			if (--argc < 1)
-				goto bad;
-			passargout = *(++argv);
-		} else if (strcmp(*argv, "-engine") == 0) {
-			if (--argc < 1)
-				goto bad;
-			engine = *(++argv);
-		} else if (strcmp(*argv, "-noout") == 0)
-			noout = 1;
-		else if (strcmp(*argv, "-text") == 0)
-			text = 1;
-		else if (strcmp(*argv, "-conv_form") == 0) {
-			if (--argc < 1)
-				goto bad;
-			++argv;
-			new_form = 1;
-			if (strcmp(*argv, "compressed") == 0)
-				form = POINT_CONVERSION_COMPRESSED;
-			else if (strcmp(*argv, "uncompressed") == 0)
-				form = POINT_CONVERSION_UNCOMPRESSED;
-			else if (strcmp(*argv, "hybrid") == 0)
-				form = POINT_CONVERSION_HYBRID;
-			else
-				goto bad;
-		} else if (strcmp(*argv, "-param_enc") == 0) {
-			if (--argc < 1)
-				goto bad;
-			++argv;
-			new_asn1_flag = 1;
-			if (strcmp(*argv, "named_curve") == 0)
-				asn1_flag = OPENSSL_EC_NAMED_CURVE;
-			else if (strcmp(*argv, "explicit") == 0)
-				asn1_flag = 0;
-			else
-				goto bad;
-		} else if (strcmp(*argv, "-param_out") == 0)
-			param_out = 1;
-		else if (strcmp(*argv, "-pubin") == 0)
-			pubin = 1;
-		else if (strcmp(*argv, "-pubout") == 0)
-			pubout = 1;
-		else if ((enc = EVP_get_cipherbyname(&(argv[0][1]))) == NULL) {
-			BIO_printf(bio_err, "unknown option %s\n", *argv);
-			badops = 1;
-			break;
-		}
-		argc--;
-		argv++;
-	}
+	ec_config.asn1_flag = OPENSSL_EC_NAMED_CURVE;
+	ec_config.form = POINT_CONVERSION_UNCOMPRESSED;
+	ec_config.informat = FORMAT_PEM;
+	ec_config.outformat = FORMAT_PEM;
 
-	if (badops) {
-bad:
-		BIO_printf(bio_err, "%s [options] <infile >outfile\n", prog);
-		BIO_printf(bio_err, "where options are\n");
-		BIO_printf(bio_err, " -inform arg     input format - "
-		    "DER or PEM\n");
-		BIO_printf(bio_err, " -outform arg    output format - "
-		    "DER or PEM\n");
-		BIO_printf(bio_err, " -in arg         input file\n");
-		BIO_printf(bio_err, " -passin arg     input file pass "
-		    "phrase source\n");
-		BIO_printf(bio_err, " -out arg        output file\n");
-		BIO_printf(bio_err, " -passout arg    output file pass "
-		    "phrase source\n");
-		BIO_printf(bio_err, " -engine e       use engine e, "
-		    "possibly a hardware device.\n");
-		BIO_printf(bio_err, " -des            encrypt PEM output, "
-		    "instead of 'des' every other \n"
-		    "                 cipher "
-		    "supported by OpenSSL can be used\n");
-		BIO_printf(bio_err, " -text           print the key\n");
-		BIO_printf(bio_err, " -noout          don't print key out\n");
-		BIO_printf(bio_err, " -param_out      print the elliptic "
-		    "curve parameters\n");
-		BIO_printf(bio_err, " -conv_form arg  specifies the "
-		    "point conversion form \n");
-		BIO_printf(bio_err, "                 possible values:"
-		    " compressed\n");
-		BIO_printf(bio_err, "                                 "
-		    " uncompressed (default)\n");
-		BIO_printf(bio_err, "                                  "
-		    " hybrid\n");
-		BIO_printf(bio_err, " -param_enc arg  specifies the way"
-		    " the ec parameters are encoded\n");
-		BIO_printf(bio_err, "                 in the asn1 der "
-		    "encoding\n");
-		BIO_printf(bio_err, "                 possible values:"
-		    " named_curve (default)\n");
-		BIO_printf(bio_err, "                                  "
-		    "explicit\n");
+	if (options_parse(argc, argv, ec_options, NULL, NULL) != 0) {
+		ec_usage();
 		goto end;
 	}
 
 #ifndef OPENSSL_NO_ENGINE
-	setup_engine(bio_err, engine, 0);
+	setup_engine(bio_err, ec_config.engine, 0);
 #endif
 
-	if (!app_passwd(bio_err, passargin, passargout, &passin, &passout)) {
+	if (!app_passwd(bio_err, ec_config.passargin, ec_config.passargout,
+	    &passin, &passout)) {
 		BIO_printf(bio_err, "Error getting passwords\n");
 		goto end;
 	}
 	in = BIO_new(BIO_s_file());
 	out = BIO_new(BIO_s_file());
-	if ((in == NULL) || (out == NULL)) {
+	if (in == NULL || out == NULL) {
 		ERR_print_errors(bio_err);
 		goto end;
 	}
-	if (infile == NULL)
+	if (ec_config.infile == NULL)
 		BIO_set_fp(in, stdin, BIO_NOCLOSE);
 	else {
-		if (BIO_read_filename(in, infile) <= 0) {
-			perror(infile);
+		if (BIO_read_filename(in, ec_config.infile) <= 0) {
+			perror(ec_config.infile);
 			goto end;
 		}
 	}
 
 	BIO_printf(bio_err, "read EC key\n");
-	if (informat == FORMAT_ASN1) {
-		if (pubin)
+	if (ec_config.informat == FORMAT_ASN1) {
+		if (ec_config.pubin)
 			eckey = d2i_EC_PUBKEY_bio(in, NULL);
 		else
 			eckey = d2i_ECPrivateKey_bio(in, NULL);
-	} else if (informat == FORMAT_PEM) {
-		if (pubin)
+	} else if (ec_config.informat == FORMAT_PEM) {
+		if (ec_config.pubin)
 			eckey = PEM_read_bio_EC_PUBKEY(in, NULL, NULL,
 			    NULL);
 		else
@@ -272,49 +349,49 @@
 		ERR_print_errors(bio_err);
 		goto end;
 	}
-	if (outfile == NULL) {
+	if (ec_config.outfile == NULL) {
 		BIO_set_fp(out, stdout, BIO_NOCLOSE);
 	} else {
-		if (BIO_write_filename(out, outfile) <= 0) {
-			perror(outfile);
+		if (BIO_write_filename(out, ec_config.outfile) <= 0) {
+			perror(ec_config.outfile);
 			goto end;
 		}
 	}
 
 	group = EC_KEY_get0_group(eckey);
 
-	if (new_form)
-		EC_KEY_set_conv_form(eckey, form);
+	if (ec_config.new_form)
+		EC_KEY_set_conv_form(eckey, ec_config.form);
 
-	if (new_asn1_flag)
-		EC_KEY_set_asn1_flag(eckey, asn1_flag);
+	if (ec_config.new_asn1_flag)
+		EC_KEY_set_asn1_flag(eckey, ec_config.asn1_flag);
 
-	if (text)
+	if (ec_config.text)
 		if (!EC_KEY_print(out, eckey, 0)) {
-			perror(outfile);
+			perror(ec_config.outfile);
 			ERR_print_errors(bio_err);
 			goto end;
 		}
-	if (noout) {
+	if (ec_config.noout) {
 		ret = 0;
 		goto end;
 	}
 	BIO_printf(bio_err, "writing EC key\n");
-	if (outformat == FORMAT_ASN1) {
-		if (param_out)
+	if (ec_config.outformat == FORMAT_ASN1) {
+		if (ec_config.param_out)
 			i = i2d_ECPKParameters_bio(out, group);
-		else if (pubin || pubout)
+		else if (ec_config.pubin || ec_config.pubout)
 			i = i2d_EC_PUBKEY_bio(out, eckey);
 		else
 			i = i2d_ECPrivateKey_bio(out, eckey);
-	} else if (outformat == FORMAT_PEM) {
-		if (param_out)
+	} else if (ec_config.outformat == FORMAT_PEM) {
+		if (ec_config.param_out)
 			i = PEM_write_bio_ECPKParameters(out, group);
-		else if (pubin || pubout)
+		else if (ec_config.pubin || ec_config.pubout)
 			i = PEM_write_bio_EC_PUBKEY(out, eckey);
 		else
-			i = PEM_write_bio_ECPrivateKey(out, eckey, enc,
-			    NULL, 0, NULL, passout);
+			i = PEM_write_bio_ECPrivateKey(out, eckey,
+			    ec_config.enc, NULL, 0, NULL, passout);
 	} else {
 		BIO_printf(bio_err, "bad output format specified for "
 		    "outfile\n");