See ChangeLog: Mon Nov 15 21:36:02 CET 1999 Werner Koch
authorWerner Koch <wk@gnupg.org>
Mon, 15 Nov 1999 20:32:24 +0000 (20:32 +0000)
committerWerner Koch <wk@gnupg.org>
Mon, 15 Nov 1999 20:32:24 +0000 (20:32 +0000)
14 files changed:
Makefile.am
cipher/ChangeLog
cipher/dsa.c
cipher/elgamal.c
cipher/md.c
cipher/primegen.c
cipher/pubkey.c
cipher/random.c
cipher/rndegd.c
cipher/rndlinux.c
cipher/rndunix.c
src/gcrypt.h
src/global.c
src/misc.c

index 20fad91..b783612 100644 (file)
@@ -17,7 +17,7 @@ else
 checks = checks
 endif
 
-SUBDIRS = intl zlib util mpi cipher ${gcrypt} tools g10 po doc ${checks} 
+SUBDIRS = intl zlib util mpi cipher ${gcrypt} g10 po doc ${checks}
 EXTRA_DIST = README-alpha VERSION  PROJECTS BUGS
 # gettext never gets it right, so we take here care of deleting the
 # symlink.  my_clean_gcrypt is just a kludge until we can include
index 6aed450..8231cbe 100644 (file)
@@ -1,3 +1,10 @@
+Mon Nov 15 21:36:02 CET 1999  Werner Koch  <wk@gnupg.de>
+
+       * elgamal.c (gen_k): Use the new random API.
+       (generate): Ditto.
+       * dsa.c (gen_k): Ditto.
+       (generate): Ditto.
+
 Sat Nov 13 17:44:23 CET 1999  Werner Koch  <wk@gnupg.de>
 
        * pubkey.c (disable_pubkey_algo): Made static.
index 5a356c9..91c797c 100644 (file)
@@ -79,13 +79,14 @@ gen_k( MPI q )
 
        if( !rndbuf || nbits < 32 ) {
            g10_free(rndbuf);
-           rndbuf = get_random_bits( nbits, 1, 1 );
+           rndbuf = gcry_random_bytes_secure( (nbits+7)/8,
+                                              GCRY_STRONG_RANDOM );
        }
        else { /* change only some of the higher bits */
            /* we could imporove this by directly requesting more memory
-            * at the first call to get_random_bits() and use this the here
+            * at the first call to get_random_bytes() and use this the here
             * maybe it is easier to do this directly in random.c */
-           char *pp = get_random_bits( 32, 1, 1 );
+           char *pp = gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
            memcpy( rndbuf,pp, 4 );
            g10_free(pp);
        }
@@ -129,8 +130,7 @@ test_keys( DSA_secret_key *sk, unsigned qbits )
     pk.q = sk->q;
     pk.g = sk->g;
     pk.y = sk->y;
