static int
generate_subkey( cdk_keygen_ctx_t hd )
{
gcry_sexp_t s_params = NULL, s_key;
size_t n = hd->key[1].len;
int rc;
if( !hd )
return CDK_Inv_Value;
if( is_DSA( hd->key[1].algo) )
rc = gcry_sexp_build( &s_params, NULL, "(genkey(dsa(nbits %d)))", n );
else if( is_ELG( hd->key[1].algo) )
rc = gcry_sexp_build( &s_params, NULL, "(genkey(elg(nbits %d)))", n );
else if( is_RSA( hd->key[1].algo) )
rc = gcry_sexp_build( &s_params, NULL, "(genkey(rsa(nbits %d)))", n );
else
rc = CDK_Inv_Algo;
if( !rc )
rc = gcry_pk_genkey( &s_key, s_params );
gcry_sexp_release( s_params );
if( !rc ) {
if( is_DSA( hd->key[1].algo) )
rc = read_dsa_key( s_key, hd->key[1].resarr );
else if( is_ELG( hd->key[1].algo) )
rc = read_elg_key( s_key, hd->key[1].resarr );
else if( is_RSA( hd->key[1].algo) )
rc = read_rsa_key( s_key, hd->key[1].resarr );
}
hd->key[1].n = cdk_pk_get_npkey( hd->key[1].algo );
gcry_sexp_release( s_key );
return rc;
}
int
main(int argc, char **argv)
{
struct rsa_private_key key;
struct rsa_session ctx;
struct rsa_session_info session;
unsigned length;
mpz_t x;
mpz_init(x);
if (argc != 2)
{
werror("Usage: rsa-decrypt PRIVATE-KEY < ciphertext\n");
return EXIT_FAILURE;
}
rsa_private_key_init(&key);
if (!read_rsa_key(argv[1], NULL, &key))
{
werror("Invalid key\n");
return EXIT_FAILURE;
}
if (!read_version(stdin))
{
werror("Bad version number in input file.\n");
return EXIT_FAILURE;
}
if (!read_bignum(stdin, x))
{
werror("Bad rsa header in input file.\n");
return EXIT_FAILURE;
}
length = sizeof(session.key);
if (!rsa_decrypt(&key, &length, session.key, x) || length != sizeof(session.key))
{
werror("Failed to decrypt rsa header in input file.\n");
return EXIT_FAILURE;
}
mpz_clear(x);
rsa_session_set_decrypt_key(&ctx, &session);
if (!process_file(&ctx,
stdin, stdout))
return EXIT_FAILURE;
rsa_private_key_clear(&key);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
struct rsa_public_key key;
struct sha1_ctx hash;
mpz_t s;
if (argc != 3)
{
werror("Usage: rsa-verify PUBLIC-KEY SIGNATURE-FILE < FILE\n");
return EXIT_FAILURE;
}
rsa_public_key_init(&key);
if (!read_rsa_key(argv[1], &key, NULL))
{
werror("Invalid key\n");
return EXIT_FAILURE;
}
mpz_init(s);
if (!read_signature(argv[2], s))
{
werror("Failed to read signature file `%s'\n",
argv[2]);
return EXIT_FAILURE;
}
sha1_init(&hash);
if (!hash_file(&nettle_sha1, &hash, stdin))
{
werror("Failed reading stdin: %s\n",
strerror(errno));
return 0;
}
if (!rsa_sha1_verify(&key, &hash, s))
{
werror("Invalid signature!\n");
return EXIT_FAILURE;
}
mpz_clear(s);
rsa_public_key_clear(&key);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
rsa_pub pub;
rsa_priv key;
int do_seed = 1;
int MODULUS_BITS = 2048;
ZZ E; E = 65537;
char *filein = NULL;
char *filename = "/dev/fd/1"; // stdout
int c;
while((c = getopt(argc, argv, "e:n:so:i:h")) != EOF)
switch (c)
{
case 'e':
E = atoi(optarg);
break;
case 'n':
MODULUS_BITS = atoi(optarg);
break;
case 's':
do_seed = 0;
break;
case 'i':
filein = optarg;
break;
case 'o':
filename = optarg;
break;
case 'h':
usage();
exit(0);
}
if (do_seed)
seed();
if (filein)
read_rsa_key(filein, pub, key, MODULUS_BITS);
else
make_rsa_key(pub, key, MODULUS_BITS, E);
write_rsa_key(filename, pub, key, MODULUS_BITS);
return 0;
}
/**
* cdk_keygen_start: kick off the key generation
* @hd: the keygen object
*
**/
cdk_error_t
cdk_keygen_start( cdk_keygen_ctx_t hd )
{
gcry_sexp_t s_params = NULL, s_key = NULL;
size_t n;
int rc = 0;
if( !hd || !hd->user_id )
return CDK_Inv_Value;
if( is_ELG( hd->key[0].algo ) )
return CDK_Inv_Mode;
if( !hd->key[0].len )
hd->key[0].len = 1024;
n = hd->key[0].len;
if( !hd->sym_prefs )
cdk_keygen_set_prefs( hd, CDK_PREFTYPE_SYM, NULL, 0 );
if( !hd->hash_prefs )
cdk_keygen_set_prefs( hd, CDK_PREFTYPE_HASH, NULL, 0 );
if( !hd->zip_prefs )
cdk_keygen_set_prefs( hd, CDK_PREFTYPE_ZIP, NULL, 0 );
if( is_DSA( hd->key[0].algo ) )
rc = gcry_sexp_build( &s_params, NULL, "(genkey(dsa(nbits %d)))", n );
else if( is_RSA( hd->key[0].algo ) )
rc = gcry_sexp_build( &s_params, NULL, "(genkey(rsa(nbits %d)))", n );
else
rc = CDK_Inv_Algo;
if( !rc )
rc = gcry_pk_genkey( &s_key, s_params );
gcry_sexp_release( s_params );
if( !rc ) {
if( is_DSA( hd->key[0].algo ) )
rc = read_dsa_key( s_key, hd->key[0].resarr );
else if( is_RSA( hd->key[0].algo ) )
rc = read_rsa_key( s_key, hd->key[0].resarr );
hd->key[0].n = cdk_pk_get_npkey( hd->key[0].algo );
}
gcry_sexp_release( s_key );
if( !rc ) {
if( hd->key[1].algo && hd->key[1].len )
rc = generate_subkey( hd );
}
return rc;
}
int
main(int argc, char **argv)
{
struct rsa_session ctx;
struct rsa_session_info info;
struct rsa_public_key key;
mpz_t x;
int c;
const char *random_name = NULL;
enum { OPT_HELP = 300 };
static const struct option options[] =
{
/* Name, args, flag, val */
{ "help", no_argument, NULL, OPT_HELP },
{ "random", required_argument, NULL, 'r' },
{ NULL, 0, NULL, 0}
};
while ( (c = getopt_long(argc, argv, "o:r:", options, NULL)) != -1)
switch (c)
{
case 'r':
random_name = optarg;
break;
case '?':
return EXIT_FAILURE;
case OPT_HELP:
usage(stdout);
return EXIT_SUCCESS;
default:
abort();
}
argv += optind;
argc -= optind;
if (argc != 1)
{
usage (stderr);
return EXIT_FAILURE;
}
rsa_public_key_init(&key);
if (!read_rsa_key(argv[0], &key, NULL))
{
werror("Invalid key\n");
return EXIT_FAILURE;
}
/* NOTE: No sources */
yarrow256_init(&ctx.yarrow, 0, NULL);
/* Read some data to seed the generator */
if (!simple_random(&ctx.yarrow, random_name))
{
werror("Initialization of randomness generator failed.\n");
return EXIT_FAILURE;
}
WRITE_UINT32(SESSION_VERSION(&info), RSA_VERSION);
yarrow256_random(&ctx.yarrow, sizeof(info.key) - 4, info.key + 4);
rsa_session_set_encrypt_key(&ctx, &info);
#ifdef WIN32
_setmode(0, O_BINARY);
_setmode(1, O_BINARY);
#endif
write_version(stdout);
mpz_init(x);
if (!rsa_encrypt(&key,
&ctx.yarrow, (nettle_random_func *) yarrow256_random,
sizeof(info.key), info.key,
x))
{
werror("RSA encryption failed.\n");
return EXIT_FAILURE;
}
write_bignum(stdout, x);
mpz_clear (x);
if (!process_file(&ctx,
stdin, stdout))
return EXIT_FAILURE;
rsa_public_key_clear(&key);
return EXIT_SUCCESS;
}
