* exec.c (expand_args): Remove loop left over from earlier implementation.
[gnupg.git] / cipher / dsa.c
index 6e41dd8..d728a1b 100644 (file)
@@ -1,5 +1,5 @@
-/* dsa.c  -  DSA signature scheme
- *     Copyright (C) 1998, 2000 Free Software Foundation, Inc.
+/* dsa.c  -  DSA signature algorithm
+ *     Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -23,8 +23,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-
-#include "g10lib.h"
+#include "util.h"
 #include "mpi.h"
 #include "cipher.h"
 #include "dsa.h"
@@ -53,6 +52,7 @@ static void generate( DSA_secret_key *sk, unsigned nbits, MPI **ret_factors );
 static void sign(MPI r, MPI s, MPI input, DSA_secret_key *skey);
 static int  verify(MPI r, MPI s, MPI input, DSA_public_key *pkey);
 
+
 static void (*progress_cb) ( void *, int );
 static void *progress_cb_data;
 
@@ -93,17 +93,16 @@ gen_k( MPI q )
            progress('.');
 
        if( !rndbuf || nbits < 32 ) {
-           g10_free(rndbuf);
-           rndbuf = gcry_random_bytes_secure( (nbits+7)/8,
-                                              GCRY_STRONG_RANDOM );
+           m_free(rndbuf);
+           rndbuf = get_random_bits( nbits, 1, 1 );
        }
        else { /* change only some of the higher bits */
            /* we could imporove this by directly requesting more memory
-            * at the first call to get_random_bytes() and use this the here
+            * at the first call to get_random_bits() and use this the here
             * maybe it is easier to do this directly in random.c */
-           char *pp = gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
+           char *pp = get_random_bits( 32, 1, 1 );
            memcpy( rndbuf,pp, 4 );
-           g10_free(pp);
+           m_free(pp);
        }
        mpi_set_buffer( k, rndbuf, nbytes, 0 );
        if( mpi_test_bit( k, nbits-1 ) )
@@ -125,7 +124,7 @@ gen_k( MPI q )
        }
        break;  /* okay */
     }
-    g10_free(rndbuf);
+    m_free(rndbuf);
     if( DBG_CIPHER )
        progress('\n');
 
@@ -137,23 +136,27 @@ static void
 test_keys( DSA_secret_key *sk, unsigned qbits )
 {
     DSA_public_key pk;
-    MPI test = gcry_mpi_new ( qbits  );
-    MPI out1_a = gcry_mpi_new ( qbits );
-    MPI out1_b = gcry_mpi_new ( qbits );
+    MPI test = mpi_alloc( qbits / BITS_PER_MPI_LIMB );
+    MPI out1_a = mpi_alloc( qbits / BITS_PER_MPI_LIMB );
+    MPI out1_b = mpi_alloc( qbits / BITS_PER_MPI_LIMB );
 
     pk.p = sk->p;
     pk.q = sk->q;
     pk.g = sk->g;
     pk.y = sk->y;
-    gcry_mpi_randomize( test, qbits, GCRY_WEAK_RANDOM );
+    /*mpi_set_bytes( test, qbits, get_random_byte, 0 );*/
+    {  char *p = get_random_bits( qbits, 0, 0 );
+       mpi_set_buffer( test, p, (qbits+7)/8, 0 );
+       m_free(p);
+    }
 
     sign( out1_a, out1_b, test, sk );
     if( !verify( out1_a, out1_b, test, &pk ) )
        log_fatal("DSA:: sign, verify failed\n");
 
-    gcry_mpi_release ( test );
-    gcry_mpi_release ( out1_a );
-    gcry_mpi_release ( out1_b );
+    mpi_free( test );
+    mpi_free( out1_a );
+    mpi_free( out1_b );
 }
 
 
@@ -194,7 +197,7 @@ generate( DSA_secret_key *sk, unsigned nbits, MPI **ret_factors )
     do {
        mpi_add_ui( h, h, 1 );
        /* g = h^e mod p */
-       gcry_mpi_powm( g, h, e, p );
+       mpi_powm( g, h, e, p );
     } while( !mpi_cmp_ui( g, 1 ) );  /* continue until g != 1 */
 
     /* select a random number which has these properties:
@@ -211,24 +214,22 @@ generate( DSA_secret_key *sk, unsigned nbits, MPI **ret_factors )
        if( DBG_CIPHER )
            progress('.');
        if( !rndbuf )
-           rndbuf = gcry_random_bytes_secure( (qbits+7)/8,
-                                              GCRY_VERY_STRONG_RANDOM );
+           rndbuf = get_random_bits( qbits, 2, 1 );
        else { /* change only some of the higher bits (= 2 bytes)*/
-           char *r = gcry_random_bytes_secure( 2,
-                                               GCRY_VERY_STRONG_RANDOM );
-           memcpy(rndbuf, r, 2 );
-           g10_free(r);
+           char *r = get_random_bits( 16, 2, 1 );
+           memcpy(rndbuf, r, 16/8 );
+           m_free(r);
        }
        mpi_set_buffer( x, rndbuf, (qbits+7)/8, 0 );
        mpi_clear_highbit( x, qbits+1 );
     } while( !( mpi_cmp_ui( x, 0 )>0 && mpi_cmp( x, h )<0 ) );
