2003-07-14 Moritz Schulte <moritz@g10code.com>
authorMoritz Schulte <mo@g10code.com>
Mon, 14 Jul 2003 22:36:44 +0000 (22:36 +0000)
committerMoritz Schulte <mo@g10code.com>
Mon, 14 Jul 2003 22:36:44 +0000 (22:36 +0000)
* cipher.c (gcry_cipher_lookup_func_name): Also check the cipher
name aliases, not just the primary name.
(gcry_cipher_map_name): Remove kludge for aliasing Rijndael to
AES.

* arcfour.c, blowfish.c, cast5.c, des.c, twofish.c: Adjust cipher
specification structures.

* rijndael.c (rijndael_names, rijndael192_names,
rijndael256_names): New variables, use them in the cipher
specifications.

* rmd160test.c: Removed file.

* ac.c, arcfour.c, blowfish.c, cast5.c, cipher.c, des.c, dsa.c,
elgamal.c, md.c, pubkey.c, random.c, rijndael.c, rsa.c, twofish.c:
Used gcry_err* wrappers for libgpg symbols.

* primegen.c (gen_prime): Correct the order arguments to
extra_check.

2003-07-12  Moritz Schulte  <moritz@g10code.com>

* ac.c: Replaced all public occurences of gpg_error_t with
gcry_error_t.
* cipher.c: Likewise.
* md.c: Likewise.
* pubkey.c: Likewise.
* random.c: Likewise.

* cipher.c: Added support for TWOFISH128.

16 files changed:
cipher/ChangeLog
cipher/ac.c
cipher/arcfour.c
cipher/blowfish.c
cipher/cast5.c
cipher/cipher.c
cipher/des.c
cipher/dsa.c
cipher/elgamal.c
cipher/md.c
cipher/primegen.c
cipher/pubkey.c
cipher/random.c
cipher/rijndael.c
cipher/rsa.c
cipher/twofish.c

index 53f277e..5c52869 100644 (file)
@@ -1,3 +1,37 @@
+2003-07-14  Moritz Schulte  <moritz@g10code.com>
+
+       * cipher.c (gcry_cipher_lookup_func_name): Also check the cipher
+       name aliases, not just the primary name.
+       (gcry_cipher_map_name): Remove kludge for aliasing Rijndael to
+       AES.
+
+       * arcfour.c, blowfish.c, cast5.c, des.c, twofish.c: Adjust cipher
+       specification structures.
+
+       * rijndael.c (rijndael_names, rijndael192_names,
+       rijndael256_names): New variables, use them in the cipher
+       specifications.
+
+       * rmd160test.c: Removed file.
+
+       * ac.c, arcfour.c, blowfish.c, cast5.c, cipher.c, des.c, dsa.c,
+       elgamal.c, md.c, pubkey.c, random.c, rijndael.c, rsa.c, twofish.c:
+       Used gcry_err* wrappers for libgpg symbols.
+
+       * primegen.c (gen_prime): Correct the order arguments to
+       extra_check.
+
+2003-07-12  Moritz Schulte  <moritz@g10code.com>
+
+       * ac.c: Replaced all public occurences of gpg_error_t with
+       gcry_error_t.
+       * cipher.c: Likewise.
+       * md.c: Likewise.
+       * pubkey.c: Likewise.
+       * random.c: Likewise.
+
+       * cipher.c: Added support for TWOFISH128.
+
 2003-07-08  Moritz Schulte  <moritz@g10code.com>
 
        * ac.c (gcry_ac_data_copy_internal): New function, based on
index 370d581..a14a6ef 100644 (file)
@@ -139,11 +139,11 @@ gcry_ac_data_search (gcry_ac_data_t data,
 }
 
 /* Add MPI to DATA, with the label being NAME.  */
-static gpg_err_code_t
+static gcry_err_code_t
 gcry_ac_data_add (gcry_ac_data_t data,
                  const char *name, gcry_mpi_t mpi)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_ac_mpi_t *ac_mpis = NULL;
 
   /* Allocate.  */
@@ -166,10 +166,10 @@ gcry_ac_data_add (gcry_ac_data_t data,
 }
 
 /* Create a copy of the data set DATA and store it in DATA_CP.  */
-static gpg_err_code_t
+static gcry_err_code_t
 gcry_ac_data_copy_internal (gcry_ac_data_t *data_cp, gcry_ac_data_t data)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_ac_data_t data_new = NULL;
   int i = 0;
 
