[thirdparty/openssl.git] / apps / dsaparam.c

/*
 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/opensslconf.h>

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "apps.h"
#include "progs.h"
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/bn.h>
#include <openssl/dsa.h>
#include <openssl/x509.h>
#include <openssl/pem.h>

static int verbose = 0;

static int gendsa_cb(EVP_PKEY_CTX *ctx);

typedef enum OPTION_choice {
    OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
    OPT_INFORM, OPT_OUTFORM, OPT_IN, OPT_OUT, OPT_TEXT, OPT_C,
    OPT_NOOUT, OPT_GENKEY, OPT_ENGINE, OPT_VERBOSE,
    OPT_R_ENUM, OPT_PROV_ENUM
} OPTION_CHOICE;

const OPTIONS dsaparam_options[] = {
    {OPT_HELP_STR, 1, '-', "Usage: %s [options] [numbits]\n"},

    OPT_SECTION("General"),
    {"help", OPT_HELP, '-', "Display this summary"},
#ifndef OPENSSL_NO_ENGINE
    {"engine", OPT_ENGINE, 's', "Use engine e, possibly a hardware device"},
#endif

    OPT_SECTION("Input"),
    {"in", OPT_IN, '<', "Input file"},
    {"inform", OPT_INFORM, 'F', "Input format - DER or PEM"},

    OPT_SECTION("Output"),
    {"out", OPT_OUT, '>', "Output file"},
    {"outform", OPT_OUTFORM, 'F', "Output format - DER or PEM"},
    {"text", OPT_TEXT, '-', "Print as text"},
    {"C", OPT_C, '-', "Output C code"},
    {"noout", OPT_NOOUT, '-', "No output"},
    {"verbose", OPT_VERBOSE, '-', "Verbose output"},
    {"genkey", OPT_GENKEY, '-', "Generate a DSA key"},

    OPT_R_OPTIONS,
    OPT_PROV_OPTIONS,

    OPT_PARAMETERS(),
    {"numbits", 0, 0, "Number of bits if generating parameters (optional)"},
    {NULL}
};

int dsaparam_main(int argc, char **argv)
{
    ENGINE *e = NULL;
    DSA *dsa = NULL;
    BIO *in = NULL, *out = NULL;
    EVP_PKEY *pkey = NULL;
    EVP_PKEY_CTX *ctx = NULL;
    int numbits = -1, num = 0, genkey = 0;
    int informat = FORMAT_PEM, outformat = FORMAT_PEM, noout = 0, C = 0;
    int ret = 1, i, text = 0, private = 0;
    char *infile = NULL, *outfile = NULL, *prog;
    OPTION_CHOICE o;

    prog = opt_init(argc, argv, dsaparam_options);
    while ((o = opt_next()) != OPT_EOF) {
        switch (o) {
        case OPT_EOF:
        case OPT_ERR:
 opthelp:
            BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
            goto end;
        case OPT_HELP:
            opt_help(dsaparam_options);
            ret = 0;
            goto end;
        case OPT_INFORM:
            if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
                goto opthelp;
            break;
        case OPT_IN:
            infile = opt_arg();
            break;
        case OPT_OUTFORM:
            if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
                goto opthelp;
            break;
        case OPT_OUT:
            outfile = opt_arg();
            break;
        case OPT_ENGINE:
            e = setup_engine(opt_arg(), 0);
            break;
        case OPT_TEXT:
            text = 1;
            break;
        case OPT_C:
            C = 1;
            break;
        case OPT_GENKEY:
            genkey = 1;
            break;
        case OPT_R_CASES:
            if (!opt_rand(o))
                goto end;
            break;
        case OPT_PROV_CASES:
            if (!opt_provider(o))
                goto end;
            break;
        case OPT_NOOUT:
            noout = 1;
            break;
        case OPT_VERBOSE:
            verbose = 1;
            break;
        }
    }
    argc = opt_num_rest();
    argv = opt_rest();

    if (argc == 1) {
        if (!opt_int(argv[0], &num) || num < 0)
            goto end;
        /* generate a key */
        numbits = num;
    }
    private = genkey ? 1 : 0;

    in = bio_open_default(infile, 'r', informat);
    if (in == NULL)
        goto end;
    out = bio_open_owner(outfile, outformat, private);
    if (out == NULL)
        goto end;

    ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL);
    if (ctx == NULL) {
        ERR_print_errors(bio_err);
        BIO_printf(bio_err,
                   "Error, DSA parameter generation context allocation failed\n");
        goto end;
    }
    if (numbits > 0) {
        if (numbits > OPENSSL_DSA_MAX_MODULUS_BITS)
            BIO_printf(bio_err,
                       "Warning: It is not recommended to use more than %d bit for DSA keys.\n"
                       "         Your key size is %d! Larger key size may behave not as expected.\n",
                       OPENSSL_DSA_MAX_MODULUS_BITS, numbits);

        EVP_PKEY_CTX_set_cb(ctx, gendsa_cb);
        EVP_PKEY_CTX_set_app_data(ctx, bio_err);
        if (verbose) {
            BIO_printf(bio_err, "Generating DSA parameters, %d bit long prime\n",
                       num);
            BIO_printf(bio_err, "This could take some time\n");
        }
        if (EVP_PKEY_paramgen_init(ctx) <= 0) {
            ERR_print_errors(bio_err);
            BIO_printf(bio_err,
                       "Error, DSA key generation paramgen init failed\n");
            goto end;
        }
        if (!EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, num)) {
            ERR_print_errors(bio_err);
            BIO_printf(bio_err,
                       "Error, DSA key generation setting bit length failed\n");
            goto end;
        }
        if (EVP_PKEY_paramgen(ctx, &pkey) <= 0) {
            ERR_print_errors(bio_err);
            BIO_printf(bio_err, "Error, DSA key generation failed\n");
            goto end;
        }
        dsa = EVP_PKEY_get1_DSA(pkey);
        if (dsa == NULL) {
            ERR_print_errors(bio_err);
            BIO_printf(bio_err, "Error, DSA key extraction failed\n");
            goto end;
        }
    } else if (informat == FORMAT_ASN1) {
        dsa = d2i_DSAparams_bio(in, NULL);
    } else {
        dsa = PEM_read_bio_DSAparams(in, NULL, NULL, NULL);
    }
    if (dsa == NULL) {
        BIO_printf(bio_err, "unable to load DSA parameters\n");
        ERR_print_errors(bio_err);
        goto end;
    }

    if (pkey == NULL) {
        pkey = EVP_PKEY_new();
        if (pkey == NULL) {
            BIO_printf(bio_err, "Error, unable to allocate PKEY object\n");
            ERR_print_errors(bio_err);
            goto end;
        }
        if (!EVP_PKEY_set1_DSA(pkey, dsa)) {
            BIO_printf(bio_err, "Error, unable to set DSA parameters\n");
            ERR_print_errors(bio_err);
            goto end;
        }
    }
    if (text) {
        EVP_PKEY_print_params(out, pkey, 0, NULL);
    }

    if (C) {
        const BIGNUM *p = NULL, *q = NULL, *g = NULL;
        unsigned char *data;
        int len, bits_p;

        DSA_get0_pqg(dsa, &p, &q, &g);
        len = BN_num_bytes(p);
        bits_p = BN_num_bits(p);

        data = app_malloc(len + 20, "BN space");

        BIO_printf(bio_out, "static DSA *get_dsa%d(void)\n{\n", bits_p);
        print_bignum_var(bio_out, p, "dsap", bits_p, data);
        print_bignum_var(bio_out, q, "dsaq", bits_p, data);
        print_bignum_var(bio_out, g, "dsag", bits_p, data);
        BIO_printf(bio_out, "    DSA *dsa = DSA_new();\n"
                            "    BIGNUM *p, *q, *g;\n"
                            "\n");
        BIO_printf(bio_out, "    if (dsa == NULL)\n"
                            "        return NULL;\n");
        BIO_printf(bio_out, "    if (!DSA_set0_pqg(dsa, p = BN_bin2bn(dsap_%d, sizeof(dsap_%d), NULL),\n",
                   bits_p, bits_p);
        BIO_printf(bio_out, "                           q = BN_bin2bn(dsaq_%d, sizeof(dsaq_%d), NULL),\n",
                   bits_p, bits_p);
        BIO_printf(bio_out, "                           g = BN_bin2bn(dsag_%d, sizeof(dsag_%d), NULL))) {\n",
                   bits_p, bits_p);
        BIO_printf(bio_out, "        DSA_free(dsa);\n"
                            "        BN_free(p);\n"
                            "        BN_free(q);\n"
                            "        BN_free(g);\n"
                            "        return NULL;\n"
                            "    }\n"
                            "    return dsa;\n}\n");
        OPENSSL_free(data);
    }

    if (outformat == FORMAT_ASN1 && genkey)
        noout = 1;

    if (!noout) {
        if (outformat == FORMAT_ASN1)
            i = i2d_DSAparams_bio(out, dsa);
        else
            i = PEM_write_bio_DSAparams(out, dsa);
        if (!i) {
            BIO_printf(bio_err, "unable to write DSA parameters\n");
            ERR_print_errors(bio_err);
            goto end;
        }
    }
    if (genkey) {
        DSA *dsakey;

        EVP_PKEY_CTX_free(ctx);
        ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL);
        if (ctx == NULL) {
            ERR_print_errors(bio_err);
            BIO_printf(bio_err,
                       "Error, DSA key generation context allocation failed\n");
            goto end;
        }
        if (!EVP_PKEY_keygen_init(ctx)) {
            BIO_printf(bio_err, "unable to initialise for key generation\n");
            ERR_print_errors(bio_err);
            goto end;
        }
        if (!EVP_PKEY_keygen(ctx, &pkey)) {
            BIO_printf(bio_err, "unable to generate key\n");
            ERR_print_errors(bio_err);
            goto end;
        }
        dsakey = EVP_PKEY_get0_DSA(pkey);
        if (dsakey == NULL) {
            BIO_printf(bio_err, "unable to extract generated key\n");
            ERR_print_errors(bio_err);
            goto end;
        }
        assert(private);
        if (outformat == FORMAT_ASN1)
            i = i2d_DSAPrivateKey_bio(out, dsakey);
        else
            i = PEM_write_bio_DSAPrivateKey(out, dsakey, NULL, NULL, 0, NULL,
                                            NULL);
    }
    ret = 0;
 end:
    BIO_free(in);
    BIO_free_all(out);
    EVP_PKEY_CTX_free(ctx);
    EVP_PKEY_free(pkey);
    DSA_free(dsa);
    release_engine(e);
    return ret;
}