-    g10_free(rndbuf);
+    m_free(rndbuf);
     mpi_free( e );
     mpi_free( h );
 
     /* y = g^x mod p */
     y = mpi_alloc( mpi_get_nlimbs(p) );
-    gcry_mpi_powm( y, g, x, p );
+    mpi_powm( y, g, x, p );
 
     if( DBG_CIPHER ) {
        progress('\n');
@@ -262,7 +263,7 @@ check_secret_key( DSA_secret_key *sk )
     int rc;
     MPI y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
-    gcry_mpi_powm( y, sk->g, sk->x, sk->p );
+    mpi_powm( y, sk->g, sk->x, sk->p );
     rc = !mpi_cmp( y, sk->y );
     mpi_free( y );
     return rc;
@@ -272,6 +273,9 @@ check_secret_key( DSA_secret_key *sk )
 
 /****************
  * Make a DSA signature from HASH and put it into r and s.
+ *
+ * Without generating the k this function runs in 
+ * about 26ms on a 300 Mhz Mobile Pentium
  */
 
 static void
@@ -285,7 +289,7 @@ sign(MPI r, MPI s, MPI hash, DSA_secret_key *skey )
     k = gen_k( skey->q );
 
     /* r = (a^k mod p) mod q */
-    gcry_mpi_powm( r, skey->g, k, skey->p );
+    mpi_powm( r, skey->g, k, skey->p );
     mpi_fdiv_r( r, r, skey->q );
 
     /* kinv = k^(-1) mod q */
@@ -306,6 +310,9 @@ sign(MPI r, MPI s, MPI hash, DSA_secret_key *skey )
 
 /****************
  * Returns true if the signature composed from R and S is valid.
+ *
+ * Without the checks this function runs in 
+ * about 31ms on a 300 Mhz Mobile Pentium
  */
 static int
 verify(MPI r, MPI s, MPI hash, DSA_public_key *pkey )
@@ -362,7 +369,7 @@ dsa_generate( int algo, unsigned nbits, MPI *skey, MPI **retfactors )
     DSA_secret_key sk;
 
     if( algo != PUBKEY_ALGO_DSA )
-       return GCRYERR_INV_PK_ALGO;
+       return G10ERR_PUBKEY_ALGO;
 
     generate( &sk, nbits, retfactors );
     skey[0] = sk.p;
@@ -380,9 +387,9 @@ dsa_check_secret_key( int algo, MPI *skey )
     DSA_secret_key sk;
 
     if( algo != PUBKEY_ALGO_DSA )
-       return GCRYERR_INV_PK_ALGO;
+       return G10ERR_PUBKEY_ALGO;
     if( !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4] )
-       return GCRYERR_BAD_MPI;
+       return G10ERR_BAD_MPI;
 
     sk.p = skey[0];
     sk.q = skey[1];
@@ -390,7 +397,7 @@ dsa_check_secret_key( int algo, MPI *skey )
     sk.y = skey[3];
     sk.x = skey[4];
     if( !check_secret_key( &sk ) )
-       return GCRYERR_BAD_SECRET_KEY;
+       return G10ERR_BAD_SECKEY;
 
     return 0;
 }
@@ -403,9 +410,9 @@ dsa_sign( int algo, MPI *resarr, MPI data, MPI *skey )
     DSA_secret_key sk;
 
     if( algo != PUBKEY_ALGO_DSA )
-       return GCRYERR_INV_PK_ALGO;
+       return G10ERR_PUBKEY_ALGO;
     if( !data || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4] )
-       return GCRYERR_BAD_MPI;
+       return G10ERR_BAD_MPI;
 
     sk.p = skey[0];
     sk.q = skey[1];
@@ -425,17 +432,17 @@ dsa_verify( int algo, MPI hash, MPI *data, MPI *pkey,
     DSA_public_key pk;
 
     if( algo != PUBKEY_ALGO_DSA )
-       return GCRYERR_INV_PK_ALGO;
+       return G10ERR_PUBKEY_ALGO;
     if( !data[0] || !data[1] || !hash
        || !pkey[0] || !pkey[1] || !pkey[2] || !pkey[3] )
-       return GCRYERR_BAD_MPI;
+       return G10ERR_BAD_MPI;
 
     pk.p = pkey[0];
     pk.q = pkey[1];
     pk.g = pkey[2];
     pk.y = pkey[3];
     if( !verify( data[0], data[1], hash, &pk ) )
-       return GCRYERR_BAD_SIGNATURE;
+       return G10ERR_BAD_SIGN;
     return 0;
 }
 
@@ -468,7 +475,7 @@ dsa_get_info( int algo, int *npkey, int *nskey, int *nenc, int *nsig,
     *nsig = 2;
 
     switch( algo ) {
-      case PUBKEY_ALGO_DSA:   *use = GCRY_PK_USAGE_SIGN; return "DSA";
+      case PUBKEY_ALGO_DSA:   *use = PUBKEY_USAGE_SIG; return "DSA";
       default: *use = 0; return NULL;
     }
 }