-    /*mpi_set_bytes( test, qbits, get_random_byte, 0 );*/
-    {  char *p = get_random_bits( qbits, 0, 0 );
+    {  char *p = gcry_random_bytes( (qbits+7)/8, GCRY_WEAK_RANDOM );
        mpi_set_buffer( test, p, (qbits+7)/8, 0 );
        g10_free(p);
     }
@@ -199,10 +199,12 @@ generate( DSA_secret_key *sk, unsigned nbits, MPI **ret_factors )
        if( DBG_CIPHER )
            progress('.');
        if( !rndbuf )
-           rndbuf = get_random_bits( qbits, 2, 1 );
+           rndbuf = gcry_random_bytes_secure( (qbits+7)/8,
+                                              GCRY_VERY_STRONG_RANDOM );
        else { /* change only some of the higher bits (= 2 bytes)*/
-           char *r = get_random_bits( 16, 2, 1 );
-           memcpy(rndbuf, r, 16/8 );
+           char *r = gcry_random_bytes_secure( 2,
+                                               GCRY_VERY_STRONG_RANDOM );
+           memcpy(rndbuf, r, 2 );
            g10_free(r);
        }
        mpi_set_buffer( x, rndbuf, (qbits+7)/8, 0 );
@@ -454,7 +456,7 @@ dsa_get_info( int algo, int *npkey, int *nskey, int *nenc, int *nsig,
     *nsig = 2;
 
     switch( algo ) {
-      case PUBKEY_ALGO_DSA:   *use = PUBKEY_USAGE_SIG; return "DSA";
+      case PUBKEY_ALGO_DSA:   *use = GCRY_PK_USAGE_SIGN; return "DSA";
       default: *use = 0; return NULL;
     }
 }
index 48fe22a..d579064 100644 (file)
@@ -78,11 +78,12 @@ test_keys( ELG_secret_key *sk, unsigned nbits )
     pk.y = sk->y;
 
     /*mpi_set_bytes( test, nbits, get_random_byte, 0 );*/
-    {  char *p = get_random_bits( nbits, 0, 0 );
+    {  char *p = gcry_random_bytes( (nbits+7)/8, GCRY_WEAK_RANDOM );
        mpi_set_buffer( test, p, (nbits+7)/8, 0 );
        g10_free(p);
     }
 
+
     encrypt( out1_a, out1_b, test, &pk );
     decrypt( out2, out1_a, out1_b, sk );
     if( mpi_cmp( test, out2 ) )
@@ -121,14 +122,14 @@ gen_k( MPI p )
            progress('.');
        if( !rndbuf || nbits < 32 ) {
            g10_free(rndbuf);
-           rndbuf = get_random_bits( nbits, 1, 1 );
+           rndbuf = gcry_random_bytes_secure( nbytes, GCRY_STRONG_RANDOM );
        }
        else { /* change only some of the higher bits */
            /* we could imporove this by directly requesting more memory
-            * at the first call to get_random_bits() and use this the here
+            * at the first call to get_random_bytes() and use this the here
             * maybe it is easier to do this directly in random.c */
-           char *pp = get_random_bits( 32, 1, 1 );
-           memcpy( rndbuf,pp, 4 );
+           char *pp = gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
+           memcpy( rndbuf, pp, 4 );
            g10_free(pp);
        }
        mpi_set_buffer( k, rndbuf, nbytes, 0 );
@@ -214,16 +215,20 @@ generate(  ELG_secret_key *sk, unsigned nbits, MPI **ret_factors )
        if( rndbuf ) { /* change only some of the higher bits */
            if( nbits < 16 ) {/* should never happen ... */
                g10_free(rndbuf);
-               rndbuf = get_random_bits( nbits, 2, 1 );
+               rndbuf = gcry_random_bytes_secure( (nbits+7)/8,
+                                                  GCRY_VERY_STRONG_RANDOM );
            }
            else {
-               char *r = get_random_bits( 16, 2, 1 );
-               memcpy(rndbuf, r, 16/8 );
+               char *r = gcry_random_bytes_secure( 2,
+                                                  GCRY_VERY_STRONG_RANDOM );
+               memcpy(rndbuf, r, 2 );
                g10_free(r);
            }
        }
-       else
-           rndbuf = get_random_bits( nbits, 2, 1 );
+       else {
+           rndbuf = gcry_random_bytes_secure( (nbits+7)/8,
+                                              GCRY_VERY_STRONG_RANDOM );
+       }
        mpi_set_buffer( x, rndbuf, (nbits+7)/8, 0 );
        mpi_clear_highbit( x, nbits+1 );
     } while( !( mpi_cmp_ui( x, 0 )>0 && mpi_cmp( x, p_min1 )<0 ) );
@@ -589,10 +594,10 @@ elg_get_info( int algo, int *npkey, int *nskey, int *nenc, int *nsig,
 
     switch( algo ) {
       case PUBKEY_ALGO_ELGAMAL:
-       *use = PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC;
+       *use = GCRY_PK_USAGE_SIGN|GCRY_PK_USAGE_ENCR;
        return "ELG";
       case PUBKEY_ALGO_ELGAMAL_E:
-       *use = PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC;
+       *use = GCRY_PK_USAGE_SIGN|GCRY_PK_USAGE_ENCR;
        return "ELG-E";
       default: *use = 0; return NULL;
     }
index bb179b6..480954a 100644 (file)
@@ -326,7 +326,7 @@ md_enable( GCRY_MD_HD hd, int algo )
                                               - sizeof(r->context) )
                  : g10_malloc( sizeof *ac + r->contextsize
                                               - sizeof(r->context) );
-    if( !rc )
+    if( !ac )
        return set_lasterr( GCRYERR_NO_MEM );
 
     *ac = *r;
index ca8e3ee..5dc1e1a 100644 (file)
@@ -122,7 +122,7 @@ generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
     q_factor = mode==1? gen_prime( req_qbits, 0, 1 ) : NULL;
 
     /* allocate an array to hold the factors + 2 for later usage */
-    factors = g10_xcalloc_clear( n+2, sizeof *factors );
+    factors = g10_xcalloc( n+2, sizeof *factors );
 
     /* make a pool of 3n+5 primes (this is an arbitrary value) */
     m = n*3+5;
index 8d00d95..b77ebff 100644 (file)
@@ -670,7 +670,7 @@ sexp_to_key( GCRY_SEXP sexp, int want_private, MPI **retarray, int *retalgo)
     elems1 = algo_info_table[i].common_elements;
     elems2 = want_private? algo_info_table[i].secret_elements
                         : algo_info_table[i].public_elements;
-    array = g10_calloc( (strlen(elems1)+strlen(elems2)+1, sizeof *array );
+    array = g10_calloc( strlen(elems1)+strlen(elems2)+1, sizeof *array );
     if( !array )
        return GCRYERR_NO_MEM;
 
@@ -825,7 +825,7 @@ gcry_pk_sign( GCRY_SEXP *r_sig, GCRY_SEXP s_hash, GCRY_SEXP s_skey )
        release_mpi_array( skey );
        return -1; /* fixme: get a real errorcode for this */
     }
-    result = g10_xcalloc_clear( (strlen(algo_elems)+1) , sizeof *result );
+    result = g10_xcalloc( (strlen(algo_elems)+1) , sizeof *result );
     rc = pubkey_sign( algo, result, hash, skey );
     release_mpi_array( skey );
     mpi_free( hash );
index b8a09bb..d80b870 100644 (file)
@@ -49,7 +49,6 @@
 #include "util.h"
 #include "rmd.h"
 #include "ttyio.h"
-#include "i18n.h"
 #include "random.h"
 #include "rand-internal.h"
 #include "dynload.h"
index 87d75cf..d6a6a39 100644 (file)
 #include "dynload.h"
 #include "cipher.h"
 
-#ifdef IS_MODULE
-  #define _(a) (a)
-#else
-  #include "i18n.h"
-#endif
-
 #ifndef offsetof
 #define offsetof(type, member) ((size_t) &((type *)0)->member)
 #endif
index 78fee15..63befd2 100644 (file)
   #endif
 #endif
 #include "types.h"
+#include "g10lib.h"  /* need this for i18n */
 #include "util.h"
 #include "ttyio.h"
 #include "dynload.h"
 
-#ifdef IS_MODULE
-  #define _(a) (a)
-#else
-  #include "i18n.h"
-#endif
-
 static int open_device( const char *name, int minor );
 static int gather_random( void (*add)(const void*, size_t, int), int requester,
                                          size_t length, int level );
index 36482df..849f1e0 100644 (file)
@@ -44,8 +44,8 @@
   code base to be maintained */
 
 
-  /* Fixme: We use plain mallocs here beucase it may be used as a module
-   * should be changed. *
+/* Fixme: We use plain mallocs here beucase it may be used as a module
+ * should be changed. */
 
 /* General includes */
 
index de5f05a..dee14cd 100644 (file)
@@ -364,6 +364,38 @@ void gcry_randomize( byte *buffer, size_t length,
 void *gcry_random_bytes( size_t nbytes, enum gcry_random_level level );
 void *gcry_random_bytes_secure( size_t nbytes, enum gcry_random_level level );
 
+/* Provide custom functions for special tasks of libgcrypt.
+ */
+void gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
+                                 void *(*new_alloc_secure_func)(size_t n),
+                                 int (*new_is_secure_func)(const void*),
+                                 void *(*new_realloc_func)(void *p, size_t n),
+                                 void (*new_free_func)(void*) );
+void gcry_set_outofcore_handler( int (*h)( void*, size_t, unsigned int ),
+                                                               void *opaque );
+void gcry_set_fatalerror_handler( void (*fnc)(void*,int, const char*),
+                                                               void *opaque );
+void gcry_set_gettext_handler( const char *(*f)(const char*) );
+
+
+/* Access to the memory function of libgcrypt.
+ * Especially the gcry_free() should be used for memory
+ * allocated by gcry_ functions.
+ */
+void *gcry_malloc( size_t n );
+void *gcry_calloc( size_t n, size_t m );
+void *gcry_malloc_secure( size_t n );
+void *gcry_calloc_secure( size_t n, size_t m );
+void *gcry_realloc( void *a, size_t n );
+void *gcry_xmalloc( size_t n );
+void *gcry_xcalloc( size_t n, size_t m );
+void *gcry_xmalloc_secure( size_t n );
+void *gcry_xcalloc_secure( size_t n, size_t m );
+void *gcry_xrealloc( void *a, size_t n );
+char *gcry_xstrdup( const char * a);
+void  gcry_free( void *p );
+
+
 
 #ifndef GCRYPT_NO_MPI_MACROS
   typedef struct gcry_mpi *MPI;
index 72206b4..9a54bf6 100644 (file)
 #include <assert.h>
 
 #include "g10lib.h"
+#include "memory.h" /* for the m_* functions */
 
 static int last_ec; /* fixme: make thread safe */
 
+static void *(*alloc_func)(size_t n) = NULL;
+static void *(*alloc_secure_func)(size_t n) = NULL;
+static int   (*is_secure_func)(const void*) = NULL;
+static void *(*realloc_func)(void *p, size_t n) = NULL;
+static void (*free_func)(void*) = NULL;
+static int (*outofcore_handler)( void*, size_t, unsigned int ) = NULL;
+static void *outofcore_handler_value = NULL;
 
 int
 gcry_control( enum gcry_ctl_cmds cmd, ... )
@@ -73,7 +81,7 @@ gcry_strerror( int ec )
       X(SUCCESS,       N_("no error"))
       X(GENERAL,       N_("general error"))
       X(INV_OP,        N_("invalid operation code or ctl command"))
-      X(NOMEM,         N_("out of core"))
+      X(NO_MEM,        N_("out of core"))
       X(INV_ARG,       N_("invalid argument"))
       X(INTERNAL,      N_("internal error"))
       X(EOF,           N_("EOF"))
@@ -102,23 +110,93 @@ set_lasterr( int ec )
     return ec;
 }
 