static int gendsa_cb(EVP_PKEY_CTX *ctx)
{
    static const char symbols[] = ".+*\n";
    int p;
    char c;
    BIO *b;

    if (!verbose)
        return 1;

    b = EVP_PKEY_CTX_get_app_data(ctx);
    p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
    c = (p >= 0 && (size_t)p < sizeof(symbols) - 1) ? symbols[p] : '?';

    BIO_write(b, &c, 1);
    (void)BIO_flush(b);
    return 1;
}
Commit	Line	Data
	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	#include <openssl/opensslconf.h>
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <time.h>
	15	#include <string.h>
	16	#include "apps.h"
	17	#include "progs.h"
	18	#include <openssl/bio.h>
	19	#include <openssl/err.h>
	20	#include <openssl/bn.h>
	21	#include <openssl/dsa.h>
	22	#include <openssl/x509.h>
	23	#include <openssl/pem.h>
	24
	25	static int verbose = 0;
	26
	27	static int gendsa_cb(EVP_PKEY_CTX *ctx);
	28
	29	typedef enum OPTION_choice {
	30	OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
	31	OPT_INFORM, OPT_OUTFORM, OPT_IN, OPT_OUT, OPT_TEXT, OPT_C,
	32	OPT_NOOUT, OPT_GENKEY, OPT_ENGINE, OPT_VERBOSE,
	33	OPT_R_ENUM, OPT_PROV_ENUM
	34	} OPTION_CHOICE;
	35
	36	const OPTIONS dsaparam_options[] = {
	37	{OPT_HELP_STR, 1, '-', "Usage: %s [options] [numbits]\n"},
	38
	39	OPT_SECTION("General"),
	40	{"help", OPT_HELP, '-', "Display this summary"},
	41	#ifndef OPENSSL_NO_ENGINE
	42	{"engine", OPT_ENGINE, 's', "Use engine e, possibly a hardware device"},
	43	#endif
	44
	45	OPT_SECTION("Input"),
	46	{"in", OPT_IN, '<', "Input file"},
	47	{"inform", OPT_INFORM, 'F', "Input format - DER or PEM"},
	48
	49	OPT_SECTION("Output"),
	50	{"out", OPT_OUT, '>', "Output file"},
	51	{"outform", OPT_OUTFORM, 'F', "Output format - DER or PEM"},
	52	{"text", OPT_TEXT, '-', "Print as text"},
	53	{"C", OPT_C, '-', "Output C code"},
	54	{"noout", OPT_NOOUT, '-', "No output"},
	55	{"verbose", OPT_VERBOSE, '-', "Verbose output"},
	56	{"genkey", OPT_GENKEY, '-', "Generate a DSA key"},
	57
	58	OPT_R_OPTIONS,
	59	OPT_PROV_OPTIONS,
	60
	61	OPT_PARAMETERS(),
	62	{"numbits", 0, 0, "Number of bits if generating parameters (optional)"},
	63	{NULL}
	64	};
	65
	66	int dsaparam_main(int argc, char **argv)
	67	{
	68	ENGINE *e = NULL;
	69	DSA *dsa = NULL;
	70	BIO in = NULL, out = NULL;
	71	EVP_PKEY *pkey = NULL;
	72	EVP_PKEY_CTX *ctx = NULL;
	73	int numbits = -1, num = 0, genkey = 0;
	74	int informat = FORMAT_PEM, outformat = FORMAT_PEM, noout = 0, C = 0;
	75	int ret = 1, i, text = 0, private = 0;
	76	char infile = NULL, outfile = NULL, *prog;
	77	OPTION_CHOICE o;
	78
	79	prog = opt_init(argc, argv, dsaparam_options);
	80	while ((o = opt_next()) != OPT_EOF) {
	81	switch (o) {
	82	case OPT_EOF:
	83	case OPT_ERR:
	84	opthelp:
	85	BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
	86	goto end;
	87	case OPT_HELP:
	88	opt_help(dsaparam_options);
	89	ret = 0;
	90	goto end;
	91	case OPT_INFORM:
	92	if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
	93	goto opthelp;
	94	break;
	95	case OPT_IN:
	96	infile = opt_arg();
	97	break;
	98	case OPT_OUTFORM:
	99	if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
	100	goto opthelp;
	101	break;
	102	case OPT_OUT:
	103	outfile = opt_arg();
	104	break;
	105	case OPT_ENGINE:
	106	e = setup_engine(opt_arg(), 0);
	107	break;
	108	case OPT_TEXT:
	109	text = 1;
	110	break;
	111	case OPT_C:
	112	C = 1;
	113	break;
	114	case OPT_GENKEY:
	115	genkey = 1;
	116	break;
	117	case OPT_R_CASES:
	118	if (!opt_rand(o))
	119	goto end;
	120	break;
	121	case OPT_PROV_CASES:
	122	if (!opt_provider(o))
	123	goto end;
	124	break;
	125	case OPT_NOOUT:
	126	noout = 1;
	127	break;
	128	case OPT_VERBOSE:
	129	verbose = 1;
	130	break;
	131	}
	132	}
	133	argc = opt_num_rest();
	134	argv = opt_rest();
	135
	136	if (argc == 1) {
	137	if (!opt_int(argv[0], &num) \|\| num < 0)
	138	goto end;
	139	/* generate a key */
	140	numbits = num;
	141	}
	142	private = genkey ? 1 : 0;
	143
	144	in = bio_open_default(infile, 'r', informat);
	145	if (in == NULL)
	146	goto end;
	147	out = bio_open_owner(outfile, outformat, private);
	148	if (out == NULL)
	149	goto end;
	150
	151	ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL);
	152	if (ctx == NULL) {
	153	ERR_print_errors(bio_err);
	154	BIO_printf(bio_err,
	155	"Error, DSA parameter generation context allocation failed\n");
	156	goto end;
	157	}
	158	if (numbits > 0) {
	159	if (numbits > OPENSSL_DSA_MAX_MODULUS_BITS)
	160	BIO_printf(bio_err,
	161	"Warning: It is not recommended to use more than %d bit for DSA keys.\n"
	162	" Your key size is %d! Larger key size may behave not as expected.\n",
	163	OPENSSL_DSA_MAX_MODULUS_BITS, numbits);
	164
	165	EVP_PKEY_CTX_set_cb(ctx, gendsa_cb);
	166	EVP_PKEY_CTX_set_app_data(ctx, bio_err);
	167	if (verbose) {
	168	BIO_printf(bio_err, "Generating DSA parameters, %d bit long prime\n",
	169	num);
	170	BIO_printf(bio_err, "This could take some time\n");
	171	}
	172	if (EVP_PKEY_paramgen_init(ctx) <= 0) {
	173	ERR_print_errors(bio_err);
	174	BIO_printf(bio_err,
	175	"Error, DSA key generation paramgen init failed\n");
	176	goto end;
	177	}
	178	if (!EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, num)) {
	179	ERR_print_errors(bio_err);
	180	BIO_printf(bio_err,
	181	"Error, DSA key generation setting bit length failed\n");
	182	goto end;
	183	}
	184	if (EVP_PKEY_paramgen(ctx, &pkey) <= 0) {
	185	ERR_print_errors(bio_err);
	186	BIO_printf(bio_err, "Error, DSA key generation failed\n");
	187	goto end;
	188	}
	189	dsa = EVP_PKEY_get1_DSA(pkey);
	190	if (dsa == NULL) {
	191	ERR_print_errors(bio_err);
	192	BIO_printf(bio_err, "Error, DSA key extraction failed\n");
	193	goto end;
	194	}
	195	} else if (informat == FORMAT_ASN1) {
	196	dsa = d2i_DSAparams_bio(in, NULL);
	197	} else {
	198	dsa = PEM_read_bio_DSAparams(in, NULL, NULL, NULL);
	199	}
	200	if (dsa == NULL) {
	201	BIO_printf(bio_err, "unable to load DSA parameters\n");
	202	ERR_print_errors(bio_err);
	203	goto end;
	204	}
	205
	206	if (pkey == NULL) {
	207	pkey = EVP_PKEY_new();
	208	if (pkey == NULL) {
	209	BIO_printf(bio_err, "Error, unable to allocate PKEY object\n");
	210	ERR_print_errors(bio_err);
	211	goto end;
	212	}
	213	if (!EVP_PKEY_set1_DSA(pkey, dsa)) {
	214	BIO_printf(bio_err, "Error, unable to set DSA parameters\n");
	215	ERR_print_errors(bio_err);
	216	goto end;
	217	}
	218	}
	219	if (text) {
	220	EVP_PKEY_print_params(out, pkey, 0, NULL);
	221	}
	222
	223	if (C) {
	224	const BIGNUM p = NULL, q = NULL, *g = NULL;
	225	unsigned char *data;
	226	int len, bits_p;
	227
	228	DSA_get0_pqg(dsa, &p, &q, &g);
	229	len = BN_num_bytes(p);
	230	bits_p = BN_num_bits(p);
	231
	232	data = app_malloc(len + 20, "BN space");
	233
	234	BIO_printf(bio_out, "static DSA *get_dsa%d(void)\n{\n", bits_p);
	235	print_bignum_var(bio_out, p, "dsap", bits_p, data);
	236	print_bignum_var(bio_out, q, "dsaq", bits_p, data);
	237	print_bignum_var(bio_out, g, "dsag", bits_p, data);
	238	BIO_printf(bio_out, " DSA *dsa = DSA_new();\n"
	239	" BIGNUM p, q, *g;\n"
	240	"\n");
	241	BIO_printf(bio_out, " if (dsa == NULL)\n"
	242	" return NULL;\n");
	243	BIO_printf(bio_out, " if (!DSA_set0_pqg(dsa, p = BN_bin2bn(dsap_%d, sizeof(dsap_%d), NULL),\n",
	244	bits_p, bits_p);
	245	BIO_printf(bio_out, " q = BN_bin2bn(dsaq_%d, sizeof(dsaq_%d), NULL),\n",
	246	bits_p, bits_p);
	247	BIO_printf(bio_out, " g = BN_bin2bn(dsag_%d, sizeof(dsag_%d), NULL))) {\n",
	248	bits_p, bits_p);
	249	BIO_printf(bio_out, " DSA_free(dsa);\n"
	250	" BN_free(p);\n"
	251	" BN_free(q);\n"
	252	" BN_free(g);\n"
	253	" return NULL;\n"
	254	" }\n"
	255	" return dsa;\n}\n");
	256	OPENSSL_free(data);
	257	}
	258
	259	if (outformat == FORMAT_ASN1 && genkey)
	260	noout = 1;
	261
	262	if (!noout) {
	263	if (outformat == FORMAT_ASN1)
	264	i = i2d_DSAparams_bio(out, dsa);
	265	else
	266	i = PEM_write_bio_DSAparams(out, dsa);
	267	if (!i) {
	268	BIO_printf(bio_err, "unable to write DSA parameters\n");
	269	ERR_print_errors(bio_err);
	270	goto end;
	271	}
	272	}
	273	if (genkey) {
	274	DSA *dsakey;
	275
	276	EVP_PKEY_CTX_free(ctx);
	277	ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL);
	278	if (ctx == NULL) {
	279	ERR_print_errors(bio_err);
	280	BIO_printf(bio_err,
	281	"Error, DSA key generation context allocation failed\n");
	282	goto end;
	283	}
	284	if (!EVP_PKEY_keygen_init(ctx)) {
	285	BIO_printf(bio_err, "unable to initialise for key generation\n");
	286	ERR_print_errors(bio_err);
	287	goto end;
	288	}
	289	if (!EVP_PKEY_keygen(ctx, &pkey)) {
	290	BIO_printf(bio_err, "unable to generate key\n");
	291	ERR_print_errors(bio_err);
	292	goto end;
	293	}
	294	dsakey = EVP_PKEY_get0_DSA(pkey);
	295	if (dsakey == NULL) {
	296	BIO_printf(bio_err, "unable to extract generated key\n");
	297	ERR_print_errors(bio_err);
	298	goto end;
	299	}
	300	assert(private);
	301	if (outformat == FORMAT_ASN1)
	302	i = i2d_DSAPrivateKey_bio(out, dsakey);
	303	else
	304	i = PEM_write_bio_DSAPrivateKey(out, dsakey, NULL, NULL, 0, NULL,
	305	NULL);
	306	}
	307	ret = 0;
	308	end:
	309	BIO_free(in);
	310	BIO_free_all(out);
	311	EVP_PKEY_CTX_free(ctx);
	312	EVP_PKEY_free(pkey);
	313	DSA_free(dsa);
	314	release_engine(e);
	315	return ret;
	316	}
	317
	318	static int gendsa_cb(EVP_PKEY_CTX *ctx)
	319	{
	320	static const char symbols[] = ".+*\n";
	321	int p;
	322	char c;
	323	BIO *b;
	324
	325	if (!verbose)
	326	return 1;
	327
	328	b = EVP_PKEY_CTX_get_app_data(ctx);
	329	p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
	330	c = (p >= 0 && (size_t)p < sizeof(symbols) - 1) ? symbols[p] : '?';
	331
	332	BIO_write(b, &c, 1);
	333	(void)BIO_flush(b);
	334	return 1;
	335	}