vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d173dfe7cd4505aa50d109eee91c0c3c48e1d1db
RedBear-OS/local/recipes/libs/libgcrypt/source/tests/keygen.c
T
vasilito c825f470cb
redbear-ci / check (push) Has been cancelled
Details
libs: vendor libgcrypt 1.11.1 + libgpg-error 1.55; wire into kf6-kwallet 
kf6-kwallet's kwalletbackend hard-requires LibGcrypt 1.5.0 for PBKDF2 key
derivation and the GPG-backed wallet format. Vendor both libraries under the
full-fork model (committed source/, offline-reproducible) and add libgcrypt to
kf6-kwallet's dependencies.

Release tarballs ship a pre-generated configure and a config.sub that already
recognises the *-redox triple, so no autotools regeneration is needed at cook
time. libgpg-error supplies a generic pthread-backed gpgrt_lock_t for Redox via
its build script; the test-only redox.patch (tms/times stub) is baked into
libgcrypt's source and kept alongside for future version bumps.

Promoted from the stale recipes/wip copies (now .disabled).
2026-08-02 04:29:16 +03:00

898 lines
24 KiB
C
Raw Blame History

/* keygen.c - key generation regression tests
* Copyright (C) 2003, 2005, 2012 Free Software Foundation, Inc.
* Copyright (C) 2013, 2015 g10 Code GmbH
*
* This file is part of Libgcrypt.
*
* Libgcrypt is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* Libgcrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include "../src/gcrypt-int.h"
#define PGM "keygen"
#include "t-common.h"
static int in_fips_mode;
/* static void */
/* show_note (const char *format, ...) */
/* { */
/* va_list arg_ptr; */
/* if (!verbose && getenv ("srcdir")) */
/* fputs (" ", stderr); /\* To align above "PASS: ". *\/ */
/* else */
/* fprintf (stderr, "%s: ", PGM); */
/* va_start (arg_ptr, format); */
/* vfprintf (stderr, format, arg_ptr); */
/* if (*format && format[strlen(format)-1] != '\n') */
/* putc ('\n', stderr); */
/* va_end (arg_ptr); */
/* } */
static void
show_sexp (const char *prefix, gcry_sexp_t a)
{
char *buf;
size_t size;
fprintf (stderr, "%s: ", PGM);
if (prefix)
fputs (prefix, stderr);
size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
buf = xmalloc (size);
gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
fprintf (stderr, "%.*s", (int)size, buf);
gcry_free (buf);
}
#if USE_RSA
static void
show_mpi (const char *prefix, gcry_mpi_t a)
{
char *buf;
void *bufaddr = &buf;
gcry_error_t rc;
fprintf (stderr, "%s: ", PGM);
if (prefix)
fputs (prefix, stderr);
rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
if (rc)
fprintf (stderr, "[error printing number: %s]\n", gpg_strerror (rc));
else
{
fprintf (stderr, "%s\n", buf);
gcry_free (buf);
}
}
static void
check_generated_rsa_key (gcry_sexp_t key, unsigned long expected_e)
{
gcry_sexp_t skey, pkey, list;
pkey = gcry_sexp_find_token (key, "public-key", 0);
if (!pkey)
fail ("public part missing in return value\n");
else
{
gcry_mpi_t e = NULL;
list = gcry_sexp_find_token (pkey, "e", 0);
if (!list || !(e=gcry_sexp_nth_mpi (list, 1, 0)) )
fail ("public exponent not found\n");
else if (!expected_e)
{
if (verbose)
show_mpi ("public exponent: ", e);
}
else if ( gcry_mpi_cmp_ui (e, expected_e))
{
show_mpi ("public exponent: ", e);
fail ("public exponent is not %lu\n", expected_e);
}
gcry_sexp_release (list);
gcry_mpi_release (e);
gcry_sexp_release (pkey);
}
skey = gcry_sexp_find_token (key, "private-key", 0);
if (!skey)
fail ("private part missing in return value\n");
else
{
int rc = gcry_pk_testkey (skey);
if (rc)
fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
gcry_sexp_release (skey);
}
}
#endif /* USE_RSA */
static void
check_rsa_keys (void)
{
#if USE_RSA
gcry_sexp_t keyparm, key;
int rc;
if (verbose)
info ("creating 2048 bit RSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (rsa\n"
" (nbits 4:2048)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating RSA key: %s\n", gpg_strerror (rc));
if (verbose)
info ("creating 1024 bit RSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (rsa\n"
" (nbits 4:1024)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
gcry_sexp_release (key);
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
fail ("error generating RSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
fail ("generating 1024 bit RSA key must not work!");
if (!rc)
{
if (verbose > 1)
show_sexp ("1024 bit RSA key:\n", key);
check_generated_rsa_key (key, 65537);
}
gcry_sexp_release (key);
if (verbose)
info ("creating 2048 bit RSA key with e=65539\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (rsa\n"
" (nbits 4:2048)\n"
" (rsa-use-e 5:65539)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
fail ("error generating RSA key: %s\n", gpg_strerror (rc));
if (!rc)
check_generated_rsa_key (key, 65539);
gcry_sexp_release (key);
if (verbose)
info ("creating 512 bit RSA key with e=257\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (rsa\n"
" (nbits 3:512)\n"
" (rsa-use-e 3:257)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
fail ("error generating RSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
fail ("generating 512 bit RSA key must not work!");
if (verbose && rc && in_fips_mode)
info ("... correctly rejected key creation in FIPS mode (%s)\n",
gpg_strerror (rc));
if (!rc)
check_generated_rsa_key (key, 257);
gcry_sexp_release (key);
if (verbose)
info ("creating 512 bit RSA key with default e\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (rsa\n"
" (nbits 3:512)\n"
" (rsa-use-e 1:0)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
fail ("error generating RSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
fail ("generating 512 bit RSA key must not work!");
if (verbose && rc && in_fips_mode)
info ("... correctly rejected key creation in FIPS mode (%s)\n",
gpg_strerror (rc));
if (!rc)
check_generated_rsa_key (key, 0); /* We don't expect a constant exponent. */
gcry_sexp_release (key);
#endif /* USE_RSA */
}
static void
check_elg_keys (void)
{
#if USE_ELGAMAL
gcry_sexp_t keyparm, key;
int rc;
if (verbose)
info ("creating 1024 bit Elgamal key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (elg\n"
" (nbits 4:1024)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating Elgamal key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating Elgamal key must not work in FIPS mode.");
if (verbose > 1)
show_sexp ("1024 bit Elgamal key:\n", key);
gcry_sexp_release (key);
#endif /* USE_ELGAMAL */
}
static void
check_dsa_keys (void)
{
#if USE_DSA
gcry_sexp_t keyparm, key;
int rc;
int i;
/* Check that DSA generation works and that it can grok the qbits
argument. */
if (verbose)
info ("creating 5 1024 bit DSA keys\n");
for (i=0; i < 5; i++)
{
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (dsa\n"
" (nbits 4:1024)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating DSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating 1024 bit DSA key must not work in FIPS mode!");
if (!i && verbose > 1)
show_sexp ("1024 bit DSA key:\n", key);
gcry_sexp_release (key);
}
if (verbose)
info ("creating 1536 bit DSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (dsa\n"
" (nbits 4:1536)\n"
" (qbits 3:224)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating DSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating 1536 bit DSA key must not work in FIPS mode!");
if (verbose > 1)
show_sexp ("1536 bit DSA key:\n", key);
gcry_sexp_release (key);
if (verbose)
info ("creating 3072 bit DSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (dsa\n"
" (nbits 4:3072)\n"
" (qbits 3:256)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating DSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating DSA key must not work in FIPS mode!");
if (verbose > 1)
show_sexp ("3072 bit DSA key:\n", key);
gcry_sexp_release (key);
if (verbose)
info ("creating 2048/256 bit DSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (dsa\n"
" (nbits 4:2048)\n"
" (qbits 3:256)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating DSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating DSA key must not work in FIPS mode!");
if (verbose > 1)
show_sexp ("2048 bit DSA key:\n", key);
gcry_sexp_release (key);
if (verbose)
info ("creating 2048/224 bit DSA key\n");
rc = gcry_sexp_new (&keyparm,
"(genkey\n"
" (dsa\n"
" (nbits 4:2048)\n"
" (qbits 3:224)\n"
" ))", 0, 1);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc && !in_fips_mode)
die ("error generating DSA key: %s\n", gpg_strerror (rc));
else if (!rc && in_fips_mode)
die ("generating DSA key must not work in FIPS mode!");
if (verbose > 1)
show_sexp ("2048 bit DSA key:\n", key);
gcry_sexp_release (key);
#endif /* USE_DSA */
}
#if USE_ECC
static void
check_generated_ecc_key (gcry_sexp_t key)
{
gcry_sexp_t skey, pkey;
pkey = gcry_sexp_find_token (key, "public-key", 0);
if (!pkey)
fail ("public part missing in return value\n");
else
{
/* Fixme: Check more stuff. */
gcry_sexp_release (pkey);
}
skey = gcry_sexp_find_token (key, "private-key", 0);
if (!skey)
fail ("private part missing in return value\n");
else
{
int rc = gcry_pk_testkey (skey);
if (rc)
fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
gcry_sexp_release (skey);
}
/* Finally check that gcry_pk_testkey also works on the entire
S-expression. */
{
int rc = gcry_pk_testkey (key);
if (rc)
fail ("gcry_pk_testkey failed on key pair: %s\n", gpg_strerror (rc));
}
}
#endif /* USE_ECC */
static void
check_ecc_keys (void)
{
#if USE_ECC
const char *curves[] = { "NIST P-521", "NIST P-384", "NIST P-256",
"Ed25519", NULL };
int testno;
gcry_sexp_t keyparm, key;
int rc;
for (testno=0; curves[testno]; testno++)
{
if (verbose)
info ("creating ECC key using curve %s\n", curves[testno]);
if (!strcmp (curves[testno], "Ed25519"))
{
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve %s)(flags param eddsa)))",
curves[testno]);
}
else
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve %s)(flags param)))",
curves[testno]);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve %s: %s\n",
curves[testno], gpg_strerror (rc));
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
gcry_sexp_release (key);
}
if (verbose)
info ("creating ECC key using curve Ed25519 for ECDSA\n");
rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve Ed25519)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve Ed25519 for ECDSA: %s\n",
gpg_strerror (rc));
if (!rc)
{
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
}
gcry_sexp_release (key);
if (verbose)
info ("creating ECC key using curve Ed25519 for ECDSA (nocomp)\n");
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve Ed25519)(flags nocomp)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve Ed25519 for ECDSA"
" (nocomp): %s\n",
gpg_strerror (rc));
gcry_sexp_release (key);
if (verbose)
info ("creating ECC key using curve NIST P-384 for ECDSA\n");
/* Must be specified as nistp384 (one word), because ecc_generate
* uses _gcry_sexp_nth_string which takes the first word of the name
* and thus libgcrypt can't find it later in its curves table. */
rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve nistp384)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve NIST P-384 for ECDSA: %s\n",
gpg_strerror (rc));
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
gcry_sexp_release (key);
if (verbose)
info ("creating ECC key using curve NIST P-384 for ECDSA (nocomp)\n");
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve nistp384)(flags nocomp)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve NIST P-384 for ECDSA"
" (nocomp): %s\n",
gpg_strerror (rc));
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
gcry_sexp_release (key);
if (verbose)
info ("creating ECC key using curve Ed25519 for ECDSA (transient-key)\n");
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve Ed25519)(flags transient-key)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve Ed25519 for ECDSA"
" (transient-key): %s\n",
gpg_strerror (rc));
if (!rc)
{
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
}
gcry_sexp_release (key);
if (verbose)
info ("creating ECC key using curve Ed25519 for ECDSA "
"(transient-key no-keytest)\n");
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey(ecc(curve Ed25519)"
"(flags transient-key no-keytest)))");
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (rc)
die ("error generating ECC key using curve Ed25519 for ECDSA"
" (transient-key no-keytest): %s\n",
gpg_strerror (rc));
if (!rc)
{
if (verbose > 1)
show_sexp ("ECC key:\n", key);
check_generated_ecc_key (key);
}
gcry_sexp_release (key);
#endif /* USE_ECC */
}
static void
check_generated_kem_key (gcry_sexp_t key, const char *algoname)
{
gpg_error_t err;
gcry_sexp_t skey, pkey;
unsigned char keygrip_pk[20];
unsigned char keygrip_all[20];
int n, nbits;
const char *s;
pkey = gcry_sexp_find_token (key, "public-key", 0);
if (!pkey)
fail ("public part missing in return value\n");
else
{
if (!gcry_pk_get_keygrip (pkey, keygrip_pk))
fail ("gcry_pk_get_keyrip for pubkey failed\n");
gcry_sexp_release (pkey);
}
skey = gcry_sexp_find_token (key, "private-key", 0);
if (!skey)
fail ("private part missing in return value\n");
else
{
err = gcry_pk_testkey (skey);
if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED)
info ("note: gcry_pk_testkey has not yet been implemented\n");
else if (err)
fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (err));
gcry_sexp_release (skey);
}
/* Finally check that gcry_pk_testkey also works on the entire
S-expression. */
err = gcry_pk_testkey (key);
if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED)
info ("note: gcry_pk_testkey has not yet been implemented\n");
else if (err)
fail ("gcry_pk_testkey failed on keypair: %s\n", gpg_strerror (err));
if (!gcry_pk_get_keygrip (key, keygrip_all))
fail ("gcry_pk_get_keyrip for all failed\n");
if (memcmp (keygrip_pk, keygrip_all, 20))
fail ("keygrips do not match\n");
/* Simple hack to check nbits. */
nbits = gcry_pk_get_nbits (key);
n = 0;
for (s=algoname; !isdigit (*s); s++)
;
n = atoi (s);
if (n != nbits)
fail ("gcry_pk_get_nbits returned a wrong value n=%d nbits=%d\n", n, nbits);
}
#define TEST_NOFIPS (1 << 0)
static void
check_kem_keys (void)
{
const struct {
const char *algonames;
int flags;
} tv[] = {
{ "sntrup761", TEST_NOFIPS },
{ "kyber512", TEST_NOFIPS },
{ "kyber768", TEST_NOFIPS },
{ "kyber1024", TEST_NOFIPS },
};
int testno;
gcry_sexp_t keyparm, key;
int rc;
for (testno=0; testno < DIM (tv); testno++)
{
if (verbose)
info ("creating KEM key using algo %s\n", tv[testno].algonames);
rc = gcry_sexp_build (&keyparm, NULL, "(genkey(%s))",
tv[testno].algonames);
if (rc)
die ("error creating S-expression: %s\n", gpg_strerror (rc));
rc = gcry_pk_genkey (&key, keyparm);
gcry_sexp_release (keyparm);
if (in_fips_mode && (tv[testno].flags & TEST_NOFIPS))
{
if (!rc)
die ("KEM: creating %s key should have failed in fips mode\n",
tv[testno].algonames);
continue;
}
else
{
if (rc)
die ("error creating KEM key using algo %s: %s\n",
tv[testno].algonames, gpg_strerror (rc));
}
if (verbose > 1)
show_sexp ("KEM key:\n", key);
check_generated_kem_key (key, tv[testno].algonames);
gcry_sexp_release (key);
}
}
static void
check_nonce (void)
{
char a[32], b[32];
int i,j;
int oops=0;
if (verbose)
info ("checking gcry_create_nonce\n");
gcry_create_nonce (a, sizeof a);
for (i=0; i < 10; i++)
{
gcry_create_nonce (b, sizeof b);
if (!memcmp (a, b, sizeof a))
die ("identical nonce found\n");
}
for (i=0; i < 10; i++)
{
gcry_create_nonce (a, sizeof a);
if (!memcmp (a, b, sizeof a))
die ("identical nonce found\n");
}
again:
for (i=1,j=0; i < sizeof a; i++)
if (a[0] == a[i])
j++;
if (j+1 == sizeof (a))
{
if (oops)
die ("impossible nonce found\n");
oops++;
gcry_create_nonce (a, sizeof a);
goto again;
}
}
static void
progress_cb (void *cb_data, const char *what, int printchar,
int current, int total)
{
(void)cb_data;
(void)what;
(void)current;
(void)total;
if (printchar == '\n')
fputs ( "<LF>", stdout);
else
putchar (printchar);
fflush (stdout);
}
static void
usage (int mode)
{
fputs ("usage: " PGM " [options] [{rsa|elg|dsa|ecc|nonce}]\n"
"Options:\n"
" --verbose be verbose\n"
" --debug flyswatter\n"
" --fips run in FIPS mode\n"
" --no-quick To not use the quick RNG hack\n"
" --progress print progress indicators\n",
mode? stderr : stdout);
if (mode)
exit (1);
}
int
main (int argc, char **argv)
{
int last_argc = -1;
int opt_fips = 0;
int with_progress = 0;
int no_quick = 0;
if (argc)
{ argc--; argv++; }
while (argc && last_argc != argc )
{
last_argc = argc;
if (!strcmp (*argv, "--"))
{
argc--; argv++;
break;
}
else if (!strcmp (*argv, "--help"))
{
usage (0);
exit (0);
}
else if (!strcmp (*argv, "--verbose"))
{
verbose++;
argc--; argv++;
}
else if (!strcmp (*argv, "--debug"))
{
verbose += 2;
debug++;
argc--; argv++;
}
else if (!strcmp (*argv, "--fips"))
{
argc--; argv++;
opt_fips = 1;
}
else if (!strcmp (*argv, "--progress"))
{
argc--; argv++;
with_progress = 1;
}
else if (!strcmp (*argv, "--no-quick"))
{
argc--; argv++;
no_quick = 1;
}
else if (!strncmp (*argv, "--", 2))
die ("unknown option '%s'", *argv);
else
break;
}
xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
if (opt_fips)
xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
if (!gcry_check_version (GCRYPT_VERSION))
die ("version mismatch\n");
if (!opt_fips)
xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
if (debug)
xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
/* No valuable keys are create, so we can speed up our RNG. */
if (!no_quick)
xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
if (with_progress)
gcry_set_progress_handler (progress_cb, NULL);
if ( gcry_fips_mode_active () )
in_fips_mode = 1;
if (opt_fips && !in_fips_mode)
die ("failed to switch into FIPS mode\n");
if (!argc)
{
check_rsa_keys ();
check_elg_keys ();
check_dsa_keys ();
check_ecc_keys ();
check_kem_keys ();
check_nonce ();
}
else
{
for (; argc; argc--, argv++)
if (!strcmp (*argv, "rsa"))
check_rsa_keys ();
else if (!strcmp (*argv, "elg"))
check_elg_keys ();
else if (!strcmp (*argv, "dsa"))
check_dsa_keys ();
else if (!strcmp (*argv, "ecc"))
check_ecc_keys ();
else if (!strcmp (*argv, "kem"))
check_kem_keys ();
else if (!strcmp (*argv, "nonce"))
check_nonce ();
else
usage (1);
}
return error_count? 1:0;
}
Reference in New Issue View Git Blame Copy Permalink