@@ -254,11 +254,11 @@ gcry_ac_data_copy_internal (gcry_ac_data_t *data_cp, gcry_ac_data_t data)
 
   IDENTIFIER is one of `private-key', `public-key', `enc-val',
   `sig-val'; ALGORITHM is the name of the algorithm used.  */
-static gpg_err_code_t
+static gcry_err_code_t
 gcry_ac_data_extract (const char *identifier, const char *algorithm,
                      gcry_sexp_t data_sexp, gcry_ac_data_t *data)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t data_element_sexp = NULL;
   gcry_sexp_t inner_data_sexp = NULL;
   size_t inner_data_n;
@@ -406,12 +406,12 @@ gcry_ac_data_extract (const char *identifier, const char *algorithm,
 
      (IDENTIFIER (flags [...])
                  (ALGORITHM <list of named MPI values>))  */
-static gpg_err_code_t
+static gcry_err_code_t
 gcry_ac_data_construct (const char *identifier, unsigned int flags,
                        const char *algorithm, gcry_ac_data_t data,
                        gcry_sexp_t *data_sexp)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   void **arg_list = NULL;
 
   gcry_sexp_t data_sexp_new = NULL;
@@ -506,10 +506,10 @@ gcry_ac_data_construct (const char *identifier, unsigned int flags,
  */
 
 /* Creates a new, empty data set and stores it in DATA.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_new (gcry_ac_data_t *data)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_ac_data_t data_new = NULL;
 
   data_new = gcry_malloc (sizeof (struct gcry_ac_data));
@@ -523,7 +523,7 @@ gcry_ac_data_new (gcry_ac_data_t *data)
       *data = data_new;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Destroys the data set DATA.  */
@@ -544,11 +544,11 @@ gcry_ac_data_destroy (gcry_ac_data_t data)
 /* Adds the value MPI to the data set DATA with the label NAME.  If
    there is already a value with that label, it is replaced, otherwise
    a new value is added. */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_set (gcry_ac_data_t data,
                  const char *name, gcry_mpi_t mpi)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_ac_mpi_t *ac_mpi;
 
   gcry_ac_data_search (data, name, &ac_mpi);
@@ -586,18 +586,18 @@ gcry_ac_data_set (gcry_ac_data_t data,
        }
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Create a copy of the data set DATA and store it in DATA_CP.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_copy (gcry_ac_data_t *data_cp, gcry_ac_data_t data)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   err = gcry_ac_data_copy_internal (data_cp, data);
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Returns the number of named MPI values inside of the data set
@@ -612,11 +612,11 @@ gcry_ac_data_length (gcry_ac_data_t data)
    MPI.  The returned MPI value will be released in case
    gcry_ac_data_set is used to associate the label NAME with a
    different MPI value.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
                       gcry_mpi_t *mpi)
 {
-  gpg_err_code_t err = GPG_ERR_NO_DATA;
+  gcry_err_code_t err = GPG_ERR_NO_DATA;
   gcry_mpi_t mpi_found = NULL;
   int i;
   
@@ -630,18 +630,18 @@ gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
   if (! err)
     *mpi = mpi_found;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Stores in NAME and MPI the named MPI value contained in the data
    set DATA with the index INDEX.  NAME or MPI may be NULL.  The
    returned MPI value will be released in case gcry_ac_data_set is
    used to associate the label NAME with a different MPI value.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
                        const char **name, gcry_mpi_t *mpi)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   if (index < data->data_n)
     {
@@ -653,7 +653,7 @@ gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
   else
     err = GPG_ERR_NO_DATA;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Destroys any values contained in the data set DATA.  */
@@ -673,11 +673,11 @@ gcry_ac_data_clear (gcry_ac_data_t data)
 
 /* Creates a new handle for the algorithm ALGORITHM and store it in
    HANDLE.  FLAGS is not used yet.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_open (gcry_ac_handle_t *handle,
              gcry_ac_id_t algorithm, unsigned int flags)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t module = NULL;
   gcry_ac_handle_t handle_new;
   const char *algorithm_name;
@@ -715,7 +715,7 @@ gcry_ac_open (gcry_ac_handle_t *handle,
        _gcry_pk_module_release (module);
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Destroys the handle HANDLE.  */
@@ -735,13 +735,13 @@ gcry_ac_close (gcry_ac_handle_t handle)
 
 /* Creates a new key of type TYPE, consisting of the MPI values
    contained in the data set DATA and stores it in KEY.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_key_init (gcry_ac_key_t *key,
                  gcry_ac_handle_t handle,
                  gcry_ac_key_type_t type,
                  gcry_ac_data_t data)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_ac_data_t data_new = NULL;
   gcry_sexp_t data_sexp = NULL;
   gcry_ac_key_t key_new = NULL;
@@ -777,20 +777,20 @@ gcry_ac_key_init (gcry_ac_key_t *key,
        gcry_sexp_release (data_sexp);
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Generates a new key pair via the handle HANDLE of NBITS bits and
    stores it in KEY_PAIR.  In case non-standard settings are wanted, a
    pointer to a structure of type gcry_ac_key_spec_<algorithm>_t,
    matching the selected algorithm, can be given as KEY_SPEC.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
                           gcry_ac_key_pair_t *key_pair,
                           unsigned int nbits,
                           void *key_spec)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   gcry_ac_key_pair_t key_pair_new = NULL;
 
@@ -898,12 +898,12 @@ gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
 
   if (! err)
     /* Construct final request S-expression.  */
-    err = gpg_err_code (gcry_sexp_build_array (&genkey_sexp_request, NULL,
+    err = gcry_err_code (gcry_sexp_build_array (&genkey_sexp_request, NULL,
                                               genkey_format, arg_list));
 
   if (! err)
     /* Perform genkey operation.  */
-    err = gpg_err_code (gcry_pk_genkey (&genkey_sexp_reply,
+    err = gcry_err_code (gcry_pk_genkey (&genkey_sexp_reply,
                                        genkey_sexp_request));
 
   /* Split keys.  */
@@ -962,7 +962,7 @@ gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
        gcry_sexp_release (genkey_sexp_reply);
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Returns the key of type WHICH out of the key pair KEY_PAIR.  */
@@ -1014,21 +1014,21 @@ gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair)
 }
 
 /* Verifies that the key KEY is sane.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_key_test (gcry_ac_key_t key)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
-  err = gpg_err_code (gcry_pk_testkey (key->data_sexp));
+  err = gcry_err_code (gcry_pk_testkey (key->data_sexp));
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Stores the number of bits of the key KEY in NBITS.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_key_get_nbits (gcry_ac_key_t key, unsigned int *nbits)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   unsigned int n;
 
   n = gcry_pk_get_nbits (key->data_sexp);
@@ -1037,21 +1037,21 @@ gcry_ac_key_get_nbits (gcry_ac_key_t key, unsigned int *nbits)
   else
     err = GPG_ERR_PUBKEY_ALGO;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Writes the 20 byte long key grip of the key KEY to KEY_GRIP.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_key_get_grip (gcry_ac_key_t key, unsigned char *key_grip)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   unsigned char *ret;
 
   ret = gcry_pk_get_keygrip (key->data_sexp, key_grip);
   if (! ret)
     err = GPG_ERR_INTERNAL;    /* FIXME.  */
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 \f
@@ -1063,14 +1063,14 @@ gcry_ac_key_get_grip (gcry_ac_key_t key, unsigned char *key_grip)
 /* Encrypts the plain text MPI value DATA_PLAIN with the key public
    KEY under the control of the flags FLAGS and stores the resulting
    data set into DATA_ENCRYPTED.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_encrypt (gcry_ac_handle_t handle,
                      unsigned int flags,
                      gcry_ac_key_t key,
                      gcry_mpi_t data_plain,
                      gcry_ac_data_t *data_encrypted)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t sexp_request = NULL;
   gcry_sexp_t sexp_reply = NULL;
   char *request_format = NULL;
@@ -1135,21 +1135,21 @@ gcry_ac_data_encrypt (gcry_ac_handle_t handle,
     /* Copy out.  */
     *data_encrypted = data;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Decrypts the encrypted data contained in the data set
    DATA_ENCRYPTED with the secret key KEY under the control of the
    flags FLAGS and stores the resulting plain text MPI value in
    DATA_PLAIN.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_decrypt (gcry_ac_handle_t handle,
                      unsigned int flags,
                      gcry_ac_key_t key,
                      gcry_mpi_t *data_plain,
                      gcry_ac_data_t data_encrypted)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_mpi_t data_decrypted = NULL;
   gcry_sexp_t sexp_request = NULL;
   gcry_sexp_t sexp_reply = NULL;
@@ -1197,19 +1197,19 @@ gcry_ac_data_decrypt (gcry_ac_handle_t handle,
   else
     *data_plain = data_decrypted;
 
-  return gpg_error (err);
+  return gcry_error (err);
 
 }
 
 /* Signs the data contained in DATA with the secret key KEY and stores
    the resulting signature data set in DATA_SIGNATURE.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_sign (gcry_ac_handle_t handle,
                   gcry_ac_key_t key,
                   gcry_mpi_t data,
                   gcry_ac_data_t *data_signature)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t sexp_request = NULL;
   gcry_sexp_t sexp_reply = NULL;
   gcry_ac_data_t ac_data;
@@ -1240,19 +1240,19 @@ gcry_ac_data_sign (gcry_ac_handle_t handle,
   if (! err)
     *data_signature = ac_data;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Verifies that the signature contained in the data set
    DATA_SIGNATURE is indeed the result of signing the data contained
    in DATA with the secret key belonging to the public key KEY.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_data_verify (gcry_ac_handle_t handle,
                     gcry_ac_key_t key,
                     gcry_mpi_t data,
                     gcry_ac_data_t data_signature)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t sexp_request = NULL;
   gcry_sexp_t sexp_data = NULL;
 
@@ -1280,7 +1280,7 @@ gcry_ac_data_verify (gcry_ac_handle_t handle,
   if (sexp_data)
     gcry_sexp_release (sexp_data);
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 \f
@@ -1291,10 +1291,10 @@ gcry_ac_data_verify (gcry_ac_handle_t handle,
 
 /* Stores the textual representation of the algorithm whose id is
    given in ALGORITHM in NAME.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_id_to_name (gcry_ac_id_t algorithm, const char **name)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   const char *n;
 
   n = gcry_pk_algo_name (algorithm);
@@ -1303,15 +1303,15 @@ gcry_ac_id_to_name (gcry_ac_id_t algorithm, const char **name)
   else
     err = GPG_ERR_PUBKEY_ALGO;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Stores the numeric ID of the algorithm whose textual representation
    is contained in NAME in ALGORITHM.  */
-gpg_error_t
+gcry_error_t
 gcry_ac_name_to_id (const char *name, gcry_ac_id_t *algorithm)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   int algo;
 
   algo = gcry_pk_map_name (name);
@@ -1320,5 +1320,5 @@ gcry_ac_name_to_id (const char *name, gcry_ac_id_t *algorithm)
   else
     err = GPG_ERR_PUBKEY_ALGO;
     
-  return gpg_error (err);
+  return gcry_error (err);
 }
index 2e3bf22..926d2f6 100644 (file)
@@ -71,7 +71,7 @@ encrypt_stream (void *context,
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_arcfour_setkey (void *context, const byte *key, unsigned int keylen)
 {
     static int initialized;
@@ -109,11 +109,11 @@ do_arcfour_setkey (void *context, const byte *key, unsigned int keylen)
     return GPG_ERR_NO_ERROR;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 arcfour_setkey ( void *context, const byte *key, unsigned int keylen )
 {
   ARCFOUR_context *ctx = (ARCFOUR_context *) context;
-  gpg_err_code_t rc = do_arcfour_setkey (ctx, key, keylen );
+  gcry_err_code_t rc = do_arcfour_setkey (ctx, key, keylen );
   _gcry_burn_stack (300);
   return rc;
 }
@@ -149,6 +149,6 @@ selftest(void)
 
 gcry_cipher_spec_t cipher_spec_arcfour =
   {
-    "ARCFOUR", 1, 128, sizeof (ARCFOUR_context),
+    "ARCFOUR", NULL, 1, 128, sizeof (ARCFOUR_context),
     arcfour_setkey, NULL, NULL, encrypt_stream, encrypt_stream,
   };
index 97909a5..54d54f6 100644 (file)
@@ -49,7 +49,7 @@ typedef struct {
     u32 p[BLOWFISH_ROUNDS+2];
 } BLOWFISH_context;
 
-static gpg_err_code_t bf_setkey (void *c, const byte *key, unsigned keylen);
+static gcry_err_code_t bf_setkey (void *c, const byte *key, unsigned keylen);
 static void encrypt_block (void *bc, byte *outbuf, const byte *inbuf);
 static void decrypt_block (void *bc, byte *outbuf, const byte *inbuf);
 
@@ -490,7 +490,7 @@ selftest(void)
 
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_bf_setkey (BLOWFISH_context *c, const byte *key, unsigned keylen)
 {
     int i, j;
@@ -574,11 +574,11 @@ do_bf_setkey (BLOWFISH_context *c, const byte *key, unsigned keylen)
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 bf_setkey (void *context, const byte *key, unsigned keylen)
 {
   BLOWFISH_context *c = (BLOWFISH_context *) context;
-  gpg_err_code_t rc = do_bf_setkey (c, key, keylen);
+  gcry_err_code_t rc = do_bf_setkey (c, key, keylen);
   _gcry_burn_stack (64);
   return rc;
 }
@@ -587,7 +587,7 @@ bf_setkey (void *context, const byte *key, unsigned keylen)
 
 gcry_cipher_spec_t cipher_spec_blowfish =
   {
-    "BLOWFISH", BLOWFISH_BLOCKSIZE, 128,
+    "BLOWFISH", NULL, BLOWFISH_BLOCKSIZE, 128,
     sizeof (BLOWFISH_context),
     bf_setkey, encrypt_block, decrypt_block,
   };
index 8c036d8..12e0d2a 100644 (file)
@@ -50,7 +50,7 @@ typedef struct {
     byte Kr[16];
 } CAST5_context;
 
-static gpg_err_code_t cast_setkey (void *c, const byte *key, unsigned keylen);
+static gcry_err_code_t cast_setkey (void *c, const byte *key, unsigned keylen);
 static void encrypt_block (void *c, byte *outbuf, const byte *inbuf);
 static void decrypt_block (void *c, byte *outbuf, const byte *inbuf);
 
@@ -561,7 +561,7 @@ key_schedule( u32 *x, u32 *z, u32 *k )
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_cast_setkey( CAST5_context *c, const byte *key, unsigned keylen )
 {
   static int initialized;
@@ -604,11 +604,11 @@ do_cast_setkey( CAST5_context *c, const byte *key, unsigned keylen )
     return GPG_ERR_NO_ERROR;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 cast_setkey (void *context, const byte *key, unsigned keylen )
 {
   CAST5_context *c = (CAST5_context *) context;
-  gpg_err_code_t rc = do_cast_setkey (c, key, keylen);
+  gcry_err_code_t rc = do_cast_setkey (c, key, keylen);
   _gcry_burn_stack (96+7*sizeof(void*));
   return rc;
 }
@@ -616,6 +616,6 @@ cast_setkey (void *context, const byte *key, unsigned keylen )
 
 gcry_cipher_spec_t cipher_spec_cast5 =
   {
-    "CAST5", CAST5_BLOCKSIZE, 128, sizeof (CAST5_context),
+    "CAST5", NULL, CAST5_BLOCKSIZE, 128, sizeof (CAST5_context),
     cast_setkey, encrypt_block, decrypt_block,
   };
index 30cd4f0..1f2bbce 100644 (file)
@@ -91,7 +91,7 @@ static struct cipher_table_entry
 #endif
 #if USE_TWOFISH
     { &cipher_spec_twofish,    GCRY_CIPHER_TWOFISH },
-    //    { &cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
+    { &cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
 #endif
     { NULL                    },
   };
@@ -120,11 +120,25 @@ static int default_ciphers_registered;
     }                                              \
   while (0)
 
+/* The handle structure.  */
+struct gcry_cipher_handle
+{
+  int magic;
+  gcry_cipher_spec_t *cipher;
+  gcry_module_t module;
+  int mode;
+  unsigned int flags;
+  byte iv[MAX_BLOCKSIZE];      /* (this should be ulong aligned) */
+  byte lastiv[MAX_BLOCKSIZE];
+  int unused;  /* in IV */
+  byte ctr[MAX_BLOCKSIZE];    /* for Counter (CTR) mode */
+  PROPERLY_ALIGNED_TYPE context;
+};
 
 /* These dummy functions are used in case a cipher implementation
    refuses to provide it's own functions.  */
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_setkey (void *c, const unsigned char *key, unsigned keylen)
 {
   return GPG_ERR_NO_ERROR;
@@ -165,7 +179,7 @@ dummy_decrypt_stream (void *c,
 static void
 gcry_cipher_register_default (void)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   int i;
   
   for (i = 0; (! err) && cipher_table[i].cipher; i++)
@@ -197,8 +211,14 @@ gcry_cipher_lookup_func_name (void *spec, void *data)
 {
   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
   char *name = (char *) data;
+  const char **aliases = cipher->aliases;
+  int ret = stricmp (name, cipher->name), i;
 
-  return (! stricmp (cipher->name, name));
+  if (ret && aliases)
+    for (i = 0; aliases[i] && ret; i++)
+      ret = stricmp (name, aliases[i]);
+
+  return ret;
 }
 
 /* Internal function.  Lookup a cipher entry by it's name.  */
@@ -216,12 +236,12 @@ gcry_cipher_lookup_name (const char *name)
 /* Register a new cipher module whose specification can be found in
    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t
+gcry_error_t
 gcry_cipher_register (gcry_cipher_spec_t *cipher,
                      unsigned int *algorithm_id,
                      gcry_module_t *module)
 {
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
   gcry_module_t mod;
 
   ath_mutex_lock (&ciphers_registered_lock);
@@ -235,7 +255,7 @@ gcry_cipher_register (gcry_cipher_spec_t *cipher,
       *algorithm_id = mod->mod_id;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Unregister the cipher identified by MODULE, which must have been
@@ -248,21 +268,6 @@ gcry_cipher_unregister (gcry_module_t module)
   ath_mutex_unlock (&ciphers_registered_lock);
 }
 
-/* The handle structure.  */
-struct gcry_cipher_handle
-{
-  int magic;
-  gcry_cipher_spec_t *cipher;
-  gcry_module_t module;
-  int  mode;
-  unsigned int flags;
-  byte iv[MAX_BLOCKSIZE];      /* (this should be ulong aligned) */
-  byte lastiv[MAX_BLOCKSIZE];
-  int  unused;  /* in IV */
-  byte ctr[MAX_BLOCKSIZE];    /* for Counter (CTR) mode */
-  PROPERLY_ALIGNED_TYPE context;
-};
-
 /* locate the OID in the oid table and return the index or -1 when not
    found */
 static int 
@@ -300,17 +305,6 @@ gcry_cipher_map_name( const char *string )
   if (!string)
     return 0;
 
-  /* kludge to alias RIJNDAEL to AES */
-  if ( *string == 'R' || *string == 'r')
-    {
-      if (!strcasecmp (string, "RIJNDAEL"))
-        string = "AES";
-      else if (!strcasecmp (string, "RIJNDAEL192"))
-        string = "AES192";
-      else if (!strcasecmp (string, "RIJNDAEL256"))
-        string = "AES256";
-    }
-
   /* If the string starts with a digit (optionally prefixed with
      either "OID." or "oid."), we first look into our table of ASN.1
      object identifiers to figure out the algorithm */
@@ -400,10 +394,10 @@ disable_cipher_algo (int algorithm)
  * Return 0 if the cipher algo is available.
  */
 
-static gpg_err_code_t
+static gcry_err_code_t
 check_cipher_algo (int algorithm)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t cipher;
 
   REGISTER_DEFAULT_CIPHERS;
@@ -477,7 +471,7 @@ cipher_get_blocksize (int algorithm)
  * return the handle.  Put NULL into HANDLER and return and error code
  * if something goes wrong.  */
 
-gpg_error_t
+gcry_error_t
 gcry_cipher_open (gcry_cipher_hd_t *handle,
                  int algo, int mode, unsigned int flags)
 {
@@ -485,7 +479,7 @@ gcry_cipher_open (gcry_cipher_hd_t *handle,
   gcry_cipher_spec_t *cipher = NULL;
   gcry_module_t module = NULL;
   gcry_cipher_hd_t h = NULL;
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
 
   _gcry_fast_random_poll();
   
@@ -590,7 +584,7 @@ gcry_cipher_open (gcry_cipher_hd_t *handle,
 
   *handle = err ? NULL : h;
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -599,6 +593,7 @@ gcry_cipher_close (gcry_cipher_hd_t h)
 {
   if (! h)
     return;
+
   if ((h->magic != CTX_MAGIC_SECURE)
       && (h->magic != CTX_MAGIC_NORMAL))
     _gcry_fatal_error(GPG_ERR_INTERNAL,
@@ -615,10 +610,10 @@ gcry_cipher_close (gcry_cipher_hd_t h)
 }
 
 
-static gpg_error_t
+static gcry_error_t
 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
 {
-  gpg_err_code_t ret;
+  gcry_err_code_t ret;
 
   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
   if (! ret)
@@ -627,7 +622,7 @@ cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
            (void *) &c->context.c,
            c->cipher->contextsize);
 
-  return gpg_error (ret);
+  return gcry_error (ret);
 }
 
 
@@ -929,11 +924,11 @@ do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nb
  * inbuf and outbuf may overlap or be the same.
  * Depending on the mode some contraints apply to NBYTES.
  */
-static gpg_err_code_t
+static gcry_err_code_t
 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
                const byte *inbuf, unsigned int nbytes)
 {
-    gpg_err_code_t rc = GPG_ERR_NO_ERROR;
+    gcry_err_code_t rc = GPG_ERR_NO_ERROR;
 
     switch( c->mode ) {
       case GCRY_CIPHER_MODE_ECB:
@@ -976,11 +971,11 @@ cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
  * been requested,
  */
-gpg_error_t
+gcry_error_t
 gcry_cipher_encrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
                      const byte  *in, size_t inlen)
 {
-  gpg_err_code_t err;
+  gcry_err_code_t err;
 
   if (!in)
     /* caller requested in-place encryption */
@@ -1003,7 +998,7 @@ gcry_cipher_encrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
                                     plaintext will never make it into
                                     OUT. */
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -1013,11 +1008,11 @@ gcry_cipher_encrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
  * inbuf and outbuf may overlap or be the same.
  * Depending on the mode some some contraints apply to NBYTES.
  */
-static gpg_err_code_t
+static gcry_err_code_t
 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
                unsigned nbytes)
 {
-    gpg_err_code_t rc = GPG_ERR_NO_ERROR;
+    gcry_err_code_t rc = GPG_ERR_NO_ERROR;
 
     switch( c->mode ) {
       case GCRY_CIPHER_MODE_ECB:
@@ -1056,11 +1051,11 @@ cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
 }
 
 
-gpg_error_t
+gcry_error_t
 gcry_cipher_decrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
                     const byte  *in, size_t inlen)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   if (! in)
     /* caller requested in-place encryption */
@@ -1078,7 +1073,7 @@ gcry_cipher_decrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
   else
     err = cipher_decrypt (h, out, in, inlen);
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -1098,10 +1093,10 @@ cipher_sync( gcry_cipher_hd_t c )
 }
 
 
-gpg_error_t
+gcry_error_t
 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
 {
-  gpg_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
 
   switch (cmd)
     {
@@ -1140,7 +1135,7 @@ gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
        * integer with the algo number.
        */
       if( h || !buffer || buflen != sizeof(int) )
-        return gpg_error (GPG_ERR_CIPHER_ALGO);
+       return gcry_error (GPG_ERR_CIPHER_ALGO);
       disable_cipher_algo( *(int*)buffer );
       break;
     case GCRYCTL_SET_CTR:
@@ -1155,25 +1150,26 @@ gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
     default:
       rc = GPG_ERR_INV_OP;
     }
-  return gpg_error (rc);
+
+  return gcry_error (rc);
 }
 
 
 /****************
  * Return information about the cipher handle.
  */
-gpg_error_t
+gcry_error_t
 gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   switch (cmd)
     {
     default:
       err = GPG_ERR_INV_OP;
     }
-  
-  return gpg_error (err);
+
+  return gcry_error (err);
 }
 
 /****************
@@ -1198,10 +1194,10 @@ gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
  * and thereby detecting whether a error occured or not (i.e. while checking
  * the block size)
  */
-gpg_error_t
+gcry_error_t
 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   unsigned int ui;
 
   switch (what)
@@ -1247,7 +1243,7 @@ gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
        err = GPG_ERR_INV_OP;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -1273,10 +1269,10 @@ gcry_cipher_get_algo_blklen (int algo)
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_cipher_init (void)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   REGISTER_DEFAULT_CIPHERS;
 
@@ -1289,10 +1285,10 @@ _gcry_cipher_init (void)
    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
    according size.  In case there are less cipher modules than
    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
-gpg_error_t
+gcry_error_t
 gcry_cipher_list (int *list, int *list_length)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   ath_mutex_lock (&ciphers_registered_lock);
   err = _gcry_module_list (ciphers_registered, list, list_length);
index d9acaaf..a38b4f4 100644 (file)
@@ -991,7 +991,7 @@ selftest (void)
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_tripledes_setkey ( void *context, const byte *key, unsigned keylen )
 {
   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
@@ -1028,7 +1028,7 @@ do_tripledes_decrypt( void *context, byte *outbuf, const byte *inbuf )
   _gcry_burn_stack (32);
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_des_setkey (void *context, const byte *key, unsigned keylen)
 {
   struct _des_ctx *ctx = (struct _des_ctx *) context;
@@ -1068,12 +1068,12 @@ do_des_decrypt( void *context, byte *outbuf, const byte *inbuf )
 
 gcry_cipher_spec_t cipher_spec_des =
   {
-    "DES", 8, 64, sizeof (struct _des_ctx),
+    "DES", NULL, 8, 64, sizeof (struct _des_ctx),
     do_des_setkey, do_des_encrypt, do_des_decrypt
   };
 
 gcry_cipher_spec_t cipher_spec_tripledes =
   {
-    "3DES", 8, 192, sizeof (struct _tripledes_ctx),
+    "3DES", NULL, 8, 192, sizeof (struct _tripledes_ctx),
     do_tripledes_setkey, do_tripledes_encrypt, do_tripledes_decrypt
   };
index 970002e..62fd082 100644 (file)
@@ -356,7 +356,7 @@ verify(gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t hash, DSA_public_key *pkey )
  **************  interface  ******************
  *********************************************/
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_dsa_generate (int algo, unsigned nbits, unsigned long dummy,
                     gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
@@ -373,10 +373,10 @@ _gcry_dsa_generate (int algo, unsigned nbits, unsigned long dummy,
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_dsa_check_secret_key (int algo, gcry_mpi_t *skey)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_secret_key sk;
 
   if ((! skey[0]) || (! skey[1]) || (! skey[2]) || (! skey[3]) || (! skey[4]))
@@ -396,10 +396,10 @@ _gcry_dsa_check_secret_key (int algo, gcry_mpi_t *skey)
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_dsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_secret_key sk;
 
   if ((! data)
@@ -420,11 +420,11 @@ _gcry_dsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
   return err;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_dsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
                  int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_public_key pk;
 
   if ((! data[0]) || (! data[1]) || (! hash)
index e1b2074..04c3733 100644 (file)
@@ -498,7 +498,7 @@ verify(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey )
  **************  interface  ******************
  *********************************************/
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_generate (int algo, unsigned nbits, unsigned long dummy,
                     gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
@@ -514,10 +514,10 @@ _gcry_elg_generate (int algo, unsigned nbits, unsigned long dummy,
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_check_secret_key (int algo, gcry_mpi_t *skey)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
 
   if ((! skey[0]) || (! skey[1]) || (! skey[2]) || (! skey[3]))
@@ -537,10 +537,10 @@ _gcry_elg_check_secret_key (int algo, gcry_mpi_t *skey)
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey, int flags)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_public_key pk;
 
   if ((! data) || (! pkey[0]) || (! pkey[1]) || (! pkey[2]))
@@ -558,10 +558,10 @@ _gcry_elg_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pk
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
 
   if ((! data[0]) || (! data[1])
@@ -580,10 +580,10 @@ _gcry_elg_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *s
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
 
   if ((! data)
@@ -603,11 +603,11 @@ _gcry_elg_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
   return err;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_elg_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
                  int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_public_key pk;
 
   if ((! data[0]) || (! data[1]) || (! hash)
index 82fe186..6549261 100644 (file)
@@ -125,7 +125,7 @@ static int default_digests_registered;
 static void
 gcry_md_register_default (void)
 {
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
   int i;
   
   for (i = 0; (! err) && digest_table[i].digest; i++)
@@ -163,12 +163,12 @@ gcry_md_lookup_name (const char *name)
 /* Register a new digest module whose specification can be found in
    DIGEST.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t
+gcry_error_t
 gcry_md_register (gcry_md_spec_t *digest,
                  unsigned int *algorithm_id,
                  gcry_module_t *module)
 {
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
   gcry_module_t mod;
 
   ath_mutex_lock (&digests_registered_lock);
@@ -182,7 +182,7 @@ gcry_md_register (gcry_md_spec_t *digest,
       *algorithm_id = mod->mod_id;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /* Unregister the digest identified by ID, which must have been
@@ -219,10 +219,10 @@ struct gcry_md_context
 #define CTX_MAGIC_SECURE 0x16917011
 
 static const char * digest_algo_to_string( int algo );
-static gpg_err_code_t check_digest_algo (int algo);
-static gpg_err_code_t md_open (gcry_md_hd_t *h, int algo, int secure, int hmac);
-static gpg_err_code_t md_enable (gcry_md_hd_t hd, int algo);
-static gpg_err_code_t md_copy (gcry_md_hd_t a, gcry_md_hd_t *b);
+static gcry_err_code_t check_digest_algo (int algo);
+static gcry_err_code_t md_open (gcry_md_hd_t *h, int algo, int secure, int hmac);
+static gcry_err_code_t md_enable (gcry_md_hd_t hd, int algo);
+static gcry_err_code_t md_copy (gcry_md_hd_t a, gcry_md_hd_t *b);
 static void md_close (gcry_md_hd_t a);
 static void md_write (gcry_md_hd_t a, byte *inbuf, size_t inlen);
 static void md_final(gcry_md_hd_t a);
@@ -315,10 +315,10 @@ gcry_md_algo_name (int algorithm)
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 check_digest_algo (int algorithm)
 {
-  gpg_err_code_t rc = 0;
+  gcry_err_code_t rc = 0;
   gcry_module_t digest;
 
   REGISTER_DEFAULT_DIGESTS;
@@ -341,10 +341,10 @@ check_digest_algo (int algorithm)
  * More algorithms may be added by md_enable(). The initial algorithm
  * may be 0.
  */
-static gpg_err_code_t
+static gcry_err_code_t
 md_open (gcry_md_hd_t *h, int algo, int secure, int hmac)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   int bufsize = secure ? 512 : 1024;
   struct gcry_md_context *ctx;
   gcry_md_hd_t hd;
@@ -424,10 +424,10 @@ md_open (gcry_md_hd_t *h, int algo, int secure, int hmac)
    given as 0 if the algorithms to be used are later set using
    gcry_md_enable. H is guaranteed to be a valid handle or NULL on
    error.  */
-gpg_error_t
+gcry_error_t
 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_md_hd_t hd;
 
   if ((flags & ~(GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC)))
@@ -439,19 +439,19 @@ gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
     }
 
   *h = err? NULL : hd;
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 md_enable (gcry_md_hd_t hd, int algorithm)
 {
   struct gcry_md_context *h = hd->ctx;
   gcry_md_spec_t *digest = NULL;
   GcryDigestEntry *entry;
   gcry_module_t module;
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
 
   for (entry = h->list; entry; entry = entry->next)
     if (entry->module->mod_id == algorithm)
@@ -510,17 +510,17 @@ md_enable (gcry_md_hd_t hd, int algorithm)
 }
 
 
-gpg_error_t
+gcry_error_t
 gcry_md_enable (gcry_md_hd_t hd, int algorithm)
 {
-  gpg_err_code_t err = md_enable (hd, algorithm);
-  return gpg_error (err);
+  gcry_err_code_t err = md_enable (hd, algorithm);
+  return gcry_error (err);
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   struct gcry_md_context *a = ahd->ctx;
   struct gcry_md_context *b;
   GcryDigestEntry *ar, *br;
@@ -597,13 +597,13 @@ md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
   return err;
 }
 
-gpg_error_t
+gcry_error_t
 gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
 {
-  gpg_err_code_t err = md_copy (hd, handle);
+  gcry_err_code_t err = md_copy (hd, handle);
   if (err)
     *handle = NULL;
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 /****************
@@ -704,7 +704,7 @@ md_final (gcry_md_hd_t a)
       byte *p = md_read (a, algo);
       size_t dlen = md_digest_length (algo);
       gcry_md_hd_t om;
-      gpg_err_code_t err = md_open (&om, algo, a->ctx->secure, 0);
+      gcry_err_code_t err = md_open (&om, algo, a->ctx->secure, 0);
 
       if (err)
        _gcry_fatal_error (err, NULL);
@@ -717,7 +717,7 @@ md_final (gcry_md_hd_t a)
     }
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 prepare_macpads( gcry_md_hd_t hd, const byte *key, size_t keylen)
 {
   int i;
@@ -752,10 +752,10 @@ prepare_macpads( gcry_md_hd_t hd, const byte *key, size_t keylen)
   return GPG_ERR_NO_ERROR;
 }
 
-gpg_error_t
+gcry_error_t
 gcry_md_ctl (gcry_md_hd_t hd, int cmd, byte *buffer, size_t buflen)
 {
-  gpg_err_code_t rc = 0;
+  gcry_err_code_t rc = 0;
   
   switch (cmd)
     {
@@ -763,7 +763,7 @@ gcry_md_ctl (gcry_md_hd_t hd, int cmd, byte *buffer, size_t buflen)
       md_final (hd);
       break;
     case GCRYCTL_SET_KEY:
-      rc = gpg_err_code (gcry_md_setkey (hd, buffer, buflen));
+      rc = gcry_err_code (gcry_md_setkey (hd, buffer, buflen));
       break;
     case GCRYCTL_START_DUMP:
       md_start_debug (hd, buffer);
@@ -774,13 +774,13 @@ gcry_md_ctl (gcry_md_hd_t hd, int cmd, byte *buffer, size_t buflen)
     default:
       rc = GPG_ERR_INV_OP;
     }
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
-gpg_error_t
+gcry_error_t
 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
 {
-  gpg_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
 
   if (! hd->ctx->macpads)
     rc = GPG_ERR_CONFLICT;
@@ -791,7 +791,7 @@ gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
        gcry_md_reset (hd);
     }
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 
@@ -886,7 +886,7 @@ md_digest( gcry_md_hd_t a, int algo, byte *buffer, int buflen )
 /****************
  * Read out an intermediate digest.
  */
-gpg_err_code_t
+gcry_err_code_t
 gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
 {
   /*md_digest ... */
@@ -910,7 +910,7 @@ gcry_md_hash_buffer (int algo, void *digest, const void *buffer, size_t length)
       /* for the others we do not have a fast function, so we use the
         normal functions to do it */
       gcry_md_hd_t h;
-      gpg_err_code_t err = md_open (&h, algo, 0, 0);
+      gcry_err_code_t err = md_open (&h, algo, 0, 0);
       if (err)
        /* FIXME?  */
        BUG(); /* algo not available */
@@ -1018,10 +1018,10 @@ md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
  * and thereby detecting whether a error occured or not (i.e. while checking
  * the block size)
  */
-gpg_error_t
+gcry_error_t
 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   switch (what)
     {
@@ -1057,7 +1057,7 @@ gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
     err = GPG_ERR_INV_OP;
   }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -1108,10 +1108,10 @@ md_stop_debug( gcry_md_hd_t md )
  *     Returns 1 if the algo is enanled for that handle.
  *     The algo must be passed as the address of an int.
  */
-gpg_error_t
+gcry_error_t
 gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   switch (cmd)
     {
@@ -1146,13 +1146,13 @@ gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
     err = GPG_ERR_INV_OP;
   }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_md_init (void)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   REGISTER_DEFAULT_DIGESTS;
 
@@ -1189,10 +1189,10 @@ gcry_md_is_enabled (gcry_md_hd_t a, int algo)
    of according size.  In case there are less message digest modules
    than *LIST_LENGTH, *LIST_LENGTH is updated to the correct
    number.  */
-gpg_error_t
+gcry_error_t
 gcry_md_list (int *list, int *list_length)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   ath_mutex_lock (&digests_registered_lock);
   err = _gcry_module_list (digests_registered, list, list_length);
index 34361e3..751f49a 100644 (file)
@@ -456,7 +456,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
                        break; /* stop loop, continue with a new prime */
                       }
 
-                    if (extra_check && extra_check (ptest, extra_check_arg))
+                    if (extra_check && extra_check (extra_check_arg, ptest))
                       { /* The extra check told us that this prime is
                            not of the caller's taste. */
                         progress ('/');
index ff29563..2dcfb23 100644 (file)
@@ -30,9 +30,9 @@
 #include "cipher.h"
 #include "ath.h"
 
-static gpg_err_code_t pubkey_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags);
-static gpg_err_code_t pubkey_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t hash, gcry_mpi_t *skey);
-static gpg_err_code_t pubkey_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+static gcry_err_code_t pubkey_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags);
+static gcry_err_code_t pubkey_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t hash, gcry_mpi_t *skey);
+static gcry_err_code_t pubkey_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
                                     int (*cmp) (void *, gcry_mpi_t), void *opaque);
 
 /* This is the list of the default public-key ciphers included in
@@ -82,7 +82,7 @@ static int default_pubkeys_registered;
 /* These dummy functions are used in case a cipher implementation
    refuses to provide it's own functions.  */
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
@@ -90,35 +90,35 @@ dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
   return GPG_ERR_PUBKEY_ALGO;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_check_secret_key (int algorithm, gcry_mpi_t *skey)
 {
   log_bug ("no check_secret_key() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey, int flags)
 {
   log_bug ("no encrypt() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags)
 {
   log_bug ("no decrypt() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   log_bug ("no sign() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 dummy_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
              int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
@@ -138,7 +138,7 @@ dummy_get_nbits (int algorithm, gcry_mpi_t *pkey)
 static void
 gcry_pk_register_default (void)
 {
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
   int i;
   
   for (i = 0; (! err) && pubkey_table[i].pubkey; i++)
@@ -194,12 +194,12 @@ gcry_pk_lookup_name (const char *name)
 /* Register a new pubkey module whose specification can be found in
    PUBKEY.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t
+gcry_error_t
 gcry_pk_register (gcry_pk_spec_t *pubkey,
                  unsigned int *algorithm_id,
                  gcry_module_t *module)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t mod;
 
   ath_mutex_lock (&pubkeys_registered_lock);
@@ -304,10 +304,10 @@ disable_pubkey_algo (int algorithm)
 /****************
  * a use of 0 means: don't care
  */
-static gpg_err_code_t
+static gcry_err_code_t
 check_pubkey_algo (int algorithm, unsigned use)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_pk_spec_t *pubkey;
   gcry_module_t module;
 
@@ -429,11 +429,11 @@ pubkey_get_nenc (int algorithm)
 }
 
 
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_generate (int algorithm, unsigned int nbits, unsigned long use_e,
                  gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
-  gpg_err_code_t err = GPG_ERR_PUBKEY_ALGO;
+  gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
   gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
@@ -451,10 +451,10 @@ pubkey_generate (int algorithm, unsigned int nbits, unsigned long use_e,
   return err;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
 {
-  gpg_err_code_t err = GPG_ERR_PUBKEY_ALGO;
+  gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
   gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
@@ -478,13 +478,13 @@ pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
  * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
  * check with pubkey_get_nenc() )
  */
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
                int flags)
 {
   gcry_pk_spec_t *pubkey;
   gcry_module_t module;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
@@ -525,13 +525,13 @@ pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *
  * result is a pointer to a mpi variable which will receive a
  * newly allocated mpi or NULL in case of an error.
  */
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
                int flags)
 {
   gcry_pk_spec_t *pubkey;
   gcry_module_t module;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   int i;
 
   *result = NULL; /* so the caller can always do a mpi_free */
@@ -572,12 +572,12 @@ pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t
  * should be an array of MPIs of size PUBKEY_MAX_NSIG (or less if the
  * algorithm allows this - check with pubkey_get_nsig() )
  */
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   gcry_pk_spec_t *pubkey;
   gcry_module_t module;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
@@ -614,13 +614,13 @@ pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *ske
  * Verify a public key signature.
  * Return 0 if the signature is good
  */
-static gpg_err_code_t
+static gcry_err_code_t
 pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
               int (*cmp)(void *, gcry_mpi_t), void *opaquev)
 {
   gcry_pk_spec_t *pubkey;
   gcry_module_t module;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
@@ -651,11 +651,11 @@ pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pke
 }
 
 /* Internal function.   */
-static gpg_err_code_t
+static gcry_err_code_t
 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
                       gcry_mpi_t *elements)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   int i, index;
   const char *name;
   gcry_sexp_t list;
@@ -715,7 +715,7 @@ sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
  *  )
  * The <mpi> are expected to be in GCRYMPI_FMT_USG
  */
-static gpg_err_code_t
+static gcry_err_code_t
 sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
              gcry_module_t *retalgo)
 {
@@ -724,7 +724,7 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
     size_t n;
     const char *elems;
     gcry_mpi_t *array;
-    gpg_err_code_t err = GPG_ERR_NO_ERROR;
+    gcry_err_code_t err = GPG_ERR_NO_ERROR;
     gcry_module_t module;
     gcry_pk_spec_t *pubkey;
 
@@ -790,7 +790,7 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
     return err;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
             gcry_module_t *retalgo)
 {
@@ -799,7 +799,7 @@ sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
     size_t n;
     const char *elems;
     gcry_mpi_t *array;
-    gpg_err_code_t err = GPG_ERR_NO_ERROR;
+    gcry_err_code_t err = GPG_ERR_NO_ERROR;
     gcry_module_t module;
     gcry_pk_spec_t *pubkey;
 
@@ -895,7 +895,7 @@ sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
  *           ))
  * RET_MODERN is set to true when at least an empty flags list has been found.
  */
-static gpg_err_code_t
+static gcry_err_code_t
 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
              int *ret_modern, int *ret_want_pkcs1, int *flags)
 {
@@ -907,7 +907,7 @@ sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
   int parsed_flags = 0;
   const char *elems;
   gcry_mpi_t *array = NULL;
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   *ret_want_pkcs1 = 0;
   *ret_modern = 0;
@@ -1049,11 +1049,11 @@ sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
    NBITS is the length of the key in bits. 
 
 */
-static gpg_err_code_t
+static gcry_err_code_t
 sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
                   int for_encryption, int *flags)
 {
-  gpg_err_code_t rc = 0;
+  gcry_err_code_t rc = 0;
   gcry_sexp_t ldata, lhash, lvalue;
   int i;
   size_t n;
@@ -1297,13 +1297,13 @@ sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
                ))
 
 */
-gpg_error_t
+gcry_error_t
 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
 {
   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
   const char *algo_name, *algo_elems;
   int flags;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   gcry_pk_spec_t *pubkey = NULL;
   gcry_module_t module = NULL;
 
@@ -1395,7 +1395,7 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
       ath_mutex_unlock (&pubkeys_registered_lock);
     }
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 /****************
@@ -1421,12 +1421,12 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
  * r_plain= Either an incomplete S-expression without the parentheses
  *          or if the flags list is used (even if empty) a real S-expression:
  *          (value PLAIN).  */
-gpg_error_t
+gcry_error_t
 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
 {
   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
   int modern, want_pkcs1, flags;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   gcry_module_t module_enc = NULL, module_key = NULL;
   gcry_pk_spec_t *pubkey = NULL;
 
@@ -1488,7 +1488,7 @@ gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
       ath_mutex_unlock (&pubkeys_registered_lock);
     }
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 
@@ -1518,7 +1518,7 @@ gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
  *             ...
  *             (<param_namen> <mpi>)
  * )) */
-gpg_error_t
+gcry_error_t
 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
 {
   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
@@ -1526,7 +1526,7 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
   gcry_module_t module = NULL;
   const char *key_algo_name, *algo_name, *algo_elems;
   int i;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
 
 
   REGISTER_DEFAULT_PUBKEYS;
@@ -1608,7 +1608,7 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
   if (result)
     gcry_free (result);
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 
@@ -1619,12 +1619,12 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
  * from gcry_pk_sign and data must be an S-Exp like the one in sign
  * too.
  */
-gpg_error_t
+gcry_error_t
 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
 {
   gcry_module_t module_key = NULL, module_sig = NULL;
   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
 
   REGISTER_DEFAULT_PUBKEYS;
  
@@ -1665,7 +1665,7 @@ gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
       ath_mutex_unlock (&pubkeys_registered_lock);
     }
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 
@@ -1677,12 +1677,12 @@ gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
  *
  * s_key = <key-as-defined-in-sexp_to_key>
  */
-gpg_error_t
+gcry_error_t
 gcry_pk_testkey (gcry_sexp_t s_key)
 {
   gcry_module_t module = NULL;
   gcry_mpi_t *key = NULL;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
   
   REGISTER_DEFAULT_PUBKEYS;
 
@@ -1694,7 +1694,7 @@ gcry_pk_testkey (gcry_sexp_t s_key)
       release_mpi_array (key);
       gcry_free (key);
     }
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 
@@ -1732,7 +1732,7 @@ gcry_pk_testkey (gcry_sexp_t s_key)
  *  )
  * )
  */
-gpg_error_t
+gcry_error_t
 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
 {
   gcry_pk_spec_t *pubkey = NULL;
@@ -1740,7 +1740,7 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
   gcry_sexp_t list = NULL, l2 = NULL;
   const char *name;
   size_t n;
-  gpg_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
   int i;
   const char *algo_name = NULL;
   int algo;
@@ -1947,7 +1947,7 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
       ath_mutex_unlock (&pubkeys_registered_lock);
     }
 
-  return gpg_error (rc);
+  return gcry_error (rc);
 }
 
 /****************
@@ -1963,7 +1963,7 @@ gcry_pk_get_nbits (gcry_sexp_t key)
   gcry_pk_spec_t *pubkey;
   gcry_mpi_t *keyarr = NULL;
   unsigned int nbits = 0;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
 
   REGISTER_DEFAULT_PUBKEYS;
 
@@ -2107,10 +2107,10 @@ gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
 }
 
 
-gpg_error_t
+gcry_error_t
 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   REGISTER_DEFAULT_PUBKEYS;
 
@@ -2130,7 +2130,7 @@ gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
       err = GPG_ERR_INV_OP;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
 
@@ -2154,10 +2154,10 @@ gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
  * and thereby detecting whether a error occured or not (i.e. while checking
  * the block size)
  */
-gpg_error_t
+gcry_error_t
 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   switch (what)
     {
@@ -2224,23 +2224,23 @@ gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
       err = GPG_ERR_INV_OP;
     }
 
-  return gpg_error (err);
+  return gcry_error (err);
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_pk_init (void)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   return err;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
@@ -2270,10 +2270,10 @@ _gcry_pk_module_release (gcry_module_t module)
    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
    according size.  In case there are less pubkey modules than
    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
-gpg_error_t
+gcry_error_t
 gcry_pk_list (int *list, int *list_length)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   ath_mutex_lock (&pubkeys_registered_lock);
   err = _gcry_module_list (pubkeys_registered, list, list_length);
index 2105036..c463992 100644 (file)
@@ -281,10 +281,10 @@ get_random_bytes( size_t nbytes, int level, int secure )
 
    Note, that this fucntion currently does nothing.
 */
-gpg_error_t
+gcry_error_t
 gcry_random_add_bytes (const void * buf, size_t buflen, int quality)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   if (!buf || quality < -1 || quality > 100)
     err = GPG_ERR_INV_ARG;
index 1aa9e22..4e57d6b 100644 (file)
@@ -1710,7 +1710,7 @@ static const u32 rcon[30] = {
 
 /* Perform the key setup.
  */  
-static gpg_err_code_t
+static gcry_err_code_t
 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
 {
     static int initialized = 0;
@@ -1810,7 +1810,7 @@ do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
     return 0;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
 {
   RIJNDAEL_context *ctx = (RIJNDAEL_context *) context;
@@ -2131,20 +2131,38 @@ selftest (void)
 
 \f
 
+static const char *rijndael_names[] =
+  {
+    "RIJNDAEL",
+    NULL,
+  };
+
 gcry_cipher_spec_t cipher_spec_aes =
   {
-    "AES", 16, 128, sizeof (RIJNDAEL_context),
+    "AES", rijndael_names, 16, 128, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
 
+static const char *rijndael192_names[] =
+  {
+    "RIJNDAEL192",
+    NULL,
+  };
+
 gcry_cipher_spec_t cipher_spec_aes192 =
   {
-    "AES192", 16, 192, sizeof (RIJNDAEL_context),
+    "AES192", rijndael192_names, 16, 192, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
 
+static const char *rijndael256_names[] =
+  {
+    "RIJNDAEL256",
+    NULL,
+  };
+
 gcry_cipher_spec_t cipher_spec_aes256 =
   {
-    "AES256", 16, 256, sizeof (RIJNDAEL_context),
+    "AES256", rijndael256_names, 16, 256, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
index 1a5a8dc..bd110b9 100644 (file)
@@ -388,7 +388,7 @@ secret(gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
  **************  interface  ******************
  *********************************************/
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_generate (int algo, unsigned int nbits, unsigned long use_e,
                     gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
@@ -409,10 +409,10 @@ _gcry_rsa_generate (int algo, unsigned int nbits, unsigned long use_e,
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_check_secret_key( int algo, gcry_mpi_t *skey )
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   RSA_secret_key sk;
 
   sk.n = skey[0];
@@ -429,7 +429,7 @@ _gcry_rsa_check_secret_key( int algo, gcry_mpi_t *skey )
 }
 
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
                   int flags)
 {
@@ -484,7 +484,7 @@ _gcry_rsa_unblind (gcry_mpi_t x, gcry_mpi_t ri, gcry_mpi_t n)
   return y;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
                   int flags)
 {
@@ -559,7 +559,7 @@ _gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *s
   return GPG_ERR_NO_ERROR;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   RSA_secret_key sk;
@@ -576,14 +576,14 @@ _gcry_rsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
   return GPG_ERR_NO_ERROR;
 }
 
-gpg_err_code_t
+gcry_err_code_t
 _gcry_rsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
                  int (*cmp) (void *opaque, gcry_mpi_t tmp),
                  void *opaquev)
 {
   RSA_public_key pk;
   gcry_mpi_t result;
-  gpg_err_code_t rc;
+  gcry_err_code_t rc;
 
   pk.n = pkey[0];
   pk.e = pkey[1];
index ac70051..704c45c 100644 (file)
@@ -563,7 +563,7 @@ static byte calc_sb_tbl[512] = {
 /* Perform the key setup.  Note that this works only with 128- and 256-bit
  * keys, despite the API that looks like it might support other sizes. */
 
-static gpg_err_code_t
+static gcry_err_code_t
 do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
 {
     int i, j, k;
@@ -698,7 +698,7 @@ do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
     return 0;
 }
 
-static gpg_err_code_t
+static gcry_err_code_t
 twofish_setkey (void *context, const byte *key, unsigned int keylen)
 {
   TWOFISH_context *ctx = (TWOFISH_context *) context;
@@ -1021,12 +1021,12 @@ main()
 
 gcry_cipher_spec_t cipher_spec_twofish =
   {
-    "TWOFISH", 16, 256, sizeof (TWOFISH_context),
+    "TWOFISH", NULL, 16, 256, sizeof (TWOFISH_context),
     twofish_setkey, twofish_encrypt, twofish_decrypt,
   };
 
 gcry_cipher_spec_t cipher_spec_twofish128 =
   {
-    "TWOFISH128", 16, 128, sizeof (TWOFISH_context),
+    "TWOFISH128", NULL, 16, 128, sizeof (TWOFISH_context),
     twofish_setkey, twofish_encrypt, twofish_decrypt,
   };