*
* Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
*
- * Copyright (C) 1997 - 2000 Pekka Riikonen
+ * Copyright (C) 1997 - 2001 Pekka Riikonen
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* Public key exponent:
* e relatively prime to (p-1) * (q-1)
* Private key exponent:
- * d = e ^ -1 mod ((p-1) * (q-1))
+ * d = e ^ -1 mod lcm(((p-1) * (q-1)))
*
* Encryption:
* c = m ^ e mod n
*/
/* $Id$ */
+/*
+ ChangeLog
+
+ o Mon Feb 12 11:20:32 EET 2001 Pekka
+
+ Changed RSA private exponent generation to what PKCS #1 suggests. We
+ try to find the smallest possible d by doing modinv(e, lcm(phi)) instead
+ of modinv(e, phi). Note: this is not security fix but optimization.
+
+ o Tue Feb 20 13:58:58 EET 2001 Pekka
+
+ Set key->bits in rsa_generate_key. It is the modulus length in bits.
+ The `tmplen' in encrypt, decrypt, sign and verify PKCS API functions
+ is now calculated by (key->bits + 7) / 8. It is the length of one block.
+
+*/
+
#include "silcincludes.h"
#include "rsa.h"
SILC_PKCS_API_INIT(rsa)
{
- unsigned int prime_bits = keylen / 2;
+ uint32 prime_bits = keylen / 2;
SilcInt p, q;
printf("Generating RSA Public and Private keys, might take a while...\n");
{
RsaKey *key = (RsaKey *)context;
unsigned char *e, *n, *ret;
- unsigned int e_len, n_len;
+ uint32 e_len, n_len;
unsigned char tmp[4];
- e = silc_mp_mp2bin(&key->e, &e_len);
- n = silc_mp_mp2bin(&key->n, &n_len);
+ e = silc_mp_mp2bin(&key->e, 0, &e_len);
+ n = silc_mp_mp2bin(&key->n, key->bits / 8, &n_len);
*ret_len = e_len + 4 + n_len + 4;
ret = silc_calloc(*ret_len, sizeof(unsigned char));
{
RsaKey *key = (RsaKey *)context;
unsigned char *e, *n, *d, *ret;
- unsigned int e_len, n_len, d_len;
+ uint32 e_len, n_len, d_len;
unsigned char tmp[4];
- e = silc_mp_mp2bin(&key->e, &e_len);
- n = silc_mp_mp2bin(&key->n, &n_len);
- d = silc_mp_mp2bin(&key->d, &d_len);
+ e = silc_mp_mp2bin(&key->e, 0, &e_len);
+ n = silc_mp_mp2bin(&key->n, key->bits / 8, &n_len);
+ d = silc_mp_mp2bin(&key->d, 0, &d_len);
*ret_len = e_len + 4 + n_len + 4 + d_len + 4;
ret = silc_calloc(*ret_len, sizeof(unsigned char));
{
RsaKey *key = (RsaKey *)context;
unsigned char tmp[4];
- unsigned int e_len, n_len;
+ uint32 e_len, n_len;
silc_mp_init(&key->e);
silc_mp_init(&key->n);
if (e_len > key_len) {
silc_mp_clear(&key->e);
silc_mp_clear(&key->n);
- return FALSE;
+ return 0;
}
silc_mp_bin2mp(key_data + 4, e_len, &key->e);
if (e_len + n_len > key_len) {
silc_mp_clear(&key->e);
silc_mp_clear(&key->n);
- return FALSE;
+ return 0;
}
silc_mp_bin2mp(key_data + 4 + e_len + 4, n_len, &key->n);
- return TRUE;
+ key->bits = n_len * 8;
+
+ return key->bits;
}
/* Set private key. This derives the public key from the private
{
RsaKey *key = (RsaKey *)context;
unsigned char tmp[4];
- unsigned int e_len, n_len, d_len;
+ uint32 e_len, n_len, d_len;
silc_mp_init(&key->e);
silc_mp_init(&key->n);
silc_mp_bin2mp(key_data + 4 + e_len + 4 + n_len + 4, d_len, &key->d);
+ key->bits = n_len * 8;
+
return TRUE;
}
return sizeof(RsaKey);
}
-SILC_PKCS_API_DATA_CONTEXT_LEN(rsa)
-{
- return sizeof(RsaDataContext);
-}
-
-SILC_PKCS_API_SET_ARG(rsa)
-{
- RsaDataContext *data_ctx = (RsaDataContext *)data_context;
-
- switch(argnum) {
- case 1:
- data_ctx->src = val;
- return TRUE;
- break;
- case 2:
- data_ctx->dst = val;
- return TRUE;
- break;
- case 3:
- data_ctx->exp = val;
- return TRUE;
- break;
- case 4:
- data_ctx->mod = val;
- return TRUE;
- break;
- default:
- return FALSE;
- break;
- }
-
- return FALSE;
-}
-
SILC_PKCS_API_ENCRYPT(rsa)
{
RsaKey *key = (RsaKey *)context;
/* Encrypt */
rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->e, &key->n);
- tmplen = (1024 + 7) / 8;
+ tmplen = (key->bits + 7) / 8;
/* Format the MP int back into data */
for (i = tmplen; i > 0; i--) {
/* Decrypt */
rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->d, &key->n);
- tmplen = (1024 + 7) / 8;
+ tmplen = (key->bits + 7) / 8;
/* Format the MP int back into data */
for (i = tmplen; i > 0; i--) {
/* Sign */
rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->d, &key->n);
- tmplen = (1024 + 7) / 8;
+ tmplen = (key->bits + 7) / 8;
/* Format the MP int back into data */
for (i = tmplen; i > 0; i--) {
to compute the modulus n has to be generated before calling this. They
are then sent as argument for the function. */
-void rsa_generate_keys(RsaKey *key, unsigned int bits,
+void rsa_generate_keys(RsaKey *key, uint32 bits,
SilcInt *p, SilcInt *q)
{
SilcInt phi, hlp;
- SilcInt dq;
+ SilcInt div, lcm;
SilcInt pm1, qm1;
/* Initialize variables */
silc_mp_init(&key->d);
silc_mp_init(&phi);
silc_mp_init(&hlp);
- silc_mp_init(&dq);
+ silc_mp_init(&div);
+ silc_mp_init(&lcm);
silc_mp_init(&pm1);
silc_mp_init(&qm1);
+ /* Set modulus length */
+ key->bits = bits;
+
/* Set the primes */
silc_mp_set(&key->p, p);
silc_mp_set(&key->q, q);
goto retry_e;
}
- /* Find d, the private exponent. First we do phi / 2, to get it a
- bit smaller */
- silc_mp_div_ui(&dq, &phi, 2);
- silc_mp_modinv(&key->d, &key->e, &dq);
+ /* Find d, the private exponent. */
+ silc_mp_gcd(&div, &pm1, &qm1);
+ silc_mp_fdiv_q(&lcm, &phi, &div);
+ silc_mp_modinv(&key->d, &key->e, &lcm);
silc_mp_clear(&phi);
silc_mp_clear(&hlp);
- silc_mp_clear(&dq);
+ silc_mp_clear(&div);
+ silc_mp_clear(&lcm);
silc_mp_clear(&pm1);
silc_mp_clear(&qm1);
}
projects / silc.git / blobdiff