+
+
+/****************
+ * NOTE: All 5 functions should be set.
+ */
 void
-g10_free( void *p )
+gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
+                            void *(*new_alloc_secure_func)(size_t n),
+                            int (*new_is_secure_func)(const void*),
+                            void *(*new_realloc_func)(void *p, size_t n),
+                            void (*new_free_func)(void*) )
 {
-    if( p )
-       m_free(p);
+    alloc_func       = new_alloc_func;
+    alloc_secure_func = new_alloc_secure_func;
+    is_secure_func    = new_is_secure_func;
+    realloc_func      = new_realloc_func;
+    free_func        = new_free_func;
+}
+
+
+
+/****************
+ * Set an optional handler which is called in case the xmalloc functions
+ * ran out of memory.  This handler may do one of these things:
+ *   o free some memory and return true, so that the xmalloc function
+ *     tries again.
+ *   o Do whatever tit like and return false, so that the xmalloc functions
+ *     use the default fatal error handler.
+ *   o Terminate the program and don't return.
+ *
+ * The handler function is called with 3 argiments:  The opaque value set with
+ * this function, the requested memory size, and a flag with these bits
+ * currently defined:
+ *     bit 0 set = secure memory has been requested.
+ */
+void
+gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
+                                                       void *value )
+{
+    outofcore_handler = f;
+    outofcore_handler_value = value;
 }
 
+
+
 void *
 g10_malloc( size_t n )
 {
-    return m_alloc( n );
+    if( alloc_func )
+       return alloc_func( n ) ;
+    return g10_private_malloc( n );
 }
 
 void *
 g10_malloc_secure( size_t n )
 {
-    return m_alloc_secure( n );
+    if( alloc_secure_func )
+       return alloc_secure_func( n ) ;
+    return g10_private_malloc_secure( n );
+}
+
+int
+g10_is_secure( const void *a )
+{
+    if( is_secure_func )
+       return is_secure_func( a ) ;
+    return g10_private_is_secure( a );
+}
+
+void *
+g10_realloc( void *a, size_t n )
+{
+    if( realloc_func )
+       return realloc_func( a, n ) ;
+    return g10_private_realloc( a, n );
+}
+
+void
+g10_free( void *p )
+{
+    if( !p )
+       return;
+
+    if( free_func )
+       free_func( p );
+    else
+       g10_private_free( p );
 }
 
 void *
@@ -143,10 +221,27 @@ g10_calloc_secure( size_t n, size_t m )
 void *
 g10_xmalloc( size_t n )
 {
-    void *p = g10_malloc( n );
-    if( !n ) {
-       fprintf(stderr,"OUT OF CORE\n");
-       exit(4);
+    void *p;
+
+    while ( !(p = g10_malloc( n )) ) {
+       if( !outofcore_handler
+           || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
+           g10_fatal_error(GCRYERR_NO_MEM, NULL );
+       }
+    }
+    return p;
+}
+
+void *
+g10_xrealloc( void *a, size_t n )
+{
+    void *p;
+
+    while ( !(p = g10_realloc( a, n )) ) {
+       if( !outofcore_handler
+           || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
+           g10_fatal_error(GCRYERR_NO_MEM, NULL );
+       }
     }
     return p;
 }
@@ -154,10 +249,14 @@ g10_xmalloc( size_t n )
 void *
 g10_xmalloc_secure( size_t n )
 {
-    void *p = g10_malloc_secure( n );
-    if( !n ) {
-       fprintf(stderr,"OUT OF CORE in secure memory\n");
-       exit(4);
+    void *p;
+
+    while ( !(p = g10_malloc_secure( n )) ) {
+       if( !outofcore_handler
+           || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
+           g10_fatal_error(GCRYERR_NO_MEM,
+                            _("out of core in secure memory"));
+       }
     }
     return p;
 }
@@ -165,22 +264,16 @@ g10_xmalloc_secure( size_t n )
 void *
 g10_xcalloc( size_t n, size_t m )
 {
-    void *p = g10_calloc( n, m );
-    if( !n ) {
-       fprintf(stderr,"OUT OF CORE\n");
-       exit(4);
-    }
+    void *p = g10_xmalloc( n*m );
+    memset( p, 0, n*m );
     return p;
 }
 
 void *
 g10_xcalloc_secure( size_t n, size_t m )
 {
-    void *p = g10_calloc_secure( n, m );
-    if( !n ) {
-       fprintf(stderr,"OUT OF CORE in secure memory\n");
-       exit(4);
-    }
+    void *p = g10_xmalloc_secure( n* m );
+    memset( p, 0, n*m );
     return p;
 }
 
index e1e135c..fe3d63e 100644 (file)
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <unistd.h>
 
 #include "g10lib.h"
 
+static void (*fatal_error_handler)(void*,int, const char*) = NULL;
+static void *fatal_error_handler_value = 0;
+
+static const char *(*user_gettext_handler)( const char * ) = NULL;
+
+void
+gcry_set_gettext_handler( const char *(*f)(const char*) )
+{
+    user_gettext_handler = f;
+}
+
 
 const char *
 g10_gettext( const char *key )
 {
-    /* switch the domain to gnupg and restore later */
+    if( user_gettext_handler )
+       return user_gettext_handler( key );
+    /* FIXME: switch the domain to gnupg and restore later */
     return key;
 }
 
+void
+gcry_set_fatalerror_handler( void (*fnc)(void*,int, const char*), void *value)
+{
+    fatal_error_handler_value = value;
+    fatal_error_handler = fnc;
+}
 
+static void
+write2stderr( const char *s )
+{
+    write( 2, s, strlen(s) );
+}
 
 /****************
- * This function is here as a default fatal error
- * handler.  The caller might want to use his own.
+ * This function is called for fatal errors.  A caller might want to
+ * set his own handler becuase this function simply calls abort().
  */
-int
-fatal_invalid_arg(const char *text)
+void
+g10_fatal_error(int rc, const char *text )
 {
-    /*log_error("Fatal error: %s\n", text );*/
-    return GCRYERR_INV_ARG;
+    if( !text ) /* get a default text */
+       text = gcry_strerror(rc);
+
+    if( fatal_error_handler )
+       fatal_error_handler( fatal_error_handler_value, rc, text );
+
+    write2stderr("\nFatal error: ");
+    write2stderr(text);
+    write2stderr("\n");
+    abort();
 }